velocious 1.0.592 → 1.0.594

package/README.md

@@ -20,7 +20,7 @@
 * Self-sustaining sync feeds: upstream imports triggered by the changes pull itself, with framework-owned coalescing and throttling (see [docs/sync-upstream-imports.md](docs/sync-upstream-imports.md))
 * AwesomeTasks-shaped offline sync proof using routed resources, domain commands, signed offline grants, and peer-forwarded mutations (see the [developer guide](docs/shared-resource-sync-guide.md) and [proof](docs/awesome-tasks-offline-sync-proof.md))
 * SQLite web persistence that automatically prefers OPFS, then IndexedDB, and migrates legacy persisted bytes when possible (see [docs/sqlite-web-persistence.md](docs/sqlite-web-persistence.md))
-* Bounded frontend tenant SQLite handles with durable flush/close, backend-complete deletion, clean-only LRU eviction, and scoped pins (see [docs/frontend-tenant-sqlite-lifecycle.md](docs/frontend-tenant-sqlite-lifecycle.md))
+* Bounded frontend tenant SQLite handles with independently deduplicated per-database migrations/model readiness, React lifecycle integration, durable flush/close, backend-complete deletion, clean-only LRU eviction, and scoped pins (see [docs/frontend-tenant-sqlite-lifecycle.md](docs/frontend-tenant-sqlite-lifecycle.md))
 * Expo / Metro compatibility guidance and a real Expo export check (see [docs/expo-metro-compatibility.md](docs/expo-metro-compatibility.md))
 * Gap-less positional lists with automatic reordering via `actsAsList`, including models with numeric, string, or UUID primary keys (see [docs/acts-as-list.md](docs/acts-as-list.md))
 * Rails-style nested-attribute writes on frontend-model `save()` (see [docs/nested-attributes.md](docs/nested-attributes.md))
@@ -328,6 +328,7 @@ npm run test:browser
 ```
 
 Browser system tests must be named `*.browser-test.js` or `*.browser-spec.js` (override with `VELOCIOUS_BROWSER_TEST_PATTERN`).
+The runner validates and persists the exact Chrome/ChromeDriver pair selected by `scripts/prewarm-chromedriver.js`, then owns ChromeDriver and Chrome as a managed process group. Startup failures report the runtime paths and versions, service URL, retained logs under `tmp/browser-test-chrome/`, and Chrome process state before and after cleanup.
 
 Use beforeAll/afterAll for suite-level setup/teardown.
 
@@ -954,7 +955,8 @@ Translated models also get a `currentTranslation` `hasOne` relationship scoped t
 Async class APIs initialize record metadata on first use when a model has not
 already been initialized eagerly. See [docs/model-initialization.md](docs/model-initialization.md)
 for the eager and lazy initialization behavior, including atomic shared bootstrap
-and complete recovery after an eager initialization failure.
+and complete recovery after an eager initialization failure or database-connection
+closure without overlapping stale and current bootstrap side effects.
 
 ## Lifecycle callbacks
 
@@ -2070,6 +2072,13 @@ If you are developing on Velocious, you can run the tests with:
 
 Tests default to a 60-second timeout. Override per test with `{timeoutSeconds: 5}` or set a suite-wide default via `configureTests({defaultTimeoutSeconds: 30})`.
 
+Truncation-based test cleanup batches eligible tables into one request on PostgreSQL,
+SQL Server, and SQLite while preserving each driver's existing identity behavior,
+foreign-key restoration, stale-schema retry, and SQL.js persistence guarantees.
+MySQL/MariaDB batching requires the database's existing `multipleStatements: true`
+option; the default configuration keeps sequential `TRUNCATE TABLE` requests. See
+[database cleanup guidance](docs/testing-guidelines.md#truncation-cleanup).
+
 Request tests share transaction-active, non-tenant database connections with their in-process HTTP handlers. Eligibility is evaluated when each request is dispatched, so a hook can start a transaction and issue a request in the same callback. This makes uncommitted setup visible to handlers while preserving rollback isolation. Without an active transaction, handlers use independent pooled connections, so concurrency and locking tests can opt out of transaction cleanup and exercise production-style connections. Shared connection state is scoped to the test lifecycle and cleared around each test. See [docs/testing-guidelines.md](docs/testing-guidelines.md#request-test-database-connections).
 
 Transactional tests also share active non-tenant connections with real forked, reusable pooled, and spawned background-job child runners through a per-attempt test-only loopback broker. Parent setup and child writes therefore occupy the same physical transaction and roll back together, including background-job persistence. Multiple configured databases route by identifier; tenant-only databases remain excluded. Tests using `{transaction: false, truncate: true}` retain ordinary independent physical connections for concurrency and locking coverage. See [docs/testing-guidelines.md](docs/testing-guidelines.md#request-test-database-connections).

package/build/configuration-types.js

@@ -72,7 +72,7 @@
  * @property {() => ReturnType<typeof JSON.parse>} [getConnection] - Custom connection factory override.
  * @property {string} [host] - Database host.
  * @property {boolean} [migrations] - Whether migrations are enabled for this database.
- * @property {boolean} [multipleStatements] - (MySQL) Opt in to multi-statement queries so a whole structure SQL dump loads in one round-trip via `StructureSqlLoader`. Off by default; ordinary queries otherwise reject stacked statements.
+ * @property {boolean} [multipleStatements] - (MySQL) Opt in to multi-statement queries so structure SQL loads and all-table cleanup can batch into one round-trip. Off by default; ordinary queries otherwise reject stacked statements.
  * @property {number} [maxRowsPerInsert] - Maximum rows per `INSERT ... VALUES (...), (...), ...` statement generated by `Record.insertMultiple`. Defaults to 500.
  * @property {number} [maxInsertSqlBytes] - Maximum serialized SQL size, in bytes, for a single `INSERT ... VALUES (...), (...), ...` statement. Defaults to 1 MiB (1048576).
  * @property {number} [maxInClauseValues] - Maximum values in a single `IN (...)` cohort used by preloads, association counts, and queryData aggregates. Defaults to 999.

package/build/configuration.js

@@ -302,8 +302,9 @@ export default class VelociousConfiguration {
      */
     this._initializeModelsPromise = undefined
     /**
-     * In-progress `initialize()` promise, memoized so concurrent callers await
-     * the same bootstrap. Reset to undefined if initialization fails.
+     * Current `initialize()` promise, memoized so concurrent callers await the
+     * same bootstrap. Retained across a connection close until stale bootstrap
+     * work settles, then cleared by identity before the new generation retries.
      * @type {Promise<void> | undefined}
      */
     this._initializePromise = undefined
@@ -1102,6 +1103,18 @@ export default class VelociousConfiguration {
     }
   }
 
+  /**
+   * Invalidates record metadata owned by one closed/deleted physical tenant
+   * database while preserving every other tenant generation.
+   * @param {string} databaseIdentity - Logical identifier plus pool reuse key.
+   * @returns {void}
+   */
+  clearRecordMetadataForDatabaseIdentity(databaseIdentity) {
+    for (const modelClass of Object.values(this.modelClasses)) {
+      modelClass.clearRecordMetadataValuesForDatabaseIdentity(databaseIdentity)
+    }
+  }
+
   /**
    * Runs get database pool type.
    * @param {string} identifier - Identifier.
@@ -2054,10 +2067,25 @@ export default class VelociousConfiguration {
    * @returns {Promise<void>} - Resolves when complete.
    */
   async initializeModels(args = {type: "server"}) {
+    const modelInitializationGeneration = this._modelInitializationGeneration
+
     if (this._modelsInitialized) return
-    if (this._initializeModelsPromise) return await this._initializeModelsPromise
+    if (this._initializeModelsPromise) {
+      const initializeModelsPromise = this._initializeModelsPromise
+
+      await initializeModelsPromise
+
+      if (this._modelInitializationGeneration === modelInitializationGeneration && !this._modelsInitialized) {
+        if (this._initializeModelsPromise === initializeModelsPromise) {
+          this._initializeModelsPromise = undefined
+        }
+
+        return await this.initializeModels(args)
+      }
+
+      return
+    }
 
-    const modelInitializationGeneration = this._modelInitializationGeneration
     const initializeModelsPromise = (async () => {
       const shouldSkipDummyModelInitialization = process.env.VELOCIOUS_SKIP_DUMMY_MODEL_INITIALIZATION === "1"
         && process.env.VELOCIOUS_BROWSER_TESTS === "true"
@@ -2110,6 +2138,12 @@ export default class VelociousConfiguration {
    * @returns {Promise<void>} - Resolves when complete.
    */
   async initialize({type} = {type: "undefined"}) {
+    if (this._closeDatabaseConnectionsPromise) {
+      await this._closeDatabaseConnectionsPromise
+    }
+
+    const initializationGeneration = this._modelInitializationGeneration
+
     if (this._isInitialized) return
     // Memoize the in-progress initialization so concurrent callers await the same
     // bootstrap instead of racing. `_isInitialized` was previously set to `true`
@@ -2117,15 +2151,29 @@ export default class VelociousConfiguration {
     // `pooledRunnerConcurrency > 1` starting several jobs on a cold child) could
     // skip initialization and load models / perform a job while the first call
     // was still awaiting model discovery and initializers. Mirrors connectBeacon.
-    if (this._initializePromise) return await this._initializePromise
+    if (this._initializePromise) {
+      const initializePromise = this._initializePromise
 
-    this._initializePromise = (async () => {
+      await initializePromise
+
+      if (this._modelInitializationGeneration === initializationGeneration && !this._isInitialized) {
+        if (this._initializePromise === initializePromise) {
+          this._initializePromise = undefined
+        }
+
+        return await this.initialize({type})
+      }
+
+      return
+    }
+
+    const initializePromise = (async () => {
       await this.initializeModels({type})
 
       // Model initialization can be invalidated by a concurrent connection close.
       // If models are not ready, stop without marking the configuration initialized
       // so the next caller retries a full bootstrap.
-      if (!this._modelsInitialized) return
+      if (this._modelInitializationGeneration !== initializationGeneration || !this._modelsInitialized) return
 
       await this.getEnvironmentHandler().autoDiscoverResources(this)
       this._mergeDiscoveredAbilityResources()
@@ -2147,22 +2195,28 @@ export default class VelociousConfiguration {
         }
       }
 
-      this._isInitialized = true
+      if (this._modelInitializationGeneration === initializationGeneration) {
+        this._isInitialized = true
+      }
     })()
 
+    this._initializePromise = initializePromise
+
     try {
-      await this._initializePromise
+      await initializePromise
     } catch (error) {
       // Let a later call retry a failed initialization instead of every future
       // caller awaiting the same cached rejection.
-      this._initializePromise = undefined
+      if (this._initializePromise === initializePromise) {
+        this._initializePromise = undefined
+      }
       throw error
     }
 
     // If the inner IIFE returned without marking the configuration initialized
     // (e.g. because models were invalidated mid-bootstrap), clear the promise so
     // a later call retries a full bootstrap.
-    if (!this._isInitialized) {
+    if (!this._isInitialized && this._initializePromise === initializePromise) {
       this._initializePromise = undefined
     }
   }
@@ -3072,11 +3126,11 @@ export default class VelociousConfiguration {
    * database configuration. No ambient tenant value is read during checkout or
    * execution.
    * @template T
-   * @param {{databaseConfiguration: import("./configuration-types.js").DatabaseConfigurationType, databaseIdentifier: string, name?: string, tenant?: object}} options - Captured operation options.
+   * @param {{databaseConfiguration: import("./configuration-types.js").DatabaseConfigurationType, databaseIdentifier: string, name?: string, schemaGeneration?: string, tenant?: object}} options - Captured operation options.
    * @param {(operation: DatabaseOperation) => Promise<T>} callback - Operation callback.
    * @returns {Promise<T>} - Callback result.
    */
-  async withDatabaseOperation({databaseConfiguration, databaseIdentifier, name = "Configuration.withDatabaseOperation", tenant, ...restArgs}, callback) {
+  async withDatabaseOperation({databaseConfiguration, databaseIdentifier, name = "Configuration.withDatabaseOperation", schemaGeneration, tenant, ...restArgs}, callback) {
     restArgsError(restArgs)
 
     if (!databaseIdentifier) throw new Error("Configuration.withDatabaseOperation requires a databaseIdentifier")
@@ -3095,6 +3149,7 @@ export default class VelociousConfiguration {
         databaseIdentifier,
         enforceCurrentTenantReuseKey: false,
         owner,
+        schemaGeneration,
         tenant
       })
 

package/build/database/drivers/base.js

@@ -65,6 +65,7 @@
  * @property {boolean} [processListComment] - Whether to add process-list comments to the query.
  * @property {boolean} [retry] - Whether retryable errors may retry the query; defaults to true.
  * @property {boolean} [sessionTimeZone] - Whether to ensure the configured database session time zone before the query.
+ * @property {boolean} [sqliteScript] - Internal SQLite flag selecting native multi-statement script execution.
  * @property {AbortSignal} [signal] - Aborts the in-flight query (destroying its connection) when it fires.
  * @property {string} [sourceStack] - Stack captured at the caller boundary.
  * @property {symbol} [operationOwner] - Opaque owner for an operation-leased connection.
@@ -141,7 +142,8 @@ import TableData from "../table-data/index.js"
 import TableColumn from "../table-data/table-column.js"
 import TableForeignKey from "../table-data/table-foreign-key.js"
 import wait from "awaitery/build/wait.js"
-import {optionalPositiveInteger} from "typanic"
+import { optionalPositiveInteger } from "typanic"
+import { coordinateSharedTransactionConnection } from "../../testing/shared-transaction-connection-coordinator.js"
 
 /** Maximum characters inspected when building the debug SQL preview. */
 const SQL_PREVIEW_SCAN_LIMIT = 4096
@@ -193,6 +195,10 @@ export default class VelociousDatabaseDriversBase {
    * Narrows the runtime value to the documented type.
    * @type {TransactionCallbackFrame[]} */
   _transactionCallbackFrames
+  /** @type {Promise<void>} */
+  _transactionCompletionPromise
+  /** @type {(() => void) | undefined} */
+  _resolveTransactionCompletion
   /**
    * Narrows the runtime value to the documented type.
    * @type {Map<string, Promise<ReturnType<typeof JSON.parse>>>} */
@@ -229,6 +235,8 @@ export default class VelociousDatabaseDriversBase {
     this.logger = new Logger(this)
     this._transactionCallbackFrames = []
     this._transactionsCount = 0
+    this._transactionCompletionPromise = Promise.resolve()
+    this._resolveTransactionCompletion = undefined
     this._transactionsActionsMutex = new Mutex()
     this._schemaCache = new Map()
   }
@@ -1424,6 +1432,12 @@ export default class VelociousDatabaseDriversBase {
    */
   insideTransaction() { return this._transactionsCount > 0 }
 
+  /**
+   * Returns the completion promise identifying the current outer transaction.
+   * @returns {Promise<void>} Resolves after that transaction commits or rolls back.
+   */
+  transactionCompletion() { return this._transactionCompletionPromise }
+
   /**
    * Runs start transaction.
    * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
@@ -1444,6 +1458,12 @@ export default class VelociousDatabaseDriversBase {
 
         await this._startTransactionAction(options)
         this._transactionsCount++
+
+        if (this._transactionsCount === 1) {
+          this._transactionCompletionPromise = new Promise((resolve) => {
+            this._resolveTransactionCompletion = resolve
+          })
+        }
       })
 
       if (!blockingOperationLease) return
@@ -1470,9 +1490,20 @@ export default class VelociousDatabaseDriversBase {
     await this._transactionsActionsMutex.sync(async () => {
       await this._commitTransactionAction(options)
       this._transactionsCount--
+      this._resolveCompletedTransaction()
     })
   }
 
+  /** Resolves the current outer transaction completion when it has finished. */
+  _resolveCompletedTransaction() {
+    if (this._transactionsCount !== 0) return
+
+    const resolve = this._resolveTransactionCompletion
+
+    this._resolveTransactionCompletion = undefined
+    if (resolve) resolve()
+  }
+
   /**
    * Runs commit transaction action.
    * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
@@ -1594,13 +1625,16 @@ export default class VelociousDatabaseDriversBase {
   async affectedRows(sql, options = {}) {
     await this._waitForOperationLease(options.operationOwner)
     this._assertWritableQuery(sql)
-    await this.beforeQuery(sql, options)
 
-    try {
-      return await this._affectedRowsActual(sql)
-    } finally {
-      await this.afterQuery(sql, options)
-    }
+    return await coordinateSharedTransactionConnection(this, async () => {
+      await this.beforeQuery(sql, options)
+
+      try {
+        return await this._affectedRowsActual(sql)
+      } finally {
+        await this.afterQuery(sql, options)
+      }
+    }, options.operationOwner)
   }
 
   /**
@@ -1663,13 +1697,15 @@ export default class VelociousDatabaseDriversBase {
    * @returns {Promise<QueryResultType>} - Resolves with the query.
    */
   async _queryActualWithHooks(sql, options) {
-    await this.beforeQuery(sql, options)
+    return await coordinateSharedTransactionConnection(this, async () => {
+      await this.beforeQuery(sql, options)
 
-    try {
-      return await this._queryActual(sql, options)
-    } finally {
-      await this.afterQuery(sql, options)
-    }
+      try {
+        return await this._queryActual(sql, options)
+      } finally {
+        await this.afterQuery(sql, options)
+      }
+    }, options.operationOwner)
   }
 
   /**
@@ -2084,6 +2120,7 @@ export default class VelociousDatabaseDriversBase {
         await this._rollbackTransactionAction(options)
       } finally {
         this._transactionsCount--
+        this._resolveCompletedTransaction()
 
         // A rolled-back transaction may have reverted DDL (e.g. a CREATE TABLE
         // run lazily inside the transaction), so any cached schema metadata is
@@ -2214,42 +2251,54 @@ export default class VelociousDatabaseDriversBase {
     await this.query(`ROLLBACK TO SAVEPOINT ${savePointName}`, options)
   }
 
+  /**
+   * Truncates the given table snapshot. Drivers can override this to issue one batch.
+   * @protected
+   * @param {Array<import("./base-table.js").default>} tables - Eligible tables for this cleanup attempt.
+   * @returns {Promise<void>} - Resolves when every table has been cleaned.
+   */
+  async truncateTables(tables) {
+    const truncateErrors = []
+
+    for (const table of tables) {
+      try {
+        await table.truncate({cascade: true})
+      } catch (error) {
+        truncateErrors.push(error)
+      }
+    }
+
+    if (truncateErrors.length > 0) throw truncateErrors[0]
+  }
+
   /**
    * Runs truncate all tables.
    * @returns {Promise<void>} - Resolves when complete.
    */
   async truncateAllTables() {
     this._assertNotReadOnly()
-    await this.withDisabledForeignKeys(async () => {
-      let tries = 0
+    let tables = (await this.getTables()).filter((table) => table.getName() != "schema_migrations")
 
-      while(tries <= 5) {
-        tries++
+    if (tables.length == 0) return
 
-        const tables = await this.getTables()
-        const truncateErrors = []
+    await this.withDisabledForeignKeys(async () => {
+      for (let tries = 1; tries <= 6; tries++) {
+        try {
+          await this.truncateTables(tables)
+          return
+        } catch (error) {
+          console.error(error)
 
-        for (const table of tables) {
-          if (table.getName() != "schema_migrations") {
-            try {
-              await table.truncate({cascade: true})
-            } catch (error) {
-              console.error(error)
-              truncateErrors.push(error)
-            }
-          }
-        }
+          if (tries == 6) throw error
 
-        if (truncateErrors.length == 0) {
-          break
-        } else if (tries <= 5) {
           // A truncate failed — the schema cache may still list a table that was
           // dropped out from under us (e.g. a db:rollback test that left the
           // shared DB rolled back). Clear it so the next pass re-reads the live
           // table list and no longer tries to truncate a table that is gone.
           this.clearSchemaCache()
-        } else {
-          throw truncateErrors[0]
+          tables = (await this.getTables()).filter((table) => table.getName() != "schema_migrations")
+
+          if (tables.length == 0) return
         }
       }
     })

package/build/database/drivers/mssql/index.js

@@ -506,6 +506,38 @@ export default class VelociousDatabaseDriversMssql extends Base{
     })
   }
 
+  /**
+   * Truncates all eligible tables in one SQL Server request, retaining the
+   * recognized foreign-key fallback used by the per-table implementation.
+   * @param {Array<import("../base-table.js").default>} tables - Eligible tables.
+   * @returns {Promise<void>} - Resolves when the batch completes.
+   */
+  async truncateTables(tables) {
+    const statements = []
+
+    for (const table of tables) {
+      const quotedTable = this.quoteTable(table.getName())
+
+      statements.push(
+        "BEGIN TRY",
+        `  TRUNCATE TABLE ${quotedTable};`,
+        "END TRY",
+        "BEGIN CATCH",
+        "  IF ERROR_NUMBER() = 4712",
+        "  BEGIN",
+        `    DELETE FROM ${quotedTable};`,
+        "  END",
+        "  ELSE",
+        "  BEGIN",
+        "    THROW;",
+        "  END",
+        "END CATCH;"
+      )
+    }
+
+    await this.query(statements.join("\n"))
+  }
+
   async lastInsertID(options = {}) {
     const result = await this.query("SELECT SCOPE_IDENTITY() AS last_insert_id", options)
     const lastInsertID = digg(result, 0, "last_insert_id")

package/build/database/drivers/mysql/index.js

@@ -486,6 +486,23 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return true
   }
 
+  /**
+   * Uses one multi-statement request only when the existing connection option
+   * explicitly allows it; otherwise retains the base sequential behavior.
+   * @param {Array<import("../base-table.js").default>} tables - Eligible tables.
+   * @returns {Promise<void>} - Resolves when every table has been truncated.
+   */
+  async truncateTables(tables) {
+    if (!this.getArgs().multipleStatements) {
+      await super.truncateTables(tables)
+      return
+    }
+
+    const statements = tables.map((table) => `TRUNCATE TABLE ${this.quoteTable(table.getName())}`)
+
+    await this.query(statements.join(";\n"))
+  }
+
   /**
    * Runs query to sql.
    * @param {import("../../query/index.js").default} query - Query instance.

package/build/database/drivers/pgsql/index.js

@@ -326,6 +326,17 @@ export default class VelociousDatabaseDriversPgsql extends Base{
     })
   }
 
+  /**
+   * Truncates all eligible tables in one PostgreSQL request.
+   * @param {Array<import("../base-table.js").default>} tables - Eligible tables.
+   * @returns {Promise<void>} - Resolves when the batch completes.
+   */
+  async truncateTables(tables) {
+    const quotedTables = tables.map((table) => this.quoteTable(table.getName()))
+
+    await this.query(`TRUNCATE TABLE ${quotedTables.join(", ")} CASCADE`)
+  }
+
   async lastInsertID(options = {}) {
     const result = await this.query("SELECT LASTVAL() AS last_insert_id", options)
 

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

@@ -161,6 +161,18 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
     })
   }
 
+  /**
+   * Deletes every eligible table through the platform driver's native SQLite
+   * script path so the whole cleanup is submitted as one request.
+   * @param {Array<import("../base-table.js").default>} tables - Eligible tables.
+   * @returns {Promise<void>} - Resolves when the script completes.
+   */
+  async truncateTables(tables) {
+    const statements = tables.map((table) => `DELETE FROM ${this.quoteTable(table.getName())}`)
+
+    await this.query(statements.join(";\n"), {sqliteScript: true})
+  }
+
   /**
    * Runs insert multiple.
    * @param {string} tableName - Table name.

package/build/database/drivers/sqlite/connection-sql-js.js

@@ -89,14 +89,15 @@ export default class VelociousDatabaseDriversSqliteConnectionSqlJs {
   /**
    * Runs query.
    * @param {string} sql - SQL string.
+   * @param {{mutation?: boolean}} [options] - Internal query classification options.
    * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>[]>} - Resolves with the query.
    */
-  async query(sql) {
+  async query(sql, {mutation = false} = {}) {
     const result = await queryWeb(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 ")) {
+    if (mutation || downcasedSQL.startsWith("delete ") || downcasedSQL.startsWith("insert into ") || downcasedSQL.startsWith("update ")) {
       this.saveDatabaseDebounce()
     }
 

package/build/database/drivers/sqlite/index.js

@@ -84,11 +84,17 @@ export default class VelociousDatabaseDriversSqliteNode extends Base {
   /**
    * Runs query actual.
    * @param {string} sql - SQL string.
+   * @param {import("../base.js").QueryOptions} [options] - Query options.
    * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>[]>} - Resolves with the query actual.
    */
-  async _queryActual(sql) {
+  async _queryActual(sql, options = {}) {
     if (!this.connection) throw new Error("No connection")
 
+    if (options.sqliteScript) {
+      await this.connection.exec(sql)
+      return []
+    }
+
     return await query(this.connection, sql)
   }
 

package/build/database/drivers/sqlite/index.native.js

@@ -82,13 +82,19 @@ export default class VelociousDatabaseDriversSqliteNative extends Base {
   /**
    * Runs query actual.
    * @param {string} sql - SQL string.
+   * @param {import("../base.js").QueryOptions} [options] - Query options.
    * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>[]>} - Query result rows.
    */
-  async _queryActual(sql) {
-    return await this._queryMutex.sync(() => {
+  async _queryActual(sql, options = {}) {
+    return await this._queryMutex.sync(async () => {
       if (!this.connection) throw new Error("Not connected yet")
 
-      return query(this.connection, sql)
+      if (options.sqliteScript) {
+        await this.connection.execAsync(sql)
+        return []
+      }
+
+      return await query(this.connection, sql)
     })
   }
 

package/build/database/drivers/sqlite/index.web.js

@@ -178,13 +178,16 @@ export default class VelociousDatabaseDriversSqliteWeb extends Base {
   /**
    * Runs query actual.
    * @param {string} sql - SQL string.
+   * @param {import("../base.js").QueryOptions} [options] - Query options.
    * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>[]>} - Resolves with the query actual.
    */
-  async _queryActual(sql) {
-    const result = await this.getConnection().query(sql)
+  async _queryActual(sql, options = {}) {
+    const connection = this.getConnection()
+    const result = connection instanceof ConnectionSqlJs
+      ? await connection.query(sql, {mutation: options.sqliteScript === true})
+      : await connection.query(sql)
 
     if (!Array.isArray(result)) {
-      const connection = this.getConnection()
       const connectionName = connection?.constructor?.name || "UnknownConnection"
 
       throw new Error(`Sqlite web connection ${connectionName} returned a non-array result: ${typeof result}`)