Adding new operator dateBetween

Author: ppiyush13

package-lock.json

@@ -27,7 +27,9 @@
   "license": "MIT",
   "dependencies": {
     "arrify": "^2.0.1",
+    "date-format": "^3.0.0",
     "identity-function": "^1.0.0",
+    "is-date-object": "^1.0.1",
     "is-function": "^1.0.1",
     "is-number": "^7.0.0",
     "is-string": "^1.0.4",

package.json

@@ -55,7 +55,15 @@ const query = select({
                     value: 10,
                 }
             ]
-        }
+        },
+        {
+            operator: 'dateBetween',
+            field: 'BIRTH',
+            value: {
+                start: new Date(1975, 0, 1),
+                end: new Date(1999, 11, 31),
+            }
+        },
     ],
     groupBy: ['A', 'B', 'C'],
     orderBy: ['A'],
@@ -70,7 +78,8 @@ console.log(query);
 Will output:
 
 SELECT A, B, count(D) AS CNT FROM STUDENTS
-WHERE NAME = 'Piyush' AND ROLL = 13 AND (A = 5 OR A = 10)
+WHERE NAME = 'Piyush' AND ROLL = 13 AND (A = 5 OR A = 10) AND 
+BIRTH BETWEEN '1975-01-01' AND '1999-12-31'
 GROUP BY A, B, C
 ORDER BY A
 EXTERNAL NAME 'TestFuncs$MyMath.pow'

readme.md

@@ -7,6 +7,7 @@ import templates from './template/templates'
 import templateUtil from './template/util';
 import {arrayJoinMap} from './arrayUtils';
 import {wrapInSpace, wrapeInSpacedBrackets} from './stringUtils';
+import dateValue from './dateValue';
 
 const builder = {
     build(where) {
@@ -57,7 +58,7 @@ const builder = {
         }
         const createBetweenCfg = (start, end) => {
             return {
-                field: config.field,
+                ...config,
                 start, end,
             };
         }
@@ -77,6 +78,13 @@ const builder = {
         return templateUtil.applyTemplate(templates.between, transformedConfigs, isNot);
     },
 
+    dateBetween(config, isNot) {
+        const toDate = dateValue(config.format || 'yyyy-MM-dd');
+        const mapFn = item => quotifyValue(toDate(item));
+        const transformedConfigs = mapObjValues(this.transformBetweenConfig(config), mapFn, ['start', 'end']);
+        return templateUtil.applyTemplate(templates.between, transformedConfigs, isNot);
+    },
+
     equal: templateUtil.composeOperatorForTemplate(templates.equal.bind(templates)),
     like: templateUtil.composeOperatorForTemplate(templates.like),
     greaterThan: templateUtil.composeRelationalOperator('>'),

src/buildWhereClause.js

@@ -0,0 +1,9 @@
+import isDate from 'is-date-object';
+import dateFormat from 'date-format';
+
+export default format => value => {
+    if(isDate(value))
+        return dateFormat(format, value);
+    else
+        return value;
+}

src/dateValue.js

@@ -11,6 +11,10 @@ const aliasConfigs = {
         alias: 'range',
         generateNotEquivalent: true,
     },
+    dateBetween: {
+        alias: 'dateRange',
+        generateNotEquivalent: true,
+    },
     like: {
         // no alias and no operator
         generateNotEquivalent: true,

src/funtionAliasMap.js

@@ -239,11 +239,26 @@ describe('testing buildWhereClause module', () => {
                 )
             `
         ],
+        [
+            [
+                {
+                    operator: 'dateBetween',
+                    field: 'birth',
+                    value: {
+                        start: new Date(1975, 0, 1),
+                        end: new Date(1999, 11, 31),
+                    }
+                }
+            ],
+            `
+                birth BETWEEN '1975-01-01' AND '1999-12-31'
+            `
+        ],
     ])('testing with each utility', (received, expected) => {
         expect(buildWhereClause.build(received)).toBeSimilarWith(expected);
     });
 
-    it('nesgative testing blocks', () => {
+    it('negative testing blocks', () => {
         const configObj = {
             operator: 'and',
         };
@@ -296,4 +311,76 @@ describe('testing buildWhereClause module', () => {
     ])('testing between module', (received, expected) => {
         expect(buildWhereClause.between(received)).toBeSimilarWith(expected);
     });
+
+    it.each([
+        [
+            {
+                field: 'A',
+                start: new Date(2019, 10, 15),
+                end: new Date(2019, 10, 30)
+            },
+            `
+                A BETWEEN '2019-11-15' AND '2019-11-30' 
+            `
+        ],
+        [
+            {
+                field: 'A',
+                value: {
+                    start: new Date(2019, 10, 15),
+                    end: new Date(2019, 10, 30),
+                }
+            },
+            `
+                A BETWEEN '2019-11-15' AND '2019-11-30' 
+            `
+        ],
+        
+        [
+            {
+                field: 'A',
+                value: [ new Date(2019, 10, 15), new Date(2019, 10, 30) ]
+            },
+            `
+                A BETWEEN '2019-11-15' AND '2019-11-30' 
+            `
+        ],
+        [
+            {
+                field: 'A',
+                start: new Date(2019, 10, 15),
+                end: new Date(2019, 10, 30),
+                format: 'MM-yyyy-dd',
+            },
+            `
+                A BETWEEN '11-2019-15' AND '11-2019-30' 
+            `
+        ],
+        [
+            {
+                field: 'A',
+                format: 'MM-yyyy-dd',
+                value: {
+                    start: new Date(2019, 10, 15),
+                    end: new Date(2019, 10, 30),
+                }
+            },
+            `
+                A BETWEEN '11-2019-15' AND '11-2019-30' 
+            `
+        ],
+        
+        [
+            {
+                field: 'A',
+                format: 'MM-yyyy-dd',
+                value: [ new Date(2019, 10, 15), new Date(2019, 10, 30) ]
+            },
+            `
+                A BETWEEN '11-2019-15' AND '11-2019-30' 
+            `
+        ],
+    ])('Testing DateBetween operator', (received, expected) => {
+        expect(buildWhereClause.dateBetween(received)).toBeSimilarWith(expected);
+    });
 });

src/test/buildWhereClause.test.js

@@ -6,6 +6,7 @@ describe('testing functionAliasMap module', () => {
             equal: [ 'in', 'eq', 'is', 'equal', '=' ],
             notequal: [ 'notin', 'noteq', 'notis', 'notequal', '!=', '<>' ],
             between: [ 'range', 'between' ],
+            dateBetween: ['dateRange', 'dateBetween'],
             notbetween: [ 'notrange', 'notbetween' ],
             like: ['like'],
             notlike: ['notlike'],