@sqb/sqljs 4.0.10 → 4.0.14

package/dist/SqljsAdapter.d.ts

@@ -0,0 +1,11 @@
+import { Adapter, ClientConfiguration } from '@sqb/connect';
+import '@sqb/sqlite-dialect';
+export declare class SqljsAdapter implements Adapter {
+    driver: string;
+    dialect: string;
+    features: {
+        cursor: boolean;
+    };
+    connect(config: ClientConfiguration): Promise<Adapter.Connection>;
+}
+export declare function closeMemoryDatabase(name?: string): Promise<void>;

package/dist/SqljsAdapter.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closeMemoryDatabase = exports.SqljsAdapter = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+require("@sqb/sqlite-dialect");
+const sql_js_1 = tslib_1.__importDefault(require("sql.js"));
+const SqljsConnection_1 = require("./SqljsConnection");
+const path_1 = tslib_1.__importDefault(require("path"));
+const putil_promisify_1 = tslib_1.__importDefault(require("putil-promisify"));
+const dbCache = new Map();
+class SqljsAdapter {
+    constructor() {
+        this.driver = 'sqljs';
+        this.dialect = 'sqlite';
+        this.features = {
+            cursor: true,
+            // fetchAsString: [DataType.DATE, DataType.TIMESTAMP, DataType.TIMESTAMPTZ]
+        };
+    }
+    async connect(config) {
+        if (!config.database)
+            throw new Error('You must provide sqlite database file for sql.js driver');
+        let dbName = '';
+        let isMemory = false;
+        const m = config.database.match(/^(:memory:)(\w+)?$/);
+        if (m) {
+            isMemory = true;
+            dbName = config.database;
+        }
+        else {
+            dbName = path_1.default.resolve(config.database);
+        }
+        let intlDb = dbCache.get(dbName);
+        if (intlDb) {
+            intlDb._refCount++;
+        }
+        else {
+            const SQL = await (0, sql_js_1.default)();
+            if (isMemory) {
+                intlDb = new SQL.Database();
+                intlDb._refCount = 0;
+            }
+            else {
+                const buf = await putil_promisify_1.default.fromCallback(cb => fs_1.default.readFile(dbName, cb));
+                intlDb = new SQL.Database(buf);
+                intlDb._refCount = 1;
+            }
+            dbCache.set(dbName, intlDb);
+        }
+        const _intlDb = intlDb;
+        return new SqljsConnection_1.SqljsConnection(_intlDb, () => {
+            if (isMemory)
+                return;
+            if (--_intlDb._refCount <= 0) {
+                _intlDb.close();
+                dbCache.delete(dbName);
+            }
+        });
+    }
+}
+exports.SqljsAdapter = SqljsAdapter;
+async function closeMemoryDatabase(name) {
+    const memoryDbName = name || ':memory:';
+    const memDb = dbCache.get(memoryDbName);
+    if (memDb) {
+        dbCache.delete(memoryDbName);
+        memDb.close();
+    }
+}
+exports.closeMemoryDatabase = closeMemoryDatabase;

package/dist/SqljsConnection.d.ts

@@ -0,0 +1,16 @@
+import { Database } from 'sql.js';
+import { Adapter, QueryRequest } from '@sqb/connect';
+export declare class SqljsConnection implements Adapter.Connection {
+    private _onClose;
+    private intlcon?;
+    constructor(db: Database, _onClose: Function);
+    get sessionId(): any;
+    close(): Promise<void>;
+    reset(): Promise<void>;
+    startTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    test(): Promise<void>;
+    execute(query: QueryRequest): Promise<Adapter.Response>;
+    private _convertFields;
+}

package/dist/SqljsConnection.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqljsConnection = void 0;
+const SqljsCursor_1 = require("./SqljsCursor");
+class SqljsConnection {
+    constructor(db, _onClose) {
+        this._onClose = _onClose;
+        this.intlcon = db;
+    }
+    get sessionId() {
+        return 0;
+    }
+    async close() {
+        if (this.intlcon) {
+            this.intlcon = undefined;
+            await this._onClose();
+        }
+    }
+    async reset() {
+        return this.rollback();
+    }
+    async startTransaction() {
+        assertDefined(this.intlcon);
+        try {
+            this.intlcon.exec('BEGIN TRANSACTION;');
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.match(/within a transaction/))
+                return;
+            throw e;
+        }
+    }
+    async commit() {
+        assertDefined(this.intlcon);
+        try {
+            this.intlcon.exec('COMMIT;');
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.match(/no transaction/))
+                return;
+            throw e;
+        }
+    }
+    async rollback() {
+        assertDefined(this.intlcon);
+        try {
+            this.intlcon.exec('ROLLBACK;');
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.match(/no transaction/))
+                return;
+            throw e;
+        }
+    }
+    async test() {
+        assertDefined(this.intlcon);
+        this.intlcon.exec('select 1');
+    }
+    async execute(query) {
+        assertDefined(this.intlcon);
+        if (!query.autoCommit)
+            await this.startTransaction();
+        const out = {};
+        let params;
+        if (query.params) {
+            const prms = query.params;
+            params = Object.keys(prms).reduce((obj, k) => {
+                obj[':' + k] = prms[k];
+                return obj;
+            }, {});
+        }
+        const m = query.sql.match(/\b(insert into|update|delete from)\b ("?\w+"?)/i);
+        if (m) {
+            const stmt = this.intlcon.prepare(query.sql);
+            stmt.run(params);
+            stmt.free();
+            out.rowsAffected = this.intlcon.getRowsModified();
+            if (query.autoCommit)
+                await this.commit();
+            if (out.rowsAffected === 1 && query.returningFields) {
+                const selectFields = query.returningFields.map(x => x.field + (x.alias ? ' as ' + x.alias : ''));
+                let sql = `select ${selectFields.join(',')} from ${m[2]}\n`;
+                // Emulate insert into ... returning
+                if (m[1].toLowerCase() === 'insert into') {
+                    sql += 'where rowid=last_insert_rowid();';
+                    const r = this.intlcon.exec(sql);
+                    if (r.length) {
+                        out.fields = this._convertFields(r[0].columns);
+                        out.rows = r[0].values;
+                        out.rowType = 'array';
+                    }
+                    return out;
+                }
+                else 
+                // Emulate update ... returning
+                if (m[1].toLowerCase() === 'update') {
+                    const m2 = query.sql.match(/where (.+)/);
+                    query = { ...query };
+                    query.sql = sql + (m2 ? ' where ' + m2[1] : '');
+                }
+                else
+                    return out;
+            }
+        }
+        let stmt = this.intlcon.prepare(query.sql, query.params);
+        try {
+            const colNames = stmt.getColumnNames();
+            if (colNames && colNames.length) {
+                out.fields = this._convertFields(colNames);
+                const rowType = query.objectRows ? 'object' : 'array';
+                out.rowType = rowType;
+                const cursor = new SqljsCursor_1.SqljsCursor(stmt, { rowType });
+                if (query.cursor) {
+                    out.cursor = cursor;
+                    stmt = undefined;
+                }
+                else
+                    out.rows = await cursor.fetch(query.fetchRows || 100);
+            }
+            return out;
+        }
+        finally {
+            if (stmt)
+                stmt.free();
+        }
+    }
+    _convertFields(fields) {
+        const result = [];
+        for (let i = 0; i < fields.length; i++) {
+            const v = fields[i];
+            const o = {
+                fieldName: v,
+                dataType: 'any',
+                jsType: 'any',
+                _inf: { name: v }
+            };
+            result.push(o);
+        }
+        return result;
+    }
+}
+exports.SqljsConnection = SqljsConnection;
+function assertDefined(d) {
+    if (d == null)
+        throw new Error("Invalid data");
+}

package/dist/SqljsCursor.d.ts

@@ -0,0 +1,12 @@
+import { Adapter, RowType } from '@sqb/connect';
+export declare class SqljsCursor implements Adapter.Cursor {
+    private _stmt?;
+    private readonly _rowType;
+    constructor(stmt: any, opts: {
+        rowType: RowType;
+    });
+    get isClosed(): boolean;
+    get rowType(): RowType;
+    close(): Promise<void>;
+    fetch(nRows: number): Promise<any[] | undefined>;
+}

package/dist/SqljsCursor.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqljsCursor = void 0;
+class SqljsCursor {
+    constructor(stmt, opts) {
+        this._rowType = opts.rowType;
+        this._stmt = stmt;
+    }
+    get isClosed() {
+        return !this._stmt;
+    }
+    get rowType() {
+        return this._rowType;
+    }
+    async close() {
+        if (!this._stmt)
+            return;
+        this._stmt.free();
+        this._stmt = undefined;
+    }
+    async fetch(nRows) {
+        if (!this._stmt)
+            return;
+        const stmt = this._stmt;
+        const rows = [];
+        while (nRows-- && stmt.step()) {
+            rows.push(this.rowType === 'object' ? stmt.getAsObject() : stmt.get());
+        }
+        return rows;
+    }
+}
+exports.SqljsCursor = SqljsCursor;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const connect_1 = require("@sqb/connect");
+const SqljsAdapter_1 = require("./SqljsAdapter");
+(0, connect_1.registerAdapter)(new SqljsAdapter_1.SqljsAdapter());

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sqb/sqljs",
   "description": "SQB serialization extension for sql.js driver",
-  "version": "4.0.10",
+  "version": "4.0.14",
   "author": "Panates",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>"
@@ -26,8 +26,8 @@
     "putil-promisify": "^1.8.5"
   },
   "devDependencies": {
-    "@types/sql.js": "^1.4.2",
-    "sql.js": "^1.5.0"
+    "@types/sql.js": "^1.4.3",
+    "sql.js": "^1.6.2"
   },
   "peerDependencies": {
     "sql.js": "^1.4.0",