velocious 1.0.574 → 1.0.576

package/build/database/advisory-lock-runner.js

@@ -52,7 +52,8 @@ class AdvisoryLockHoldTimeoutError extends Error {
 
 /**
  * Runs advisory locks on the caller connection by default, using a dedicated
- * lock connection only when a positive hold timeout needs separate ownership.
+ * lock connection when `dedicatedConnection` is requested or when a positive
+ * hold timeout needs separate ownership.
  */
 export default class AdvisoryLockRunner {
   /**
@@ -67,17 +68,21 @@ export default class AdvisoryLockRunner {
 
   /**
    * Runs a callback after acquiring the advisory lock, waiting up to `timeoutMs`.
-   * When a `holdTimeoutMs` is set the callback receives a `TimeoutControl` from
-   * awaitery for cooperative cancellation (`control.check()`, `control.signal`,
-   * `control.timedOut`, `control.remaining()`).
+   * When `dedicatedConnection` is true the lock is acquired on a spawned
+   * connection that is released after the callback finishes, while the callback
+   * itself still runs against the caller/model connection. When a `holdTimeoutMs`
+   * is set the callback receives a `TimeoutControl` from awaitery for cooperative
+   * cancellation (`control.check()`, `control.signal`, `control.timedOut`,
+   * `control.remaining()`); a dedicated connection is also used so timeout
+   * cleanup can release the lock even if callback database work is stuck.
    * @template T
    * @param {string} name - Lock name.
    * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
-   * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null}} [args] - Lock and hold timeout options.
+   * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null, dedicatedConnection?: boolean}} [args] - Lock and hold timeout options.
    * @returns {Promise<T>} - Resolves with the callback result.
    */
   async withAdvisoryLock(name, callback, args = {}) {
-    return await this.withLockConnection(args.holdTimeoutMs, async (connection) => {
+    return await this.withLockConnection(args, async (connection) => {
       const acquired = await connection.acquireAdvisoryLock(name, args)
 
       if (!acquired) {
@@ -90,16 +95,19 @@ export default class AdvisoryLockRunner {
 
   /**
    * Runs a callback only if the advisory lock can be acquired immediately.
-   * When a `holdTimeoutMs` is set the callback receives a `TimeoutControl` from
-   * awaitery for cooperative cancellation.
+   * When `dedicatedConnection` is true the lock is acquired on a spawned
+   * connection that is released after the callback finishes, while the callback
+   * itself still runs against the caller/model connection. When a `holdTimeoutMs`
+   * is set the callback receives a `TimeoutControl` from awaitery for cooperative
+   * cancellation.
    * @template T
    * @param {string} name - Lock name.
    * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
-   * @param {{holdTimeoutMs?: number | null}} [args] - Hold timeout options.
+   * @param {{holdTimeoutMs?: number | null, dedicatedConnection?: boolean}} [args] - Hold timeout options.
    * @returns {Promise<T>} - Resolves with the callback result.
    */
   async withAdvisoryLockOrFail(name, callback, args = {}) {
-    return await this.withLockConnection(args.holdTimeoutMs, async (connection) => {
+    return await this.withLockConnection(args, async (connection) => {
       const acquired = await connection.tryAcquireAdvisoryLock(name)
 
       if (!acquired) {
@@ -125,15 +133,17 @@ export default class AdvisoryLockRunner {
   }
 
   /**
-   * Runs lock work on the caller connection unless a positive hold timeout needs
-   * its own lock connection.
+   * Runs lock work on the caller connection unless `dedicatedConnection` is
+   * requested or a positive hold timeout needs its own lock connection.
    * @template T
-   * @param {number | null | undefined} holdTimeoutMs - Max hold time; positive values use a dedicated lock connection.
+   * @param {{dedicatedConnection?: boolean, holdTimeoutMs?: number | null}} args - Lock connection options.
    * @param {(connection: import("./drivers/base.js").default) => Promise<T>} callback - Callback receiving the connection that owns the advisory lock.
    * @returns {Promise<T>} - Resolves with the callback result.
    */
-  async withLockConnection(holdTimeoutMs, callback) {
-    if (holdTimeoutMs && holdTimeoutMs > 0) {
+  async withLockConnection(args, callback) {
+    const holdTimeoutMs = args.holdTimeoutMs
+
+    if (args.dedicatedConnection || (holdTimeoutMs && holdTimeoutMs > 0)) {
       return await this.withDedicatedConnection(callback)
     }
 
@@ -141,8 +151,8 @@ export default class AdvisoryLockRunner {
   }
 
   /**
-   * Spawns a hold-timeout lock connection and closes it after lock work completes when
-   * the spawned driver owns the underlying physical connection.
+   * Spawns a dedicated lock connection and closes it after lock work completes
+   * when the spawned driver owns the underlying physical connection.
    * @template T
    * @param {(connection: import("./drivers/base.js").default) => Promise<T>} callback - Callback that receives the dedicated lock connection.
    * @returns {Promise<T>} - Resolves with the callback result.

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

@@ -35,6 +35,9 @@ import UUID from "pure-uuid"
 const APPLOCK_NOT_HELD_ERROR_NUMBER = 1223
 
 export default class VelociousDatabaseDriversMssql extends Base{
+  /** @type {import("mssql").Transaction | null} */
+  _advisoryLockTransaction = null
+
   async connect() {
     const args = this.getArgs()
     const sqlConfig = digg(args, "sqlConfig")
@@ -65,12 +68,22 @@ export default class VelociousDatabaseDriversMssql extends Base{
     this.connection = undefined
     this._currentTransaction = null
     this._transactionsCount = 0
+    /** @type {Error | undefined} */
+    let sessionError
+
+    try {
+      await this._closeAdvisoryLockTransaction()
+    } catch (error) {
+      sessionError = error instanceof Error ? error : new Error("Failed to close MSSQL advisory-lock session", {cause: error})
+    }
 
     try {
       await timeout({timeout: 2000}, () => connection.close())
     } catch (error) {
       this.logger.warn("Failed to close MSSQL connection cleanly", {error})
     }
+
+    if (sessionError) throw sessionError
   }
 
   /**
@@ -662,12 +675,15 @@ export default class VelociousDatabaseDriversMssql extends Base{
    */
   async _acquireAdvisoryLock(name, {timeoutMs} = {}) {
     const timeoutValue = typeof timeoutMs === "number" && timeoutMs >= 0 ? Math.ceil(timeoutMs) : -1
-    const rows = await this.query(
+    const rows = await this._advisoryLockQuery(
       `DECLARE @velocious_advisory_lock_result INT; EXEC @velocious_advisory_lock_result = sp_getapplock @Resource = ${this.quote(name)}, @LockMode = 'Exclusive', @LockOwner = 'Session', @LockTimeout = ${timeoutValue}; SELECT @velocious_advisory_lock_result AS velocious_advisory_lock_result`
     )
     const result = Number(rows?.[0]?.velocious_advisory_lock_result)
 
     if (result === 0 || result === 1) return true
+
+    await this._closeAdvisoryLockTransaction()
+
     if (result === -1) return false
 
     throw new Error(`sp_getapplock returned ${result} for advisory lock ${JSON.stringify(name)} (see SQL Server documentation for sp_getapplock return codes)`)
@@ -698,20 +714,99 @@ export default class VelociousDatabaseDriversMssql extends Base{
     let rows
 
     try {
-      rows = await this.query(
+      rows = await this._advisoryLockQuery(
         `DECLARE @velocious_advisory_lock_result INT; EXEC @velocious_advisory_lock_result = sp_releaseapplock @Resource = ${this.quote(name)}, @LockOwner = 'Session'; SELECT @velocious_advisory_lock_result AS velocious_advisory_lock_result`
       )
     } catch (error) {
-      if (this._isApplockNotHeldError(error)) return false
+      if (this._isApplockNotHeldError(error)) {
+        await this._closeAdvisoryLockTransactionIfFinalRelease()
+
+        return false
+      }
 
       throw error
     }
 
     const result = Number(rows?.[0]?.velocious_advisory_lock_result)
 
+    await this._closeAdvisoryLockTransactionIfFinalRelease()
+
     return result === 0
   }
 
+  /**
+   * Runs an advisory-lock statement through one transaction request parent.
+   * node-mssql reserves one physical session for a Transaction, whereas
+   * separate ConnectionPool requests may check out different sessions. The
+   * transaction contains only application-lock statements; caller/model work
+   * continues through its original connection.
+   * @param {string} sql - Advisory-lock SQL.
+   * @returns {Promise<import("../base.js").QueryResultType>} - Result rows.
+   */
+  async _advisoryLockQuery(sql) {
+    const transaction = await this._ensureAdvisoryLockTransaction()
+
+    try {
+      const request = new mssql.Request(transaction)
+      const result = await request.query(sql)
+
+      return Array.isArray(result.recordsets) ? result.recordsets[0] || [] : []
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Query failed '${error.message}': ${sql}`, {cause: error})
+      }
+
+      throw new Error(`Query failed '${error}': ${sql}`, {cause: error})
+    }
+  }
+
+  /**
+   * Starts the transaction request parent that reserves the advisory-lock
+   * session until the final release or driver close.
+   * @returns {Promise<import("mssql").Transaction>} - Session-affine parent.
+   */
+  async _ensureAdvisoryLockTransaction() {
+    if (this._advisoryLockTransaction) return this._advisoryLockTransaction
+    if (!this.connection) await this.connect()
+    if (!this.connection) throw new Error("MSSQL connection unavailable for advisory lock")
+
+    const transaction = new mssql.Transaction(this.connection)
+
+    await transaction.begin()
+    this._advisoryLockTransaction = transaction
+
+    return transaction
+  }
+
+  /**
+   * Releases the reserved session after the last tracked lock release.
+   * Base untracks the current release after the driver hook returns, so a
+   * current total of one means this is the final release.
+   * @returns {Promise<void>} - Resolves after cleanup when this is final.
+   */
+  async _closeAdvisoryLockTransactionIfFinalRelease() {
+    let heldCount = 0
+
+    for (const count of this._heldAdvisoryLocks.values()) heldCount += count
+
+    if (heldCount <= 1) await this._closeAdvisoryLockTransaction()
+  }
+
+  /**
+   * Rolls back the otherwise-empty transaction and returns its physical
+   * session to node-mssql. Rollback is cleanup only; advisory locks are
+   * explicitly released first whenever their release statement succeeds.
+   * @returns {Promise<void>} - Resolves after session cleanup.
+   */
+  async _closeAdvisoryLockTransaction() {
+    const transaction = this._advisoryLockTransaction
+
+    if (!transaction) return
+
+    this._advisoryLockTransaction = null
+    await transaction.rollback()
+  }
+
   /**
    * Detects the SQL Server "application lock is not currently held" error
    * raised by `sp_releaseapplock`. It walks the wrapped-error cause chain

package/build/database/record/index.js

@@ -2677,12 +2677,14 @@ class VelociousDatabaseRecord {
 
   /**
    * Runs the callback while holding a named advisory lock. Calls without
-   * a positive `holdTimeoutMs` use the caller connection; calls with a positive
-   * `holdTimeoutMs` use a dedicated lock connection so timeout cleanup can
-   * release the lock even when callback database work is stuck. Advisory locks
-   * are cooperative and session-scoped: they serialize callers that opt into
-   * the same `name`, without touching row or table locks, so unrelated traffic
-   * is free to proceed.
+   * By default calls use the caller connection. Calls with `dedicatedConnection`
+   * use a spawned lock connection that is released after the callback finishes,
+   * while the callback itself still runs against the caller/model connection.
+   * Calls with a positive `holdTimeoutMs` use a dedicated lock connection so
+   * timeout cleanup can release the lock even when callback database work is
+   * stuck. Advisory locks are cooperative and session-scoped: they serialize
+   * callers that opt into the same `name`, without touching row or table locks,
+   * so unrelated traffic is free to proceed.
    *
    * The lock is acquired before the callback runs and released in a
    * `finally` block afterwards, so the callback's return value is
@@ -2690,7 +2692,7 @@ class VelociousDatabaseRecord {
    * @template T
    * @param {string} name - Lock name.
    * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
-   * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null}} [args] - `timeoutMs` caps how long we wait to acquire the lock; `holdTimeoutMs` caps how long the callback may hold it before the lock is released and `AdvisoryLockHoldTimeoutError` is thrown.
+   * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null, dedicatedConnection?: boolean}} [args] - `timeoutMs` caps how long we wait to acquire the lock; `holdTimeoutMs` caps how long the callback may hold it before the lock is released and `AdvisoryLockHoldTimeoutError` is thrown; `dedicatedConnection` spawns a separate lock session without enabling a hold timeout.
    * @returns {Promise<T>} - Resolves with the callback's return value.
    * @throws {AdvisoryLockTimeoutError} - If `timeoutMs` elapses before the lock is granted.
    * @throws {AdvisoryLockHoldTimeoutError} - If `holdTimeoutMs` elapses while the callback holds the lock.
@@ -2716,7 +2718,7 @@ class VelociousDatabaseRecord {
    * @template T
    * @param {string} name - Lock name.
    * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
-   * @param {{holdTimeoutMs?: number | null}} [args] - `holdTimeoutMs` caps how long the callback may hold the lock before it is released and `AdvisoryLockHoldTimeoutError` is thrown.
+   * @param {{holdTimeoutMs?: number | null, dedicatedConnection?: boolean}} [args] - `holdTimeoutMs` caps how long the callback may hold the lock before it is released and `AdvisoryLockHoldTimeoutError` is thrown; `dedicatedConnection` spawns a separate lock session without enabling a hold timeout.
    * @returns {Promise<T>} - Resolves with the callback's return value.
    * @throws {AdvisoryLockBusyError} - If the lock is already held.
    * @throws {AdvisoryLockHoldTimeoutError} - If `holdTimeoutMs` elapses while the callback holds the lock.

package/build/database/table-data/table-column.js

@@ -349,6 +349,8 @@ export default class TableColumn {
 
     if (precision !== undefined && precision !== null) {
       sql += scale !== undefined && scale !== null ? `(${precision}, ${scale})` : `(${precision})`
+    } else if (databaseType == "mysql" && type == "DATETIME") {
+      sql += "(3)"
     } else if (type && maxlength !== undefined && maxlength !== null) {
       sql += `(${maxlength})`
     }

package/build/frontend-models/resource-definition.js

@@ -3,6 +3,7 @@
 import * as inflection from "inflection"
 import FrontendModelBaseResource from "../frontend-model-resource/base-resource.js"
 import restArgsError from "../utils/rest-args-error.js"
+import sha256Hex from "../utils/sha256-hex.js"
 import {validateFrontendModelResourceCommandName} from "./resource-config-validation.js"
 
 /**
@@ -13,28 +14,6 @@ import {validateFrontendModelResourceCommandName} from "./resource-config-valida
  * @property {import("../configuration-types.js").NormalizedFrontendModelResourceConfiguration} resourceConfiguration - Normalized resource configuration.
  */
 const BASE_FRONTEND_MODEL_ABILITY_ACTIONS = ["create", "destroy", "read", "update"]
-const SHA256_INITIAL_HASH = [
-  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
-  0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
-]
-const SHA256_K = [
-  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
-  0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
-  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
-  0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
-  0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
-  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
-  0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
-  0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
-  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
-]
 const RESOURCE_STATIC_CONFIG_KEYS = new Set([
   "abilities",
   "attachments",
@@ -529,122 +508,6 @@ function syncPolicyHash(value) {
   return `sha256-${sha256Hex(stableJsonStringify(value))}`
 }
 
-/**
- * Computes SHA-256 without importing Node-only crypto modules, keeping this
- * resource-definition module safe for Expo/browser bundles.
- * @param {string} message - UTF-8 message.
- * @returns {string} - Hex digest.
- */
-function sha256Hex(message) {
-  const bytes = utf8Bytes(message)
-  const padded = [...bytes]
-  const bitLength = bytes.length * 8
-  const hash = [...SHA256_INITIAL_HASH]
-  /** @type {number[]} */
-  const words = new Array(64)
-
-  padded.push(0x80)
-  while (padded.length % 64 !== 56) padded.push(0)
-
-  const highLength = Math.floor(bitLength / 0x100000000)
-  const lowLength = bitLength >>> 0
-
-  for (const value of [highLength, lowLength]) {
-    padded.push((value >>> 24) & 0xff, (value >>> 16) & 0xff, (value >>> 8) & 0xff, value & 0xff)
-  }
-
-  for (let offset = 0; offset < padded.length; offset += 64) {
-    for (let i = 0; i < 16; i++) {
-      const index = offset + (i * 4)
-
-      words[i] = (((padded[index] || 0) << 24) | ((padded[index + 1] || 0) << 16) | ((padded[index + 2] || 0) << 8) | (padded[index + 3] || 0)) >>> 0
-    }
-
-    for (let i = 16; i < 64; i++) {
-      const s0 = rotateRight(words[i - 15], 7) ^ rotateRight(words[i - 15], 18) ^ (words[i - 15] >>> 3)
-      const s1 = rotateRight(words[i - 2], 17) ^ rotateRight(words[i - 2], 19) ^ (words[i - 2] >>> 10)
-
-      words[i] = add32(words[i - 16], s0, words[i - 7], s1)
-    }
-
-    let [a, b, c, d, e, f, g, h] = hash
-
-    for (let i = 0; i < 64; i++) {
-      const s1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25)
-      const ch = (e & f) ^ ((~e) & g)
-      const temp1 = add32(h, s1, ch, SHA256_K[i], words[i])
-      const s0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22)
-      const maj = (a & b) ^ (a & c) ^ (b & c)
-      const temp2 = add32(s0, maj)
-
-      h = g
-      g = f
-      f = e
-      e = add32(d, temp1)
-      d = c
-      c = b
-      b = a
-      a = add32(temp1, temp2)
-    }
-
-    hash[0] = add32(hash[0], a)
-    hash[1] = add32(hash[1], b)
-    hash[2] = add32(hash[2], c)
-    hash[3] = add32(hash[3], d)
-    hash[4] = add32(hash[4], e)
-    hash[5] = add32(hash[5], f)
-    hash[6] = add32(hash[6], g)
-    hash[7] = add32(hash[7], h)
-  }
-
-  return hash.map((value) => value.toString(16).padStart(8, "0")).join("")
-}
-
-/**
- * Converts a string to UTF-8 bytes.
- * @param {string} value - String value.
- * @returns {number[]} - UTF-8 bytes.
- */
-function utf8Bytes(value) {
-  /** @type {number[]} */
-  const bytes = []
-
-  for (const character of value) {
-    const codePoint = /** @type {number} */ (character.codePointAt(0))
-
-    if (codePoint <= 0x7f) {
-      bytes.push(codePoint)
-    } else if (codePoint <= 0x7ff) {
-      bytes.push(0xc0 | (codePoint >>> 6), 0x80 | (codePoint & 0x3f))
-    } else if (codePoint <= 0xffff) {
-      bytes.push(0xe0 | (codePoint >>> 12), 0x80 | ((codePoint >>> 6) & 0x3f), 0x80 | (codePoint & 0x3f))
-    } else {
-      bytes.push(0xf0 | (codePoint >>> 18), 0x80 | ((codePoint >>> 12) & 0x3f), 0x80 | ((codePoint >>> 6) & 0x3f), 0x80 | (codePoint & 0x3f))
-    }
-  }
-
-  return bytes
-}
-
-/**
- * Adds unsigned 32-bit integers.
- * @param {...number} values - Values to add.
- * @returns {number} - Unsigned 32-bit result.
- */
-function add32(...values) {
-  return values.reduce((sum, value) => (sum + value) >>> 0, 0)
-}
-
-/**
- * Rotates a 32-bit integer right.
- * @param {number} value - Value to rotate.
- * @param {number} bits - Bit count.
- * @returns {number} - Rotated value.
- */
-function rotateRight(value, bits) {
-  return (value >>> bits) | (value << (32 - bits))
-}
-
 /**
  * Validates that a sync config subtree is deterministic JSON and does not contain obvious secrets.
  * @param {object} args - Arguments.

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

@@ -8,6 +8,11 @@ export default class BackgroundJobsClient {
         configuration?: import("../configuration.js").default | undefined;
     });
     configurationPromise: Promise<import("../configuration.js").default>;
+    /**
+     * Builds a one-shot client socket request from the resolved configuration.
+     * @returns {Promise<BackgroundJobsSocketRequest>} - Socket request.
+     */
+    _request(): Promise<BackgroundJobsSocketRequest>;
     /**
      * Runs enqueue.
      * @param {object} args - Options.
@@ -21,5 +26,30 @@ export default class BackgroundJobsClient {
         args: Array<unknown>;
         options?: import("./types.js").BackgroundJobOptions | undefined;
     }): Promise<string>;
+    /**
+     * Atomically replaces the queued owner of a stable schedule key.
+     * @param {object} args - Options.
+     * @param {string} args.scheduleKey - Stable logical schedule key.
+     * @param {string} args.jobName - Job name.
+     * @param {Array<?>} args.args - Job args.
+     * @param {import("./types.js").BackgroundJobOptions} [args.options] - Job options.
+     * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Replacement result.
+     */
+    replaceScheduled({ scheduleKey, jobName, args, options }: {
+        scheduleKey: string;
+        jobName: string;
+        args: Array<unknown>;
+        options?: import("./types.js").BackgroundJobOptions | undefined;
+    }): Promise<import("./types.js").BackgroundJobReplacementResult>;
+    /**
+     * Cancels or detaches the current owner of a stable schedule key.
+     * @param {object} args - Options.
+     * @param {string} args.scheduleKey - Stable logical schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Cancellation result.
+     */
+    cancelScheduled({ scheduleKey }: {
+        scheduleKey: string;
+    }): Promise<import("./types.js").BackgroundJobCancellationResult>;
 }
+import BackgroundJobsSocketRequest from "./socket-request.js";
 //# sourceMappingURL=client.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/client.js"],"names":[],"mappings":"AAKA;IACE;;;;OAIG;IACH,gCAFG;QAAqD,aAAa;KACpE,EAGA;IADC,qEAAoG;IAGtG;;;;;;;OAOG;IACH,oCALG;QAAqB,OAAO,EAApB,MAAM;QACS,IAAI,EAAnB,KAAK,CAAC,OAAC,CAAC;QACyC,OAAO;KAChE,GAAU,OAAO,CAAC,MAAM,CAAC,CA2B3B;CACF"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/client.js"],"names":[],"mappings":"AAKA;IACE;;;;OAIG;IACH,gCAFG;QAAqD,aAAa;KACpE,EAGA;IADC,qEAAoG;IAGtG;;;OAGG;IACH,YAFa,OAAO,CAAC,2BAA2B,CAAC,CAOhD;IAED;;;;;;;OAOG;IACH,oCALG;QAAqB,OAAO,EAApB,MAAM;QACS,IAAI,EAAnB,KAAK,CAAC,OAAC,CAAC;QACyC,OAAO;KAChE,GAAU,OAAO,CAAC,MAAM,CAAC,CAyB3B;IAED;;;;;;;;OAQG;IACH,0DANG;QAAqB,WAAW,EAAxB,MAAM;QACO,OAAO,EAApB,MAAM;QACS,IAAI,EAAnB,KAAK,CAAC,OAAC,CAAC;QACyC,OAAO;KAChE,GAAU,OAAO,CAAC,OAAO,YAAY,EAAE,8BAA8B,CAAC,CAwBxE;IAED;;;;;OAKG;IACH,iCAHG;QAAqB,WAAW,EAAxB,MAAM;KACd,GAAU,OAAO,CAAC,OAAO,YAAY,EAAE,+BAA+B,CAAC,CAoBzE;CACF;wCAlHuC,qBAAqB"}

package/build/src/background-jobs/client.js

@@ -10,6 +10,15 @@ export default class BackgroundJobsClient {
     constructor({ configuration } = {}) {
         this.configurationPromise = configuration ? Promise.resolve(configuration) : configurationResolver();
     }
+    /**
+     * Builds a one-shot client socket request from the resolved configuration.
+     * @returns {Promise<BackgroundJobsSocketRequest>} - Socket request.
+     */
+    async _request() {
+        const configuration = await this.configurationPromise;
+        const { host, port } = configuration.getBackgroundJobsConfig();
+        return new BackgroundJobsSocketRequest({ host, port, role: "client" });
+    }
     /**
      * Runs enqueue.
      * @param {object} args - Options.
@@ -19,9 +28,7 @@ export default class BackgroundJobsClient {
      * @returns {Promise<string>} - Job id.
      */
     async enqueue({ jobName, args, options }) {
-        const configuration = await this.configurationPromise;
-        const { host, port } = configuration.getBackgroundJobsConfig();
-        const request = new BackgroundJobsSocketRequest({ host, port, role: "client" });
+        const request = await this._request();
         return await request.run({
             onConnect: (jsonSocket) => {
                 jsonSocket.send({
@@ -42,5 +49,58 @@ export default class BackgroundJobsClient {
             }
         });
     }
+    /**
+     * Atomically replaces the queued owner of a stable schedule key.
+     * @param {object} args - Options.
+     * @param {string} args.scheduleKey - Stable logical schedule key.
+     * @param {string} args.jobName - Job name.
+     * @param {Array<?>} args.args - Job args.
+     * @param {import("./types.js").BackgroundJobOptions} [args.options] - Job options.
+     * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Replacement result.
+     */
+    async replaceScheduled({ scheduleKey, jobName, args, options }) {
+        const request = await this._request();
+        return await request.run({
+            onConnect: (jsonSocket) => {
+                jsonSocket.send({ type: "replace-scheduled", scheduleKey, jobName, args, options });
+            },
+            onMessage: ({ message, resolve, reject }) => {
+                if (message?.type === "schedule-replaced") {
+                    resolve({
+                        jobId: message.jobId,
+                        previousJobId: message.previousJobId,
+                        previousStatus: message.previousStatus
+                    });
+                    return;
+                }
+                if (message?.type === "replace-scheduled-error") {
+                    reject(new Error(message.error || "Failed to replace scheduled job"));
+                }
+            }
+        });
+    }
+    /**
+     * Cancels or detaches the current owner of a stable schedule key.
+     * @param {object} args - Options.
+     * @param {string} args.scheduleKey - Stable logical schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Cancellation result.
+     */
+    async cancelScheduled({ scheduleKey }) {
+        const request = await this._request();
+        return await request.run({
+            onConnect: (jsonSocket) => {
+                jsonSocket.send({ type: "cancel-scheduled", scheduleKey });
+            },
+            onMessage: ({ message, resolve, reject }) => {
+                if (message?.type === "schedule-cancelled") {
+                    resolve({ jobId: message.jobId, outcome: message.outcome });
+                    return;
+                }
+                if (message?.type === "cancel-scheduled-error") {
+                    reject(new Error(message.error || "Failed to cancel scheduled job"));
+                }
+            }
+        });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/background-jobs/client.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport configurationResolver from \"../configuration-resolver.js\"\nimport BackgroundJobsSocketRequest from \"./socket-request.js\"\n\nexport default class BackgroundJobsClient {\n  /**\n   * Runs constructor.\n   * @param {object} [args] - Options.\n   * @param {import(\"../configuration.js\").default} [args.configuration] - Configuration.\n   */\n  constructor({configuration} = {}) {\n    this.configurationPromise = configuration ? Promise.resolve(configuration) : configurationResolver()\n  }\n\n  /**\n   * Builds a one-shot client socket request from the resolved configuration.\n   * @returns {Promise<BackgroundJobsSocketRequest>} - Socket request.\n   */\n  async _request() {\n    const configuration = await this.configurationPromise\n    const {host, port} = configuration.getBackgroundJobsConfig()\n\n    return new BackgroundJobsSocketRequest({host, port, role: \"client\"})\n  }\n\n  /**\n   * Runs enqueue.\n   * @param {object} args - Options.\n   * @param {string} args.jobName - Job name.\n   * @param {Array<?>} args.args - Job args.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @returns {Promise<string>} - Job id.\n   */\n  async enqueue({jobName, args, options}) {\n    const request = await this._request()\n\n    return await request.run({\n      onConnect: (jsonSocket) => {\n        jsonSocket.send({\n          type: \"enqueue\",\n          jobName,\n          args,\n          options\n        })\n      },\n      onMessage: ({message, resolve, reject}) => {\n        if (message?.type === \"enqueued\") {\n          resolve(message.jobId)\n          return\n        }\n\n        if (message?.type === \"enqueue-error\") {\n          reject(new Error(message.error || \"Failed to enqueue job\"))\n        }\n      }\n    })\n  }\n\n  /**\n   * Atomically replaces the queued owner of a stable schedule key.\n   * @param {object} args - Options.\n   * @param {string} args.scheduleKey - Stable logical schedule key.\n   * @param {string} args.jobName - Job name.\n   * @param {Array<?>} args.args - Job args.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobReplacementResult>} - Replacement result.\n   */\n  async replaceScheduled({scheduleKey, jobName, args, options}) {\n    const request = await this._request()\n\n    return await request.run({\n      onConnect: (jsonSocket) => {\n        jsonSocket.send({type: \"replace-scheduled\", scheduleKey, jobName, args, options})\n      },\n      onMessage: ({message, resolve, reject}) => {\n        if (message?.type === \"schedule-replaced\") {\n          resolve({\n            jobId: message.jobId,\n            previousJobId: message.previousJobId,\n            previousStatus: message.previousStatus\n          })\n          return\n        }\n\n        if (message?.type === \"replace-scheduled-error\") {\n          reject(new Error(message.error || \"Failed to replace scheduled job\"))\n        }\n      }\n    })\n  }\n\n  /**\n   * Cancels or detaches the current owner of a stable schedule key.\n   * @param {object} args - Options.\n   * @param {string} args.scheduleKey - Stable logical schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobCancellationResult>} - Cancellation result.\n   */\n  async cancelScheduled({scheduleKey}) {\n    const request = await this._request()\n\n    return await request.run({\n      onConnect: (jsonSocket) => {\n        jsonSocket.send({type: \"cancel-scheduled\", scheduleKey})\n      },\n      onMessage: ({message, resolve, reject}) => {\n        if (message?.type === \"schedule-cancelled\") {\n          resolve({jobId: message.jobId, outcome: message.outcome})\n          return\n        }\n\n        if (message?.type === \"cancel-scheduled-error\") {\n          reject(new Error(message.error || \"Failed to cancel scheduled job\"))\n        }\n      }\n    })\n  }\n}\n"]}

package/build/src/background-jobs/job.d.ts

@@ -65,6 +65,25 @@ export default class VelociousJob<TArgs extends Array<unknown> = []> {
         args: Array<unknown>;
         options?: import("./types.js").BackgroundJobOptions | undefined;
     }): Promise<string>;
+    /**
+     * Atomically replaces this job class's queued owner for a stable schedule key.
+     * @param {object} args - Options.
+     * @param {string} args.scheduleKey - Stable logical schedule key.
+     * @param {Array<?>} args.args - Job args.
+     * @param {import("./types.js").BackgroundJobOptions} [args.options] - Job options.
+     * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Replacement result.
+     */
+    static replaceScheduled({ scheduleKey, args, options }: {
+        scheduleKey: string;
+        args: Array<unknown>;
+        options?: import("./types.js").BackgroundJobOptions | undefined;
+    }): Promise<import("./types.js").BackgroundJobReplacementResult>;
+    /**
+     * Cancels or detaches the current owner of a stable schedule key.
+     * @param {string} scheduleKey - Stable logical schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Cancellation result.
+     */
+    static cancelScheduled(scheduleKey: string): Promise<import("./types.js").BackgroundJobCancellationResult>;
     /**
      * Runs split args and options.
      * @param {Array<?>} args - Job args.

package/build/src/background-jobs/job.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"job.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,kCAFyB,KAAK,SAAhB,KAAK,CAAC,OAAC,CAAE;IAGrB;;;;;;OAMG;IACH,4BAFU,MAAM,EAAE,GAAG,SAAS,CAEQ;IAEtC;;;;;;OAMG;IACH,cAFU,MAAM,GAAG,SAAS,CAEJ;IAExB;;;;;;;;;OASG;IACH,qBAFU,MAAM,GAAG,SAAS,CAEG;IAE/B;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,2BAHW,OAAO,YAAY,EAAE,oBAAoB,GAAG,SAAS,GACnD,OAAO,YAAY,EAAE,oBAAoB,CAUrD;IAED;;;;OAIG;IACH,6BAHc,OAAC,EAAA,GACF,OAAO,CAAC,MAAM,CAAC,CAW3B;IAED;;;;;;OAMG;IACH,kDAJG;QAAuB,IAAI,EAAnB,KAAK,CAAC,OAAC,CAAC;QACyC,OAAO;KAChE,GAAU,OAAO,CAAC,MAAM,CAAC,CAU3B;IAED;;;;OAIG;IACH,kCAHW,KAAK,CAAC,OAAC,CAAC,GACN;QAAC,OAAO,EAAE,KAAK,CAAC,OAAC,CAAC,CAAC;QAAC,UAAU,EAAE,OAAO,YAAY,EAAE,oBAAoB,CAAA;KAAC,CAgBtF;IAED;;;;OAIG;IACH,kBAHW,KAAK,GACH,OAAO,CAAC,IAAI,CAAC,CAIzB;CACF"}
+{"version":3,"file":"job.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,kCAFyB,KAAK,SAAhB,KAAK,CAAC,OAAC,CAAE;IAGrB;;;;;;OAMG;IACH,4BAFU,MAAM,EAAE,GAAG,SAAS,CAEQ;IAEtC;;;;;;OAMG;IACH,cAFU,MAAM,GAAG,SAAS,CAEJ;IAExB;;;;;;;;;OASG;IACH,qBAFU,MAAM,GAAG,SAAS,CAEG;IAE/B;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,2BAHW,OAAO,YAAY,EAAE,oBAAoB,GAAG,SAAS,GACnD,OAAO,YAAY,EAAE,oBAAoB,CAUrD;IAED;;;;OAIG;IACH,6BAHc,OAAC,EAAA,GACF,OAAO,CAAC,MAAM,CAAC,CAW3B;IAED;;;;;;OAMG;IACH,kDAJG;QAAuB,IAAI,EAAnB,KAAK,CAAC,OAAC,CAAC;QACyC,OAAO;KAChE,GAAU,OAAO,CAAC,MAAM,CAAC,CAU3B;IAED;;;;;;;OAOG;IACH,wDALG;QAAqB,WAAW,EAAxB,MAAM;QACS,IAAI,EAAnB,KAAK,CAAC,OAAC,CAAC;QACyC,OAAO;KAChE,GAAU,OAAO,CAAC,OAAO,YAAY,EAAE,8BAA8B,CAAC,CAWxE;IAED;;;;OAIG;IACH,oCAHW,MAAM,GACJ,OAAO,CAAC,OAAO,YAAY,EAAE,+BAA+B,CAAC,CAMzE;IAED;;;;OAIG;IACH,kCAHW,KAAK,CAAC,OAAC,CAAC,GACN;QAAC,OAAO,EAAE,KAAK,CAAC,OAAC,CAAC,CAAC;QAAC,UAAU,EAAE,OAAO,YAAY,EAAE,oBAAoB,CAAA;KAAC,CAgBtF;IAED;;;;OAIG;IACH,kBAHW,KAAK,GACH,OAAO,CAAC,IAAI,CAAC,CAIzB;CACF"}