feat: fix SelectQL to be used properly as a chainable methods

BREAKING CHANGE: it might break if older version might used

Author: Nadeem Ur-Rehman

src/SelectQL.ts

@@ -1,5 +1,5 @@
 
-import { SelectStatement, ISelector, Selector, ISelectBuilder, Operators } from './Selector'
+import { SelectStatement, ISelector, Selector, ISelectBuilder, Operators, whereClauseArray } from './Selector'
 import * as util from './utils'
 
 export class SelectQL implements ISelectBuilder {
@@ -15,107 +15,109 @@ export class SelectQL implements ISelectBuilder {
             this.selector = new Selector();
             if (util.checkArray(selectorInput)) {
                 this.isArray = true;
-                this.selectType = new ArraySelector(selectorInput);
-            } 
+                // this.selectType = new ArraySelector(selectorInput);
+            }
         } else {
             throw new Error('Provide array or object as an input to select');
         }
     }
 
-    where(whereClause: any): this {
-        return !util.isEmpty(whereClause) ? this.selectType.where(whereClause) : this;
-    }
-
-    concat(concatWith: any): this {
-        return !util.isEmpty(concatWith) ? this.selectType.concat(concatWith) : this;
-    }
-
-    and(andOption: any): this {
-        return !util.isEmpty(andOption) ? this.selectType.where(andOption) : this;
-    }
-
-    uniqueByKey(key: string): this {
-        return !util.isEmpty(key) ? this.selectType.uniqueByKey(key) : this;
-    }
-
-    build(): Selector {
-        return this.selector;
-    }
-
-}
-
-
-class ArraySelector implements ISelector {
-    selectorArray: any;
-    constructor(select: any) {
-        this.selectorArray = select;
-    }
 
     /**
-     * Like a map to iterate and pick an item by key
-     * @param whereClause any type
-     * @returns this
+     * Like a map to iterate and pick an item by key and conditionally change array like object
+     * @param expressionKey string or any key
+     * @param expressionOperator Operator type operator
+     * @param expressionValue  string or any value
+     * @returns extracted array like object
      */
-    where(key: any, operator: Operators, value: any, notOption?: boolean): this {
-        let returned = this.selectorArray;
+    where(expressionKey: any, expressionOperator: Operators, expressionValue: any) {
+        let returned = this.selectType;
 
-        if (operator == Operators.EQUAL) {
+        // checks if any of the where clause is key/operator or value is empty
+        if (util.isEmpty(expressionKey) || util.isEmpty(expressionOperator) || util.isEmpty(expressionValue)) {
+            throw new Error ('WHERE expression not provided correctly!');
+        }
+        
+        if (expressionOperator == Operators.EQUAL) {
             // Returned only one item where condition met
-            returned = this.selectorArray.splice(this.selectorArray.findIndex((o) => {
-                return o[key] == value;
+            returned = this.selectType.splice(this.selectType.findIndex((o) => {
+                return o[expressionKey] == expressionValue;
             }), 1);
-        } else if (operator == Operators.NOT_EQUAL) {
+        } else if (expressionOperator == Operators.NOT_EQUAL) {
             // Remove all element except the key mentioned
-            returned = this.selectorArray.filter(o => o[key] !== value);
-        } else if (operator == Operators.GREATER_THAN) {
-            returned = this.selectorArray.filter(o => o[key] > value);
-        } else if (operator == Operators.GREATER_EQUAL) {
-            returned = this.selectorArray.filter(o => o[key] >= value);
-        } else if (operator == Operators.LESS_THEN) {
-            returned = this.selectorArray.filter(o => o[key] < value);
-        } else if (operator == Operators.LESS_THEN_EQUAL) {
-            returned = this.selectorArray.filter(o => o[key] <= value);
+            returned = this.selectType.filter(o => o[expressionKey] !== expressionValue);
+        } else if (expressionOperator == Operators.GREATER_THAN) {
+            returned = this.selectType.filter(o => o[expressionKey] > expressionValue);
+        } else if (expressionOperator == Operators.GREATER_EQUAL) {
+            returned = this.selectType.filter(o => o[expressionKey] >= expressionValue);
+        } else if (expressionOperator == Operators.LESS_THEN) {
+            returned = this.selectType.filter(o => o[expressionKey] < expressionValue);
+        } else if (expressionOperator == Operators.LESS_THEN_EQUAL) {
+            returned = this.selectType.filter(o => o[expressionKey] <= expressionValue);
         }
 
         if (returned) {
             // console.log(returned, 'retu');
             return returned
         } else {
-            throw 'No Key found!';
+            throw new Error('No correct WHERE expression found!');
         }
     }
 
-    /**
+     /**
      * Creates a new array concatenating array with any additional arrays and/or values.
      * @param concatWith array or value
      * @returns this
      */
-    concat(concatWith: any): this {
-        return this.selectorArray.concat(concatWith);
+
+    join(concatWith: any): this {
+        return !util.isEmpty(concatWith) ? this.selectType.concat(concatWith) : this;
     }
 
     /**
-     * option to filter by another predicate
-     * @param andOption any
-     * return this
+     * another predicate which eventually calls where
+     * @param expressionKey string or any key
+     * @param expressionOperator Operator type operator
+     * @param expressionValue  string or any value
+     * @returns extracted array like object
      */
-    and(key: any, operator: Operators, value: any): this {
-        return this.where(key, operator, value);
+    and(expressionKey: any, expressionOperator: Operators, expressionValue: any) {
+        return this.where(expressionKey, expressionOperator, expressionValue);
     }
 
-    /**
+   /**
      * Creates an array of unique values, taking an iteratee to compute uniqueness with the provided key
      * @param key string
      * @returns 
      */
     uniqueByKey(key: string): this {
         let uniquArr: any = [];
-        this.selectorArray.forEach((value, index) => {
+        this.selectType.forEach((value, index) => {
             if (uniquArr.indexOf(value[key]) === -1) {
                 uniquArr.push(value);
 
             }
         });
         return uniquArr;
     }
+
+    /**
+     * if no condition met or null then client can return it's own input/object
+     * @param input 
+     * @returns client's provided input.
+     */
+    orElse(input: any) {
+        if (!util.isEmpty(input)) {
+            return input;
+        }
+    }
+
+    /**
+     * builder function 
+     * @returns final object.
+     */
+    build(): Selector {
+        return this.selector;
+    }
+
 }

src/Selector.ts

@@ -1,17 +1,22 @@
 
 export interface SelectStatement {
         where: any,
-        concat: any,
+        join: any,
         and: any,
         uniqueByKey: any
 }
 
 export interface ISelector {
-        where(key: any, operator: Operators, value: any, notOption?: boolean): this
-        concat(concatWith: any): this
+        where(key: any, operator: Operators, value: any): this
+        join(concatWith: any): this
         and(key: any, operator: Operators, value: any): this
         uniqueByKey(key: string): this
 }
+export interface whereClauseArray {
+        key: any;
+        operator: Operators;
+        value: any;
+}
 
 export interface ISelectBuilder extends ISelector {
         build(): Selector
@@ -22,8 +27,8 @@ export class Selector {
 }
 
 export enum Operators {
-        EQUAL = '==',
-        NOT_EQUAL = '!==',
+        EQUAL = '=',
+        NOT_EQUAL = '!=',
         GREATER_THAN = '>',
         GREATER_EQUAL = '>=',
         LESS_THEN = '<',