@arcote.tech/arc-adapter-db-sqlite 0.3.1 → 0.3.3

package/src/sqlite-adapter.ts

@@ -1,812 +0,0 @@
-import {
-  type ArcContextAny,
-  type DatabaseAdapter,
-  type DatabaseAgnosticColumnInfo,
-  type DatabaseStoreData,
-  type DatabaseStoreSchema,
-  type DBAdapterFactory,
-  type FindOptions,
-  type ReadTransaction,
-  type ReadWriteTransaction,
-  type StoreColumn,
-  type StoreTable,
-  type WhereCondition,
-  extractDatabaseAgnosticSchema,
-} from "@arcote.tech/arc";
-
-export interface SQLiteDatabase {
-  exec(sql: string, params?: any[]): Promise<any>;
-  execBatch(queries: Array<{ sql: string; params?: any[] }>): Promise<any>;
-}
-
-class SQLiteReadTransaction implements ReadTransaction {
-  constructor(
-    protected db: SQLiteDatabase,
-    protected tables: Map<string, StoreTable>,
-    protected adapter?: SQLiteAdapter,
-  ) {}
-
-  protected hasSoftDelete(tableName: string): boolean {
-    if (this.adapter) {
-      return this.adapter.hasSoftDelete(tableName);
-    }
-    // Fallback: check if table has deleted column
-    const table = this.tables.get(tableName);
-    if (!table) return false;
-    return table.columns.some((col) => col.name === "deleted");
-  }
-
-  protected deserializeValue(value: any, column: StoreColumn): any {
-    if (value === null || value === undefined) return null;
-
-    switch (column.type.toLowerCase()) {
-      case "json":
-        // SQLite JSON columns should always be parsed
-        if (typeof value === "string") {
-          try {
-            return JSON.parse(value);
-          } catch {
-            return value;
-          }
-        }
-        return value;
-      case "text":
-        // For text columns, only attempt JSON parsing if it looks like JSON
-        if (
-          typeof value === "string" &&
-          (value.startsWith("{") || value.startsWith("["))
-        ) {
-          try {
-            const parsed = JSON.parse(value);
-            if (typeof parsed === "object" || Array.isArray(parsed)) {
-              return parsed;
-            }
-          } catch {
-            // Not valid JSON, return as string
-          }
-        }
-        return value;
-      case "datetime":
-      case "timestamp":
-        return new Date(value);
-      default:
-        return value;
-    }
-  }
-
-  protected deserializeRow(row: any, table: StoreTable): any {
-    const result: any = {};
-    for (const column of table.columns) {
-      const value = row[column.name];
-      result[column.name] = this.deserializeValue(value, column);
-    }
-    return result;
-  }
-
-  protected getId(store: string, id: any) {
-    return id;
-  }
-
-  protected buildWhereClause(
-    where?: WhereCondition,
-    tableName?: string,
-  ): {
-    sql: string;
-    params: any[];
-  } {
-    const conditions: string[] = [];
-    const params: any[] = [];
-
-    // Only add deleted condition if table has soft delete enabled
-    if (tableName && this.hasSoftDelete(tableName)) {
-      conditions.push('"deleted" = 0');
-    }
-
-    if (!where) {
-      return {
-        sql: conditions.length > 0 ? conditions.join(" AND ") : "1=1",
-        params,
-      };
-    }
-
-    Object.entries(where).forEach(([key, value]) => {
-      if (typeof value === "object" && value !== null) {
-        Object.entries(value as Record<string, unknown>).forEach(
-          ([operator, operand]) => {
-            switch (operator) {
-              case "$eq":
-              case "$ne":
-              case "$gt":
-              case "$gte":
-              case "$lt":
-              case "$lte":
-                conditions.push(
-                  `"${key}" ${this.getOperatorSymbol(operator)} ?`,
-                );
-                params.push(operand);
-                break;
-              case "$in":
-              case "$nin":
-                if (Array.isArray(operand)) {
-                  conditions.push(
-                    `"${key}" ${operator === "$in" ? "IN" : "NOT IN"} (${operand.map(() => "?").join(", ")})`,
-                  );
-                  params.push(...operand);
-                }
-                break;
-              case "$exists":
-                if (typeof operand === "boolean") {
-                  conditions.push(
-                    operand ? `"${key}" IS NOT NULL` : `"${key}" IS NULL`,
-                  );
-                }
-                break;
-            }
-          },
-        );
-      } else {
-        conditions.push(`"${key}" = ?`);
-        params.push(value);
-      }
-    });
-
-    return {
-      sql: conditions.join(" AND "),
-      params,
-    };
-  }
-
-  protected getOperatorSymbol(operator: string): string {
-    const operators: Record<string, string> = {
-      $eq: "=",
-      $ne: "!=",
-      $gt: ">",
-      $gte: ">=",
-      $lt: "<",
-      $lte: "<=",
-    };
-    return operators[operator] || "=";
-  }
-
-  protected buildOrderByClause(
-    orderBy?: Record<string, "asc" | "desc">,
-  ): string {
-    if (!orderBy) return "";
-
-    const orderClauses = Object.entries(orderBy)
-      .map(([key, direction]) => `"${key}" ${direction.toUpperCase()}`)
-      .join(", ");
-
-    return orderClauses ? `ORDER BY ${orderClauses}` : "";
-  }
-
-  async find<T>(store: string, options: FindOptions<T>): Promise<T[]> {
-    const { where, limit, offset, orderBy } = options || {};
-    const whereClause = this.buildWhereClause(where, store);
-    const orderByClause = this.buildOrderByClause(orderBy);
-    const table = this.tables.get(store);
-
-    if (!table) {
-      throw new Error(`Store ${store} not found`);
-    }
-
-    const query = `
-      SELECT * 
-      FROM "${table.name}" 
-      WHERE ${whereClause.sql}
-      ${orderByClause}
-      ${limit ? `LIMIT ${limit}` : ""}
-      ${offset ? `OFFSET ${offset}` : ""}
-    `;
-
-    const rows = await this.db.exec(query, whereClause.params);
-    return rows.map((row: any) => this.deserializeRow(row, table));
-  }
-}
-
-class SQLiteReadWriteTransaction
-  extends SQLiteReadTransaction
-  implements ReadWriteTransaction
-{
-  private queries: Array<{ sql: string; params?: any[] }> = [];
-
-  constructor(
-    db: SQLiteDatabase,
-    tables: Map<string, StoreTable>,
-    protected adapter: SQLiteAdapter,
-  ) {
-    super(db, tables);
-  }
-
-  async remove(store: string, id: any) {
-    const table = this.tables.get(store);
-    if (!table) {
-      throw new Error(`Store ${store} not found`);
-    }
-
-    // Check if table has soft delete enabled
-    const hasSoftDelete = this.adapter.hasSoftDelete(store);
-
-    if (hasSoftDelete) {
-      // Soft delete: set deleted flag
-      const query = `UPDATE "${table.name}" SET "deleted" = 1, "lastUpdate" = ? WHERE "${table.primaryKey}" = ?`;
-      this.queries.push({
-        sql: query,
-        params: [new Date().toISOString(), id],
-      });
-    } else {
-      // Hard delete: actually remove the row
-      const query = `DELETE FROM "${table.name}" WHERE "${table.primaryKey}" = ?`;
-      this.queries.push({
-        sql: query,
-        params: [id],
-      });
-    }
-  }
-
-  async set(store: string, item: any) {
-    const table = this.tables.get(store);
-    if (!table) {
-      throw new Error(`Store ${store} not found`);
-    }
-
-    const hasVersioning = this.adapter.hasVersioning(store);
-
-    if (hasVersioning) {
-      // For versioned tables, use a transaction with version increment
-      await this.setWithVersioning(store, item, table);
-    } else {
-      // For non-versioned tables, use simple insert
-      await this.setWithoutVersioning(store, item, table);
-    }
-  }
-
-  private async setWithoutVersioning(
-    store: string,
-    item: any,
-    table: StoreTable,
-  ) {
-    const columnNames = table.columns.map((col) => col.name);
-    const values = table.columns.map((column) => {
-      let value = item[column.name];
-      if (value === undefined && column.default !== undefined) {
-        value = column.default;
-      }
-      return this.serializeValue(value, column);
-    });
-
-    const placeholders = columnNames.map(() => "?").join(", ");
-
-    // For events table, use simple INSERT since events are typically append-only
-    if (store === "events") {
-      const simpleInsertSql = `
-        INSERT INTO "${table.name}"
-        (${columnNames.map((c) => `"${c}"`).join(", ")})
-        VALUES (${placeholders})
-      `;
-      this.queries.push({
-        sql: simpleInsertSql,
-        params: values,
-      });
-    } else {
-      const sql = `
-        INSERT OR REPLACE INTO "${table.name}"
-        (${columnNames.map((c) => `"${c}"`).join(", ")})
-        VALUES (${placeholders})
-      `;
-      this.queries.push({
-        sql: sql,
-        params: values,
-      });
-    }
-  }
-
-  private async setWithVersioning(store: string, item: any, table: StoreTable) {
-    // Filter out __version from regular columns and handle it separately
-    const regularColumns = table.columns.filter(
-      (col) => col.name !== "__version",
-    );
-    const columnNames = regularColumns.map((col) => col.name);
-    const values = regularColumns.map((column) => {
-      let value = item[column.name];
-      if (value === undefined && column.default !== undefined) {
-        value = column.default;
-      }
-      return this.serializeValue(value, column);
-    });
-
-    // Add __version column
-    columnNames.push("__version");
-    const placeholders = regularColumns.map(() => "?").join(", ");
-
-    // Always increment version counter and use the new version
-    const sql = `
-      WITH next_version AS (
-        INSERT INTO __arc_version_counters (table_name, last_version) 
-        VALUES (?, 1)
-        ON CONFLICT(table_name) 
-        DO UPDATE SET last_version = last_version + 1
-        RETURNING last_version
-      )
-      INSERT OR REPLACE INTO "${table.name}"
-      (${columnNames.map((c) => `"${c}"`).join(", ")})
-      VALUES (${placeholders}, (SELECT last_version FROM next_version))
-    `;
-
-    this.queries.push({
-      sql: sql,
-      params: [...values, store],
-    });
-  }
-
-  async commit() {
-    if (this.queries.length === 0) {
-      return Promise.resolve();
-    }
-
-    try {
-      await this.db.execBatch(this.queries);
-      this.queries = [];
-    } catch (error) {
-      this.queries = [];
-      throw error;
-    }
-  }
-
-  private serializeValue(value: any, column: StoreColumn): any {
-    if (value === null || value === undefined) return null;
-
-    switch (column.type.toLowerCase()) {
-      case "timestamp":
-      case "datetime":
-        // Handle various timestamp formats
-        if (value instanceof Date) {
-          return value.toISOString();
-        }
-        if (typeof value === "number") {
-          // Unix timestamp (seconds or milliseconds)
-          const date = value > 1e10 ? new Date(value) : new Date(value * 1000);
-          return date.toISOString();
-        }
-        if (typeof value === "string") {
-          // Already an ISO string or date string, validate and normalize
-          const date = new Date(value);
-          if (!isNaN(date.getTime())) {
-            return date.toISOString();
-          }
-        }
-        return value; // Pass through if we can't convert
-      case "json":
-        return JSON.stringify(value);
-      default:
-        if (value instanceof Date) {
-          return value.toISOString();
-        }
-        if (Array.isArray(value) || typeof value === "object") {
-          return JSON.stringify(value);
-        }
-        return value;
-    }
-  }
-}
-
-export class SQLiteAdapter implements DatabaseAdapter {
-  private tables: Map<string, StoreTable> = new Map();
-  private tableSchemas: Map<string, any[]> = new Map();
-  private pendingReinitTables: Array<{
-    tableName: string;
-    reinitFn: (tableName: string, dataStorage: any) => Promise<void>;
-  }> = [];
-
-  private mapType(arcType: string, storeData?: DatabaseStoreData): string {
-    // Check for database-specific type override
-    if (storeData?.databaseType?.sqlite) {
-      return storeData.databaseType.sqlite;
-    }
-
-    switch (arcType) {
-      case "string":
-      case "id":
-      case "customId":
-      case "stringEnum":
-        return "TEXT";
-      case "number":
-        return "INTEGER";
-      case "boolean":
-        return "INTEGER"; // SQLite stores booleans as integers
-      case "date":
-        return "TIMESTAMP";
-      case "object":
-      case "array":
-      case "record":
-        return "JSON";
-      case "blob":
-        return "BLOB";
-      default:
-        return "TEXT";
-    }
-  }
-
-  private buildConstraints(storeData?: DatabaseStoreData): string[] {
-    const constraints: string[] = [];
-
-    if (storeData?.isPrimaryKey) {
-      constraints.push("PRIMARY KEY");
-    }
-    if (storeData?.isAutoIncrement) {
-      constraints.push("AUTOINCREMENT");
-    }
-    if (storeData?.isUnique) {
-      constraints.push("UNIQUE");
-    }
-    if (storeData?.foreignKey) {
-      const { table, column, onDelete, onUpdate } = storeData.foreignKey;
-      let fkConstraint = `REFERENCES ${table}(${column})`;
-      if (onDelete) fkConstraint += ` ON DELETE ${onDelete}`;
-      if (onUpdate) fkConstraint += ` ON UPDATE ${onUpdate}`;
-      constraints.push(fkConstraint);
-    }
-
-    return constraints;
-  }
-
-  private generateColumnSQL(
-    columnInfo: DatabaseAgnosticColumnInfo & { name: string },
-  ): string {
-    const type = this.mapType(columnInfo.type, columnInfo.storeData);
-    const constraints: string[] = [];
-
-    if (!columnInfo.storeData?.isNullable) {
-      constraints.push("NOT NULL");
-    }
-
-    constraints.push(...this.buildConstraints(columnInfo.storeData));
-
-    if (columnInfo.defaultValue !== undefined) {
-      if (typeof columnInfo.defaultValue === "string") {
-        constraints.push(`DEFAULT '${columnInfo.defaultValue}'`);
-      } else {
-        constraints.push(`DEFAULT ${columnInfo.defaultValue}`);
-      }
-    }
-
-    return `"${columnInfo.name}" ${type} ${constraints.join(" ")}`.trim();
-  }
-
-  private generateCreateTableSQL(
-    tableName: string,
-    columns: (DatabaseAgnosticColumnInfo & { name: string })[],
-  ): string {
-    const columnDefinitions = columns.map((col) => this.generateColumnSQL(col));
-    const indexes = columns
-      .filter((col) => col.storeData?.hasIndex && !col.storeData?.isPrimaryKey)
-      .map(
-        (col) =>
-          `CREATE INDEX IF NOT EXISTS idx_${tableName}_${col.name} ON "${tableName}"("${col.name}");`,
-      );
-
-    let sql = `CREATE TABLE IF NOT EXISTS "${tableName}" (\n  ${columnDefinitions.join(",\n  ")}\n)`;
-
-    if (indexes.length > 0) {
-      sql += ";\n" + indexes.join("\n");
-    }
-
-    return sql;
-  }
-
-  constructor(
-    private db: SQLiteDatabase,
-    private context: ArcContextAny,
-  ) {
-    this.context.elements.forEach((element) => {
-      if (
-        "databaseStoreSchema" in element &&
-        typeof element.databaseStoreSchema === "function"
-      ) {
-        const databaseSchema =
-          element.databaseStoreSchema() as DatabaseStoreSchema;
-
-        databaseSchema.tables.forEach((dbTable) => {
-          // Extract database-agnostic schema from ArcObject
-          const agnosticSchema = extractDatabaseAgnosticSchema(
-            dbTable.schema,
-            dbTable.name,
-          );
-
-          // Convert to database-specific columns
-          const columns = agnosticSchema.columns.map((columnInfo) => ({
-            name: columnInfo.name,
-            type: this.mapType(columnInfo.type, columnInfo.storeData),
-            constraints: this.buildConstraints(columnInfo.storeData),
-            isNullable: columnInfo.storeData?.isNullable || false,
-            defaultValue: columnInfo.defaultValue,
-            isPrimaryKey: columnInfo.storeData?.isPrimaryKey || false,
-            isAutoIncrement: columnInfo.storeData?.isAutoIncrement || false,
-            isUnique: columnInfo.storeData?.isUnique || false,
-            hasIndex: columnInfo.storeData?.hasIndex || false,
-            foreignKey: columnInfo.storeData?.foreignKey,
-          }));
-
-          this.tableSchemas.set(dbTable.name, columns);
-
-          // Convert to legacy StoreTable format for compatibility with existing transaction code
-          const legacyTable: StoreTable = {
-            name: dbTable.name,
-            primaryKey: columns.find((col) => col.isPrimaryKey)?.name || "_id",
-            columns: columns.map((col) => ({
-              name: col.name,
-              type: col.type,
-              isOptional: col.isNullable,
-              default: col.defaultValue,
-            })),
-          };
-          this.tables.set(dbTable.name, legacyTable);
-        });
-      }
-    });
-  }
-
-  public async initialize() {
-    // Create the version counter table first
-    await this.createVersionCounterTable();
-    // Create the table versions tracking table
-    await this.createTableVersionsTable();
-
-    const processedSchemas = new Set<DatabaseStoreSchema>();
-    const processedTables = new Set<string>();
-
-    for (const element of this.context.elements) {
-      if (
-        "databaseStoreSchema" in element &&
-        typeof element.databaseStoreSchema === "function"
-      ) {
-        const databaseSchema =
-          element.databaseStoreSchema() as DatabaseStoreSchema;
-
-        // Skip if we've already processed this exact schema reference
-        if (processedSchemas.has(databaseSchema)) {
-          continue;
-        }
-        processedSchemas.add(databaseSchema);
-
-        for (const dbTable of databaseSchema.tables) {
-          const tableKey = dbTable.version
-            ? `${dbTable.name}_v${dbTable.version}`
-            : dbTable.name;
-
-          if (!processedTables.has(tableKey)) {
-            // Extract database-agnostic schema from ArcObject
-            const agnosticSchema = extractDatabaseAgnosticSchema(
-              dbTable.schema,
-              dbTable.name,
-            );
-
-            // Add system columns if enabled
-            let allColumns = [...agnosticSchema.columns];
-
-            if (dbTable.options?.versioning) {
-              allColumns.push({
-                name: "__version",
-                type: "number",
-                storeData: { isNullable: false, hasIndex: true },
-                defaultValue: 1,
-              });
-            }
-
-            if (dbTable.options?.softDelete) {
-              allColumns.push({
-                name: "deleted",
-                type: "boolean",
-                storeData: { isNullable: false, hasIndex: true },
-                defaultValue: false,
-              });
-            }
-
-            // Determine physical table name based on version
-            const physicalTableName = this.getPhysicalTableName(
-              dbTable.name,
-              dbTable.version,
-            );
-
-            // Check if versioned table already exists
-            if (
-              dbTable.version &&
-              (await this.checkVersionedTableExists(
-                dbTable.name,
-                dbTable.version,
-              ))
-            ) {
-              console.log(
-                `Versioned table ${physicalTableName} already exists, skipping creation`,
-              );
-            } else {
-              await this.createTableIfNotExistsNew(
-                physicalTableName,
-                allColumns,
-              );
-
-              // Register the new version if it's a versioned table
-              if (dbTable.version) {
-                await this.registerTableVersion(
-                  dbTable.name,
-                  dbTable.version,
-                  physicalTableName,
-                );
-              }
-            }
-
-            // Store reinit function for later execution (only for versioned tables)
-            // reinitTable rebuilds views from events when schema version changes
-            if (dbTable.version && databaseSchema.reinitTable) {
-              this.pendingReinitTables.push({
-                tableName: physicalTableName,
-                reinitFn: databaseSchema.reinitTable,
-              });
-            }
-
-            // Update the legacy table mapping with the actual columns (including system columns)
-            const legacyTable: StoreTable = {
-              name: physicalTableName, // Use physical table name for actual queries
-              primaryKey:
-                allColumns.find((col) => col.storeData?.isPrimaryKey)?.name ||
-                "_id",
-              columns: allColumns.map((col) => ({
-                name: col.name,
-                type: this.mapType(col.type, col.storeData),
-                isOptional: col.storeData?.isNullable || false,
-                default: col.defaultValue,
-              })),
-            };
-            this.tables.set(dbTable.name, legacyTable); // Still use logical name as key
-
-            processedTables.add(tableKey);
-          }
-        }
-      }
-    }
-  }
-
-  private async createTableIfNotExistsNew(
-    tableName: string,
-    columns: (DatabaseAgnosticColumnInfo & { name: string })[],
-  ) {
-    const createTableSQL = this.generateCreateTableSQL(tableName, columns);
-    await this.db.exec(createTableSQL);
-  }
-
-  /**
-   * Create the version counter table for tracking per-table version sequences
-   */
-  private async createVersionCounterTable() {
-    const sql = `
-      CREATE TABLE IF NOT EXISTS __arc_version_counters (
-        table_name TEXT PRIMARY KEY,
-        last_version INTEGER NOT NULL DEFAULT 0
-      )
-    `;
-    await this.db.exec(sql);
-  }
-
-  /**
-   * Create the table versions tracking table for schema versioning
-   */
-  private async createTableVersionsTable() {
-    const sql = `
-      CREATE TABLE IF NOT EXISTS __arc_table_versions (
-        table_name TEXT NOT NULL,
-        version INTEGER NOT NULL,
-        physical_table_name TEXT NOT NULL,
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-        is_active INTEGER DEFAULT 0,
-        PRIMARY KEY (table_name, version)
-      )
-    `;
-    await this.db.exec(sql);
-  }
-
-  /**
-   * Generate physical table name with version suffix
-   */
-  private getPhysicalTableName(logicalName: string, version?: number): string {
-    return version ? `${logicalName}_v${version}` : logicalName;
-  }
-
-  /**
-   * Check if a versioned table exists
-   */
-  private async checkVersionedTableExists(
-    logicalName: string,
-    version: number,
-  ): Promise<boolean> {
-    const result = await this.db.exec(
-      "SELECT COUNT(*) as count FROM __arc_table_versions WHERE table_name = ? AND version = ?",
-      [logicalName, version],
-    );
-    return result[0]?.count > 0;
-  }
-
-  /**
-   * Register a new table version
-   */
-  private async registerTableVersion(
-    logicalName: string,
-    version: number,
-    physicalName: string,
-  ): Promise<void> {
-    await this.db.exec(
-      "INSERT INTO __arc_table_versions (table_name, version, physical_table_name, is_active) VALUES (?, ?, ?, ?)",
-      [logicalName, version, physicalName, 1],
-    );
-  }
-
-  /**
-   * Check if a table has versioning enabled
-   */
-  public hasVersioning(tableName: string): boolean {
-    // Check if the table has a __version column
-    const table = this.tables.get(tableName);
-    if (!table) return false;
-    return table.columns.some((col) => col.name === "__version");
-  }
-
-  /**
-   * Check if a table has soft delete enabled
-   */
-  public hasSoftDelete(tableName: string): boolean {
-    // Check if the table has a deleted column
-    const table = this.tables.get(tableName);
-    if (!table) return false;
-    return table.columns.some((col) => col.name === "deleted");
-  }
-
-  /**
-   * Execute all pending reinitTable functions
-   */
-  public async executeReinitTables(dataStorage: any): Promise<void> {
-    for (const { tableName, reinitFn } of this.pendingReinitTables) {
-      await reinitFn(tableName, dataStorage);
-    }
-    this.pendingReinitTables = [];
-  }
-
-  readWriteTransaction(stores?: string[]) {
-    return new SQLiteReadWriteTransaction(this.db, this.tables, this);
-  }
-
-  readTransaction(stores?: string[]) {
-    return new SQLiteReadTransaction(this.db, this.tables, this);
-  }
-
-  /**
-   * Destroy the database - drop all tables
-   * Used for logout/reset scenarios
-   */
-  async destroy(): Promise<void> {
-    // Drop all application tables
-    for (const tableName of this.tables.keys()) {
-      const table = this.tables.get(tableName);
-      if (table) {
-        await this.db.exec(`DROP TABLE IF EXISTS "${table.name}"`);
-      }
-    }
-
-    // Drop system tables
-    await this.db.exec("DROP TABLE IF EXISTS __arc_version_counters");
-    await this.db.exec("DROP TABLE IF EXISTS __arc_table_versions");
-
-    // Clear internal state
-    this.tables.clear();
-    this.tableSchemas.clear();
-    this.pendingReinitTables = [];
-  }
-}
-
-export const createSQLiteAdapterFactory = (
-  db: SQLiteDatabase,
-): DBAdapterFactory => {
-  return async (context: ArcContextAny): Promise<DatabaseAdapter> => {
-    const adapter = new SQLiteAdapter(db, context);
-    await adapter.initialize();
-    return adapter;
-  };
-};