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

package/src/epm-query-builder/types/query-builder-types.d.ts

@@ -0,0 +1,289 @@
+export interface Relationship {
+  fromTable: string;
+  fromColumn: string;
+  toTable: string;
+  toColumn: string;
+  isActive?: boolean;
+  crossFilterDirection?: 'SINGLE' | 'BOTH' | null;
+  fromColumnMultiplicity: '*' | '0..1';
+  toColumnMultiplicity: '*' | '0..1';
+}
+
+export interface EpmQueryBuilderOptions {
+  config: { source: string };
+  selectedColumns?: string[];
+  databaseDetails: Record<string, unknown>;
+  primaryKeyColumns?: string[];
+  pagination?: PaginationConfig;
+  searchExpression?: string;
+  distinct?: boolean;
+  superFilters?: SuperFilterConfig;
+  rows: RowColumnConfig[];
+  columns: RowColumnConfig[];
+  values: MeasureConfig[];
+  orderBy: OrderByConfig[];
+  skipRollup?: boolean;
+  isCrossHighlightEnabled?: boolean;
+  measureFilters?: MeasureFilterConfig[];
+  dimensionIdMappings?: Record<string, DimensionIdMapping[]>;
+  customMeasures?: string[];
+  staticFormatStrings?: Record<string, string>;
+  isRankingFilterIncluded?: boolean;
+  relationships?: Relationship[];
+}
+
+export interface RowColumnConfig {
+  id: string;
+  label: string;
+  type: string;
+  columnName: string;
+  tableName?: string;
+  aggregationType?: string;
+  dataType?: string;
+  orderByRef?: string;
+  formatString?: string;
+  expansionConfig?: ExpansionConfig;
+}
+
+export interface MeasureConfig {
+  id: string;
+  label: string;
+  columnName: string;
+  tableName: string;
+  type: string;
+  aggregationType?: string;
+  dataType?: string;
+  formatString?: string;
+  isGetRangeEnabled?: boolean;
+}
+
+export interface OrderByConfig {
+  id: string;
+  columnName: string;
+  tableName?: string;
+  type: 'ASC' | 'DESC';
+  aggregationType?: string;
+  isColumnPresentInOutput?: boolean;
+}
+
+export interface RangeFilter {
+  operator?: string;
+  value?: string | number;
+  from?: string | number;
+  fromCondition?: string;
+  to?: string | number;
+  toCondition?: string;
+  logicalOperator?: string;
+}
+
+export interface DateRangeFilter {
+  startDate: string;
+  endDate: string;
+  operator?: string;
+}
+
+export interface SearchCondition {
+  operator: string;
+  value: string;
+  logicalOperator?: string;
+}
+
+export interface RankingConfig {
+  type: RankingFilterType;
+  rankByColumnId: string;
+  rankByAggregationType: AggregationType;
+  rankByColumnName?: string;
+  rankByTableName?: string;
+  rankByColumnType?: string;
+  value: number;
+  isPercentage?: boolean;
+  operator?: string;
+  measureId?: string;
+}
+
+export interface FilterConfig {
+  filterType: string;
+  columnIds: string[];
+  columnNames: string[];
+  tableNames: string[];
+  columnDataType?: string[];
+  sourceType?: string[];
+  dataType?: string[];
+  valuesFilterApplicationType?: ValuesFilterApplicationType;
+  valuesFilter?: { id: string | string[]; label: string | string[] }[];
+  isCrossHighlight?: boolean;
+  rangeFilter?: RangeFilter[];
+  dateRangeFilter?: DateRangeFilter[];
+  relativePeriodFilter?: RelativePeriodFilterConfig;
+  aggregationType?: string[];
+  columnType?: string[];
+  logicalOperator?: string;
+  isTupleFilter?: boolean;
+  searchConditions?: SearchCondition[];
+  isRankingFilter?: boolean;
+  rankingConfig?: RankingConfig;
+  rankingFilter?: RankingConfig[];
+  blankFilterConfig?: BlankFilterConfig;
+  dateHierarchyConfig?: DateHierarchyConfig;
+  compositeColumnConfig?: CompositeColumnConfig;
+  fieldParameterMapping?: FieldParameterMapping;
+  distinctRowsCount?: number;
+  isRelativePeriodFilter?: boolean;
+  isDateHierarchyFilter?: boolean;
+  isFieldParameterFilter?: boolean;
+  isCompositeFilter?: boolean;
+}
+
+export interface SuperFilterChild {
+  filters?: FilterConfig;
+  isGroup?: boolean;
+  isFilter?: boolean;
+  groupId?: string;
+  groupLabel?: string;
+  condition?: string;
+  children?: SuperFilterChild[];
+}
+
+export interface SuperFilterConfig {
+  groupId: string;
+  groupLabel: string;
+  condition: string;
+  children: SuperFilterChild[];
+}
+
+export interface MeasureFilterConfig {
+  id: string;
+  tableName: string;
+  columnName: string;
+  aggregationType?: string;
+  dataType: string;
+  operator: string;
+  value: string | number;
+  logicalOperator?: string;
+}
+
+export interface PaginationConfig {
+  limit?: number;
+  skip?: number;
+  take?: number;
+  reference?: PaginationReference;
+}
+
+export interface PaginationReference {
+  dimensions?: string[];
+  instances?: string[];
+  command?: PaginationCommand;
+  nextToken?: string[];
+}
+
+export interface ExpansionConfig {
+  expansionType: string;
+  items?: string[];
+  start?: string;
+  end?: string;
+  step?: number;
+  interval?: string;
+  hierarchies?: string[];
+  hierarchyTable?: string[][];
+}
+
+export type AggregationType =
+  | 'SUM'
+  | 'COUNT'
+  | 'COUNT_DISTINCT'
+  | 'DISTINCT_COUNT'
+  | 'AVG'
+  | 'MIN'
+  | 'MAX'
+  | 'FIRST'
+  | 'LAST'
+  | 'STANDARD_DEVIATION'
+  | 'VARIANCE'
+  | 'MEDIAN'
+  | 'MODE'
+  | 'CONCATENATED'
+  | 'CONCATENATED_IDS';
+
+export type FilterType =
+  | 'VALUES'
+  | 'RANGE'
+  | 'DATE'
+  | 'MEASURE'
+  | 'TUPLE'
+  | 'RANKING'
+  | 'SEARCH'
+  | 'DATE_RANGE'
+  | 'BLANK'
+  | 'FIELD_PARAMETER'
+  | 'RELATIVE_PERIOD'
+  | 'DATE_HIERARCHY'
+  | 'COMPOSITE'
+  | 'EXPRESSION';
+
+export type RankingFilterType = 'TOP' | 'BOTTOM' | 'BOTH';
+
+export type ValuesFilterApplicationType = 'INCLUDE' | 'EXCLUDE';
+
+export type PaginationCommand = 'NEXT_HEIR' | 'SIBLING' | 'CHILDREN';
+
+export type RelativePeriodFilter =
+  | 'DAYS'
+  | 'WEEKS'
+  | 'MONTHS'
+  | 'YEARS'
+  | 'CALENDER_WEEKS'
+  | 'CALENDER_MONTHS'
+  | 'CALENDER_YEARS'
+  | 'CALENDER_QUARTERS'
+  | 'FISCAL_YEAR'
+  | 'FISCAL_QUARTER'
+  | 'HOURS'
+  | 'MINUTES';
+
+export type DateRelativeFilter =
+  | 'IS_IN_THE_LAST'
+  | 'IS_IN_THE_NEXT'
+  | 'IS_IN_THIS'
+  | 'IS_BEFORE'
+  | 'IS_AFTER';
+
+export type SortDirection = 'ASC' | 'DESC';
+
+export interface DimensionIdMapping {
+  sourceField: string;
+  targetTable: string;
+  targetField: string;
+}
+
+export interface FieldParameterMapping {
+  sourceField: string;
+  targetTable: string;
+  targetField: string;
+  filterValues?: string[];
+}
+
+export interface RelativePeriodFilterConfig {
+  duration: number;
+  period: RelativePeriodFilter;
+  relativeDateFilter: DateRelativeFilter;
+  includeToday?: boolean;
+  fiscalYearStartMonth?: number;
+}
+
+export interface DateHierarchyConfig {
+  level: 'YEAR' | 'QUARTER' | 'MONTH' | 'DAY' | 'WEEK' | 'DAYOFWEEK';
+  values: number[];
+  format?: string;
+  fiscalYearStartMonth?: number;
+}
+
+export interface BlankFilterConfig {
+  operator: 'IS_BLANK' | 'IS_NOT_BLANK';
+  treatEmptyStringAsBlank?: boolean;
+}
+
+export interface CompositeColumnConfig {
+  columnIds: string[];
+  operator: 'CONCATENATE' | 'COMBINE';
+  separator?: string;
+}

package/src/epm-query-builder/utils/format.ts

@@ -0,0 +1,22 @@
+export function formatValue(value: string | number | boolean): string {
+  if (typeof value === 'string') {
+    return `'${value.replace(/'/g, "''")}'`;
+  }
+  return String(value);
+}
+
+export function sanitizeIdentifier(identifier: string): string {
+  return identifier.replace(/[^a-zA-Z0-9_]/g, '_');
+}
+
+export function buildColumnReference(
+  tableName: string | undefined,
+  columnName: string,
+  useQuotes = true,
+): string {
+  if (!tableName) return columnName;
+  if (useQuotes) {
+    return `"${tableName}"."${columnName}"`;
+  }
+  return `${tableName}.${columnName}`;
+}

package/src/epm-query-builder/utils/sql.ts

@@ -0,0 +1,54 @@
+export function combineConditions(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} `)})`;
+}
+
+export function buildSqlSelect(
+  items: string[],
+  tableName: string,
+  whereClause?: string,
+  groupBy?: string[],
+  orderBy?: string,
+  limit?: string,
+): string {
+  let query = `SELECT ${items.join(', ')} FROM ${tableName}`;
+  if (whereClause) {
+    query += ` WHERE ${whereClause}`;
+  }
+  if (groupBy?.length) {
+    query += ` GROUP BY ${groupBy.join(', ')}`;
+  }
+  if (orderBy) {
+    query += ` ORDER BY ${orderBy}`;
+  }
+  if (limit) {
+    query += ` ${limit}`;
+  }
+  return query;
+}
+
+export function buildDistinctSelect(
+  columns: string[],
+  tableName: string,
+  whereClause?: string,
+  orderBy?: string,
+): string {
+  let query = `SELECT DISTINCT ${columns.join(', ')} FROM ${tableName}`;
+  if (whereClause) {
+    query += ` WHERE ${whereClause}`;
+  }
+  if (orderBy) {
+    query += ` ORDER BY ${orderBy}`;
+  }
+  return query;
+}
+
+export function buildLimitClause(offset?: number, limit?: number): string {
+  if (limit === undefined) return '';
+  if (offset !== undefined && offset > 0) {
+    return `LIMIT ${limit} OFFSET ${offset}`;
+  }
+  return `LIMIT ${limit}`;
+}

package/src/epm-query-builder/utils/validation.ts

@@ -0,0 +1,13 @@
+export function validateRequiredFields(obj: unknown, fields: string[]): boolean {
+  if (!obj) return false;
+  const rec = obj as Record<string, unknown>;
+  return fields.every((field) => rec[field] !== undefined && rec[field] !== null);
+}
+
+export function isEmptyOrWhitespace(value: string | undefined | null): boolean {
+  return !value || value.trim().length === 0;
+}
+
+export function isValidIdentifier(identifier: string): boolean {
+  return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(identifier);
+}

package/src/epm-query-builder/validation/QueryOptionsValidator.ts

@@ -0,0 +1,182 @@
+import { EpmQueryBuilderOptions } from '@epm-query-builder/types/query-builder-types';
+import { InvalidConfigurationError } from '@epm-query-builder/errors/QueryBuilderErrors';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+
+export class QueryOptionsValidator {
+  static validateBasicConfiguration(options: EpmQueryBuilderOptions): void {
+    if (!options.databaseDetails) {
+      throw new InvalidConfigurationError('databaseDetails is required');
+    }
+
+    const hasRows = options.rows?.length;
+    const hasColumns = options.columns?.length;
+    const hasValues = options.values?.length;
+    const dbType = String(options.databaseDetails?.databaseType || '').toLowerCase();
+    const hasSelectAll =
+      dbType === 'duckdb' &&
+      Array.isArray(options.selectedColumns) &&
+      options.selectedColumns.some((c) => {
+        const s = String(c || '').trim();
+        return s === '*' || (/\*$/i.test(s) && /\./.test(s)) || /^table(name)?[:=]/i.test(s);
+      });
+
+    if (!hasRows && !hasColumns && !hasValues && !hasSelectAll) {
+      throw new InvalidConfigurationError(
+        'At least one of rows, columns, or values must be specified',
+      );
+    }
+
+    this.validateTableNames(options);
+    this.validateMeasures(options);
+    this.validatePagination(options);
+    this.validateRelationships(options);
+  }
+
+  private static validateTableNames(options: EpmQueryBuilderOptions): void {
+    const allItems = [
+      ...(options.rows || []),
+      ...(options.columns || []),
+      ...(options.values || []),
+    ];
+
+    const missingTableNames = allItems.filter((item) => {
+      const hasDirectTableName = Boolean(item.tableName);
+      const hasExtractableTableName = Boolean(item.id && BaseUtilities.getTableNameFromId(item.id));
+      return !hasDirectTableName && !hasExtractableTableName;
+    });
+
+    if (missingTableNames.length > 0) {
+      throw new InvalidConfigurationError(
+        'All items must have a tableName specified or extractable from id',
+        {
+          itemsWithoutTableName: missingTableNames.length,
+        },
+      );
+    }
+  }
+
+  private static validateMeasures(options: EpmQueryBuilderOptions): void {
+    if (!options.values?.length) return;
+
+    const validAggregationTypes = [
+      'EARLIEST',
+      'LATEST',
+      'SUM',
+      'COUNT',
+      'DISTINCT_COUNT',
+      'AVG',
+      'AVERAGE',
+      'MIN',
+      'MINIMUM',
+      'MAX',
+      'MAXIMUM',
+      'FIRST',
+      'FIRST_VALUE',
+      'LAST',
+      'LAST_VALUE',
+      'STANDARD_DEVIATION',
+      'VARIANCE',
+      'VAR_POP',
+      'COUNT_DISTINCT',
+      'COUNT_DISTINCT_VALUE',
+      'MEDIAN',
+      'MODE',
+      'MODE_VALUE',
+      'CONCATENATED',
+      'CONCATENATED_IDS',
+    ];
+
+    options.values.forEach((measure) => {
+      if (!measure.columnName && !measure.id) {
+        throw new InvalidConfigurationError('Measure must have either columnName or id', {
+          measure: measure.label || 'unnamed',
+        });
+      }
+
+      if (
+        measure.aggregationType &&
+        !validAggregationTypes.includes(measure.aggregationType.toUpperCase())
+      ) {
+        throw new InvalidConfigurationError(
+          `Invalid aggregation type: ${measure.aggregationType}`,
+          {
+            measure: measure.label || measure.columnName,
+            validTypes: validAggregationTypes,
+          },
+        );
+      }
+    });
+  }
+
+  private static validatePagination(options: EpmQueryBuilderOptions): void {
+    if (!options.pagination) return;
+
+    const { limit, take, reference } = options.pagination;
+
+    if (!limit && !take) {
+      throw new InvalidConfigurationError(
+        'Pagination requires either limit or take to be specified',
+      );
+    }
+
+    if (reference) {
+      const { command, dimensions, instances, nextToken } = reference;
+
+      if (!command) {
+        throw new InvalidConfigurationError('Pagination reference requires command');
+      }
+
+      if (!['NEXT_HEIR', 'SIBLING', 'CHILDREN'].includes(command)) {
+        throw new InvalidConfigurationError(`Invalid pagination command: ${command}`, {
+          validCommands: ['NEXT_HEIR', 'SIBLING', 'CHILDREN'],
+        });
+      }
+
+      if (command === 'NEXT_HEIR' && (!dimensions?.length || !nextToken?.length)) {
+        throw new InvalidConfigurationError(
+          'NEXT_HEIR pagination requires dimensions and nextToken',
+        );
+      }
+
+      if (
+        (command === 'SIBLING' || command === 'CHILDREN') &&
+        (!dimensions?.length || !instances?.length)
+      ) {
+        throw new InvalidConfigurationError(
+          `${command} pagination requires dimensions and instances`,
+        );
+      }
+    }
+  }
+
+  private static validateRelationships(options: EpmQueryBuilderOptions): void {
+    const rels = options.relationships || [];
+    if (!rels.length) return;
+    rels.forEach((r, idx) => {
+      if (!r) {
+        throw new InvalidConfigurationError(`Relationship at index ${idx} is empty`);
+      }
+      const required: [string, unknown][] = [
+        ['fromTable', r.fromTable],
+        ['fromColumn', r.fromColumn],
+        ['toTable', r.toTable],
+        ['toColumn', r.toColumn],
+        ['fromColumnMultiplicity', r.fromColumnMultiplicity],
+        ['toColumnMultiplicity', r.toColumnMultiplicity],
+      ];
+      required.forEach(([k, v]) => {
+        if (typeof v !== 'string' || String(v).trim().length === 0) {
+          throw new InvalidConfigurationError(
+            `Relationship[${idx}] field '${k}' must be a non-empty string`,
+          );
+        }
+      });
+      const multOk = (m: string) => m === '*' || m === '0..1';
+      if (!multOk(r.fromColumnMultiplicity) || !multOk(r.toColumnMultiplicity)) {
+        throw new InvalidConfigurationError(
+          `Relationship[${idx}] multiplicity must be '*' or '0..1'`,
+        );
+      }
+    });
+  }
+}

package/src/epm-query-builder/validation/SqlQueryValidator.ts

@@ -0,0 +1,130 @@
+import { QueryGenerationError } from '@epm-query-builder/errors/QueryBuilderErrors';
+
+const SELECT_PATTERN = /^\s*(WITH\s+.*\s+)?SELECT\s+/;
+const SUSPICIOUS_PATTERNS: RegExp[] = [
+  /;\s*(DROP|DELETE|INSERT|UPDATE|ALTER|CREATE|EXEC|EXECUTE)\s+/i,
+  /--\s*$/m,
+  /\/\*.*?\*\//s,
+  /'\s*;\s*--/i,
+  /union\s+select/i,
+  /'\s*or\s*'.*'=/i,
+];
+
+export class SqlQueryValidator {
+  static validateQuery(query: string): void {
+    if (!query || query.trim().length === 0) {
+      throw new QueryGenerationError('Generated query is empty');
+    }
+
+    const trimmedQuery = query.trim();
+
+    if (!this.hasValidSqlStructure(trimmedQuery)) {
+      throw new QueryGenerationError('Generated query has invalid SQL structure', {
+        query: trimmedQuery.substring(0, 200),
+      });
+    }
+
+    this.validateBasicSyntax(trimmedQuery);
+    this.validateSqlInjection(trimmedQuery);
+  }
+
+  private static hasValidSqlStructure(query: string): boolean {
+    const upperQuery = query.toUpperCase();
+
+    const hasSelect = SELECT_PATTERN.test(upperQuery);
+
+    if (!hasSelect) {
+      return false;
+    }
+
+    const hasFrom = upperQuery.includes('FROM');
+    const isCountQuery = upperQuery.includes('COUNT(');
+
+    return hasFrom || isCountQuery;
+  }
+
+  private static validateBasicSyntax(query: string): void {
+    const issues: string[] = [];
+
+    const parenthesesCount = this.countParentheses(query);
+    if (parenthesesCount.open !== parenthesesCount.close) {
+      issues.push(
+        `Unbalanced parentheses: ${parenthesesCount.open} opening, ${parenthesesCount.close} closing`,
+      );
+    }
+
+    const quoteCount = this.countQuotes(query);
+    if (quoteCount.single % 2 !== 0) {
+      issues.push('Unbalanced single quotes');
+    }
+    if (quoteCount.double % 2 !== 0) {
+      issues.push('Unbalanced double quotes');
+    }
+
+    if (this.hasDanglingCommas(query)) {
+      issues.push('Query contains dangling commas');
+    }
+
+    if (this.hasEmptySelectList(query)) {
+      issues.push('SELECT statement has empty column list');
+    }
+
+    if (issues.length > 0) {
+      throw new QueryGenerationError(`SQL syntax validation failed: ${issues.join(', ')}`, {
+        issues,
+        query: query.substring(0, 200),
+      });
+    }
+  }
+
+  private static validateSqlInjection(query: string): void {
+    const foundPattern = SUSPICIOUS_PATTERNS.find((pattern) => pattern.test(query));
+    if (foundPattern) {
+      throw new QueryGenerationError('Query contains potentially dangerous SQL patterns', {
+        pattern: foundPattern.toString(),
+        query: query.substring(0, 100),
+      });
+    }
+  }
+
+  private static countParentheses(query: string): { open: number; close: number } {
+    const open = (query.match(/\(/g) || []).length;
+    const close = (query.match(/\)/g) || []).length;
+    return { open, close };
+  }
+
+  private static countQuotes(query: string): { single: number; double: number } {
+    const single = (query.match(/'/g) || []).length;
+    const double = (query.match(/"/g) || []).length;
+    return { single, double };
+  }
+
+  private static hasDanglingCommas(query: string): boolean {
+    const patterns = [
+      /,\s*FROM\s+/i,
+      /,\s*WHERE\s+/i,
+      /,\s*ORDER\s+BY\s+/i,
+      /,\s*GROUP\s+BY\s+/i,
+      /,\s*HAVING\s+/i,
+      /,\s*LIMIT\s+/i,
+      /,\s*\)/,
+      /SELECT\s+,/i,
+    ];
+
+    return patterns.some((pattern) => pattern.test(query));
+  }
+
+  private static hasEmptySelectList(query: string): boolean {
+    const selectPattern = /SELECT\s+FROM\s+/i;
+    return selectPattern.test(query);
+  }
+
+  static validateCountQuery(query: string): void {
+    this.validateQuery(query);
+
+    const upperQuery = query.toUpperCase();
+    if (!upperQuery.includes('COUNT(')) {
+      throw new QueryGenerationError('Count query must contain COUNT() function');
+    }
+  }
+}