velocious 1.0.632 → 1.0.633

package/build/database/pool/async-tracked-multi-connection.js

@@ -17,6 +17,7 @@ import { currentTestProfileContext } from "../../testing/test-profile-context.js
  * @property {number | null} timeoutAt - Timestamp when the checkout will time out, or null when disabled.
  * @property {number | null} timeoutMillis - Milliseconds to wait before rejecting, or null when disabled.
  * @property {ReturnType<typeof setTimeout> | undefined} timeoutTimer - Timer that rejects the pending checkout.
+ * @property {{revoked: boolean} | undefined} [testDatabaseAccessScope] - Database-access scope captured at enqueue.
  * @property {import("../../testing/test-profiler.js").TestProfileAsyncContext | undefined} [testProfileContext] - Async-safe profile attribution captured at enqueue.
  */
 export const CLOSED_CONNECTION = Symbol("velociousClosedConnection")
@@ -227,7 +228,7 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
     const trackedConnection = /** @type {import("../drivers/base.js").default & {[CLOSED_CONNECTION]?: boolean, [CONNECTION_CHECKED_OUT_AT]?: number, [IDLE_CONNECTION_CHECKED_IN_AT]?: number}} */ (connection)
 
     if (trackedConnection[CLOSED_CONNECTION]) {
-      this.untrackConnectionInUse(connection, id)
+      if (typeof id === "number") this.untrackConnectionInUse(connection, id)
       await this.drainPendingCheckouts()
       return
     }
@@ -343,6 +344,7 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
    * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the checkout.
    */
   async checkout(options = {}) {
+    this.assertDatabaseAccessAllowed()
     let databaseConfig = this.getConfiguration()
     let reuseKey = this.getConfigurationReuseKey(databaseConfig)
     let connection = this.takeIdleConnectionForReuseKey(reuseKey)
@@ -380,6 +382,7 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
    * @returns {Promise<import("../drivers/base.js").default>} - Activated pooled connection.
    */
   async checkoutForConfiguration(databaseConfig, options = {}) {
+    this.assertDatabaseAccessAllowed()
     const reuseKey = this.getConfigurationReuseKey(databaseConfig)
     const lifecycleRetainedConnection = this.lifecycleRetainedConnections.get(reuseKey)
 
@@ -446,6 +449,11 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
    * @returns {Promise<import("../drivers/base.js").default>} - Activated connection.
    */
   async activateConnection(connection, options = {}) {
+    try {
+      this.assertDatabaseAccessAllowed()
+    } catch (error) {
+      await this.closeRejectedCheckoutAndThrow(connection, error)
+    }
     if (connection.getIdSeq() !== undefined) throw new Error(`Connection already has an ID-seq - is it in use? ${connection.getIdSeq()}`)
 
     const id = this.idSeq++
@@ -459,15 +467,48 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
 
     try {
       await connection.setConnectionCheckoutName(options.name)
+      this.assertDatabaseAccessAllowed()
     } catch (error) {
-      delete this.connectionsInUse[id]
-      connection.setIdSeq(undefined)
+      await this.closeRejectedCheckoutAndThrow(connection, error, id)
+    }
+
+    return connection
+  }
+
+  /**
+   * Closes a rejected checkout, then hands freed capacity to queued callers.
+   * @param {import("../drivers/base.js").default} connection - Rejected connection.
+   * @param {ReturnType<typeof JSON.parse>} error - Access revocation error.
+   * @param {number} [id] - Assigned checkout id, if activation reached that stage.
+   * @returns {Promise<never>} - Always rejects with the access or cleanup errors.
+   */
+  async closeRejectedCheckoutAndThrow(connection, error, id) {
+    if (id !== undefined) this.untrackConnectionInUse(connection, id)
+
+    /** @type {ReturnType<typeof JSON.parse>[]} */
+    const cleanupErrors = []
+
+    try {
       await this.closeConnection(connection)
+    } catch (closeError) {
+      cleanupErrors.push(closeError)
+    }
 
-      throw error
+    try {
+      if (this.pendingCheckoutDrainPromise) {
+        this.pendingCheckoutDrainRequested = true
+      } else {
+        await this.drainPendingCheckouts()
+      }
+    } catch (drainError) {
+      cleanupErrors.push(drainError)
     }
 
-    return connection
+    if (cleanupErrors.length > 0) {
+      throw new AggregateError([error, ...cleanupErrors], "Database checkout rejection cleanup failed", {cause: error})
+    }
+
+    throw error
   }
 
   /**
@@ -588,6 +629,7 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
         timeoutAt: timeoutMillis === null ? null : enqueuedAt + timeoutMillis,
         timeoutMillis,
         timeoutTimer: undefined,
+        testDatabaseAccessScope: this.configuration.getEnvironmentHandler().currentTestDatabaseAccessScope(),
         testProfileContext: currentTestProfileContext(this.configuration)
       }
 
@@ -887,20 +929,23 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
     const environmentHandler = this.configuration.getEnvironmentHandler()
 
     return await environmentHandler.runWithTestProfileContext(checkout.testProfileContext, async () => {
-      let connection
-
-      try {
-        connection = await this.spawnConnectionForCheckout(
-          checkout.databaseConfig,
-          checkout.reuseKey,
-          checkout.testProfileContext
-        )
-      } catch (error) {
-        checkout.reject(error instanceof Error ? error : new Error("Failed to spawn database connection.", {cause: error}))
-        return
-      }
-
-      await this.resolvePendingCheckout(checkout, connection)
+      return await environmentHandler.runWithCapturedTestDatabaseAccessScope(checkout.testDatabaseAccessScope, async () => {
+        let connection
+
+        try {
+          this.assertDatabaseAccessAllowed()
+          connection = await this.spawnConnectionForCheckout(
+            checkout.databaseConfig,
+            checkout.reuseKey,
+            checkout.testProfileContext
+          )
+        } catch (error) {
+          checkout.reject(error instanceof Error ? error : new Error("Failed to spawn database connection.", {cause: error}))
+          return
+        }
+
+        await this.resolvePendingCheckout(checkout, connection)
+      })
     })
   }
 
@@ -914,11 +959,13 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
     const environmentHandler = this.configuration.getEnvironmentHandler()
 
     return await environmentHandler.runWithTestProfileContext(checkout.testProfileContext, async () => {
-      try {
-        checkout.resolve(await this.activateConnection(connection, checkout.options))
-      } catch (error) {
-        checkout.reject(error instanceof Error ? error : new Error("Failed to activate database connection.", {cause: error}))
-      }
+      return await environmentHandler.runWithCapturedTestDatabaseAccessScope(checkout.testDatabaseAccessScope, async () => {
+        try {
+          checkout.resolve(await this.activateConnection(connection, checkout.options))
+        } catch (error) {
+          checkout.reject(error instanceof Error ? error : new Error("Failed to activate database connection.", {cause: error}))
+        }
+      })
     })
   }
 
@@ -945,6 +992,7 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
    * @returns {Promise<T>} - Resolves with the callback result.
    */
   async withConnection(optionsOrCallback, callback) {
+    this.assertDatabaseAccessAllowed()
     const options = typeof optionsOrCallback == "function" ? {} : optionsOrCallback
     const actualCallback = typeof optionsOrCallback == "function" ? optionsOrCallback : callback
 
@@ -1046,6 +1094,7 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
    * @returns {import("../drivers/base.js").default} - The current connection.
    */
   getCurrentConnection() {
+    this.assertDatabaseAccessAllowed()
     const id = this.asyncLocalStorage.getStore()
 
     if (id === undefined) return this.currentFallbackConnectionOrFail()

package/build/database/pool/base.js

@@ -120,6 +120,11 @@ class VelociousDatabasePoolBase {
     this.logger = new Logger(this)
   }
 
+  /** Throws when a revoked test attempt tries to acquire database access. */
+  assertDatabaseAccessAllowed() {
+    this.configuration.assertDatabaseAccessAllowed()
+  }
+
   /**
    * Runs checkin.
    * @abstract

package/build/database/pool/single-multi-use.js

@@ -2,6 +2,7 @@
 
 import BasePool from "./base.js"
 import OperationLease from "../operation-lease.js"
+import {coordinateSharedTransactionConnection} from "../../testing/shared-transaction-connection-coordinator.js"
 
 /**
  * SinglePoolConnectionEntry type.
@@ -118,6 +119,7 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
    * @returns {Promise<import("../drivers/base.js").default>} - Checked-out connection.
    */
   async checkoutForConfiguration(databaseConfiguration, options = {}, {retain} = {retain: false}) {
+    this.assertDatabaseAccessAllowed()
     const reuseKey = this.getConfigurationReuseKey(databaseConfiguration)
     let entry = this.connectionEntries.get(reuseKey)
 
@@ -156,6 +158,22 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
       }
     }
     if (!entry) throw new Error("Database connection entry was not created")
+    if (this.connectionEntries.get(reuseKey) !== entry) {
+      return await this.checkoutForConfiguration(databaseConfiguration, options, {retain})
+    }
+
+    try {
+      this.assertDatabaseAccessAllowed()
+    } catch (error) {
+      if (entry.activeCheckoutCount === 0 && this.capacityWaiters.size > 0) {
+        try {
+          await this.removeAndCloseEntry(entry)
+        } catch (closeError) {
+          throw new AggregateError([error, closeError], "Database access revocation and connection close both failed", {cause: closeError})
+        }
+      }
+      throw error
+    }
 
     if (retain) {
       const previousConnection = this.connection
@@ -178,6 +196,17 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
     entry.activeCheckoutCount++
     this.activeCheckoutCount++
 
+    try {
+      this.assertDatabaseAccessAllowed()
+    } catch (error) {
+      try {
+        await this.checkin(entry.connection)
+      } catch (checkinError) {
+        throw new AggregateError([error, checkinError], "Database access revocation and connection check-in both failed", {cause: checkinError})
+      }
+      throw error
+    }
+
     return entry.connection
   }
 
@@ -380,21 +409,23 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
     const owner = Symbol("single-pool-operation-owner")
     const operationLease = new OperationLease(owner)
     const connection = await this.checkoutForConfiguration(databaseConfiguration, options, checkoutArgs)
-    let operationLeaseInstalled = false
 
     try {
-      await connection.setOperationLease(operationLease)
-      operationLeaseInstalled = true
+      return await coordinateSharedTransactionConnection(connection, async () => {
+        let operationLeaseInstalled = false
 
-      return await callback(connection, owner)
-    } finally {
-      operationLease.release()
+        try {
+          await connection.setOperationLease(operationLease)
+          operationLeaseInstalled = true
 
-      try {
-        if (operationLeaseInstalled) connection.clearOperationLease(operationLease)
-      } finally {
-        await this.checkin(connection)
-      }
+          return await callback(connection, owner)
+        } finally {
+          operationLease.release()
+          if (operationLeaseInstalled) connection.clearOperationLease(operationLease)
+        }
+      })
+    } finally {
+      await this.checkin(connection)
     }
   }
 
@@ -492,6 +523,7 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
    * @returns {import("../drivers/base.js").default} - Mutable ambient fallback connection.
    */
   getCurrentConnection() {
+    this.assertDatabaseAccessAllowed()
     if (!this.connection) throw new Error("A connection hasn't been made yet")
 
     return this.connection

package/build/database/record/attachments/store.js

@@ -103,32 +103,7 @@ export default class RecordAttachmentsStore {
 
     this._readyPromise = (async () => {
       await this._withDb(async (db) => {
-        db.clearSchemaCache()
-
-        if (await db.tableExists(ATTACHMENTS_TABLE)) {
-          await this.ensureAttachmentStoreSchema({db})
-          return
-        }
-
-        const table = new TableData(ATTACHMENTS_TABLE, {ifNotExists: true})
-
-        table.string("id", {null: false, primaryKey: true})
-        table.string("record_type", {null: false, index: true})
-        table.string("record_id", {null: false, index: true})
-        table.string("name", {null: false, index: true})
-        table.integer("position", {null: false})
-        table.string("filename", {null: false})
-        table.string("content_type", {null: true})
-        table.bigint("byte_size", {null: false})
-        table.string("driver", {null: true})
-        table.string("storage_key", {null: true})
-        table.text("content_base64", {null: true})
-        table.bigint("created_at_ms", {null: false})
-        table.bigint("updated_at_ms", {null: false})
-
-        await db.createTable(table)
-        this._driverColumnsAvailable = true
-        this._contentBase64Nullable = true
+        await this.ensureSchema(db)
       }, model)
     })()
 
@@ -139,6 +114,40 @@ export default class RecordAttachmentsStore {
     }
   }
 
+  /**
+   * Ensures attachment schema through an already-owned connection.
+   * @param {import("../../drivers/base.js").default} db - Database connection.
+   * @returns {Promise<void>} - Resolves when schema is ready.
+   */
+  async ensureSchema(db) {
+    db.clearSchemaCache()
+
+    if (await db.tableExists(ATTACHMENTS_TABLE)) {
+      await this.ensureAttachmentStoreSchema({db})
+      return
+    }
+
+    const table = new TableData(ATTACHMENTS_TABLE, {ifNotExists: true})
+
+    table.string("id", {null: false, primaryKey: true})
+    table.string("record_type", {null: false, index: true})
+    table.string("record_id", {null: false, index: true})
+    table.string("name", {null: false, index: true})
+    table.integer("position", {null: false})
+    table.string("filename", {null: false})
+    table.string("content_type", {null: true})
+    table.bigint("byte_size", {null: false})
+    table.string("driver", {null: true})
+    table.string("storage_key", {null: true})
+    table.text("content_base64", {null: true})
+    table.bigint("created_at_ms", {null: false})
+    table.bigint("updated_at_ms", {null: false})
+
+    await db.createTable(table)
+    this._driverColumnsAvailable = true
+    this._contentBase64Nullable = true
+  }
+
   /**
    * Runs attach.
    * @param {object} args - Options.

package/build/environment-handlers/base.js

@@ -18,6 +18,14 @@ import { validateTimeZone } from "../time-zone.js"
  * @property {string} migrationClassName - Exported migration class name.
  * @property {string} file - Migration filename.
  */
+/**
+ * TestDatabaseAccessScopeStorage type.
+ * @typedef {object} TestDatabaseAccessScopeStorage
+ * @property {() => ({revoked: boolean} | undefined)} getStore - Gets the inherited scope.
+ * @property {(scope: {revoked: boolean} | undefined, callback: () => ReturnType<typeof JSON.parse>) => ReturnType<typeof JSON.parse>} run - Runs in the scope.
+ */
+
+export class TestDatabaseAccessRevokedError extends Error {}
 
 export default class VelociousEnvironmentHandlerBase {
   /**
@@ -38,30 +46,49 @@ export default class VelociousEnvironmentHandlerBase {
 
   /**
    * Gets the active shared-transaction coordinator owner for a connection.
-   * Browser runtimes never install the Node test broker.
-   * @param {object} _connection - Parent physical connection.
+   * @param {object} connection - Parent physical connection.
    * @returns {symbol | undefined} - Active coordinator owner.
    */
-  getSharedTransactionCoordinatorOwner(_connection) { return undefined }
+  getSharedTransactionCoordinatorOwner(connection) {
+    return this._sharedTransactionCoordinatorOwnerStorage?.getStore()?.get(connection)
+  }
 
   /**
    * Runs work as the current shared-transaction coordinator owner.
    * @template T
-   * @param {object} _connection - Parent physical connection.
-   * @param {symbol} _owner - Coordinator owner.
+   * @param {object} connection - Parent physical connection.
+   * @param {symbol} owner - Coordinator owner.
    * @param {() => T} callback - Owned work.
    * @returns {T} - Callback result.
    */
-  runWithSharedTransactionCoordinatorOwner(_connection, _owner, callback) { return callback() }
+  runWithSharedTransactionCoordinatorOwner(connection, owner, callback) {
+    const storage = this._sharedTransactionCoordinatorOwnerStorage
+
+    if (!storage) return callback()
+
+    const owners = new Map(storage.getStore())
+
+    owners.set(connection, owner)
+    return storage.run(owners, callback)
+  }
 
   /**
    * Runs work without inherited shared-transaction ownership for one connection.
    * @template T
-   * @param {import("../database/drivers/base.js").default} _connection - Physical connection whose owner is cleared.
+   * @param {import("../database/drivers/base.js").default} connection - Physical connection whose owner is cleared.
    * @param {() => T} callback - Physical connection work.
    * @returns {T} - Callback result.
    */
-  runWithoutSharedTransactionCoordinatorOwner(_connection, callback) { return callback() }
+  runWithoutSharedTransactionCoordinatorOwner(connection, callback) {
+    const storage = this._sharedTransactionCoordinatorOwnerStorage
+
+    if (!storage) return callback()
+
+    const owners = new Map(storage.getStore())
+
+    owners.delete(connection)
+    return storage.run(owners, callback)
+  }
 
   /**
    * Runs work without inherited shared-transaction coordinator ownership.
@@ -69,7 +96,24 @@ export default class VelociousEnvironmentHandlerBase {
    * @param {() => T} callback - Detached work.
    * @returns {T} - Callback result.
    */
-  runWithoutSharedTransactionCoordinatorOwners(callback) { return callback() }
+  runWithoutSharedTransactionCoordinatorOwners(callback) {
+    const storage = this._sharedTransactionCoordinatorOwnerStorage
+
+    if (!storage) return callback()
+
+    return storage.run(new Map(), callback)
+  }
+
+  /**
+   * Installs async-context storage when this handler is driven by the Node test runner.
+   * @param {import("node:async_hooks").AsyncLocalStorage<Map<object, symbol>>} storage - Coordinator owner storage.
+   */
+  installSharedTransactionCoordinatorOwnerStorage(storage) {
+    this._sharedTransactionCoordinatorOwnerStorage ??= storage
+  }
+
+  /** @type {import("node:async_hooks").AsyncLocalStorage<Map<object, symbol>> | undefined} */
+  _sharedTransactionCoordinatorOwnerStorage = undefined
 
   /**
    * Runs work with test-profile attribution. Runtimes without async-context
@@ -87,6 +131,75 @@ export default class VelociousEnvironmentHandlerBase {
    */
   getCurrentTestProfileContext() { return undefined }
 
+  /**
+   * Runs work in a revocable test database-access scope.
+   * @template T
+   * @param {{revoked: boolean}} scope - Attempt-owned access scope.
+   * @param {() => T | Promise<T>} callback - Attempt work.
+   * @returns {Promise<T>} - Callback result.
+   */
+  async runWithTestDatabaseAccessScope(scope, callback) {
+    return await this.runWithCapturedTestDatabaseAccessScope(scope, callback)
+  }
+
+  /**
+   * Runs work with an explicitly captured test database-access scope.
+   * @template T
+   * @param {{revoked: boolean} | undefined} scope - Captured access scope.
+   * @param {() => T | Promise<T>} callback - Work to run.
+   * @returns {Promise<T>} - Callback result.
+   */
+  async runWithCapturedTestDatabaseAccessScope(scope, callback) {
+    if (this._testDatabaseAccessScopeStorage) {
+      return await this._testDatabaseAccessScopeStorage.run(scope, callback)
+    }
+
+    const entry = {owner: Symbol("test-database-access-scope"), scope}
+
+    this._testDatabaseAccessScopes.push(entry)
+
+    try {
+      return await callback()
+    } finally {
+      const index = this._testDatabaseAccessScopes.findIndex((candidate) => candidate.owner === entry.owner)
+
+      if (index !== -1) this._testDatabaseAccessScopes.splice(index, 1)
+    }
+  }
+
+  /**
+   * Gets the current test database-access scope.
+   * @returns {{revoked: boolean} | undefined} - Current scope.
+   */
+  currentTestDatabaseAccessScope() {
+    if (this._testDatabaseAccessScopeStorage) return this._testDatabaseAccessScopeStorage.getStore()
+
+    return this._testDatabaseAccessScopes[this._testDatabaseAccessScopes.length - 1]?.scope
+  }
+
+  /** Throws when the current test attempt no longer owns database access. */
+  assertTestDatabaseAccessAllowed() {
+    const scope = this.currentTestDatabaseAccessScope()
+
+    if (scope?.revoked) {
+      throw new TestDatabaseAccessRevokedError("Database access is no longer allowed for this test attempt")
+    }
+  }
+
+  /**
+   * Installs async-context storage owned by the first Node test runner.
+   * @param {TestDatabaseAccessScopeStorage} storage - Scope storage.
+   */
+  installTestDatabaseAccessScopeStorage(storage) {
+    this._testDatabaseAccessScopeStorage ??= storage
+  }
+
+  /** @type {Array<{owner: symbol, scope: {revoked: boolean} | undefined}>} */
+  _testDatabaseAccessScopes = []
+
+  /** @type {TestDatabaseAccessScopeStorage | undefined} */
+  _testDatabaseAccessScopeStorage = undefined
+
   /**
    * Mutable ambient tenant used by runtimes without async-context storage.
    * @type {ReturnType<typeof JSON.parse> | undefined}

package/build/environment-handlers/node.js

@@ -39,6 +39,7 @@ import { timingSafeEqual } from "node:crypto"
 import requireContext from "require-context"
 import AsyncTrackedMultiConnectionPool from "../database/pool/async-tracked-multi-connection.js"
 import InitializerFromRequireContext from "../database/initializer-from-require-context.js"
+import RecordAttachmentsStore from "../database/record/attachments/store.js"
 import toImportSpecifier from "../utils/to-import-specifier.js"
 import { validateTimeZone } from "../time-zone.js"
 import AttachmentPathSource from "./node/attachment-path-source.js"
@@ -1213,21 +1214,26 @@ export default class VelociousEnvironmentHandlerNode extends Base{
   }
 
   /**
-   * Ensures velocious' background-jobs schema exists on its configured database
-   * as part of `db:migrate`, so the framework's own tables (background_jobs +
-   * background_job_concurrency, execution_mode etc.) are created deterministically
-   * alongside app migrations and captured in the dumped structure SQL — rather than
-   * only appearing once a runtime store boots. Reuses the store's idempotent
-   * `_ensureSchema`, so it's safe to re-run against DBs that already have it.
+   * Ensures Velocious framework schema exists as part of `db:migrate`, so internal
+   * tables are created deterministically alongside app migrations and captured in
+   * the dumped structure SQL instead of appearing only when runtime stores boot.
    * @param {object} args - Options object.
    * @param {Record<string, import("../database/drivers/base.js").default>} args.dbs - Dbs being migrated.
    * @returns {Promise<void>} - Resolves when complete.
    */
   async ensureFrameworkSchema({dbs}) {
     // Migration passes its already checked-out DB into the adapter hook. Do not
-    // run runtime readiness here: SQL readiness would open a nested checkout and
-    // can deadlock a single-connection migration pool.
-    const adapter = this.getConfiguration().getBackgroundJobsAdapter()
+    // run runtime readiness here: it would open a nested checkout and can deadlock
+    // a single-connection migration pool.
+    const configuration = this.getConfiguration()
+
+    for (const [databaseIdentifier, db] of Object.entries(dbs)) {
+      const attachmentStore = new RecordAttachmentsStore({configuration, databaseIdentifier})
+
+      await attachmentStore.ensureSchema(db)
+    }
+
+    const adapter = configuration.getBackgroundJobsAdapter()
 
     await adapter.ensureFrameworkSchema({dbs})
   }

package/build/http-server/websocket-events-host.js

@@ -155,15 +155,17 @@ export class VelociousHttpServerWebsocketEventsHost {
     const handler = this.handlers.values().next().value
     const configuration = originatingConfiguration || handler?.configuration
     const previousTail = this.publishQueuesByChannel.get(channel) || Promise.resolve()
+    let queuedPublish
+
+    if (configuration) {
+      queuedPublish = previousTail.then(() => configuration.withoutCurrentTestDatabaseAccessScope(() => {
+        return configuration.withoutCurrentConnectionContexts(callback)
+      }))
+    } else {
+      queuedPublish = previousTail.then(callback)
+    }
 
-    const tail = previousTail
-      .then(async () => {
-        if (configuration) {
-          return await configuration.withoutCurrentConnectionContexts(callback)
-        }
-
-        return await callback()
-      })
+    const tail = queuedPublish
       .catch((error) => {
         console.error(errorMessage, error)
         throw error

package/build/src/background-jobs/lifecycle-client.d.ts

@@ -1,3 +1,4 @@
+export declare const MAX_LIFECYCLE_REQUEST_TIMEOUT_MS = 60000;
 /** One-request acknowledged lifecycle client. */
 export default class BackgroundJobsLifecycleClient {
     generationId: string;

package/build/src/background-jobs/lifecycle-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle-client.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/lifecycle-client.js"],"names":[],"mappings":"AAUA,iDAAiD;AACjD,MAAM,CAAC,OAAO,OAAO,6BAA6B;IAezC,YAAY;IACZ,UAAU;IAIV,gBAAgB;IAnBvB;;;;;;;OAOG;IACH,YAAY,EAAC,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,gBAA6C,EAAC,EALjG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAAsB,YAAY,AAAlC,CACA,EADQ,MAAM,CACd;QAAsB,UAAU,AAAhC,CACA,EADQ,MAAM,CACd;QAAsB,gBAAgB,AAAtC,CACF,EADU,MAAM,CAChB;KACmG,EAcnG;IAED;;;OAGG;IACG,QAAQ,IAFD,OAAO,CAAC,OAAO,YAAY,EAAE,sCAAsC,CAAC,CAEtB;IAE3D;;;OAGG;IACG,MAAM,IAFC,OAAO,CAAC,OAAO,YAAY,EAAE,sCAAsC,CAAC,CAE1B;IAEvD;;;;OAIG;IACG,QAAQ,CAAC,MAAM,EAHV,UAAU,GAAG,QAGH,GAFR,OAAO,CAAC,OAAO,YAAY,EAAE,sCAAsC,CAAC,CAOhF;IAED;;;;;;OAMG;IACG,WAAW,CAAC,EAAC,MAAM,EAAE,MAAM,EAAC,EAJ/B;QAAoC,MAAM,EAAlC,UAAU,GAAG,QAAQ,CAC7B;QAA0B,MAAM,EAAxB,WAAW,CACnB;KAE+B,GAFrB,OAAO,CAAC,OAAO,YAAY,EAAE,sCAAsC,CAAC,CA4DhF;CACF"}
+{"version":3,"file":"lifecycle-client.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/lifecycle-client.js"],"names":[],"mappings":"AAQA,eAAO,MAAM,gCAAgC,QAAQ,CAAA;AAErD,iDAAiD;AACjD,MAAM,CAAC,OAAO,OAAO,6BAA6B;IAezC,YAAY;IACZ,UAAU;IAIV,gBAAgB;IAnBvB;;;;;;;OAOG;IACH,YAAY,EAAC,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,gBAA6C,EAAC,EALjG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAAsB,YAAY,AAAlC,CACA,EADQ,MAAM,CACd;QAAsB,UAAU,AAAhC,CACA,EADQ,MAAM,CACd;QAAsB,gBAAgB,AAAtC,CACF,EADU,MAAM,CAChB;KACmG,EAcnG;IAED;;;OAGG;IACG,QAAQ,IAFD,OAAO,CAAC,OAAO,YAAY,EAAE,sCAAsC,CAAC,CAEtB;IAE3D;;;OAGG;IACG,MAAM,IAFC,OAAO,CAAC,OAAO,YAAY,EAAE,sCAAsC,CAAC,CAE1B;IAEvD;;;;OAIG;IACG,QAAQ,CAAC,MAAM,EAHV,UAAU,GAAG,QAGH,GAFR,OAAO,CAAC,OAAO,YAAY,EAAE,sCAAsC,CAAC,CAOhF;IAED;;;;;;OAMG;IACG,WAAW,CAAC,EAAC,MAAM,EAAE,MAAM,EAAC,EAJ/B;QAAoC,MAAM,EAAlC,UAAU,GAAG,QAAQ,CAC7B;QAA0B,MAAM,EAAxB,WAAW,CACnB;KAE+B,GAFrB,OAAO,CAAC,OAAO,YAAY,EAAE,sCAAsC,CAAC,CA4DhF;CACF"}