velocious 1.0.430 → 1.0.431

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

@@ -1,424 +1,498 @@
 // @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 StructureSql from "./structure-sql.js";
-import Upsert from "./sql/upsert.js";
-import Update from "./sql/update.js";
+
+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 StructureSql from "./structure-sql.js"
+import Upsert from "./sql/upsert.js"
+import Update from "./sql/update.js"
+
 export default class VelociousDatabaseDriversSqliteBase extends Base {
+  /**
+   * Version major.
+    @type {number | undefined} */
+  versionMajor = undefined
+  /**
+   * Version minor.
+    @type {number | undefined} */
+  versionMinor = undefined
+  /**
+   * Version patch.
+    @type {number | undefined} */
+  versionPatch = undefined
+
+  /**
+   * Runs alter table sqls.
+   * @param {import("../../table-data/index.js").default} tableData - Table data.
+   * @returns {Promise<string[]>} - Resolves with SQL statements.
+   */
+  async alterTableSQLs(tableData) {
+    const alterArgs = {driver: this, tableData}
+    const alterTable = new AlterTable(alterArgs)
+
+    return await alterTable.toSQLs()
+  }
+
+  /**
+   * Runs create index sqls.
+   * @param {import("../base.js").CreateIndexSqlArgs} indexData - Index data.
+   * @returns {Promise<string[]>} - Resolves with SQL statements.
+   */
+  async createIndexSQLs(indexData) {
+    const createArgs = Object.assign({driver: this}, indexData)
+    const createIndex = new CreateIndex(createArgs)
+
+    return await createIndex.toSQLs()
+  }
+
+  /**
+   * Runs create table sql.
+   * @abstract
+   * @param {import("../../table-data/index.js").default} tableData - Table data.
+   * @returns {Promise<string[]>} - Resolves with SQL statements.
+   */
+  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")
+  }
+
+  /**
+   * Runs drop table sqls.
+   * @param {string} tableName - Table name.
+   * @param {import("../base.js").DropTableSqlArgsType} [args] - Options object.
+   * @returns {Promise<string[]>} - Resolves with SQL statements.
+   */
+  async dropTableSQLs(tableName, args = {}) {
+    const driver = /**
+                    * Narrows the runtime value to the documented type.
+                     @type {import("../base.js").default} */ (this)
+    const dropArgs = Object.assign({tableName, driver}, args)
+    const dropTable = new DropTable(dropArgs)
+
+    return await dropTable.toSQLs()
+  }
+
+  /**
+   * Runs delete sql.
+   * @param {import("../base.js").DeleteSqlArgsType} args - Options object.
+   * @returns {string} - SQL string.
+   */
+  deleteSql(args) { return new Delete(Object.assign({driver: this}, args)).toSql() }
+
+  /**
+   * Runs get type.
+   * @returns {string} - The type.
+   */
+  getType() { return "sqlite" }
+
+  /**
+   * Runs insert sql.
+   * @param {import("../base.js").InsertSqlArgsType} args - Options object.
+   * @returns {string} - SQL string.
+   */
+  insertSql(args) { return new Insert(Object.assign({driver: this}, args)).toSql() }
+
+  /**
+   * Runs get tables.
+   * @returns {Promise<Array<import("../base-table.js").default>>} - Resolves with the tables.
+   */
+  async getTables() {
+    return await this._cachedSchemaMetadata("tables", async () => {
+      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: /**
+                                                     * Narrows the runtime value to the documented type.
+                                                      @type {Record<string, string | number | null>} */ (row)})
+
+        tables.push(table)
+      }
+
+      return tables
+    })
+  }
+
+  /**
+   * Runs insert multiple.
+   * @param {string} tableName - Table name.
+   * @param {Array<string>} columns - Column names.
+   * @param {Array<Array<?>>} rows - Rows to insert.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async insertMultiple(tableName, columns, rows) {
+    this._assertNotReadOnly()
+    await this.registerVersion()
+
+    if (this.supportsMultipleInsertValues()) {
+      await this.insertMultipleWithSingleInsert(tableName, columns, rows)
+    } else {
+      await this.insertMultipleWithTransaction(tableName, columns, rows)
+    }
+  }
+
+  /**
+   * Runs supports multiple insert values.
+   * @returns {boolean} - Whether supports multiple insert values.
+   */
+  supportsMultipleInsertValues() {
     /**
      * Version major.
-      @type {number | undefined} */
-    versionMajor = undefined;
+      @type {number} */
+    const versionMajor = this.versionMajor || 0
     /**
      * Version minor.
-      @type {number | undefined} */
-    versionMinor = undefined;
+      @type {number} */
+    const versionMinor = this.versionMinor || 0
     /**
      * Version patch.
-      @type {number | undefined} */
-    versionPatch = undefined;
-    /**
-     * Runs alter table sqls.
-     * @param {import("../../table-data/index.js").default} tableData - Table data.
-     * @returns {Promise<string[]>} - Resolves with SQL statements.
-     */
-    async alterTableSQLs(tableData) {
-        const alterArgs = { driver: this, tableData };
-        const alterTable = new AlterTable(alterArgs);
-        return await alterTable.toSQLs();
-    }
-    /**
-     * Runs create index sqls.
-     * @param {import("../base.js").CreateIndexSqlArgs} indexData - Index data.
-     * @returns {Promise<string[]>} - Resolves with SQL statements.
-     */
-    async createIndexSQLs(indexData) {
-        const createArgs = Object.assign({ driver: this }, indexData);
-        const createIndex = new CreateIndex(createArgs);
-        return await createIndex.toSQLs();
-    }
-    /**
-     * Runs create table sql.
-     * @abstract
-     * @param {import("../../table-data/index.js").default} tableData - Table data.
-     * @returns {Promise<string[]>} - Resolves with SQL statements.
-     */
-    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");
-    }
-    /**
-     * Runs drop table sqls.
-     * @param {string} tableName - Table name.
-     * @param {import("../base.js").DropTableSqlArgsType} [args] - Options object.
-     * @returns {Promise<string[]>} - Resolves with SQL statements.
-     */
-    async dropTableSQLs(tableName, args = {}) {
-        const driver = /**
-                        * Narrows the runtime value to the documented type.
-                         @type {import("../base.js").default} */ (this);
-        const dropArgs = Object.assign({ tableName, driver }, args);
-        const dropTable = new DropTable(dropArgs);
-        return await dropTable.toSQLs();
-    }
-    /**
-     * Runs delete sql.
-     * @param {import("../base.js").DeleteSqlArgsType} args - Options object.
-     * @returns {string} - SQL string.
-     */
-    deleteSql(args) { return new Delete(Object.assign({ driver: this }, args)).toSql(); }
-    /**
-     * Runs get type.
-     * @returns {string} - The type.
-     */
-    getType() { return "sqlite"; }
+      @type {number} */
+    const versionPatch = this.versionPatch || 0
+
+    if (versionMajor >= 4) return true
+    if (versionMajor == 3 && versionMinor >= 8) return true
+    if (versionMajor == 3 && versionMinor == 7 && versionPatch >= 11) return true
+
+    return false
+  }
+
+  /**
+   * Runs supports insert into returning.
+   * @returns {boolean} - Whether supports insert into returning.
+   */
+  supportsInsertIntoReturning() {
     /**
-     * Runs insert sql.
-     * @param {import("../base.js").InsertSqlArgsType} args - Options object.
-     * @returns {string} - SQL string.
-     */
-    insertSql(args) { return new Insert(Object.assign({ driver: this }, args)).toSql(); }
+     * Version major.
+      @type {number} */
+    const versionMajor = this.versionMajor || 0
     /**
-     * Runs get tables.
-     * @returns {Promise<Array<import("../base-table.js").default>>} - Resolves with the tables.
-     */
-    async getTables() {
-        return await this._cachedSchemaMetadata("tables", async () => {
-            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: /**
-                                                                 * Narrows the runtime value to the documented type.
-                                                                  @type {Record<string, string | number | null>} */ (row) });
-                tables.push(table);
-            }
-            return tables;
-        });
-    }
+     * Version minor.
+      @type {number} */
+    const versionMinor = this.versionMinor || 0
+
+    if (versionMajor >= 4) return true
+    if (versionMajor == 3 && versionMinor >= 35) return true
+
+    return false
+  }
+
+  /**
+   * Runs insert multiple with single insert.
+   * @param {string} tableName - Table name.
+   * @param {Array<string>} columns - Column names.
+   * @param {Array<Array<?>>} rows - Rows to insert.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async insertMultipleWithSingleInsert(tableName, columns, rows) {
+    this._assertNotReadOnly()
+    const sql = new Insert({columns, driver: this, rows, tableName}).toSql()
+
+    await this.query(sql)
+  }
+
+  /**
+   * Runs insert multiple with transaction.
+   * @param {string} tableName - Table name.
+   * @param {Array<string>} columns - Column names.
+   * @param {Array<Array<?>>} rows - Rows to insert.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async insertMultipleWithTransaction(tableName, columns, rows) {
+    this._assertNotReadOnly()
     /**
-     * Runs insert multiple.
-     * @param {string} tableName - Table name.
-     * @param {Array<string>} columns - Column names.
-     * @param {Array<Array<?>>} rows - Rows to insert.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async insertMultiple(tableName, columns, rows) {
-        this._assertNotReadOnly();
-        await this.registerVersion();
-        if (this.supportsMultipleInsertValues()) {
-            await this.insertMultipleWithSingleInsert(tableName, columns, rows);
-        }
-        else {
-            await this.insertMultipleWithTransaction(tableName, columns, rows);
-        }
+     * Sqls.
+      @type {string[]} */
+    const sqls = []
+
+    for (const row of rows) {
+      /**
+       * Data.
+        @type {Record<string, ?>} */
+      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)
     }
-    /**
-     * Runs supports multiple insert values.
-     * @returns {boolean} - Whether supports multiple insert values.
-     */
-    supportsMultipleInsertValues() {
-        /**
-         * Version major.
-          @type {number} */
-        const versionMajor = this.versionMajor || 0;
-        /**
-         * Version minor.
-          @type {number} */
-        const versionMinor = this.versionMinor || 0;
-        /**
-         * Version patch.
-          @type {number} */
-        const versionPatch = this.versionPatch || 0;
-        if (versionMajor >= 4)
-            return true;
-        if (versionMajor == 3 && versionMinor >= 8)
-            return true;
-        if (versionMajor == 3 && versionMinor == 7 && versionPatch >= 11)
-            return true;
-        return false;
+
+    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
+  }
+
+  /**
+   * Runs primary key type.
+   * @returns {string} - The type of the primary key for this driver.
+   */
+  primaryKeyType() { return "integer" } // Because bigint on SQLite doesn't support auto increment
+
+  /**
+   * Runs query to sql.
+   * @param {import("../../query/index.js").default} query - Query instance.
+   * @returns {string} - SQL string.
+   */
+  queryToSql(query) { return new QueryParser({query}).toSql() }
+
+  async registerVersion() {
+    if (this.versionMajor || this.versionMinor) {
+      return
     }
-    /**
-     * Runs supports insert into returning.
-     * @returns {boolean} - Whether supports insert into returning.
-     */
-    supportsInsertIntoReturning() {
+
+    const versionResult = await this.query("SELECT sqlite_version() AS version")
+
+    this.version = String(versionResult[0].version)
+
+    const versionParts = this.version.split(".")
+
+    this.versionMajor = Number(versionParts[0])
+    this.versionMinor = Number(versionParts[1])
+    this.versionPatch = Number(versionParts[2])
+  }
+
+  shouldSetAutoIncrementWhenPrimaryKey() { return false }
+  supportsDefaultPrimaryKeyUUID() { return false }
+
+  /**
+   * Runs escape.
+   * @param {?} value - Value to use.
+   * @returns {?} - The escape.
+   */
+  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
+  }
+
+  /**
+   * Runs retryable database error.
+   * @param {Error} error - Error instance.
+   * @returns {import("../base.js").RetryableDatabaseErrorResult} - Retry info.
+   */
+  retryableDatabaseError(error) {
+    const shouldRetry = (
+      error.message?.startsWith("attempt to write a readonly database") ||
+      error.message?.startsWith("database is locked") ||
+      error.message?.includes("→ Caused by: Error code : database is locked")
+    )
+
+    return {retry: shouldRetry, reconnect: false}
+  }
+
+  /**
+   * Runs quote.
+   * @param {?} value - Value to use.
+   * @returns {string | number} - The quoted value.
+   */
+  quote(value) {
+    value = this._convertValue(value)
+
+    const type = typeof value
+
+    if (type == "number") return /** Narrows the runtime value to the documented type. @type {number} */ (value)
+    if (type != "string") value = String(value)
+
+    return escapeString(value, null)
+  }
+
+  /**
+   * Runs update sql.
+   * @param {import("../base.js").UpdateSqlArgsType} args - Options object.
+   * @returns {string} - SQL string.
+   */
+  updateSql({conditions, data, tableName}) { return new Update({conditions, data, driver: this, tableName}).toSql() }
+
+  /**
+   * Runs upsert sql.
+   * @param {import("../base.js").UpsertSqlArgsType} args - Options object.
+   * @returns {string} - SQL string.
+   */
+  upsertSql(args) { return new Upsert({...args, driver: this}).toSql() }
+
+  /**
+   * Runs structure sql.
+   * @returns {Promise<string | null>} - Resolves with SQL string.
+   */
+  async structureSql() {
+    return await this._cachedSchemaMetadata("structureSql", async () => await new StructureSql({driver: this}).toSql())
+  }
+
+  /**
+   * Blocks until an in-process advisory lock with the given name is
+   * acquired. SQLite has no built-in advisory lock primitive, so this is
+   * implemented as a process-local waiter queue. Typical SQLite deployments
+   * run inside a single Node process, which is exactly the scope this
+   * emulation covers; multi-process SQLite setups should not rely on this
+   * for cross-process mutual exclusion.
+   *
+   * The owning driver instance is recorded so that `releaseAdvisoryLock`
+   * can refuse to release a lock that was acquired by someone else.
+   * @param {string} name - Lock name.
+   * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null`, `undefined`, or negative blocks forever.
+   * @returns {Promise<boolean>} - True if the lock was acquired, false if the timeout elapsed.
+   */
+  async acquireAdvisoryLock(name, {timeoutMs} = {}) {
+    const state = VelociousDatabaseDriversSqliteBase._advisoryLockState
+
+    while (state.ownersByName.has(name)) {
+      let remainingMs = null
+
+      if (typeof timeoutMs === "number" && timeoutMs >= 0) {
+        remainingMs = timeoutMs
+
+        if (remainingMs <= 0) return false
+      }
+
+      await new Promise((resolve) => {
+        const waiters = state.waitersByName.get(name) || []
         /**
-         * Version major.
-          @type {number} */
-        const versionMajor = this.versionMajor || 0;
-        /**
-         * Version minor.
-          @type {number} */
-        const versionMinor = this.versionMinor || 0;
-        if (versionMajor >= 4)
-            return true;
-        if (versionMajor == 3 && versionMinor >= 35)
-            return true;
-        return false;
-    }
-    /**
-     * Runs insert multiple with single insert.
-     * @param {string} tableName - Table name.
-     * @param {Array<string>} columns - Column names.
-     * @param {Array<Array<?>>} rows - Rows to insert.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async insertMultipleWithSingleInsert(tableName, columns, rows) {
-        this._assertNotReadOnly();
-        const sql = new Insert({ columns, driver: this, rows, tableName }).toSql();
-        await this.query(sql);
-    }
-    /**
-     * Runs insert multiple with transaction.
-     * @param {string} tableName - Table name.
-     * @param {Array<string>} columns - Column names.
-     * @param {Array<Array<?>>} rows - Rows to insert.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async insertMultipleWithTransaction(tableName, columns, rows) {
-        this._assertNotReadOnly();
+         * Timeout handle.
+          @type {NodeJS.Timeout | null} */
+        let timeoutHandle = null
         /**
-         * Sqls.
-          @type {string[]} */
-        const sqls = [];
-        for (const row of rows) {
-            /**
-             * Data.
-              @type {Record<string, ?>} */
-            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);
+         * Remove and resolve.
+          @type {(() => void) | null} */
+        let removeAndResolve = null
+
+        removeAndResolve = () => {
+          if (timeoutHandle) clearTimeout(timeoutHandle)
+
+          const current = state.waitersByName.get(name) || []
+          const index = current.indexOf(/**
+                                         * Narrows the runtime value to the documented type.
+                                          @type {() => void} */ (removeAndResolve))
+
+          if (index >= 0) current.splice(index, 1)
+          if (current.length === 0) state.waitersByName.delete(name)
+
+          resolve(undefined)
         }
-        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;
-    }
-    /**
-     * Runs primary key type.
-     * @returns {string} - The type of the primary key for this driver.
-     */
-    primaryKeyType() { return "integer"; } // Because bigint on SQLite doesn't support auto increment
-    /**
-     * Runs query to sql.
-     * @param {import("../../query/index.js").default} query - Query instance.
-     * @returns {string} - SQL string.
-     */
-    queryToSql(query) { return new QueryParser({ query }).toSql(); }
-    async registerVersion() {
-        if (this.versionMajor || this.versionMinor) {
-            return;
+
+        waiters.push(removeAndResolve)
+        state.waitersByName.set(name, waiters)
+
+        if (remainingMs !== null) {
+          timeoutHandle = setTimeout(() => {
+            if (removeAndResolve) removeAndResolve()
+          }, remainingMs)
         }
-        const versionResult = await this.query("SELECT sqlite_version() AS version");
-        this.version = String(versionResult[0].version);
-        const versionParts = this.version.split(".");
-        this.versionMajor = Number(versionParts[0]);
-        this.versionMinor = Number(versionParts[1]);
-        this.versionPatch = Number(versionParts[2]);
+      })
+
+      if (typeof timeoutMs === "number" && timeoutMs >= 0 && state.ownersByName.has(name)) {
+        return false
+      }
     }
-    shouldSetAutoIncrementWhenPrimaryKey() { return false; }
-    supportsDefaultPrimaryKeyUUID() { return false; }
-    /**
-     * Runs escape.
-     * @param {?} value - Value to use.
-     * @returns {?} - The escape.
-     */
-    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;
-    }
-    /**
-     * Runs retryable database error.
-     * @param {Error} error - Error instance.
-     * @returns {import("../base.js").RetryableDatabaseErrorResult} - Retry info.
-     */
-    retryableDatabaseError(error) {
-        const shouldRetry = (error.message?.startsWith("attempt to write a readonly database") ||
-            error.message?.startsWith("database is locked") ||
-            error.message?.includes("→ Caused by: Error code : database is locked"));
-        return { retry: shouldRetry, reconnect: false };
-    }
-    /**
-     * Runs quote.
-     * @param {?} value - Value to use.
-     * @returns {string | number} - The quoted value.
-     */
-    quote(value) {
-        value = this._convertValue(value);
-        const type = typeof value;
-        if (type == "number")
-            return /** Narrows the runtime value to the documented type. @type {number} */ (value);
-        if (type != "string")
-            value = String(value);
-        return escapeString(value, null);
-    }
-    /**
-     * Runs update sql.
-     * @param {import("../base.js").UpdateSqlArgsType} args - Options object.
-     * @returns {string} - SQL string.
-     */
-    updateSql({ conditions, data, tableName }) { return new Update({ conditions, data, driver: this, tableName }).toSql(); }
-    /**
-     * Runs upsert sql.
-     * @param {import("../base.js").UpsertSqlArgsType} args - Options object.
-     * @returns {string} - SQL string.
-     */
-    upsertSql(args) { return new Upsert({ ...args, driver: this }).toSql(); }
-    /**
-     * Runs structure sql.
-     * @returns {Promise<string | null>} - Resolves with SQL string.
-     */
-    async structureSql() {
-        return await this._cachedSchemaMetadata("structureSql", async () => await new StructureSql({ driver: this }).toSql());
-    }
-    /**
-     * Blocks until an in-process advisory lock with the given name is
-     * acquired. SQLite has no built-in advisory lock primitive, so this is
-     * implemented as a process-local waiter queue. Typical SQLite deployments
-     * run inside a single Node process, which is exactly the scope this
-     * emulation covers; multi-process SQLite setups should not rely on this
-     * for cross-process mutual exclusion.
-     *
-     * The owning driver instance is recorded so that `releaseAdvisoryLock`
-     * can refuse to release a lock that was acquired by someone else.
-     * @param {string} name - Lock name.
-     * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null`, `undefined`, or negative blocks forever.
-     * @returns {Promise<boolean>} - True if the lock was acquired, false if the timeout elapsed.
-     */
-    async acquireAdvisoryLock(name, { timeoutMs } = {}) {
-        const state = VelociousDatabaseDriversSqliteBase._advisoryLockState;
-        while (state.ownersByName.has(name)) {
-            let remainingMs = null;
-            if (typeof timeoutMs === "number" && timeoutMs >= 0) {
-                remainingMs = timeoutMs;
-                if (remainingMs <= 0)
-                    return false;
-            }
-            await new Promise((resolve) => {
-                const waiters = state.waitersByName.get(name) || [];
-                /**
-                 * Timeout handle.
-                  @type {NodeJS.Timeout | null} */
-                let timeoutHandle = null;
-                /**
-                 * Remove and resolve.
-                  @type {(() => void) | null} */
-                let removeAndResolve = null;
-                removeAndResolve = () => {
-                    if (timeoutHandle)
-                        clearTimeout(timeoutHandle);
-                    const current = state.waitersByName.get(name) || [];
-                    const index = current.indexOf(/**
-                                                   * Narrows the runtime value to the documented type.
-                                                    @type {() => void} */ (removeAndResolve));
-                    if (index >= 0)
-                        current.splice(index, 1);
-                    if (current.length === 0)
-                        state.waitersByName.delete(name);
-                    resolve(undefined);
-                };
-                waiters.push(removeAndResolve);
-                state.waitersByName.set(name, waiters);
-                if (remainingMs !== null) {
-                    timeoutHandle = setTimeout(() => {
-                        if (removeAndResolve)
-                            removeAndResolve();
-                    }, remainingMs);
-                }
-            });
-            if (typeof timeoutMs === "number" && timeoutMs >= 0 && state.ownersByName.has(name)) {
-                return false;
-            }
-        }
-        state.ownersByName.set(name, this);
-        return true;
-    }
-    /**
-     * Runs try acquire advisory lock.
-     * @param {string} name - Lock name.
-     * @returns {Promise<boolean>} - True if the lock was acquired, false if it was already held.
-     */
-    async tryAcquireAdvisoryLock(name) {
-        const state = VelociousDatabaseDriversSqliteBase._advisoryLockState;
-        if (state.ownersByName.has(name))
-            return false;
-        state.ownersByName.set(name, this);
-        return true;
-    }
-    /**
-     * Releases the lock only if **this** driver instance owns it. Calling
-     * release for a lock owned by another driver instance is a no-op that
-     * returns `false`, matching the "you can only release locks you own"
-     * contract of MySQL's `RELEASE_LOCK` and PostgreSQL's
-     * `pg_advisory_unlock`.
-     * @param {string} name - Lock name.
-     * @returns {Promise<boolean>} - True if the lock was held by this driver and has now been released.
-     */
-    async releaseAdvisoryLock(name) {
-        const state = VelociousDatabaseDriversSqliteBase._advisoryLockState;
-        const owner = state.ownersByName.get(name);
-        if (owner !== this)
-            return false;
-        state.ownersByName.delete(name);
-        const waiters = state.waitersByName.get(name);
-        if (waiters && waiters.length > 0) {
-            const nextWaiter = waiters.shift();
-            if (waiters.length === 0)
-                state.waitersByName.delete(name);
-            if (nextWaiter)
-                nextWaiter();
-        }
-        return true;
-    }
-    /**
-     * Runs is advisory lock held.
-     * @param {string} name - Lock name.
-     * @returns {Promise<boolean>} - True if any driver instance currently holds the lock.
-     */
-    async isAdvisoryLockHeld(name) {
-        return VelociousDatabaseDriversSqliteBase._advisoryLockState.ownersByName.has(name);
+
+    state.ownersByName.set(name, this)
+
+    return true
+  }
+
+  /**
+   * Runs try acquire advisory lock.
+   * @param {string} name - Lock name.
+   * @returns {Promise<boolean>} - True if the lock was acquired, false if it was already held.
+   */
+  async tryAcquireAdvisoryLock(name) {
+    const state = VelociousDatabaseDriversSqliteBase._advisoryLockState
+
+    if (state.ownersByName.has(name)) return false
+
+    state.ownersByName.set(name, this)
+
+    return true
+  }
+
+  /**
+   * Releases the lock only if **this** driver instance owns it. Calling
+   * release for a lock owned by another driver instance is a no-op that
+   * returns `false`, matching the "you can only release locks you own"
+   * contract of MySQL's `RELEASE_LOCK` and PostgreSQL's
+   * `pg_advisory_unlock`.
+   * @param {string} name - Lock name.
+   * @returns {Promise<boolean>} - True if the lock was held by this driver and has now been released.
+   */
+  async releaseAdvisoryLock(name) {
+    const state = VelociousDatabaseDriversSqliteBase._advisoryLockState
+    const owner = state.ownersByName.get(name)
+
+    if (owner !== this) return false
+
+    state.ownersByName.delete(name)
+
+    const waiters = state.waitersByName.get(name)
+
+    if (waiters && waiters.length > 0) {
+      const nextWaiter = waiters.shift()
+
+      if (waiters.length === 0) state.waitersByName.delete(name)
+      if (nextWaiter) nextWaiter()
     }
+
+    return true
+  }
+
+  /**
+   * Runs is advisory lock held.
+   * @param {string} name - Lock name.
+   * @returns {Promise<boolean>} - True if any driver instance currently holds the lock.
+   */
+  async isAdvisoryLockHeld(name) {
+    return VelociousDatabaseDriversSqliteBase._advisoryLockState.ownersByName.has(name)
+  }
 }
+
 /**
  * Process-wide state for the SQLite advisory lock emulation. Shared across
  * every SQLite driver instance (native, web, sql.js) because there is no
@@ -430,7 +504,6 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
  * @type {{ownersByName: Map<string, VelociousDatabaseDriversSqliteBase>, waitersByName: Map<string, Array<() => void>>}}
  */
 VelociousDatabaseDriversSqliteBase._advisoryLockState = {
-    ownersByName: new Map(),
-    waitersByName: new Map()
-};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../../src/database/drivers/sqlite/base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {digg} from \"diggerize\"\n\nimport AlterTable from \"./sql/alter-table.js\"\nimport Base from \"../base.js\"\nimport CreateIndex from \"./sql/create-index.js\"\nimport CreateTable from \"./sql/create-table.js\"\nimport Delete from \"./sql/delete.js\"\nimport DropTable from \"./sql/drop-table.js\"\nimport escapeString from \"sql-escape-string\"\nimport Insert from \"./sql/insert.js\"\nimport Options from \"./options.js\"\nimport QueryParser from \"./query-parser.js\"\nimport Table from \"./table.js\"\nimport StructureSql from \"./structure-sql.js\"\nimport Upsert from \"./sql/upsert.js\"\nimport Update from \"./sql/update.js\"\n\nexport default class VelociousDatabaseDriversSqliteBase extends Base {\n  /**\n   * Version major.\n    @type {number | undefined} */\n  versionMajor = undefined\n  /**\n   * Version minor.\n    @type {number | undefined} */\n  versionMinor = undefined\n  /**\n   * Version patch.\n    @type {number | undefined} */\n  versionPatch = undefined\n\n  /**\n   * Runs alter table sqls.\n   * @param {import(\"../../table-data/index.js\").default} tableData - Table data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async alterTableSQLs(tableData) {\n    const alterArgs = {driver: this, tableData}\n    const alterTable = new AlterTable(alterArgs)\n\n    return await alterTable.toSQLs()\n  }\n\n  /**\n   * Runs create index sqls.\n   * @param {import(\"../base.js\").CreateIndexSqlArgs} indexData - Index data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async createIndexSQLs(indexData) {\n    const createArgs = Object.assign({driver: this}, indexData)\n    const createIndex = new CreateIndex(createArgs)\n\n    return await createIndex.toSQLs()\n  }\n\n  /**\n   * Runs create table sql.\n   * @abstract\n   * @param {import(\"../../table-data/index.js\").default} tableData - Table data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async createTableSql(tableData) {\n    const createArgs = {tableData, driver: this, indexInCreateTable: false}\n    const createTable = new CreateTable(createArgs)\n\n    return await createTable.toSql()\n  }\n\n  currentDatabase() {\n    return null\n  }\n\n  async disableForeignKeys() {\n    await this.query(\"PRAGMA foreign_keys = 0\")\n  }\n\n  async enableForeignKeys() {\n    await this.query(\"PRAGMA foreign_keys = 1\")\n  }\n\n  /**\n   * Runs drop table sqls.\n   * @param {string} tableName - Table name.\n   * @param {import(\"../base.js\").DropTableSqlArgsType} [args] - Options object.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async dropTableSQLs(tableName, args = {}) {\n    const driver = /**\n                    * Narrows the runtime value to the documented type.\n                     @type {import(\"../base.js\").default} */ (this)\n    const dropArgs = Object.assign({tableName, driver}, args)\n    const dropTable = new DropTable(dropArgs)\n\n    return await dropTable.toSQLs()\n  }\n\n  /**\n   * Runs delete sql.\n   * @param {import(\"../base.js\").DeleteSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  deleteSql(args) { return new Delete(Object.assign({driver: this}, args)).toSql() }\n\n  /**\n   * Runs get type.\n   * @returns {string} - The type.\n   */\n  getType() { return \"sqlite\" }\n\n  /**\n   * Runs insert sql.\n   * @param {import(\"../base.js\").InsertSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  insertSql(args) { return new Insert(Object.assign({driver: this}, args)).toSql() }\n\n  /**\n   * Runs get tables.\n   * @returns {Promise<Array<import(\"../base-table.js\").default>>} - Resolves with the tables.\n   */\n  async getTables() {\n    return await this._cachedSchemaMetadata(\"tables\", async () => {\n      const result = await this.query(\"SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name\")\n      const tables = []\n\n      for (const row of result) {\n        const table = new Table({driver: this, row: /**\n                                                     * Narrows the runtime value to the documented type.\n                                                      @type {Record<string, string | number | null>} */ (row)})\n\n        tables.push(table)\n      }\n\n      return tables\n    })\n  }\n\n  /**\n   * Runs insert multiple.\n   * @param {string} tableName - Table name.\n   * @param {Array<string>} columns - Column names.\n   * @param {Array<Array<?>>} rows - Rows to insert.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async insertMultiple(tableName, columns, rows) {\n    this._assertNotReadOnly()\n    await this.registerVersion()\n\n    if (this.supportsMultipleInsertValues()) {\n      await this.insertMultipleWithSingleInsert(tableName, columns, rows)\n    } else {\n      await this.insertMultipleWithTransaction(tableName, columns, rows)\n    }\n  }\n\n  /**\n   * Runs supports multiple insert values.\n   * @returns {boolean} - Whether supports multiple insert values.\n   */\n  supportsMultipleInsertValues() {\n    /**\n     * Version major.\n      @type {number} */\n    const versionMajor = this.versionMajor || 0\n    /**\n     * Version minor.\n      @type {number} */\n    const versionMinor = this.versionMinor || 0\n    /**\n     * Version patch.\n      @type {number} */\n    const versionPatch = this.versionPatch || 0\n\n    if (versionMajor >= 4) return true\n    if (versionMajor == 3 && versionMinor >= 8) return true\n    if (versionMajor == 3 && versionMinor == 7 && versionPatch >= 11) return true\n\n    return false\n  }\n\n  /**\n   * Runs supports insert into returning.\n   * @returns {boolean} - Whether supports insert into returning.\n   */\n  supportsInsertIntoReturning() {\n    /**\n     * Version major.\n      @type {number} */\n    const versionMajor = this.versionMajor || 0\n    /**\n     * Version minor.\n      @type {number} */\n    const versionMinor = this.versionMinor || 0\n\n    if (versionMajor >= 4) return true\n    if (versionMajor == 3 && versionMinor >= 35) return true\n\n    return false\n  }\n\n  /**\n   * Runs insert multiple with single insert.\n   * @param {string} tableName - Table name.\n   * @param {Array<string>} columns - Column names.\n   * @param {Array<Array<?>>} rows - Rows to insert.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async insertMultipleWithSingleInsert(tableName, columns, rows) {\n    this._assertNotReadOnly()\n    const sql = new Insert({columns, driver: this, rows, tableName}).toSql()\n\n    await this.query(sql)\n  }\n\n  /**\n   * Runs insert multiple with transaction.\n   * @param {string} tableName - Table name.\n   * @param {Array<string>} columns - Column names.\n   * @param {Array<Array<?>>} rows - Rows to insert.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async insertMultipleWithTransaction(tableName, columns, rows) {\n    this._assertNotReadOnly()\n    /**\n     * Sqls.\n      @type {string[]} */\n    const sqls = []\n\n    for (const row of rows) {\n      /**\n       * Data.\n        @type {Record<string, ?>} */\n      const data = {}\n\n      for (const columnIndex in columns) {\n        const columnName = columns[columnIndex]\n        const value = row[columnIndex]\n\n        data[columnName] = value\n      }\n\n      const insertSql = this.insertSql({tableName, data})\n\n      sqls.push(insertSql)\n    }\n\n    await this.transaction(async () => {\n      for (const sql of sqls) {\n        await this.query(sql)\n      }\n    })\n  }\n\n  async lastInsertID() {\n    const result = await this.query(\"SELECT LAST_INSERT_ROWID() AS last_insert_id\")\n\n    return digg(result, 0, \"last_insert_id\")\n  }\n\n  options() {\n    if (!this._options) this._options = new Options(this)\n\n    return this._options\n  }\n\n  /**\n   * Runs primary key type.\n   * @returns {string} - The type of the primary key for this driver.\n   */\n  primaryKeyType() { return \"integer\" } // Because bigint on SQLite doesn't support auto increment\n\n  /**\n   * Runs query to sql.\n   * @param {import(\"../../query/index.js\").default} query - Query instance.\n   * @returns {string} - SQL string.\n   */\n  queryToSql(query) { return new QueryParser({query}).toSql() }\n\n  async registerVersion() {\n    if (this.versionMajor || this.versionMinor) {\n      return\n    }\n\n    const versionResult = await this.query(\"SELECT sqlite_version() AS version\")\n\n    this.version = String(versionResult[0].version)\n\n    const versionParts = this.version.split(\".\")\n\n    this.versionMajor = Number(versionParts[0])\n    this.versionMinor = Number(versionParts[1])\n    this.versionPatch = Number(versionParts[2])\n  }\n\n  shouldSetAutoIncrementWhenPrimaryKey() { return false }\n  supportsDefaultPrimaryKeyUUID() { return false }\n\n  /**\n   * Runs escape.\n   * @param {?} value - Value to use.\n   * @returns {?} - The escape.\n   */\n  escape(value) {\n    value = this._convertValue(value)\n\n    const type = typeof value\n\n    if (type != \"string\") value = `${value}`\n\n    const resultWithQuotes = escapeString(value, null)\n    const result = resultWithQuotes.substring(1, resultWithQuotes.length - 1)\n\n    return result\n  }\n\n  /**\n   * Runs retryable database error.\n   * @param {Error} error - Error instance.\n   * @returns {import(\"../base.js\").RetryableDatabaseErrorResult} - Retry info.\n   */\n  retryableDatabaseError(error) {\n    const shouldRetry = (\n      error.message?.startsWith(\"attempt to write a readonly database\") ||\n      error.message?.startsWith(\"database is locked\") ||\n      error.message?.includes(\"→ Caused by: Error code : database is locked\")\n    )\n\n    return {retry: shouldRetry, reconnect: false}\n  }\n\n  /**\n   * Runs quote.\n   * @param {?} value - Value to use.\n   * @returns {string | number} - The quoted value.\n   */\n  quote(value) {\n    value = this._convertValue(value)\n\n    const type = typeof value\n\n    if (type == \"number\") return /** Narrows the runtime value to the documented type. @type {number} */ (value)\n    if (type != \"string\") value = String(value)\n\n    return escapeString(value, null)\n  }\n\n  /**\n   * Runs update sql.\n   * @param {import(\"../base.js\").UpdateSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  updateSql({conditions, data, tableName}) { return new Update({conditions, data, driver: this, tableName}).toSql() }\n\n  /**\n   * Runs upsert sql.\n   * @param {import(\"../base.js\").UpsertSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  upsertSql(args) { return new Upsert({...args, driver: this}).toSql() }\n\n  /**\n   * Runs structure sql.\n   * @returns {Promise<string | null>} - Resolves with SQL string.\n   */\n  async structureSql() {\n    return await this._cachedSchemaMetadata(\"structureSql\", async () => await new StructureSql({driver: this}).toSql())\n  }\n\n  /**\n   * Blocks until an in-process advisory lock with the given name is\n   * acquired. SQLite has no built-in advisory lock primitive, so this is\n   * implemented as a process-local waiter queue. Typical SQLite deployments\n   * run inside a single Node process, which is exactly the scope this\n   * emulation covers; multi-process SQLite setups should not rely on this\n   * for cross-process mutual exclusion.\n   *\n   * The owning driver instance is recorded so that `releaseAdvisoryLock`\n   * can refuse to release a lock that was acquired by someone else.\n   * @param {string} name - Lock name.\n   * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null`, `undefined`, or negative blocks forever.\n   * @returns {Promise<boolean>} - True if the lock was acquired, false if the timeout elapsed.\n   */\n  async acquireAdvisoryLock(name, {timeoutMs} = {}) {\n    const state = VelociousDatabaseDriversSqliteBase._advisoryLockState\n\n    while (state.ownersByName.has(name)) {\n      let remainingMs = null\n\n      if (typeof timeoutMs === \"number\" && timeoutMs >= 0) {\n        remainingMs = timeoutMs\n\n        if (remainingMs <= 0) return false\n      }\n\n      await new Promise((resolve) => {\n        const waiters = state.waitersByName.get(name) || []\n        /**\n         * Timeout handle.\n          @type {NodeJS.Timeout | null} */\n        let timeoutHandle = null\n        /**\n         * Remove and resolve.\n          @type {(() => void) | null} */\n        let removeAndResolve = null\n\n        removeAndResolve = () => {\n          if (timeoutHandle) clearTimeout(timeoutHandle)\n\n          const current = state.waitersByName.get(name) || []\n          const index = current.indexOf(/**\n                                         * Narrows the runtime value to the documented type.\n                                          @type {() => void} */ (removeAndResolve))\n\n          if (index >= 0) current.splice(index, 1)\n          if (current.length === 0) state.waitersByName.delete(name)\n\n          resolve(undefined)\n        }\n\n        waiters.push(removeAndResolve)\n        state.waitersByName.set(name, waiters)\n\n        if (remainingMs !== null) {\n          timeoutHandle = setTimeout(() => {\n            if (removeAndResolve) removeAndResolve()\n          }, remainingMs)\n        }\n      })\n\n      if (typeof timeoutMs === \"number\" && timeoutMs >= 0 && state.ownersByName.has(name)) {\n        return false\n      }\n    }\n\n    state.ownersByName.set(name, this)\n\n    return true\n  }\n\n  /**\n   * Runs try acquire advisory lock.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - True if the lock was acquired, false if it was already held.\n   */\n  async tryAcquireAdvisoryLock(name) {\n    const state = VelociousDatabaseDriversSqliteBase._advisoryLockState\n\n    if (state.ownersByName.has(name)) return false\n\n    state.ownersByName.set(name, this)\n\n    return true\n  }\n\n  /**\n   * Releases the lock only if **this** driver instance owns it. Calling\n   * release for a lock owned by another driver instance is a no-op that\n   * returns `false`, matching the \"you can only release locks you own\"\n   * contract of MySQL's `RELEASE_LOCK` and PostgreSQL's\n   * `pg_advisory_unlock`.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - True if the lock was held by this driver and has now been released.\n   */\n  async releaseAdvisoryLock(name) {\n    const state = VelociousDatabaseDriversSqliteBase._advisoryLockState\n    const owner = state.ownersByName.get(name)\n\n    if (owner !== this) return false\n\n    state.ownersByName.delete(name)\n\n    const waiters = state.waitersByName.get(name)\n\n    if (waiters && waiters.length > 0) {\n      const nextWaiter = waiters.shift()\n\n      if (waiters.length === 0) state.waitersByName.delete(name)\n      if (nextWaiter) nextWaiter()\n    }\n\n    return true\n  }\n\n  /**\n   * Runs is advisory lock held.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - True if any driver instance currently holds the lock.\n   */\n  async isAdvisoryLockHeld(name) {\n    return VelociousDatabaseDriversSqliteBase._advisoryLockState.ownersByName.has(name)\n  }\n}\n\n/**\n * Process-wide state for the SQLite advisory lock emulation. Shared across\n * every SQLite driver instance (native, web, sql.js) because there is no\n * concept of \"connection\" to distinguish them at the SQLite level.\n *\n * `ownersByName` maps each held lock name to the driver instance that\n * acquired it so `releaseAdvisoryLock` can reject releases from drivers\n * that do not own the lock.\n * @type {{ownersByName: Map<string, VelociousDatabaseDriversSqliteBase>, waitersByName: Map<string, Array<() => void>>}}\n */\nVelociousDatabaseDriversSqliteBase._advisoryLockState = {\n  ownersByName: new Map(),\n  waitersByName: new Map()\n}\n"]}
+  ownersByName: new Map(),
+  waitersByName: new Map()
+}