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

package/eslint.config.js

@@ -0,0 +1,4 @@
+import { config } from "@repo/eslint-config";
+
+/** @type {import("eslint").Linter.Config} */
+export default config;

package/jest.config.ts

@@ -0,0 +1,44 @@
+import type { Config } from 'jest';
+
+const config: Config = {
+  verbose: true,
+  roots: ['<rootDir>/src', '<rootDir>/tests'],
+  testMatch: ['**/?(*.)+(spec|test).+(ts|tsx|js)'],
+  transform: {
+    '^.+\\.(ts|tsx)$': [
+      'ts-jest',
+      {
+        useESM: true,
+        tsconfig: 'tsconfig.json',
+        diagnostics: {
+          exclude: ['**'],
+        },
+      },
+    ],
+  },
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  moduleFileExtensions: ['js', 'jsx', 'ts', 'tsx'],
+  testEnvironment: 'node',
+  reporters: [
+    'default',
+    [
+      'jest-junit',
+      {
+        outputDirectory: '<rootDir>/test-output/report',
+        outputName: 'junit.xml',
+        suiteName: 'DSL to SQL Tests',
+      },
+    ],
+  ],
+  testTimeout: 30000,
+  displayName: 'DSL to SQL: Unit Tests',
+  collectCoverage: true,
+  collectCoverageFrom: ['src/**/*.{js,jsx,ts,tsx}', '!**/*.d.ts'],
+  coverageDirectory: 'coverage',
+  coverageReporters: ['html', 'text'],
+  extensionsToTreatAsEsm: ['.ts'],
+};
+
+export default config;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "dsl-to-sql",
+  "version": "1.0.0-fabric-1p-development.1",
+  "description": "Converts DSL formulas to SQL queries",
+  "type": "module",
+  "private": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check-types": "tsc --noEmit",
+    "lint": "eslint src/ --max-warnings 2337",
+    "test": "jest --detectOpenHandles"
+  },
+  "author": "Lumel",
+  "license": "MIT",
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@repo/eslint-config": "workspace:*",
+    "@repo/jest-presets": "workspace:*",
+    "@repo/typescript-config": "workspace:*",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^22.16.0",
+    "eslint": "^9.31.0",
+    "jest": "^29.7.0",
+    "jest-junit": "^16.0.0",
+    "node-sql-parser": "^5.3.13",
+    "ts-jest": "^29.1.0",
+    "tsdown": "^0.15.4",
+    "typescript": "^5.8.2"
+  },
+  "dependencies": {
+    "acorn": "^8.15.0",
+    "acorn-walk": "^8.3.4",
+    "xxhashjs": "^0.2.2"
+  }
+}

package/src/constants.ts

@@ -0,0 +1,247 @@
+// Column Types
+export enum ECustomColumnType {
+  TEXT = 1,
+  SINGLE_SELECT = 2,
+  MULTI_SELECT = 3,
+  DATE = 4,
+  COMMENTS = 5,
+  NUMBER = 6,
+  PERSON = 7,
+  TIME = 8,
+  LAST_UPDATED_BY = 9,
+  LAST_UPDATED_AT = 10,
+  CHECKBOX = 11,
+  DATETIME = 12,
+  DECIMAL = 13,
+  IMAGE = 14,
+  URL = 15,
+  EMAIL = 16,
+  FORMULA = 17,
+  BUTTON_COLUMN = 18,
+  CURRENCY = 19,
+  PHONE_NUMBER = 20,
+  RATING = 21,
+  ATTACHMENT = 22,
+  PERCENT_SLIDER = 23,
+  PERCENT = 24,
+}
+
+export enum EDataType {
+  STRING = 'string',
+  NUMBER = 'number',
+  DATE = 'date',
+  BOOLEAN = 'boolean',
+  NULL = 'null',
+}
+
+export type NullableValueType = EDataType | null;
+
+// Column Type - Value Type Mapping
+export const COLUMN_TYPE_TO_STRING: Record<ECustomColumnType, NullableValueType> = {
+  [ECustomColumnType.TEXT]: EDataType.STRING,
+  [ECustomColumnType.SINGLE_SELECT]: EDataType.STRING,
+  [ECustomColumnType.MULTI_SELECT]: EDataType.STRING,
+  [ECustomColumnType.COMMENTS]: EDataType.STRING,
+  [ECustomColumnType.URL]: EDataType.STRING,
+  [ECustomColumnType.EMAIL]: EDataType.STRING,
+  [ECustomColumnType.PERSON]: EDataType.STRING,
+  [ECustomColumnType.IMAGE]: EDataType.STRING,
+  [ECustomColumnType.ATTACHMENT]: EDataType.STRING,
+
+  [ECustomColumnType.NUMBER]: EDataType.NUMBER,
+  [ECustomColumnType.DECIMAL]: EDataType.NUMBER,
+  [ECustomColumnType.CURRENCY]: EDataType.NUMBER,
+  [ECustomColumnType.RATING]: EDataType.NUMBER,
+  [ECustomColumnType.PERCENT]: EDataType.NUMBER,
+  [ECustomColumnType.PERCENT_SLIDER]: EDataType.NUMBER,
+
+  [ECustomColumnType.DATE]: EDataType.DATE,
+  [ECustomColumnType.TIME]: EDataType.DATE,
+  [ECustomColumnType.DATETIME]: EDataType.DATE,
+  [ECustomColumnType.LAST_UPDATED_AT]: EDataType.DATE,
+
+  [ECustomColumnType.CHECKBOX]: EDataType.BOOLEAN,
+
+  // Null types
+  [ECustomColumnType.LAST_UPDATED_BY]: null,
+  [ECustomColumnType.FORMULA]: null,
+  [ECustomColumnType.BUTTON_COLUMN]: null,
+  [ECustomColumnType.PHONE_NUMBER]: null,
+};
+
+// Operators
+export const MATH_OPERATORS = new Set(['+', '-', '*', '/', '%']);
+export const COMPARISON_OPERATORS = new Set(['=', '==', '<', '<=', '>', '>=', '!=', '<>']);
+export const OPERATOR_MAP = new Map([['==', '=']]);
+
+// Date/Time functions
+const DATE_FUNCTIONS = [
+  'TODAY',
+  'CURRENT_DATE',
+  'GETDATE',
+  'CURRENT_TIMESTAMP',
+  'NOW',
+  'SYSDATE',
+  'DATEADD',
+  'DATEDIFF',
+  'EOMONTH',
+  'DATE',
+  'FROMEXCELDATE',
+] as const;
+
+// Numeric functions
+const NUMERIC_FUNCTIONS = [
+  'YEAR',
+  'MONTH',
+  'DAY',
+  'HOUR',
+  'MINUTE',
+  'SECOND',
+  'DATEDIFF_DAY',
+  'DATEDIFF_MONTH',
+  'DATEDIFF_YEAR',
+  'ABS',
+  'CEIL',
+  'CEILING',
+  'FLOOR',
+  'ROUND',
+  'RAND',
+  'RANDBETWEEN',
+  'POW',
+  'POWER',
+  'SQRT',
+  'LOG',
+  'LN',
+  'EXP',
+  'MOD',
+  'ODD',
+  'EVEN',
+  'NUMBERVALUE',
+  'VALUE',
+  'LEN',
+  'LENGTH',
+  'FIND',
+  'SEARCH',
+  'INDEXOF',
+] as const;
+
+// String functions
+const STRING_FUNCTIONS = [
+  'LOWER',
+  'UPPER',
+  'TRIM',
+  'LTRIM',
+  'RTRIM',
+  'SUBSTRING',
+  'SUBSTR',
+  'LEFT',
+  'RIGHT',
+  'REPLACE',
+  'CONCAT',
+  'CONCATENATE',
+  'TEXT',
+  'FORMAT',
+  'MID',
+  'REPT',
+  'UUID',
+  'TOSTRING',
+  'STRING',
+] as const;
+
+// Logical functions
+const LOGICAL_FUNCTIONS = [
+  'IF',
+  'IFS',
+  'SWITCH',
+  'IFNA',
+  'ISBLANK',
+  'ISEMPTY',
+  'ISNUMBER',
+  'ISNUMERIC',
+  'HAS',
+  'HASSOME',
+  'HASALL',
+  'IN',
+  'INCLUDES',
+  'CONTAINS',
+  'STARTSWITH',
+  'ENDSWITH',
+  'MATCHES',
+  'REGEXMATCH',
+] as const;
+
+// Aggregate functions
+const AGGREGATE_FUNCTIONS = [
+  'SUM',
+  'AVG',
+  'AVERAGE',
+  'AVERAGEXNEG',
+  'AVERAGEXZERO',
+  'AVERAGEXZERONEG',
+  'COUNT',
+  'COUNTDISTINCT',
+  'COUNTIF',
+  'SUMIF',
+  'AVERAGEIF',
+  'MIN',
+  'MAX',
+  'MEDIAN',
+  'MODE',
+  'PERCENTILE',
+  'QUARTILE',
+  'STDEV',
+  'STDEVP',
+  'VAR',
+  'VARP',
+] as const;
+
+// Other function types
+const PERCENT_FUNCTIONS = ['PCT', 'PERCENT'] as const;
+
+// Function - return type map
+export const FUNCTION_RETURN_TYPE: Record<string, EDataType> = Object.fromEntries([
+  ...DATE_FUNCTIONS.map((fn) => [fn, EDataType.DATE]),
+  ...NUMERIC_FUNCTIONS.map((fn) => [fn, EDataType.NUMBER]),
+  ...STRING_FUNCTIONS.map((fn) => [fn, EDataType.STRING]),
+  ...LOGICAL_FUNCTIONS.map((fn) => [fn, EDataType.BOOLEAN]),
+  ...AGGREGATE_FUNCTIONS.map((fn) => [fn, EDataType.NUMBER]),
+  ...PERCENT_FUNCTIONS.map((fn) => [fn, EDataType.NUMBER]),
+]);
+
+// SQL Expression Enums
+export enum ESqlDateExpression {
+  CURRENT_DATE = 'CURRENT_DATE',
+  GETDATE = 'GETDATE()',
+  CURRENT_TIMESTAMP = 'CURRENT_TIMESTAMP',
+  NOW = 'NOW()',
+  SYSDATE = 'SYSDATE',
+}
+
+export enum ESqlMathExpression {
+  RAND = 'RAND()',
+  NEWID = 'NEWID()',
+}
+
+export enum ESqlWindowExpression {
+  ROW_NUMBER = 'ROW_NUMBER()',
+  PERCENTILE_CONT = 'PERCENTILE_CONT',
+  COUNT = 'COUNT',
+}
+
+export type SqlExpression = ESqlDateExpression | ESqlMathExpression | ESqlWindowExpression;
+
+// Function Type Unions
+export type DateFunction = (typeof DATE_FUNCTIONS)[number];
+export type NumericFunction = (typeof NUMERIC_FUNCTIONS)[number];
+export type StringFunction = (typeof STRING_FUNCTIONS)[number];
+export type LogicalFunction = (typeof LOGICAL_FUNCTIONS)[number];
+export type AggregateFunction = (typeof AGGREGATE_FUNCTIONS)[number];
+export type PercentFunction = (typeof PERCENT_FUNCTIONS)[number];
+
+export type FunctionType =
+  | DateFunction
+  | NumericFunction
+  | StringFunction
+  | LogicalFunction
+  | AggregateFunction
+  | PercentFunction;

package/src/epm-query-builder/EpmQueryBuilder.ts

@@ -0,0 +1,27 @@
+// entry point: routes options to the correct dialect builder
+import { DuckDbQueryBuilder } from '@epm-query-builder/dialects/duckdb/DuckDbQueryBuilder';
+import { DATABASE_TYPES } from '@epm-query-builder/constants/Database';
+import { IDatabaseQueryBuilder } from '@epm-query-builder/interfaces';
+import { EpmQueryBuilderOptions } from '@epm-query-builder/types/query-builder-types';
+
+export class EpmQueryBuilder {
+  private readonly impl: IDatabaseQueryBuilder;
+
+  constructor(options: EpmQueryBuilderOptions) {
+    const databaseType = options.databaseDetails?.databaseType as string;
+
+    switch (databaseType?.toLowerCase()) {
+      // add other database types here
+      case DATABASE_TYPES.DUCKDB:
+        this.impl = new DuckDbQueryBuilder(options);
+        break;
+      default:
+        throw new Error(`Unsupported database type: ${databaseType}`);
+    }
+  }
+
+  build(): string {
+    // delegates to dialect implementation; keep method name stable for public api
+    return this.impl.generateQuery();
+  }
+}

package/src/epm-query-builder/base/BaseAdvancedAggregations.ts

@@ -0,0 +1,161 @@
+import {
+  EpmQueryBuilderOptions,
+  MeasureConfig,
+} from '@epm-query-builder/types/query-builder-types';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+
+export class BaseAdvancedAggregations {
+  protected options: EpmQueryBuilderOptions;
+
+  constructor(options: EpmQueryBuilderOptions) {
+    this.options = options;
+  }
+
+  buildArrayAggregation(measure: MeasureConfig, distinct = false): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+    const distinctClause = distinct ? 'DISTINCT ' : '';
+
+    return `ARRAY_AGG(${distinctClause}${columnRef})`;
+  }
+
+  buildStringAggregation(measure: MeasureConfig, separator = ', ', distinct = false): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+    const distinctClause = distinct ? 'DISTINCT ' : '';
+
+    return `STRING_AGG(${distinctClause}${columnRef}, '${separator}')`;
+  }
+
+  buildJsonAggregation(measure: MeasureConfig, distinct = false): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+    const distinctClause = distinct ? 'DISTINCT ' : '';
+
+    return `JSON_AGG(${distinctClause}${columnRef})`;
+  }
+
+  buildJsonObjectAggregation(keyColumn: string, valueColumn: string): string {
+    return `JSON_OBJECT_AGG(${keyColumn}, ${valueColumn})`;
+  }
+
+  buildApproximateCountDistinct(measure: MeasureConfig): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+
+    return `APPROX_COUNT_DISTINCT(${columnRef})`;
+  }
+
+  buildCorrelation(measure1: MeasureConfig, measure2: MeasureConfig): string {
+    const columnRef1 = BaseUtilities.buildColumnReference(
+      measure1.tableName,
+      measure1.columnName || measure1.id,
+    );
+    const columnRef2 = BaseUtilities.buildColumnReference(
+      measure2.tableName,
+      measure2.columnName || measure2.id,
+    );
+
+    return `CORR(${columnRef1}, ${columnRef2})`;
+  }
+
+  buildCovariance(measure1: MeasureConfig, measure2: MeasureConfig, population = false): string {
+    const columnRef1 = BaseUtilities.buildColumnReference(
+      measure1.tableName,
+      measure1.columnName || measure1.id,
+    );
+    const columnRef2 = BaseUtilities.buildColumnReference(
+      measure2.tableName,
+      measure2.columnName || measure2.id,
+    );
+    const functionName = population ? 'COVAR_POP' : 'COVAR_SAMP';
+
+    return `${functionName}(${columnRef1}, ${columnRef2})`;
+  }
+
+  buildRegressionStats(
+    xMeasure: MeasureConfig,
+    yMeasure: MeasureConfig,
+    statType: 'SLOPE' | 'INTERCEPT' | 'R2',
+  ): string {
+    const xColumnRef = BaseUtilities.buildColumnReference(
+      xMeasure.tableName,
+      xMeasure.columnName || xMeasure.id,
+    );
+    const yColumnRef = BaseUtilities.buildColumnReference(
+      yMeasure.tableName,
+      yMeasure.columnName || yMeasure.id,
+    );
+
+    switch (statType) {
+      case 'SLOPE':
+        return `REGR_SLOPE(${yColumnRef}, ${xColumnRef})`;
+      case 'INTERCEPT':
+        return `REGR_INTERCEPT(${yColumnRef}, ${xColumnRef})`;
+      case 'R2':
+        return `REGR_R2(${yColumnRef}, ${xColumnRef})`;
+      default:
+        return `REGR_SLOPE(${yColumnRef}, ${xColumnRef})`;
+    }
+  }
+
+  buildBitAggregations(measure: MeasureConfig, operation: 'AND' | 'OR' | 'XOR'): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+
+    switch (operation) {
+      case 'AND':
+        return `BIT_AND(${columnRef})`;
+      case 'OR':
+        return `BIT_OR(${columnRef})`;
+      case 'XOR':
+        return `BIT_XOR(${columnRef})`;
+      default:
+        return `BIT_AND(${columnRef})`;
+    }
+  }
+
+  buildBoolAggregations(measure: MeasureConfig, operation: 'AND' | 'OR'): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+
+    switch (operation) {
+      case 'AND':
+        return `BOOL_AND(${columnRef})`;
+      case 'OR':
+        return `BOOL_OR(${columnRef})`;
+      default:
+        return `BOOL_AND(${columnRef})`;
+    }
+  }
+
+  buildGeometricMean(measure: MeasureConfig): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+
+    return `EXP(AVG(LN(${columnRef})))`;
+  }
+
+  buildHarmonicMean(measure: MeasureConfig): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+
+    return `COUNT(${columnRef}) / SUM(1.0 / ${columnRef})`;
+  }
+}