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

package/src/superFilter/DateFilterFactory.ts

@@ -0,0 +1,180 @@
+// DateFilterFactory.ts
+import { IGroupFilter } from '../filters/filter-types';
+import { EDateRangeRelativeFilterCondition } from '../query-builder/SuperFilterBuilder';
+import { getDateFunctions } from './dateFunction';
+
+type PeriodConfig = {
+  startExpr: () => string;
+  shiftFn: (expr: string, amount: number) => string;
+  isCalendar: boolean;
+};
+
+export enum Period {
+  DAYS = 'DAYS',
+  WEEKS = 'WEEKS',
+  CALENDER_WEEKS = 'CALENDER_WEEKS',
+  MONTHS = 'MONTHS',
+  CALENDER_MONTHS = 'CALENDER_MONTHS',
+  CALENDER_QUARTERS = 'CALENDER_QUARTERS',
+  CALENDER_YEARS = 'CALENDER_YEARS',
+  FISCAL_QUARTER = 'FISCAL_QUARTER',
+  FISCAL_YEAR = 'FISCAL_YEAR',
+  YEARS = 'YEARS',
+}
+
+/**
+ * Centralized period configs
+ * @param today :today expression
+ * @param fiscalShift :fiscal shift
+ * @returns :period configs <object <string, PeriodConfig>>
+ */
+const getPeriodConfigs = (today: string, fiscalShift = 0): Record<Period, PeriodConfig> => {
+  const fns = getDateFunctions();
+  return {
+    [Period.DAYS]: {
+      startExpr: () => today,
+      shiftFn: (e, a) => fns.dateAdd(e, a, 'day'),
+      isCalendar: false,
+    },
+    [Period.WEEKS]: {
+      startExpr: () => today,
+      shiftFn: (e, a) => fns.dateAdd(e, a * 7, 'day'),
+      isCalendar: false,
+    },
+    [Period.CALENDER_WEEKS]: {
+      startExpr: () => fns.startOfWeek!(today),
+      shiftFn: (e, a) => fns.dateAdd(e, a * 7, 'day'),
+      isCalendar: true,
+    },
+    [Period.MONTHS]: {
+      startExpr: () => today,
+      shiftFn: (e, a) => fns.dateAdd(e, a, 'month'),
+      isCalendar: false,
+    },
+    [Period.CALENDER_MONTHS]: {
+      startExpr: () => fns.dateTrunc('month', today),
+      shiftFn: (e, a) => fns.dateAdd(e, a, 'month'),
+      isCalendar: true,
+    },
+    [Period.CALENDER_QUARTERS]: {
+      startExpr: () => fns.dateTrunc('quarter', today),
+      shiftFn: (e, a) => fns.dateAdd(e, a * 3, 'month'),
+      isCalendar: true,
+    },
+    [Period.CALENDER_YEARS]: {
+      startExpr: () => fns.dateTrunc('year', today),
+      shiftFn: (e, a) => fns.dateAdd(e, a, 'year'),
+      isCalendar: true,
+    },
+    [Period.FISCAL_QUARTER]: {
+      startExpr: () =>
+        fns.dateAdd(
+          fns.dateTrunc('quarter', fns.dateAdd(today, -fiscalShift, 'month')),
+          fiscalShift,
+          'month',
+        ),
+      shiftFn: (e, a) => fns.dateAdd(e, a * 3, 'month'),
+      isCalendar: true,
+    },
+    [Period.FISCAL_YEAR]: {
+      startExpr: () =>
+        fns.dateAdd(
+          fns.dateTrunc('year', fns.dateAdd(today, -fiscalShift, 'month')),
+          fiscalShift,
+          'month',
+        ),
+      shiftFn: (e, a) => fns.dateAdd(e, a, 'year'),
+      isCalendar: true,
+    },
+    [Period.YEARS]: {
+      startExpr: () => today,
+      shiftFn: (e, a) => fns.dateAdd(e, a, 'year'),
+      isCalendar: false,
+    },
+  };
+};
+
+// Base class for date filter factor
+export class DateFilterFactory {
+  static build(column: string, filter: IGroupFilter): string {
+    const fns = getDateFunctions();
+    const today = fns.today;
+
+    const dt = filter.dateTimeFilter;
+    if (!dt || !dt.period || !dt.relativeDateFilter) throw new Error('Invalid date filter');
+
+    const fiscalShift = dt.fiscalYearStartMonth ?? 0;
+    const configs = getPeriodConfigs(today, fiscalShift);
+
+    const periodKey = this.resolvePeriodKey(dt.period, dt.relativeDateFilter);
+    const cfg = configs[periodKey];
+    if (!cfg) throw new Error(`Unsupported period: ${periodKey}`);
+
+    const duration = dt.duration ?? 1;
+
+    const { startExpr, endExpr } = this.resolveDateRangeExpressions({
+      relativeDateFilter: dt.relativeDateFilter,
+      cfg,
+      fns,
+      today,
+      duration,
+    });
+
+    return `(${column} >= ${startExpr} AND ${column} < ${endExpr})`;
+  }
+
+  private static resolvePeriodKey(
+    period: string,
+    relativeDateFilter: EDateRangeRelativeFilterCondition,
+  ): Period {
+    if (relativeDateFilter === EDateRangeRelativeFilterCondition.IS_IN_THIS) {
+      switch (period) {
+        case Period.WEEKS:
+          return Period.CALENDER_WEEKS;
+        case Period.MONTHS:
+          return Period.CALENDER_MONTHS;
+        case 'QUARTERS':
+          return Period.CALENDER_QUARTERS;
+        case Period.YEARS:
+          return Period.CALENDER_YEARS;
+      }
+    }
+    return period as Period;
+  }
+
+  private static resolveDateRangeExpressions(params: {
+    relativeDateFilter: EDateRangeRelativeFilterCondition;
+    cfg: PeriodConfig;
+    fns: ReturnType<typeof getDateFunctions>;
+    today: string;
+    duration: number;
+  }): { startExpr: string; endExpr: string } {
+    const { relativeDateFilter, cfg, fns, today, duration } = params;
+    const startOfPeriod = cfg.startExpr();
+
+    switch (relativeDateFilter) {
+      case EDateRangeRelativeFilterCondition.IS_IN_THIS:
+        return {
+          startExpr: startOfPeriod,
+          endExpr: cfg.shiftFn(startOfPeriod, 1),
+        };
+
+      case EDateRangeRelativeFilterCondition.IS_IN_THE_LAST:
+        return {
+          startExpr: cfg.shiftFn(cfg.isCalendar ? startOfPeriod : today, -duration),
+          endExpr: cfg.isCalendar ? startOfPeriod : today,
+        };
+
+      case EDateRangeRelativeFilterCondition.IS_IN_THE_NEXT:
+        const baseNext = cfg.isCalendar ? startOfPeriod : today;
+        const startExpr = cfg.isCalendar ? cfg.shiftFn(baseNext, 1) : fns.dateAdd(today, 1, 'day');
+        return {
+          startExpr,
+          endExpr: cfg.shiftFn(startExpr, duration),
+        };
+
+      default:
+        throw new Error(`Unsupported relative date filter: ${relativeDateFilter}`);
+    }
+  }
+}

package/src/superFilter/dateFunction.ts

@@ -0,0 +1,36 @@
+// dateFunctions.ts
+
+export interface DateFunctions {
+  today: string;
+  dateAdd(expr: string, amount: number, unit: string): string;
+  dateTrunc(unit: string, expr: string): string;
+  startOfWeek?(expr: string): string;
+}
+
+abstract class BaseDateFunctions implements DateFunctions {
+  abstract today: string;
+  abstract dateAdd(expr: string, amount: number, unit: string): string;
+  abstract dateTrunc(unit: string, expr: string): string;
+  startOfWeek?(expr: string): string;
+}
+
+class FabricSQLDateFunctions extends BaseDateFunctions {
+  today = 'CURRENT_DATE';
+  dateAdd = (expr: any, amount: any, unit: string) =>
+    `DATEADD(${unit.toUpperCase()}, ${amount}, ${expr})`;
+  dateTrunc(unit: string, expr: string) {
+    const truncMap: Record<string, string> = {
+      week: `DATEADD(DAY, -DATEPART(WEEKDAY, ${expr}) + 1, ${expr})`,
+      month: `DATEFROMPARTS(YEAR(${expr}), MONTH(${expr}), 1)`,
+      quarter: `DATEADD(QUARTER, DATEDIFF(QUARTER, 0, ${expr}), 0)`,
+      year: `DATEFROMPARTS(YEAR(${expr}), 1, 1)`,
+    };
+    return truncMap[unit] ?? expr;
+  }
+  startOfWeek = (expr: any) => `DATEADD(DAY, -DATEPART(WEEKDAY, ${expr}) + 1, ${expr})`;
+}
+
+// Factory function
+export const getDateFunctions = (): DateFunctions => {
+  return new FabricSQLDateFunctions();
+};

package/src/utils.ts

@@ -0,0 +1,354 @@
+import { JoinExpressions } from './filters/filter-types';
+import { IMDMColumnConfigWithParsedMeta, ParseContext } from './js-lib/ParseContext';
+import { RuntimeVariables } from './query-builder/QueryBuilder';
+import XXH from 'xxhashjs';
+import { Binary, Case, ExpressionValue, SqlFunction } from './sql-types';
+import {
+  COLUMN_TYPE_TO_STRING,
+  COMPARISON_OPERATORS,
+  ECustomColumnType,
+  EDataType,
+  ESqlDateExpression,
+  ESqlMathExpression,
+  ESqlWindowExpression,
+  FUNCTION_RETURN_TYPE,
+  MATH_OPERATORS,
+  NullableValueType,
+  OPERATOR_MAP,
+} from './constants';
+import { RUNTIME_CURRENT_DATE } from './runtime_var';
+
+function wrapPart(part: string, wrapper: string): string {
+  if (wrapper === '`') return `\`${part}\``;
+  if (wrapper === '[') return `[${part}]`;
+  return `"${part}"`;
+}
+
+function formatNameByWrapper(name: string, wrapper: string): string {
+  return name
+    .split('.')
+    .map((part) => wrapPart(part, wrapper))
+    .join('.');
+}
+
+export function formatDBEntityName(name: string): string {
+  return formatNameByWrapper(name, '[');
+}
+
+export function getEntityNameFormatter(): (name: string, type?: string) => string {
+  const baseFormatter = (name: string) => {
+    return formatNameByWrapper(name, '[');
+  };
+
+  return (name: string, type?: string) => {
+    if (type === 'bit') {
+      return `CAST(${baseFormatter(name)} AS int) as ${baseFormatter(name)}`;
+    }
+    return baseFormatter(name);
+  };
+}
+
+export function resolveRuntimeVariables(expr: string, runtimeVariables: RuntimeVariables): string {
+  // regular expression to match words starting with $ and containing only word characters
+  return expr.replace(
+    /\$\w+/g,
+    (match) => runtimeVariables[match as keyof RuntimeVariables] ?? match,
+  );
+}
+
+function hashEncrypt(text: string): string {
+  const seed = 0xabcd;
+  const hash64 = XXH.h64(text, seed);
+  return hash64.toString(16).slice(0, 8).padStart(8, '0');
+}
+
+export function getDeprecatedFormulaId(columnName: string): string {
+  return columnName.replace(/\W+/g, '__');
+}
+
+export function getFormulaId(columnName: string): string {
+  const sanitizedName = columnName.replace(/\W+/g, '__');
+  const hashKey = hashEncrypt(columnName).slice(0, 8);
+  return `${sanitizedName}_${hashKey}`;
+}
+
+export function getDeprecatedFormulaIdColumnMap(
+  columnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta>,
+): Record<string, string> {
+  const formulaIdColumnMap = Object.values(columnConfigMap as Record<string, any>).reduce(
+    (acc, column) => {
+      const columnName = column?.columnName;
+      const sanitizedColumnName = getDeprecatedFormulaId(columnName);
+      if (sanitizedColumnName && columnName) {
+        acc[sanitizedColumnName] = columnName;
+      }
+      return acc;
+    },
+    {} as Record<string, string>,
+  );
+
+  return formulaIdColumnMap;
+}
+
+export function getFormulaIdColumnMap(
+  columnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta>,
+): Record<string, string> {
+  const formulaIdColumnMap = Object.values(columnConfigMap as Record<string, any>).reduce(
+    (acc, column) => {
+      const columnName = column?.columnName;
+      const sanitizedColumnName = getFormulaId(columnName);
+      if (sanitizedColumnName && columnName) {
+        acc[sanitizedColumnName] = columnName;
+      }
+      return acc;
+    },
+    {} as Record<string, string>,
+  );
+
+  return formulaIdColumnMap;
+}
+
+export function getFormattedTableName(databaseDetails: Record<string, any>): string {
+  const { database, schema, dataTableName } = databaseDetails;
+
+  const tableName = `${database}.${schema}.${dataTableName}`;
+  return formatDBEntityName(tableName);
+}
+
+export function getCurrentDate(): string {
+  return new Date().toISOString().split('T')[0];
+}
+
+export function getCurrentDateTime(): string {
+  return new Date().toISOString();
+}
+/**
+ * Gets the join expressions from the join config
+ * @returns An array of join expressions in SQL format
+ */
+export function getJoinExpressions(
+  joinClauses: JoinExpressions,
+  databaseDetails: Record<string, string>,
+): string[] {
+  const { joinRelation, alias } = joinClauses || {};
+
+  if (!Array.isArray(joinRelation) || joinRelation.length === 0) {
+    return [];
+  }
+  const entityNameFormatter = getEntityNameFormatter();
+  const { database } = databaseDetails;
+  const formattedDatabaseName = database ? `${entityNameFormatter(database)}.` : '';
+  const mainTablePrefix = alias ? `${entityNameFormatter(alias)}.` : '';
+
+  return joinRelation.map((join) => {
+    const formattedSchema = join?.schema ? entityNameFormatter(join.schema) : undefined;
+    const formattedTable = entityNameFormatter(join.table);
+    const qualifiedJoinTable = formattedSchema
+      ? `${formattedDatabaseName}${formattedSchema}.${formattedTable}`
+      : formattedTable;
+    const joinAlias = entityNameFormatter(join.alias ?? join.table);
+
+    // Build left & right columns
+    const leftCol = `${mainTablePrefix}${entityNameFormatter(join.id)}`;
+    const rightCol = `${joinAlias}.${entityNameFormatter(join.joinId)}`;
+
+    // Build join target: always alias the table
+    const joinTarget = `${qualifiedJoinTable} ${joinAlias}`;
+
+    return `${join.joinType.toUpperCase()} JOIN ${joinTarget} ON ${leftCol} = ${rightCol}`;
+  });
+}
+
+/**
+ * Strips the 'WHERE' clause from the SQL query.
+ *  - If where clause is not present, returns the original query.
+ *  - If where clause is present, returns the part of the query after the 'WHERE' clause.
+ */
+export function stripWhereClause(sqlQuery: string): string {
+  const queryInUpperCase = sqlQuery.toUpperCase();
+  const whereLabel = 'WHERE';
+  // since query generated by Knex starts with 'SELECT' and includes 'WHERE' in the query,
+  // we need to slice that part out to just get the filter condition.
+  const startIndex = queryInUpperCase.indexOf(whereLabel);
+  if (startIndex === -1) {
+    return sqlQuery;
+  }
+  return sqlQuery.slice(startIndex + whereLabel.length).trim();
+}
+
+/**
+ * Extracts the target type of a CAST expression from a given Binary expression.
+ * The target type is the right-hand side of the AS operator, e.g. 'INT' in 'CAST(x AS INT)'.
+ * If the given expression does not represent a CAST expression, returns null.
+ * @param {Binary} arg - The Binary expression to extract the target type from.
+ * @returns {string | null} - The target type of the CAST expression, or null if it is not a CAST expression.
+ */
+export function extractCastTargetType(arg: Binary): string | null {
+  if (arg?.type === 'binary_expr' && arg.operator === 'AS' && arg.right?.type === 'default') {
+    return arg.right.value;
+  }
+  return null;
+}
+
+/**
+ * Maps a SQL cast type  to a Fabric data type
+ * @param {string} type - The SQL cast type to map.
+ * @returns {NullableValueType} - The corresponding Fabric data type.
+ */
+export function mapSqlTypeToDataType(type: string): NullableValueType {
+  // Convert SQL type to Fabric data type
+  const dataType = String(type)
+    .replace(/\(.*\)/, '')
+    .trim()
+    .toUpperCase();
+  switch (dataType) {
+    // Numeric types supported in Fabric
+    case 'INT':
+    case 'INTEGER':
+    case 'BIGINT':
+    case 'FLOAT':
+    case 'DOUBLE':
+    case 'DECIMAL':
+    case 'NUMERIC':
+      return EDataType.NUMBER;
+
+    // Date and time types supported in Fabric
+    case 'DATE':
+    case 'TIMESTAMP':
+    case 'DATETIME':
+      return EDataType.DATE;
+
+    // Boolean types supported in Fabric
+    case 'BOOLEAN':
+    case 'BOOL':
+    case 'BIT':
+      return EDataType.BOOLEAN;
+
+    // String types supported in Fabric
+    case 'STRING':
+    case 'TEXT':
+    case 'VARCHAR':
+    case 'CHAR':
+    case 'NVARCHAR':
+      return EDataType.STRING;
+
+    default:
+      return null;
+  }
+}
+
+export function isValidDate(value: string): boolean {
+  if (typeof value !== 'string') return false;
+  if (RUNTIME_CURRENT_DATE === value) return true;
+  const isoDateRegex = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
+  if (!isoDateRegex.test(value)) return false;
+
+  const date = new Date(value);
+  if (isNaN(date.getTime())) return false;
+
+  const [year, month, day] = value.split('-').map(Number);
+  return (
+    date.getUTCFullYear() === year && date.getUTCMonth() + 1 === month && date.getUTCDate() === day
+  );
+}
+
+export function getArgType(arg: ExpressionValue, context: ParseContext): NullableValueType {
+  if (arg.type === 'column_ref') {
+    const columnName = (arg as Record<string, string>).column.replace(/[`[\]"]/g, '');
+    const column = context.columnConfigMap[columnName];
+    if (!column) return null;
+    // Handle formula columns by returning their resolved data type
+    if ((column.columnType as number) === ECustomColumnType.FORMULA) {
+      const dataType = column.columnMeta?.formulaColumnDetails?.dataType;
+      return dataType ?? null;
+    }
+    return COLUMN_TYPE_TO_STRING[column.columnType] ?? null;
+  }
+
+  if (arg.type === EDataType.STRING) {
+    return isValidDate(arg.value) ? EDataType.DATE : EDataType.STRING;
+  }
+  if (arg.type === EDataType.NUMBER) return EDataType.NUMBER;
+  if (arg.type === EDataType.BOOLEAN) return EDataType.BOOLEAN;
+  if (arg.type === EDataType.NULL) return null;
+
+  if (arg.type === 'case') {
+    const resultTypes = (arg as Case).args.map((branch) =>
+      branch.type === 'when' || branch.type === 'else'
+        ? getArgType(branch.result as ExpressionValue, context)
+        : null,
+    );
+
+    const unique = [...new Set(resultTypes)];
+    return unique.length === 1 ? unique[0] : null;
+  }
+
+  if (arg.type === 'binary_expr') {
+    const operator = OPERATOR_MAP.get((arg as Binary).operator) ?? (arg as Binary).operator;
+
+    const leftType = getArgType((arg as Binary).left, context);
+    const rightType = getArgType((arg as Binary).right, context);
+
+    // Math operators
+    if (MATH_OPERATORS.has(operator)) {
+      if (leftType !== EDataType.NUMBER || rightType !== EDataType.NUMBER) {
+        context.isValid = false;
+        context.error = `Operator "${operator}" requires both operands to be numbers`;
+      }
+      return EDataType.NUMBER;
+    }
+
+    // Comparison operators
+    if (COMPARISON_OPERATORS.has(operator)) {
+      if (leftType !== rightType && leftType !== null && rightType !== null) {
+        context.isValid = false;
+        context.error = `Please ensure both sides of the comparison are of the same type`;
+      }
+      return EDataType.BOOLEAN;
+    }
+
+    return null;
+  }
+
+  if (arg.type === 'expr_list') {
+    const types = (arg.value as ExpressionValue[]).map((v) => getArgType(v, context));
+    return types.find((t) => t !== null) || null;
+  }
+
+  if (arg.type === 'function') {
+    const fnName = (arg as SqlFunction).name.name[0].value.toUpperCase();
+    const args =
+      (arg as SqlFunction).args?.type === 'expr_list'
+        ? (arg as SqlFunction).args.value
+        : [(arg as SqlFunction).args];
+
+    // Handle specific SQL functions
+    if (fnName === 'COALESCE') {
+      const types = args.map((a) => getArgType(a, context));
+      return types.find((t) => t !== null) || null;
+    } else if (fnName === 'CAST') {
+      const targetType = extractCastTargetType(args[0] as Binary);
+      return targetType ? mapSqlTypeToDataType(targetType) : null;
+    }
+
+    // Resolve return type for precomputed functions
+    const returnType = FUNCTION_RETURN_TYPE[fnName];
+    if (returnType) return returnType;
+
+    return null;
+  }
+
+  // Handle SQL expressions
+  if (arg.type === 'sql_expr') {
+    const sqlValue = (arg as any).value;
+
+    if (Object.values(ESqlDateExpression).includes(sqlValue)) return EDataType.DATE;
+    if (Object.values(ESqlMathExpression).includes(sqlValue)) return EDataType.NUMBER;
+    if (Object.values(ESqlWindowExpression).some((expr) => sqlValue.includes(expr)))
+      return EDataType.NUMBER;
+
+    return null;
+  }
+
+  return null;
+}