@arcote.tech/arc-adapter-db-sqlite 0.3.0

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@arcote.tech/arc-adapter-db-sqlite",
+  "version": "0.3.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target node --format esm && bun run build:types",
+    "build:types": "tsc --emitDeclarationOnly --declaration --outDir ./dist",
+    "dev": "bun build ./src/index.ts --outdir ./dist --target node --format esm --watch",
+    "test": "bun test"
+  },
+  "peerDependencies": {
+    "@arcote.tech/arc": "workspace:*"
+  },
+  "devDependencies": {
+    "@arcote.tech/arc": "workspace:*",
+    "typescript": "^5.0.0"
+  }
+}

package/src/bun-sqlite.ts

@@ -0,0 +1,82 @@
+import type { ArcContextAny, DBAdapterFactory } from "@arcote.tech/arc";
+import { Database } from "bun:sqlite";
+import type { SQLiteDatabase } from "./sqlite-adapter";
+import { createSQLiteAdapterFactory } from "./sqlite-adapter";
+
+/**
+ * Bun SQLite wrapper that implements SQLiteDatabase interface
+ */
+export class BunSQLiteDatabase implements SQLiteDatabase {
+  private db: Database;
+
+  constructor(filename: string = ":memory:") {
+    this.db = new Database(filename);
+  }
+
+  async exec(sql: string, params?: any[]): Promise<any[]> {
+    try {
+      if (params && params.length > 0) {
+        const stmt = this.db.prepare(sql);
+        if (sql.trim().toUpperCase().startsWith("SELECT")) {
+          return stmt.all(...params) as any[];
+        } else {
+          stmt.run(...params);
+          return [];
+        }
+      } else {
+        const statements = sql.split(";").filter((s) => s.trim());
+        let result: any[] = [];
+
+        for (const statement of statements) {
+          if (!statement.trim()) continue;
+
+          if (statement.trim().toUpperCase().startsWith("SELECT")) {
+            result = this.db.prepare(statement).all() as any[];
+          } else {
+            this.db.exec(statement);
+          }
+        }
+        return result;
+      }
+    } catch (error) {
+      console.error("SQL Error:", error, "\nSQL:", sql, "\nParams:", params);
+      throw error;
+    }
+  }
+
+  async execBatch(
+    queries: Array<{ sql: string; params?: any[] }>,
+  ): Promise<void> {
+    this.db.exec("BEGIN TRANSACTION");
+    try {
+      for (const query of queries) {
+        if (query.params && query.params.length > 0) {
+          this.db.prepare(query.sql).run(...query.params);
+        } else {
+          this.db.exec(query.sql);
+        }
+      }
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+
+  close() {
+    this.db.close();
+  }
+}
+
+/**
+ * Create a Bun SQLite adapter factory
+ * @param filename - Database filename, defaults to ":memory:" for in-memory database
+ */
+export const createBunSQLiteAdapterFactory = (
+  filename: string = ":memory:",
+): DBAdapterFactory => {
+  return async (context: ArcContextAny) => {
+    const db = new BunSQLiteDatabase(filename);
+    return createSQLiteAdapterFactory(db)(context);
+  };
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export { BunSQLiteDatabase, createBunSQLiteAdapterFactory } from "./bun-sqlite";
+export { createSQLiteAdapterFactory, SQLiteAdapter } from "./sqlite-adapter";
+export type { SQLiteDatabase } from "./sqlite-adapter";

package/src/sqlite-adapter.ts

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

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}