@kubun/db-expo 0.10.0 → 0.12.0

package/lib/driver.js

@@ -1 +1,139 @@
-import*as e from"expo-sqlite";import{SqliteAdapter as t,SqliteIntrospector as n,SqliteQueryCompiler as i}from"kysely";import{serialize as s}from"./serialize.js";export class ExpoDialect{config;constructor(e){this.config={...e,disableStrictModeCreateTable:!0}}createDriver(){return new ExpoDriver(this.config)}createQueryCompiler(){return new i}createAdapter(){return new t}createIntrospector(e){return new n(e)}}export class ExpoDriver{#e=new o;#t;constructor(e){this.#t=new r(e)}async releaseConnection(){this.#e.unlock()}async init(){}async acquireConnection(){return await this.#e.lock(),this.#t}async beginTransaction(e){await e.directQuery("begin transaction")}async commitTransaction(e){await e.directQuery("commit")}async rollbackTransaction(e){await e.directQuery("rollback")}async destroy(){this.#t.closeConnection()}async getDatabaseRuntimeVersion(){try{return(await this.#t.directQuery("select sqlite_version() as version;"))[0].version}catch(e){return console.error(e),"unknown"}}}class r{sqlite;debug;config;constructor(t){this.sqlite=e.openDatabaseSync(t.database),this.debug=t.debug??!1,this.config=t,this.config.disableForeignKeys?this.sqlite.execSync("PRAGMA foreign_keys = OFF;"):this.sqlite.execSync("PRAGMA foreign_keys = ON;")}async closeConnection(){return this.sqlite.closeAsync()}async executeQuery(e){let{sql:t,parameters:n,query:i}=e;"CreateTableNode"!==i.kind||t.includes("kysely_migration")||t.includes("kysely_migration_lock")||t.includes("STRICT")||this.config.disableStrictModeCreateTable||(t+=" STRICT");let r="SelectQueryNode"===i.kind||"RawNode"===i.kind,o=!r&&t.includes(" returning "),c=s([...n]);if(this.debug&&console.debug(`${i.kind}${r?" (readonly)":""}${o?" (returning)":""}: ${t}`),r||o)return{rows:await this.sqlite.getAllAsync(t,c)};let a=await this.sqlite.runAsync(t,c),l={numAffectedRows:BigInt(a.changes),insertId:BigInt(a.lastInsertRowId),rows:[]};return this.debug&&console.log("queryResult",l),l}async directQuery(e){return await this.sqlite.getAllAsync(e,[])}streamQuery(e,t){throw Error("Expo SQLite driver does not support iterate on prepared statements")}}class o{#n;#i;async lock(){for(;this.#n;)await this.#n;this.#n=new Promise(e=>{this.#i=e})}unlock(){let e=this.#i;this.#n=void 0,this.#i=void 0,e?.()}}
+import * as SQLite from 'expo-sqlite';
+// Adapted from https://github.com/mphill/kysely-expo/blob/main/src/driver.ts
+import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from 'kysely';
+import { serialize } from './serialize.js';
+/**
+ * Expo dialect for Kysely.
+ */ export class ExpoDialect {
+    config;
+    constructor(config){
+        this.config = {
+            ...config,
+            disableStrictModeCreateTable: true
+        };
+    }
+    createDriver() {
+        return new ExpoDriver(this.config);
+    }
+    createQueryCompiler() {
+        return new SqliteQueryCompiler();
+    }
+    createAdapter() {
+        return new SqliteAdapter();
+    }
+    createIntrospector(db) {
+        return new SqliteIntrospector(db);
+    }
+}
+/**
+ * Expo driver for Kysely.
+ */ export class ExpoDriver {
+    #connectionMutex = new ConnectionMutex();
+    #connection;
+    constructor(config){
+        this.#connection = new ExpoConnection(config);
+    }
+    async releaseConnection() {
+        this.#connectionMutex.unlock();
+    }
+    async init() {}
+    async acquireConnection() {
+        await this.#connectionMutex.lock();
+        return this.#connection;
+    }
+    async beginTransaction(connection) {
+        await connection.directQuery('begin transaction');
+    }
+    async commitTransaction(connection) {
+        await connection.directQuery('commit');
+    }
+    async rollbackTransaction(connection) {
+        await connection.directQuery('rollback');
+    }
+    async destroy() {
+        this.#connection.closeConnection();
+    }
+    async getDatabaseRuntimeVersion() {
+        try {
+            const res = await this.#connection.directQuery('select sqlite_version() as version;');
+            //@ts-expect-error
+            return res[0].version;
+        } catch (e) {
+            console.error(e);
+            return 'unknown';
+        }
+    }
+}
+/**
+ * Expo connection for Kysely.
+ */ class ExpoConnection {
+    sqlite;
+    debug;
+    config;
+    constructor(config){
+        this.sqlite = SQLite.openDatabaseSync(config.database);
+        this.debug = config.debug ?? false;
+        this.config = config;
+        if (this.config.disableForeignKeys) {
+            this.sqlite.execSync('PRAGMA foreign_keys = OFF;');
+        } else {
+            this.sqlite.execSync('PRAGMA foreign_keys = ON;');
+        }
+    }
+    async closeConnection() {
+        return this.sqlite.closeAsync();
+    }
+    async executeQuery(compiledQuery) {
+        let { sql, parameters, query } = compiledQuery;
+        // Kysely uses varchar(255) as the default string type for migrations which is not supported by STRICT mode.
+        if (query.kind === 'CreateTableNode' && !sql.includes('kysely_migration') && !sql.includes('kysely_migration_lock') && !sql.includes('STRICT') && !this.config.disableStrictModeCreateTable) {
+            sql += ' STRICT';
+        }
+        const readonly = query.kind === 'SelectQueryNode' || query.kind === 'RawNode';
+        const hasReturning = !readonly && sql.includes(' returning ');
+        const transformedParameters = serialize([
+            ...parameters
+        ]);
+        if (this.debug) {
+            console.debug(`${query.kind}${readonly ? ' (readonly)' : ''}${hasReturning ? ' (returning)' : ''}: ${sql}`);
+        }
+        if (readonly || hasReturning) {
+            const res = await this.sqlite.getAllAsync(sql, transformedParameters);
+            return {
+                rows: res
+            };
+        }
+        const res = await this.sqlite.runAsync(sql, transformedParameters);
+        const queryResult = {
+            numAffectedRows: BigInt(res.changes),
+            insertId: BigInt(res.lastInsertRowId),
+            rows: []
+        };
+        if (this.debug) console.log('queryResult', queryResult);
+        return queryResult;
+    }
+    async directQuery(query) {
+        return await this.sqlite.getAllAsync(query, []);
+    }
+    streamQuery(_compiledQuery, _chunkSize) {
+        throw new Error('Expo SQLite driver does not support iterate on prepared statements');
+    }
+}
+class ConnectionMutex {
+    #promise;
+    #resolve;
+    async lock() {
+        while(this.#promise){
+            await this.#promise;
+        }
+        this.#promise = new Promise((resolve)=>{
+            this.#resolve = resolve;
+        });
+    }
+    unlock() {
+        const resolve = this.#resolve;
+        this.#promise = undefined;
+        this.#resolve = undefined;
+        resolve?.();
+    }
+}

package/lib/index.js

@@ -1 +1,29 @@
-import{AbstractSQLiteAdapter as e}from"@kubun/db-adapter";import{ExpoDialect as r}from"./driver.js";export class ExpoAdapter extends e{#e;#r=!1;constructor(e){super(),this.#e=new r(e)}get dialect(){return this.#e}#a(){this.#r||(console.warn("ExpoAdapter: full-text search is not supported in Expo environments"),this.#r=!0)}async createSearchIndex(e,r){this.#a()}async dropSearchIndex(e,r){}async updateSearchEntry(e,r,a,n,t){}async removeSearchEntry(e,r,a){}async searchIndex(e,r){return this.#a(),[]}}
+import { AbstractSQLiteAdapter } from '@kubun/db-adapter';
+import { ExpoDialect } from './driver.js';
+export class ExpoAdapter extends AbstractSQLiteAdapter {
+    #dialect;
+    #searchWarned = false;
+    constructor(params){
+        super();
+        this.#dialect = new ExpoDialect(params);
+    }
+    get dialect() {
+        return this.#dialect;
+    }
+    #warnOnce() {
+        if (!this.#searchWarned) {
+            console.warn('ExpoAdapter: full-text search is not supported in Expo environments');
+            this.#searchWarned = true;
+        }
+    }
+    async createSearchIndex(_db, _config) {
+        this.#warnOnce();
+    }
+    async dropSearchIndex(_db, _modelID) {}
+    async updateSearchEntry(_db, _modelID, _documentID, _fields, _fieldNames) {}
+    async removeSearchEntry(_db, _modelID, _documentID) {}
+    async searchIndex(_db, _params) {
+        this.#warnOnce();
+        return [];
+    }
+}

package/lib/serialize.js

@@ -1 +1,27 @@
-export function serialize(r){return r.map(r=>{if("string"==typeof r)return r.toString();if(r instanceof Date)return r.toISOString();if("number"==typeof r||r instanceof Uint8Array)return r;if(null==r)return null;if("object"==typeof r)return JSON.stringify(r);if("boolean"==typeof r)return r?"true":"false";throw Error(`Unknown type: ${typeof r}`)})}
+export function serialize(parameters) {
+    return parameters.map((parameter)=>{
+        if (typeof parameter === 'string') {
+            return parameter.toString();
+        }
+        if (parameter instanceof Date) {
+            return parameter.toISOString();
+        }
+        if (typeof parameter === 'number') {
+            return parameter;
+        }
+        if (parameter instanceof Uint8Array) {
+            return parameter;
+        }
+        if (parameter === null || parameter === undefined) {
+            return null;
+        }
+        if (typeof parameter === 'object') {
+            return JSON.stringify(parameter);
+        }
+        if (typeof parameter === 'boolean') {
+            return parameter ? 'true' : 'false' // SQLite booleans must be stored a strings.
+            ;
+        }
+        throw new Error(`Unknown type: ${typeof parameter}`);
+    });
+}

package/package.json

@@ -1,32 +1,32 @@
 {
   "name": "@kubun/db-expo",
-  "version": "0.10.0",
-  "license": "see LICENSE.md",
+  "version": "0.12.0",
   "keywords": [],
+  "license": "see LICENSE.md",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/*",
     "LICENSE.md"
   ],
-  "sideEffects": false,
   "dependencies": {
-    "expo-sqlite": "~56.0.4",
-    "kysely": "^0.29.2",
-    "@kubun/db-adapter": "^0.10.0"
+    "expo-sqlite": "~57.0.1",
+    "kysely": "^0.29.4",
+    "@kubun/db-adapter": "^0.12.0"
   },
   "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
-    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }