velocious 1.0.107 → 1.0.109

package/dist/src/database/drivers/sqlite/base.js

@@ -0,0 +1,253 @@
+// @ts-check
+import { digg } from "diggerize";
+import AlterTable from "./sql/alter-table.js";
+import Base from "../base.js";
+import CreateIndex from "./sql/create-index.js";
+import CreateTable from "./sql/create-table.js";
+import Delete from "./sql/delete.js";
+import DropTable from "./sql/drop-table.js";
+import escapeString from "sql-escape-string";
+import Insert from "./sql/insert.js";
+import Options from "./options.js";
+import QueryParser from "./query-parser.js";
+import Table from "./table.js";
+import Update from "./sql/update.js";
+export default class VelociousDatabaseDriversSqliteBase extends Base {
+    /**
+     * @param {import("../../table-data/index.js").default} tableData
+     * @returns {Promise<string[]>}
+     */
+    async alterTableSQLs(tableData) {
+        const alterArgs = { driver: this, tableData };
+        const alterTable = new AlterTable(alterArgs);
+        return await alterTable.toSQLs();
+    }
+    /**
+     * @param {import("../base.js").CreateIndexSqlArgs} indexData
+     * @returns {Promise<string[]>}
+     */
+    async createIndexSQLs(indexData) {
+        const createArgs = Object.assign({ driver: this }, indexData);
+        const createIndex = new CreateIndex(createArgs);
+        return await createIndex.toSQLs();
+    }
+    /**
+     * @abstract
+     * @param {import("../../table-data/index.js").default} tableData
+     * @returns {Promise<string[]>}
+     */
+    async createTableSql(tableData) {
+        const createArgs = { tableData, driver: this, indexInCreateTable: false };
+        const createTable = new CreateTable(createArgs);
+        return await createTable.toSql();
+    }
+    currentDatabase() {
+        return null;
+    }
+    async disableForeignKeys() {
+        await this.query("PRAGMA foreign_keys = 0");
+    }
+    async enableForeignKeys() {
+        await this.query("PRAGMA foreign_keys = 1");
+    }
+    /**
+     * @param {string} tableName
+     * @param {import("../base.js").DropTableSqlArgsType} [args]
+     * @returns {Promise<string[]>}
+     */
+    async dropTableSQLs(tableName, args = {}) {
+        const driver = /** @type {import("../base.js").default} */ (this);
+        const dropArgs = Object.assign({ tableName, driver }, args);
+        const dropTable = new DropTable(dropArgs);
+        return await dropTable.toSQLs();
+    }
+    /**
+     * @param {import("../base.js").DeleteSqlArgsType} args
+     * @returns {string}
+     */
+    deleteSql(args) { return new Delete(Object.assign({ driver: this }, args)).toSql(); }
+    /**
+     * @returns {string}
+     */
+    getType() { return "sqlite"; }
+    /**
+     * @param {import("../base.js").InsertSqlArgsType} args
+     * @returns {string}
+     */
+    insertSql(args) { return new Insert(Object.assign({ driver: this }, args)).toSql(); }
+    /**
+     * @param {string} name
+     * @param {object} [args]
+     * @param {boolean} args.throwError
+     * @returns {Promise<import("../base-table.js").default | undefined>}
+     */
+    async getTableByName(name, args) {
+        const result = await this.query(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${this.quote(name)} LIMIT 1`);
+        const row = result[0];
+        if (row) {
+            return new Table({ driver: this, row });
+        }
+        if (args?.throwError !== false) {
+            const tables = await this.getTables();
+            const tableNames = tables.map((table) => table.getName());
+            throw new Error(`No table by that name: ${name} in ${tableNames.join(", ")}`);
+        }
+    }
+    /** @returns {Promise<Array<import("../base-table.js").default>>} */
+    async getTables() {
+        const result = await this.query("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name");
+        const tables = [];
+        for (const row of result) {
+            const table = new Table({ driver: this, row });
+            tables.push(table);
+        }
+        return tables;
+    }
+    /**
+     * @param {string} tableName
+     * @param {Array<string>} columns
+     * @param {Array<Array<string>>} rows
+     * @returns {Promise<void>}
+     */
+    async insertMultiple(tableName, columns, rows) {
+        await this.registerVersion();
+        if (this.supportsMultipleInsertValues()) {
+            await this.insertMultipleWithSingleInsert(tableName, columns, rows);
+        }
+        else {
+            await this.insertMultipleWithTransaction(tableName, columns, rows);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    supportsMultipleInsertValues() {
+        if (this.versionMajor >= 4)
+            return true;
+        if (this.versionMajor == 3 && this.versionMinor >= 8)
+            return true;
+        if (this.versionMajor == 3 && this.versionMinor == 7 && this.versionPatch >= 11)
+            return true;
+        return false;
+    }
+    /**
+     * @returns {boolean}
+     */
+    supportsInsertIntoReturning() {
+        if (this.versionMajor >= 4)
+            return true;
+        if (this.versionMajor == 3 && this.versionMinor >= 35)
+            return true;
+        return false;
+    }
+    /**
+     * @param {string} tableName
+     * @param {Array<string>} columns
+     * @param {Array<Array<string>>} rows
+     * @returns {Promise<void>}
+     */
+    async insertMultipleWithSingleInsert(tableName, columns, rows) {
+        const sql = new Insert({ columns, driver: this, rows, tableName }).toSql();
+        await this.query(sql);
+    }
+    /**
+     * @param {string} tableName
+     * @param {Array<string>} columns
+     * @param {Array<Array<string>>} rows
+     * @returns {Promise<void>}
+     */
+    async insertMultipleWithTransaction(tableName, columns, rows) {
+        /** @type {string[]} */
+        const sqls = [];
+        for (const row of rows) {
+            /** @type {Record<string, any>} */
+            const data = [];
+            for (const columnIndex in columns) {
+                const columnName = columns[columnIndex];
+                const value = row[columnIndex];
+                data[columnName] = value;
+            }
+            const insertSql = this.insertSql({ tableName, data });
+            sqls.push(insertSql);
+        }
+        await this.transaction(async () => {
+            for (const sql of sqls) {
+                await this.query(sql);
+            }
+        });
+    }
+    async lastInsertID() {
+        const result = await this.query("SELECT LAST_INSERT_ROWID() AS last_insert_id");
+        return digg(result, 0, "last_insert_id");
+    }
+    options() {
+        if (!this._options)
+            this._options = new Options(this);
+        return this._options;
+    }
+    /**
+     * @returns {string} - The type of the primary key for this driver.
+     */
+    primaryKeyType() { return "integer"; } // Because bigint on SQLite doesn't support auto increment
+    /**
+     * @param {import("../../query/index.js").default} query
+     * @returns {string}
+     */
+    queryToSql(query) { return new QueryParser({ query }).toSql(); }
+    async registerVersion() {
+        if (this.versionMajor || this.versionMinor) {
+            return;
+        }
+        const versionResult = await this.query("SELECT sqlite_version() AS version");
+        this.version = versionResult[0].version;
+        const versionParts = this.version.split(".");
+        this.versionMajor = versionParts[0];
+        this.versionMinor = versionParts[1];
+        this.versionPatch = versionParts[2];
+    }
+    shouldSetAutoIncrementWhenPrimaryKey() { return false; }
+    /**
+     * @param {any} value
+     * @returns {any}
+     */
+    escape(value) {
+        value = this._convertValue(value);
+        const type = typeof value;
+        if (type != "string")
+            value = `${value}`;
+        const resultWithQuotes = escapeString(value, null);
+        const result = resultWithQuotes.substring(1, resultWithQuotes.length - 1);
+        return result;
+    }
+    /**
+     * @param {Error} error
+     * @returns {boolean}
+     */
+    retryableDatabaseError(error) {
+        if (error.message?.startsWith("attempt to write a readonly database"))
+            return true;
+        if (error.message?.startsWith("database is locked"))
+            return true;
+        if (error.message?.includes("→ Caused by: Error code : database is locked"))
+            return true;
+        return false;
+    }
+    /**
+     * @param {string} value
+     * @returns {string}
+     */
+    quote(value) {
+        value = this._convertValue(value);
+        const type = typeof value;
+        if (type == "number")
+            return value;
+        if (type != "string")
+            value = `${value}`;
+        return escapeString(value, null);
+    }
+    /**
+     * @param {import("../base.js").UpdateSqlArgsType} args
+     * @returns {string}
+     */
+    updateSql({ conditions, data, tableName }) { return new Update({ conditions, data, driver: this, tableName }).toSql(); }
+}

package/dist/src/database/drivers/sqlite/column.d.ts

@@ -0,0 +1,19 @@
+export default class VelociousDatabaseDriversSqliteColumn extends BaseColumn {
+    /**
+     * @param {object} args
+     * @param {Record<string, any>} args.column
+     * @param {import("../base.js").default} args.driver
+     * @param {import("../base-table.js").default} args.table
+     */
+    constructor({ column, driver, table }: {
+        column: Record<string, any>;
+        driver: import("../base.js").default;
+        table: import("../base-table.js").default;
+    });
+    column: Record<string, any>;
+    driver: import("../base.js").default;
+    getName(): any;
+    getType(): any;
+}
+import BaseColumn from "../base-column.js";
+//# sourceMappingURL=column.d.ts.map

package/dist/src/database/drivers/sqlite/column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/sqlite/column.js"],"names":[],"mappings":"AAKA;IACE;;;;;OAKG;IACH,uCAJG;QAAkC,MAAM,EAAhC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACgB,MAAM,EAAzC,OAAO,YAAY,EAAE,OAAO;QACa,KAAK,EAA9C,OAAO,kBAAkB,EAAE,OAAO;KAC5C,EAMA;IAHC,4BAAoB;IACpB,qCAAoB;IAetB,eAMC;IAuBD,eASC;CACF;uBAlEsB,mBAAmB"}

package/dist/src/database/drivers/sqlite/column.js

@@ -0,0 +1,55 @@
+// @ts-check
+import { digg } from "diggerize";
+import BaseColumn from "../base-column.js";
+export default class VelociousDatabaseDriversSqliteColumn extends BaseColumn {
+    /**
+     * @param {object} args
+     * @param {Record<string, any>} args.column
+     * @param {import("../base.js").default} args.driver
+     * @param {import("../base-table.js").default} args.table
+     */
+    constructor({ column, driver, table }) {
+        super();
+        this.column = column;
+        this.driver = driver;
+        this.table = table;
+    }
+    getAutoIncrement() { return this.getPrimaryKey(); }
+    async getIndexes() {
+        const indexes = await this.getTable().getIndexes();
+        const indexesForColumn = indexes.filter((index) => index.getColumnNames().includes(this.getName()));
+        return indexesForColumn;
+    }
+    getDefault() { return digg(this, "column", "dflt_value"); }
+    getName() {
+        const name = digg(this, "column", "name");
+        if (!name)
+            throw new Error("No name given for SQLite column");
+        return name;
+    }
+    getMaxLength() {
+        const columnType = digg(this, "column", "type");
+        const match = columnType.match(/(.*)\((\d+)\)$/);
+        if (match) {
+            return parseInt(match[2]);
+        }
+    }
+    getNull() {
+        const notNullValue = digg(this, "column", "notnull");
+        if (notNullValue === 1) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    getPrimaryKey() { return digg(this, "column", "pk") == 1; }
+    getType() {
+        const columnType = digg(this, "column", "type");
+        const match = columnType.match(/(.*)\((\d+)\)$/);
+        if (match) {
+            return match[1].toLowerCase();
+        }
+        return columnType.toLowerCase();
+    }
+}

package/dist/src/database/drivers/sqlite/columns-index.d.ts

@@ -0,0 +1,6 @@
+export default class VelociousDatabaseDriversSqliteColumnsIndex extends BaseColumnsIndex {
+    getColumnNames(): any;
+    getName(): any;
+}
+import BaseColumnsIndex from "../base-columns-index.js";
+//# sourceMappingURL=columns-index.d.ts.map

package/dist/src/database/drivers/sqlite/columns-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columns-index.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/sqlite/columns-index.js"],"names":[],"mappings":"AAMA;IACE,sBAEC;IAED,eAEC;CAgBF;6BA3B4B,0BAA0B"}

package/dist/src/database/drivers/sqlite/columns-index.js

@@ -0,0 +1,24 @@
+// @ts-check
+import BaseColumnsIndex from "../base-columns-index.js";
+import { digg } from "diggerize";
+import TableIndex from "../../table-data/table-index.js";
+export default class VelociousDatabaseDriversSqliteColumnsIndex extends BaseColumnsIndex {
+    getColumnNames() {
+        return digg(this, "data", "columnNames");
+    }
+    getName() {
+        return digg(this, "data", "name");
+    }
+    getTableDataIndex() {
+        return new TableIndex(this.getColumnNames(), {
+            name: this.getName(),
+            unique: this.isUnique()
+        });
+    }
+    isPrimaryKey() {
+        return false;
+    }
+    isUnique() {
+        return digg(this, "data", "unique") == 1;
+    }
+}

package/dist/src/database/drivers/sqlite/connection-remote.d.ts

@@ -0,0 +1,9 @@
+export default class VelociousDatabaseDriversSqliteConnectionRemote {
+    /**
+     * @abstract
+     * @param {string} sql
+     * @returns {Promise<any[]>}
+     */
+    query(sql: string): Promise<any[]>;
+}
+//# sourceMappingURL=connection-remote.d.ts.map

package/dist/src/database/drivers/sqlite/connection-remote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-remote.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/sqlite/connection-remote.js"],"names":[],"mappings":"AAEA;IACE;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAAC,GAAG,EAAE,CAAC,CAI1B;CACF"}

package/dist/src/database/drivers/sqlite/connection-remote.js

@@ -0,0 +1,11 @@
+// @ts-check
+export default class VelociousDatabaseDriversSqliteConnectionRemote {
+    /**
+     * @abstract
+     * @param {string} sql
+     * @returns {Promise<any[]>}
+     */
+    async query(sql) {
+        throw new Error("stub");
+    }
+}

package/dist/src/database/drivers/sqlite/connection-sql-js.d.ts

@@ -0,0 +1,19 @@
+export default class VelociousDatabaseDriversSqliteConnectionSqlJs {
+    /**
+     * @param {import("../base.js").default} driver
+     * @param {import("sql.js").Database} connection
+     */
+    constructor(driver: import("../base.js").default, connection: any);
+    connection: any;
+    driver: import("../base.js").default;
+    close(): Promise<void>;
+    disconnect(): Promise<void>;
+    /**
+     * @param {string} sql
+     * @returns {Promise<Record<string, any>[]>}
+     */
+    query(sql: string): Promise<Record<string, any>[]>;
+    saveDatabase: () => Promise<void>;
+    saveDatabaseDebounce: import("debounce").DebouncedFunction<() => Promise<void>>;
+}
+//# sourceMappingURL=connection-sql-js.d.ts.map

package/dist/src/database/drivers/sqlite/connection-sql-js.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-sql-js.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/sqlite/connection-sql-js.js"],"names":[],"mappings":"AAOA;IACE;;;OAGG;IACH,oBAHW,OAAO,YAAY,EAAE,OAAO,mBAMtC;IAFC,gBAA4B;IAC5B,qCAAoB;IAGtB,uBAGC;IAED,4BAAgD;IAEhD;;;OAGG;IACH,WAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,CAY1C;IAED,kCAKC;IAED,gFAAuD;CACxD"}

package/dist/src/database/drivers/sqlite/connection-sql-js.js

@@ -0,0 +1,38 @@
+// @ts-check
+import debounce from "debounce";
+// @ts-expect-error
+import query from "./query";
+export default class VelociousDatabaseDriversSqliteConnectionSqlJs {
+    /**
+     * @param {import("../base.js").default} driver
+     * @param {import("sql.js").Database} connection
+     */
+    constructor(driver, connection) {
+        this.connection = connection;
+        this.driver = driver;
+    }
+    async close() {
+        await this.saveDatabase();
+        await this.connection.close();
+    }
+    async disconnect() { await this.saveDatabase(); }
+    /**
+     * @param {string} sql
+     * @returns {Promise<Record<string, any>[]>}
+     */
+    async query(sql) {
+        const result = await query(this.connection, sql);
+        const downcasedSQL = sql.toLowerCase().trim();
+        // Auto-save database in local storage in case we can find manipulating instructions in the SQL
+        if (downcasedSQL.startsWith("delete ") || downcasedSQL.startsWith("insert into ") || downcasedSQL.startsWith("update ")) {
+            this.saveDatabaseDebounce();
+        }
+        return result;
+    }
+    saveDatabase = async () => {
+        const localStorageContent = this.connection.export();
+        // @ts-expect-error
+        await this.driver.betterLocalStorage.set(this.driver.localStorageName(), localStorageContent);
+    };
+    saveDatabaseDebounce = debounce(this.saveDatabase, 500);
+}

package/dist/src/database/drivers/sqlite/foreign-key.d.ts

@@ -0,0 +1,17 @@
+export default class VelociousDatabaseDriversSqliteForeignKey extends BaseForeignKey {
+    /**
+     * @param {Record<string, any>} data
+     * @param {object} args
+     * @param {string} args.tableName
+     */
+    constructor(data: Record<string, any>, { tableName }: {
+        tableName: string;
+    });
+    tableName: string;
+    getColumnName(): any;
+    getTableName(): any;
+    getReferencedColumnName(): any;
+    getReferencedTableName(): any;
+}
+import BaseForeignKey from "../base-foreign-key.js";
+//# sourceMappingURL=foreign-key.d.ts.map

package/dist/src/database/drivers/sqlite/foreign-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foreign-key.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/sqlite/foreign-key.js"],"names":[],"mappings":"AAKA;IACE;;;;OAIG;IACH,kBAJW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,iBAE3B;QAAqB,SAAS,EAAtB,MAAM;KAChB,EAIA;IADC,kBAA0B;IAG5B,qBAAqD;IAErD,oBAAiD;IACjD,+BAA6D;IAC7D,8BAA+D;CAChE;2BAnB0B,wBAAwB"}

package/dist/src/database/drivers/sqlite/foreign-key.js

@@ -0,0 +1,19 @@
+// @ts-check
+import BaseForeignKey from "../base-foreign-key.js";
+import { digg } from "diggerize";
+export default class VelociousDatabaseDriversSqliteForeignKey extends BaseForeignKey {
+    /**
+     * @param {Record<string, any>} data
+     * @param {object} args
+     * @param {string} args.tableName
+     */
+    constructor(data, { tableName }) {
+        super(data);
+        this.tableName = tableName;
+    }
+    getColumnName() { return digg(this, "data", "from"); }
+    getName() { return `${this.getTableName()}_${this.getColumnName()}_${this.data.id}`; }
+    getTableName() { return digg(this, "tableName"); }
+    getReferencedColumnName() { return digg(this, "data", "to"); }
+    getReferencedTableName() { return digg(this, "data", "table"); }
+}

package/dist/src/database/drivers/sqlite/index.d.ts

@@ -0,0 +1,8 @@
+export default class VelociousDatabaseDriversSqliteNode extends Base {
+    /** @type {import("sqlite3").Database | undefined} */
+    connection: import("sqlite3").Database | undefined;
+    localStorageName(): string;
+    close(): Promise<void>;
+}
+import Base from "./base.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/database/drivers/sqlite/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/sqlite/index.js"],"names":[],"mappings":"AASA;IACE,qDAAqD;IACrD,YADW,OAAO,SAAS,EAAE,QAAQ,GAAG,SAAS,CAC3B;IAkBtB,2BAMC;IAED,uBAGC;CAWF;iBA5CgB,WAAW"}

package/dist/src/database/drivers/sqlite/index.js

@@ -0,0 +1,42 @@
+// @ts-check
+import fs from "fs/promises";
+import query from "./query.js";
+import sqlite3 from "sqlite3";
+import { open } from "sqlite";
+import Base from "./base.js";
+export default class VelociousDatabaseDriversSqliteNode extends Base {
+    /** @type {import("sqlite3").Database | undefined} */
+    connection = undefined;
+    async connect() {
+        const args = this.getArgs();
+        const databasePath = `${this.getConfiguration().getDirectory()}/db/${this.localStorageName()}.sqlite`;
+        if (args.reset) {
+            await fs.unlink(databasePath);
+        }
+        // @ts-expect-error
+        this.connection = /** @type {import("sqlite3").Database} */ (await open({
+            filename: databasePath,
+            driver: sqlite3.Database
+        }));
+        await this.registerVersion();
+    }
+    localStorageName() {
+        const args = this.getArgs();
+        if (!args.name)
+            throw new Error("No name given for SQLite Node");
+        return `VelociousDatabaseDriversSqlite---${args.name}`;
+    }
+    async close() {
+        await this.connection?.close();
+        this.connection = undefined;
+    }
+    /**
+     * @param {string} sql
+     * @returns {Promise<Record<string, any>[]>}
+     */
+    async _queryActual(sql) {
+        if (!this.connection)
+            throw new Error("No connection");
+        return await query(this.connection, sql);
+    }
+}

package/dist/src/database/drivers/sqlite/index.native.d.ts

@@ -0,0 +1,9 @@
+export default class VelociousDatabaseDriversSqliteNative extends Base {
+    connection: any;
+    disconnect(): Promise<void>;
+    connectArgs(): any[];
+    close(): Promise<void>;
+    _queryActual(sql: any): Promise<any>;
+}
+import Base from "./base.js";
+//# sourceMappingURL=index.native.d.ts.map

package/dist/src/database/drivers/sqlite/index.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.native.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/sqlite/index.native.js"],"names":[],"mappings":"AAWA;IAwBI,gBAA8D;IAIhE,4BAEC;IAED,qBAYC;IAED,uBAGC;IAED,qCAIC;CACF;iBA1DgB,WAAW"}

package/dist/src/database/drivers/sqlite/index.native.js

@@ -0,0 +1,57 @@
+import { digg } from "diggerize";
+import envSense from "env-sense/src/use-env-sense.js";
+// @ts-expect-error
+import query from "./query";
+// @ts-expect-error
+import * as SQLite from "expo-sqlite";
+import Base from "./base.js";
+export default class VelociousDatabaseDriversSqliteNative extends Base {
+    async connect() {
+        const { isBrowser, isNative, isServer } = envSense();
+        if (!isNative)
+            throw new Error(`SQLite native driver running inside non-native environment: ${JSON.stringify({ isBrowser, isNative, isServer })}`);
+        const args = this.getArgs();
+        if (!args.name)
+            throw new Error("No name given for SQLite Native");
+        const databaseName = args.name;
+        if (args.reset) {
+            try {
+                await SQLite.deleteDatabaseAsync(databaseName);
+            }
+            catch (error) {
+                if (error.message.match(/Database '(.+)' not found/)) {
+                    // Ignore not found
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        this.connection = await SQLite.openDatabaseAsync(databaseName);
+        await this.registerVersion();
+    }
+    async disconnect() {
+        await this.connection.closeAsync();
+    }
+    connectArgs() {
+        const args = this.getArgs();
+        const connectArgs = [];
+        const forward = ["database", "host", "password"];
+        for (const forwardValue of forward) {
+            if (forwardValue in args)
+                connectArgs[forwardValue] = digg(args, forwardValue);
+        }
+        if ("username" in args)
+            connectArgs["user"] = args["username"];
+        return connectArgs;
+    }
+    async close() {
+        await this.connection.end();
+        this.connection = undefined;
+    }
+    async _queryActual(sql) {
+        if (!this.connection)
+            throw new Error("Not connected yet");
+        return await query(this.connection, sql);
+    }
+}

package/dist/src/database/drivers/sqlite/index.web.d.ts

@@ -0,0 +1,14 @@
+export default class VelociousDatabaseDriversSqliteWeb extends Base {
+    /** @type {BetterLocalStorage | undefined} */
+    betterLocalStorage: BetterLocalStorage | undefined;
+    args: import("../../../configuration-types.js").DatabaseConfigurationType;
+    _connection: ConnectionSqlJs;
+    close(): Promise<void>;
+    /** @returns {ConnectionSqlJs | any} */
+    getConnection(): ConnectionSqlJs | any;
+    localStorageName(): string;
+}
+import Base from "./base.js";
+import BetterLocalStorage from "better-localstorage";
+import ConnectionSqlJs from "./connection-sql-js.js";
+//# sourceMappingURL=index.web.d.ts.map

package/dist/src/database/drivers/sqlite/index.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.web.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/sqlite/index.web.js"],"names":[],"mappings":"AAQA;IACE,6CAA6C;IAC7C,oBADW,kBAAkB,GAAG,SAAS,CACX;IAG5B,0EAA0B;IAiBxB,6BAAkC;IAItC,uBAEC;IAED,uCAAuC;IACvC,iBADc,eAAe,GAAG,GAAG,CAOlC;IAED,2BAMC;CASF;iBAxDgB,WAAW;+BAJG,qBAAqB;4BACxB,wBAAwB"}