@qrvey/formula-lang 0.1.3 → 0.2.0

package/CHANGELOG.md

@@ -1,3 +1,30 @@
+<a name="0.2.0"></a>
+# [0.2.0](https://bitbucket.org/qrvey/qrvey_formula_lang/compare/v0.1.3...v0.2.0) (2023-04-21)
+
+
+### Bug Fixes
+
+* **iffunction:** return False keyword for each lenguage in value if false case ([34a0160](https://bitbucket.org/qrvey/qrvey_formula_lang/commits/34a0160))
+
+
+### Features
+
+* **argumentvalidation:** add arguments validation function RB-1072 ([4e5e3fc](https://bitbucket.org/qrvey/qrvey_formula_lang/commits/4e5e3fc))
+* **datedif:** add DATEDIF function ([1354f1d](https://bitbucket.org/qrvey/qrvey_formula_lang/commits/1354f1d))
+* **datedif:** dateDif function finish ([5089728](https://bitbucket.org/qrvey/qrvey_formula_lang/commits/5089728))
+* **day:** add DAY function ([6553dae](https://bitbucket.org/qrvey/qrvey_formula_lang/commits/6553dae))
+* **errordefinition:** add and improve error defintions (TooManyArguments and InvalidArgument) ([22c9b8b](https://bitbucket.org/qrvey/qrvey_formula_lang/commits/22c9b8b))
+* **errordefinition:** add error definition for Unknow and missing arguments errors ([7054f55](https://bitbucket.org/qrvey/qrvey_formula_lang/commits/7054f55))
+* **function:** add Month, Year, Hour, Minute, Second ([e14ff0a](https://bitbucket.org/qrvey/qrvey_formula_lang/commits/e14ff0a))
+* **functions:** add ABS function and refactor folder structure of tests ([5f82ce2](https://bitbucket.org/qrvey/qrvey_formula_lang/commits/5f82ce2))
+* **functions:** add IF funciton along intgration test in elasticsearch ([c18af49](https://bitbucket.org/qrvey/qrvey_formula_lang/commits/c18af49))
+* **ifsfunction:** add IFS support for elasticsearch ([ddc9da9](https://bitbucket.org/qrvey/qrvey_formula_lang/commits/ddc9da9))
+* **ifsfunction:** add redshift and snowflake transpilation ([731cf94](https://bitbucket.org/qrvey/qrvey_formula_lang/commits/731cf94))
+* **json-parser.ts:** date parser with tests ([2e20873](https://bitbucket.org/qrvey/qrvey_formula_lang/commits/2e20873))
+* **syntax.grammar:** date grammar definition ([ccea58f](https://bitbucket.org/qrvey/qrvey_formula_lang/commits/ccea58f))
+
+
+
 <a name="0.1.3"></a>
 ## [0.1.3](https://bitbucket.org/qrvey/qrvey_formula_lang/compare/v0.1.2...v0.1.3) (2023-04-16)
 

package/__tests__/integration/__mocks__/elasticsearchScripts.ts

@@ -0,0 +1,21 @@
+export const dateFormatScript = `String DATE_FORMAT_SCRIPT(def date_value, String format) {
+    def isCustomDate = (date_value instanceof JodaCompatibleZonedDateTime || date_value instanceof ZonedDateTime);
+    if (date_value instanceof List && !isCustomDate) {
+        if (date_value.empty) return null;
+        date_value = date_value.value;
+    }
+    return DateTimeFormatter.ofPattern(format).format(date_value)
+}`;
+
+export function dateFormatToInt(format: string): string {
+    return `Integer.parseInt(DATE_FORMAT_SCRIPT(ZonedDateTime.parse("2023-12-31T00:00:00.000Z"), '${format}'))`;
+}
+
+export function dateParser(format: string): string {
+    const dateToInt = dateFormatToInt(format);
+    return `${dateFormatScript}\n${dateToInt}`;
+}
+
+export function dateDif(format: string) {
+    return `ChronoUnit.${format}.between(ZonedDateTime.parse("2023-12-31T00:00:00.000Z"), ZonedDateTime.parse("2022-12-31T00:00:00.000Z"))`;
+}

package/__tests__/integration/__mocks__/sqlScripts.ts

@@ -0,0 +1,20 @@
+export function datePart(part: string) {
+    return `DATE_PART('${part}', CAST('2023-12-31T00:00:00.000Z' AS TIMESTAMPTZ))`;
+}
+
+export function dateDif(unit: string): string {
+    switch (unit) {
+        case 'day':
+        case 'month':
+            return `DATEDIFF('${unit}', CAST('2023-12-31T00:00:00.000Z' AS TIMESTAMPTZ), CAST('2022-12-31T00:00:00.000Z' AS TIMESTAMPTZ))`;
+        case 'year':
+            return `CASE
+        WHEN DATEDIFF('day', CAST('2023-12-31T00:00:00.000Z' AS TIMESTAMPTZ), CAST('DATE_PART('CAST('2023-12-31T00:00:00.000Z' AS TIMESTAMPTZ)', year)|| '-' ||DATE_PART('CAST('2022-12-31T00:00:00.000Z' AS TIMESTAMPTZ)', month)|| '-' ||DATE_PART('CAST('2022-12-31T00:00:00.000Z' AS TIMESTAMPTZ)', day)' AS TIMESTAMPTZ)) >= 0
+            THEN DATEDIFF('${unit}', CAST('2023-12-31T00:00:00.000Z' AS TIMESTAMPTZ), CAST('2022-12-31T00:00:00.000Z' AS TIMESTAMPTZ))
+        ELSE DATEDIFF('${unit}', CAST('2023-12-31T00:00:00.000Z' AS TIMESTAMPTZ), CAST('2022-12-31T00:00:00.000Z' AS TIMESTAMPTZ)) - 1
+    END`; //Indentation care, be careful
+
+        default:
+            return '';
+    }
+}

package/__tests__/integration/elasticsearch.test.ts

@@ -0,0 +1,158 @@
+import { ENGINES, Transpile } from '../../src';
+import {
+    dateDif,
+    dateParser,
+    dateFormatToInt,
+    dateFormatScript,
+} from './__mocks__/elasticsearchScripts';
+const currentEngine = ENGINES.ELASTICSEARCH;
+
+describe('ELASTICSEARCH Transpile program', () => {
+    test('Basic case', () => {
+        const result = Transpile('1 + 2', currentEngine);
+        expect(result?.expression).toBe('(1 + 2)');
+    });
+
+    test('MID function', () => {
+        const result = Transpile('MID("test", 1, 5)', currentEngine);
+        expect(result?.expression).toBe(`'test'.substring(1, 5)`);
+    });
+
+    test('Should transpile a function inside another function', () => {
+        const program = 'MID(MID("This is a test", 1, 5), 1, 2)';
+        const result = Transpile(program, currentEngine);
+        expect(result?.valid).toBe(true);
+        expect(result?.expression).toBe(
+            "'This is a test'.substring(1, 5).substring(1, 2)",
+        );
+    });
+
+    test('ABS function', () => {
+        const result = Transpile('ABS(5)', currentEngine);
+        expect(result?.expression).toBe(`Math.abs(5)`);
+    });
+
+    test('DAY function', () => {
+        const result = Transpile('DAY("12/31/2023")', currentEngine);
+        const mock = dateParser('dd').replace(/\n/g, '');
+        expect(result?.expression?.replace(/\n/g, '')).toBe(mock);
+    });
+
+    test('Two DAY function', () => {
+        const result = Transpile(
+            'DAY("12/31/2023") + DAY("12/31/2023")',
+            currentEngine,
+        );
+        const concat = `${dateFormatScript}\n(${dateFormatToInt(
+            'dd',
+        )} + ${dateFormatToInt('dd')})`;
+        const mock = concat.replace(/\n/g, '');
+        expect(result?.expression?.replace(/\n/g, '')).toBe(mock);
+    });
+
+    test('MONTH function', () => {
+        const result = Transpile('MONTH("12/31/2023")', currentEngine);
+        const mock = dateParser('MM').replace(/\n/g, '');
+        expect(result?.expression?.replace(/\n/g, '')).toBe(mock);
+    });
+
+    test('One DAY plus One Month function', () => {
+        const result = Transpile(
+            'DAY("12/31/2023") + MONTH("12/31/2023")',
+            currentEngine,
+        );
+        const concat = `${dateFormatScript}\n(${dateFormatToInt(
+            'dd',
+        )} + ${dateFormatToInt('MM')})`;
+        const mock = concat.replace(/\n/g, '');
+        expect(result?.expression?.replace(/\n/g, '')).toBe(mock);
+    });
+
+    test('YEAR function', () => {
+        const result = Transpile('YEAR("12/31/2023")', currentEngine);
+        const mock = dateParser('yyyy').replace(/\n/g, '');
+        expect(result?.expression?.replace(/\n/g, '')).toBe(mock);
+    });
+
+    test('HOUR function', () => {
+        const result = Transpile('HOUR("12/31/2023")', currentEngine);
+        const mock = dateParser('HH').replace(/\n/g, '');
+        expect(result?.expression?.replace(/\n/g, '')).toBe(mock);
+    });
+
+    test('MINUTE function', () => {
+        const result = Transpile('MINUTE("12/31/2023")', currentEngine);
+        const mock = dateParser('mm').replace(/\n/g, '');
+        expect(result?.expression?.replace(/\n/g, '')).toBe(mock);
+    });
+
+    test('SECOND function', () => {
+        const result = Transpile('SECOND("12/31/2023")', currentEngine);
+        const mock = dateParser('ss').replace(/\n/g, '');
+        expect(result?.expression?.replace(/\n/g, '')).toBe(mock);
+    });
+
+    test('DATEDIF function with Y unit', () => {
+        const result = Transpile(
+            'DATEDIF("12/31/2023", "12/31/2022", "Y")',
+            currentEngine,
+        );
+        const mock = dateDif('YEARS');
+        expect(result?.expression).toBe(mock);
+    });
+
+    test('DATEDIF function with M unit', () => {
+        const result = Transpile(
+            'DATEDIF("12/31/2023", "12/31/2022", "M")',
+            currentEngine,
+        );
+        const mock = dateDif('MONTHS');
+        expect(result?.expression).toBe(mock);
+    });
+
+    test('DATEDIF function with D unit', () => {
+        const result = Transpile(
+            'DATEDIF("12/31/2023", "12/31/2022", "D")',
+            currentEngine,
+        );
+        const mock = dateDif('DAYS');
+        expect(result?.expression).toBe(mock);
+    });
+
+    test('DATEDIF function with a not valid Unit', () => {
+        const result = Transpile(
+            'DATEDIF("12/31/2023", "12/31/2022", "X")',
+            currentEngine,
+        );
+        expect(result).not.toBeUndefined();
+        expect(result?.valid).toBe(false);
+        expect(result?.error).not.toBeUndefined();
+        expect(result?.error?.code).toBe('DATE_DIF_UNIT_PARAM');
+    });
+
+    test('IF function full parameters', () => {
+        const result = Transpile('IF(5 = 1, "True", "False")', currentEngine);
+        expect(result).not.toBeUndefined();
+        expect(result?.error).toBeUndefined();
+        expect(result?.expression).toBe(`((5 == 1) ? 'True' : 'False')`);
+    });
+
+    test('IF function basic parameters', () => {
+        const result = Transpile('IF(5 = 1, "True")', currentEngine);
+        expect(result).not.toBeUndefined();
+        expect(result?.error).toBeUndefined();
+        expect(result?.expression).toBe(`((5 == 1) ? 'True' : false)`);
+    });
+
+    test('IFS function basic parameters', () => {
+        const result = Transpile(
+            'IFS(5>10, "Greater than 10", 5>5, "Greater than 5",5>0, "Greater than 0")',
+            currentEngine,
+        );
+        expect(result).not.toBeUndefined();
+        expect(result?.error).toBeUndefined();
+        expect(result?.expression).toBe(
+            `((5 > 10) ? 'Greater than 10' : ((5 > 5) ? 'Greater than 5' : ((5 > 0) ? 'Greater than 0' : null)))`,
+        );
+    });
+});

package/__tests__/integration/expression.test.ts

@@ -0,0 +1,22 @@
+import { ENGINES, Transpile } from '../../src';
+import { MissingArgumentError } from '../../src/errors';
+
+describe('Raw Expression test suite', () => {
+    test('should transpile a logical operator', () => {
+        const program = '1 < 2';
+        const result = Transpile(program, ENGINES.ELASTICSEARCH);
+        expect(result?.valid).toBe(true);
+        expect(result?.expression).toBe('(1 < 2)');
+    });
+
+    test('IFS function should not work (invalid parameters)', () => {
+        const result = Transpile(
+            'IFS(5>10, "Greater than 10", 5>5, "Greater than 5",5>0)',
+            ENGINES.ELASTICSEARCH,
+        );
+        expect(result).not.toBeUndefined();
+        expect(result?.valid).toBe(false);
+        expect(result?.error).not.toBeUndefined();
+        expect(result?.error instanceof MissingArgumentError).toBeTruthy();
+    });
+});

package/__tests__/integration/redshift.test.ts

@@ -0,0 +1,127 @@
+import { ENGINES, Transpile } from '../../src';
+import { datePart, dateDif } from './__mocks__/sqlScripts';
+const currentEngine = ENGINES.REDSHIFT;
+
+describe('SNOWFLAKE Transpile program', () => {
+    test('Basic case', () => {
+        const result = Transpile('1 + 2', currentEngine);
+        expect(result?.expression).toBe('(1 + 2)');
+    });
+
+    test('MID function', () => {
+        const result = Transpile('MID("test", 1, 5)', currentEngine);
+        expect(result?.expression).toBe(`SUBSTRING('test', 1, 5)`);
+    });
+
+    test('Should transpile a function inside another function', () => {
+        const program = 'MID(MID("This is a test", 1, 5), 1, 2)';
+        const result = Transpile(program, currentEngine);
+        expect(result?.valid).toBe(true);
+        expect(result?.expression).toBe(
+            "SUBSTRING(SUBSTRING('This is a test', 1, 5), 1, 2)",
+        );
+    });
+
+    test('ABS function', () => {
+        const result = Transpile('ABS(5)', currentEngine);
+        expect(result?.expression).toBe(`ABS(5)`);
+    });
+
+    test('DAY function', () => {
+        const result = Transpile('DAY("12/31/2023")', currentEngine);
+        expect(result?.expression).toBe(datePart('day'));
+    });
+
+    test('MONTH function', () => {
+        const result = Transpile('MONTH("12/31/2023")', currentEngine);
+        expect(result?.expression).toBe(datePart('month'));
+    });
+
+    test('YEAR function', () => {
+        const result = Transpile('YEAR("12/31/2023")', currentEngine);
+        expect(result?.expression).toBe(datePart('year'));
+    });
+
+    test('HOUR function', () => {
+        const result = Transpile('HOUR("12/31/2023")', currentEngine);
+        expect(result?.expression).toBe(datePart('hour'));
+    });
+
+    test('MINUTE function', () => {
+        const result = Transpile('MINUTE("12/31/2023")', currentEngine);
+        expect(result?.expression).toBe(datePart('minute'));
+    });
+
+    test('SECOND function', () => {
+        const result = Transpile('SECOND("12/31/2023")', currentEngine);
+        expect(result?.expression).toBe(datePart('second'));
+    });
+
+    test('DATEDIF function with Y unit', () => {
+        const result = Transpile(
+            'DATEDIF("12/31/2023", "12/31/2022", "Y")',
+            currentEngine,
+        );
+        const mock = dateDif('year');
+        expect(result?.expression).toBe(mock);
+    });
+
+    test('DATEDIF function with M unit', () => {
+        const result = Transpile(
+            'DATEDIF("12/31/2023", "12/31/2022", "M")',
+            currentEngine,
+        );
+        const mock = dateDif('month');
+        expect(result?.expression).toBe(mock);
+    });
+
+    test('DATEDIF function with D unit', () => {
+        const result = Transpile(
+            'DATEDIF("12/31/2023", "12/31/2022", "D")',
+            currentEngine,
+        );
+        const mock = dateDif('day');
+        expect(result?.expression).toBe(mock);
+    });
+
+    test('DATEDIF function with a not valid Unit', () => {
+        const result = Transpile(
+            'DATEDIF("12/31/2023", "12/31/2022", "X")',
+            currentEngine,
+        );
+        expect(result).not.toBeUndefined();
+        expect(result?.valid).toBe(false);
+        expect(result?.error).not.toBeUndefined();
+        expect(result?.error?.code).toBe('DATE_DIF_UNIT_PARAM');
+    });
+
+    test('IF function full parameters', () => {
+        const result = Transpile('IF(5 = 1, "True", "False")', currentEngine);
+        expect(result).not.toBeUndefined();
+        expect(result?.error).toBeUndefined();
+        expect(result?.expression?.replace(/\n/g, '')).toBe(
+            `(CASE    WHEN (5 = 1) THEN 'True'    ELSE 'False'END)`,
+        );
+    });
+
+    test('IF function basic parameters', () => {
+        const result = Transpile('IF(5 = 1, "True")', currentEngine);
+        expect(result).not.toBeUndefined();
+        expect(result?.error).toBeUndefined();
+        expect(result?.expression?.replace(/\n/g, '')).toBe(
+            `(CASE    WHEN (5 = 1) THEN 'True'    ELSE FALSEEND)`,
+        );
+    });
+
+    test('IFS function basic parameters', () => {
+        const result = Transpile(
+            'IFS(5>10, "Greater than 10", 5>5, "Greater than 5",5>0, "Greater than 0")',
+            currentEngine,
+        );
+        expect(result).not.toBeUndefined();
+        expect(result?.error).toBeUndefined();
+        expect(result?.expression?.replace(/\n/g, '')).toBe(
+            `(CASE            WHEN (5 > 10) THEN 'Greater than 10'            ELSE (CASE            WHEN (5 > 5) THEN 'Greater than 5'            ELSE (CASE            WHEN (5 > 0) THEN 'Greater than 0'            ELSE NULL        END)        END)        END)`,
+        );
+    });
+});

package/__tests__/integration/sonwflake.test.ts

@@ -0,0 +1,123 @@
+import { ENGINES, Transpile } from '../../src';
+import { datePart, dateDif } from './__mocks__/sqlScripts';
+const currentEngine = ENGINES.SNOWFLAKE;
+
+describe('SNOWFLAKE Transpile program', () => {
+    test('Basic case', () => {
+        const result = Transpile('1 + 2', currentEngine);
+        expect(result?.expression).toBe('(1 + 2)');
+    });
+
+    test('MID function', () => {
+        const result = Transpile('MID("test", 1, 5)', currentEngine);
+        expect(result?.expression).toBe(`SUBSTRING('test', 1, 5)`);
+    });
+
+    test('Should transpile a function inside another function', () => {
+        const program = 'MID(MID("This is a test", 1, 5), 1, 2)';
+        const result = Transpile(program, currentEngine);
+        expect(result?.valid).toBe(true);
+        expect(result?.expression).toBe(
+            "SUBSTRING(SUBSTRING('This is a test', 1, 5), 1, 2)",
+        );
+    });
+
+    test('ABS function', () => {
+        const result = Transpile('ABS(5)', currentEngine);
+        expect(result?.expression).toBe(`ABS(5)`);
+    });
+
+    test('DAY function', () => {
+        const result = Transpile('DAY("12/31/2023")', currentEngine);
+        expect(result?.expression).toBe(datePart('day'));
+    });
+
+    test('MONTH function', () => {
+        const result = Transpile('MONTH("12/31/2023")', currentEngine);
+        expect(result?.expression).toBe(datePart('month'));
+    });
+
+    test('YEAR function', () => {
+        const result = Transpile('YEAR("12/31/2023")', currentEngine);
+        expect(result?.expression).toBe(datePart('year'));
+    });
+
+    test('HOUR function', () => {
+        const result = Transpile('HOUR("12/31/2023")', currentEngine);
+        expect(result?.expression).toBe(datePart('hour'));
+    });
+
+    test('MINUTE function', () => {
+        const result = Transpile('MINUTE("12/31/2023")', currentEngine);
+        expect(result?.expression).toBe(datePart('minute'));
+    });
+
+    test('SECOND function', () => {
+        const result = Transpile('SECOND("12/31/2023")', currentEngine);
+        expect(result?.expression).toBe(datePart('second'));
+    });
+
+    test('DATEDIF function with Y unit', () => {
+        const result = Transpile(
+            'DATEDIF("12/31/2023", "12/31/2022", "Y")',
+            currentEngine,
+        );
+        const mock = dateDif('year');
+        expect(result?.expression).toBe(mock);
+    });
+
+    test('DATEDIF function with M unit', () => {
+        const result = Transpile(
+            'DATEDIF("12/31/2023", "12/31/2022", "M")',
+            currentEngine,
+        );
+        const mock = dateDif('month');
+        expect(result?.expression).toBe(mock);
+    });
+
+    test('DATEDIF function with D unit', () => {
+        const result = Transpile(
+            'DATEDIF("12/31/2023", "12/31/2022", "D")',
+            currentEngine,
+        );
+        const mock = dateDif('day');
+        expect(result?.expression).toBe(mock);
+    });
+
+    test('DATEDIF function with a not valid Unit', () => {
+        const result = Transpile(
+            'DATEDIF("12/31/2023", "12/31/2022", "X")',
+            currentEngine,
+        );
+        expect(result).not.toBeUndefined();
+        expect(result?.valid).toBe(false);
+        expect(result?.error).not.toBeUndefined();
+        expect(result?.error?.code).toBe('DATE_DIF_UNIT_PARAM');
+    });
+
+    test('IF function full parameters', () => {
+        const result = Transpile('IF(5 = 1, "True", "False")', currentEngine);
+        expect(result).not.toBeUndefined();
+        expect(result?.error).toBeUndefined();
+        expect(result?.expression).toBe(`IFF((5 = 1), 'True', 'False')`);
+    });
+
+    test('IF function basic parameters', () => {
+        const result = Transpile('IF(5 = 1, "True")', currentEngine);
+        expect(result).not.toBeUndefined();
+        expect(result?.error).toBeUndefined();
+        expect(result?.expression).toBe(`IFF((5 = 1), 'True', FALSE)`);
+    });
+
+    test('IFS function basic parameters', () => {
+        const result = Transpile(
+            'IFS(5>10, "Greater than 10", 5>5, "Greater than 5",5>0, "Greater than 0")',
+            currentEngine,
+        );
+        expect(result).not.toBeUndefined();
+        expect(result?.error).toBeUndefined();
+        expect(result?.expression).toBe(
+            `IFF((5 > 10), 'Greater than 10', IFF((5 > 5), 'Greater than 5', IFF((5 > 0), 'Greater than 0', NULL)))`,
+        );
+    });
+});

package/__tests__/unit/parser.test.ts

@@ -0,0 +1,106 @@
+import { AST_TYPES } from '../../src/constants';
+import { calculateAST, FormulaLang } from '../../src';
+import {
+    BinaryExpressionAST,
+    LiteralAST,
+} from '../../src/constants/interfaces';
+
+describe('Parser tests suite', () => {
+    test('Should parse a single node', () => {
+        const program = '1 + 2';
+        const parser = FormulaLang.parser;
+        const { topNode } = parser.parse(program);
+        const ast = calculateAST(program, topNode);
+        expect(ast?.body).not.toBeUndefined();
+
+        const body = ast?.body as BinaryExpressionAST;
+        expect(body.operator).toBe('+');
+        expect(body.type).toBe(AST_TYPES.binaryExpression);
+    });
+
+    test('Should fail a logic operation', () => {
+        const program = '1 <';
+        const parser = FormulaLang.parser;
+        const { topNode } = parser.parse(program);
+        const ast = calculateAST(program, topNode);
+        expect(ast?.body).not.toBeUndefined();
+
+        const body = ast?.body as BinaryExpressionAST;
+        expect(body.operator).toBe('<');
+        expect(body.type).toBe(AST_TYPES.binaryExpression);
+    });
+
+    describe('Date literals', () => {
+        test('Should fail with a date without time', () => {
+            const program = '"31/12/2022"';
+            const parser = FormulaLang.parser;
+            const { topNode } = parser.parse(program);
+            const ast = calculateAST(program, topNode);
+            expect(ast?.body).not.toBeUndefined();
+
+            const body = ast?.body as LiteralAST;
+            expect(body.value).toEqual('31/12/2022');
+            expect(body.dataType).toBe('string');
+        });
+
+        test('Should return a date without time', () => {
+            const program = '"12/31/2022"';
+            const parser = FormulaLang.parser;
+            const { topNode } = parser.parse(program);
+            const ast = calculateAST(program, topNode);
+            expect(ast?.body).not.toBeUndefined();
+
+            const body = ast?.body as LiteralAST;
+            expect(body.value).toEqual('2022-12-31T00:00:00.000Z');
+            expect(body.dataType).toBe('date');
+        });
+
+        test('Should return a date with time', () => {
+            const program = '"12/31/2022 15:22:18"';
+            const parser = FormulaLang.parser;
+            const { topNode } = parser.parse(program);
+            const ast = calculateAST(program, topNode);
+            expect(ast?.body).not.toBeUndefined();
+
+            const body = ast?.body as LiteralAST;
+            expect(body.value).toEqual('2022-12-31T15:22:18.000Z');
+            expect(body.dataType).toBe('date');
+        });
+
+        test('Should return a date with invalid time', () => {
+            const program = '"12/31/2022 15:89:18"';
+            const parser = FormulaLang.parser;
+            const { topNode } = parser.parse(program);
+            const ast = calculateAST(program, topNode);
+            expect(ast?.body).not.toBeUndefined();
+
+            const body = ast?.body as LiteralAST;
+            expect(body.value).toEqual('12/31/2022 15:89:18');
+            expect(body.dataType).toBe('string');
+        });
+
+        test('Should return string with invalid dates february with 31', () => {
+            const program = '"02/31/2022 15:23:18"';
+            const parser = FormulaLang.parser;
+            const { topNode } = parser.parse(program);
+            const ast = calculateAST(program, topNode);
+            expect(ast?.body).not.toBeUndefined();
+
+            const body = ast?.body as LiteralAST;
+            expect(body.value).toEqual('02/31/2022 15:23:18');
+            expect(body.dataType).toBe('string');
+        });
+
+        test('Should return date valid for leap years february with 29', () => {
+            const program = '"02/29/2024"';
+            const parser = FormulaLang.parser;
+            const { topNode } = parser.parse(program);
+            const ast = calculateAST(program, topNode);
+            expect(ast?.body).not.toBeUndefined();
+
+            const body = ast?.body as LiteralAST;
+            expect(body.value).toEqual('2024-02-29T00:00:00.000Z');
+            expect(body.dataType).toBe('date');
+        });
+    });
+});

package/__tests__/{src → unit}/transpiler.test.ts

@@ -1,7 +1,6 @@
 import { ENGINES } from '../../src/constants';
 import { ProgramAST } from '../../src/constants/interfaces';
 import { Transpiler } from '../../src/transpiler';
-import { Transpile } from '../../src/index';
 
 describe('Transpiler tests suit', () => {
     test('Should resolve basic arithmetic operation', () => {
@@ -126,20 +125,4 @@ describe('Transpiler tests suit', () => {
         expect(result.valid).toBe(false);
         expect(result.error).not.toBeUndefined();
     });
-
-    test('should transpile a function to elasticsearch', () => {
-        const program = 'MID(MID("This is a test", 1, 5), 1, 2)';
-        const result = Transpile(program, ENGINES.ELASTICSEARCH);
-        expect(result?.valid).toBe(true);
-        expect(result?.expression).toBe(
-            "'This is a test'.substring(1, 5).substring(1, 2)",
-        );
-    });
-
-    test('should transpile a logical operator', () => {
-        const program = '1 < 2';
-        const result = Transpile(program, ENGINES.ELASTICSEARCH);
-        expect(result?.valid).toBe(true);
-        expect(result?.expression).toBe('(1 < 2)');
-    });
 });

package/dist/constants/index.d.ts

@@ -1,6 +1,7 @@
 export declare enum ENGINES {
     ELASTICSEARCH = "elasticsearch",
-    SNOWFLAKE = "snowflake"
+    SNOWFLAKE = "snowflake",
+    REDSHIFT = "redshift"
 }
 export declare enum AST_TYPES {
     program = "Program",
@@ -16,10 +17,13 @@ export declare enum ERROR_LIST {
     floatingPoint = "floatingPoint",
     missingString = "missingString",
     missingNumber = "missingNumber",
+    missingDate = "missingDate",
     greaterThanZero = "greaterThanZero",
     missingArg = "missingArg",
     unknownFunction = "unknownFunction",
-    unknown = "unknown"
+    unknown = "unknown",
+    customDateDifParams = "customDateDifParams",
+    tooManyArguments = "tooManyArguments"
 }
 type iErrorsType = {
     [key in ERROR_LIST]: IErrorDictionary;
@@ -29,4 +33,10 @@ interface IErrorDictionary {
     code: string;
 }
 export declare const ERROR_DICTIONARY: iErrorsType;
+export type CustomEngineOperators = {
+    [key in ENGINES]?: {
+        [T: string]: string;
+    };
+};
+export declare const CustomOperators: CustomEngineOperators;
 export {};