@an5/adapters 0.2.5 → 0.2.9

package/dist/sqlite/browserEngine.d.ts

@@ -0,0 +1,27 @@
+import type { Dialect, QueryEngine, TransactionHandle } from '../base/types';
+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;
+    driver?: SqliteDriver;
+    exec?: <T = any>(query: string, params?: Record<string, any>) => Promise<T[]> | T[];
+    executeRaw?: (query: string, params?: Record<string, any>) => Promise<number> | number;
+}
+export declare class SqliteBrowserEngine implements QueryEngine {
+    dialect: Dialect;
+    private db;
+    private driver;
+    private customExec;
+    private customExecuteRaw;
+    constructor(config?: SqliteBrowserConfig | any);
+    private normalizeSqlJsParams;
+    exec<T = any>(query: string, params?: Record<string, any>): Promise<T[]>;
+    executeRaw(query: string, params?: Record<string, any>): Promise<number>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    beginTransaction(): Promise<TransactionHandle>;
+}
+export declare function createBrowserSqliteAdapter(config: SqliteBrowserConfig | any): any;

package/dist/sqlite/browserEngine.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteBrowserEngine = void 0;
+exports.createBrowserSqliteAdapter = createBrowserSqliteAdapter;
+// ─── Browser SQLite Engine ──────────────────────────────────────────────────────────
+class SqliteBrowserEngine {
+    constructor(config) {
+        this.dialect = 'sqlite';
+        this.db = null;
+        this.driver = null;
+        this.customExec = null;
+        this.customExecuteRaw = null;
+        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;
+            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;
+        }
+    }
+    normalizeSqlJsParams(params) {
+        if (!params || typeof params !== 'object')
+            return {};
+        const normalized = {};
+        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(query, params) {
+        if (this.customExec) {
+            return await this.customExec(query, params);
+        }
+        if (this.driver) {
+            return await this.driver.exec(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 = [];
+                    while (stmt.step()) {
+                        results.push(stmt.getAsObject());
+                    }
+                    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) => {
+                    const obj = {};
+                    columns.forEach((col, i) => {
+                        obj[col] = row[i];
+                    });
+                    return obj;
+                });
+            }
+        }
+        throw new Error('SqliteBrowserEngine: No SQLite database or driver provided. Pass a sql.js db instance or custom driver.');
+    }
+    async executeRaw(query, params) {
+        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() { }
+    async disconnect() {
+        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() {
+        await this.executeRaw('BEGIN');
+        let done = false;
+        return {
+            exec: async (q, p) => this.exec(q, p),
+            executeRaw: async (q, p) => this.executeRaw(q, p),
+            commit: async () => {
+                if (!done) {
+                    await this.executeRaw('COMMIT');
+                    done = true;
+                }
+            },
+            rollback: async () => {
+                if (!done) {
+                    await this.executeRaw('ROLLBACK');
+                    done = true;
+                }
+            },
+        };
+    }
+}
+exports.SqliteBrowserEngine = SqliteBrowserEngine;
+// ─── Browser SQLite Adapter Factory ──────────────────────────────────────────────────
+function createBrowserSqliteAdapter(config) {
+    const { An5Adapter } = require('../an5Adapter');
+    return new An5Adapter({ engine: new SqliteBrowserEngine(config) });
+}

package/dist/sqlite/engine.js

@@ -13,7 +13,7 @@ class SqliteEngine {
         this.db = null;
         if (!BetterSqlite3)
             throw new Error('better-sqlite3 package is required for SQLite support. Run: npm install better-sqlite3');
-        this.filePath = adapterConfig.connectionString
+        this.filePath = (adapterConfig.connectionString ?? '')
             .replace(/^sqlite:\/\/\//i, '/')
             .replace(/^sqlite:\/\//i, '');
     }
@@ -24,7 +24,12 @@ class SqliteEngine {
     }
     // better-sqlite3 natively supports @name parameters
     async exec(query, params) {
-        return this.getDb().prepare(query).all(params ?? {});
+        const stmt = this.getDb().prepare(query);
+        if (stmt.reader) {
+            return stmt.all(params ?? {});
+        }
+        stmt.run(params ?? {});
+        return [];
     }
     async executeRaw(query, params) {
         const info = this.getDb().prepare(query).run(params ?? {});
@@ -42,7 +47,14 @@ class SqliteEngine {
         db.prepare('BEGIN').run();
         let done = false;
         return {
-            exec: async (q, p) => db.prepare(q).all(p ?? {}),
+            exec: async (q, p) => {
+                const stmt = db.prepare(q);
+                if (stmt.reader) {
+                    return stmt.all(p ?? {});
+                }
+                stmt.run(p ?? {});
+                return [];
+            },
             executeRaw: async (q, p) => (db.prepare(q).run(p ?? {}).changes ?? 0),
             commit: async () => { if (!done) {
                 db.prepare('COMMIT').run();

package/dist/sqlite/index.d.ts

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

package/dist/sqlite/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./engine"), exports);
+__exportStar(require("./browserEngine"), exports);

package/dist/typed.d.ts

@@ -0,0 +1,5 @@
+import type { AdapterTableClient, An5Adapter } from './an5Adapter';
+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>;
+export type TypedAn5Adapter<TModels extends object = Record<string, AdapterTableClient<any>>> = AdapterAPI & TModels;
+export {};

package/dist/typed.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });