http-request-manager 18.15.33 → 18.15.34

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

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

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

@@ -0,0 +1,384 @@
+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();
+  }
+
+}