velocious 1.0.598 → 1.0.600

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

@@ -0,0 +1,16 @@
+/**
+ * Performs a job class inside its declared database-connection scope.
+ * @param {object} args - Performance options.
+ * @param {import("../configuration.js").default} args.configuration - Active configuration.
+ * @param {typeof import("./platform-job.js").default} args.JobClass - Job class.
+ * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.
+ * @param {string} args.name - Connection-scope label.
+ * @returns {Promise<void>} - Resolves after performance.
+ */
+export default function performBackgroundJob({ configuration, JobClass, jobArgs, name }: {
+    configuration: import("../configuration.js").default;
+    JobClass: typeof import("./platform-job.js").default;
+    jobArgs: Array<ReturnType<typeof JSON.parse>>;
+    name: string;
+}): Promise<void>;
+//# sourceMappingURL=perform-job.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"perform-job.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/perform-job.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAA8B,oBAAoB,CAAC,EAAC,aAAa,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAC,EANxF;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;IAAyD,QAAQ,EAAzD,cAAc,mBAAmB,EAAE,OAAO,CAClD;IAAmD,OAAO,EAAlD,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;IAAqB,IAAI,EAAjB,MAAM,CACd;CAEwF,GAF9E,OAAO,CAAC,IAAI,CAAC,CAazB"}

package/build/src/background-jobs/perform-job.js

@@ -0,0 +1,22 @@
+// @ts-check
+/**
+ * Performs a job class inside its declared database-connection scope.
+ * @param {object} args - Performance options.
+ * @param {import("../configuration.js").default} args.configuration - Active configuration.
+ * @param {typeof import("./platform-job.js").default} args.JobClass - Job class.
+ * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.
+ * @param {string} args.name - Connection-scope label.
+ * @returns {Promise<void>} - Resolves after performance.
+ */
+export default async function performBackgroundJob({ configuration, JobClass, jobArgs, name }) {
+    const jobInstance = new JobClass();
+    /**
+     * Narrows the generic subclass's runtime method to serialized job arguments.
+     * @type {(...args: Array<ReturnType<typeof JSON.parse>>) => Promise<void>}
+     */
+    const perform = jobInstance.perform;
+    await configuration.withConnections({ databaseIdentifiers: JobClass.databaseIdentifiers, name }, async () => {
+        await perform.apply(jobInstance, jobArgs);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,110 @@
+/**
+ * Base class for background jobs.
+ *
+ * `TArgs` is the tuple of arguments the subclass's `perform` accepts, so a job that
+ * needs arguments declares them as required and typed — for example
+ * `class RunBuildJob extends VelociousJob<[string]>` with `async perform(buildId)`.
+ * The default empty tuple keeps argument-less jobs (`extends VelociousJob`,
+ * `async perform()`) working unchanged.
+ * @template {Array<ReturnType<typeof JSON.parse>>} [TArgs=[]]
+ */
+export default class VelociousJob<TArgs extends Array<ReturnType<typeof JSON.parse>> = []> {
+    /**
+     * Database identifiers checked out while this job performs. Set an explicit
+     * list to avoid holding unrelated configured database connections, or `[]`
+     * when the job establishes any connections it needs itself. Left undefined,
+     * jobs retain the existing behavior of checking out every active database.
+     * @type {string[] | undefined}
+     */
+    static databaseIdentifiers: string[] | undefined;
+    /**
+     * Queue this job class runs on. Subclasses set e.g. `static queue = "builds"`
+     * to route onto a queue with its own cluster-wide concurrency cap (configured
+     * via `backgroundJobs.queues`). The `{queue}` enqueue option overrides it.
+     * Left undefined, jobs run on the `"default"` queue.
+     * @type {string | undefined}
+     */
+    static queue: string | undefined;
+    /**
+     * Optional process title shown for the runner while this job executes.
+     * Velocious sets `process.title` to this for the duration of the job — so
+     * `ps`/`top`/`htop` identify what a runner is doing — and restores the
+     * runner's base title when the job finishes. Left undefined, the runner falls
+     * back to `velocious job-runner: <JobName>`. Set e.g.
+     * `static processTitle = "velocious media transcoder"` to give a job a
+     * custom, human-readable title.
+     * @type {string | undefined}
+     */
+    static processTitle: string | undefined;
+    /**
+     * Stops this performance and reschedules the same logical job row. This is
+     * normal control flow: it does not count as a failure or consume a retry.
+     * @param {number} delayMs - Non-negative safe-integer delay in milliseconds.
+     * @returns {never} - This method never returns.
+     */
+    rescheduleIn(delayMs: number): never;
+    /**
+     * Runs job name.
+     * @returns {string} - Job name.
+     */
+    static jobName(): string;
+    /**
+     * Folds this job class's static `queue` into the enqueue options unless the
+     * caller already specified one.
+     * @param {import("./types.js").BackgroundJobOptions | undefined} options - Job options.
+     * @returns {import("./types.js").BackgroundJobOptions} - Options including the resolved queue.
+     */
+    static _withQueue(options: import("./types.js").BackgroundJobOptions | undefined): import("./types.js").BackgroundJobOptions;
+    /**
+     * Runs perform later.
+     * @param {...ReturnType<typeof JSON.parse>} args - Job args.
+     * @returns {Promise<string>} - Job id.
+     */
+    static performLater(...args: ReturnType<typeof JSON.parse>[]): Promise<string>;
+    /**
+     * Runs perform later with options.
+     * @param {object} args - Options.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job args.
+     * @param {import("./types.js").BackgroundJobOptions} [args.options] - Job options.
+     * @returns {Promise<string>} - Job id.
+     */
+    static performLaterWithOptions({ args, options }: {
+        args: Array<ReturnType<typeof JSON.parse>>;
+        options?: import("./types.js").BackgroundJobOptions;
+    }): 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<ReturnType<typeof JSON.parse>>} 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<ReturnType<typeof JSON.parse>>;
+        options?: import("./types.js").BackgroundJobOptions;
+    }): 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<ReturnType<typeof JSON.parse>>} args - Job args.
+     * @returns {{jobArgs: Array<ReturnType<typeof JSON.parse>>, jobOptions: import("./types.js").BackgroundJobOptions}} - Split args and options.
+     */
+    static _splitArgsAndOptions(args: Array<ReturnType<typeof JSON.parse>>): {
+        jobArgs: Array<ReturnType<typeof JSON.parse>>;
+        jobOptions: import("./types.js").BackgroundJobOptions;
+    };
+    /**
+     * Override in subclasses.
+     * @param {TArgs} _args - Job args (the tuple this job class was parameterized with).
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    perform(..._args: TArgs): Promise<void>;
+}
+//# sourceMappingURL=platform-job.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"platform-job.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/platform-job.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY,CAFoB,KAAK,SAA5C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAS,EAAG;IAG5D;;;;;;OAMG;IACH,MAAM,CAAC,mBAAmB,EAFhB,MAAM,EAAE,GAAG,SAAS,CAEQ;IAEtC;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,EAFF,MAAM,GAAG,SAAS,CAEJ;IAExB;;;;;;;;;OASG;IACH,MAAM,CAAC,YAAY,EAFT,MAAM,GAAG,SAAS,CAEG;IAE/B;;;;;OAKG;IACH,YAAY,CAAC,OAAO,EAHT,MAGS,GAFP,KAAK,CAQjB;IAED;;;OAGG;IACH,MAAM,CAAC,OAAO,IAFD,MAAM,CAIlB;IAED;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO,EAHd,OAAO,YAAY,EAAE,oBAAoB,GAAG,SAG9B,GAFZ,OAAO,YAAY,EAAE,oBAAoB,CAUrD;IAED;;;;OAIG;IACH,OAAa,YAAY,CAAC,GAAG,IAAI,EAHnB,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,EAGV,GAFpB,OAAO,CAAC,MAAM,CAAC,CAK3B;IAED;;;;;;OAMG;IACH,OAAa,uBAAuB,CAAC,EAAC,IAAI,EAAE,OAAO,EAAC,EAJjD;QAAmD,IAAI,EAA/C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;QAAyD,OAAO,AAAhE,CACA,EADQ,OAAO,YAAY,EAAE,oBAAoB,CACjD;KAEiD,GAFvC,OAAO,CAAC,MAAM,CAAC,CAI3B;IAED;;;;;;;OAOG;IACH,OAAa,gBAAgB,CAAC,EAAC,WAAW,EAAE,IAAI,EAAE,OAAO,EAAC,EALvD;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAmD,IAAI,EAA/C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;QAAyD,OAAO,AAAhE,CACA,EADQ,OAAO,YAAY,EAAE,oBAAoB,CACjD;KAEuD,GAF7C,OAAO,CAAC,OAAO,YAAY,EAAE,8BAA8B,CAAC,CAIxE;IAED;;;;OAIG;IACH,OAAa,eAAe,CAAC,WAAW,EAH7B,MAG6B,GAF3B,OAAO,CAAC,OAAO,YAAY,EAAE,+BAA+B,CAAC,CAIzE;IAED;;;;OAIG;IACH,MAAM,CAAC,oBAAoB,CAAC,IAAI,EAHrB,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAGd,GAFnB;QAAC,OAAO,EAAE,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAAC,UAAU,EAAE,OAAO,YAAY,EAAE,oBAAoB,CAAA;KAAC,CAgBlH;IAED;;;;OAIG;IACG,OAAO,CAAC,GAAG,KAAK,EAHX,KAGW,GAFT,OAAO,CAAC,IAAI,CAAC,CAIzB;CACF"}

package/build/src/background-jobs/platform-job.js

@@ -0,0 +1,138 @@
+// @ts-check
+import BackgroundJobRescheduleSignal from "./reschedule-signal.js";
+import { cancelScheduledBackgroundJob, enqueueBackgroundJob, replaceScheduledBackgroundJob } from "./runtime.js";
+/**
+ * Base class for background jobs.
+ *
+ * `TArgs` is the tuple of arguments the subclass's `perform` accepts, so a job that
+ * needs arguments declares them as required and typed — for example
+ * `class RunBuildJob extends VelociousJob<[string]>` with `async perform(buildId)`.
+ * The default empty tuple keeps argument-less jobs (`extends VelociousJob`,
+ * `async perform()`) working unchanged.
+ * @template {Array<ReturnType<typeof JSON.parse>>} [TArgs=[]]
+ */
+export default class VelociousJob {
+    /**
+     * Database identifiers checked out while this job performs. Set an explicit
+     * list to avoid holding unrelated configured database connections, or `[]`
+     * when the job establishes any connections it needs itself. Left undefined,
+     * jobs retain the existing behavior of checking out every active database.
+     * @type {string[] | undefined}
+     */
+    static databaseIdentifiers = undefined;
+    /**
+     * Queue this job class runs on. Subclasses set e.g. `static queue = "builds"`
+     * to route onto a queue with its own cluster-wide concurrency cap (configured
+     * via `backgroundJobs.queues`). The `{queue}` enqueue option overrides it.
+     * Left undefined, jobs run on the `"default"` queue.
+     * @type {string | undefined}
+     */
+    static queue = undefined;
+    /**
+     * Optional process title shown for the runner while this job executes.
+     * Velocious sets `process.title` to this for the duration of the job — so
+     * `ps`/`top`/`htop` identify what a runner is doing — and restores the
+     * runner's base title when the job finishes. Left undefined, the runner falls
+     * back to `velocious job-runner: <JobName>`. Set e.g.
+     * `static processTitle = "velocious media transcoder"` to give a job a
+     * custom, human-readable title.
+     * @type {string | undefined}
+     */
+    static processTitle = undefined;
+    /**
+     * Stops this performance and reschedules the same logical job row. This is
+     * normal control flow: it does not count as a failure or consume a retry.
+     * @param {number} delayMs - Non-negative safe-integer delay in milliseconds.
+     * @returns {never} - This method never returns.
+     */
+    rescheduleIn(delayMs) {
+        if (!Number.isSafeInteger(delayMs) || delayMs < 0) {
+            throw new TypeError("background job reschedule delayMs must be a non-negative safe integer");
+        }
+        throw new BackgroundJobRescheduleSignal(delayMs);
+    }
+    /**
+     * Runs job name.
+     * @returns {string} - Job name.
+     */
+    static jobName() {
+        return this.name;
+    }
+    /**
+     * Folds this job class's static `queue` into the enqueue options unless the
+     * caller already specified one.
+     * @param {import("./types.js").BackgroundJobOptions | undefined} options - Job options.
+     * @returns {import("./types.js").BackgroundJobOptions} - Options including the resolved queue.
+     */
+    static _withQueue(options) {
+        const merged = options ? { ...options } : {};
+        if (merged.queue === undefined && typeof this.queue === "string" && this.queue.length > 0) {
+            merged.queue = this.queue;
+        }
+        return merged;
+    }
+    /**
+     * Runs perform later.
+     * @param {...ReturnType<typeof JSON.parse>} args - Job args.
+     * @returns {Promise<string>} - Job id.
+     */
+    static async performLater(...args) {
+        const { jobArgs, jobOptions } = this._splitArgsAndOptions(args);
+        return await enqueueBackgroundJob({ JobClass: this, jobArgs, jobOptions });
+    }
+    /**
+     * Runs perform later with options.
+     * @param {object} args - Options.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job args.
+     * @param {import("./types.js").BackgroundJobOptions} [args.options] - Job options.
+     * @returns {Promise<string>} - Job id.
+     */
+    static async performLaterWithOptions({ args, options }) {
+        return await enqueueBackgroundJob({ JobClass: this, jobArgs: args, jobOptions: options });
+    }
+    /**
+     * 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<ReturnType<typeof JSON.parse>>} args.args - Job args.
+     * @param {import("./types.js").BackgroundJobOptions} [args.options] - Job options.
+     * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Replacement result.
+     */
+    static async replaceScheduled({ scheduleKey, args, options }) {
+        return await replaceScheduledBackgroundJob({ JobClass: this, scheduleKey, jobArgs: args, jobOptions: options });
+    }
+    /**
+     * 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 async cancelScheduled(scheduleKey) {
+        return await cancelScheduledBackgroundJob(scheduleKey);
+    }
+    /**
+     * Runs split args and options.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args - Job args.
+     * @returns {{jobArgs: Array<ReturnType<typeof JSON.parse>>, jobOptions: import("./types.js").BackgroundJobOptions}} - Split args and options.
+     */
+    static _splitArgsAndOptions(args) {
+        if (args.length === 0) {
+            return { jobArgs: [], jobOptions: {} };
+        }
+        const lastArg = args[args.length - 1];
+        const isOptionsArg = lastArg && typeof lastArg === "object" && !Array.isArray(lastArg) && "jobOptions" in lastArg;
+        if (isOptionsArg) {
+            const { jobOptions } = /** @type {{jobOptions: import("./types.js").BackgroundJobOptions}} */ (lastArg);
+            return { jobArgs: args.slice(0, -1), jobOptions: jobOptions || {} };
+        }
+        return { jobArgs: args, jobOptions: {} };
+    }
+    /**
+     * Override in subclasses.
+     * @param {TArgs} _args - Job args (the tuple this job class was parameterized with).
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async perform(..._args) {
+        throw new Error("perform not implemented");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform-job.js","sourceRoot":"","sources":["../../../src/background-jobs/platform-job.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport BackgroundJobRescheduleSignal from \"./reschedule-signal.js\"\nimport {cancelScheduledBackgroundJob, enqueueBackgroundJob, replaceScheduledBackgroundJob} from \"./runtime.js\"\n\n/**\n * Base class for background jobs.\n *\n * `TArgs` is the tuple of arguments the subclass's `perform` accepts, so a job that\n * needs arguments declares them as required and typed — for example\n * `class RunBuildJob extends VelociousJob<[string]>` with `async perform(buildId)`.\n * The default empty tuple keeps argument-less jobs (`extends VelociousJob`,\n * `async perform()`) working unchanged.\n * @template {Array<ReturnType<typeof JSON.parse>>} [TArgs=[]]\n */\nexport default class VelociousJob {\n  /**\n   * Database identifiers checked out while this job performs. Set an explicit\n   * list to avoid holding unrelated configured database connections, or `[]`\n   * when the job establishes any connections it needs itself. Left undefined,\n   * jobs retain the existing behavior of checking out every active database.\n   * @type {string[] | undefined}\n   */\n  static databaseIdentifiers = undefined\n\n  /**\n   * Queue this job class runs on. Subclasses set e.g. `static queue = \"builds\"`\n   * to route onto a queue with its own cluster-wide concurrency cap (configured\n   * via `backgroundJobs.queues`). The `{queue}` enqueue option overrides it.\n   * Left undefined, jobs run on the `\"default\"` queue.\n   * @type {string | undefined}\n   */\n  static queue = undefined\n\n  /**\n   * Optional process title shown for the runner while this job executes.\n   * Velocious sets `process.title` to this for the duration of the job — so\n   * `ps`/`top`/`htop` identify what a runner is doing — and restores the\n   * runner's base title when the job finishes. Left undefined, the runner falls\n   * back to `velocious job-runner: <JobName>`. Set e.g.\n   * `static processTitle = \"velocious media transcoder\"` to give a job a\n   * custom, human-readable title.\n   * @type {string | undefined}\n   */\n  static processTitle = undefined\n\n  /**\n   * Stops this performance and reschedules the same logical job row. This is\n   * normal control flow: it does not count as a failure or consume a retry.\n   * @param {number} delayMs - Non-negative safe-integer delay in milliseconds.\n   * @returns {never} - This method never returns.\n   */\n  rescheduleIn(delayMs) {\n    if (!Number.isSafeInteger(delayMs) || delayMs < 0) {\n      throw new TypeError(\"background job reschedule delayMs must be a non-negative safe integer\")\n    }\n\n    throw new BackgroundJobRescheduleSignal(delayMs)\n  }\n\n  /**\n   * Runs job name.\n   * @returns {string} - Job name.\n   */\n  static jobName() {\n    return this.name\n  }\n\n  /**\n   * Folds this job class's static `queue` into the enqueue options unless the\n   * caller already specified one.\n   * @param {import(\"./types.js\").BackgroundJobOptions | undefined} options - Job options.\n   * @returns {import(\"./types.js\").BackgroundJobOptions} - Options including the resolved queue.\n   */\n  static _withQueue(options) {\n    const merged = options ? {...options} : {}\n\n    if (merged.queue === undefined && typeof this.queue === \"string\" && this.queue.length > 0) {\n      merged.queue = this.queue\n    }\n\n    return merged\n  }\n\n  /**\n   * Runs perform later.\n   * @param {...ReturnType<typeof JSON.parse>} args - Job args.\n   * @returns {Promise<string>} - Job id.\n   */\n  static async performLater(...args) {\n    const {jobArgs, jobOptions} = this._splitArgsAndOptions(args)\n    return await enqueueBackgroundJob({JobClass: this, jobArgs, jobOptions})\n  }\n\n  /**\n   * Runs perform later with options.\n   * @param {object} args - Options.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job args.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @returns {Promise<string>} - Job id.\n   */\n  static async performLaterWithOptions({args, options}) {\n    return await enqueueBackgroundJob({JobClass: this, jobArgs: args, jobOptions: options})\n  }\n\n  /**\n   * Atomically replaces this job class's queued owner for a stable schedule key.\n   * @param {object} args - Options.\n   * @param {string} args.scheduleKey - Stable logical schedule key.\n   * @param {Array<ReturnType<typeof JSON.parse>>} 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  static async replaceScheduled({scheduleKey, args, options}) {\n    return await replaceScheduledBackgroundJob({JobClass: this, scheduleKey, jobArgs: args, jobOptions: options})\n  }\n\n  /**\n   * Cancels or detaches the current owner of a stable schedule key.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobCancellationResult>} - Cancellation result.\n   */\n  static async cancelScheduled(scheduleKey) {\n    return await cancelScheduledBackgroundJob(scheduleKey)\n  }\n\n  /**\n   * Runs split args and options.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args - Job args.\n   * @returns {{jobArgs: Array<ReturnType<typeof JSON.parse>>, jobOptions: import(\"./types.js\").BackgroundJobOptions}} - Split args and options.\n   */\n  static _splitArgsAndOptions(args) {\n    if (args.length === 0) {\n      return {jobArgs: [], jobOptions: {}}\n    }\n\n    const lastArg = args[args.length - 1]\n    const isOptionsArg = lastArg && typeof lastArg === \"object\" && !Array.isArray(lastArg) && \"jobOptions\" in lastArg\n\n    if (isOptionsArg) {\n      const {jobOptions} = /** @type {{jobOptions: import(\"./types.js\").BackgroundJobOptions}} */ (lastArg)\n      return {jobArgs: args.slice(0, -1), jobOptions: jobOptions || {}}\n    }\n\n    return {jobArgs: args, jobOptions: {}}\n  }\n\n  /**\n   * Override in subclasses.\n   * @param {TArgs} _args - Job args (the tuple this job class was parameterized with).\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async perform(..._args) {\n    throw new Error(\"perform not implemented\")\n  }\n}\n"]}

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

@@ -0,0 +1,78 @@
+/**
+ * Enqueues durably in background mode or performs immediately in inline mode.
+ * @param {object} args - Enqueue request.
+ * @param {typeof import("./platform-job.js").default} args.JobClass - Job class.
+ * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.
+ * @param {import("./types.js").BackgroundJobOptions | undefined} args.jobOptions - Job options.
+ * @returns {Promise<string>} - Durable job id or ephemeral inline performance id.
+ */
+export declare function enqueueBackgroundJob({ JobClass, jobArgs, jobOptions }: {
+    JobClass: typeof import("./platform-job.js").default;
+    jobArgs: Array<ReturnType<typeof JSON.parse>>;
+    jobOptions: import("./types.js").BackgroundJobOptions | undefined;
+}): Promise<string>;
+/**
+ * Enqueues using an explicitly resolved configuration.
+ * @param {object} args - Enqueue request.
+ * @param {import("../configuration.js").default} args.configuration - Configuration.
+ * @param {typeof import("./platform-job.js").default} args.JobClass - Job class.
+ * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.
+ * @param {import("./types.js").BackgroundJobOptions | undefined} args.jobOptions - Job options.
+ * @returns {Promise<string>} - Durable job id or ephemeral inline performance id.
+ */
+export declare function enqueueBackgroundJobForConfiguration({ configuration, JobClass, jobArgs, jobOptions }: {
+    configuration: import("../configuration.js").default;
+    JobClass: typeof import("./platform-job.js").default;
+    jobArgs: Array<ReturnType<typeof JSON.parse>>;
+    jobOptions: import("./types.js").BackgroundJobOptions | undefined;
+}): Promise<string>;
+/**
+ * Replaces a stable durable schedule in background mode.
+ * @param {object} args - Replacement request.
+ * @param {typeof import("./platform-job.js").default} args.JobClass - Job class.
+ * @param {string} args.scheduleKey - Stable schedule key.
+ * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.
+ * @param {import("./types.js").BackgroundJobOptions | undefined} args.jobOptions - Job options.
+ * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Replacement result.
+ */
+export declare function replaceScheduledBackgroundJob({ JobClass, scheduleKey, jobArgs, jobOptions }: {
+    JobClass: typeof import("./platform-job.js").default;
+    scheduleKey: string;
+    jobArgs: Array<ReturnType<typeof JSON.parse>>;
+    jobOptions: import("./types.js").BackgroundJobOptions | undefined;
+}): Promise<import("./types.js").BackgroundJobReplacementResult>;
+/**
+ * Replaces a stable schedule using an explicitly resolved configuration.
+ * @param {object} args - Replacement request.
+ * @param {import("../configuration.js").default} args.configuration - Configuration.
+ * @param {typeof import("./platform-job.js").default} args.JobClass - Job class.
+ * @param {string} args.scheduleKey - Stable schedule key.
+ * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.
+ * @param {import("./types.js").BackgroundJobOptions | undefined} args.jobOptions - Job options.
+ * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Replacement result.
+ */
+export declare function replaceScheduledBackgroundJobForConfiguration({ configuration, JobClass, scheduleKey, jobArgs, jobOptions }: {
+    configuration: import("../configuration.js").default;
+    JobClass: typeof import("./platform-job.js").default;
+    scheduleKey: string;
+    jobArgs: Array<ReturnType<typeof JSON.parse>>;
+    jobOptions: import("./types.js").BackgroundJobOptions | undefined;
+}): Promise<import("./types.js").BackgroundJobReplacementResult>;
+/**
+ * Cancels a stable durable schedule in background mode.
+ * @param {string} scheduleKey - Stable schedule key.
+ * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Cancellation result.
+ */
+export declare function cancelScheduledBackgroundJob(scheduleKey: string): Promise<import("./types.js").BackgroundJobCancellationResult>;
+/**
+ * Cancels a stable schedule using an explicitly resolved configuration.
+ * @param {object} args - Cancellation request.
+ * @param {import("../configuration.js").default} args.configuration - Configuration.
+ * @param {string} args.scheduleKey - Stable logical schedule key.
+ * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Cancellation result.
+ */
+export declare function cancelScheduledBackgroundJobForConfiguration({ configuration, scheduleKey }: {
+    configuration: import("../configuration.js").default;
+    scheduleKey: string;
+}): Promise<import("./types.js").BackgroundJobCancellationResult>;
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/runtime.js"],"names":[],"mappings":"AA8BA;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CAAC,EAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAC,EALvE;IAAyD,QAAQ,EAAzD,cAAc,mBAAmB,EAAE,OAAO,CAClD;IAAmD,OAAO,EAAlD,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;IAAoE,UAAU,EAAtE,OAAO,YAAY,EAAE,oBAAoB,GAAG,SAAS,CAC7D;CAEuE,GAF7D,OAAO,CAAC,MAAM,CAAC,CAM3B;AAED;;;;;;;;GAQG;AACH,wBAAsB,oCAAoC,CAAC,EAAC,aAAa,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAC,EANtG;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;IAAyD,QAAQ,EAAzD,cAAc,mBAAmB,EAAE,OAAO,CAClD;IAAmD,OAAO,EAAlD,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;IAAoE,UAAU,EAAtE,OAAO,YAAY,EAAE,oBAAoB,GAAG,SAAS,CAC7D;CAEsG,GAF5F,OAAO,CAAC,MAAM,CAAC,CAkC3B;AAED;;;;;;;;GAQG;AACH,wBAAsB,6BAA6B,CAAC,EAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,UAAU,EAAC,EAN7F;IAAyD,QAAQ,EAAzD,cAAc,mBAAmB,EAAE,OAAO,CAClD;IAAqB,WAAW,EAAxB,MAAM,CACd;IAAmD,OAAO,EAAlD,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;IAAoE,UAAU,EAAtE,OAAO,YAAY,EAAE,oBAAoB,GAAG,SAAS,CAC7D;CAE6F,GAFnF,OAAO,CAAC,OAAO,YAAY,EAAE,8BAA8B,CAAC,CAMxE;AAED;;;;;;;;;GASG;AACH,wBAAsB,6CAA6C,CAAC,EAAC,aAAa,EAAE,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,UAAU,EAAC,EAP5H;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;IAAyD,QAAQ,EAAzD,cAAc,mBAAmB,EAAE,OAAO,CAClD;IAAqB,WAAW,EAAxB,MAAM,CACd;IAAmD,OAAO,EAAlD,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;IAAoE,UAAU,EAAtE,OAAO,YAAY,EAAE,oBAAoB,GAAG,SAAS,CAC7D;CAE4H,GAFlH,OAAO,CAAC,OAAO,YAAY,EAAE,8BAA8B,CAAC,CAgBxE;AAED;;;;GAIG;AACH,wBAAsB,4BAA4B,CAAC,WAAW,EAHnD,MAGmD,GAFjD,OAAO,CAAC,OAAO,YAAY,EAAE,+BAA+B,CAAC,CAMzE;AAED;;;;;;GAMG;AACH,wBAAsB,4CAA4C,CAAC,EAAC,aAAa,EAAE,WAAW,EAAC,EAJ5F;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;IAAqB,WAAW,EAAxB,MAAM,CACd;CAE4F,GAFlF,OAAO,CAAC,OAAO,YAAY,EAAE,+BAA+B,CAAC,CAWzE"}

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

@@ -0,0 +1,132 @@
+// @ts-check
+import { currentConfiguration } from "../current-configuration.js";
+import performBackgroundJob from "./perform-job.js";
+import BackgroundJobRescheduleSignal from "./reschedule-signal.js";
+let inlinePerformanceSequence = 0;
+/**
+ * Rejects options whose semantics require durable queue state.
+ * @param {import("./types.js").BackgroundJobOptions | undefined} options - Requested options.
+ * @returns {void}
+ */
+function validateInlineOptions(options) {
+    const optionNames = Object.keys(options || {});
+    if (optionNames.length > 0) {
+        throw new Error(`Background job option ${optionNames[0]} is not supported in inline mode`);
+    }
+}
+/**
+ * Builds an ephemeral inline performance id.
+ * @returns {string} - Performance id.
+ */
+function inlineJobId() {
+    inlinePerformanceSequence++;
+    return `inline-${Date.now()}-${inlinePerformanceSequence}`;
+}
+/**
+ * Enqueues durably in background mode or performs immediately in inline mode.
+ * @param {object} args - Enqueue request.
+ * @param {typeof import("./platform-job.js").default} args.JobClass - Job class.
+ * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.
+ * @param {import("./types.js").BackgroundJobOptions | undefined} args.jobOptions - Job options.
+ * @returns {Promise<string>} - Durable job id or ephemeral inline performance id.
+ */
+export async function enqueueBackgroundJob({ JobClass, jobArgs, jobOptions }) {
+    const configuration = currentConfiguration();
+    return await enqueueBackgroundJobForConfiguration({ configuration, JobClass, jobArgs, jobOptions });
+}
+/**
+ * Enqueues using an explicitly resolved configuration.
+ * @param {object} args - Enqueue request.
+ * @param {import("../configuration.js").default} args.configuration - Configuration.
+ * @param {typeof import("./platform-job.js").default} args.JobClass - Job class.
+ * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.
+ * @param {import("./types.js").BackgroundJobOptions | undefined} args.jobOptions - Job options.
+ * @returns {Promise<string>} - Durable job id or ephemeral inline performance id.
+ */
+export async function enqueueBackgroundJobForConfiguration({ configuration, JobClass, jobArgs, jobOptions }) {
+    if (configuration.getBackgroundJobsConfig().mode === "inline") {
+        validateInlineOptions(jobOptions);
+        configuration.setCurrent();
+        await configuration.initialize({ type: "background-jobs-inline" });
+        try {
+            await performBackgroundJob({
+                configuration,
+                JobClass,
+                jobArgs,
+                name: `Background job inline mode: ${JobClass.jobName()}`
+            });
+        }
+        catch (error) {
+            if (error instanceof BackgroundJobRescheduleSignal) {
+                throw new Error("rescheduleIn is not supported in inline mode", { cause: error });
+            }
+            throw error;
+        }
+        return inlineJobId();
+    }
+    const client = configuration.getEnvironmentHandler().backgroundJobsClient({ configuration });
+    return await client.enqueue({
+        jobName: JobClass.jobName(),
+        args: jobArgs,
+        options: JobClass._withQueue(jobOptions)
+    });
+}
+/**
+ * Replaces a stable durable schedule in background mode.
+ * @param {object} args - Replacement request.
+ * @param {typeof import("./platform-job.js").default} args.JobClass - Job class.
+ * @param {string} args.scheduleKey - Stable schedule key.
+ * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.
+ * @param {import("./types.js").BackgroundJobOptions | undefined} args.jobOptions - Job options.
+ * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Replacement result.
+ */
+export async function replaceScheduledBackgroundJob({ JobClass, scheduleKey, jobArgs, jobOptions }) {
+    const configuration = currentConfiguration();
+    return await replaceScheduledBackgroundJobForConfiguration({ configuration, JobClass, scheduleKey, jobArgs, jobOptions });
+}
+/**
+ * Replaces a stable schedule using an explicitly resolved configuration.
+ * @param {object} args - Replacement request.
+ * @param {import("../configuration.js").default} args.configuration - Configuration.
+ * @param {typeof import("./platform-job.js").default} args.JobClass - Job class.
+ * @param {string} args.scheduleKey - Stable schedule key.
+ * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.
+ * @param {import("./types.js").BackgroundJobOptions | undefined} args.jobOptions - Job options.
+ * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Replacement result.
+ */
+export async function replaceScheduledBackgroundJobForConfiguration({ configuration, JobClass, scheduleKey, jobArgs, jobOptions }) {
+    if (configuration.getBackgroundJobsConfig().mode === "inline") {
+        throw new Error("replaceScheduled is not supported in inline mode");
+    }
+    const client = configuration.getEnvironmentHandler().backgroundJobsClient({ configuration });
+    return await client.replaceScheduled({
+        scheduleKey,
+        jobName: JobClass.jobName(),
+        args: jobArgs,
+        options: JobClass._withQueue(jobOptions)
+    });
+}
+/**
+ * Cancels a stable durable schedule in background mode.
+ * @param {string} scheduleKey - Stable schedule key.
+ * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Cancellation result.
+ */
+export async function cancelScheduledBackgroundJob(scheduleKey) {
+    const configuration = currentConfiguration();
+    return await cancelScheduledBackgroundJobForConfiguration({ configuration, scheduleKey });
+}
+/**
+ * Cancels a stable schedule using an explicitly resolved configuration.
+ * @param {object} args - Cancellation request.
+ * @param {import("../configuration.js").default} args.configuration - Configuration.
+ * @param {string} args.scheduleKey - Stable logical schedule key.
+ * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Cancellation result.
+ */
+export async function cancelScheduledBackgroundJobForConfiguration({ configuration, scheduleKey }) {
+    if (configuration.getBackgroundJobsConfig().mode === "inline") {
+        throw new Error("cancelScheduled is not supported in inline mode");
+    }
+    const client = configuration.getEnvironmentHandler().backgroundJobsClient({ configuration });
+    return await client.cancelScheduled({ scheduleKey });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../src/background-jobs/runtime.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {currentConfiguration} from \"../current-configuration.js\"\nimport performBackgroundJob from \"./perform-job.js\"\nimport BackgroundJobRescheduleSignal from \"./reschedule-signal.js\"\n\nlet inlinePerformanceSequence = 0\n\n/**\n * Rejects options whose semantics require durable queue state.\n * @param {import(\"./types.js\").BackgroundJobOptions | undefined} options - Requested options.\n * @returns {void}\n */\nfunction validateInlineOptions(options) {\n  const optionNames = Object.keys(options || {})\n\n  if (optionNames.length > 0) {\n    throw new Error(`Background job option ${optionNames[0]} is not supported in inline mode`)\n  }\n}\n\n/**\n * Builds an ephemeral inline performance id.\n * @returns {string} - Performance id.\n */\nfunction inlineJobId() {\n  inlinePerformanceSequence++\n  return `inline-${Date.now()}-${inlinePerformanceSequence}`\n}\n\n/**\n * Enqueues durably in background mode or performs immediately in inline mode.\n * @param {object} args - Enqueue request.\n * @param {typeof import(\"./platform-job.js\").default} args.JobClass - Job class.\n * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.\n * @param {import(\"./types.js\").BackgroundJobOptions | undefined} args.jobOptions - Job options.\n * @returns {Promise<string>} - Durable job id or ephemeral inline performance id.\n */\nexport async function enqueueBackgroundJob({JobClass, jobArgs, jobOptions}) {\n  const configuration = currentConfiguration()\n\n  return await enqueueBackgroundJobForConfiguration({configuration, JobClass, jobArgs, jobOptions})\n}\n\n/**\n * Enqueues using an explicitly resolved configuration.\n * @param {object} args - Enqueue request.\n * @param {import(\"../configuration.js\").default} args.configuration - Configuration.\n * @param {typeof import(\"./platform-job.js\").default} args.JobClass - Job class.\n * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.\n * @param {import(\"./types.js\").BackgroundJobOptions | undefined} args.jobOptions - Job options.\n * @returns {Promise<string>} - Durable job id or ephemeral inline performance id.\n */\nexport async function enqueueBackgroundJobForConfiguration({configuration, JobClass, jobArgs, jobOptions}) {\n\n  if (configuration.getBackgroundJobsConfig().mode === \"inline\") {\n    validateInlineOptions(jobOptions)\n    configuration.setCurrent()\n    await configuration.initialize({type: \"background-jobs-inline\"})\n\n    try {\n      await performBackgroundJob({\n        configuration,\n        JobClass,\n        jobArgs,\n        name: `Background job inline mode: ${JobClass.jobName()}`\n      })\n    } catch (error) {\n      if (error instanceof BackgroundJobRescheduleSignal) {\n        throw new Error(\"rescheduleIn is not supported in inline mode\", {cause: error})\n      }\n\n      throw error\n    }\n\n    return inlineJobId()\n  }\n\n  const client = configuration.getEnvironmentHandler().backgroundJobsClient({configuration})\n\n  return await client.enqueue({\n    jobName: JobClass.jobName(),\n    args: jobArgs,\n    options: JobClass._withQueue(jobOptions)\n  })\n}\n\n/**\n * Replaces a stable durable schedule in background mode.\n * @param {object} args - Replacement request.\n * @param {typeof import(\"./platform-job.js\").default} args.JobClass - Job class.\n * @param {string} args.scheduleKey - Stable schedule key.\n * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.\n * @param {import(\"./types.js\").BackgroundJobOptions | undefined} args.jobOptions - Job options.\n * @returns {Promise<import(\"./types.js\").BackgroundJobReplacementResult>} - Replacement result.\n */\nexport async function replaceScheduledBackgroundJob({JobClass, scheduleKey, jobArgs, jobOptions}) {\n  const configuration = currentConfiguration()\n\n  return await replaceScheduledBackgroundJobForConfiguration({configuration, JobClass, scheduleKey, jobArgs, jobOptions})\n}\n\n/**\n * Replaces a stable schedule using an explicitly resolved configuration.\n * @param {object} args - Replacement request.\n * @param {import(\"../configuration.js\").default} args.configuration - Configuration.\n * @param {typeof import(\"./platform-job.js\").default} args.JobClass - Job class.\n * @param {string} args.scheduleKey - Stable schedule key.\n * @param {Array<ReturnType<typeof JSON.parse>>} args.jobArgs - Job arguments.\n * @param {import(\"./types.js\").BackgroundJobOptions | undefined} args.jobOptions - Job options.\n * @returns {Promise<import(\"./types.js\").BackgroundJobReplacementResult>} - Replacement result.\n */\nexport async function replaceScheduledBackgroundJobForConfiguration({configuration, JobClass, scheduleKey, jobArgs, jobOptions}) {\n\n  if (configuration.getBackgroundJobsConfig().mode === \"inline\") {\n    throw new Error(\"replaceScheduled is not supported in inline mode\")\n  }\n\n  const client = configuration.getEnvironmentHandler().backgroundJobsClient({configuration})\n\n  return await client.replaceScheduled({\n    scheduleKey,\n    jobName: JobClass.jobName(),\n    args: jobArgs,\n    options: JobClass._withQueue(jobOptions)\n  })\n}\n\n/**\n * Cancels a stable durable schedule in background mode.\n * @param {string} scheduleKey - Stable schedule key.\n * @returns {Promise<import(\"./types.js\").BackgroundJobCancellationResult>} - Cancellation result.\n */\nexport async function cancelScheduledBackgroundJob(scheduleKey) {\n  const configuration = currentConfiguration()\n\n  return await cancelScheduledBackgroundJobForConfiguration({configuration, scheduleKey})\n}\n\n/**\n * Cancels a stable schedule using an explicitly resolved configuration.\n * @param {object} args - Cancellation request.\n * @param {import(\"../configuration.js\").default} args.configuration - Configuration.\n * @param {string} args.scheduleKey - Stable logical schedule key.\n * @returns {Promise<import(\"./types.js\").BackgroundJobCancellationResult>} - Cancellation result.\n */\nexport async function cancelScheduledBackgroundJobForConfiguration({configuration, scheduleKey}) {\n\n  if (configuration.getBackgroundJobsConfig().mode === \"inline\") {\n    throw new Error(\"cancelScheduled is not supported in inline mode\")\n  }\n\n  const client = configuration.getEnvironmentHandler().backgroundJobsClient({configuration})\n\n  return await client.cancelScheduled({scheduleKey})\n}\n"]}

package/build/src/background-jobs/sql-adapter.d.ts

@@ -0,0 +1,13 @@
+import BackgroundJobsStore from "./store.js";
+/** Built-in SQL adapter preserving the existing durable store implementation. */
+export default class SqlBackgroundJobsAdapter extends BackgroundJobsStore {
+    /**
+     * Ensures the built-in SQL schema during migration.
+     * @param {{dbs: Record<string, import("../database/drivers/base.js").default>}} args - Migrated databases.
+     * @returns {Promise<void>} - Resolves when the SQL schema is present.
+     */
+    ensureFrameworkSchema({ dbs }: {
+        dbs: Record<string, import("../database/drivers/base.js").default>;
+    }): Promise<void>;
+}
+//# sourceMappingURL=sql-adapter.d.ts.map

package/build/src/background-jobs/sql-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-adapter.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/sql-adapter.js"],"names":[],"mappings":"AAEA,OAAO,mBAAmB,MAAM,YAAY,CAAA;AAE5C,iFAAiF;AACjF,MAAM,CAAC,OAAO,OAAO,wBAAyB,SAAQ,mBAAmB;IACvE;;;;OAIG;IACG,qBAAqB,CAAC,EAAC,GAAG,EAAC,EAHtB;QAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,OAAO,CAAC,CAAA;KAG7C,GAFpB,OAAO,CAAC,IAAI,CAAC,CASzB;CACF"}

package/build/src/background-jobs/sql-adapter.js

@@ -0,0 +1,18 @@
+// @ts-check
+import BackgroundJobsStore from "./store.js";
+/** Built-in SQL adapter preserving the existing durable store implementation. */
+export default class SqlBackgroundJobsAdapter extends BackgroundJobsStore {
+    /**
+     * Ensures the built-in SQL schema during migration.
+     * @param {{dbs: Record<string, import("../database/drivers/base.js").default>}} args - Migrated databases.
+     * @returns {Promise<void>} - Resolves when the SQL schema is present.
+     */
+    async ensureFrameworkSchema({ dbs }) {
+        const databaseIdentifier = this.getDatabaseIdentifier() || "default";
+        const frameworkDb = dbs[databaseIdentifier];
+        if (!frameworkDb)
+            return;
+        await this.ensureSchema(frameworkDb);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3FsLWFkYXB0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYmFja2dyb3VuZC1qb2JzL3NxbC1hZGFwdGVyLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVk7QUFFWixPQUFPLG1CQUFtQixNQUFNLFlBQVksQ0FBQTtBQUU1QyxpRkFBaUY7QUFDakYsTUFBTSxDQUFDLE9BQU8sT0FBTyx3QkFBeUIsU0FBUSxtQkFBbUI7SUFDdkU7Ozs7T0FJRztJQUNILEtBQUssQ0FBQyxxQkFBcUIsQ0FBQyxFQUFDLEdBQUcsRUFBQztRQUMvQixNQUFNLGtCQUFrQixHQUFHLElBQUksQ0FBQyxxQkFBcUIsRUFBRSxJQUFJLFNBQVMsQ0FBQTtRQUNwRSxNQUFNLFdBQVcsR0FBRyxHQUFHLENBQUMsa0JBQWtCLENBQUMsQ0FBQTtRQUUzQyxJQUFJLENBQUMsV0FBVztZQUFFLE9BQU07UUFFeEIsTUFBTSxJQUFJLENBQUMsWUFBWSxDQUFDLFdBQVcsQ0FBQyxDQUFBO0lBQ3RDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuXG5pbXBvcnQgQmFja2dyb3VuZEpvYnNTdG9yZSBmcm9tIFwiLi9zdG9yZS5qc1wiXG5cbi8qKiBCdWlsdC1pbiBTUUwgYWRhcHRlciBwcmVzZXJ2aW5nIHRoZSBleGlzdGluZyBkdXJhYmxlIHN0b3JlIGltcGxlbWVudGF0aW9uLiAqL1xuZXhwb3J0IGRlZmF1bHQgY2xhc3MgU3FsQmFja2dyb3VuZEpvYnNBZGFwdGVyIGV4dGVuZHMgQmFja2dyb3VuZEpvYnNTdG9yZSB7XG4gIC8qKlxuICAgKiBFbnN1cmVzIHRoZSBidWlsdC1pbiBTUUwgc2NoZW1hIGR1cmluZyBtaWdyYXRpb24uXG4gICAqIEBwYXJhbSB7e2RiczogUmVjb3JkPHN0cmluZywgaW1wb3J0KFwiLi4vZGF0YWJhc2UvZHJpdmVycy9iYXNlLmpzXCIpLmRlZmF1bHQ+fX0gYXJncyAtIE1pZ3JhdGVkIGRhdGFiYXNlcy5cbiAgICogQHJldHVybnMge1Byb21pc2U8dm9pZD59IC0gUmVzb2x2ZXMgd2hlbiB0aGUgU1FMIHNjaGVtYSBpcyBwcmVzZW50LlxuICAgKi9cbiAgYXN5bmMgZW5zdXJlRnJhbWV3b3JrU2NoZW1hKHtkYnN9KSB7XG4gICAgY29uc3QgZGF0YWJhc2VJZGVudGlmaWVyID0gdGhpcy5nZXREYXRhYmFzZUlkZW50aWZpZXIoKSB8fCBcImRlZmF1bHRcIlxuICAgIGNvbnN0IGZyYW1ld29ya0RiID0gZGJzW2RhdGFiYXNlSWRlbnRpZmllcl1cblxuICAgIGlmICghZnJhbWV3b3JrRGIpIHJldHVyblxuXG4gICAgYXdhaXQgdGhpcy5lbnN1cmVTY2hlbWEoZnJhbWV3b3JrRGIpXG4gIH1cbn1cbiJdfQ==

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

@@ -1,3 +1,4 @@
+import BackgroundJobsAdapter from "./adapter.js";
 import Logger from "../logger.js";
 export type PreparedBackgroundJob = {
     /**
@@ -43,7 +44,7 @@ export type PreparedBackgroundJob = {
 };
 export declare const BACKGROUND_JOB_COUNTS_CHANNEL = "velocious-background-job-counts";
 export declare const BACKGROUND_JOB_COUNT_BUCKETS: string[];
-export default class BackgroundJobsStore {
+export default class BackgroundJobsStore extends BackgroundJobsAdapter {
     configuration: import("../configuration.js").default;
     databaseIdentifier: string | undefined;
     logger: Logger;