http-request-manager 18.15.32 → 18.15.34

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

@@ -0,0 +1,246 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,13 @@
+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

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

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

@@ -0,0 +1,284 @@
+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];
+  }
+}