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

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

@@ -0,0 +1,571 @@
+// helpers: shared utilities used across dialects and builders
+import {
+  EpmQueryBuilderOptions,
+  RowColumnConfig,
+  OrderByConfig,
+} from '@epm-query-builder/types/query-builder-types';
+import * as ColumnRefUtils from '@epm-query-builder/base/ColumnRefUtils';
+import { mapAggregationType as mapAgg } from '@epm-query-builder/constants/Aggregations';
+import { SOURCE_TYPES } from '@epm-query-builder/constants/Source';
+import * as Validation from '@epm-query-builder/utils/validation';
+import * as Format from '@epm-query-builder/utils/format';
+import * as Sql from '@epm-query-builder/utils/sql';
+
+export class BaseUtilities {
+  static buildSqlSelect(
+    items: string[],
+    tableName: string,
+    whereClause?: string,
+    groupBy?: string[],
+    orderBy?: string,
+    limit?: string,
+  ): string {
+    return Sql.buildSqlSelect(items, tableName, whereClause, groupBy, orderBy, limit);
+  }
+
+  static formatColumnWithAlias(column: string, alias: string): string {
+    return `${column} AS "${alias}"`;
+  }
+
+  static buildCTETemplate(name: string, query: string): string {
+    return `${name} AS (${query})`;
+  }
+
+  static validateRequiredFields(obj: unknown, fields: string[]): boolean {
+    return Validation.validateRequiredFields(obj, fields);
+  }
+
+  static combineConditions(conditions: string[], operator: 'AND' | 'OR' = 'AND'): string {
+    return Sql.combineConditions(conditions, operator);
+  }
+
+  static formatValue(value: string | number | boolean): string {
+    return Format.formatValue(value);
+  }
+
+  static stringToDate(value: string): string {
+    if (!value) return 'NULL';
+
+    const dateFormats = [
+      /^\d{4}-\d{2}-\d{2}$/, // YYYY-MM-DD
+      /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/, // YYYY-MM-DD HH:mm:ss
+      /^\d{2}\/\d{2}\/\d{4}$/, // MM/DD/YYYY
+      /^\d{2}-\d{2}-\d{4}$/, // MM-DD-YYYY
+    ];
+
+    if (dateFormats.some((format) => format.test(value))) {
+      return `DATE('${value}')`;
+    }
+
+    return `'${value.replace(/'/g, "''")}'`;
+  }
+
+  static formatValueForDataType(value: string | number | boolean, dataType: string): string {
+    if (!dataType) {
+      return this.formatValue(value);
+    }
+
+    switch (dataType.toLowerCase()) {
+      case 'string':
+        return `'${String(value).replace(/'/g, "''")}'`;
+      case 'date':
+      case 'datetime':
+        return this.stringToDate(String(value));
+      case 'number':
+      case 'decimal':
+      case 'integer':
+        return String(value);
+      case 'boolean':
+        return String(value).toLowerCase() === 'true' ? 'TRUE' : 'FALSE';
+      default:
+        return this.formatValue(value);
+    }
+  }
+
+  static buildColumnReference(
+    tableName: string | undefined,
+    columnName: string,
+    useQuotes = true,
+  ): string {
+    if (!tableName) return columnName;
+
+    if (useQuotes) {
+      return `"${tableName}"."${columnName}"`;
+    }
+    return `${tableName}.${columnName}`;
+  }
+
+  static extractTableNameFromId(columnId: string): string | null {
+    return ColumnRefUtils.getTableNameFromId(columnId);
+  }
+
+  static getEffectiveColumnName(config: RowColumnConfig): string {
+    const actualColumnId = this.extractColumnIdFromHierarchy(config.id);
+    return actualColumnId;
+  }
+
+  static extractColumnIdFromHierarchy(columnId: string): string {
+    return ColumnRefUtils.extractColumnIdFromHierarchy(columnId);
+  }
+
+  static extractTableNameFromColumnId(columnId: string, columnName: string): string {
+    return ColumnRefUtils.extractTableNameFromColumnId(columnId, columnName);
+  }
+
+  static formColumnId(tableName: string, columnName: string): string {
+    if (!tableName || !columnName) return columnName || '';
+    return `"${tableName}"."${columnName}"`;
+  }
+
+  static isValidTableName(tableName: string): boolean {
+    return /^[a-zA-Z0-9_[\]().\s]+$/.test(tableName);
+  }
+
+  static getEffectiveTableName(config: RowColumnConfig, options: EpmQueryBuilderOptions): string {
+    return (
+      config.tableName ||
+      BaseUtilities.extractTableNameFromId(config.id) ||
+      BaseUtilities.getDefaultTableName(options)
+    );
+  }
+
+  static getDefaultTableName(options: EpmQueryBuilderOptions): string {
+    const allItems = [
+      ...(options.rows || []),
+      ...(options.columns || []),
+      ...(options.values || []),
+    ];
+
+    for (const item of allItems) {
+      if (item.tableName) return item.tableName;
+    }
+
+    for (const item of allItems) {
+      const tableFromId = BaseUtilities.extractTableNameFromId(item.id);
+      if (tableFromId) return tableFromId;
+    }
+
+    const tablesFromFilters = this.extractTableNames(options);
+    if (tablesFromFilters.length > 0) {
+      return tablesFromFilters[0];
+    }
+
+    return '';
+  }
+
+  static buildDistinctSelect(
+    columns: string[],
+    tableName: string,
+    whereClause?: string,
+    orderBy?: string,
+  ): string {
+    return Sql.buildDistinctSelect(columns, tableName, whereClause, orderBy);
+  }
+
+  static buildCountQuery(tableName: string, whereClause?: string): string {
+    let query = `SELECT COUNT(*) FROM ${tableName}`;
+
+    if (whereClause) {
+      query += ` WHERE ${whereClause}`;
+    }
+
+    return query;
+  }
+
+  static sanitizeIdentifier(identifier: string): string {
+    return Format.sanitizeIdentifier(identifier);
+  }
+
+  static isEmptyOrWhitespace(value: string | undefined | null): boolean {
+    return Validation.isEmptyOrWhitespace(value);
+  }
+
+  static isValidIdentifier(identifier: string): boolean {
+    return Validation.isValidIdentifier(identifier);
+  }
+
+  static ensureArray<T>(value: T | T[] | undefined): T[] {
+    if (!value) return [];
+    return Array.isArray(value) ? value : [value];
+  }
+
+  static hasValue<T>(value: T | undefined | null): value is T {
+    return value !== undefined && value !== null;
+  }
+
+  static buildOrderByClause(orderItems: OrderByConfig[]): string {
+    if (!orderItems?.length) return '';
+
+    const clauses = orderItems.map((item) => {
+      const direction = item.type?.toUpperCase() === 'DESC' ? 'DESC' : 'ASC';
+      return `${item.columnName} ${direction}`;
+    });
+
+    return `ORDER BY ${clauses.join(', ')}`;
+  }
+
+  static extractUniqueTableNames(options: EpmQueryBuilderOptions): string[] {
+    const tables = new Set<string>();
+
+    [...(options.rows || []), ...(options.columns || []), ...(options.values || [])].forEach(
+      (item) => {
+        if (!item) return;
+
+        const directTableName = item.tableName;
+
+        const inferredTableName =
+          !directTableName && item.id ? BaseUtilities.getTableNameFromId(item.id) : null;
+
+        const effectiveTableName = directTableName || inferredTableName;
+        if (effectiveTableName) {
+          tables.add(effectiveTableName);
+        }
+      },
+    );
+
+    if (options.superFilters?.children) {
+      options.superFilters.children.forEach((child) => {
+        if (child.filters?.tableNames) {
+          child.filters.tableNames.forEach((tableName) => {
+            if (tableName) tables.add(tableName);
+          });
+        }
+      });
+    }
+
+    return Array.from(tables);
+  }
+
+  static buildLimitClause(offset?: number, limit?: number): string {
+    return Sql.buildLimitClause(offset, limit);
+  }
+
+  static buildMonthOrderKey(columnExpression: string): string {
+    const expr = `TRIM(CAST(${columnExpression} AS VARCHAR))`;
+    return `COALESCE(
+            EXTRACT(MONTH FROM TRY_STRPTIME(${expr}, '%b')),
+            EXTRACT(MONTH FROM TRY_STRPTIME(${expr}, '%B')),
+            EXTRACT(MONTH FROM TRY_STRPTIME(LOWER(${expr}), '%b')),
+            EXTRACT(MONTH FROM TRY_STRPTIME(LOWER(${expr}), '%B')),
+            TRY_CAST(${columnExpression} AS INTEGER),
+            13
+        )`;
+  }
+
+  static buildQuarterOrderKey(columnExpression: string): string {
+    const expr = `TRIM(LOWER(CAST(${columnExpression} AS VARCHAR)))`;
+    return `COALESCE(
+            EXTRACT(QUARTER FROM TRY_STRPTIME(${expr}, '%b')),
+            EXTRACT(QUARTER FROM TRY_STRPTIME(${expr}, '%B')),
+            CASE WHEN ${expr} LIKE 'q1%' THEN 1 WHEN ${expr} LIKE 'q2%' THEN 2 WHEN ${expr} LIKE 'q3%' THEN 3 WHEN ${expr} LIKE 'q4%' THEN 4 ELSE NULL END,
+            TRY_CAST(${columnExpression} AS INTEGER),
+            5
+        )`;
+  }
+
+  static buildMeasureExpression(
+    tableName: string,
+    columnName: string,
+    aggregationType?: string,
+  ): string {
+    if (!aggregationType || aggregationType === 'NONE') {
+      return `"${tableName}"."${columnName}"`;
+    }
+
+    const mappedAggregation = this.mapAggregationType(aggregationType);
+    return `${mappedAggregation}("${tableName}"."${columnName}")`;
+  }
+
+  static mapAggregationType(aggregationType: string): string {
+    return mapAgg(aggregationType);
+  }
+
+  static buildWhereCondition(conditions: string[], operator: 'AND' | 'OR' = 'AND'): string {
+    const validConditions = conditions.filter((condition) => condition && condition.trim());
+
+    if (validConditions.length === 0) return '';
+    if (validConditions.length === 1) return validConditions[0];
+
+    return `(${validConditions.join(` ${operator} `)})`;
+  }
+
+  static getTableNameFromId(columnId: string): string | null {
+    return ColumnRefUtils.getTableNameFromId(columnId);
+  }
+
+  static getTableNameFromColumnId(columnId: string, columnName?: string): string {
+    if (!columnId) return '';
+    if (columnName) {
+      return this.extractTableNameFromColumnId(columnId, columnName);
+    }
+    return this.getTableNameFromId(columnId) || '';
+  }
+
+  static sanitizeHierarchyPrefix(columnId: string): string {
+    return ColumnRefUtils.extractColumnIdFromHierarchy(columnId);
+  }
+
+  static extractTableNames(options: EpmQueryBuilderOptions): string[] {
+    if (!options.superFilters?.children) {
+      return [];
+    }
+    const tableNames = new Set<string>();
+    options.superFilters.children.forEach((child) => {
+      if (child.filters?.tableNames) {
+        child.filters.tableNames.forEach((tableName) => {
+          tableNames.add(tableName);
+        });
+      }
+    });
+    return Array.from(tableNames);
+  }
+
+  static formatColumnReferenceForDb(
+    config: RowColumnConfig,
+    options: EpmQueryBuilderOptions,
+  ): string {
+    const source = this.getSource(options);
+    const actualColumnId = this.extractColumnIdFromHierarchy(config.id);
+    const idForDb = source === SOURCE_TYPES.BLEND ? config.id : actualColumnId;
+    if (options.databaseDetails?.databaseType === 'duckdb') {
+      const useDot = this.shouldUseDotNotation(options);
+      if (useDot) {
+        const tableName =
+          config.tableName ||
+          this.getTableNameFromId(config.id) ||
+          this.getDefaultTableNameFromOptions(options) ||
+          this.extractTableNames(options)[0] ||
+          '';
+        const effectiveColumnName = idForDb;
+        if (tableName) {
+          return this.buildColumnReference(tableName, effectiveColumnName);
+        }
+        return `"${effectiveColumnName}"`;
+      }
+      return `"${idForDb}"`;
+    }
+    const tableName =
+      config.tableName ||
+      this.getTableNameFromId(config.id) ||
+      this.extractTableNames(options)[0] ||
+      '';
+    const effectiveColumnName = idForDb;
+    return `${tableName}.${effectiveColumnName}`;
+  }
+
+  static buildDimensionReference(
+    items: RowColumnConfig[] | undefined,
+    options: EpmQueryBuilderOptions,
+  ): string[] {
+    return items?.map((item) => this.formatColumnReferenceForDb(item, options)) || [];
+  }
+
+  static getDefaultTableNameFromOptions(options: EpmQueryBuilderOptions): string {
+    const rows = options.rows || [];
+    const columns = options.columns || [];
+    const values = options.values || [];
+    const allItems = [...rows, ...columns, ...values];
+    if (allItems.length > 0 && allItems[0].tableName) {
+      return allItems[0].tableName;
+    }
+    const tablesFromFilters = this.extractTableNames(options);
+    if (tablesFromFilters.length > 0) {
+      return tablesFromFilters[0];
+    }
+    return '';
+  }
+
+  static formatTableColumnReference(tableName: string, columnName: string): string {
+    return `"${tableName}"."${columnName}"`;
+  }
+
+  static sanitizeIdentifierString(identifier: string): string {
+    return identifier.replace(/[^a-zA-Z0-9_]/g, '_');
+  }
+
+  static isValidTableNameString(tableName: string): string | boolean {
+    return /^[a-zA-Z0-9_[\]().\s]+$/.test(tableName);
+  }
+
+  static formatTableNameForDb(tableName: string, databaseType?: string): string {
+    if (databaseType === 'duckdb' || tableName.includes(' ') || tableName.includes('-')) {
+      return `"${tableName}"`;
+    }
+    return tableName;
+  }
+
+  static shouldUseDotNotation(options: EpmQueryBuilderOptions): boolean {
+    const src = this.getSource(options);
+    return src === SOURCE_TYPES.BLEND;
+  }
+
+  static getSource(options: EpmQueryBuilderOptions): string {
+    const source =
+      (options as unknown as { config?: { source?: string } })?.config?.source ||
+      (options as unknown as { source?: string })?.source ||
+      this.safeGet<string>(
+        options.databaseDetails as unknown as Record<string, unknown>,
+        'source',
+        '',
+      ) ||
+      '';
+    return String(source || '').toLowerCase();
+  }
+
+  static buildFilterConditionForOperator(
+    column: string,
+    operator: string,
+    value: string | number | boolean,
+  ): string {
+    const formattedValue = typeof value === 'string' ? BaseUtilities.formatValue(value) : value;
+    switch (operator.toUpperCase()) {
+      case 'IS_EQUAL_TO':
+      case 'IS':
+        return `${column} = ${formattedValue}`;
+      case 'IS_NOT_EQUAL_TO':
+      case 'IS_NOT':
+        return `${column} != ${formattedValue}`;
+      case 'IS_GREATER_THAN':
+        return `${column} > ${formattedValue}`;
+      case 'IS_GREATER_THAN_OR_EQUAL_TO':
+        return `${column} >= ${formattedValue}`;
+      case 'IS_LESS_THAN':
+        return `${column} < ${formattedValue}`;
+      case 'IS_LESS_THAN_OR_EQUAL_TO':
+        return `${column} <= ${formattedValue}`;
+      case 'IS_BLANK':
+        return `${column} IS NULL`;
+      case 'IS_NOT_BLANK':
+        return `${column} IS NOT NULL`;
+      default:
+        return `${column} = ${formattedValue}`;
+    }
+  }
+
+  static normalizeComparisonOperator(operator: string): string {
+    const canonical = (operator || '')
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '_')
+      .replace(/^_+|_+$/g, '');
+    switch (canonical) {
+      case 'is':
+      case 'equals':
+      case 'is_equal_to':
+        return '=';
+      case 'is_not':
+      case 'not_equals':
+      case 'is_not_equal_to':
+        return '!=';
+      case 'is_greater_than':
+        return '>';
+      case 'is_greater_than_or_equal_to':
+        return '>=';
+      case 'is_less_than':
+        return '<';
+      case 'is_less_than_or_equal_to':
+        return '<=';
+      case 'is_blank':
+        return 'IS NULL';
+      case 'is_not_blank':
+        return 'IS NOT NULL';
+      default:
+        return '=';
+    }
+  }
+
+  static validateRequiredField<T>(
+    value: T | undefined | null,
+    fieldName: string,
+    context?: string,
+  ): T {
+    if (value === undefined || value === null) {
+      const contextMsg = context ? ` in ${context}` : '';
+      throw new Error(`Required field '${fieldName}' is missing${contextMsg}`);
+    }
+    return value;
+  }
+
+  static safeGet<T>(
+    obj: Record<string, unknown> | undefined,
+    key: string,
+    defaultValue?: T,
+  ): T | undefined {
+    if (!obj || !(key in obj)) {
+      return defaultValue;
+    }
+    return obj[key] as T;
+  }
+
+  static extractDimensionsFromOptions(options: EpmQueryBuilderOptions): string[] {
+    const rowDimensions = this.buildDimensionReference(options.rows, options);
+    const columnDimensions = this.buildDimensionReference(options.columns, options);
+    return [...rowDimensions, ...columnDimensions];
+  }
+
+  static extractMeasuresFromOptions(options: EpmQueryBuilderOptions): unknown[] {
+    return options.values || [];
+  }
+
+  static getSelectedColumnsFromOptions(options: EpmQueryBuilderOptions): string[] {
+    if (options.rows?.length) {
+      return options.rows.map((row) => row.columnName);
+    }
+    return options.selectedColumns || [];
+  }
+
+  static hasDimensionsInOptions(options: EpmQueryBuilderOptions): boolean {
+    const rowCount = options.rows?.length || 0;
+    const columnCount = options.columns?.length || 0;
+    return rowCount + columnCount > 0;
+  }
+
+  static hasMeasuresInOptions(options: EpmQueryBuilderOptions): boolean {
+    return (options.values?.length || 0) > 0;
+  }
+
+  static shouldGenerateRollupForOptions(options: EpmQueryBuilderOptions): boolean {
+    return !options.skipRollup && this.hasDimensionsInOptions(options);
+  }
+
+  static shouldGenerateAnalyticalQueryForOptions(options: EpmQueryBuilderOptions): boolean {
+    return (
+      this.hasMeasuresInOptions(options) ||
+      (this.shouldGenerateRollupForOptions(options) && this.hasMeasuresInOptions(options))
+    );
+  }
+
+  static formatColumnNameWithFallbackString(columnName: string, columnId: string): string {
+    const actualColumnId = this.extractColumnIdFromHierarchy(columnId);
+    return columnName || actualColumnId;
+  }
+
+  static buildBasicGroupByClauseForOptions(options: EpmQueryBuilderOptions): string {
+    const dimensions = this.extractDimensionsFromOptions(options);
+    return dimensions.length > 0 ? `GROUP BY ${dimensions.join(', ')}` : '';
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static generateConcatenatedIdMeasure(dimensionMappings: Record<string, any>): [string, string] {
+    if (!dimensionMappings || Object.keys(dimensionMappings).length === 0) {
+      return ['', ''];
+    }
+
+    const targetTable = Object.keys(dimensionMappings)[0];
+    const mappings = dimensionMappings[targetTable];
+
+    if (!mappings || mappings.length === 0) {
+      return ['', targetTable];
+    }
+
+    const concatenatedColumns = mappings
+      .map(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (mapping: any) => `COALESCE("${mapping.targetTable}"."${mapping.targetField}", '')`,
+      )
+      .join(" || '|' || ");
+
+    const measure = `MEASURE '${targetTable}'[CONCATENATED_IDS] = ${concatenatedColumns}`;
+
+    return [measure, targetTable];
+  }
+}

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

@@ -0,0 +1,42 @@
+export function extractColumnIdFromHierarchy(columnId: string): string {
+  if (columnId.startsWith('[H] ')) {
+    return columnId.substring(4);
+  }
+  if (columnId.includes('~||~')) {
+    const parts = columnId.split('~||~');
+    return parts.length > 1 ? parts[1] : columnId;
+  }
+  return columnId;
+}
+
+export function getTableNameFromId(columnId: string): string | null {
+  const actualColumnId = extractColumnIdFromHierarchy(columnId);
+  const lastBracketIndex = actualColumnId.lastIndexOf('[');
+  if (lastBracketIndex > 0) {
+    return actualColumnId.substring(0, lastBracketIndex).trim();
+  }
+  return null;
+}
+
+export function extractTableNameFromColumnId(columnId: string, columnName: string): string {
+  if (!columnId || !columnName) {
+    return '';
+  }
+  const sanitizedColumnId = extractColumnIdFromHierarchy(columnId);
+  const columnNamePattern = `[${columnName}]`;
+  const index = sanitizedColumnId.lastIndexOf(columnNamePattern);
+  if (index !== -1) {
+    return sanitizedColumnId.substring(0, index);
+  }
+  return sanitizedColumnId;
+}
+
+export function getColumnNameFromId(columnId: string): string {
+  const actualColumnId = extractColumnIdFromHierarchy(columnId);
+  const start = actualColumnId.lastIndexOf('[');
+  const end = actualColumnId.lastIndexOf(']');
+  if (start >= 0 && end > start) {
+    return actualColumnId.substring(start + 1, end);
+  }
+  return actualColumnId;
+}