velocious 1.0.540 → 1.0.542

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.540",
+  "version": "1.0.542",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

package/src/background-jobs/store.js

@@ -146,14 +146,16 @@ export default class BackgroundJobsStore {
     await this._withDb(async (db) => {
       if (options?.deduplicateWhileQueued) {
         // Dedupe on the job's identity (name + args + queue), NOT its concurrency key, so a job
-        // keeps whatever concurrency it resolves to — in particular a scheduled job that relies on
-        // its queue-derived `queue:<name>` cap still participates in that cluster-wide cap instead
-        // of being pulled onto a private per-job key.
+        // keeps whatever concurrency it resolves to. Only an existing job scheduled no later than
+        // this enqueue can cover it; a retry backed off into the future must not suppress earlier
+        // work. Ordering returns the earliest covering job when several queued rows already exist.
         const existing = await db
           .newQuery()
           .from(JOBS_TABLE)
           .select("id")
           .where({status: "queued", job_name: jobName, args_json: argsJson, queue})
+          .where(`scheduled_at_ms <= ${db.quote(scheduledAtMs)}`)
+          .order("scheduled_at_ms ASC")
           .limit(1)
           .results()
 

package/src/background-jobs/types.js

@@ -15,7 +15,7 @@
  * @property {string} [queue] - Queue name. Defaults to `"default"`. When the queue has a configured cap in `backgroundJobs.queues`, that cap is enforced cluster-wide.
  * @property {string} [concurrencyKey] - Opaque non-empty key used to share a concurrency cap. Overrides any queue-derived cap.
  * @property {number} [maxConcurrency] - Positive integer cap; must be paired with `concurrencyKey`.
- * @property {boolean} [deduplicateWhileQueued] - When true, skip the enqueue if an identical still-queued job (same job name, args and queue) already exists, returning that job's id. Deduplication is by job identity and independent of `concurrencyKey`, so the job keeps its normal (e.g. queue-derived) concurrency cap. Keeps an interval-scheduled recurring job (e.g. retention pruning) from piling up redundant queued rows when it runs slower than its interval or no worker is free.
+ * @property {boolean} [deduplicateWhileQueued] - When true, skip the enqueue if an identical still-queued job (same job name, args and queue) is scheduled no later than this enqueue, returning the earliest matching job's id. A future retry does not suppress earlier work. Deduplication is independent of `concurrencyKey`, so the job keeps its normal (e.g. queue-derived) concurrency cap. Keeps an interval-scheduled recurring job (e.g. retention pruning) from piling up redundant queued rows when it runs slower than its interval or no worker is free.
  * @property {number} [scheduledAtMs] - Epoch timestamp in milliseconds when the job becomes eligible for dispatch. Defaults to enqueue time.
  */
 /**

package/src/database/record/index.js

@@ -3167,6 +3167,47 @@ class VelociousDatabaseRecord {
     return await this._newQuery().findByOrFail(conditions)
   }
 
+  /**
+   * Returns a scope whose eager finders run against an explicit `tenant` (and
+   * therefore its database) instead of whatever tenant is ambient in
+   * `Current.tenant()`. Use it to read a model that may live in a specific
+   * tenant or in the default database from another tenant context — for example
+   * `GithubWebhook.usingTenant(tenant).findBy({id})` — without depending on
+   * which tenant happens to be active. The target tenant's connections are
+   * ensured for the duration of each query.
+   * @template {typeof VelociousDatabaseRecord} MC
+   * @this {MC}
+   * @param {?} tenant - Tenant descriptor to scope the queries to (as accepted by `configuration.runWithTenant`).
+   * @returns {{find: (recordId: ?) => Promise<InstanceType<MC> | null>, findBy: (conditions: {[key: string]: string | number}) => Promise<InstanceType<MC> | null>, findByOrFail: (conditions: {[key: string]: string | number}) => Promise<InstanceType<MC>>}} - Eager finders scoped to the given tenant.
+   */
+  static usingTenant(tenant) {
+    const ModelClass = this
+
+    return {
+      find: (recordId) => ModelClass._runUsingTenant(tenant, () => ModelClass.find(recordId)),
+      findBy: (conditions) => ModelClass._runUsingTenant(tenant, () => ModelClass.findBy(conditions)),
+      findByOrFail: (conditions) => ModelClass._runUsingTenant(tenant, () => ModelClass.findByOrFail(conditions))
+    }
+  }
+
+  /**
+   * Runs `callback` with the tenant switched to `tenant` and that tenant's
+   * connections ensured. Backs `usingTenant`.
+   * @template T
+   * @param {?} tenant - Tenant descriptor.
+   * @param {() => Promise<T>} callback - Query to run under the tenant.
+   * @returns {Promise<T>} - Resolves with the callback's result.
+   */
+  static async _runUsingTenant(tenant, callback) {
+    const configuration = this._getConfiguration()
+
+    // Do NOT ensureInitialized() out here: for a tenant-switched model whose
+    // first initialization would resolve metadata from the ambient tenant's
+    // database, that must happen under the requested tenant. The finders inside
+    // `callback` call ensureInitialized() themselves, now within this scope.
+    return await configuration.runWithTenant(tenant, () => configuration.ensureConnections({name: `usingTenant: ${this.getModelName()}`}, callback))
+  }
+
   /**
    * Runs find or create by.
    * @template {typeof VelociousDatabaseRecord} MC