@qrvey/formula-lang 0.3.1 → 0.5.0

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