@connecttomahdi/rxdb 17.0.0-beta.17

package/src/plugins/storage-sqlite/sqlite-basics-helpers.ts

@@ -0,0 +1,656 @@
+import {
+    ensureNotFalsy,
+    PROMISE_RESOLVE_VOID,
+    getFromMapOrCreate,
+    randomToken,
+    promiseWait
+} from '../../index.ts';
+import type {
+    Sqlite3Type,
+    SQLiteBasics,
+    SQLiteDatabaseClass,
+    SQLiteQueryWithParams
+} from './sqlite-types.ts';
+import { boolParamsToInt } from './sqlite-helpers.ts';
+
+
+const BASICS_BY_SQLITE_LIB = new WeakMap();
+export function getSQLiteBasicsNode(
+    sqlite3: Sqlite3Type
+): SQLiteBasics<SQLiteDatabaseClass> {
+    let basics: SQLiteBasics<SQLiteDatabaseClass> = BASICS_BY_SQLITE_LIB.get(sqlite3);
+    if (!basics) {
+        basics = {
+            open: (name: string) => Promise.resolve(new sqlite3.Database(name)),
+            async run(
+                db: SQLiteDatabaseClass,
+                queryWithParams: SQLiteQueryWithParams
+            ) {
+                if (!Array.isArray(queryWithParams.params)) {
+                    console.dir(queryWithParams);
+                    throw new Error('no params array given for query: ' + queryWithParams.query);
+                }
+                await execSqlSQLiteNode(
+                    db,
+                    queryWithParams,
+                    'run'
+                );
+            },
+            async all(
+                db: SQLiteDatabaseClass,
+                queryWithParams: SQLiteQueryWithParams
+            ) {
+                const result = await execSqlSQLiteNode(
+                    db,
+                    queryWithParams,
+                    'all'
+                );
+                return result;
+            },
+            async setPragma(db, key, value) {
+                return await execSqlSQLiteNode(
+                    db,
+                    {
+                        query: 'PRAGMA ' + key + ' = ' + value,
+                        params: [],
+                        context: {
+                            method: 'setPragma',
+                            data: {
+                                key,
+                                value
+                            }
+                        }
+                    },
+                    'run'
+                );
+            },
+            async close(db: SQLiteDatabaseClass) {
+                return await closeSQLiteDatabaseNode(db);
+            },
+            journalMode: 'WAL2'
+        };
+        BASICS_BY_SQLITE_LIB.set(sqlite3, basics);
+    }
+    return basics;
+}
+
+
+
+/**
+ * Uses the native sqlite that comes sshipped with node version 22+
+ * @link https://nodejs.org/api/sqlite.html
+ */
+export function getSQLiteBasicsNodeNative(
+    // Pass the `sqlite.DatabaseSync` method here
+    constructor: any
+): SQLiteBasics<any> {
+    return {
+        open: async (name: string) => {
+            const db = new constructor(name);
+            return db;
+        },
+        all: async (db: any, queryWithParams: SQLiteQueryWithParams) => {
+            await promiseWait(0); // TODO we should not need this
+            const prepared = db.prepare(queryWithParams.query);
+            const result = await prepared.all(...mapNodeNativeParams(queryWithParams.params));
+            return result;
+        },
+        run: async (db: any, queryWithParams: SQLiteQueryWithParams) => {
+            const prepared = db.prepare(queryWithParams.query);
+            await prepared.run(...mapNodeNativeParams(queryWithParams.params));
+        },
+        setPragma: async (db, key, value) => {
+            await db.exec(`pragma ${key} = ${value};`);
+        },
+        close: async (db: any) => {
+            return db.close();
+        },
+        journalMode: 'WAL',
+    };
+};
+
+/**
+ * For unknown reason we cannot bind boolean values
+ * and have to map them to one and zero.
+ * TODO create an issue at Node.js
+ */
+export function mapNodeNativeParams(params: SQLiteQueryWithParams['params']): SQLiteQueryWithParams['params'] {
+    return params.map(param => {
+        if (typeof param === 'boolean') {
+            if (param) {
+                return 1;
+            } else {
+                return 0;
+            }
+        } else {
+            return param;
+        }
+    });
+}
+
+
+/**
+ * Promisified version of db.run()
+ */
+export function execSqlSQLiteNode(
+    database: SQLiteDatabaseClass,
+    queryWithParams: SQLiteQueryWithParams,
+    operator: 'run' | 'all'
+): any {
+    const debug = false;
+    let resolved = false;
+    return new Promise((res, rej) => {
+        if (debug) {
+            console.log('# execSqlSQLiteNode() ' + queryWithParams.query);
+        }
+        database[operator](
+            queryWithParams.query,
+            queryWithParams.params,
+            ((err: any, result: any) => {
+                if (resolved) {
+                    throw new Error('callback called multiple times ' + queryWithParams.query);
+                }
+                resolved = true;
+                if (err) {
+                    if (debug) {
+                        console.log('---- ERROR RUNNING SQL:');
+                        console.log(queryWithParams.query);
+                        console.dir(queryWithParams.params);
+                        console.dir(err);
+                        console.log('----');
+                    }
+                    rej(err);
+                } else {
+                    if (debug) {
+                        console.log('execSql() result: ' + database.eventNames());
+                        console.log(queryWithParams.query);
+                        console.dir(result);
+                        console.log('execSql() result:');
+                        console.log(queryWithParams.query);
+                        console.dir(queryWithParams.params);
+                        console.log('execSql() result -------------------------');
+                    }
+                    res(result);
+                }
+            })
+        );
+    });
+}
+
+
+export function closeSQLiteDatabaseNode(
+    database: SQLiteDatabaseClass
+): Promise<void> {
+    return new Promise((res, rej) => {
+        let resolved = false;
+        database.close((err: any) => {
+            if (resolved) {
+                throw new Error('close() callback called multiple times');
+            }
+            resolved = true;
+            if (
+                err &&
+                !err.message.includes('Database is closed')
+            ) {
+                rej(err);
+            } else {
+                res();
+            }
+        });
+    });
+}
+
+
+
+
+
+
+
+
+type SQLiteCapacitorDatabase = any;
+type SQLiteConnection = any;
+
+const BASICS_BY_SQLITE_LIB_CAPACITOR: WeakMap<SQLiteConnection, SQLiteBasics<SQLiteCapacitorDatabase>> = new WeakMap();
+const CAPACITOR_CONNECTION_BY_NAME = new Map();
+/**
+ * In capacitor it is not allowed to reopen an already
+ * open database connection. So we have to queue the open-close
+ * calls so that they do not run in parallel and we do not open&close
+ * database connections at the same time.
+ */
+let capacitorOpenCloseQueue = PROMISE_RESOLVE_VOID;
+
+export function getSQLiteBasicsCapacitor(
+    sqlite: SQLiteConnection,
+    capacitorCore: any
+): SQLiteBasics<SQLiteCapacitorDatabase> {
+    const basics = getFromMapOrCreate<SQLiteConnection, SQLiteBasics<SQLiteCapacitorDatabase>>(
+        BASICS_BY_SQLITE_LIB_CAPACITOR,
+        sqlite,
+        () => {
+            const innerBasics: SQLiteBasics<SQLiteCapacitorDatabase> = {
+                open(dbName: string) {
+                    capacitorOpenCloseQueue = capacitorOpenCloseQueue.then(async () => {
+                        const db = await getFromMapOrCreate(
+                            CAPACITOR_CONNECTION_BY_NAME,
+                            dbName,
+                            () => sqlite.createConnection(dbName, false, 'no-encryption', 1)
+                        );
+                        await db.open();
+                        return db;
+                    });
+                    return capacitorOpenCloseQueue;
+                },
+                async run(
+                    db: SQLiteCapacitorDatabase,
+                    queryWithParams: SQLiteQueryWithParams
+                ) {
+                    await db.run(
+                        queryWithParams.query,
+                        queryWithParams.params,
+                        false
+                    );
+                },
+                async all(
+                    db: SQLiteCapacitorDatabase,
+                    queryWithParams: SQLiteQueryWithParams
+                ) {
+                    const result: any = await db.query(
+                        queryWithParams.query,
+                        queryWithParams.params
+                    );
+                    return ensureNotFalsy(result.values);
+                },
+                setPragma(db, key, value) {
+                    return db.execute('PRAGMA ' + key + ' = ' + value, false);
+                },
+                close(db: SQLiteCapacitorDatabase) {
+                    capacitorOpenCloseQueue = capacitorOpenCloseQueue.then(() => {
+                        return db.close();
+                    });
+                    return capacitorOpenCloseQueue;
+                },
+                /**
+                 * On android, there is already WAL mode set.
+                 * So we do not have to set it by our own.
+                 * @link https://github.com/capacitor-community/sqlite/issues/258#issuecomment-1102966087
+                 */
+                journalMode: capacitorCore.getPlatform() === 'android' ? '' : 'WAL'
+            };
+            return innerBasics;
+        }
+    );
+    return basics;
+}
+
+
+
+
+
+type SQLiteQuickDatabase = any;
+type SQLiteQuickConnection = any;
+export const EMPTY_FUNCTION = () => { };
+
+export function getSQLiteBasicsQuickSQLite(
+    openDB: any
+): SQLiteBasics<SQLiteQuickDatabase> {
+    return {
+        open: async (name: string) => {
+            return await openDB(
+                { name }
+            );
+        },
+        all: async (db: SQLiteQuickConnection, queryWithParams: SQLiteQueryWithParams) => {
+            const result = await db.executeAsync(
+                queryWithParams.query,
+                queryWithParams.params
+            );
+            return result.rows._array;
+        },
+        run: (db: SQLiteQuickConnection, queryWithParams: SQLiteQueryWithParams) => {
+            return db.executeAsync(
+                queryWithParams.query,
+                queryWithParams.params
+            );
+        },
+        setPragma(db, key, value) {
+            return db.executeAsync(
+                'PRAGMA ' + key + ' = ' + value,
+                []
+            );
+        },
+        close: async (db: SQLiteQuickConnection) => {
+            return await db.close(
+                EMPTY_FUNCTION,
+                EMPTY_FUNCTION,
+            );
+        },
+        journalMode: '',
+    };
+}
+
+
+
+
+/**
+ * @deprecated Use getSQLiteBasicsExpoSQLiteAsync() instead
+ */
+export function getSQLiteBasicsExpoSQLite(
+    openDB: any,
+    options?: any,
+    directory?: any
+): SQLiteBasics<any> {
+    return {
+        open: async (name: string,) => {
+            return await openDB(name, options, directory);
+        },
+        all: (db: any, queryWithParams: SQLiteQueryWithParams) => {
+            const result = new Promise<any>((resolve, reject) => {
+                db.exec(
+                    [{ sql: queryWithParams.query, args: queryWithParams.params }],
+                    false,
+                    (err: any, res: any) => {
+                        if (err) {
+                            return reject(err);
+                        }
+                        if (Array.isArray(res)) {
+                            const queryResult = res[0]; // there is only one query
+                            if (Object.prototype.hasOwnProperty.call(queryResult, 'rows')) {
+                                return resolve(queryResult.rows);
+                            }
+                            return reject(queryResult.error);
+                        }
+                        return reject(new Error(`getSQLiteBasicsExpoSQLite.all() response is not an array: ${res}`));
+                    }
+                );
+            });
+            return result;
+        },
+        run: (db: any, queryWithParams: SQLiteQueryWithParams) => {
+            return new Promise<any>((resolve, reject) => {
+                db.exec([{ sql: queryWithParams.query, args: queryWithParams.params }], false, (err: any, res: any) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    if (Array.isArray(res) && res[0] && res[0].error) {
+                        return reject(res);
+                    } else {
+                        resolve(res);
+                    };
+                });
+            });
+        },
+        setPragma(db, key, value) {
+            return new Promise<any>((resolve, reject) => {
+                db.exec([{ sql: `pragma ${key} = ${value};`, args: [] }], false, (err: any, res: any) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    if (Array.isArray(res) && res[0] && res[0].error) {
+                        return reject(res);
+                    } else {
+                        resolve(res);
+                    };
+                });
+            });
+        },
+        close: async (db: any) => {
+            return await db.closeAsync();
+        },
+        journalMode: '',
+    };
+};
+
+
+/**
+ * @link https://docs.expo.dev/versions/latest/sdk/sqlite/
+ */
+export function getSQLiteBasicsExpoSQLiteAsync(
+    openDB: any,
+    options?: any,
+    directory?: any
+): SQLiteBasics<any> {
+    return {
+        open: async (name: string) => {
+            return await openDB(name, options, directory);
+        },
+        all: async (db: any, queryWithParams: SQLiteQueryWithParams) => {
+            const result = await db.getAllAsync(
+                queryWithParams.query,
+                queryWithParams.params
+            );
+            return result as any;
+        },
+        run: async (db: any, queryWithParams: SQLiteQueryWithParams) => {
+            const ret = await db.runAsync(
+                queryWithParams.query,
+                queryWithParams.params
+            );
+            return ret as any;
+        },
+        async setPragma(db, key, value) {
+            await db.execAsync('PRAGMA ' + key + ' = ' + value);
+        },
+        close: async (db: any) => {
+            return await db.closeAsync();
+        },
+        journalMode: '',
+    };
+};
+
+
+
+/**
+ * Build to be compatible with packages
+ * that use the websql npm package like:
+ * @link https://www.npmjs.com/package/react-native-sqlite-2
+ * @link https://www.npmjs.com/package/websql
+ * Use like:
+ * import SQLite from 'react-native-sqlite-2';
+ * getRxStorageSQLite({
+ *   sqliteBasics: getSQLiteBasicsWebSQL(SQLite.openDatabase)
+ * });
+ *
+ */
+export function getSQLiteBasicsWebSQL(
+    openDB: any,
+): SQLiteBasics<any> {
+    return {
+        open: async (name: string) => {
+            const webSQLDatabase = await openDB(name, '1.0', '', 1);
+            return ensureNotFalsy(webSQLDatabase._db);
+        },
+        all: async (db: any, queryWithParams: SQLiteQueryWithParams) => {
+            const rawResult = await webSQLExecuteQuery(db, queryWithParams);
+            const rows = Array.from(rawResult.rows);
+            return rows as any;
+        },
+        run: async (db: any, queryWithParams: SQLiteQueryWithParams) => {
+            await webSQLExecuteQuery(db, queryWithParams);
+        },
+        setPragma: async (db, key, value) => {
+            await webSQLExecuteQuery(db, {
+                query: `pragma ${key} = ${value};`,
+                params: [],
+                context: {
+                    method: 'setPragma',
+                    data: {
+                        key,
+                        value
+                    }
+                }
+            }).catch(err => {
+                /**
+                 * WebSQL in the browser does not allow us to set any pragma
+                 * so we have to catch the error.
+                 * @link https://stackoverflow.com/a/10298712/3443137
+                 */
+                if (err.message.includes('23 not authorized')) {
+                    return;
+                }
+                throw err;
+            });
+        },
+        close: async (db: any) => {
+            /**
+             * The WebSQL API itself has no close() method.
+             * But some libraries have different custom close methods.
+             */
+            if (typeof db.closeAsync === 'function') {
+                return await db.closeAsync();
+            }
+            if (typeof db.close === 'function') {
+                return await db.close();
+            }
+        },
+        journalMode: '',
+    };
+};
+
+export function webSQLExecuteQuery(
+    db: any,
+    queryWithParams: SQLiteQueryWithParams
+): Promise<any> {
+    return new Promise<any>((resolve, reject) => {
+        db.exec(
+            [{ sql: queryWithParams.query, args: queryWithParams.params }],
+            false,
+            (err: any, res: any) => {
+                if (err) {
+                    return reject(err);
+                }
+                if (Array.isArray(res) && res[0] && res[0].error) {
+                    return reject(res[0].error);
+                } else {
+                    return resolve(res[0]);
+                };
+            }
+        );
+    });
+}
+
+
+
+/**
+ * Build to be compatible with packages
+ * that use SQLite compiled to webassembly:
+ * @link https://github.com/rhashimoto/wa-sqlite
+ * Use like:
+ * ```ts
+ * import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
+ * const sqliteWasm = await sqlite3InitModule();
+ * getSQLiteBasicsWasm({ dbConstructor: sqliteWasm.oo1.DB });
+ * ```
+ *
+ */
+
+
+/**
+ * The wa-sqlite module has problems
+ * when running prepared statements with params
+ * in parallel. So we de-parallel the runs here.
+ * This is bad for performance and should be fixed at the
+ * wa-sqlite repo.
+ */
+let runQueueWasmSQLite: Promise<any> = PROMISE_RESOLVE_VOID;
+export type WasmSqliteDb = { nr: number; name: string; };
+export function getSQLiteBasicsWasm(
+    sqlite3: any,
+): SQLiteBasics<WasmSqliteDb> {
+    const debugId = randomToken(5);
+    console.log('getSQLiteBasicsWasm() debugId: ' + debugId);
+    return {
+        debugId,
+        open: (name: string) => {
+            const newQueue = runQueueWasmSQLite.then(async () => {
+                const dbNr = await sqlite3.open_v2(name);
+                return { nr: dbNr, name };
+            });
+            runQueueWasmSQLite = newQueue.catch(() => { });
+            return newQueue as any;
+        },
+        all: (db, queryWithParams: SQLiteQueryWithParams) => {
+            const newQueue = runQueueWasmSQLite.then(async () => {
+                const result = await sqlite3.execWithParams(
+                    db.nr,
+                    queryWithParams.query,
+                    boolParamsToInt(queryWithParams.params)
+                );
+                return result.rows;
+            });
+            runQueueWasmSQLite = newQueue.catch(() => { });
+            return newQueue as any;
+        },
+        run: (db, queryWithParams: SQLiteQueryWithParams) => {
+            const newQueue = runQueueWasmSQLite.then(async () => {
+                await sqlite3.run(db.nr, queryWithParams.query, queryWithParams.params);
+                // return new Promise(async (res) => {
+                //     console.log('run start! ' + queryWithParams.query);
+                //     const runResult = await sqlite3.run(db.nr, queryWithParams, (a1: any, a2: any) => {
+                //         console.log('run result ccallback:');
+                //         console.log(JSON.stringify({ a1, a2 }));
+                //         res();
+                //     });
+                //     console.log('runResult:');
+                //     console.log(JSON.stringify(runResult));
+                // });
+            });
+            runQueueWasmSQLite = newQueue.catch(() => {});
+            return newQueue as any;
+        },
+        setPragma: (db, key, value) => {
+            const newQueue = runQueueWasmSQLite.then(async () => {
+                await sqlite3.exec(db.nr, `pragma ${key} = ${value};`);
+            });
+            runQueueWasmSQLite = newQueue.catch(() => {});
+            return newQueue as any;
+        },
+        close: (db) => {
+            const newQueue = runQueueWasmSQLite.then(async () => {
+                await sqlite3.close(db.nr);
+            });
+            runQueueWasmSQLite = newQueue.catch(() => {});
+            return newQueue as any;
+        },
+        journalMode: "WAL",
+    };
+}
+
+export function getSQLiteBasicsTauri(sqlite3: Sqlite3Type): SQLiteBasics<any> {
+    let basics: SQLiteBasics<any> = BASICS_BY_SQLITE_LIB.get(sqlite3);
+    if (!basics) {
+        basics = {
+            async open(name: string) {
+                return await sqlite3.load(`sqlite:${name}.db`);
+            },
+            async run(
+                db: SQLiteDatabaseClass,
+                queryWithParams: SQLiteQueryWithParams,
+            ) {
+                await db.execute(queryWithParams.query, queryWithParams.params);
+            },
+            async all(
+                db: SQLiteDatabaseClass,
+                queryWithParams: SQLiteQueryWithParams,
+            ) {
+                return await db.select(
+                    queryWithParams.query,
+                    queryWithParams.params,
+                );
+            },
+            async setPragma(
+                db: SQLiteDatabaseClass,
+                key: string,
+                value: string,
+            ) {
+                await db.execute(`PRAGMA ${key} = ${value};`);
+            },
+            async close(db: SQLiteDatabaseClass) {
+                await db.close();
+            },
+            journalMode: 'WAL2',
+        };
+        BASICS_BY_SQLITE_LIB.set(sqlite3, basics);
+    }
+    return basics;
+}