@qrvey/formula-lang 0.0.2 → 0.1.0

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,120 @@
+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 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[];
+}
+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/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 +1,8 @@
-export * from "./grammar/qformula.grammar";
+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 +1,17 @@
-export * from "./grammar/qformula.grammar";
+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/models/ast.models.d.ts

@@ -0,0 +1,29 @@
+export interface AstNode {
+    type: string;
+}
+export interface AstBinaryExpressionNode extends AstNode {
+    operator: string;
+    left: AstNode;
+    right: AstNode;
+}
+export interface AstUnaryExpressionNode extends AstNode {
+    operator: string;
+    right: AstNode;
+}
+export interface AstValueNode extends AstNode {
+    value: string | boolean | number | AstNode[];
+    dataType: string;
+}
+export interface AstVariableNode extends AstNode {
+    value: string;
+}
+export interface AstFunctionNode extends AstNode {
+    name: string;
+    arguments: AstNode[];
+}
+export interface AstProgramNode extends AstNode {
+    exp: string;
+    lang: string;
+    version: string;
+    body: AstNode;
+}

package/dist/models/ast.models.js

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

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,92 @@
+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;
+    return {
+        type: AST_TYPES.program,
+        exp: program,
+        lang: LANG_NAME,
+        version: PARSER_VERSION,
+        body: transformNode(program, startNode),
+    };
+}
+function transformNode(program, node) {
+    switch (node.name) {
+        case 'BinaryExpression':
+            return transformBinaryExpression(program, node);
+        case 'UnaryExpression':
+            return transformUnaryExpression(program, node);
+        case 'Function':
+            return transformFunctionExpression(program, node);
+        case 'Number':
+            return {
+                type: 'Literal',
+                dataType: 'number',
+                value: parseFloat(getNodeValue(program, node)),
+            };
+        case 'String':
+            return {
+                type: 'Literal',
+                dataType: 'string',
+                value: getNodeValue(program, node).slice(1, -1),
+            };
+        case 'Boolean':
+            return {
+                type: 'Literal',
+                dataType: 'boolean',
+                value: getNodeValue(program, node) === 'true',
+            };
+        case 'Array':
+            return {
+                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),
+            };
+        default:
+            return node.firstChild
+                ? transformNode(program, node.firstChild)
+                : undefined;
+    }
+}
+function transformBinaryExpression(program, node) {
+    const [left, right] = node.getChildren('Expression');
+    const operator = node.getChild('ArithOp');
+    return {
+        operator: getNodeValue(program, operator),
+        type: AST_TYPES.binaryExpression,
+        left: transformNode(program, left),
+        right: transformNode(program, right),
+    };
+}
+function transformUnaryExpression(program, node) {
+    const [right] = node.getChildren('Expression');
+    const operator = node.getChild('ArithOp');
+    return {
+        operator: getNodeValue(program, operator),
+        type: AST_TYPES.unaryExpression,
+        right: transformNode(program, right),
+    };
+}
+function transformFunctionExpression(program, node) {
+    const args = node.getChild('FunctionArguments');
+    const nodeValue = node.getChild('FunctionIdentifier');
+    return {
+        type: AST_TYPES.functionCall,
+        name: getNodeValue(program, nodeValue),
+        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[];
+    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/dist/utils/utils.d.ts

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

package/dist/utils/utils.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.2",
+  "version": "0.1.0",
   "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,14 +30,35 @@
   "author": "Qrvey Inc",
   "homepage": "https://bitbucket.org/qrvey/qrvey_formula_lang#readme",
   "dependencies": {
-    "@codemirror/language": "^6.6.0",
-    "@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"
+    }
   }
-}
+}