http-request-manager 18.15.34 → 18.16.1

package/src/lib/services/SQL-DixieJS service/dexie-query-executor.ts

@@ -1,246 +0,0 @@
-import { inject, Injectable } from '@angular/core';
-import { firstValueFrom } from 'rxjs';
-import { Table } from 'dexie';
-import { DatabaseManagerService } from '../database-manager-service/database.manager.service';
-import { SqlValidationError } from './models/sql-errors.model';
-import { ExecutionPlan, ExecutionPlanType, PlanStep } from './models/execution-plan.model';
-
-@Injectable({ providedIn: 'root' })
-export class DexieQueryExecutor {
-  private readonly _dbManager = inject(DatabaseManagerService);
-
-  async execute(plan: ExecutionPlan): Promise<any[]> {
-    switch (plan.type) {
-      case ExecutionPlanType.SIMPLE:       return this._executeSimple(plan);
-      case ExecutionPlanType.AND_BOUNDED:  return this._executeAndBounded(plan);
-      case ExecutionPlanType.AND_COMPOUND: return this._executeAndCompound(plan);
-      case ExecutionPlanType.OR_MERGE:     return this._executeOrMerge(plan);
-      case ExecutionPlanType.JOIN_HASH:    return this._executeJoinHash(plan);
-      default:
-        throw new SqlValidationError(`Unknown plan type`);
-    }
-  }
-
-  // ─── SIMPLE ───────────────────────────────────────────────────────────────
-
-  private async _executeSimple(plan: ExecutionPlan): Promise<any[]> {
-    const table = await this._getTable(plan.table);
-    let rows: any[];
-
-    if (!plan.primaryStep) {
-      rows = await table.toArray();
-    } else {
-      rows = await this._applyDexieStep(table, plan.primaryStep);
-    }
-
-    return this._postProcess(rows, plan);
-  }
-
-  // ─── AND_BOUNDED ──────────────────────────────────────────────────────────
-
-  private async _executeAndBounded(plan: ExecutionPlan): Promise<any[]> {
-    const table = await this._getTable(plan.table);
-
-    if (plan.compoundWarnCols?.length) {
-      console.warn(
-        `[DexieSqlService] Consider adding a compound index [${plan.compoundWarnCols.join('+')}] ` +
-        `to table "${plan.table}" for full index coverage on AND conditions.`,
-      );
-    }
-
-    let rows = plan.primaryStep
-      ? await this._applyDexieStep(table, plan.primaryStep)
-      : await table.toArray();
-
-    // Apply remaining AND conditions as JS filter
-    for (const f of plan.boundedFilters) {
-      rows = rows.filter(row => this._matchStep(row, f));
-    }
-
-    return this._postProcess(rows, plan);
-  }
-
-  // ─── AND_COMPOUND ─────────────────────────────────────────────────────────
-
-  private async _executeAndCompound(plan: ExecutionPlan): Promise<any[]> {
-    const table = await this._getTable(plan.table);
-    const rows  = await (table.where(plan.compoundIndex!) as any).equals(plan.compoundValues!).toArray();
-    return this._postProcess(rows, plan);
-  }
-
-  // ─── OR_MERGE ─────────────────────────────────────────────────────────────
-
-  private async _executeOrMerge(plan: ExecutionPlan): Promise<any[]> {
-    const table    = await this._getTable(plan.table);
-    const branches = plan.orBranches ?? [];
-
-    const results = await Promise.all(
-      branches.map(branch => this._applyDexieStep(table, branch)),
-    );
-
-    // Deduplicate by primary key
-    const pk   = plan.dedupeKey ?? 'id';
-    const seen = new Map<any, any>();
-    for (const batch of results) {
-      for (const row of batch) {
-        seen.set(row[pk], row);
-      }
-    }
-
-    return this._postProcess(Array.from(seen.values()), plan);
-  }
-
-  // ─── JOIN_HASH ────────────────────────────────────────────────────────────
-
-  private async _executeJoinHash(plan: ExecutionPlan): Promise<any[]> {
-    const join = plan.joinInfo!;
-
-    const leftTable  = await this._getTable(join.leftTable);
-    const rightTable = await this._getTable(join.rightTable);
-
-    // Fetch left rows (full scan; bounded WHERE filters applied post-join)
-    const leftRows = await leftTable.toArray();
-
-    // Extract FK values for right-side lookup
-    const fkValues = [...new Set(leftRows.map(r => r[join.leftKey]).filter(v => v != null))];
-
-    // Fetch right rows indexed by join key
-    const rightRows: any[] = fkValues.length > 0
-      ? await (rightTable.where(join.rightKey) as any).anyOf(fkValues).toArray()
-      : [];
-
-    // Build lookup map from rightKey → array of right rows
-    const rightMap = new Map<any, any[]>();
-    for (const rr of rightRows) {
-      const k = rr[join.rightKey];
-      if (!rightMap.has(k)) rightMap.set(k, []);
-      rightMap.get(k)!.push(rr);
-    }
-
-    // Hash join
-    const joined: any[] = [];
-    for (const lr of leftRows) {
-      const matches = rightMap.get(lr[join.leftKey]);
-      if (matches?.length) {
-        for (const rr of matches) {
-          joined.push({ ...lr, ...rr });
-        }
-      } else if (join.joinType === 'left') {
-        joined.push({ ...lr });
-      }
-    }
-
-    // Apply post-join bounded filters (any WHERE conditions from the query)
-    let result = joined;
-    for (const f of plan.boundedFilters) {
-      result = result.filter(row => this._matchStep(row, f));
-    }
-
-    return this._postProcess(result, plan);
-  }
-
-  // ─── Post-processing ──────────────────────────────────────────────────────
-
-  private _postProcess(rows: any[], plan: ExecutionPlan): any[] {
-    let result = rows;
-
-    // ORDER BY
-    if (plan.orderBy) {
-      const { col, dir } = plan.orderBy;
-      result = [...result].sort((a, b) => {
-        const av = a[col];
-        const bv = b[col];
-        if (av == null && bv == null) return 0;
-        if (av == null) return 1;
-        if (bv == null) return -1;
-        const cmp = av < bv ? -1 : av > bv ? 1 : 0;
-        return dir === 'desc' ? -cmp : cmp;
-      });
-    }
-
-    // LIMIT / OFFSET
-    const offset = plan.offset ?? 0;
-    const limit  = plan.limit  ?? null;
-    if (offset > 0 || limit != null) {
-      result = result.slice(offset, limit != null ? offset + limit : undefined);
-    }
-
-    // Projection
-    if (plan.projection && plan.projection.length > 0) {
-      const cols = plan.projection;
-      result = result.map(row => {
-        const projected: Record<string, any> = {};
-        for (const c of cols) projected[c] = row[c];
-        return projected;
-      });
-    }
-
-    // DISTINCT
-    if (plan.distinct) {
-      const seen = new Set<string>();
-      result = result.filter(row => {
-        const key = JSON.stringify(row);
-        if (seen.has(key)) return false;
-        seen.add(key);
-        return true;
-      });
-    }
-
-    // COUNT(*)
-    if (plan.aggregate === 'count') {
-      return [{ count: result.length }];
-    }
-
-    return result;
-  }
-
-  // ─── Dexie step dispatch ──────────────────────────────────────────────────
-
-  private _applyDexieStep(table: Table<any, any>, step: PlanStep): Promise<any[]> {
-    const col = step.col;
-    const val = step.val;
-
-    switch (step.op) {
-      case 'equals':       return table.where(col).equals(val).toArray();
-      case 'notEqual':     return table.where(col).notEqual(val).toArray();
-      case 'above':        return table.where(col).above(val).toArray();
-      case 'aboveOrEqual': return table.where(col).aboveOrEqual(val).toArray();
-      case 'below':        return table.where(col).below(val).toArray();
-      case 'belowOrEqual': return table.where(col).belowOrEqual(val).toArray();
-      case 'between':      return table.where(col).between(val[0], val[1], true, true).toArray();
-      case 'anyOf':        return table.where(col).anyOf(val).toArray();
-      case 'noneOf':       return table.where(col).noneOf(val).toArray();
-      case 'startsWith':   return table.where(col).startsWith(val).toArray();
-      default:
-        throw new SqlValidationError(`Unsupported Dexie op: "${step.op}"`);
-    }
-  }
-
-  // ─── JS row predicate ─────────────────────────────────────────────────────
-
-  private _matchStep(row: any, step: PlanStep): boolean {
-    const rv = row[step.col];
-    const v  = step.val;
-    switch (step.op) {
-      case 'equals':       return rv === v;
-      case 'notEqual':     return rv !== v;
-      case 'above':        return rv > v;
-      case 'aboveOrEqual': return rv >= v;
-      case 'below':        return rv < v;
-      case 'belowOrEqual': return rv <= v;
-      case 'between':      return rv >= v[0] && rv <= v[1];
-      case 'anyOf':        return (v as any[]).includes(rv);
-      case 'noneOf':       return !(v as any[]).includes(rv);
-      case 'startsWith':   return typeof rv === 'string' && rv.startsWith(v);
-      default:             return true;
-    }
-  }
-
-  // ─── Table accessor ───────────────────────────────────────────────────────
-
-  private async _getTable(tableName: string): Promise<Table<any, any>> {
-    const t = await firstValueFrom(this._dbManager.getDatabaseTable(tableName));
-    if (!t) throw new SqlValidationError(`Table "${tableName}" not found or not accessible`);
-    return t;
-  }
-}

package/src/lib/services/SQL-DixieJS service/dexie-sql.service.ts

@@ -1,31 +0,0 @@
-import { inject, Injectable } from '@angular/core';
-import { from, Observable } from 'rxjs';
-import { DexieSqlOptions } from './models/sql-options.model';
-import { SqlParser } from './sql-parser';
-import { SchemaValidator } from './schema-validator';
-import { QueryPlanner } from './query-planner';
-import { DexieQueryExecutor } from './dexie-query-executor';
-
-@Injectable({ providedIn: 'root' })
-export class DexieSqlService {
-  private readonly _parser    = new SqlParser();
-  private readonly _validator = inject(SchemaValidator);
-  private readonly _planner   = new QueryPlanner();
-  private readonly _executor  = inject(DexieQueryExecutor);
-
-  /**
-   * Execute a MySQL-syntax SQL SELECT string against the DexieJS IndexedDB database.
-   * Returns an Observable that emits the result array and completes, or errors with
-   * SqlParseError / SqlValidationError if the query is invalid.
-   */
-  query(sql: string, options: DexieSqlOptions = {}): Observable<any[]> {
-    return from(this._run(sql, options));
-  }
-
-  private async _run(sql: string, options: DexieSqlOptions): Promise<any[]> {
-    const parsed    = this._parser.parse(sql);
-    const validated = await this._validator.validate(parsed, options);
-    const plan      = this._planner.plan(validated, options);
-    return this._executor.execute(plan);
-  }
-}

package/src/lib/services/SQL-DixieJS service/index.ts

@@ -1,4 +0,0 @@
-export * from './dexie-sql.service';
-export * from './models/index';
-export { ParseResult } from './sql-parser';
-export { TableSchemaInfo, ValidatedQuery } from './schema-validator';

package/src/lib/services/SQL-DixieJS service/models/execution-plan.model.ts

@@ -1,52 +0,0 @@
-export enum ExecutionPlanType {
-  SIMPLE       = 'SIMPLE',
-  AND_BOUNDED  = 'AND_BOUNDED',
-  AND_COMPOUND = 'AND_COMPOUND',
-  OR_MERGE     = 'OR_MERGE',
-  JOIN_HASH    = 'JOIN_HASH',
-}
-
-export type DexieOp =
-  | 'equals'
-  | 'notEqual'
-  | 'above'
-  | 'aboveOrEqual'
-  | 'below'
-  | 'belowOrEqual'
-  | 'between'
-  | 'anyOf'
-  | 'noneOf'
-  | 'startsWith';
-
-export interface PlanStep {
-  col: string;
-  op: DexieOp;
-  val: any;
-}
-
-export interface JoinInfo {
-  leftTable:  string;
-  rightTable: string;
-  leftKey:    string;
-  rightKey:   string;
-  joinType:  'inner' | 'left';
-}
-
-export interface ExecutionPlan {
-  type:              ExecutionPlanType;
-  table:             string;
-  primaryStep:       PlanStep | null;
-  boundedFilters:    PlanStep[];
-  compoundIndex?:    string;
-  compoundValues?:   any[];
-  compoundWarnCols?: string[];
-  orBranches?:       PlanStep[];
-  joinInfo?:         JoinInfo;
-  orderBy?:          { col: string; dir: 'asc' | 'desc' } | null;
-  limit?:            number | null;
-  offset?:           number | null;
-  projection?:       string[] | null;
-  aggregate?:        'count' | null;
-  distinct?:         boolean;
-  dedupeKey?:        string;
-}

package/src/lib/services/SQL-DixieJS service/models/index.ts

@@ -1,3 +0,0 @@
-export * from './sql-errors.model';
-export * from './sql-options.model';
-export * from './execution-plan.model';

package/src/lib/services/SQL-DixieJS service/models/sql-errors.model.ts

@@ -1,13 +0,0 @@
-export class SqlParseError extends Error {
-  override name = 'SqlParseError';
-  constructor(message: string) {
-    super(message);
-  }
-}
-
-export class SqlValidationError extends Error {
-  override name = 'SqlValidationError';
-  constructor(message: string) {
-    super(message);
-  }
-}

package/src/lib/services/SQL-DixieJS service/models/sql-options.model.ts

@@ -1,3 +0,0 @@
-export interface DexieSqlOptions {
-  strict?: boolean;
-}

package/src/lib/services/SQL-DixieJS service/query-planner.ts

@@ -1,284 +0,0 @@
-import { SqlValidationError } from './models/sql-errors.model';
-import { DexieSqlOptions } from './models/sql-options.model';
-import {
-  ExecutionPlan,
-  ExecutionPlanType,
-  DexieOp,
-  PlanStep,
-  JoinInfo,
-} from './models/execution-plan.model';
-import { ValidatedQuery, TableSchemaInfo } from './schema-validator';
-
-export class QueryPlanner {
-
-  plan(validated: ValidatedQuery, options: DexieSqlOptions = {}): ExecutionPlan {
-    const { ast, schemas, aliases } = validated;
-    const fromItems: any[] = (ast as any).from ?? [];
-    const mainTable  = fromItems[0]?.table ?? '';
-    const dedupeKey  = schemas[mainTable]?.pk ?? 'id';
-    const basePlan   = this._buildBasePlanExtras(ast, mainTable, dedupeKey);
-
-    // ── JOIN ────────────────────────────────────────────────────────────────
-    const joinItem = fromItems.find((f: any) => f.join);
-    if (joinItem) {
-      return this._buildJoinPlan(ast, fromItems, joinItem, schemas, aliases, mainTable, basePlan);
-    }
-
-    const where = (ast as any).where;
-
-    // ── No WHERE ─────────────────────────────────────────────────────────────
-    if (!where) {
-      return { ...basePlan, type: ExecutionPlanType.SIMPLE, primaryStep: null, boundedFilters: [] };
-    }
-
-    // ── OR ──────────────────────────────────────────────────────────────────
-    if (where.operator === 'OR') {
-      return this._buildOrPlan(where, basePlan, aliases, mainTable);
-    }
-
-    // ── AND ──────────────────────────────────────────────────────────────────
-    if (where.operator === 'AND') {
-      return this._buildAndPlan(where, basePlan, schemas, aliases, mainTable, options);
-    }
-
-    // ── Single condition ────────────────────────────────────────────────────
-    const step = this._nodeToStep(where, aliases, mainTable);
-    return { ...basePlan, type: ExecutionPlanType.SIMPLE, primaryStep: step, boundedFilters: [] };
-  }
-
-  // ─── AND ──────────────────────────────────────────────────────────────────
-
-  private _buildAndPlan(
-    where:        any,
-    basePlan:     Partial<ExecutionPlan> & { table: string },
-    schemas:      Record<string, TableSchemaInfo>,
-    aliases:      Record<string, string>,
-    mainTable:    string,
-    _options:     DexieSqlOptions,
-  ): ExecutionPlan {
-    const conditions = this._flattenAnd(where);
-    const cols       = conditions.map((c: any) => c.left?.column as string).filter(Boolean);
-    const schema     = schemas[mainTable];
-
-    // Check for matching compound index
-    const matchedCompound = schema?.compoundIndexes.find(
-      ci => ci.length === cols.length && cols.every(c => ci.includes(c)),
-    );
-
-    if (matchedCompound) {
-      const orderedValues = matchedCompound.map(ciCol => {
-        const cond = conditions.find((c: any) => c.left?.column === ciCol);
-        return this._extractValue(cond.right, cond.operator);
-      });
-      return {
-        ...basePlan,
-        type:           ExecutionPlanType.AND_COMPOUND,
-        primaryStep:    null,
-        boundedFilters: [],
-        compoundIndex:  `[${matchedCompound.join('+')}]`,
-        compoundValues: orderedValues,
-      } as ExecutionPlan;
-    }
-
-    // Pragmatic: first condition → Dexie, rest → JS filter
-    const primaryStep     = this._nodeToStep(conditions[0], aliases, mainTable);
-    const boundedFilters  = conditions.slice(1).map((c: any) => this._nodeToStep(c, aliases, mainTable));
-
-    return {
-      ...basePlan,
-      type:             ExecutionPlanType.AND_BOUNDED,
-      primaryStep,
-      boundedFilters,
-      compoundWarnCols: cols,
-    } as ExecutionPlan;
-  }
-
-  // ─── OR ───────────────────────────────────────────────────────────────────
-
-  private _buildOrPlan(
-    where:        any,
-    basePlan:     Partial<ExecutionPlan> & { table: string },
-    aliases:      Record<string, string>,
-    mainTable:    string,
-  ): ExecutionPlan {
-    const branches  = this._flattenOr(where);
-    const orBranches = branches.map((b: any) => this._nodeToStep(b, aliases, mainTable));
-    return {
-      ...basePlan,
-      type:           ExecutionPlanType.OR_MERGE,
-      primaryStep:    null,
-      boundedFilters: [],
-      orBranches,
-    } as ExecutionPlan;
-  }
-
-  // ─── JOIN ─────────────────────────────────────────────────────────────────
-
-  private _buildJoinPlan(
-    ast:        any,
-    fromItems:  any[],
-    joinItem:   any,
-    schemas:    Record<string, TableSchemaInfo>,
-    aliases:    Record<string, string>,
-    mainTable:  string,
-    basePlan:   Partial<ExecutionPlan> & { table: string },
-  ): ExecutionPlan {
-    const rightTable = joinItem.table as string;
-    const onNode     = joinItem.on;
-    const joinType   = (joinItem.join as string).toLowerCase().includes('left') ? 'left' : 'inner';
-
-    // Resolve join keys from ON clause
-    const l = onNode?.left;
-    const r = onNode?.right;
-
-    const lTableResolved = aliases[l?.table ?? ''] ?? l?.table ?? mainTable;
-    const rTableResolved = aliases[r?.table ?? ''] ?? r?.table ?? rightTable;
-
-    let leftKey: string, rightKey: string;
-    if (lTableResolved === mainTable) {
-      leftKey  = l?.column ?? '';
-      rightKey = r?.column ?? '';
-    } else {
-      leftKey  = r?.column ?? '';
-      rightKey = l?.column ?? '';
-    }
-
-    const joinInfo: JoinInfo = { leftTable: mainTable, rightTable, leftKey, rightKey, joinType };
-
-    // WHERE conditions become post-join bounded filters
-    const where = (ast as any).where;
-    const boundedFilters: PlanStep[] = [];
-    if (where) {
-      this._flattenAnd(where.operator === 'AND' ? where : { operator: 'AND', left: where, right: null })
-        .filter(Boolean)
-        .forEach((c: any) => boundedFilters.push(this._nodeToStep(c, aliases, mainTable)));
-    }
-
-    return {
-      ...basePlan,
-      type: ExecutionPlanType.JOIN_HASH,
-      primaryStep: null,
-      boundedFilters: where ? (where.operator === 'AND' ? boundedFilters : [this._nodeToStep(where, aliases, mainTable)]) : [],
-      joinInfo,
-    } as ExecutionPlan;
-  }
-
-  // ─── Base plan extras (ORDER BY, LIMIT, OFFSET, projection, etc.) ─────────
-
-  private _buildBasePlanExtras(ast: any, mainTable: string, dedupeKey: string): Partial<ExecutionPlan> & { table: string } {
-    const plan: Partial<ExecutionPlan> & { table: string } = { table: mainTable, dedupeKey };
-
-    // ORDER BY
-    const orderby: any[] = ast.orderby ?? [];
-    if (orderby.length > 0) {
-      const ob = orderby[0];
-      plan.orderBy = {
-        col: ob.expr?.column ?? '',
-        dir: ob.type?.toUpperCase() === 'DESC' ? 'desc' : 'asc',
-      };
-    }
-
-    // LIMIT / OFFSET
-    if (ast.limit) {
-      const vals: any[] = ast.limit.value ?? [];
-      if (ast.limit.seperator === 'offset' && vals.length === 2) {
-        plan.limit  = vals[0].value;
-        plan.offset = vals[1].value;
-      } else if (vals.length === 1) {
-        plan.limit = vals[0].value;
-      }
-    }
-
-    // Projection
-    const columns: any[] = ast.columns;
-    if (columns && columns !== '*' as any) {
-      // COUNT(*)
-      const countCol = columns.find((c: any) => c.expr?.type === 'aggr_func' && c.expr?.name === 'COUNT');
-      if (countCol) {
-        plan.aggregate  = 'count';
-        plan.projection = null;
-      } else {
-        const projected = columns
-          .filter((c: any) => c.expr?.type === 'column_ref')
-          .map((c: any) => c.expr.column as string);
-        plan.projection = projected.length > 0 ? projected : null;
-      }
-    } else {
-      plan.projection = null;
-    }
-
-    // DISTINCT
-    plan.distinct = ast.distinct === 'DISTINCT';
-
-    return plan;
-  }
-
-  // ─── Node → PlanStep ──────────────────────────────────────────────────────
-
-  private _nodeToStep(node: any, aliases: Record<string, string>, defaultTable: string): PlanStep {
-    if (!node || node.type !== 'binary_expr' || node.left?.type !== 'column_ref') {
-      throw new SqlValidationError(`Unsupported WHERE condition structure`);
-    }
-
-    const col = node.left.column as string;
-    const { op, val } = this._mapOperator(node.operator, node.right);
-    return { col, op, val };
-  }
-
-  private _mapOperator(astOp: string, rightNode: any): { op: DexieOp; val: any } {
-    switch (astOp) {
-      case '=':   return { op: 'equals',        val: this._extractValue(rightNode, astOp) };
-      case '!=':
-      case '<>':  return { op: 'notEqual',       val: this._extractValue(rightNode, astOp) };
-      case '>':   return { op: 'above',          val: this._extractValue(rightNode, astOp) };
-      case '>=':  return { op: 'aboveOrEqual',   val: this._extractValue(rightNode, astOp) };
-      case '<':   return { op: 'below',          val: this._extractValue(rightNode, astOp) };
-      case '<=':  return { op: 'belowOrEqual',   val: this._extractValue(rightNode, astOp) };
-      case 'BETWEEN': {
-        const vals: any[] = rightNode?.value ?? [];
-        return { op: 'between', val: [vals[0]?.value, vals[1]?.value] };
-      }
-      case 'IN':      return { op: 'anyOf',  val: (rightNode?.value ?? []).map((v: any) => v.value) };
-      case 'NOT IN':  return { op: 'noneOf', val: (rightNode?.value ?? []).map((v: any) => v.value) };
-      case 'LIKE': {
-        const raw = String(rightNode?.value ?? '');
-        if (raw.startsWith('%')) {
-          throw new SqlValidationError('LIKE with leading wildcard is not supported');
-        }
-        if (raw.includes('%')) {
-          const pctIdx = raw.indexOf('%');
-          if (pctIdx !== raw.length - 1) {
-            throw new SqlValidationError('LIKE with leading wildcard is not supported');
-          }
-          return { op: 'startsWith', val: raw.slice(0, -1) };
-        }
-        // No wildcard — treat as equals
-        return { op: 'equals', val: raw };
-      }
-      default:
-        throw new SqlValidationError(`Unsupported SQL operator: "${astOp}"`);
-    }
-  }
-
-  private _extractValue(node: any, _op: string): any {
-    return node?.value ?? null;
-  }
-
-  // ─── WHERE tree helpers ───────────────────────────────────────────────────
-
-  private _flattenAnd(node: any): any[] {
-    if (!node) return [];
-    if (node.type === 'binary_expr' && node.operator === 'AND') {
-      return [...this._flattenAnd(node.left), ...this._flattenAnd(node.right)];
-    }
-    return [node];
-  }
-
-  private _flattenOr(node: any): any[] {
-    if (!node) return [];
-    if (node.type === 'binary_expr' && node.operator === 'OR') {
-      return [...this._flattenOr(node.left), ...this._flattenOr(node.right)];
-    }
-    return [node];
-  }
-}