dsl-to-sql 1.0.0-fabric-1p-development.1

package/tests/mocks/MockQueryResolver.ts

@@ -0,0 +1,14 @@
+import { QueryResolver, FilterResolverParams } from '../../src';
+import { buildFilterCondition } from '../../src/filters/FilterConditionBuilder';
+
+export class MockQueryResolver implements QueryResolver {
+  private tableName: string;
+
+  constructor(tableName: string) {
+    this.tableName = tableName;
+  }
+
+  filterResolver(params: FilterResolverParams): string {
+    return buildFilterCondition(this.tableName, params.filterConfig);
+  }
+}

package/tests/sanity.test.ts

@@ -0,0 +1,146 @@
+import { createJsToSqlParser } from '../src/js-lib/JsToSqlParser';
+import { MDM_COLUMN_TYPE, ParseContext } from '../src/js-lib/ParseContext';
+
+describe('sanity', () => {
+  test('should create sql query from formula for project status tracking', () => {
+    const formula = `IF(
+            AND(DueDate < TODAY(), Status != "Completed"), "Overdue", 
+            IF(AND(StartDate <= TODAY(), DueDate >= TODAY(), Status != "Completed"), "In Progress", 
+            IF(Status == "Completed", "Completed", "Not Started")))`;
+    const expectedSql = `CASE WHEN [DueDate] < CURRENT_DATE AND [Status] != 'Completed' THEN 'Overdue' WHEN [StartDate] <= CURRENT_DATE AND [DueDate] >= CURRENT_DATE AND [Status] != 'Completed' THEN 'In Progress' WHEN [Status] = 'Completed' THEN 'Completed' ELSE 'Not Started' END`;
+    const columnConfigMap = {
+      DueDate: {
+        columnName: 'DueDate',
+        columnType: MDM_COLUMN_TYPE.DATE,
+        columnMeta: { tableName: 'Project' },
+      },
+      Status: {
+        columnName: 'Status',
+        columnType: MDM_COLUMN_TYPE.TEXT,
+        columnMeta: { tableName: 'Project' },
+      },
+      StartDate: {
+        columnName: 'StartDate',
+        columnType: MDM_COLUMN_TYPE.DATE,
+        columnMeta: { tableName: 'Project' },
+      },
+    };
+    const context = new ParseContext({
+      columnConfigMap,
+      currentColumnId: 'ProjectStatus',
+      primaryKeyColumns: ['PK'],
+      tableName: 'Project',
+    });
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const resultSql = parser.toSql(ast);
+    expect(resultSql).toEqual(expectedSql);
+  });
+
+  test('should create sql query from formula for ROI', () => {
+    const formula = `IF(Revenue - Cost > 0, (Revenue - Cost) / Cost * 100, 0)`;
+    const expectedSql = `CASE WHEN (COALESCE([Revenue], 0) - COALESCE([Cost], 0)) > 0 THEN (COALESCE((CAST(COALESCE((COALESCE([Revenue], 0) - COALESCE([Cost], 0)), 0) AS FLOAT) / COALESCE([Cost], 0)), 0) * COALESCE(100, 0)) ELSE 0 END`;
+    const columnConfigMap = {
+      Revenue: {
+        columnName: 'Revenue',
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnMeta: { tableName: 'Investment' },
+      },
+      Cost: {
+        columnName: 'Cost',
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnMeta: { tableName: 'Investment' },
+      },
+    };
+    const context = new ParseContext({
+      columnConfigMap,
+      currentColumnId: 'ROI',
+      primaryKeyColumns: ['PK'],
+      tableName: 'Investment',
+    });
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const resultSql = parser.toSql(ast);
+    expect(resultSql).toEqual(expectedSql);
+  });
+
+  test('should create sql query from formula for priority sorting', () => {
+    const formula = `(IF(Deadline_Category == "Critical", 100, IF(Deadline_Category == "High", 70, IF(Deadline_Category == "Medium", 40, 10)))) +
+            (IF(Client_Tier == "Enterprise", 50, IF(Client_Tier == "Mid-Market", 30, 10))) +
+            (IF(Revenue_Impact > 100000, 50, IF(Revenue_Impact > 50000, 30, 10)))`;
+    const expectedSql = `(COALESCE((COALESCE(CASE WHEN [Deadline_Category] = 'Critical' THEN 100 WHEN [Deadline_Category] = 'High' THEN 70 WHEN [Deadline_Category] = 'Medium' THEN 40 ELSE 10 END, 0) + COALESCE(CASE WHEN [Client_Tier] = 'Enterprise' THEN 50 WHEN [Client_Tier] = 'Mid-Market' THEN 30 ELSE 10 END, 0)), 0) + COALESCE(CASE WHEN [Revenue_Impact] > 100000 THEN 50 WHEN [Revenue_Impact] > 50000 THEN 30 ELSE 10 END, 0))`;
+    const columnConfigMap = {
+      Revenue: {
+        columnName: 'Revenue',
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnMeta: { tableName: 'Revenue' },
+      },
+      Cost: {
+        columnName: 'Cost',
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnMeta: { tableName: 'Revenue' },
+      },
+      Deadline_Category: {
+        columnName: 'Deadline_Category',
+        columnType: MDM_COLUMN_TYPE.TEXT,
+        columnMeta: { tableName: 'Revenue' },
+      },
+      Client_Tier: {
+        columnName: 'Client_Tier',
+        columnType: MDM_COLUMN_TYPE.TEXT,
+        columnMeta: { tableName: 'Revenue' },
+      },
+      Revenue_Impact: {
+        columnName: 'Revenue_Impact',
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnMeta: { tableName: 'Revenue' },
+      },
+    };
+    const context = new ParseContext({
+      columnConfigMap,
+      currentColumnId: 'Priority',
+      primaryKeyColumns: ['PK'],
+      tableName: 'Revenue',
+    });
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const resultSql = parser.toSql(ast);
+    expect(resultSql).toEqual(expectedSql);
+  });
+
+  test('should create sql query from formula for date intelligence', () => {
+    const formula = `
+            DATEDIFF(TODAY(), Follow_Up_Date, 'days') + 
+            IF(Interaction_Count < 3, 10, 0) + 
+            IF(Lead_Source == "Referral", -5, 0)
+`;
+    const expectedSql = `(COALESCE((COALESCE(DATEDIFF(DAY, CURRENT_DATE, [Follow_Up_Date]), 0) + COALESCE(CASE WHEN [Interaction_Count] < 3 THEN 10 ELSE 0 END, 0)), 0) + COALESCE(CASE WHEN [Lead_Source] = 'Referral' THEN -5 ELSE 0 END, 0))`;
+    const columnConfigMap = {
+      Follow_Up_Date: {
+        columnName: 'Follow_Up_Date',
+        columnType: MDM_COLUMN_TYPE.DATE,
+        columnMeta: { tableName: 'Project' },
+      },
+      Interaction_Count: {
+        columnName: 'Interaction_Count',
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnMeta: { tableName: 'Project' },
+      },
+      Lead_Source: {
+        columnName: 'Lead_Source',
+        columnType: MDM_COLUMN_TYPE.TEXT,
+        columnMeta: { tableName: 'Project' },
+      },
+    };
+    const context = new ParseContext({
+      columnConfigMap,
+      currentColumnId: 'DateIntelligence',
+      primaryKeyColumns: ['PK'],
+      tableName: 'Project',
+    });
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const resultSql = parser.toSql(ast);
+    expect(resultSql).toEqual(expectedSql);
+  });
+});

package/tests/sql-lib/binary_expr.test.ts

@@ -0,0 +1,75 @@
+import { toBinaryExpression } from '../../src/sql-lib/binary_expr';
+import { toValue, DataType } from '../../src/sql-lib/literal';
+import { toColumnRef } from '../../src/sql-lib/column';
+
+describe('toBinaryExpression', () => {
+  test('should create a binary expression with two literals', () => {
+    const left = toValue(DataType.NUMBER, 10);
+    const right = toValue(DataType.NUMBER, 20);
+    const result = toBinaryExpression('+', left, right);
+
+    expect(result).toEqual({
+      type: 'binary_expr',
+      operator: '+',
+      left: { type: 'number', value: 10 },
+      right: { type: 'number', value: 20 },
+      parentheses: false,
+    });
+  });
+
+  test('should create a binary expression with column references', () => {
+    const left = toColumnRef('column1', 'table1');
+    const right = toColumnRef('column2', 'table1');
+    const result = toBinaryExpression('=', left, right);
+
+    expect(result).toEqual({
+      type: 'binary_expr',
+      operator: '=',
+      left: { type: 'column_ref', table: 'table1', column: 'column1', collate: undefined },
+      right: { type: 'column_ref', table: 'table1', column: 'column2', collate: undefined },
+      parentheses: false,
+    });
+  });
+
+  test('should create a binary expression with parentheses', () => {
+    const left = toValue(DataType.NUMBER, 5);
+    const right = toValue(DataType.NUMBER, 10);
+    const result = toBinaryExpression('*', left, right, true);
+
+    expect(result).toEqual({
+      type: 'binary_expr',
+      operator: '*',
+      left: { type: 'number', value: 5 },
+      right: { type: 'number', value: 10 },
+      parentheses: true,
+    });
+  });
+
+  test('should create a binary expression with mixed operand types', () => {
+    const left = toColumnRef('price');
+    const right = toValue(DataType.NUMBER, 100);
+    const result = toBinaryExpression('>', left, right);
+
+    expect(result).toEqual({
+      type: 'binary_expr',
+      operator: '>',
+      left: { type: 'column_ref', table: null, column: 'price', collate: undefined },
+      right: { type: 'number', value: 100 },
+      parentheses: false,
+    });
+  });
+
+  test('should create a binary expression with string literals', () => {
+    const left = toValue(DataType.STRING, 'hello');
+    const right = toValue(DataType.STRING, 'world');
+    const result = toBinaryExpression('||', left, right);
+
+    expect(result).toEqual({
+      type: 'binary_expr',
+      operator: '||',
+      left: { type: 'string', value: 'hello' },
+      right: { type: 'string', value: 'world' },
+      parentheses: false,
+    });
+  });
+});

package/tests/sql-lib/case.test.ts

@@ -0,0 +1,117 @@
+import { toCase } from '../../src/sql-lib/case';
+import { toWhen } from '../../src/sql-lib/when';
+import { toElse } from '../../src/sql-lib/else';
+import { toBinaryExpression } from '../../src/sql-lib/binary_expr';
+import { toValue, DataType } from '../../src/sql-lib/literal';
+import { toColumnRef } from '../../src/sql-lib/column';
+
+describe('toCase', () => {
+  test('should create a CASE expression with single WHEN-THEN-ELSE', () => {
+    const condition = toBinaryExpression('>', toColumnRef('amount'), toValue(DataType.NUMBER, 100));
+    const whenResult = toValue(DataType.STRING, 'High');
+    const elseResult = toValue(DataType.STRING, 'Low');
+
+    const whenClause = toWhen(condition, whenResult);
+    const elseClause = toElse(elseResult);
+
+    const result = toCase({
+      whenList: [whenClause],
+      elseResult: elseClause,
+    });
+
+    expect(result).toEqual({
+      type: 'case',
+      expr: null,
+      args: [
+        {
+          type: 'when',
+          cond: {
+            type: 'binary_expr',
+            operator: '>',
+            left: {
+              type: 'column_ref',
+              table: null,
+              column: 'amount',
+              collate: undefined,
+            },
+            right: { type: 'number', value: 100 },
+            parentheses: false,
+          },
+          result: { type: 'string', value: 'High' },
+        },
+        {
+          type: 'else',
+          result: { type: 'string', value: 'Low' },
+        },
+      ],
+    });
+  });
+
+  test('should create a CASE expression with multiple WHEN-THEN clauses', () => {
+    const condition1 = toBinaryExpression(
+      '>',
+      toColumnRef('amount'),
+      toValue(DataType.NUMBER, 1000),
+    );
+    const condition2 = toBinaryExpression(
+      '>',
+      toColumnRef('amount'),
+      toValue(DataType.NUMBER, 500),
+    );
+    const whenResult1 = toValue(DataType.STRING, 'Very High');
+    const whenResult2 = toValue(DataType.STRING, 'High');
+    const elseResult = toValue(DataType.STRING, 'Normal');
+
+    const whenClause1 = toWhen(condition1, whenResult1);
+    const whenClause2 = toWhen(condition2, whenResult2);
+    const elseClause = toElse(elseResult);
+
+    const result = toCase({
+      whenList: [whenClause1, whenClause2],
+      elseResult: elseClause,
+    });
+
+    expect(result).toEqual({
+      type: 'case',
+      expr: null,
+      args: [
+        {
+          type: 'when',
+          cond: {
+            type: 'binary_expr',
+            operator: '>',
+            left: {
+              type: 'column_ref',
+              table: null,
+              column: 'amount',
+              collate: undefined,
+            },
+            right: { type: 'number', value: 1000 },
+            parentheses: false,
+          },
+          result: { type: 'string', value: 'Very High' },
+        },
+        {
+          type: 'when',
+          cond: {
+            type: 'binary_expr',
+            operator: '>',
+            left: {
+              type: 'column_ref',
+              table: null,
+              column: 'amount',
+              collate: undefined,
+            },
+            right: { type: 'number', value: 500 },
+            parentheses: false,
+          },
+          result: { type: 'string', value: 'High' },
+        },
+        {
+          type: 'else',
+          result: { type: 'string', value: 'Normal' },
+        },
+      ],
+    });
+  });
+});

package/tests/sql-lib/column.test.ts

@@ -0,0 +1,87 @@
+import { toColumnRef, toColumn } from '../../src/sql-lib/column';
+import { toValue, DataType } from '../../src/sql-lib/literal';
+import { Binary } from '../../src/sql-types';
+
+describe('toColumnRef', () => {
+  test('should create a column reference without table name', () => {
+    const result = toColumnRef('amount');
+
+    expect(result).toEqual({
+      type: 'column_ref',
+      table: null,
+      column: 'amount',
+      collate: undefined,
+    });
+  });
+
+  test('should create a column reference with table name', () => {
+    const result = toColumnRef('amount', 'invoices');
+
+    expect(result).toEqual({
+      type: 'column_ref',
+      table: 'invoices',
+      column: 'amount',
+      collate: undefined,
+    });
+  });
+});
+
+describe('toColumn', () => {
+  test('should create a column without alias', () => {
+    const expr = toValue(DataType.NUMBER, 100);
+    const result = toColumn(expr);
+
+    expect(result).toEqual({
+      type: 'column',
+      expr: { type: 'number', value: 100 },
+      as: null,
+    });
+  });
+
+  test('should create a column with alias', () => {
+    const expr = toColumnRef('amount', 'invoices');
+    const result = toColumn(expr, 'invoice_amount');
+
+    expect(result).toEqual({
+      type: 'column',
+      expr: {
+        type: 'column_ref',
+        table: 'invoices',
+        column: 'amount',
+        collate: undefined,
+      },
+      as: 'invoice_amount',
+    });
+  });
+
+  test('should create a column from a complex expression', () => {
+    const columnRef = toColumnRef('price');
+    const numValue = toValue(DataType.NUMBER, 1.1);
+    const expr: Binary = {
+      type: 'binary_expr',
+      operator: '*',
+      left: columnRef,
+      right: numValue,
+      parentheses: false,
+    };
+
+    const result = toColumn(expr, 'price_with_tax');
+
+    expect(result).toEqual({
+      type: 'column',
+      expr: {
+        type: 'binary_expr',
+        operator: '*',
+        left: {
+          type: 'column_ref',
+          table: null,
+          column: 'price',
+          collate: undefined,
+        },
+        right: { type: 'number', value: 1.1 },
+        parentheses: false,
+      },
+      as: 'price_with_tax',
+    });
+  });
+});

package/tests/sql-lib/else.test.ts

@@ -0,0 +1,56 @@
+import { toElse } from '../../src/sql-lib/else';
+import { toValue, DataType } from '../../src/sql-lib/literal';
+import { toColumnRef } from '../../src/sql-lib/column';
+
+describe('toElse', () => {
+  test('should create an ELSE clause with a string literal', () => {
+    const result = toElse(toValue(DataType.STRING, 'Default'));
+
+    expect(result).toEqual({
+      type: 'else',
+      result: { type: 'string', value: 'Default' },
+    });
+  });
+
+  test('should create an ELSE clause with a number literal', () => {
+    const result = toElse(toValue(DataType.NUMBER, 0));
+
+    expect(result).toEqual({
+      type: 'else',
+      result: { type: 'number', value: 0 },
+    });
+  });
+
+  test('should create an ELSE clause with a column reference', () => {
+    const columnRef = toColumnRef('default_value', 'settings');
+    const result = toElse(columnRef);
+
+    expect(result).toEqual({
+      type: 'else',
+      result: {
+        type: 'column_ref',
+        table: 'settings',
+        column: 'default_value',
+        collate: undefined,
+      },
+    });
+  });
+
+  test('should create an ELSE clause with a boolean literal', () => {
+    const result = toElse(toValue(DataType.BOOLEAN, false));
+
+    expect(result).toEqual({
+      type: 'else',
+      result: { type: 'boolean', value: false },
+    });
+  });
+
+  test('should create an ELSE clause with a NULL literal', () => {
+    const result = toElse(toValue(DataType.NULL, null));
+
+    expect(result).toEqual({
+      type: 'else',
+      result: { type: 'null', value: null },
+    });
+  });
+});

package/tests/sql-lib/function.test.ts

@@ -0,0 +1,96 @@
+import { toFunction } from '../../src/sql-lib/function';
+import { toValue, DataType } from '../../src/sql-lib/literal';
+import { toColumnRef } from '../../src/sql-lib/column';
+import { ValueExpr } from 'node-sql-parser';
+
+describe('toFunction', () => {
+  test('should create a function with no arguments', () => {
+    const name = toValue(DataType.STRING, 'NOW');
+    const result = toFunction(name as ValueExpr<string>, []);
+
+    expect(result).toEqual({
+      type: 'function',
+      name: { name: [{ type: 'string', value: 'NOW' }] },
+      args: { type: 'expr_list', value: [] },
+    });
+  });
+
+  test('should create a function with a single argument', () => {
+    const name = toValue(DataType.STRING, 'ABS');
+    const arg = toValue(DataType.NUMBER, -10);
+    const result = toFunction(name as ValueExpr<string>, [arg]);
+
+    expect(result).toEqual({
+      type: 'function',
+      name: { name: [{ type: 'string', value: 'ABS' }] },
+      args: { type: 'expr_list', value: [{ type: 'number', value: -10 }] },
+    });
+  });
+
+  test('should create a function with multiple arguments', () => {
+    const name = toValue(DataType.STRING, 'CONCAT');
+    const arg1 = toValue(DataType.STRING, 'Hello');
+    const arg2 = toValue(DataType.STRING, 'World');
+    const result = toFunction(name as ValueExpr<string>, [arg1, arg2]);
+
+    expect(result).toEqual({
+      type: 'function',
+      name: { name: [{ type: 'string', value: 'CONCAT' }] },
+      args: {
+        type: 'expr_list',
+        value: [
+          { type: 'string', value: 'Hello' },
+          { type: 'string', value: 'World' },
+        ],
+      },
+    });
+  });
+
+  test('should create a function with column reference arguments', () => {
+    const name = toValue(DataType.STRING, 'SUM');
+    const arg = toColumnRef('amount', 'invoices');
+    const result = toFunction(name as ValueExpr<string>, [arg]);
+
+    expect(result).toEqual({
+      type: 'function',
+      name: { name: [{ type: 'string', value: 'SUM' }] },
+      args: {
+        type: 'expr_list',
+        value: [
+          {
+            type: 'column_ref',
+            table: 'invoices',
+            column: 'amount',
+            collate: undefined,
+          },
+        ],
+      },
+    });
+  });
+
+  test('should create a function with mixed argument types', () => {
+    const name = toValue(DataType.STRING, 'DATEADD');
+    const arg1 = toValue(DataType.STRING, 'day');
+    const arg2 = toValue(DataType.NUMBER, 7);
+    const arg3 = toColumnRef('date_column');
+    const result = toFunction(name as ValueExpr<string>, [arg1, arg2, arg3]);
+
+    expect(result).toEqual({
+      type: 'function',
+      name: { name: [{ type: 'string', value: 'DATEADD' }] },
+      args: {
+        type: 'expr_list',
+        value: [
+          { type: 'string', value: 'day' },
+          { type: 'number', value: 7 },
+          {
+            type: 'column_ref',
+            table: null,
+            column: 'date_column',
+            collate: undefined,
+          },
+        ],
+      },
+    });
+  });
+});

package/tests/sql-lib/literal.test.ts

@@ -0,0 +1,75 @@
+import { toValue, DataType } from '../../src/sql-lib/literal';
+
+describe('toValue', () => {
+  test('should create a number literal', () => {
+    const result = toValue(DataType.NUMBER, 42);
+
+    expect(result).toEqual({
+      type: 'number',
+      value: 42,
+    });
+  });
+
+  test('should create a string literal', () => {
+    const result = toValue(DataType.STRING, 'hello');
+
+    expect(result).toEqual({
+      type: 'string',
+      value: 'hello',
+    });
+  });
+
+  test('should create a boolean literal - true', () => {
+    const result = toValue(DataType.BOOLEAN, true);
+
+    expect(result).toEqual({
+      type: 'boolean',
+      value: true,
+    });
+  });
+
+  test('should create a boolean literal - false', () => {
+    const result = toValue(DataType.BOOLEAN, false);
+
+    expect(result).toEqual({
+      type: 'boolean',
+      value: false,
+    });
+  });
+
+  test('should create a null literal', () => {
+    const result = toValue(DataType.NULL, null);
+
+    expect(result).toEqual({
+      type: 'null',
+      value: null,
+    });
+  });
+
+  test('should handle decimal numbers', () => {
+    const result = toValue(DataType.NUMBER, 3.14159);
+
+    expect(result).toEqual({
+      type: 'number',
+      value: 3.14159,
+    });
+  });
+
+  test('should handle negative numbers', () => {
+    const result = toValue(DataType.NUMBER, -100);
+
+    expect(result).toEqual({
+      type: 'number',
+      value: -100,
+    });
+  });
+
+  test('should handle empty strings', () => {
+    const result = toValue(DataType.STRING, '');
+
+    expect(result).toEqual({
+      type: 'string',
+      value: '',
+    });
+  });
+});