@an5/adapters 0.2.5 → 0.2.6

package/typescript/src/postgres/engine.ts

@@ -1,87 +1,87 @@
-import type { An5AdapterConfig, Dialect, QueryEngine, TransactionHandle } from '../base/types';
-
-// ─── PostgreSQL Engine ─────────────────────────────────────────────────────────────
-
-let PgPool: any = null;
-try { PgPool = require('pg').Pool; } catch { }
-
-export class PostgresEngine implements QueryEngine {
-  dialect: Dialect = 'postgres';
-  private pool: any = null;
-
-  constructor(adapterConfig: An5AdapterConfig) {
-    if (!PgPool) throw new Error('pg package is required for PostgreSQL support. Run: npm install pg');
-    this.pool = new PgPool({
-      connectionString: adapterConfig.connectionString,
-      max: adapterConfig.poolMax ?? 10,
-    });
-  }
-
-  /** Convert @name → $N; identical names reuse the same $N */
-  private transform(query: string, params?: Record<string, any>): { text: string; values: any[] } {
-    if (!params || Object.keys(params).length === 0) return { text: query, values: [] };
-    const values: any[] = [];
-    const seen: Record<string, number> = {};
-    const text = query.replace(/@(\w+)/g, (_, name: string) => {
-      if (seen[name] !== undefined) return `$${seen[name]}`;
-      const idx = values.length + 1;
-      seen[name] = idx;
-      values.push(params[name] ?? null);
-      return `$${idx}`;
-    });
-    return { text, values };
-  }
-
-  async exec<T = any>(query: string, params?: Record<string, any>): Promise<T[]> {
-    const { text, values } = this.transform(query, params);
-    const result = await this.pool.query(text, values);
-    return result.rows as T[];
-  }
-
-  async executeRaw(query: string, params?: Record<string, any>): Promise<number> {
-    const { text, values } = this.transform(query, params);
-    const result = await this.pool.query(text, values);
-    return result.rowCount ?? 0;
-  }
-
-  async connect(): Promise<void> {
-    const client = await this.pool.connect();
-    client.release();
-  }
-
-  async disconnect(): Promise<void> { await this.pool.end(); }
-
-  async beginTransaction(): Promise<TransactionHandle> {
-    const client = await this.pool.connect();
-    await client.query('BEGIN');
-
-    const transform = (query: string, params?: Record<string, any>) => {
-      if (!params || Object.keys(params).length === 0) return { text: query, values: [] };
-      const values: any[] = [];
-      const seen: Record<string, number> = {};
-      const text = query.replace(/@(\w+)/g, (_, name: string) => {
-        if (seen[name] !== undefined) return `$${seen[name]}`;
-        const idx = values.length + 1;
-        seen[name] = idx;
-        values.push(params[name] ?? null);
-        return `$${idx}`;
-      });
-      return { text, values };
-    };
-
-    return {
-      exec: async <T>(q: string, p?: Record<string, any>) => {
-        const { text, values } = transform(q, p);
-        const r = await client.query(text, values);
-        return (r.rows || []) as T[];
-      },
-      executeRaw: async (q: string, p?: Record<string, any>) => {
-        const { text, values } = transform(q, p);
-        const r = await client.query(text, values);
-        return r.rowCount ?? 0;
-      },
-      commit: async () => { await client.query('COMMIT'); client.release(); },
-      rollback: async () => { await client.query('ROLLBACK'); client.release(); },
-    };
-  }
-}
+import type { An5AdapterConfig, Dialect, QueryEngine, TransactionHandle } from '../base/types';
+
+// ─── PostgreSQL Engine ─────────────────────────────────────────────────────────────
+
+let PgPool: any = null;
+try { PgPool = require('pg').Pool; } catch { }
+
+export class PostgresEngine implements QueryEngine {
+  dialect: Dialect = 'postgres';
+  private pool: any = null;
+
+  constructor(adapterConfig: An5AdapterConfig) {
+    if (!PgPool) throw new Error('pg package is required for PostgreSQL support. Run: npm install pg');
+    this.pool = new PgPool({
+      connectionString: adapterConfig.connectionString ?? '',
+      max: adapterConfig.poolMax ?? 10,
+    });
+  }
+
+  /** Convert @name → $N; identical names reuse the same $N */
+  private transform(query: string, params?: Record<string, any>): { text: string; values: any[] } {
+    if (!params || Object.keys(params).length === 0) return { text: query, values: [] };
+    const values: any[] = [];
+    const seen: Record<string, number> = {};
+    const text = query.replace(/@(\w+)/g, (_, name: string) => {
+      if (seen[name] !== undefined) return `$${seen[name]}`;
+      const idx = values.length + 1;
+      seen[name] = idx;
+      values.push(params[name] ?? null);
+      return `$${idx}`;
+    });
+    return { text, values };
+  }
+
+  async exec<T = any>(query: string, params?: Record<string, any>): Promise<T[]> {
+    const { text, values } = this.transform(query, params);
+    const result = await this.pool.query(text, values);
+    return result.rows as T[];
+  }
+
+  async executeRaw(query: string, params?: Record<string, any>): Promise<number> {
+    const { text, values } = this.transform(query, params);
+    const result = await this.pool.query(text, values);
+    return result.rowCount ?? 0;
+  }
+
+  async connect(): Promise<void> {
+    const client = await this.pool.connect();
+    client.release();
+  }
+
+  async disconnect(): Promise<void> { await this.pool.end(); }
+
+  async beginTransaction(): Promise<TransactionHandle> {
+    const client = await this.pool.connect();
+    await client.query('BEGIN');
+
+    const transform = (query: string, params?: Record<string, any>) => {
+      if (!params || Object.keys(params).length === 0) return { text: query, values: [] };
+      const values: any[] = [];
+      const seen: Record<string, number> = {};
+      const text = query.replace(/@(\w+)/g, (_, name: string) => {
+        if (seen[name] !== undefined) return `$${seen[name]}`;
+        const idx = values.length + 1;
+        seen[name] = idx;
+        values.push(params[name] ?? null);
+        return `$${idx}`;
+      });
+      return { text, values };
+    };
+
+    return {
+      exec: async <T>(q: string, p?: Record<string, any>) => {
+        const { text, values } = transform(q, p);
+        const r = await client.query(text, values);
+        return (r.rows || []) as T[];
+      },
+      executeRaw: async (q: string, p?: Record<string, any>) => {
+        const { text, values } = transform(q, p);
+        const r = await client.query(text, values);
+        return r.rowCount ?? 0;
+      },
+      commit: async () => { await client.query('COMMIT'); client.release(); },
+      rollback: async () => { await client.query('ROLLBACK'); client.release(); },
+    };
+  }
+}

package/typescript/src/postgres/index.ts

@@ -1 +1 @@
-export * from './engine';
+export * from './engine';

package/typescript/src/sqlite/browserEngine.ts

@@ -0,0 +1,192 @@
+import type { Dialect, QueryEngine, TransactionHandle } from '../base/types';
+
+// ─── Browser SQLite Driver & Config ──────────────────────────────────────────────────
+
+export interface SqliteDriver {
+  exec<T = any>(query: string, params?: Record<string, any>): Promise<T[]> | T[];
+  executeRaw?(query: string, params?: Record<string, any>): Promise<number> | number;
+  close?(): Promise<void> | void;
+}
+
+export interface SqliteBrowserConfig {
+  db?: any; // sql.js Database instance or SQLite WASM DB
+  driver?: SqliteDriver;
+  exec?: <T = any>(query: string, params?: Record<string, any>) => Promise<T[]> | T[];
+  executeRaw?: (query: string, params?: Record<string, any>) => Promise<number> | number;
+}
+
+// ─── Browser SQLite Engine ──────────────────────────────────────────────────────────
+
+export class SqliteBrowserEngine implements QueryEngine {
+  dialect: Dialect = 'sqlite';
+  private db: any = null;
+  private driver: SqliteDriver | null = null;
+  private customExec: ((query: string, params?: Record<string, any>) => Promise<any[]> | any[]) | null = null;
+  private customExecuteRaw: ((query: string, params?: Record<string, any>) => Promise<number> | number) | null = null;
+
+  constructor(config?: SqliteBrowserConfig | any) {
+    if (!config) return;
+
+    if (config.exec && typeof config.exec === 'function') {
+      this.customExec = config.exec;
+      this.customExecuteRaw = config.executeRaw ?? null;
+      return;
+    }
+
+    if (config.driver) {
+      this.driver = config.driver;
+      return;
+    }
+
+    // Direct DB instance (e.g. sql.js Database or sqlite-wasm)
+    if (config.db) {
+      this.db = config.db;
+      return;
+    }
+
+    // If config itself looks like a driver with exec()
+    if (typeof config.exec === 'function' && typeof config.run !== 'function' && typeof config.prepare !== 'function') {
+      this.driver = config as SqliteDriver;
+      return;
+    }
+
+    // If config itself is a Database instance (has prepare, exec, run)
+    if (typeof config.prepare === 'function' || typeof config.run === 'function' || typeof config.exec === 'function') {
+      this.db = config;
+    }
+  }
+
+  private normalizeSqlJsParams(params?: Record<string, any>): Record<string, any> {
+    if (!params || typeof params !== 'object') return {};
+    const normalized: Record<string, any> = {};
+    for (const [k, v] of Object.entries(params)) {
+      const key = k.startsWith('@') || k.startsWith(':') || k.startsWith('$') ? k : `@${k}`;
+      normalized[key] = v;
+    }
+    return normalized;
+  }
+
+  async exec<T = any>(query: string, params?: Record<string, any>): Promise<T[]> {
+    if (this.customExec) {
+      return await this.customExec(query, params);
+    }
+
+    if (this.driver) {
+      return await this.driver.exec<T>(query, params);
+    }
+
+    if (this.db) {
+      // sql.js Database with prepare()
+      if (typeof this.db.prepare === 'function') {
+        const stmt = this.db.prepare(query);
+        try {
+          if (params && Object.keys(params).length > 0) {
+            stmt.bind(this.normalizeSqlJsParams(params));
+          }
+          const results: T[] = [];
+          while (stmt.step()) {
+            results.push(stmt.getAsObject() as T);
+          }
+          return results;
+        } finally {
+          stmt.free();
+        }
+      }
+
+      // Fallback sql.js db.exec()
+      if (typeof this.db.exec === 'function') {
+        const res = this.db.exec(query);
+        if (!res || res.length === 0) return [];
+        const { columns, values } = res[0];
+        return values.map((row: any[]) => {
+          const obj: any = {};
+          columns.forEach((col: string, i: number) => {
+            obj[col] = row[i];
+          });
+          return obj as T;
+        });
+      }
+    }
+
+    throw new Error('SqliteBrowserEngine: No SQLite database or driver provided. Pass a sql.js db instance or custom driver.');
+  }
+
+  async executeRaw(query: string, params?: Record<string, any>): Promise<number> {
+    if (this.customExecuteRaw) {
+      return await this.customExecuteRaw(query, params);
+    }
+
+    if (this.driver && typeof this.driver.executeRaw === 'function') {
+      return await this.driver.executeRaw(query, params);
+    }
+
+    if (this.db) {
+      if (typeof this.db.prepare === 'function') {
+        const stmt = this.db.prepare(query);
+        try {
+          if (params && Object.keys(params).length > 0) {
+            stmt.bind(this.normalizeSqlJsParams(params));
+          }
+          stmt.step();
+          if (typeof this.db.getRowsModified === 'function') {
+            return this.db.getRowsModified();
+          }
+          return 1;
+        } finally {
+          stmt.free();
+        }
+      }
+
+      if (typeof this.db.run === 'function') {
+        this.db.run(query, this.normalizeSqlJsParams(params));
+        if (typeof this.db.getRowsModified === 'function') {
+          return this.db.getRowsModified();
+        }
+        return 1;
+      }
+    }
+
+    const rows = await this.exec(query, params);
+    return rows.length;
+  }
+
+  async connect(): Promise<void> {}
+
+  async disconnect(): Promise<void> {
+    if (this.driver && typeof this.driver.close === 'function') {
+      await this.driver.close();
+    } else if (this.db && typeof this.db.close === 'function') {
+      this.db.close();
+    }
+  }
+
+  async beginTransaction(): Promise<TransactionHandle> {
+    await this.executeRaw('BEGIN');
+    let done = false;
+
+    return {
+      exec: async <T>(q: string, p?: Record<string, any>) => this.exec<T>(q, p),
+      executeRaw: async (q: string, p?: Record<string, any>) => this.executeRaw(q, p),
+      commit: async () => {
+        if (!done) {
+          await this.executeRaw('COMMIT');
+          done = true;
+        }
+      },
+      rollback: async () => {
+        if (!done) {
+          await this.executeRaw('ROLLBACK');
+          done = true;
+        }
+      },
+    };
+  }
+}
+
+// ─── Browser SQLite Adapter Factory ──────────────────────────────────────────────────
+
+export function createBrowserSqliteAdapter(config: SqliteBrowserConfig | any): any {
+  const { An5Adapter } = require('../an5Adapter');
+  return new An5Adapter({ engine: new SqliteBrowserEngine(config) });
+}
+

package/typescript/src/sqlite/engine.ts

@@ -1,55 +1,66 @@
-import type { An5AdapterConfig, Dialect, QueryEngine, TransactionHandle } from '../base/types';
-
-// ─── SQLite Engine ─────────────────────────────────────────────────────────────────
-
-let BetterSqlite3: any = null;
-try { BetterSqlite3 = require('better-sqlite3'); } catch { }
-
-export class SqliteEngine implements QueryEngine {
-  dialect: Dialect = 'sqlite';
-  private db: any = null;
-  private readonly filePath: string;
-
-  constructor(adapterConfig: An5AdapterConfig) {
-    if (!BetterSqlite3) throw new Error('better-sqlite3 package is required for SQLite support. Run: npm install better-sqlite3');
-    this.filePath = adapterConfig.connectionString
-      .replace(/^sqlite:\/\/\//i, '/')
-      .replace(/^sqlite:\/\//i, '');
-  }
-
-  private getDb(): any {
-    if (!this.db) this.db = new BetterSqlite3(this.filePath);
-    return this.db;
-  }
-
-  // better-sqlite3 natively supports @name parameters
-  async exec<T = any>(query: string, params?: Record<string, any>): Promise<T[]> {
-    return this.getDb().prepare(query).all(params ?? {}) as T[];
-  }
-
-  async executeRaw(query: string, params?: Record<string, any>): Promise<number> {
-    const info = this.getDb().prepare(query).run(params ?? {});
-    return info.changes ?? 0;
-  }
-
-  async connect(): Promise<void> { this.getDb(); }
-
-  async disconnect(): Promise<void> {
-    if (this.db) { this.db.close(); this.db = null; }
-  }
-
-  async beginTransaction(): Promise<TransactionHandle> {
-    const db = this.getDb();
-    db.prepare('BEGIN').run();
-    let done = false;
-
-    return {
-      exec: async <T>(q: string, p?: Record<string, any>) =>
-        db.prepare(q).all(p ?? {}) as T[],
-      executeRaw: async (q: string, p?: Record<string, any>) =>
-        (db.prepare(q).run(p ?? {}).changes ?? 0),
-      commit: async () => { if (!done) { db.prepare('COMMIT').run(); done = true; } },
-      rollback: async () => { if (!done) { db.prepare('ROLLBACK').run(); done = true; } },
-    };
-  }
-}
+import type { An5AdapterConfig, Dialect, QueryEngine, TransactionHandle } from '../base/types';
+
+// ─── SQLite Engine ─────────────────────────────────────────────────────────────────
+
+let BetterSqlite3: any = null;
+try { BetterSqlite3 = require('better-sqlite3'); } catch { }
+
+export class SqliteEngine implements QueryEngine {
+  dialect: Dialect = 'sqlite';
+  private db: any = null;
+  private readonly filePath: string;
+
+  constructor(adapterConfig: An5AdapterConfig) {
+    if (!BetterSqlite3) throw new Error('better-sqlite3 package is required for SQLite support. Run: npm install better-sqlite3');
+    this.filePath = (adapterConfig.connectionString ?? '')
+      .replace(/^sqlite:\/\/\//i, '/')
+      .replace(/^sqlite:\/\//i, '');
+  }
+
+  private getDb(): any {
+    if (!this.db) this.db = new BetterSqlite3(this.filePath);
+    return this.db;
+  }
+
+  // better-sqlite3 natively supports @name parameters
+  async exec<T = any>(query: string, params?: Record<string, any>): Promise<T[]> {
+    const stmt = this.getDb().prepare(query);
+    if (stmt.reader) {
+      return stmt.all(params ?? {}) as T[];
+    }
+    stmt.run(params ?? {});
+    return [] as T[];
+  }
+
+  async executeRaw(query: string, params?: Record<string, any>): Promise<number> {
+    const info = this.getDb().prepare(query).run(params ?? {});
+    return info.changes ?? 0;
+  }
+
+  async connect(): Promise<void> { this.getDb(); }
+
+  async disconnect(): Promise<void> {
+    if (this.db) { this.db.close(); this.db = null; }
+  }
+
+  async beginTransaction(): Promise<TransactionHandle> {
+    const db = this.getDb();
+    db.prepare('BEGIN').run();
+    let done = false;
+
+    return {
+      exec: async <T>(q: string, p?: Record<string, any>) => {
+        const stmt = db.prepare(q);
+        if (stmt.reader) {
+          return stmt.all(p ?? {}) as T[];
+        }
+        stmt.run(p ?? {});
+        return [] as T[];
+      },
+      executeRaw: async (q: string, p?: Record<string, any>) =>
+        (db.prepare(q).run(p ?? {}).changes ?? 0),
+      commit: async () => { if (!done) { db.prepare('COMMIT').run(); done = true; } },
+      rollback: async () => { if (!done) { db.prepare('ROLLBACK').run(); done = true; } },
+    };
+  }
+}

package/typescript/src/sqlite/index.ts

@@ -1 +1,3 @@
-export * from './engine';
+export * from './engine';
+export * from './browserEngine';
+

package/typescript/src/typed.ts

@@ -0,0 +1,52 @@
+import type { AdapterTableClient, An5Adapter } from './an5Adapter';
+
+// ─── Typed model access ──────────────────────────────────────────────────────
+// The runtime adapter resolves `db.user` / `db.User` dynamically through a
+// Proxy, which TypeScript normally types as `any` (An5Adapter declares
+// `[key: string]: any`). These helpers let app code bind generated model
+// delegate types (e.g. `UserTableClient` emitted by the schema generator) so
+// `db.user` gets full autocomplete and compile-time argument checking — the
+// standard ORM experience — without changing any runtime behavior.
+//
+// Usage:
+//   import { createAn5Adapter } from '@an5/adapters';
+//   import type { UserTableClient } from './generated/typescript/User';
+//   import type { OrderTableClient } from './generated/typescript/Order';
+//   const db = createAn5Adapter<{
+//     user: UserTableClient;
+//     order: OrderTableClient;
+//   }>({ connectionString: process.env.DATABASE_URL! });
+//   await db.user.findMany({ where: { email: { contains: '@example.com' } } });
+
+// Public adapter surface (methods/getters) without the open-ended index
+// signature, so explicit model props in TModels take effect instead of `any`.
+type AdapterMethodKeys =
+  | 'dialect'
+  | 'exec'
+  | '$queryRawUnsafe'
+  | '$executeRaw'
+  | '$executeRawUnsafe'
+  | '$connect'
+  | '$disconnect'
+  | '$transaction'
+  | '$begin'
+  | 'table'
+  | '$on'
+  | '$off'
+  | '$emit'
+  | '$use'
+  | 'view'
+  | '$queryProc'
+  | '$executeProc'
+  | 'readRange'
+  | 'writeRange'
+  | 'appendRange'
+  | 'listSheets'
+  | 'deleteSheet';
+
+export type AdapterAPI = Pick<An5Adapter, AdapterMethodKeys>;
+
+// An5Adapter with dynamically-resolved model delegates typed as TModels.
+// NOTE: keep AdapterMethodKeys in sync when adding public An5Adapter methods.
+export type TypedAn5Adapter<TModels extends object = Record<string, AdapterTableClient<any>>> =
+  AdapterAPI & TModels;