@qrvey/formula-lang 0.4.0 → 0.5.0

package/__tests__/integration/sonwflake.test.ts

@@ -1,138 +0,0 @@
-import { ENGINES, Transpile } from '../../src';
-import { datePart, dateDif } from './__mocks__/sqlScripts';
-import { basicContext } from './__mocks__/context';
-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('Cast Date string', () => {
-        const result = Transpile('"12/31/2022 13:35:45"', currentEngine);
-        expect(result?.expression).toBe(
-            `CAST('2022-12-31T13:35:45.000Z' AS TIMESTAMPTZ)`,
-        );
-    });
-
-    test('DAY function', () => {
-        const result = Transpile('DAY("12/31/2023")', currentEngine);
-        expect(result?.expression).toBe(datePart('day'));
-    });
-
-    test('DAY function with a variable Column', () => {
-        const result = Transpile('DAY([DateID1])', currentEngine, basicContext);
-        const column = '"Origin_Date_Column_Test"';
-        const mock = datePart('day', column).replace(/\n/g, '');
-        expect(result?.expression?.replace(/\n/g, '')).toBe(mock);
-    });
-
-    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

@@ -1,236 +0,0 @@
-import { AST_TYPES } from '../../src/constants';
-import { calculateAST, FormulaLang } from '../../src';
-import {
-    BinaryExpressionAST,
-    FormulaContext,
-    LiteralAST,
-    UnaryExpressionAST,
-    VariableAST,
-} 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('Value types', () => {
-        test('Should return a unary expression', () => {
-            const program = '-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 UnaryExpressionAST;
-            expect(body.operator).toEqual('-');
-            const numberResult = body.right as LiteralAST;
-            expect(numberResult.type).toEqual('Literal');
-            expect(numberResult.dataType).toEqual('number');
-            expect(numberResult.value).toEqual(2);
-        });
-
-        test('Should return a boolean expression', () => {
-            const program = 'false';
-            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.type).toEqual('Literal');
-            expect(body.dataType).toEqual('boolean');
-            expect(body.value).toEqual(false);
-        });
-
-        test('Should return a null expression', () => {
-            const program = 'null';
-            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.type).toEqual('Literal');
-            expect(body.dataType).toEqual('null');
-            expect(body.value).toEqual(null);
-        });
-
-        test('Should return a array expression', () => {
-            const program = '<1,2,3>';
-            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.type).toEqual('Literal');
-            expect(body.dataType).toEqual('array');
-            const arrayValue = body.value as Array<LiteralAST>;
-
-            expect(arrayValue[0].type).toEqual('Literal');
-            expect(arrayValue[0].dataType).toEqual('number');
-            expect(arrayValue[0].value).toEqual(1);
-            expect(arrayValue[1].type).toEqual('Literal');
-            expect(arrayValue[1].dataType).toEqual('number');
-            expect(arrayValue[1].value).toEqual(2);
-            expect(arrayValue[2].type).toEqual('Literal');
-            expect(arrayValue[2].dataType).toEqual('number');
-            expect(arrayValue[2].value).toEqual(3);
-        });
-    });
-
-    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');
-        });
-    });
-
-    describe('Parser with context', () => {
-        const context: FormulaContext = {
-            model: [
-                {
-                    id: 'column.test',
-                    label: 'Column Test',
-                    column: 'Origin_Column_Test',
-                    type: 'string',
-                },
-                {
-                    id: 'NOW',
-                    label: 'NOW',
-                    type: 'string',
-                },
-            ],
-        };
-        test('Should return a column without context', () => {
-            const program = '[columnNoContext]';
-            const parser = FormulaLang.parser;
-            const { topNode } = parser.parse(program);
-            const ast = calculateAST(program, topNode, context);
-            expect(ast?.body).not.toBeUndefined();
-
-            const body = ast?.body as VariableAST;
-            expect(body.value).toEqual('columnNoContext');
-            expect(body.type).toEqual('Variable');
-            expect(body.context).toBeUndefined();
-        });
-
-        test('Should return a column with context', () => {
-            const program = '[column.test]';
-            const parser = FormulaLang.parser;
-            const { topNode } = parser.parse(program);
-            const ast = calculateAST(program, topNode, context);
-            expect(ast?.body).not.toBeUndefined();
-
-            const body = ast?.body as VariableAST;
-            expect(body.value).toEqual('column.test');
-            expect(body.type).toEqual('Column');
-            expect(body.context?.id).toEqual('column.test');
-            expect(body.context?.type).toEqual('string');
-            expect(body.context?.label).toEqual('Column Test');
-            expect(body.context?.column).toEqual('Origin_Column_Test');
-        });
-
-        test('Should return a token with context', () => {
-            const program = '[NOW]';
-            const parser = FormulaLang.parser;
-            const { topNode } = parser.parse(program);
-            const ast = calculateAST(program, topNode, context);
-            expect(ast?.body).not.toBeUndefined();
-
-            const body = ast?.body as VariableAST;
-            expect(body.value).toEqual('{{NOW}}');
-            expect(body.type).toEqual('Token');
-            expect(body.context?.id).toEqual('NOW');
-            expect(body.context?.type).toEqual('string');
-            expect(body.context?.label).toEqual('NOW');
-        });
-    });
-});

package/__tests__/unit/transpiler.test.ts

@@ -1,128 +0,0 @@
-import { ENGINES } from '../../src/constants';
-import { ProgramAST } from '../../src/constants/interfaces';
-import { Transpiler } from '../../src/transpiler';
-
-describe('Transpiler tests suit', () => {
-    test('Should resolve basic arithmetic operation', () => {
-        const AST: ProgramAST = {
-            type: 'Program',
-            exp: '1 + 1',
-            lang: 'QrveyLang',
-            version: '0.0.0',
-            body: {
-                operator: '+',
-                type: 'BinaryExpression',
-                left: {
-                    type: 'Literal',
-                    dataType: 'number',
-                    value: 1,
-                },
-                right: {
-                    type: 'Literal',
-                    dataType: 'number',
-                    value: 2,
-                },
-            },
-        } as ProgramAST;
-
-        const transpiler = new Transpiler(AST, ENGINES.ELASTICSEARCH);
-        const result = transpiler.get();
-        expect(result.expression).toBe('(1 + 2)');
-    });
-
-    test('Should resolve basic logic operation', () => {
-        const AST: ProgramAST = {
-            type: 'Program',
-            exp: '1 <= 1',
-            lang: 'QrveyLang',
-            version: '0.0.0',
-            body: {
-                operator: '<=',
-                type: 'BinaryExpression',
-                left: {
-                    type: 'Literal',
-                    dataType: 'number',
-                    value: 1,
-                },
-                right: {
-                    type: 'Literal',
-                    dataType: 'number',
-                    value: 2,
-                },
-            },
-        } as ProgramAST;
-
-        const transpiler = new Transpiler(AST, ENGINES.ELASTICSEARCH);
-        const result = transpiler.get();
-        expect(result.expression).toBe('(1 <= 2)');
-    });
-
-    test('Should resolve MID function', () => {
-        const AST: ProgramAST = {
-            type: 'Program',
-            exp: 'MID("string", 2, 3)',
-            lang: 'QrveyLang',
-            version: '0.0.0',
-            body: {
-                type: 'FunctionCall',
-                name: 'MID',
-                arguments: [
-                    {
-                        type: 'Literal',
-                        dataType: 'string',
-                        value: 'string',
-                    },
-                    {
-                        type: 'Literal',
-                        dataType: 'number',
-                        value: 2,
-                    },
-                    {
-                        type: 'Literal',
-                        dataType: 'number',
-                        value: 3,
-                    },
-                ],
-            },
-        } as ProgramAST;
-
-        const transpiler = new Transpiler(AST, ENGINES.ELASTICSEARCH);
-        const result = transpiler.get();
-        expect(result.expression).toBe(`'string'.substring(2, 3)`);
-    });
-
-    test('Should throw a exception because is a invalid expression (function does not exists)', () => {
-        const AST: ProgramAST = {
-            type: 'Program',
-            exp: 'MID1("string", 2, 3)',
-            lang: 'QrveyLang',
-            version: '0.0.0',
-            body: {
-                type: 'FunctionCall',
-                name: 'MID1',
-                arguments: [
-                    {
-                        type: 'Literal',
-                        dataType: 'string',
-                        value: 'string',
-                    },
-                    {
-                        type: 'Literal',
-                        dataType: 'number',
-                        value: 2,
-                    },
-                    {
-                        type: 'Literal',
-                        dataType: 'number',
-                        value: 3,
-                    },
-                ],
-            },
-        } as ProgramAST;
-
-        const transpiler = new Transpiler(AST, ENGINES.ELASTICSEARCH);
-        const result = transpiler.get();
-        expect(result.valid).toBe(false);
-        expect(result.error).not.toBeUndefined();
-    });
-});

package/bitbucket-pipelines.yml

@@ -1,63 +0,0 @@
-image: node:16
-
-clone:
-  depth: full # SonarCloud scanner needs the full history to assign issues properly
-
-unitTesting: &unitTesting
-  name: Unit tests
-  caches:
-    - node
-    - npm
-  script:
-    - npm run test:coverage
-  artifacts:
-    # store coverage report
-    - coverage/**
-
-sonar: &sonar
-  name: SonarQube analysis
-  image: maven:3.3.9
-  caches:
-    - sonar
-  script:
-    - pipe: sonarsource/sonarqube-scan:1.2.0
-      variables:
-          SONAR_HOST_URL: ${SONAR_HOST_URL} # Get the value from the repository/workspace variable.
-          SONAR_TOKEN: ${SONAR_TOKEN} # Get the value from the repository/workspace variable. You shouldn't set secret in clear text here.
-
-pipelines:
-  branches: 
-    develop: 
-      - step:
-          name: 'Install, lint, and build'
-          caches:
-            - node
-            - npm
-          script:
-            - npm ci --unsafe-perm
-            - npm run lint
-            - npm run build
-      - step:
-          <<: *unitTesting
-      - step:
-          <<: *sonar
-  default:
-    - step:
-        name: 'Install, lint, and build'
-        caches:
-          - node
-          - npm
-        script:
-          - npm ci --unsafe-perm
-          - npm run lint
-          - npm run build
-    - step:
-        <<: *unitTesting
-
-definitions:
-  caches:
-    npm: $HOME/.npm
-    sonar: ~/.sonar
-  services:
-    docker:
-      memory: 2048