@qrvey/formula-lang 0.0.3 → 0.1.1

package/README.md

@@ -1,51 +1,68 @@
 # Qrvey Formula Language
+[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
+
 
 ## Usage
 
-Use it inside a javascript module
+### Transpile function
+```js
+import { ENGINES, Transpile } from "@qrvey/formula-lang";
 
+const program = "MID(MID(\"This is a test\", 1, 5), 1, 2)"
+const transpiled = Transpile(program, ENGINES.ELASTICSEARCH)
+console.log(transpiled)
+```
+the output will be
+```
+'This is a test'.substring(1, 5).substring(1, 2)
 ```
-import { QFormulaLang, calculateAST } from "@qrvey/formula-lang"
-import { iRootAST, ENGINES, Transpiler } from '../../qrvey-lang/transpiler/lib/constants/interfaces';
-
-// input expression
-const expression = 'MID("this is an ex", 1)';
-
-// get the parser from QFormulaLang
-const parser = QFormulaLang.parser;
-
-// get the tree from input expression
-const tree = parser.parse(expression);
 
-// transform the tree into an understandable AST
-const ast = calculateAST(expression, tree.topNode);
+### TranspileAST function
 
-// transpile the code to a specific target Engine
-const transpilated = calculateTranspilation(ast, ENGINES.ELASTICSEARCH)
+```js
+import { ENGINES, TranspileAST } from "@qrvey/formula-lang";
 
-calculateTranspilation = (ast: iRootAST, engine: ENGINES) => {
-    let result;
-    try {
-        const transpiler = new Transpiler(ast, engine)
-        result = transpiler.get()
-    } catch (error) {
-        result = JSON.stringify(error, undefined, 4)
+const ast = {
+    "type": "Program",
+    "exp": "1 + 2",
+    "lang": "QrveyLang",
+    "version": "0.0.0",
+    "body": {
+        "operator": "+",
+        "type": "BinaryExpression",
+        "left": {
+            "type": "Literal",
+            "dataType": "number",
+            "value": 1
+        },
+        "right": {
+            "type": "Literal",
+            "dataType": "number",
+            "value": 2
+        }
     }
-    return result
 }
+const transpiled = TranspileAST(ast, ENGINES.ELASTICSEARCH)
+console.log(transpiled)
 ```
-
-Use inside codemirror editor
+the output will be
+```
+(1 + 2)
 ```
+
+
+### codemirror editor
+```js
 import { EditorState } from "@codemirror/state";
-import { QFormula, calculateAST } from "@qrvey/formula-lang"
+import { basicSetup } from "codemirror";
+import { FormulaHighlight, calculateAST } from "@qrvey/formula-lang"
 
 // set the editor state with the QFormula plugin. This adds the support for 
 this._state = EditorState.create({
-    doc: options?.text ?? '',
+    doc: 'Test formula',
     extensions: [
     basicSetup,
-    QFormula(),
+    FormulaHighlight(),
     ...
     ]
 })

package/__tests__/src/parser.test.ts

@@ -0,0 +1,17 @@
+import { AST_TYPES } from '../../src/constants';
+import { calculateAST, FormulaLang } from '../../src';
+import { BinaryExpressionAST } 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);
+    });
+});

package/__tests__/src/transpiler.test.ts

@@ -0,0 +1,147 @@
+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', () => {
+        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();
+    });
+
+    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 function to snowflake', () => {
+        const program = 'MID(MID("This is a test", 1, 5), 1, 2)';
+        const result = Transpile(program, ENGINES.SNOWFLAKE);
+        expect(result?.valid).toBe(true);
+        expect(result?.expression).toBe(
+            "SUBSTRING(SUBSTRING('This is a test', 1, 5), 1, 2)",
+        );
+    });
+});

package/dist/constants/index.d.ts

@@ -0,0 +1,32 @@
+export declare enum ENGINES {
+    ELASTICSEARCH = "elasticsearch",
+    SNOWFLAKE = "snowflake"
+}
+export declare enum AST_TYPES {
+    program = "Program",
+    binaryExpression = "BinaryExpression",
+    unaryExpression = "UnaryExpression",
+    functionCall = "FunctionCall",
+    variable = "Variable",
+    literal = "Literal"
+}
+export declare enum ERROR_LIST {
+    arguments = "arguments",
+    nulls = "nulls",
+    floatingPoint = "floatingPoint",
+    missingString = "missingString",
+    missingNumber = "missingNumber",
+    greaterThanZero = "greaterThanZero",
+    missingArg = "missingArg",
+    unknownFunction = "unknownFunction",
+    unknown = "unknown"
+}
+type iErrorsType = {
+    [key in ERROR_LIST]: IErrorDictionary;
+};
+interface IErrorDictionary {
+    message: string;
+    code: string;
+}
+export declare const ERROR_DICTIONARY: iErrorsType;
+export {};

package/dist/constants/index.js

@@ -0,0 +1,65 @@
+export var ENGINES;
+(function (ENGINES) {
+    ENGINES["ELASTICSEARCH"] = "elasticsearch";
+    ENGINES["SNOWFLAKE"] = "snowflake";
+    // REDSHIFT = 'redshift',
+})(ENGINES || (ENGINES = {}));
+export var AST_TYPES;
+(function (AST_TYPES) {
+    AST_TYPES["program"] = "Program";
+    AST_TYPES["binaryExpression"] = "BinaryExpression";
+    AST_TYPES["unaryExpression"] = "UnaryExpression";
+    AST_TYPES["functionCall"] = "FunctionCall";
+    AST_TYPES["variable"] = "Variable";
+    AST_TYPES["literal"] = "Literal";
+})(AST_TYPES || (AST_TYPES = {}));
+export var ERROR_LIST;
+(function (ERROR_LIST) {
+    ERROR_LIST["arguments"] = "arguments";
+    ERROR_LIST["nulls"] = "nulls";
+    ERROR_LIST["floatingPoint"] = "floatingPoint";
+    ERROR_LIST["missingString"] = "missingString";
+    ERROR_LIST["missingNumber"] = "missingNumber";
+    ERROR_LIST["greaterThanZero"] = "greaterThanZero";
+    ERROR_LIST["missingArg"] = "missingArg";
+    ERROR_LIST["unknownFunction"] = "unknownFunction";
+    ERROR_LIST["unknown"] = "unknown";
+})(ERROR_LIST || (ERROR_LIST = {}));
+export const ERROR_DICTIONARY = {
+    [ERROR_LIST.arguments]: {
+        message: 'Ilegal number of arguments for function',
+        code: 'NUMBER_ARGS',
+    },
+    [ERROR_LIST.nulls]: {
+        message: 'Can not apply function with null values',
+        code: 'NULL_FOUNDS',
+    },
+    [ERROR_LIST.floatingPoint]: {
+        message: 'Invalid floating point operation to integer',
+        code: 'FLOATING_POINT',
+    },
+    [ERROR_LIST.missingString]: {
+        message: 'Element has to be a String',
+        code: 'MISSING_STRING',
+    },
+    [ERROR_LIST.missingNumber]: {
+        message: 'Element has to be a Number',
+        code: 'MISSING_NUMBER',
+    },
+    [ERROR_LIST.greaterThanZero]: {
+        message: 'Element has to be greater than 0',
+        code: 'GREATER_THAN_ZERO',
+    },
+    [ERROR_LIST.missingArg]: {
+        message: 'Missing arguments',
+        code: 'MISSING_ARG',
+    },
+    [ERROR_LIST.unknownFunction]: {
+        message: 'Unknown function',
+        code: 'UNKNOWN_FUNCTION',
+    },
+    [ERROR_LIST.unknown]: {
+        message: 'Unknown error',
+        code: 'UNKNOWN',
+    },
+};

package/dist/constants/interfaces.d.ts

@@ -0,0 +1,60 @@
+import { ENGINES, AST_TYPES } from '.';
+interface FunctionElementDefinition {
+    identifier: string;
+    name: string;
+}
+export interface FunctionDefinition extends FunctionElementDefinition {
+    transpiler: TranspilerEnginesFunction;
+    parameters?: Array<FunctionParameters>;
+}
+type TranspilerEnginesFunction = {
+    [key in ENGINES]: Function;
+};
+interface FunctionParameters extends FunctionElementDefinition {
+    type: string;
+    optional: boolean;
+    validator: Array<ValidatorFunctionParameter>;
+}
+interface ValidatorFunctionParameter {
+    (args: any): ValidatorResponse;
+}
+export interface ValidatorResponse {
+    valid: boolean;
+    code?: string;
+    message?: string;
+}
+export interface TranspilationResponse {
+    valid: boolean;
+    expression?: string;
+    error?: any;
+}
+export interface FunctionList {
+    [identifier: string]: FunctionDefinition;
+}
+export interface CommonAST {
+    type: AST_TYPES;
+}
+export interface ProgramAST extends CommonAST {
+    exp: string;
+    lang: string;
+    version: string;
+    body?: CommonAST;
+}
+export interface UnaryExpressionAST extends CommonAST {
+    operator: string;
+    right: CommonAST;
+}
+export interface BinaryExpressionAST extends UnaryExpressionAST {
+    left: CommonAST;
+}
+export interface FunctionCallAST extends CommonAST {
+    name: string;
+    arguments: Array<CommonAST>;
+}
+export interface VariableAST extends CommonAST {
+    value: string | boolean | number | CommonAST[] | null;
+}
+export interface LiteralAST extends VariableAST {
+    dataType: string;
+}
+export {};

package/dist/constants/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/errors/definitions.d.ts

@@ -0,0 +1,11 @@
+export declare class BaseError extends Error {
+    code: string;
+    constructor(code: string, message: string);
+    toString(): {
+        code: string;
+        message: string;
+    };
+}
+export declare class GenericError extends BaseError {
+    constructor(message?: string);
+}

package/dist/errors/definitions.js

@@ -0,0 +1,18 @@
+import { ERROR_DICTIONARY, ERROR_LIST } from '../constants';
+export class BaseError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+    toString() {
+        return {
+            code: this.code,
+            message: this.message,
+        };
+    }
+}
+export class GenericError extends BaseError {
+    constructor(message = ERROR_DICTIONARY[ERROR_LIST.unknown].message) {
+        super(ERROR_DICTIONARY[ERROR_LIST.unknown].code, message);
+    }
+}

package/dist/errors/elasticsearch.d.ts

@@ -0,0 +1,24 @@
+import { ERROR_LIST } from '../constants';
+export declare const errorRegex: ({
+    unknownFunction: {
+        regex: RegExp;
+        value: ERROR_LIST;
+    };
+    missingArguments: {
+        regex: RegExp;
+        value: ERROR_LIST;
+    };
+} | {
+    arguments: {
+        regex: RegExp;
+        value: ERROR_LIST;
+    };
+    state: {
+        regex: RegExp;
+        value: ERROR_LIST;
+    };
+    null_pointer: {
+        regex: RegExp;
+        value: ERROR_LIST;
+    };
+})[];

package/dist/errors/elasticsearch.js

@@ -0,0 +1,26 @@
+import { ERROR_LIST } from '../constants';
+const reasonsRegex = {
+    unknownFunction: {
+        regex: /Unknown call \[.*\] with/,
+        value: ERROR_LIST.unknownFunction,
+    },
+    missingArguments: {
+        regex: /static method \[.*\] not found/,
+        value: ERROR_LIST.arguments,
+    },
+};
+const typesRegex = {
+    arguments: {
+        regex: /illegal_argument_exception/,
+        value: ERROR_LIST.arguments,
+    },
+    state: {
+        regex: /illegal_state_exception/,
+        value: ERROR_LIST.nulls,
+    },
+    null_pointer: {
+        regex: /null_pointer_exception/,
+        value: ERROR_LIST.nulls,
+    },
+};
+export const errorRegex = [reasonsRegex, typesRegex];

package/dist/errors/index.d.ts

@@ -0,0 +1,5 @@
+import { ValidatorResponse } from '../constants/interfaces';
+export declare function engineErrors(messages: Array<string>, regexs: Array<object>): ValidatorResponse;
+export declare function isStringParam(param: any): ValidatorResponse;
+export declare function isNumberParam(param: any): ValidatorResponse;
+export declare function isPositiveNumberParam(param: any): ValidatorResponse;

package/dist/errors/index.js

@@ -0,0 +1,38 @@
+import { ERROR_LIST, ERROR_DICTIONARY } from '../constants';
+export function engineErrors(messages, regexs) {
+    const loopParams = (obj, str) => {
+        for (const key in obj) {
+            const regex = new RegExp(obj[key].regex, 'g');
+            if (regex.test(str)) {
+                return obj[key].value;
+            }
+        }
+    };
+    let value;
+    messages.forEach((message) => {
+        regexs.forEach((regex) => {
+            value = loopParams(regex, message);
+        });
+    });
+    if (!value)
+        value = ERROR_LIST.unknown;
+    return Object.assign({ valid: false }, ERROR_DICTIONARY[value]);
+}
+export function isStringParam(param) {
+    const valid = typeof param === 'string';
+    if (!valid)
+        return Object.assign({ valid }, ERROR_DICTIONARY[ERROR_LIST.missingString]);
+    return { valid };
+}
+export function isNumberParam(param) {
+    const valid = typeof param === 'number';
+    if (!valid)
+        return Object.assign({ valid }, ERROR_DICTIONARY[ERROR_LIST.missingNumber]);
+    return { valid };
+}
+export function isPositiveNumberParam(param) {
+    const valid = param >= 0;
+    if (!valid)
+        return Object.assign({ valid }, ERROR_DICTIONARY[ERROR_LIST.greaterThanZero]);
+    return { valid };
+}

package/dist/errors/snowflake.d.ts

@@ -0,0 +1,15 @@
+import { ERROR_LIST } from '../constants';
+export declare const errorRegex: {
+    missingArguments: {
+        regex: RegExp;
+        value: ERROR_LIST;
+    };
+    floatingPoint: {
+        regex: RegExp;
+        value: ERROR_LIST;
+    };
+    unknownFunction: {
+        regex: RegExp;
+        value: ERROR_LIST;
+    };
+}[];

package/dist/errors/snowflake.js

@@ -0,0 +1,16 @@
+import { ERROR_LIST } from '../constants';
+const reasonsRegex = {
+    missingArguments: {
+        regex: /not enough arguments for function/,
+        value: ERROR_LIST.arguments,
+    },
+    floatingPoint: {
+        regex: /Invalid floating point operation/,
+        value: ERROR_LIST.floatingPoint,
+    },
+    unknownFunction: {
+        regex: /Unknown function/,
+        value: ERROR_LIST.unknownFunction,
+    },
+};
+export const errorRegex = [reasonsRegex];

package/dist/functions/index.d.ts

@@ -0,0 +1,2 @@
+import { FunctionList } from '../constants/interfaces';
+export declare const functionList: FunctionList;

package/dist/functions/index.js

@@ -0,0 +1,4 @@
+import { MID } from './mid';
+export const functionList = {
+    MID,
+};

package/dist/functions/mid.d.ts

@@ -0,0 +1,2 @@
+import { FunctionDefinition } from '../constants/interfaces';
+export declare const MID: FunctionDefinition;

package/dist/functions/mid.js

@@ -0,0 +1,47 @@
+import * as errorList from '../errors';
+export const MID = {
+    identifier: 'MID',
+    name: 'MID',
+    parameters: [
+        {
+            identifier: 'CURRENT',
+            name: 'current',
+            type: 'String',
+            optional: false,
+            validator: [errorList.isStringParam],
+        },
+        {
+            identifier: 'STARTING_AT',
+            name: 'starting_at',
+            type: 'Number',
+            optional: false,
+            validator: [errorList.isNumberParam, customIsPositive],
+        },
+        {
+            identifier: 'EXTRACT_LENGTH',
+            name: 'extract_length',
+            type: 'Number',
+            optional: true,
+            validator: [customIsPositive],
+        },
+    ],
+    transpiler: {
+        elasticsearch,
+        snowflake,
+    },
+};
+//TODO esto no sirve para nada, es solo un ejemplo de implementacion.
+function customIsPositive(param) {
+    const isPositive = errorList.isPositiveNumberParam(param);
+    if (!isPositive.valid)
+        return isPositive;
+    return { valid: true };
+}
+function elasticsearch(current, start, length) {
+    const optional = length ? `, ${length}` : '';
+    return `${current}.substring(${start}${optional})`;
+}
+function snowflake(current, start, length) {
+    const optional = length ? `, ${length}` : '';
+    return `SUBSTRING(${current}, ${start}${optional})`;
+}

package/dist/grammar/generated/qformula.lang.js

@@ -2,21 +2,21 @@ import { LRParser } from '@lezer/lr';
 import { LRLanguage, LanguageSupport } from '@codemirror/language';
 import { styleTags, tags } from '@lezer/highlight';
 // This file was generated by lezer-generator. You probably shouldn't edit it.
-const spec_identifier = { __proto__: null, true: 14, false: 14 };
+const spec_identifier = { __proto__: null, true: 14, false: 14, null: 16 };
 const parser = LRParser.deserialize({
     version: 14,
-    states: "%jO]QPOOOwQPO'#CdOOQO'#C`'#C`OOQO'#Cf'#CfO!YQPO'#CeO!_QQO'#ChO]QPO'#CiQ!dQPOOO]QPO'#CnOOQO'#C_'#C_O!oQPO'#CxO!wQPO,59OO!|QPO,59PO#TQPO,59SOOQO,59T,59TO]QPO,59VO]QPO,59VO#YQPO,59YO#hQPO'#CoO#|QPO,59dOOQO1G.j1G.jO$UQPO'#C|OOQO'#Cg'#CgO$gQPO1G.kOOQO1G.n1G.nOOQO1G.q1G.qO$lQPO1G.qOOQO1G.t1G.tOOQO,59Z,59ZOOQO-E6m-E6mO%QQPO'#CpO%[QPO,59hOOQO7+$V7+$VO%dQPO,59[OOQO-E6n-E6n",
-    stateData: "%|~OgOShOSPOS~OTQOUQOVQO^UOiROkPOoWOrTO~OTQOUQOVQOkPOjlP~Oo[O~Os]O~O^`O`_Oa_O~OmbOjlX~OjdO~OnpP~P]OqhO~O^`O`_Oa_OnkO~OTQOUQOVQOkPOjcXmcX~OmbOjla~O^`O`_Oa_OmnOnpX~OnpO~O`_Oa_O^_ie_in_im_i~OmdXndX~P]OmnOnpa~O^`O`_Oa_Omdanda~OP`ghig~",
-    goto: "#lqPPPr!XPPP!h!s!|#V!s!sP!sPP!s#Y#`PPPPPPP#fPPP#iQVOQ^UQaWQe[Qi_Qj`Rqn^XOUW[_`nQYPRlbcQOPUW[_`bn_XOUW[_`n_SOUW[_`nRg[QcYRmcQoeRroRZPRf[",
-    nodeNames: "⚠ LineComment Program Expression Value Number String Boolean Array Function FunctionIdentifier FunctionArguments Variable UnaryExpression ArithOp BinaryExpression ArithOp ArithOp ParenthesizedExpression",
-    maxTerm: 35,
+    states: "%vO]QPOOO!]QPO'#CeOOQO'#C`'#C`OOQO'#Cg'#CgO!dQPO'#CfO!iQQO'#CiO]QPO'#CjQ!nQSOOO]QPO'#CpOOQO'#C_'#C_O!|QPO'#CzO#UQPO,59PO#ZQPO,59QO#bQPO,59TOOQO,59U,59UO]QPO,59WO]QPO,59WO]QPO,59WO#gQSO,59[O#xQPO'#CqO$SQPO,59fOOQO1G.k1G.kO$[QSO'#DOOOQO'#Ch'#ChO$pQPO1G.lOOQO1G.o1G.oOOQO1G.r1G.rO%WQSO1G.rO%bQSO1G.rOOQO1G.v1G.vOOQO,59],59]OOQO-E6o-E6oO%lQPO'#CrO%vQPO,59jOOQO7+$W7+$WO&OQSO,59^OOQO-E6p-E6p",
+    stateData: "&k~OiOSjOSPOS~OTQOUQOVQOWQO_UOkROmPOqWOtTO~OTQOUQOVQOWQOmPO~OlnP~PzOq[O~Ou]O~O_aOa_Ob`Oc`O~OocOlnX~OleO~OprP~P]OsiO~O_aOa_Ob`Oc`OpmO~OleXoeX~PzOocOlna~O_aOa_Ob`Oc`OopOprX~OprO~Oa_O_`ig`ip`io`i~Ob`ic`i~P$uOb`Oc`O~P$uOofXpfX~P]OopOpra~O_aOa_Ob`Oc`Oofapfa~OPbijki~",
+    goto: "#usPPPt!^PPPP!n!z#U#`!z!zP!zPPP!z#c#iPPPPPPP#oPPP#rQVOQ^UQbWQf[Qj_Qk`QlaRsp`XOUW[_`apQYPRnceQOPUW[_`acpaXOUW[_`apaSOUW[_`apRh[QdYRodQqfRtqRZPRg[",
+    nodeNames: "⚠ LineComment Program Expression Value Number String Boolean Null Array Function FunctionIdentifier FunctionArguments Variable UnaryExpression ArithOp BinaryExpression LogicOp ArithOp ArithOp ParenthesizedExpression",
+    maxTerm: 37,
     skippedNodes: [0, 1],
     repeatNodeCount: 2,
-    tokenData: ")o~RoXY#SYZ#wZ[#S]^#wpq#Srs#|xy%jyz%oz{%t{|%y|}&{}!O%y!O!P'Q!P!Q'c!Q![(S!^!_(p!`!a(u!c!}(z!}#O)e#P#Q)j#R#S&d#T#o(z$f$g#S#BY#BZ#S$IS$I_#S$I|$I}#w$I}$JO#w$JT$JU#S$KV$KW#S&FU&FV#S?HT?HU#S~#XYg~XY#SZ[#Spq#S$f$g#S#BY#BZ#S$IS$I_#S$JT$JU#S$KV$KW#S&FU&FV#S?HT?HU#S~#|Oh~~$PVOr#|rs$fs#O#|#O#P$k#P;'S#|;'S;=`%d<%lO#|~$kOU~~$nRO;'S#|;'S;=`$w;=`O#|~$zWOr#|rs$fs#O#|#O#P$k#P;'S#|;'S;=`%d;=`<%l#|<%lO#|~%gP;=`<%l#|~%oOo~~%tOn~~%yOa~R&QU^PsQ{|&d}!O&d!Q![&d!c!}&d#R#S&d#T#o&dQ&iUsQ{|&d}!O&d!Q![&d!c!}&d#R#S&d#T#o&d~'QOm~P'TP!Q!['WP']QTP!Q!['W#R#S'W~'hP`~!P!Q'k~'pSP~OY'kZ;'S'k;'S;=`'|<%lO'k~(PP;=`<%l'kR(ZVTPsQ{|&d}!O&d!O!P'W!Q![(S!c!}&d#R#S(S#T#o&d~(uOk~~(zOj~R)RUsQiP{|&d}!O&d!Q![(z!c!}(z#R#S(z#T#o(z~)jOr~~)oOq~",
-    tokenizers: [0, 1],
+    tokenData: "*U~RpXY#VYZ#zZ[#V]^#zpq#Vrs$Pxy%myz%rz{%w{|%||}'O}!O%|!O!P'T!P!Q'f!Q![(V!^!_(s!_!`)Q!`!a)V!c!})a!}#O)z#P#Q*P#R#S&g#T#o)a$f$g#V#BY#BZ#V$IS$I_#V$I|$I}#z$I}$JO#z$JT$JU#V$KV$KW#V&FU&FV#V?HT?HU#V~#[Yi~XY#VZ[#Vpq#V$f$g#V#BY#BZ#V$IS$I_#V$JT$JU#V$KV$KW#V&FU&FV#V?HT?HU#V~$POj~~$SVOr$Prs$is#O$P#O#P$n#P;'S$P;'S;=`%g<%lO$P~$nOU~~$qRO;'S$P;'S;=`$z;=`O$P~$}WOr$Prs$is#O$P#O#P$n#P;'S$P;'S;=`%g;=`<%l$P<%lO$P~%jP;=`<%l$P~%rOq~~%wOp~~%|Oc~V&TU_TuQ{|&g}!O&g!Q![&g!c!}&g#R#S&g#T#o&gQ&lUuQ{|&g}!O&g!Q![&g!c!}&g#R#S&g#T#o&g~'TOo~P'WP!Q!['ZP'`QTP!Q!['Z#R#S'Z~'kPb~!P!Q'n~'sSP~OY'nZ;'S'n;'S;=`(P<%lO'n~(SP;=`<%l'nR(^VTPuQ{|&g}!O&g!O!P'Z!Q![(V!c!}&g#R#S(V#T#o&gT(zQmPaS!_!`)Q!`!a)QS)VOaST)^PlPaS!_!`)QR)hUuQkP{|&g}!O&g!Q![)a!c!})a#R#S)a#T#o)a~*POt~~*UOs~",
+    tokenizers: [0, 1, 2],
     topRules: { "Program": [0, 2] },
-    specialized: [{ term: 25, get: value => spec_identifier[value] || -1 }],
-    tokenPrec: 221
+    specialized: [{ term: 27, get: value => spec_identifier[value] || -1 }],
+    tokenPrec: 250
 });
 const QFormulaLang = LRLanguage.define({
     parser: parser.configure({
@@ -28,13 +28,13 @@ const QFormulaLang = LRLanguage.define({
                 Variable: tags.keyword,
                 LineComment: tags.lineComment,
                 FunctionIdentifier: tags.lineComment,
-                "( )": tags.paren
-            })
-        ]
+                '( )': tags.paren,
+            }),
+        ],
     }),
     languageData: {
-        commentTokens: { line: "//" }
-    }
+        commentTokens: { line: '//' },
+    },
 });
 function QFormula() {
     return new LanguageSupport(QFormulaLang);

package/dist/grammar/qformula.grammar.d.ts

@@ -1 +1 @@
-export * from "./generated/qformula.lang.js";
+export * from './generated/qformula.lang.js';

package/dist/grammar/qformula.grammar.js

@@ -1 +1 @@
-export * from "./generated/qformula.lang.js";
+export * from './generated/qformula.lang.js';

package/dist/index.d.ts

@@ -1,2 +1,8 @@
-export * from "./grammar/qformula.grammar";
-export * from "./parser/json-parser";
+import { ENGINES } from './constants/index';
+import { TranspilationResponse } from './constants/interfaces';
+export { QFormula as FormulaHighlight, QFormulaLang as FormulaLang, } from './grammar/qformula.grammar';
+export { calculateAST } from './parser/json-parser';
+export { ENGINES } from './constants/index';
+export { TranspileAST } from './transpiler/index';
+export { ProgramAST } from './constants/interfaces';
+export declare function Transpile(program: string, engine: ENGINES): TranspilationResponse | undefined;

package/dist/index.js

@@ -1,2 +1,17 @@
-export * from "./grammar/qformula.grammar";
-export * from "./parser/json-parser";
+import { QFormulaLang } from './grammar/qformula.grammar';
+import { calculateAST } from './parser/json-parser';
+import { TranspileAST } from './transpiler/index';
+export { QFormula as FormulaHighlight, QFormulaLang as FormulaLang, } from './grammar/qformula.grammar';
+export { calculateAST } from './parser/json-parser';
+export { ENGINES } from './constants/index';
+export { TranspileAST } from './transpiler/index';
+export function Transpile(program, engine) {
+    const parser = QFormulaLang.parser;
+    const { topNode } = parser.parse(program);
+    if (!topNode)
+        return;
+    const ast = calculateAST(program, topNode);
+    if (!ast)
+        return;
+    return TranspileAST(ast, engine);
+}

package/dist/parser/json-parser.d.ts

@@ -1,3 +1,3 @@
-import { AstNode } from "../models/ast.models";
-import { SyntaxNode } from "@lezer/common";
-export declare function calculateAST(program: string, startNode: SyntaxNode): AstNode;
+import { SyntaxNode } from '@lezer/common';
+import { ProgramAST } from '../constants/interfaces';
+export declare function calculateAST(program: string, startNode: SyntaxNode): ProgramAST | undefined;

package/dist/parser/json-parser.js

@@ -1,20 +1,19 @@
-import { getNodeValue } from "../utils/utils";
-const PARSER_VERSION = "0.0.0";
-const LANG_NAME = "QrveyLang";
+import { AST_TYPES } from '../constants';
+import { getNodeValue } from '../utils';
+const PARSER_VERSION = '0.0.0';
+const LANG_NAME = 'QrveyLang';
 export function calculateAST(program, startNode) {
     if (!startNode)
-        return { type: 'undefined' };
+        return;
     return {
-        "type": "Program",
-        "exp": program,
-        "lang": LANG_NAME,
-        "version": PARSER_VERSION,
-        "body": transformNode(program, startNode)
+        type: AST_TYPES.program,
+        exp: program,
+        lang: LANG_NAME,
+        version: PARSER_VERSION,
+        body: transformNode(program, startNode),
     };
 }
 function transformNode(program, node) {
-    if (!node)
-        return { type: 'undefined' };
     switch (node.name) {
         case 'BinaryExpression':
             return transformBinaryExpression(program, node);
@@ -24,48 +23,56 @@ function transformNode(program, node) {
             return transformFunctionExpression(program, node);
         case 'Number':
             return {
-                type: "Literal",
-                dataType: "number",
-                value: parseFloat(getNodeValue(program, node))
+                type: 'Literal',
+                dataType: 'number',
+                value: parseFloat(getNodeValue(program, node)),
             };
         case 'String':
             return {
-                type: "Literal",
-                dataType: "string",
-                value: getNodeValue(program, node).slice(1, -1)
+                type: 'Literal',
+                dataType: 'string',
+                value: getNodeValue(program, node).slice(1, -1),
             };
         case 'Boolean':
             return {
-                type: "Literal",
-                dataType: "boolean",
-                value: getNodeValue(program, node) === 'true'
+                type: 'Literal',
+                dataType: 'boolean',
+                value: getNodeValue(program, node) === 'true',
+            };
+        case 'Null':
+            return {
+                type: 'Literal',
+                dataType: 'boolean',
+                value: null,
             };
         case 'Array':
             return {
-                type: "Literal",
-                dataType: "array",
-                value: node.getChildren('Value')
-                    .map(node => {
+                type: 'Literal',
+                dataType: 'array',
+                value: node.getChildren('Value').map((node) => {
                     return transformNode(program, node);
-                })
+                }),
             };
         case 'Variable':
             return {
-                type: "Variable",
-                value: getNodeValue(program, node).slice(1, -1)
+                type: 'Variable',
+                value: getNodeValue(program, node).slice(1, -1),
             };
         default:
-            return transformNode(program, node.firstChild);
+            return node.firstChild
+                ? transformNode(program, node.firstChild)
+                : undefined;
     }
 }
 function transformBinaryExpression(program, node) {
     const [left, right] = node.getChildren('Expression');
-    const operator = node.getChild('ArithOp');
+    const logicOperator = node.getChild('LogicOp');
+    const arithOperator = node.getChild('ArithOp');
     return {
-        operator: getNodeValue(program, operator),
-        type: "BinaryExpression",
+        operator: getNodeValue(program, logicOperator !== null && logicOperator !== void 0 ? logicOperator : arithOperator),
+        type: AST_TYPES.binaryExpression,
         left: transformNode(program, left),
-        right: transformNode(program, right)
+        right: transformNode(program, right),
     };
 }
 function transformUnaryExpression(program, node) {
@@ -73,18 +80,20 @@ function transformUnaryExpression(program, node) {
     const operator = node.getChild('ArithOp');
     return {
         operator: getNodeValue(program, operator),
-        type: "UnaryExpression",
-        right: transformNode(program, right)
+        type: AST_TYPES.unaryExpression,
+        right: transformNode(program, right),
     };
 }
 function transformFunctionExpression(program, node) {
     const args = node.getChild('FunctionArguments');
     const nodeValue = node.getChild('FunctionIdentifier');
     return {
-        type: "FunctionCall",
+        type: AST_TYPES.functionCall,
         name: getNodeValue(program, nodeValue),
-        arguments: !!args ? args
-            .getChildren('Expression')
-            .map(node => transformNode(program, node)) : []
+        arguments: args
+            ? args
+                .getChildren('Expression')
+                .map((node) => transformNode(program, node))
+            : [],
     };
 }

package/dist/transpiler/index.d.ts

@@ -0,0 +1,15 @@
+import { ENGINES } from '../constants';
+import { CommonAST, ProgramAST, BinaryExpressionAST, UnaryExpressionAST, FunctionCallAST, LiteralAST, FunctionDefinition, TranspilationResponse } from '../constants/interfaces';
+export declare class Transpiler {
+    readonly engine: ENGINES;
+    private ast;
+    constructor(ast: ProgramAST, engine: ENGINES);
+    get(): TranspilationResponse;
+    processNode(expression: CommonAST): string;
+    literal({ value, dataType }: LiteralAST): string | number | boolean | CommonAST[] | null;
+    unaryExpression({ operator, right }: UnaryExpressionAST): string;
+    binaryExpression({ left, operator, right }: BinaryExpressionAST): string;
+    functionCall(node: FunctionCallAST): string;
+    executer(func: FunctionDefinition, args: Array<any>, node: FunctionCallAST): string;
+}
+export declare function TranspileAST(ast: ProgramAST, engine: ENGINES): TranspilationResponse;

package/dist/transpiler/index.js

@@ -0,0 +1,77 @@
+import { AST_TYPES, ERROR_DICTIONARY, ERROR_LIST } from '../constants';
+import { GenericError } from '../errors/definitions';
+import { functionList } from '../functions';
+export class Transpiler {
+    constructor(ast, engine) {
+        this.ast = ast;
+        this.engine = engine;
+    }
+    get() {
+        try {
+            const { body } = this.ast;
+            return {
+                valid: body !== undefined,
+                expression: body ? this.processNode(body) : undefined,
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                error: new GenericError(error.message),
+            };
+        }
+    }
+    processNode(expression) {
+        const { type } = expression;
+        const nodes = {
+            [AST_TYPES.variable]: this.literal,
+            [AST_TYPES.literal]: this.literal,
+            [AST_TYPES.unaryExpression]: this.unaryExpression,
+            [AST_TYPES.binaryExpression]: this.binaryExpression,
+            [AST_TYPES.functionCall]: this.functionCall,
+        };
+        return nodes[type].call(this, expression);
+    }
+    literal({ value, dataType }) {
+        if (dataType === 'string')
+            value = `'${value}'`;
+        return value;
+    }
+    unaryExpression({ operator, right }) {
+        const rightResult = this.processNode(right);
+        return `(${operator} ${rightResult})`;
+    }
+    binaryExpression({ left, operator, right }) {
+        const leftResult = this.processNode(left);
+        const rightResult = this.processNode(right);
+        return `(${leftResult} ${operator} ${rightResult})`;
+    }
+    functionCall(node) {
+        const { name, arguments: args } = node;
+        const func = functionList[name];
+        if (!func)
+            throw Object.assign({ node }, ERROR_DICTIONARY[ERROR_LIST.unknownFunction]);
+        const parameters = args.map((param) => this.processNode(param));
+        return this.executer(func, parameters, node);
+    }
+    executer(func, args, node) {
+        const params = (func === null || func === void 0 ? void 0 : func.parameters) ? [...func.parameters] : [];
+        for (const [index, element] of params.entries()) {
+            const value = args[index];
+            if (!value && element.optional)
+                continue;
+            if (!value && !element.optional)
+                throw Object.assign({ node }, ERROR_DICTIONARY[ERROR_LIST.missingArg]);
+            element.validator.forEach((validatorFunction) => {
+                const validator = validatorFunction(value);
+                if (!validator.valid)
+                    throw Object.assign({ node }, validator);
+            });
+        }
+        return func.transpiler[this.engine](...args);
+    }
+}
+export function TranspileAST(ast, engine) {
+    const transpiler = new Transpiler(ast, engine);
+    return transpiler.get();
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export declare function getNodeValue(str: string, { from, to }: {
+    from: number;
+    to: number;
+}): string;

package/dist/utils/index.js

@@ -0,0 +1,3 @@
+export function getNodeValue(str, { from, to }) {
+    return str.slice(from, to);
+}

package/package.json

@@ -1,16 +1,21 @@
 {
   "name": "@qrvey/formula-lang",
-  "version": "0.0.3",
+  "version": "0.1.1",
   "description": "QFormula support for qrvey projects",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest __tests__",
     "build": "tsc",
     "build:watch": "tsc -w",
     "prepublishOnly": "npm run build",
-    "prepare-lang": "rollup -c --bundleConfigAsCjs"
+    "cm": "cz",
+    "prepare-lang": "rollup -c --bundleConfigAsCjs",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --fix --ext .ts",
+    "prettier:fix": "prettier --write ./src",
+    "prepare:husky": "husky install"
   },
   "repository": {
     "type": "git",
@@ -25,15 +30,35 @@
   "author": "Qrvey Inc",
   "homepage": "https://bitbucket.org/qrvey/qrvey_formula_lang#readme",
   "dependencies": {
-    "@codemirror/language": "^6.6.0",
-    "@lezer/common": "^1.0.2",
-    "@lezer/highlight": "^1.1.4"
+    "@codemirror/language": "6.6.0",
+    "@lezer/common": "1.0.2",
+    "@lezer/highlight": "1.1.4"
   },
   "devDependencies": {
+    "@commitlint/cli": "^17.5.1",
+    "@commitlint/config-conventional": "^17.4.4",
     "@lezer/generator": "^1.2.2",
+    "@types/jest": "^29.5.0",
+    "@typescript-eslint/eslint-plugin": "^5.58.0",
+    "@typescript-eslint/parser": "^5.58.0",
+    "commitizen": "^4.3.0",
+    "cz-conventional-changelog": "^3.3.0",
+    "eslint": "^8.38.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "husky": "^8.0.3",
+    "jest": "^29.5.0",
+    "lint-staged": "^13.2.1",
+    "prettier": "^2.8.7",
     "rollup": "^3.20.2",
     "rollup-plugin-dts": "^5.3.0",
     "rollup-plugin-ts": "^3.2.0",
+    "ts-jest": "^29.1.0",
     "typescript": "^5.0.4"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
   }
 }