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

package/src/filters/FilterConditionBuilder.ts

@@ -0,0 +1,114 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { getEntityNameFormatter } from '../utils';
+import { FilterConfig, LogicalCombinator, Rule, RuleGroup } from './filter-types';
+
+const FILTER_OPEATOR_MAP: Record<string, (columnName: string, value: any) => string> = {
+  '=': equalsFn,
+  IN: isOneOfFn,
+  '<>': notEqualsFn,
+  LIKE: containsFn,
+  'NOT LIKE': doesNotContainFn,
+  'IS NULL': emptyFn,
+  'IS NOT NULL': notEmptyFn,
+  '<': lessThanFn,
+  '<=': lessThanOrEqualFn,
+  '>': greaterThanFn,
+  '>=': greaterThanOrEqualFn,
+};
+
+/**
+ * Builds the filter condition for the selected columns
+ */
+export function buildFilterCondition(tableName: string, filterConfig: FilterConfig): string {
+  const { rules, combinator } = filterConfig;
+  const entityNameFormatter = getEntityNameFormatter();
+  return recursiveFilterBuilder(tableName, rules, combinator, entityNameFormatter);
+}
+
+/**
+ * Recursively builds the filter condition
+ */
+function recursiveFilterBuilder(
+  tableName: string,
+  filters: (Rule | RuleGroup)[],
+  combinator: LogicalCombinator,
+  entityNameFormatter: (name: string) => string,
+): string {
+  return filters
+    .map((filter) => {
+      if ((filter as RuleGroup).rules) {
+        const ruleGroup = filter as RuleGroup;
+        return recursiveFilterBuilder(
+          tableName,
+          ruleGroup.rules,
+          ruleGroup.combinator,
+          entityNameFormatter,
+        );
+      }
+
+      const rule = filter as Rule;
+      const opFn = FILTER_OPEATOR_MAP[rule.operator];
+      if (!opFn) {
+        throw new Error(`Unsupported operator: ${rule.operator}`);
+      }
+      const [sanitizedColumnName, sanitizedValue] = sanitizeValue(
+        entityNameFormatter(rule.column),
+        rule.value,
+      );
+      return opFn(sanitizedColumnName, sanitizedValue);
+    })
+    .join(` ${combinator.toUpperCase()} `);
+}
+
+function sanitizeValue(columnName: string, value: any): [string, string] {
+  if (typeof value === 'string') {
+    return [`LOWER(${columnName})`, `'${value.toLowerCase()}'`];
+  }
+  return [columnName, value];
+}
+
+function equalsFn(columnName: string, value: any): string {
+  return `${columnName} = ${value}`;
+}
+
+function notEqualsFn(columnName: string, value: any): string {
+  return `${columnName} <> ${value} OR ${columnName} IS NULL`;
+}
+
+function containsFn(columnName: string, value: any): string {
+  return `${columnName} LIKE %${value}%`;
+}
+
+function doesNotContainFn(columnName: string, value: any): string {
+  return `${columnName} NOT LIKE %${value}% OR ${columnName} IS NULL`;
+}
+
+function emptyFn(columnName: string): string {
+  return `${columnName} IS NULL`;
+}
+
+function notEmptyFn(columnName: string): string {
+  return `${columnName} IS NOT NULL`;
+}
+
+function lessThanFn(columnName: string, value: any): string {
+  return `${columnName} < ${value} OR ${columnName} IS NULL`;
+}
+
+function lessThanOrEqualFn(columnName: string, value: any): string {
+  return `${columnName} <= ${value} OR ${columnName} IS NULL`;
+}
+
+function greaterThanFn(columnName: string, value: any): string {
+  return `${columnName} > ${value}`;
+}
+
+function greaterThanOrEqualFn(columnName: string, value: any): string {
+  return `${columnName} >= ${value}`;
+}
+
+function isOneOfFn(columnName: string, value: string): string {
+  const values = value.split(',').map((v) => `'${v.trim()}'`);
+  return `${columnName} IN (${values.join(', ')})`;
+}

package/src/filters/filter-types.ts

@@ -0,0 +1,133 @@
+import {
+  EDateRangeRelativeFilterCondition,
+  EDateRangeRelativePeriodFilterCondition,
+} from '../query-builder/SuperFilterBuilder';
+
+// Logical combinator for combining multiple rules
+export type LogicalCombinator = 'and' | 'or';
+
+// Simple filter rule (leaf node)
+export type Rule = {
+  operator: string;
+  value: string | number | boolean | (string | number)[];
+  column: string;
+  isCategoryFilter?: boolean;
+  topNDataTarget?: string;
+};
+
+// Group of rules (branch node)
+export type RuleGroup = {
+  rules: Array<Rule>;
+  combinator: LogicalCombinator;
+};
+
+// Root filter configuration
+export type FilterConfig = {
+  rules: Array<Rule | RuleGroup>;
+  combinator: LogicalCombinator;
+  not: boolean;
+};
+
+export type FilterType = 'VALUES' | 'RANGE' | 'DATE' | 'RANKING';
+
+export interface IValueFilter {
+  id: string[];
+  label: string[];
+}
+
+export interface IRangeFilter {
+  from?: string;
+  to?: string;
+  logicalOperator?: 'AND' | 'OR';
+  fromCondition?: string;
+  toCondition?: string;
+}
+
+export interface IRankingFilter {
+  type: 'TOP' | 'BOTTOM' | 'BOTH';
+  rankByColumnId: string;
+  rankByColumnName: string;
+  rankByColumnType: string;
+  rankByTableName: string;
+  rankByAggregationType: string;
+  value: number;
+  isPercentage: boolean;
+}
+
+export type IDateTimeFilter = {
+  relativeDateFilter?: EDateRangeRelativeFilterCondition;
+  period?: EDateRangeRelativePeriodFilterCondition;
+  duration?: number;
+  includeToday?: boolean;
+  fiscalYearStartMonth?: number;
+};
+
+export interface IGroupFilter {
+  columnIds: string[];
+  tableNames: string[];
+  columnNames: string[];
+  dataType: string[];
+  filterType: FilterType;
+  sourceType?: string[];
+  columnType?: string[];
+  columnDataType?: string[];
+  valuesFilterApplicationType?: 'exclude' | 'include';
+  valuesFilter?: IValueFilter[];
+  logicalOperator?: 'AND' | 'OR';
+  aggregationType?: string[];
+  rangeFilter?: IRangeFilter[];
+  dateTimeFilter?: IDateTimeFilter;
+  rankingFilter?: IRankingFilter[];
+  searchConfig?: { matchCase: boolean; searchString: string };
+}
+
+export interface ISuperFilterConfig {
+  groupId: string;
+  groupLabel: string;
+  condition: 'AND' | 'OR';
+  children: ({ filters: IGroupFilter } | ISuperFilterConfig)[];
+}
+
+export type RelationshipMapping = {
+  joinType: string;
+  id: string;
+  schema: string;
+  table: string;
+  joinId: string;
+  label: string;
+  alias: string;
+};
+
+export type JoinExpressions = {
+  alias: string;
+  joinRelation: RelationshipMapping[];
+};
+
+export type RangeOperator =
+  | 'IS'
+  | 'IS_NOT'
+  | 'IS_BLANK'
+  | 'IS_NOT_BLANK'
+  | 'IS_AFTER'
+  | 'IS_BEFORE'
+  | 'IS_ON_OR_AFTER'
+  | 'IS_ON_OR_BEFORE'
+  | 'IS_LESS_THAN'
+  | 'IS_LESS_THAN_OR_EQUAL_TO'
+  | 'IS_GREATER_THAN'
+  | 'IS_GREATER_THAN_OR_EQUAL_TO'
+  | 'CONTAINS'
+  | 'DOES_NOT_CONTAIN'
+  | 'STARTS_WITH'
+  | 'DOES_NOT_START_WITH';
+
+export interface IManualFilterOption {
+  displayName?: string;
+  value: string | number | boolean;
+  id: string;
+}
+
+export interface IManualFilterConfig {
+  column: string;
+  options: IManualFilterOption[];
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from './query-builder/QueryBuilder';
+export * from './js-lib/ParseContext';
+export * from './js-lib/JsToSqlParser';
+export * from './utils';
+export * from './query-builder/SuperFilterBuilder';
+export * from './filters/filter-types';
+
+// epm query builder
+export { EpmQueryBuilder } from '@epm-query-builder/EpmQueryBuilder';
+export type { EpmQueryBuilderOptions } from '@epm-query-builder/types/query-builder-types';

package/src/js-lib/JsToSqlParser.ts

@@ -0,0 +1,217 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { ParseContext, ResolvedExpressionType, SqlQueryProps } from './ParseContext';
+import { VisitorInterface } from './db/base/VisitorInterface';
+import * as acorn from 'acorn';
+import * as walk from 'acorn-walk';
+import { CallExpressionVisitor } from './db/base/CallExpressionVisitor';
+import { IdentifierVisitor } from './db/base/IdentifierVisitor';
+import { LiteralVisitor } from './db/base/LiteralVisitor';
+import { BinaryExpressionVisitor } from './db/base/BinaryExpressionVisitor';
+import { ArrayExpressionVisitor } from './db/base/ArrayExpressionVisitor';
+import { UnaryExpressionVisitor } from './db/base/UnaryExpressionVisitor';
+import { ProgramVisitor } from './db/base/ProgramVisitor';
+import { MemberExpressionVisitor } from './db/base/MemberExpressionVisitor';
+import { generateSqlQuery } from '../sql_query_gen';
+import { AssignmentExpressionVisitor } from './db/base/AssignmentExpressionVisitor';
+
+export type ResolvedFormulaProps = {
+  returnType: string | undefined;
+  isValid: boolean;
+  error: string | undefined;
+  sqlQueryProps: SqlQueryProps;
+  deps: string[];
+};
+
+/**
+ * Factory function to create database specific parser
+ */
+export function createJsToSqlParser(context: ParseContext): JsToSqlParser {
+  // Handles functions based on fabricsql type
+  return new JsToSqlParser(context);
+}
+
+export type VisitorConfig = {
+  callExpression?: VisitorInterface<acorn.CallExpression>;
+  identifier?: VisitorInterface<acorn.Identifier>;
+  literal?: VisitorInterface<acorn.Literal>;
+  binaryExpression?: VisitorInterface<acorn.BinaryExpression>;
+  arrayExpression?: VisitorInterface<acorn.ArrayExpression>;
+  unaryExpression?: VisitorInterface<acorn.UnaryExpression>;
+  program?: VisitorInterface<acorn.Program>;
+  memberExpression?: VisitorInterface<acorn.MemberExpression>;
+  assignmentExpression?: VisitorInterface<acorn.AssignmentExpression>;
+};
+
+/**
+ * Parses a JavaScript formula and returns the corresponding SQL AST.
+ * - For Database specific overrides, implement the corresponding visitor in `db` directory and
+ *   pass it to the constructor as part of the `config` parameter.
+ * - Use Factory function to compose parser for specific database
+ */
+export class JsToSqlParser {
+  private context: ParseContext;
+  private callExpression: VisitorInterface<acorn.CallExpression>;
+  private identifier: VisitorInterface<acorn.Identifier>;
+  private literal: VisitorInterface<acorn.Literal>;
+  private binaryExpression: VisitorInterface<acorn.BinaryExpression>;
+  private arrayExpression: VisitorInterface<acorn.ArrayExpression>;
+  private unaryExpression: VisitorInterface<acorn.UnaryExpression>;
+  private program: VisitorInterface<acorn.Program>;
+  private memberExpression: VisitorInterface<acorn.MemberExpression>;
+  private assignmentExpression: VisitorInterface<acorn.AssignmentExpression>;
+
+  constructor(context: ParseContext, config: VisitorConfig = {}) {
+    this.context = context;
+    this.callExpression = config.callExpression || new CallExpressionVisitor();
+    this.identifier = config.identifier || new IdentifierVisitor();
+    this.literal = config.literal || new LiteralVisitor();
+    this.binaryExpression = config.binaryExpression || new BinaryExpressionVisitor();
+    this.arrayExpression = config.arrayExpression || new ArrayExpressionVisitor();
+    this.unaryExpression = config.unaryExpression || new UnaryExpressionVisitor();
+    this.program = config.program || new ProgramVisitor();
+    this.memberExpression = config.memberExpression || new MemberExpressionVisitor();
+    this.assignmentExpression = config.assignmentExpression || new AssignmentExpressionVisitor();
+  }
+
+  parse(formula: string): any {
+    // Parse the formula
+    const formulaText = this.processFormulaText(formula);
+    const jsAst = acorn.parse(formulaText, { ecmaVersion: 2020 });
+
+    // Traverse the AST in pre-order to check for 'if' statements
+    this.detectIfCondition(jsAst);
+
+    // Traverse the AST and generate SQL AST
+    walk.recursive(jsAst, this.context.reset(), {
+      CallExpression: (node, state, c) => {
+        c(node.callee, state);
+        node.arguments.forEach((arg) => c(arg, state));
+        this.callExpression.visitor(node, state);
+      },
+      Identifier: (node, state) => {
+        this.identifier.visitor(node, state);
+      },
+      Literal: (node, state) => {
+        this.literal.visitor(node, state);
+      },
+      BinaryExpression: (node, state, c) => {
+        c(node.left, state);
+        c(node.right, state);
+        this.binaryExpression.visitor(node, state);
+      },
+      AssignmentExpression: (node, state, c) => {
+        c(node.left, state);
+        c(node.right, state);
+        this.assignmentExpression.visitor(node, state);
+      },
+      ArrayExpression: (node, state, c) => {
+        node.elements.forEach((el) => {
+          if (el !== null) c(el, state);
+        });
+        this.arrayExpression.visitor(node, state);
+      },
+      UnaryExpression: (node, state, c) => {
+        c(node.argument, state);
+        this.unaryExpression.visitor(node, state);
+      },
+      MemberExpression: (node, state, c) => {
+        c(node.object, state);
+        if (node.computed) c(node.property, state);
+        this.memberExpression.visitor(node, state);
+      },
+      Program: (node, state, c) => {
+        node.body.forEach((statement) => c(statement, state));
+        this.program.visitor(node, state);
+      },
+    });
+    const sqlAst = this.context.getLastEvaluatedValue();
+    return sqlAst;
+  }
+
+  /**
+   * Converts the SQL AST to a SQL query string
+   */
+  toSql(sqlAst: any): string {
+    return generateSqlQuery(sqlAst);
+  }
+
+  /**
+   * Creates appropriate SQL query props based on the SQL AST
+   */
+  toSqlProps(sqlAst: any): SqlQueryProps {
+    const sqlQueryStr = this.toSql(sqlAst);
+
+    if (this.context.cteCount > 0) {
+      return {
+        resolvedExpression: {
+          type: ResolvedExpressionType.CTE,
+          cteName: `cte_${this.context.currentColumnId}`,
+          value: [sqlQueryStr],
+        },
+      };
+    }
+
+    return {
+      resolvedExpression: {
+        type: ResolvedExpressionType.COLUMN,
+        value: [sqlQueryStr],
+      },
+    };
+  }
+
+  /**
+   * Returns the resolved formula props for current column along with the dependencies
+   */
+  getResolvedFormulaProps(sqlAst: any): ResolvedFormulaProps {
+    const sqlQueryProps = this.toSqlProps(sqlAst);
+    return {
+      sqlQueryProps,
+      deps: Array.from(this.context.getColumnDeps()),
+      returnType: this.context.returnType,
+      isValid: this.context.isValid,
+      error: this.context.error,
+    };
+  }
+
+  /**
+   * Pre walk and detect if the jsAst has 'if'
+   */
+  private detectIfCondition(jsAst: acorn.Node): void {
+    walk.simple(jsAst, {
+      CallExpression: (node: acorn.CallExpression) => {
+        if (node.callee.type === 'Identifier' && node.callee.name.toUpperCase() === 'IF') {
+          this.context.ifCondition = true;
+        }
+      },
+    });
+  }
+
+  /**
+   *  Extracts and normalizes formula by adding parentheses to reserved function names
+   */
+  private processFormulaText(formula: string): string {
+    // Extract formula from {{ ... }} or use the string as-is
+    const formulaText = formula?.match(/{{([^}]*)}}/)?.[1] ?? formula;
+
+    // Reserved function names to patch
+    const reservedFunctions = ['NOW', 'TODAY', 'UUID', 'RAND'];
+
+    // Patch function names not followed by '(' to add ()
+    let patched = formulaText;
+    for (const fn of reservedFunctions) {
+      const regex = new RegExp(`\\b${fn}\\b(?!\\s*\\()`, 'gi');
+      patched = patched.replace(regex, `${fn}()`);
+    }
+
+    if (formulaText.includes('FOREACH')) {
+      patched = this.removeForeach(formula);
+    }
+    return patched;
+  }
+
+  private removeForeach(input: string): string {
+    const foreachRegex = /FOREACH\(([^,]*),([^()]*)\)/g;
+    return input.replace(foreachRegex, '$2');
+  }
+}

package/src/js-lib/ParseContext.ts

@@ -0,0 +1,149 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import * as acorn from 'acorn';
+import {
+  getEntityNameFormatter,
+  getFormulaIdColumnMap,
+  getDeprecatedFormulaIdColumnMap,
+} from '../utils';
+
+export enum MDM_COLUMN_TYPE {
+  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,
+}
+
+export enum ResolvedExpressionType {
+  COLUMN = 'columnExpr',
+  CTE = 'cteExpr',
+}
+
+export type CteExpression = {
+  type: ResolvedExpressionType.CTE;
+  cteName: string;
+  value: string[];
+};
+
+export type ColumnExpression = {
+  type: ResolvedExpressionType.COLUMN;
+  value: string[];
+};
+
+export type SqlQueryProps = {
+  resolvedExpression: ColumnExpression | CteExpression;
+};
+
+export type ColumnMeta = {
+  sqlQueryProps?: SqlQueryProps;
+  computationOrder?: number;
+  deps?: string[];
+  [key: string]: any;
+};
+
+// This is mock interface for column config. Actual type comes from InfoRiverMDM repo from type `IMDMColumnConfigWithParsedMeta`
+export interface IMDMColumnConfigWithParsedMeta {
+  columnName: string;
+  columnType: MDM_COLUMN_TYPE;
+  columnMeta: ColumnMeta;
+}
+
+export type TColumnConfigMap = Record<string, IMDMColumnConfigWithParsedMeta>;
+
+export type ParseContextProps = {
+  columnConfigMap: TColumnConfigMap;
+  currentColumnId: string;
+  primaryKeyColumns: string[];
+  tableName: string;
+};
+
+export class ParseContext {
+  private lastEvaluatedValue: any;
+  private _cteCount: number = 0;
+  public formulaIdColumnMap: Record<string, string>;
+  public deprecatedFormulaColumnMap: Record<string, string>;
+  public ifCondition: boolean = false;
+  private readonly columnDeps: Set<string>;
+  public readonly state: Map<string, any>;
+  public readonly columnConfigMap: TColumnConfigMap;
+  public readonly currentColumnId: string;
+  public readonly primaryKeyColumns: string[];
+  public readonly tableName: string;
+  public readonly entityNameFormatter: (name: string) => string;
+  public returnType: string | undefined;
+  public isValid: boolean = true;
+  public error: string | undefined;
+
+  constructor(props: ParseContextProps) {
+    this.state = new Map();
+    this.lastEvaluatedValue = null;
+    this.columnConfigMap = props.columnConfigMap;
+    this.formulaIdColumnMap = getFormulaIdColumnMap(props.columnConfigMap);
+    this.deprecatedFormulaColumnMap = getDeprecatedFormulaIdColumnMap(props.columnConfigMap);
+    this.currentColumnId = props.currentColumnId;
+    this.primaryKeyColumns = props.primaryKeyColumns;
+    this.tableName = props.tableName;
+    this.columnDeps = new Set<string>();
+    this.entityNameFormatter = getEntityNameFormatter();
+  }
+
+  /**
+   * Reset the parse context
+   */
+  reset(): ParseContext {
+    this.lastEvaluatedValue = null;
+    this.state.clear();
+    this.columnDeps.clear();
+    return this;
+  }
+
+  get(node: acorn.Node): any {
+    return this.state.get(this.getId(node));
+  }
+
+  set(node: acorn.Node, value: any): void {
+    this.lastEvaluatedValue = value;
+    this.state.set(this.getId(node), value);
+  }
+
+  getId(node: acorn.Node): string {
+    return `${node.start}_${node.end}`;
+  }
+
+  getLastEvaluatedValue(): any {
+    return this.lastEvaluatedValue;
+  }
+
+  getColumnCount(): number {
+    return Object.keys(this.columnConfigMap).length;
+  }
+
+  addColumnDep(columnName: string): void {
+    this.columnDeps.add(columnName);
+  }
+
+  getColumnDeps(): Set<string> {
+    return this.columnDeps;
+  }
+
+  get cteCount(): number {
+    return this._cteCount;
+  }
+
+  incrementCTECount(): void {
+    this._cteCount++;
+  }
+}

package/src/js-lib/db/base/ArrayExpressionVisitor.ts

@@ -0,0 +1,16 @@
+import { VisitorInterface } from './VisitorInterface';
+import * as acorn from 'acorn';
+import { ParseContext } from '../../ParseContext';
+
+export class ArrayExpressionVisitor implements VisitorInterface<acorn.ArrayExpression> {
+  /**
+   * visitor needs to be implemented as arrow function to avoid `this` binding issue since it will be
+   * passed to `acorn-walk` library
+   */
+  public visitor = (node: acorn.ArrayExpression, context: ParseContext) => {
+    context.set(
+      node,
+      node.elements.map((arg) => context.get(arg as acorn.Node)),
+    );
+  };
+}

package/src/js-lib/db/base/AssignmentExpressionVisitor.ts

@@ -0,0 +1,34 @@
+import { VisitorInterface } from './VisitorInterface';
+import * as acorn from 'acorn';
+import { ParseContext } from '../../ParseContext';
+import { toBinaryExpression } from '../../../sql-lib/binary_expr';
+import { PctObject } from '../../objects/PctObject';
+import { ExpressionValue } from '../../../sql-types';
+import { getArgType } from '@/utils';
+
+export class AssignmentExpressionVisitor implements VisitorInterface<acorn.AssignmentExpression> {
+  public visitor = (node: acorn.AssignmentExpression, context: ParseContext) => {
+    const operator = node.operator;
+
+    // We're only treating "=" as comparison
+    if (operator !== '=') {
+      context.isValid = false;
+      context.error = `Unsupported assignment operator: "${operator}"`;
+      return;
+    }
+    const lhs = context.get(node.left) as ExpressionValue;
+    const rhs = context.get(node.right) as ExpressionValue;
+    if (getArgType(lhs, context) !== getArgType(rhs, context)) {
+      context.isValid = false;
+      context.error = `Expected both sides dataType to be same`;
+    }
+
+    if (rhs instanceof PctObject) {
+      context.set(node, rhs.resolve(lhs, { type: 'string', value: '=' }));
+      return;
+    }
+
+    const expr = toBinaryExpression('=', lhs, rhs, false);
+    context.set(node, expr);
+  };
+}