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

package/src/query-builder/SuperFilterBuilder.ts

@@ -0,0 +1,628 @@
+import {
+  JoinExpressions,
+  RangeOperator,
+  ISuperFilterConfig,
+  IGroupFilter,
+  IManualFilterConfig,
+  IManualFilterOption,
+} from '../filters/filter-types';
+import { DateFilterFactory } from '../superFilter/DateFilterFactory';
+import { getEntityNameFormatter, getFormattedTableName } from '../utils';
+import { MAX_STRING_TYPE } from './QueryBuilder';
+
+export enum EDateRangeRelativeFilterCondition {
+  IS_IN_THE_LAST = 'IS_IN_THE_LAST',
+  IS_IN_THIS = 'IS_IN_THIS',
+  IS_IN_THE_NEXT = 'IS_IN_THE_NEXT',
+}
+
+export enum EDateRangeRelativePeriodFilterCondition {
+  DAYS = 'DAYS',
+  WEEKS = 'WEEKS',
+  CALENDER_WEEKS = 'CALENDER_WEEKS',
+  MONTHS = 'MONTHS',
+  CALENDER_MONTHS = 'CALENDER_MONTHS',
+  YEARS = 'YEARS',
+  CALENDER_YEARS = 'CALENDER_YEARS',
+  HOURS = 'HOURS',
+  MINUTES = 'MINUTES',
+  CALENDER_QUARTERS = 'CALENDER_QUARTERS',
+  FISCAL_QUARTER = 'FISCAL_QUARTER',
+  FISCAL_YEAR = 'FISCAL_YEAR',
+  QUARTERS = 'QUARTERS',
+}
+
+const rangeFilterOperator: Record<RangeOperator, string> = {
+  // common operators
+  IS: '=',
+  IS_NOT: '!=',
+  IS_BLANK: 'IS',
+  IS_NOT_BLANK: 'IS NOT',
+  //date specific operators
+  IS_AFTER: '>',
+  IS_BEFORE: '<',
+  IS_ON_OR_AFTER: '>=',
+  IS_ON_OR_BEFORE: '<=',
+  //numeric specific operators
+  IS_LESS_THAN: '<',
+  IS_LESS_THAN_OR_EQUAL_TO: '<=',
+  IS_GREATER_THAN: '>',
+  IS_GREATER_THAN_OR_EQUAL_TO: '>=',
+  //character specific operators
+  CONTAINS: 'LIKE',
+  DOES_NOT_CONTAIN: 'NOT LIKE',
+  STARTS_WITH: 'LIKE',
+  DOES_NOT_START_WITH: 'NOT LIKE',
+};
+
+const characterRangeFilterOperator = [
+  'CONTAINS',
+  'DOES_NOT_CONTAIN',
+  'STARTS_WITH',
+  'DOES_NOT_START_WITH',
+];
+
+export const negativeCharacterOperators: RangeOperator[] = [
+  'DOES_NOT_CONTAIN',
+  'DOES_NOT_START_WITH',
+  'IS_NOT',
+];
+
+export const startsWithCharacterOperators: RangeOperator[] = ['STARTS_WITH', 'DOES_NOT_START_WITH'];
+
+export const containsCharacterOperators: RangeOperator[] = ['CONTAINS', 'DOES_NOT_CONTAIN'];
+
+const SUPER_FILTER_NUMERIC_SUPPORTED_DATA_TYPES = [
+  'Int64',
+  'Decimal',
+  'Double',
+  'Integer',
+  'Number',
+];
+
+export enum EFilterDataType {
+  BOOLEAN = 'boolean',
+  DATE = 'date',
+  NUMBER = 'number',
+  STRING = 'string',
+}
+
+// Base class for super filter builder
+export class SuperFilterBuilder {
+  private superFilter: ISuperFilterConfig;
+  private databaseDetails: any;
+  private skipCountForRankingFilter: boolean;
+  private joinClauses: JoinExpressions;
+  private manualFilterOptions: IManualFilterConfig[];
+
+  // new: the selected (last) ranking filter across the whole payload
+  private lastRankingFilter: IGroupFilter | null = null;
+
+  constructor(
+    superFilter: ISuperFilterConfig,
+    databaseDetails: any,
+    skipCountForRankingFilter: boolean = false,
+    joinClauses: JoinExpressions = { alias: '', joinRelation: [] },
+    manualFilterOptions: IManualFilterConfig[] = [],
+  ) {
+    this.superFilter = superFilter;
+    this.databaseDetails = databaseDetails;
+    this.skipCountForRankingFilter = skipCountForRankingFilter;
+    this.joinClauses = joinClauses;
+    this.manualFilterOptions = manualFilterOptions;
+
+    // find the last ranking filter in the whole payload and store a reference
+    this.lastRankingFilter = this.findLastRankingFilter(this.superFilter);
+  }
+
+  /**
+   * Entry point: build SQL condition string
+   */
+  public build(): string {
+    const whereCondition = this.processGroup(this.superFilter, true, this.lastRankingFilter);
+
+    //appending ranking filter at the end of the where condition.
+    if (this.lastRankingFilter && !this.skipCountForRankingFilter) {
+      // wrap existing where in parentheses to pass as a single expression to ranking
+      const existingWhere = whereCondition ? `(${whereCondition})` : '';
+      const rankingCondition = this.processRankingFilter(this.lastRankingFilter);
+
+      if (!whereCondition) {
+        // no other filters, return ranking condition
+        return rankingCondition;
+      }
+
+      // ensure ranking condition is appended at the end
+      return `${existingWhere} AND ${rankingCondition}`;
+    }
+
+    return whereCondition;
+  }
+
+  /**
+   * Recursively process group and children
+   * - skips all ranking filters during this pass
+   * - preserves order of all other filters
+   */
+  private processGroup(
+    group: any,
+    isRoot = false,
+    lastRankingToSkip: IGroupFilter | null = null,
+  ): string {
+    if (!group?.children) throw new Error('No childrens found');
+
+    const parts: string[] = [];
+
+    for (const child of group.children) {
+      if ('groupId' in child && 'children' in child) {
+        const nested = this.processGroup(child, false, lastRankingToSkip);
+        if (nested) parts.push(nested);
+      } else if ('filters' in child) {
+        const filter = child.filters as IGroupFilter;
+
+        if (filter.sourceType?.[0] !== 'powerTables') throw new Error('Unsupported source type');
+
+        if (filter.filterType === 'RANKING') continue;
+
+        const condition = this.processFilter(filter);
+        if (condition) parts.push(condition);
+        const searchCondition = this.processSearchFilter(filter);
+        if (searchCondition) parts.push(searchCondition);
+      }
+    }
+
+    if (parts.length === 0) return '';
+
+    const joined = parts.join(` ${group.condition ?? 'AND'} `);
+
+    return isRoot ? joined : `(${joined})`;
+  }
+
+  /**
+   * Find the last ranking filter in the whole superFilter (depth-first, left-to-right traversal)
+   */
+  private findLastRankingFilter(group: any): IGroupFilter | null {
+    if (!group?.children) return null;
+
+    let last: IGroupFilter | null = null;
+
+    for (const child of group.children) {
+      if ('groupId' in child && 'children' in child) {
+        const found = this.findLastRankingFilter(child);
+        if (found) last = found;
+      } else if ('filters' in child) {
+        if (child.filters.filterType === 'RANKING') {
+          last = child.filters as IGroupFilter;
+        }
+      }
+    }
+
+    return last;
+  }
+
+  /**
+   * Decide which filter type to handle
+   */
+  private processFilter(filter: IGroupFilter): string {
+    switch (filter.filterType) {
+      case 'VALUES':
+        return this.processValuesFilter(filter);
+      case 'RANGE':
+        return this.processRangeFilter(filter);
+      case 'DATE': {
+        const column = this.getColumnName(filter);
+        return DateFilterFactory.build(column, filter);
+      }
+      case 'RANKING':
+        // ranking filters are intentionally ignored here; they are processed in build()
+        return '';
+      default:
+        if (!filter.searchConfig) {
+          throw new Error(`Unsupported filter type: ${filter.filterType}`);
+        }
+        return '';
+    }
+  }
+
+  /**
+   * Handle VALUES filter => column IN/NOT IN (...)
+   */
+  private processValuesFilter(filter: IGroupFilter): string {
+    if (!filter.valuesFilter || filter.valuesFilter.length === 0)
+      throw new Error('Values filter not found');
+    const column = this.getColumnName(filter);
+    const values = filter.valuesFilter.flatMap((v) => v.id);
+
+    const include = filter.valuesFilterApplicationType === 'include';
+    const nonBlankValues = values.filter((v) => v !== '(Blank)' && v !== null);
+    const hasBlank = values.length !== nonBlankValues.length;
+
+    const formattedValues = nonBlankValues
+      .map((v) => this.formatValue(v, this.getFilterDataType(filter)))
+      .join(', ');
+
+    const parts = [];
+    if (nonBlankValues.length) {
+      parts.push(`${column} ${include ? 'IN' : 'NOT IN'} (${formattedValues})`);
+    }
+    if (hasBlank) {
+      let baseFilter = `${column} IS ${include ? '' : 'NOT '}NULL`;
+
+      if (filter.dataType?.[0] === EFilterDataType.STRING) {
+        baseFilter = `${baseFilter} OR ${column} = ''`;
+      }
+      parts.push(baseFilter);
+    }
+
+    return `(${parts.join(include ? ' OR ' : ' AND')})`;
+  }
+
+  /**
+   * Handle RANGE filter => column op value AND/OR column op value
+   */
+
+  private processRangeFilter(filter: IGroupFilter): string {
+    if (!filter.rangeFilter || filter.rangeFilter.length === 0)
+      throw new Error('Range filter not found');
+
+    const column = this.getColumnName(filter);
+    const { rangeFilter } = filter;
+
+    const allExpressions: string[] = [];
+
+    const columnName = filter.columnNames?.[0] ?? filter.columnIds?.[0];
+    const manualConfig = this.manualFilterOptions?.find((opt) => opt.column === columnName);
+
+    for (const range of rangeFilter) {
+      const parts: string[] = [];
+      const hasFrom = range.from !== undefined && range.fromCondition !== undefined;
+      const hasTo = range.to !== undefined && range.toCondition !== undefined;
+
+      const dataType = this.getFilterDataType(filter);
+
+      // Handle "from"
+      if (hasFrom) {
+        const op = rangeFilterOperator[range.fromCondition as RangeOperator];
+        const isCharacterFilter = characterRangeFilterOperator.includes(
+          range.fromCondition as RangeOperator,
+        );
+
+        if (isCharacterFilter) {
+          if (manualConfig) {
+            const manualMatch = this.getManualFilterMatch(
+              range.from,
+              filter,
+              range.fromCondition as RangeOperator,
+              manualConfig,
+            );
+            parts.push(manualMatch);
+          } else {
+            parts.push(
+              this.formatRelativeCharacterFilter(
+                column,
+                range.fromCondition as RangeOperator,
+
+                range.from,
+              ),
+            );
+          }
+        } else {
+          const formattedValue = this.formatValue(range.from, dataType);
+          let baseFilter = `${column} ${op} ${formattedValue}`;
+          const { isBlankOperator, isNotBlankOperator } = this.getOperatorFlags(
+            range.fromCondition as RangeOperator,
+          );
+          if (isBlankOperator && dataType === EFilterDataType.STRING) {
+            baseFilter = `${baseFilter} OR ${column} = ''`;
+          }
+          if (isNotBlankOperator && dataType === EFilterDataType.STRING) {
+            baseFilter = `${baseFilter} AND ${column} <> ''`;
+          }
+          parts.push(baseFilter);
+        }
+      }
+
+      // Handle "to"
+      if (hasTo) {
+        const op = rangeFilterOperator[range.toCondition as RangeOperator];
+        const isCharacterFilter = characterRangeFilterOperator.includes(
+          range.toCondition as RangeOperator,
+        );
+
+        if (isCharacterFilter) {
+          if (manualConfig) {
+            const manualMatch = this.getManualFilterMatch(
+              range.to,
+              filter,
+              range.toCondition as RangeOperator,
+              manualConfig,
+            );
+            parts.push(manualMatch);
+          } else {
+            parts.push(
+              this.formatRelativeCharacterFilter(
+                column,
+                range.toCondition as RangeOperator,
+                range.to,
+              ),
+            );
+          }
+        } else {
+          const formattedValue = this.formatValue(range.to, dataType);
+          let baseFilter = `${column} ${op} ${formattedValue}`;
+
+          const { isBlankOperator, isNotBlankOperator } = this.getOperatorFlags(
+            range.fromCondition as RangeOperator,
+          );
+          if (isBlankOperator && dataType === EFilterDataType.STRING) {
+            baseFilter = `${baseFilter} OR ${column} = ''`;
+          }
+          if (isNotBlankOperator && dataType === EFilterDataType.STRING) {
+            baseFilter = `${baseFilter} AND ${column} <> ''`;
+          }
+          parts.push(baseFilter);
+        }
+      }
+
+      if (parts.length > 0) {
+        // If both exist and this range specifies a logicalOperator join with that
+        if (hasFrom && hasTo && range.logicalOperator) {
+          allExpressions.push(`(${parts.join(` ${range.logicalOperator.toUpperCase()} `)})`);
+        } else if (parts.length === 1) {
+          allExpressions.push(parts[0]);
+        }
+      }
+    }
+
+    if (allExpressions.length === 0) return '';
+
+    // Top-level join fallback to filter.logicalOperator OR default AND
+    return `(${allExpressions.join(` ${filter.logicalOperator?.toUpperCase() ?? 'AND'} `)})`;
+  }
+
+  /**
+   * Handle RANKING filter (top/bottom/both)
+   */
+
+  private processRankingFilter(filter: IGroupFilter): string {
+    if (!filter.rankingFilter || filter.rankingFilter.length === 0) {
+      throw new Error('Ranking filter not found');
+    }
+
+    const { rankingFilter } = filter;
+    const subQueries: string[] = [];
+    const dataType = filter.dataType?.[0];
+    const formatEntity = getEntityNameFormatter();
+
+    // Step 1: Build table name without alias
+    const tableName = getFormattedTableName(this.databaseDetails);
+
+    // Step 2: Derive safe column names
+    const targetColumn = this.getColumnName(filter);
+
+    for (const rank of rankingFilter) {
+      const { type, value, isPercentage, rankByColumnId } = rank;
+
+      const rankByColumn = formatEntity(rankByColumnId, dataType);
+      const limitCondition = isPercentage
+        ? `CAST(ROUND(COUNT(*) * ${value} / 100.0) AS INT)`
+        : `${value}`;
+
+      const whereParts: string[] = [`${rankByColumn} IS NOT NULL`];
+      if (targetColumn !== rankByColumn) {
+        whereParts.push(`${targetColumn} IS NOT NULL`);
+      }
+      const finalWhere = whereParts.length > 0 ? `WHERE ${whereParts.join(' AND ')}` : '';
+
+      // Build TOP subquery if needed
+      if (type === 'TOP' || type === 'BOTH') {
+        subQueries.push(`
+            ${targetColumn} IN (
+                SELECT ranked.${targetColumn}
+                FROM (
+                        SELECT ${targetColumn},
+                        DENSE_RANK() OVER (ORDER BY ${rankByColumn} DESC) AS rn
+                    FROM ${tableName}
+                    ${finalWhere}
+                ) ranked
+                WHERE rn <= ${limitCondition}
+            )
+            `);
+      }
+
+      // Build BOTTOM subquery if needed
+      if (type === 'BOTTOM' || type === 'BOTH') {
+        subQueries.push(`
+                ${targetColumn} IN (
+                    SELECT ranked.${targetColumn}
+                    FROM (
+                        SELECT  ${targetColumn},
+                               DENSE_RANK() OVER (ORDER BY ${rankByColumn} ASC) AS rn
+                        FROM ${tableName}
+                        ${finalWhere}
+                    ) ranked
+                    WHERE rn <= ${limitCondition}
+                )
+            `);
+      }
+    }
+
+    // Join TOP/BOTTOM subqueries with OR, wrap them to maintain AND order
+    return `(${subQueries.join(' OR ')})`;
+  }
+
+  /**
+   * Resolve column name (table.column or column only)
+   */
+  private getColumnName(filter: IGroupFilter): string {
+    const { alias, joinRelation = [] } = this.joinClauses || {};
+    let mainTableAlias = alias;
+    let col = filter.columnNames?.[0] ?? filter.columnIds?.[0];
+    // If any join.id matches the column, use join.id instead join.label and alias
+    const matchingJoin = joinRelation.find((join) => join.id === col);
+    if (matchingJoin) {
+      col = matchingJoin.label;
+      mainTableAlias = matchingJoin.alias as string;
+    }
+    const formatter = getEntityNameFormatter();
+    const tableAlias = mainTableAlias ? `${formatter(mainTableAlias)}.` : '';
+    if (!col) return '';
+    return tableAlias + formatter(col, filter.dataType?.[0]);
+  }
+
+  /**
+   * Get filter data type
+   */
+  private getFilterDataType(filter: IGroupFilter): string {
+    const dataType = filter.dataType?.[0];
+    if (!dataType) return '';
+    return dataType;
+  }
+
+  /**
+   * Format value depending on datatype/db
+   */
+  private formatValue(val: unknown, dt: string): string | null {
+    if (val === null || val === undefined) return null;
+    if (dt === 'date' || dt === 'datetime') {
+      return `'${val}'`;
+    }
+    switch (typeof val) {
+      case 'string':
+        return `'${val}'`;
+      case 'boolean':
+        return val ? '1' : '0';
+      default:
+        return String(val);
+    }
+  }
+
+  /**
+   * Format relative character filter
+   */
+  private formatRelativeCharacterFilter(column: string, op: RangeOperator, value: any): string {
+    switch (op) {
+      case 'CONTAINS':
+        return `${column} LIKE '%${value}%'`;
+      case 'DOES_NOT_CONTAIN':
+        return `${column} NOT LIKE '%${value}%'`;
+      case 'STARTS_WITH':
+        return `${column} LIKE '${value}%'`;
+      case 'DOES_NOT_START_WITH':
+        return `${column} NOT LIKE '${value}%'`;
+      default:
+        throw new Error(`Unsupported character operator: ${op}`);
+    }
+  }
+
+  /**
+   * Process search filter
+   */
+  public processSearchFilter(filter: IGroupFilter, isSearch = true): string {
+    if (!filter.searchConfig) return '';
+
+    const { joinRelation = [] } = this.joinClauses || {};
+    const columnName = filter.columnNames?.[0] ?? filter.columnIds?.[0];
+    const joinTableDetails = joinRelation.find((join) => join.id === columnName);
+    const tableRef = joinTableDetails?.alias ?? joinTableDetails?.table;
+    const formatter = getEntityNameFormatter();
+    let column = this.getColumnName(filter);
+    if (joinTableDetails) {
+      column = `${formatter(tableRef!, filter.dataType?.[0])}.${formatter(joinTableDetails.label, filter.dataType?.[0])}`;
+    }
+
+    const castType = MAX_STRING_TYPE;
+    const { searchString, matchCase } = filter.searchConfig;
+
+    const columnExpr =
+      matchCase && isSearch
+        ? `CAST(${column} AS ${castType})`
+        : `LOWER(CAST(${column} AS ${castType}))`;
+    if (!isSearch) {
+      // --- No search input mode ---
+      // This handles NULL or empty strings gracefully COALESCE support all databases
+      return `COALESCE(${columnExpr}, '')`;
+    }
+    // --- Normal search mode ---
+    const valueExpr = matchCase ? `'%${searchString}%'` : `'%${searchString.toLowerCase()}%'`;
+    return `${columnExpr} LIKE ${valueExpr}`;
+  }
+
+  private getManualFilterMatch(
+    value = '',
+    filter: IGroupFilter,
+    operator: RangeOperator,
+    manualConfig?: { column: string; options: IManualFilterOption[] },
+  ): string {
+    if (
+      !manualConfig ||
+      !Array.isArray(manualConfig.options) ||
+      manualConfig.options.length === 0
+    ) {
+      return '';
+    }
+
+    const columnType = filter.dataType?.[0] || '';
+    const formattedColumn = this.getColumnName(filter);
+
+    const {
+      isBlankOperator,
+      isNotBlankOperator,
+      isNegativeOperator,
+      isStartsWithOperator,
+      isContainsOperator,
+    } = this.getOperatorFlags(operator);
+
+    if (isBlankOperator) {
+      return columnType !== EFilterDataType.STRING
+        ? `${formattedColumn} IS NULL`
+        : `${formattedColumn} IS NULL OR ${formattedColumn} = ''`;
+    }
+    if (isNotBlankOperator) {
+      return columnType !== EFilterDataType.STRING
+        ? `${formattedColumn} IS NOT NULL`
+        : `${formattedColumn} IS NOT NULL AND ${formattedColumn} <> ''`;
+    }
+    if (!value) return isNegativeOperator ? '1=1' : '1=0';
+    const matchedValues = manualConfig.options
+      .filter((opt) => {
+        const displayText = (opt.displayName || '').toString();
+
+        if (isContainsOperator) {
+          return displayText.includes(value);
+        }
+
+        if (isStartsWithOperator) {
+          return displayText.startsWith(value);
+        }
+
+        return displayText.includes(value);
+      })
+      .map((opt) => this.formatValue(opt.id ?? opt.value, this.getFilterDataType(filter)));
+
+    if (matchedValues.length > 0) {
+      const sqlOperator = isNegativeOperator ? 'NOT IN' : 'IN';
+      return `${formattedColumn} ${sqlOperator} (${matchedValues.join(', ')})`;
+    }
+
+    return isNegativeOperator ? '1=1' : '1=0';
+  }
+
+  private getOperatorFlags(operator: RangeOperator) {
+    const isCharacterOperator = characterRangeFilterOperator.includes(operator);
+    const isBlankOperator = operator === 'IS_BLANK';
+    const isNotBlankOperator = operator === 'IS_NOT_BLANK';
+    const isNegativeOperator = negativeCharacterOperators.includes(operator);
+    const isStartsWithOperator = startsWithCharacterOperators.includes(operator);
+    const isContainsOperator = containsCharacterOperators.includes(operator);
+
+    return {
+      isCharacterOperator,
+      isBlankOperator,
+      isNotBlankOperator,
+      isNegativeOperator,
+      isStartsWithOperator,
+      isContainsOperator,
+    };
+  }
+}

package/src/runtime_var.ts

@@ -0,0 +1,8 @@
+export const RUNTIME_TABLE_NAME = '$RUNTIME_TABLE_NAME';
+export const RUNTIME_FILTER_EXPR = '$RUNTIME_FILTER_EXPR';
+export const RUNTIME_SORT_EXPR = '$RUNTIME_SORT_EXPR';
+export const RUNTIME_PAGINATION_EXPR = '$RUNTIME_PAGINATION_EXPR';
+export const RUNTIME_LOGGEDIN_EMAIL = '$RUNTIME_LOGGEDIN_EMAIL';
+export const RUNTIME_LOGGEDIN_NAME = '$RUNTIME_LOGGEDIN_NAME';
+export const RUNTIME_CURRENT_DATE = '$RUNTIME_CURRENT_DATE';
+export const RUNTIME_CURRENT_DATETIME = '$RUNTIME_CURRENT_DATETIME';

package/src/sql-lib/binary_expr.ts

@@ -0,0 +1,16 @@
+import { Binary, ExpressionValue } from '../sql-types';
+
+export function toBinaryExpression(
+  operator: string,
+  left: ExpressionValue,
+  right: ExpressionValue,
+  parentheses = false,
+): Binary {
+  return {
+    type: 'binary_expr',
+    operator,
+    left,
+    right,
+    parentheses,
+  };
+}

package/src/sql-lib/case.ts

@@ -0,0 +1,16 @@
+import { Binary, Case, ExpressionValue } from '../sql-types';
+
+export function toCase(args: {
+  whenList: {
+    cond: Binary;
+    result: ExpressionValue;
+    type: 'when';
+  }[];
+  elseResult: { type: 'else'; result: ExpressionValue };
+}): Case {
+  return {
+    type: 'case',
+    expr: null,
+    args: [...args.whenList, args.elseResult],
+  };
+}

package/src/sql-lib/column.ts

@@ -0,0 +1,18 @@
+import { Column, ColumnRef, ExpressionValue } from '../sql-types';
+
+export function toColumnRef(columName: string, table: string | null = null): ColumnRef {
+  return {
+    type: 'column_ref',
+    table: table,
+    column: columName,
+    collate: undefined,
+  };
+}
+
+export function toColumn(expr: ExpressionValue, as: string | null = null): Column {
+  return {
+    type: 'column',
+    expr: expr,
+    as: as,
+  };
+}

package/src/sql-lib/else.ts

@@ -0,0 +1,13 @@
+import { ExpressionValue } from '../sql-types';
+
+export type ElseType = {
+  type: 'else';
+  result: ExpressionValue;
+};
+
+export function toElse(result: ExpressionValue): ElseType {
+  return {
+    type: 'else',
+    result,
+  };
+}