http-request-manager 18.15.34 → 18.16.1

package/src/lib/services/SQL-DixieJS service/schema-validator.ts

@@ -1,217 +0,0 @@
-import { inject, Injectable } from '@angular/core';
-import { firstValueFrom } from 'rxjs';
-import { DatabaseManagerService } from '../database-manager-service/database.manager.service';
-import { DexieSqlOptions } from './models/sql-options.model';
-import { SqlValidationError } from './models/sql-errors.model';
-import { ParseResult } from './sql-parser';
-
-export interface TableSchemaInfo {
-  pk:               string;
-  simpleIndexes:    string[];
-  compoundIndexes:  string[][];
-}
-
-export interface ValidatedQuery {
-  ast:     any;
-  schemas: Record<string, TableSchemaInfo>;
-  aliases: Record<string, string>;
-}
-
-@Injectable({ providedIn: 'root' })
-export class SchemaValidator {
-  private readonly _dbManager = inject(DatabaseManagerService);
-
-  async validate(parsed: ParseResult, options: DexieSqlOptions = {}): Promise<ValidatedQuery> {
-    const { ast } = parsed;
-    const fromItems: any[] = (ast as any).from ?? [];
-
-    // Build alias map and collect real table names
-    const aliases: Record<string, string> = {};
-    const tableNames: string[] = [];
-    for (const item of fromItems) {
-      if (item.table) {
-        tableNames.push(item.table);
-        aliases[item.as ?? item.table] = item.table;
-        aliases[item.table] = item.table;
-      }
-    }
-
-    if (tableNames.length === 0) {
-      throw new SqlValidationError('No tables found in query');
-    }
-
-    // Fetch and parse schema for each table
-    const schemas: Record<string, TableSchemaInfo> = {};
-    for (const tableName of tableNames) {
-      const schemaArr = await firstValueFrom(this._dbManager.getDatabaseTableSchema(tableName));
-      if (!schemaArr || schemaArr.length === 0) {
-        throw new SqlValidationError(`Table not found: "${tableName}"`);
-      }
-      schemas[tableName] = this._parseSchemaArray(schemaArr);
-    }
-
-    const defaultTable = tableNames[0];
-
-    // Validate WHERE columns
-    if ((ast as any).where) {
-      this._validateWhereNode((ast as any).where, defaultTable, aliases, schemas);
-    }
-
-    // Validate ORDER BY columns
-    for (const ob of ((ast as any).orderby ?? [])) {
-      if (ob.expr?.type === 'column_ref') {
-        const tbl = this._resolveTable(ob.expr.table, defaultTable, aliases);
-        this._assertIndexed(ob.expr.column, tbl, schemas);
-      }
-    }
-
-    // Validate JOIN ON columns
-    for (const item of fromItems) {
-      if (item.join && item.on) {
-        this._validateJoinOn(item.on, tableNames, aliases, schemas);
-      }
-    }
-
-    // Strict mode: AND without compound index → throw
-    if (options.strict && (ast as any).where) {
-      this._checkStrictAnd((ast as any).where, defaultTable, aliases, schemas);
-    }
-
-    return { ast, schemas, aliases };
-  }
-
-  // ─── Helpers ─────────────────────────────────────────────────────────────
-
-  private _parseSchemaArray(schemaArr: string[]): TableSchemaInfo {
-    const pk = schemaArr[0] ?? '';
-    const simpleIndexes:   string[]   = [];
-    const compoundIndexes: string[][] = [];
-
-    for (let i = 1; i < schemaArr.length; i++) {
-      const s = schemaArr[i];
-      if (s.startsWith('[') && s.endsWith(']')) {
-        compoundIndexes.push(s.slice(1, -1).split('+'));
-      } else {
-        simpleIndexes.push(s.replace(/^[*&]/, ''));
-      }
-    }
-
-    return { pk, simpleIndexes, compoundIndexes };
-  }
-
-  private _isIndexed(col: string, tableName: string, schemas: Record<string, TableSchemaInfo>): boolean {
-    const schema = schemas[tableName];
-    if (!schema) return false;
-    return col === schema.pk || schema.simpleIndexes.includes(col);
-  }
-
-  private _assertIndexed(col: string, tableName: string, schemas: Record<string, TableSchemaInfo>): void {
-    if (!this._isIndexed(col, tableName, schemas)) {
-      throw new SqlValidationError(`Column "${col}" on table "${tableName}" is not indexed`);
-    }
-  }
-
-  private _resolveTable(tableRef: string | null, defaultTable: string, aliases: Record<string, string>): string {
-    if (!tableRef) return defaultTable;
-    return aliases[tableRef] ?? tableRef;
-  }
-
-  private _validateWhereNode(
-    node: any,
-    defaultTable: string,
-    aliases: Record<string, string>,
-    schemas: Record<string, TableSchemaInfo>,
-  ): void {
-    if (!node || node.type !== 'binary_expr') return;
-
-    if (node.operator === 'AND' || node.operator === 'OR') {
-      this._validateWhereNode(node.left,  defaultTable, aliases, schemas);
-      this._validateWhereNode(node.right, defaultTable, aliases, schemas);
-      return;
-    }
-
-    if (node.left?.type === 'column_ref') {
-      const tbl = this._resolveTable(node.left.table, defaultTable, aliases);
-      this._assertIndexed(node.left.column, tbl, schemas);
-    }
-  }
-
-  private _validateJoinOn(
-    onNode:     any,
-    tableNames: string[],
-    aliases:    Record<string, string>,
-    schemas:    Record<string, TableSchemaInfo>,
-  ): void {
-    if (!onNode || onNode.type !== 'binary_expr' || onNode.operator !== '=') return;
-
-    const l = onNode.left;
-    const r = onNode.right;
-    if (l?.type !== 'column_ref' || r?.type !== 'column_ref') return;
-
-    const leftTable  = tableNames[0];
-    const rightTable = tableNames[tableNames.length - 1];
-
-    // Resolve which ON side belongs to left vs right table
-    const lTableResolved = aliases[l.table ?? ''] ?? l.table ?? leftTable;
-    const rTableResolved = aliases[r.table ?? ''] ?? r.table ?? rightTable;
-
-    const leftKey  = lTableResolved === leftTable  ? { col: l.column, table: lTableResolved } : { col: r.column, table: rTableResolved };
-    const rightKey = lTableResolved === leftTable  ? { col: r.column, table: rTableResolved } : { col: l.column, table: lTableResolved };
-
-    // Left-side key: PK is exempt, otherwise must be indexed
-    const leftSchema = schemas[leftKey.table];
-    if (leftSchema && leftKey.col !== leftSchema.pk && !leftSchema.simpleIndexes.includes(leftKey.col)) {
-      throw new SqlValidationError(`JOIN column "${leftKey.col}" on table "${leftKey.table}" must be indexed`);
-    }
-
-    // Right-side key: must be indexed (including PK counts)
-    if (!this._isIndexed(rightKey.col, rightKey.table, schemas)) {
-      throw new SqlValidationError(`JOIN column "${rightKey.col}" on table "${rightKey.table}" must be indexed`);
-    }
-  }
-
-  private _checkStrictAnd(
-    whereNode:    any,
-    defaultTable: string,
-    aliases:      Record<string, string>,
-    schemas:      Record<string, TableSchemaInfo>,
-  ): void {
-    if (!whereNode || whereNode.type !== 'binary_expr' || whereNode.operator !== 'AND') return;
-
-    const leafCols = this._flattenAndCols(whereNode, defaultTable, aliases);
-    if (leafCols.length < 2) return;
-
-    const tableName = leafCols[0].table;
-    const schema    = schemas[tableName];
-    if (!schema) return;
-
-    const colNames = leafCols.map(c => c.col);
-    const hasCompound = schema.compoundIndexes.some(
-      ci => ci.length === colNames.length && colNames.every(c => ci.includes(c)),
-    );
-
-    if (!hasCompound) {
-      throw new SqlValidationError(
-        `Strict mode: compound index required for AND on columns [${colNames.join(', ')}]`,
-      );
-    }
-  }
-
-  private _flattenAndCols(
-    node:         any,
-    defaultTable: string,
-    aliases:      Record<string, string>,
-  ): Array<{ table: string; col: string }> {
-    if (!node || node.type !== 'binary_expr') return [];
-    if (node.operator === 'AND') {
-      return [
-        ...this._flattenAndCols(node.left,  defaultTable, aliases),
-        ...this._flattenAndCols(node.right, defaultTable, aliases),
-      ];
-    }
-    if (node.left?.type === 'column_ref') {
-      return [{ table: this._resolveTable(node.left.table, defaultTable, aliases), col: node.left.column }];
-    }
-    return [];
-  }
-}

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

@@ -1,35 +0,0 @@
-import { Parser, TableColumnAst, AST } from 'node-sql-parser/build/mysql';
-import { SqlParseError } from './models/sql-errors.model';
-
-export interface ParseResult {
-  ast:        AST;
-  tableList:  string[];
-  columnList: string[];
-}
-
-export class SqlParser {
-  private readonly _parser = new Parser();
-
-  parse(sql: string): ParseResult {
-    let result: TableColumnAst;
-    try {
-      result = this._parser.parse(sql);
-    } catch (e: any) {
-      throw new SqlParseError(e.message ?? 'Failed to parse SQL');
-    }
-
-    const ast = Array.isArray(result.ast) ? result.ast[0] : result.ast;
-    if (!ast) {
-      throw new SqlParseError('SQL produced no AST — only SELECT statements are supported');
-    }
-    if ((ast as any).type !== 'select') {
-      throw new SqlParseError('Only SELECT statements are supported');
-    }
-
-    return {
-      ast,
-      tableList:  result.tableList  ?? [],
-      columnList: result.columnList ?? [],
-    };
-  }
-}

package/src/lib/services/database-manager-service/database.manager.service.ts

@@ -1,384 +0,0 @@
-import { inject, Injectable } from '@angular/core';
-import { DbService } from './db.storage.service';
-import { LocalStorageManagerService } from '../local-storage-manager-service/local-storage-manager.service';
-
-import { TableSchemaDef } from './models/table-schema';
-import { EMPTY, from, Observable, of } from 'rxjs';
-import { catchError, map, switchMap, tap } from 'rxjs/operators';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class DatabaseManagerService extends DbService {
-
-  private localStorageManager = inject(LocalStorageManagerService);
-
-  constructor() {
-    super()
-  }
-
-  getDatabaseTables() {
-    return from(this.DBOpened()).pipe(
-      map(() => this.tables.map((item: any) => item.name))
-    )
-  }
-
-  databaseExists(): Observable<boolean> {
-    return from(this.hasDatabase());
-  }
-
-  hasDatabaseTable(table: string): Observable<boolean> {
-    const tableName = this.cleanTableName(table);
-    return from(this.DBOpened()).pipe(
-      map(() => {
-        return this.tableExists(tableName)
-      })
-    )
-  }
-
-  getDatabaseTable(table: string): Observable<any> {
-    const tableName = this.cleanTableName(table);
-    return from(this.DBOpened()).pipe(
-      map(() => {
-          const found = this.getTable(tableName);
-          if(!found) {
-            console.warn('No Such Table:', tableName)
-            return null;
-          }
-          return found;
-      })
-    )
-  }
-
-  getDatabaseTableSchema(table: string): Observable<string[]> {
-    const tableName = this.cleanTableName(table);
-    return this.getDatabaseTable(tableName).pipe(
-      map((dbTable: any) => {
-        if(!dbTable) return []
-        const cols = dbTable.schema.indexes.map((col: any) => col.name)
-        const pri = dbTable.schema.primKey.name
-        return [pri, ...cols]
-      })
-    )
-  }
-
-  createDatabaseTable(tableDef: TableSchemaDef) {
-    const tableName = this.cleanTableName(tableDef.table);
-    return from(this.createTable(tableDef.table, tableDef.schema)).pipe(
-      switchMap(() => from(this.DBOpened())),
-      map((opened) => opened && this.tableExists(tableName)),
-      catchError((error) => {
-        console.error(`createDatabaseTable: failed for table '${tableName}'`, error);
-        return of(false);
-      })
-    )
-  }
-
-  updateDatabaseTableSchema(tableDef: TableSchemaDef) {
-    return from(this.createTable(tableDef.table, tableDef.schema)).pipe(
-      switchMap(() => this.getDatabaseTable(tableDef.table))
-    )
-  }
-
-  // CRUD
-  findTableRecords(table: string, column: string, value: any) {
-    const tableName = this.cleanTableName(table);
-    return this.getDatabaseTable(tableName).pipe(
-      switchMap((tableData: any) => {
-        if (!tableData) {
-          console.warn(`findTableRecords: Table '${tableName}' not found`);
-          return from([]);
-        }
-        return from(tableData.where(column).equals(value).toArray());
-      })
-    );
-  }
-
-  findTableRecord(table: string, column: string, value: any) {
-    const tableName = this.cleanTableName(table);
-    return this.findTableRecords(tableName, column, value).pipe(
-      map((records: any) => records && records.length > 0 ? records[0] : null)
-    );
-  }
-
-  getTableRecords(table: string) {
-    const tableName = this.cleanTableName(table);
-    return this.getDatabaseTable(tableName).pipe(
-      switchMap((tableData: any) => {
-        if (!tableData) {
-          console.warn(`getTableRecords: Table '${tableName}' not found`);
-          return from([]);
-        }
-        return from(tableData.toArray());
-      })
-    );
-  }
-
-  getTableRecord(table: string, id: number) {
-    const tableName = this.cleanTableName(table);
-    return this.getDatabaseTable(tableName).pipe(
-      switchMap((tableData: any) => {
-        if (!tableData) {
-          console.warn(`getTableRecord: Table '${tableName}' not found`);
-          return from([null]);
-        }
-        return from(tableData.get(id)).pipe(
-          map((record: any) => record || null)
-        );
-      })
-    );
-  }
-
-  createTableRecord(table: string, record: any) {
-    const tableName = this.cleanTableName(table);
-    return this.createTableRecords(tableName, [record])
-    .pipe(
-      map((item: any) => item ? item[0] : null))
-  }
-
-  createTableRecords(table: string, records: any[]) {
-    const tableName = this.cleanTableName(table);
-
-    // Keep full object payload; Dexie stores non-indexed properties as well.
-    const insertRecords = records.map((record: any) => {
-      const payload = { ...(record || {}) };
-      if (payload.id === undefined || payload.id === null || payload.id === '') {
-        delete payload.id;
-      }
-      return payload;
-    });
-
-    const writeRecords = () => from(this.DBOpened()).pipe(
-      switchMap((opened) => {
-        if (!opened) {
-          // console.error(`createTableRecords: DB not open. Cannot write to '${tableName}'.`);
-          return EMPTY;
-        }
-
-        const tableInstance = this.getTable(tableName);
-        if (!tableInstance) {
-          // console.error(`createTableRecords: Table '${tableName}' does not exist in DB version ${this.verno}. Available:`, this.tables.map(t => t.name));
-          return EMPTY;
-        }
-
-        // console.log(`createTableRecords: Bulk putting ${insertRecords.length} records into ${tableName}`);
-
-        return from(tableInstance.bulkPut(insertRecords)).pipe(
-          map(() => insertRecords)
-        );
-      })
-    );
-
-    const recreateMissingTableAndRetry = () => {
-      const inferredSchema = this.inferSchemaFromRecords(insertRecords);
-
-      if (!inferredSchema) {
-        // console.warn(`createTableRecords: Could not infer schema for '${tableName}'. Retrying after DB reopen.`);
-        return from(this.createNewDatabase()).pipe(
-          switchMap(() => writeRecords())
-        );
-      }
-
-      const tableDef = TableSchemaDef.adapt({ table: tableName, schema: inferredSchema });
-
-      return this.createDatabaseTable(tableDef).pipe(
-        switchMap((created) => {
-          if (!created) {
-            // console.warn(`createTableRecords: Failed to recreate table '${tableName}' from inferred schema. Retrying after DB reopen.`);
-            return from(this.createNewDatabase()).pipe(
-              switchMap(() => writeRecords())
-            );
-          }
-
-          return writeRecords();
-        })
-      );
-    };
-
-    return writeRecords().pipe(
-      catchError((error) => {
-        if (!this.isMissingObjectStoreError(error)) {
-          throw error;
-        }
-
-        return recreateMissingTableAndRetry().pipe(
-          catchError((retryError) => {
-            if (!this.isMissingObjectStoreError(retryError)) {
-              console.error(`createTableRecords: Retry failed for '${tableName}'`, retryError);
-              throw retryError;
-            }
-
-            console.warn(`createTableRecords: Table '${tableName}' still missing after retry. Deleting DB and reinitializing...`);
-            return this.deleteAndReinitialize().pipe(
-              switchMap((reinitialized) => {
-                if (!reinitialized) {
-                  throw retryError;
-                }
-                const inferredSchema = this.inferSchemaFromRecords(insertRecords);
-                if (!inferredSchema) {
-                  throw retryError;
-                }
-                const tableDef = TableSchemaDef.adapt({ table: tableName, schema: inferredSchema });
-                return this.createDatabaseTable(tableDef).pipe(
-                  switchMap(() => writeRecords())
-                );
-              }),
-              catchError((finalError) => {
-                console.error(`createTableRecords: All retries exhausted for '${tableName}'`, finalError);
-                throw finalError;
-              })
-            );
-          })
-        );
-      })
-    );
-  }
-
-  private inferSchemaFromRecords(records: any[]): string | null {
-    if (!Array.isArray(records) || records.length === 0) {
-      return null;
-    }
-
-    const sample = records.find((record: any) => record && typeof record === 'object');
-    if (!sample) {
-      return null;
-    }
-
-    const fields = Object.keys(sample)
-      .filter((key) => key !== 'id')
-      .filter((key) => {
-        const value = sample[key];
-        return value === null || ['string', 'number', 'boolean'].includes(typeof value);
-      })
-      .sort();
-
-    return ['++id', ...fields].join(', ');
-  }
-
-  private isMissingObjectStoreError(error: any): boolean {
-    const name = String(error?.name || '').toLowerCase();
-    const innerName = String(error?.inner?.name || '').toLowerCase();
-    const message = String(error?.message || error?.inner?.message || '').toLowerCase();
-
-    return (
-      name.includes('notfounderror') ||
-      innerName.includes('notfounderror') ||
-      message.includes('object store') ||
-      message.includes('one of the specified object stores was not found')
-    );
-  }
-
-  updateTableRecord(table: string, record: any) {
-    const tableName = this.cleanTableName(table);
-    return this.updateTableRecords(tableName, [record])
-    .pipe(
-      map(item => item.length > 0 ? item[0] : null)
-    )
-  }
-
-  updateTableRecords(table: string, records: any[]) {
-
-    const tableName = this.cleanTableName(table);
-
-    return this.getDatabaseTable(tableName).pipe(
-
-      switchMap((tableData: any) => {
-
-        if (!tableData) {
-          console.warn(`updateTableRecords: Table '${tableName}' not found`);
-          return EMPTY;
-        }
-
-        const insertRecords = records.map((record: any) => {
-          const payload = { ...(record || {}) };
-          if (payload.id === undefined || payload.id === null || payload.id === '') {
-            delete payload.id;
-          }
-          return payload;
-        });
-
-        return from(tableData.bulkPut(insertRecords)).pipe(
-            map(() => insertRecords)
-        );
-
-      })
-
-    )
-
-  }
-
-  deleteTableRecord<T>(table: string, id: number) {
-    const tableName = this.cleanTableName(table);
-    return this.deleteTableRecords(tableName, [id])
-    .pipe(
-      map(item => item.length > 0 ? item[0] : null)
-    )
-  }
-
-  deleteTableRecords(table: string, ids: number[]) {
-    const tableName = this.cleanTableName(table);
-    return this.getDatabaseTable(tableName).pipe(
-
-      switchMap((tableData: any) => {
-
-        return this.getDatabaseTableSchema(tableName).pipe(
-
-          switchMap((schema: string[]) => {
-
-            console.log(`deleteTableRecords: Starting delete of ${ids.length} records from ${table}. IDs:`, ids);
-
-            return from(tableData.bulkDelete(ids)).pipe(
-                map(() => ids)
-            );
-
-          })
-
-        )
-
-      })
-
-    )
-
-  }
-
-  clearTable(table: string) {
-
-    const tableName = this.cleanTableName(table);
-
-    try {
-      const tableInstance = this.table(tableName);
-      if (!tableInstance) {
-        console.warn(`clearTable: Table '${tableName}' not found`);
-        return of([]);
-      }
-
-      // console.log(`clearTable: Clearing table '${tableName}'...`);
-
-      // Use table.clear() directly and wrap in Observable
-      return from(Promise.resolve().then(() => {
-        return tableInstance.clear();
-      })).pipe(
-        // tap(() => console.log(`clearTable: ✅ Table '${tableName}' cleared successfully`)),
-        map(() => [])
-      );
-    } catch (error) {
-      console.error(`clearTable: ❌ Error:`, error);
-      return of([]);
-    }
-  }
-
-  clearDatabase(): void {
-    this.deleteAndReinitialize().pipe(
-      tap(() => this.localStorageManager.clearAllStoredData()),
-      catchError((error) => {
-        console.error('clearDatabase: ❌ Error clearing database:', error);
-        return of(false);
-      })
-    ).subscribe();
-  }
-
-  resetDatabase(): Observable<boolean> {
-    return this.deleteAndReinitialize();
-  }
-
-}