velocious 1.0.249 → 1.0.251

package/README.md

@@ -930,6 +930,23 @@ const specificTask = await Task.where({
 }).toArray()
 ```
 
+### Ransack-style filtering
+
+Use `.ransack(...)` on record queries, record classes, frontend-model queries, and frontend-model classes when you want Rails/Ransack-style predicate keys without hand-writing nested `where(...)` or `search(...)` calls.
+
+Supported predicates include `_eq`, `_not_eq`, `_gt`, `_gteq`, `_lt`, `_lteq`, `_cont`, `_start`, `_end`, `_in`, `_not_in`, and `_null`.
+
+```js
+const tasks = await Task.ransack({
+  name_cont: "deploy",
+  project_project_detail_is_active_eq: true
+}).toArray()
+
+const frontendTasks = await FrontendTask
+  .ransack({name_cont: "deploy", id_in: ["1", "2"]})
+  .toArray()
+```
+
 ### Raw where clauses
 
 ```js
@@ -1493,6 +1510,35 @@ await MyJob.performLaterWithOptions({
 })
 ```
 
+## Scheduled jobs
+
+Velocious can enqueue recurring jobs from the `background-jobs-main` process. Configure them with `scheduledBackgroundJobs` using Sidekiq Scheduler-style `every` arrays:
+
+```js
+import BuildCleanupJob from "./src/jobs/build-cleanup-job.js"
+
+export default new Configuration({
+  // ...
+  scheduledBackgroundJobs: {
+    jobs: {
+      buildCleanup: {
+        class: BuildCleanupJob,
+        every: ["1h", {first_in: "10s"}],
+        options: {forked: false}
+      }
+    }
+  }
+})
+```
+
+Supported schedule syntax:
+
+- `every: "5m"`
+- `every: ["1h", {first_in: "30s"}]`
+- `every: ["1 day", {firstIn: "5 minutes"}]`
+
+`background-jobs-main` owns the schedule and enqueues the configured jobs into the normal Velocious background-jobs queue. The HTTP server does not run scheduled jobs itself.
+
 ## Persistence and retries
 
 Jobs are persisted in the configured database (`backgroundJobs.databaseIdentifier`) in an internal `background_jobs` table. When a worker picks a job, the job is marked as handed off and the worker reports completion or failure back to the main process.

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

@@ -27,6 +27,7 @@ export default class BackgroundJobsMain {
     server: net.Server;
     _dispatchTimer: NodeJS.Timeout;
     _orphanTimer: NodeJS.Timeout;
+    scheduler: BackgroundJobsScheduler;
     /**
      * @returns {Promise<void>} - Resolves when closed.
      */
@@ -59,4 +60,5 @@ import BackgroundJobsStore from "./store.js";
 import Logger from "../logger.js";
 import JsonSocket from "./json-socket.js";
 import net from "net";
+import BackgroundJobsScheduler from "./scheduler.js";
 //# sourceMappingURL=main.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/main.js"],"names":[],"mappings":"AAOA;IACE;;;;;OAKG;IACH,2CAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACvB,IAAI,GAAlB,MAAM;QACQ,IAAI,GAAlB,MAAM;KAChB,EAaA;IAXC,qDAAkC;IAElC,aAA+B;IAC/B,aAAyD;IACzD,2BAAoG;IACpG,eAA8B;IAC9B,8BAA8B;IAC9B,SADW,GAAG,CAAC,UAAU,CAAC,CACF;IACxB,8BAA8B;IAC9B,cADW,GAAG,CAAC,UAAU,CAAC,CACG;IAC7B,sBAAyB;IAG3B;;OAEG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAnBC,mBAA0E;IAY1E,+BAEQ;IAER,6BAES;IAGX;;OAEG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAazB;IAED;;OAEG;IACH,WAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,0BAHW,OAAO,KAAK,EAAE,MAAM,GAClB,IAAI,CAqDhB;IAED;;;sBAcC;IAED;;;sBAYC;IAED;;;sBAcC;IAED,2BAyCC;IAED,+BAUC;CACF;gCAxO+B,YAAY;mBACzB,cAAc;uBAFV,kBAAkB;gBADzB,KAAK"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/main.js"],"names":[],"mappings":"AAQA;IACE;;;;;OAKG;IACH,2CAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACvB,IAAI,GAAlB,MAAM;QACQ,IAAI,GAAlB,MAAM;KAChB,EAaA;IAXC,qDAAkC;IAElC,aAA+B;IAC/B,aAAyD;IACzD,2BAAoG;IACpG,eAA8B;IAC9B,8BAA8B;IAC9B,SADW,GAAG,CAAC,UAAU,CAAC,CACF;IACxB,8BAA8B;IAC9B,cADW,GAAG,CAAC,UAAU,CAAC,CACG;IAC7B,sBAAyB;IAG3B;;OAEG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CA2CzB;IArCC,mBAA0E;IAaxE,+BAEQ;IAER,6BAES;IAET,mCAUE;IAQN;;OAEG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAczB;IAED;;OAEG;IACH,WAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,0BAHW,OAAO,KAAK,EAAE,MAAM,GAClB,IAAI,CAqDhB;IAED;;;sBAcC;IAED;;;sBAYC;IAED;;;sBAcC;IAED,2BAyCC;IAED,+BAUC;CACF;gCA3P+B,YAAY;mBACzB,cAAc;uBAHV,kBAAkB;gBADzB,KAAK;oCAEe,gBAAgB"}

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

@@ -1,6 +1,7 @@
 // @ts-check
 import net from "net";
 import JsonSocket from "./json-socket.js";
+import BackgroundJobsScheduler from "./scheduler.js";
 import BackgroundJobsStore from "./store.js";
 import Logger from "../logger.js";
 export default class BackgroundJobsMain {
@@ -31,20 +32,38 @@ export default class BackgroundJobsMain {
         await this.configuration.initialize({ type: "background-jobs-main" });
         await this.store.ensureReady();
         this.server = net.createServer((socket) => this._handleConnection(socket));
-        await new Promise((resolve, reject) => {
-            this.server.once("error", reject);
-            this.server.listen(this.port, this.host, () => resolve(undefined));
-        });
-        const address = this.server.address();
-        if (address && typeof address === "object") {
-            this.port = address.port;
+        try {
+            await new Promise((resolve, reject) => {
+                this.server.once("error", reject);
+                this.server.listen(this.port, this.host, () => resolve(undefined));
+            });
+            const address = this.server.address();
+            if (address && typeof address === "object") {
+                this.port = address.port;
+            }
+            this._dispatchTimer = setInterval(() => {
+                void this._dispatch();
+            }, 1000);
+            this._orphanTimer = setInterval(() => {
+                void this._sweepOrphans();
+            }, 60000);
+            this.scheduler = new BackgroundJobsScheduler({
+                configuration: this.configuration,
+                enqueueJob: async ({ args, jobClass, options }) => {
+                    await this.store.enqueue({
+                        jobName: jobClass.jobName(),
+                        args,
+                        options
+                    });
+                    await this._dispatch();
+                }
+            });
+            await this.scheduler.start();
+        }
+        catch (error) {
+            await this.stop();
+            throw error;
         }
-        this._dispatchTimer = setInterval(() => {
-            void this._dispatch();
-        }, 1000);
-        this._orphanTimer = setInterval(() => {
-            void this._sweepOrphans();
-        }, 60000);
     }
     /**
      * @returns {Promise<void>} - Resolves when closed.
@@ -57,6 +76,7 @@ export default class BackgroundJobsMain {
             clearInterval(this._dispatchTimer);
         if (this._orphanTimer)
             clearInterval(this._orphanTimer);
+        this.scheduler?.stop();
         if (!this.server)
             return;
         await new Promise((resolve) => this.server.close(() => resolve(undefined)));
@@ -213,4 +233,4 @@ export default class BackgroundJobsMain {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main.js","sourceRoot":"","sources":["../../../src/background-jobs/main.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport net from \"net\"\nimport JsonSocket from \"./json-socket.js\"\nimport BackgroundJobsStore from \"./store.js\"\nimport Logger from \"../logger.js\"\n\nexport default class BackgroundJobsMain {\n  /**\n   * @param {object} args - Options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration.\n   * @param {string} [args.host] - Hostname.\n   * @param {number} [args.port] - Port.\n   */\n  constructor({configuration, host, port}) {\n    this.configuration = configuration\n    const config = configuration.getBackgroundJobsConfig()\n    this.host = host || config.host\n    this.port = typeof port === \"number\" ? port : config.port\n    this.store = new BackgroundJobsStore({configuration, databaseIdentifier: config.databaseIdentifier})\n    this.logger = new Logger(this)\n    /** @type {Set<JsonSocket>} */\n    this.workers = new Set()\n    /** @type {Set<JsonSocket>} */\n    this.readyWorkers = new Set()\n    this._dispatching = false\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when listening.\n   */\n  async start() {\n    this.configuration.setCurrent()\n    await this.configuration.initialize({type: \"background-jobs-main\"})\n    await this.store.ensureReady()\n    this.server = net.createServer((socket) => this._handleConnection(socket))\n\n    await new Promise((resolve, reject) => {\n      this.server.once(\"error\", reject)\n      this.server.listen(this.port, this.host, () => resolve(undefined))\n    })\n\n    const address = this.server.address()\n    if (address && typeof address === \"object\") {\n      this.port = address.port\n    }\n\n    this._dispatchTimer = setInterval(() => {\n      void this._dispatch()\n    }, 1000)\n\n    this._orphanTimer = setInterval(() => {\n      void this._sweepOrphans()\n    }, 60000)\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when closed.\n   */\n  async stop() {\n    for (const worker of this.workers) {\n      worker.close()\n    }\n\n    if (this._dispatchTimer) clearInterval(this._dispatchTimer)\n    if (this._orphanTimer) clearInterval(this._orphanTimer)\n\n    if (!this.server) return\n\n    await new Promise((resolve) => this.server.close(() => resolve(undefined)))\n  }\n\n  /**\n   * @returns {number} - Bound port.\n   */\n  getPort() {\n    return this.port\n  }\n\n  /**\n   * @param {import(\"net\").Socket} socket - Socket.\n   * @returns {void}\n   */\n  _handleConnection(socket) {\n    const jsonSocket = new JsonSocket(socket)\n    let role = null\n\n    const cleanup = () => {\n      if (role === \"worker\") {\n        this.workers.delete(jsonSocket)\n        this.readyWorkers.delete(jsonSocket)\n      }\n    }\n\n    jsonSocket.on(\"close\", cleanup)\n    jsonSocket.on(\"error\", (error) => {\n      this.logger.warn(() => [\"Background jobs connection error:\", error])\n      cleanup()\n    })\n\n    jsonSocket.on(\"message\", (message) => {\n      if (!role && message?.type === \"hello\") {\n        role = message.role\n\n        if (role === \"worker\") {\n          jsonSocket.workerId = message.workerId\n          this.workers.add(jsonSocket)\n          this.readyWorkers.add(jsonSocket)\n          this._dispatch()\n        }\n\n        return\n      }\n\n      if (role === \"client\" && message?.type === \"enqueue\") {\n        this._handleEnqueue({jsonSocket, message})\n        return\n      }\n\n      if (role === \"worker\" && message?.type === \"ready\") {\n        this.readyWorkers.add(jsonSocket)\n        this._dispatch()\n        return\n      }\n\n      if ((role === \"worker\" || role === \"reporter\") && message?.type === \"job-complete\") {\n        this._handleJobComplete({jsonSocket, message})\n        return\n      }\n\n      if ((role === \"worker\" || role === \"reporter\") && message?.type === \"job-failed\") {\n        this._handleJobFailed({jsonSocket, message})\n      }\n    })\n  }\n\n  async _handleEnqueue({jsonSocket, message}) {\n    try {\n      const jobId = await this.store.enqueue({\n        jobName: message.jobName,\n        args: message.args || [],\n        options: message.options || {}\n      })\n\n      jsonSocket.send({type: \"enqueued\", jobId})\n      await this._dispatch()\n    } catch (error) {\n      this.logger.error(() => [\"Failed to enqueue background job:\", error])\n      jsonSocket.send({type: \"enqueue-error\", error: \"Failed to enqueue job\"})\n    }\n  }\n\n  async _handleJobComplete({jsonSocket, message}) {\n    try {\n      await this.store.markCompleted({\n        jobId: message.jobId,\n        workerId: message.workerId,\n        handedOffAtMs: message.handedOffAtMs\n      })\n      jsonSocket.send({type: \"job-updated\", jobId: message.jobId})\n    } catch (error) {\n      this.logger.error(() => [\"Failed to update job completion:\", error])\n      jsonSocket.send({type: \"job-update-error\", jobId: message.jobId, error: \"Failed to update job\"})\n    }\n  }\n\n  async _handleJobFailed({jsonSocket, message}) {\n    try {\n      await this.store.markFailed({\n        jobId: message.jobId,\n        error: message.error,\n        workerId: message.workerId,\n        handedOffAtMs: message.handedOffAtMs\n      })\n      jsonSocket.send({type: \"job-updated\", jobId: message.jobId})\n      await this._dispatch()\n    } catch (error) {\n      this.logger.error(() => [\"Failed to update job failure:\", error])\n      jsonSocket.send({type: \"job-update-error\", jobId: message.jobId, error: \"Failed to update job\"})\n    }\n  }\n\n  async _dispatch() {\n    if (this._dispatching) return\n    if (this.readyWorkers.size === 0) return\n\n    this._dispatching = true\n\n    try {\n      while (this.readyWorkers.size > 0) {\n        const job = await this.store.nextAvailableJob()\n        if (!job) return\n\n        const [worker] = this.readyWorkers\n        if (!worker) return\n\n        this.readyWorkers.delete(worker)\n\n        const handedOffAtMs = await this.store.markHandedOff({jobId: job.id, workerId: worker.workerId})\n\n        try {\n          worker.send({\n            type: \"job\",\n            payload: {\n              id: job.id,\n              jobName: job.jobName,\n              args: job.args,\n              workerId: worker.workerId,\n              handedOffAtMs,\n              options: {\n                forked: job.forked\n              }\n            }\n          })\n        } catch (error) {\n          this.logger.warn(() => [\"Failed to send job to worker, re-queueing:\", error])\n          await this.store.markReturnedToQueue({jobId: job.id})\n          this.readyWorkers.add(worker)\n        }\n      }\n    } finally {\n      this._dispatching = false\n    }\n  }\n\n  async _sweepOrphans() {\n    try {\n      const count = await this.store.markOrphanedJobs()\n\n      if (count > 0) {\n        this.logger.warn(() => [\"Marked orphaned background jobs\", count])\n      }\n    } catch (error) {\n      this.logger.error(() => [\"Failed to mark orphaned jobs:\", error])\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main.js","sourceRoot":"","sources":["../../../src/background-jobs/main.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,GAAG,MAAM,KAAK,CAAA;AACrB,OAAO,UAAU,MAAM,kBAAkB,CAAA;AACzC,OAAO,uBAAuB,MAAM,gBAAgB,CAAA;AACpD,OAAO,mBAAmB,MAAM,YAAY,CAAA;AAC5C,OAAO,MAAM,MAAM,cAAc,CAAA;AAEjC,MAAM,CAAC,OAAO,OAAO,kBAAkB;IACrC;;;;;OAKG;IACH,YAAY,EAAC,aAAa,EAAE,IAAI,EAAE,IAAI,EAAC;QACrC,IAAI,CAAC,aAAa,GAAG,aAAa,CAAA;QAClC,MAAM,MAAM,GAAG,aAAa,CAAC,uBAAuB,EAAE,CAAA;QACtD,IAAI,CAAC,IAAI,GAAG,IAAI,IAAI,MAAM,CAAC,IAAI,CAAA;QAC/B,IAAI,CAAC,IAAI,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAA;QACzD,IAAI,CAAC,KAAK,GAAG,IAAI,mBAAmB,CAAC,EAAC,aAAa,EAAE,kBAAkB,EAAE,MAAM,CAAC,kBAAkB,EAAC,CAAC,CAAA;QACpG,IAAI,CAAC,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,CAAA;QAC9B,8BAA8B;QAC9B,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,EAAE,CAAA;QACxB,8BAA8B;QAC9B,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,EAAE,CAAA;QAC7B,IAAI,CAAC,YAAY,GAAG,KAAK,CAAA;IAC3B,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,CAAA;QAC/B,MAAM,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,EAAC,IAAI,EAAE,sBAAsB,EAAC,CAAC,CAAA;QACnE,MAAM,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAA;QAC9B,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,YAAY,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAA;QAE1E,IAAI,CAAC;YACH,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACpC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;gBACjC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAA;YACpE,CAAC,CAAC,CAAA;YAEF,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAA;YACrC,IAAI,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;gBAC3C,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAA;YAC1B,CAAC;YAED,IAAI,CAAC,cAAc,GAAG,WAAW,CAAC,GAAG,EAAE;gBACrC,KAAK,IAAI,CAAC,SAAS,EAAE,CAAA;YACvB,CAAC,EAAE,IAAI,CAAC,CAAA;YAER,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC,GAAG,EAAE;gBACnC,KAAK,IAAI,CAAC,aAAa,EAAE,CAAA;YAC3B,CAAC,EAAE,KAAK,CAAC,CAAA;YAET,IAAI,CAAC,SAAS,GAAG,IAAI,uBAAuB,CAAC;gBAC3C,aAAa,EAAE,IAAI,CAAC,aAAa;gBACjC,UAAU,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAC,EAAE,EAAE;oBAC9C,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;wBACvB,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE;wBAC3B,IAAI;wBACJ,OAAO;qBACR,CAAC,CAAA;oBACF,MAAM,IAAI,CAAC,SAAS,EAAE,CAAA;gBACxB,CAAC;aACF,CAAC,CAAA;YACF,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAA;QAC9B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,IAAI,EAAE,CAAA;YACjB,MAAM,KAAK,CAAA;QACb,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,IAAI;QACR,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAClC,MAAM,CAAC,KAAK,EAAE,CAAA;QAChB,CAAC;QAED,IAAI,IAAI,CAAC,cAAc;YAAE,aAAa,CAAC,IAAI,CAAC,cAAc,CAAC,CAAA;QAC3D,IAAI,IAAI,CAAC,YAAY;YAAE,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;QACvD,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,CAAA;QAEtB,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAM;QAExB,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;IAC7E,CAAC;IAED;;OAEG;IACH,OAAO;QACL,OAAO,IAAI,CAAC,IAAI,CAAA;IAClB,CAAC;IAED;;;OAGG;IACH,iBAAiB,CAAC,MAAM;QACtB,MAAM,UAAU,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAA;QACzC,IAAI,IAAI,GAAG,IAAI,CAAA;QAEf,MAAM,OAAO,GAAG,GAAG,EAAE;YACnB,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;gBAC/B,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;YACtC,CAAC;QACH,CAAC,CAAA;QAED,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;QAC/B,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;YAC/B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,mCAAmC,EAAE,KAAK,CAAC,CAAC,CAAA;YACpE,OAAO,EAAE,CAAA;QACX,CAAC,CAAC,CAAA;QAEF,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE;YACnC,IAAI,CAAC,IAAI,IAAI,OAAO,EAAE,IAAI,KAAK,OAAO,EAAE,CAAC;gBACvC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAA;gBAEnB,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;oBACtB,UAAU,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAA;oBACtC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;oBAC5B,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;oBACjC,IAAI,CAAC,SAAS,EAAE,CAAA;gBAClB,CAAC;gBAED,OAAM;YACR,CAAC;YAED,IAAI,IAAI,KAAK,QAAQ,IAAI,OAAO,EAAE,IAAI,KAAK,SAAS,EAAE,CAAC;gBACrD,IAAI,CAAC,cAAc,CAAC,EAAC,UAAU,EAAE,OAAO,EAAC,CAAC,CAAA;gBAC1C,OAAM;YACR,CAAC;YAED,IAAI,IAAI,KAAK,QAAQ,IAAI,OAAO,EAAE,IAAI,KAAK,OAAO,EAAE,CAAC;gBACnD,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;gBACjC,IAAI,CAAC,SAAS,EAAE,CAAA;gBAChB,OAAM;YACR,CAAC;YAED,IAAI,CAAC,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,UAAU,CAAC,IAAI,OAAO,EAAE,IAAI,KAAK,cAAc,EAAE,CAAC;gBACnF,IAAI,CAAC,kBAAkB,CAAC,EAAC,UAAU,EAAE,OAAO,EAAC,CAAC,CAAA;gBAC9C,OAAM;YACR,CAAC;YAED,IAAI,CAAC,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,UAAU,CAAC,IAAI,OAAO,EAAE,IAAI,KAAK,YAAY,EAAE,CAAC;gBACjF,IAAI,CAAC,gBAAgB,CAAC,EAAC,UAAU,EAAE,OAAO,EAAC,CAAC,CAAA;YAC9C,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,EAAC,UAAU,EAAE,OAAO,EAAC;QACxC,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;gBACrC,OAAO,EAAE,OAAO,CAAC,OAAO;gBACxB,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,EAAE;gBACxB,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,EAAE;aAC/B,CAAC,CAAA;YAEF,UAAU,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAC,CAAC,CAAA;YAC1C,MAAM,IAAI,CAAC,SAAS,EAAE,CAAA;QACxB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,mCAAmC,EAAE,KAAK,CAAC,CAAC,CAAA;YACrE,UAAU,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,uBAAuB,EAAC,CAAC,CAAA;QAC1E,CAAC;IACH,CAAC;IAED,KAAK,CAAC,kBAAkB,CAAC,EAAC,UAAU,EAAE,OAAO,EAAC;QAC5C,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC;gBAC7B,KAAK,EAAE,OAAO,CAAC,KAAK;gBACpB,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,aAAa,EAAE,OAAO,CAAC,aAAa;aACrC,CAAC,CAAA;YACF,UAAU,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAC,CAAC,CAAA;QAC9D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,kCAAkC,EAAE,KAAK,CAAC,CAAC,CAAA;YACpE,UAAU,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,sBAAsB,EAAC,CAAC,CAAA;QAClG,CAAC;IACH,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,EAAC,UAAU,EAAE,OAAO,EAAC;QAC1C,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC;gBAC1B,KAAK,EAAE,OAAO,CAAC,KAAK;gBACpB,KAAK,EAAE,OAAO,CAAC,KAAK;gBACpB,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,aAAa,EAAE,OAAO,CAAC,aAAa;aACrC,CAAC,CAAA;YACF,UAAU,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAC,CAAC,CAAA;YAC5D,MAAM,IAAI,CAAC,SAAS,EAAE,CAAA;QACxB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,+BAA+B,EAAE,KAAK,CAAC,CAAC,CAAA;YACjE,UAAU,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,sBAAsB,EAAC,CAAC,CAAA;QAClG,CAAC;IACH,CAAC;IAED,KAAK,CAAC,SAAS;QACb,IAAI,IAAI,CAAC,YAAY;YAAE,OAAM;QAC7B,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,KAAK,CAAC;YAAE,OAAM;QAExC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAA;QAExB,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;gBAClC,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAA;gBAC/C,IAAI,CAAC,GAAG;oBAAE,OAAM;gBAEhB,MAAM,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,YAAY,CAAA;gBAClC,IAAI,CAAC,MAAM;oBAAE,OAAM;gBAEnB,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;gBAEhC,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,EAAC,KAAK,EAAE,GAAG,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAC,CAAC,CAAA;gBAEhG,IAAI,CAAC;oBACH,MAAM,CAAC,IAAI,CAAC;wBACV,IAAI,EAAE,KAAK;wBACX,OAAO,EAAE;4BACP,EAAE,EAAE,GAAG,CAAC,EAAE;4BACV,OAAO,EAAE,GAAG,CAAC,OAAO;4BACpB,IAAI,EAAE,GAAG,CAAC,IAAI;4BACd,QAAQ,EAAE,MAAM,CAAC,QAAQ;4BACzB,aAAa;4BACb,OAAO,EAAE;gCACP,MAAM,EAAE,GAAG,CAAC,MAAM;6BACnB;yBACF;qBACF,CAAC,CAAA;gBACJ,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,4CAA4C,EAAE,KAAK,CAAC,CAAC,CAAA;oBAC7E,MAAM,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAAC,KAAK,EAAE,GAAG,CAAC,EAAE,EAAC,CAAC,CAAA;oBACrD,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;gBAC/B,CAAC;YACH,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,YAAY,GAAG,KAAK,CAAA;QAC3B,CAAC;IACH,CAAC;IAED,KAAK,CAAC,aAAa;QACjB,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAA;YAEjD,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;gBACd,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,iCAAiC,EAAE,KAAK,CAAC,CAAC,CAAA;YACpE,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,+BAA+B,EAAE,KAAK,CAAC,CAAC,CAAA;QACnE,CAAC;IACH,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport net from \"net\"\nimport JsonSocket from \"./json-socket.js\"\nimport BackgroundJobsScheduler from \"./scheduler.js\"\nimport BackgroundJobsStore from \"./store.js\"\nimport Logger from \"../logger.js\"\n\nexport default class BackgroundJobsMain {\n  /**\n   * @param {object} args - Options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration.\n   * @param {string} [args.host] - Hostname.\n   * @param {number} [args.port] - Port.\n   */\n  constructor({configuration, host, port}) {\n    this.configuration = configuration\n    const config = configuration.getBackgroundJobsConfig()\n    this.host = host || config.host\n    this.port = typeof port === \"number\" ? port : config.port\n    this.store = new BackgroundJobsStore({configuration, databaseIdentifier: config.databaseIdentifier})\n    this.logger = new Logger(this)\n    /** @type {Set<JsonSocket>} */\n    this.workers = new Set()\n    /** @type {Set<JsonSocket>} */\n    this.readyWorkers = new Set()\n    this._dispatching = false\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when listening.\n   */\n  async start() {\n    this.configuration.setCurrent()\n    await this.configuration.initialize({type: \"background-jobs-main\"})\n    await this.store.ensureReady()\n    this.server = net.createServer((socket) => this._handleConnection(socket))\n\n    try {\n      await new Promise((resolve, reject) => {\n        this.server.once(\"error\", reject)\n        this.server.listen(this.port, this.host, () => resolve(undefined))\n      })\n\n      const address = this.server.address()\n      if (address && typeof address === \"object\") {\n        this.port = address.port\n      }\n\n      this._dispatchTimer = setInterval(() => {\n        void this._dispatch()\n      }, 1000)\n\n      this._orphanTimer = setInterval(() => {\n        void this._sweepOrphans()\n      }, 60000)\n\n      this.scheduler = new BackgroundJobsScheduler({\n        configuration: this.configuration,\n        enqueueJob: async ({args, jobClass, options}) => {\n          await this.store.enqueue({\n            jobName: jobClass.jobName(),\n            args,\n            options\n          })\n          await this._dispatch()\n        }\n      })\n      await this.scheduler.start()\n    } catch (error) {\n      await this.stop()\n      throw error\n    }\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when closed.\n   */\n  async stop() {\n    for (const worker of this.workers) {\n      worker.close()\n    }\n\n    if (this._dispatchTimer) clearInterval(this._dispatchTimer)\n    if (this._orphanTimer) clearInterval(this._orphanTimer)\n    this.scheduler?.stop()\n\n    if (!this.server) return\n\n    await new Promise((resolve) => this.server.close(() => resolve(undefined)))\n  }\n\n  /**\n   * @returns {number} - Bound port.\n   */\n  getPort() {\n    return this.port\n  }\n\n  /**\n   * @param {import(\"net\").Socket} socket - Socket.\n   * @returns {void}\n   */\n  _handleConnection(socket) {\n    const jsonSocket = new JsonSocket(socket)\n    let role = null\n\n    const cleanup = () => {\n      if (role === \"worker\") {\n        this.workers.delete(jsonSocket)\n        this.readyWorkers.delete(jsonSocket)\n      }\n    }\n\n    jsonSocket.on(\"close\", cleanup)\n    jsonSocket.on(\"error\", (error) => {\n      this.logger.warn(() => [\"Background jobs connection error:\", error])\n      cleanup()\n    })\n\n    jsonSocket.on(\"message\", (message) => {\n      if (!role && message?.type === \"hello\") {\n        role = message.role\n\n        if (role === \"worker\") {\n          jsonSocket.workerId = message.workerId\n          this.workers.add(jsonSocket)\n          this.readyWorkers.add(jsonSocket)\n          this._dispatch()\n        }\n\n        return\n      }\n\n      if (role === \"client\" && message?.type === \"enqueue\") {\n        this._handleEnqueue({jsonSocket, message})\n        return\n      }\n\n      if (role === \"worker\" && message?.type === \"ready\") {\n        this.readyWorkers.add(jsonSocket)\n        this._dispatch()\n        return\n      }\n\n      if ((role === \"worker\" || role === \"reporter\") && message?.type === \"job-complete\") {\n        this._handleJobComplete({jsonSocket, message})\n        return\n      }\n\n      if ((role === \"worker\" || role === \"reporter\") && message?.type === \"job-failed\") {\n        this._handleJobFailed({jsonSocket, message})\n      }\n    })\n  }\n\n  async _handleEnqueue({jsonSocket, message}) {\n    try {\n      const jobId = await this.store.enqueue({\n        jobName: message.jobName,\n        args: message.args || [],\n        options: message.options || {}\n      })\n\n      jsonSocket.send({type: \"enqueued\", jobId})\n      await this._dispatch()\n    } catch (error) {\n      this.logger.error(() => [\"Failed to enqueue background job:\", error])\n      jsonSocket.send({type: \"enqueue-error\", error: \"Failed to enqueue job\"})\n    }\n  }\n\n  async _handleJobComplete({jsonSocket, message}) {\n    try {\n      await this.store.markCompleted({\n        jobId: message.jobId,\n        workerId: message.workerId,\n        handedOffAtMs: message.handedOffAtMs\n      })\n      jsonSocket.send({type: \"job-updated\", jobId: message.jobId})\n    } catch (error) {\n      this.logger.error(() => [\"Failed to update job completion:\", error])\n      jsonSocket.send({type: \"job-update-error\", jobId: message.jobId, error: \"Failed to update job\"})\n    }\n  }\n\n  async _handleJobFailed({jsonSocket, message}) {\n    try {\n      await this.store.markFailed({\n        jobId: message.jobId,\n        error: message.error,\n        workerId: message.workerId,\n        handedOffAtMs: message.handedOffAtMs\n      })\n      jsonSocket.send({type: \"job-updated\", jobId: message.jobId})\n      await this._dispatch()\n    } catch (error) {\n      this.logger.error(() => [\"Failed to update job failure:\", error])\n      jsonSocket.send({type: \"job-update-error\", jobId: message.jobId, error: \"Failed to update job\"})\n    }\n  }\n\n  async _dispatch() {\n    if (this._dispatching) return\n    if (this.readyWorkers.size === 0) return\n\n    this._dispatching = true\n\n    try {\n      while (this.readyWorkers.size > 0) {\n        const job = await this.store.nextAvailableJob()\n        if (!job) return\n\n        const [worker] = this.readyWorkers\n        if (!worker) return\n\n        this.readyWorkers.delete(worker)\n\n        const handedOffAtMs = await this.store.markHandedOff({jobId: job.id, workerId: worker.workerId})\n\n        try {\n          worker.send({\n            type: \"job\",\n            payload: {\n              id: job.id,\n              jobName: job.jobName,\n              args: job.args,\n              workerId: worker.workerId,\n              handedOffAtMs,\n              options: {\n                forked: job.forked\n              }\n            }\n          })\n        } catch (error) {\n          this.logger.warn(() => [\"Failed to send job to worker, re-queueing:\", error])\n          await this.store.markReturnedToQueue({jobId: job.id})\n          this.readyWorkers.add(worker)\n        }\n      }\n    } finally {\n      this._dispatching = false\n    }\n  }\n\n  async _sweepOrphans() {\n    try {\n      const count = await this.store.markOrphanedJobs()\n\n      if (count > 0) {\n        this.logger.warn(() => [\"Marked orphaned background jobs\", count])\n      }\n    } catch (error) {\n      this.logger.error(() => [\"Failed to mark orphaned jobs:\", error])\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,69 @@
+/**
+ * @param {number | string} value - Duration value.
+ * @param {string} fieldName - Field name for errors.
+ * @returns {number} - Duration in milliseconds.
+ */
+export function parseScheduledDuration(value: number | string, fieldName: string): number;
+/** Runs configured recurring background job schedules. */
+export default class BackgroundJobsScheduler {
+    /**
+     * @param {object} args - Options.
+     * @param {import("../configuration.js").default} args.configuration - Configuration.
+     * @param {function({args: any[], jobClass: typeof import("./job.js").default, jobKey: string, options: import("./types.js").BackgroundJobOptions}) : Promise<void>} args.enqueueJob - Enqueue callback.
+     */
+    constructor({ configuration, enqueueJob }: {
+        configuration: import("../configuration.js").default;
+        enqueueJob: (arg0: {
+            args: any[];
+            jobClass: typeof import("./job.js").default;
+            jobKey: string;
+            options: import("./types.js").BackgroundJobOptions;
+        }) => Promise<void>;
+    });
+    configuration: import("../configuration.js").default;
+    enqueueJob: (arg0: {
+        args: any[];
+        jobClass: typeof import("./job.js").default;
+        jobKey: string;
+        options: import("./types.js").BackgroundJobOptions;
+    }) => Promise<void>;
+    logger: Logger;
+    /** @type {Array<ReturnType<typeof setInterval>>} */
+    intervalIds: Array<ReturnType<typeof setInterval>>;
+    /** @type {Array<ReturnType<typeof setTimeout>>} */
+    timeoutIds: Array<ReturnType<typeof setTimeout>>;
+    /** @returns {Promise<void>} */
+    start(): Promise<void>;
+    /** @returns {void} */
+    stop(): void;
+    /**
+     * @param {object} args - Options.
+     * @param {import("../configuration-types.js").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.
+     * @param {string} args.jobKey - Job key.
+     * @returns {void}
+     */
+    scheduleJob({ jobConfiguration, jobKey }: {
+        jobConfiguration: import("../configuration-types.js").ScheduledBackgroundJobConfiguration;
+        jobKey: string;
+    }): void;
+    /**
+     * @param {object} args - Options.
+     * @param {import("../configuration-types.js").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.
+     * @param {string} args.jobKey - Job key.
+     * @returns {Promise<void>}
+     */
+    enqueueScheduledJob({ jobConfiguration, jobKey }: {
+        jobConfiguration: import("../configuration-types.js").ScheduledBackgroundJobConfiguration;
+        jobKey: string;
+    }): Promise<void>;
+    /**
+     * @param {import("../configuration-types.js").ScheduledBackgroundJobConfiguration["every"]} every - Every config.
+     * @returns {{everyValue: number | string, firstInValue?: number | string}} - Normalized interval and first-run delay values.
+     */
+    normalizeEvery(every: import("../configuration-types.js").ScheduledBackgroundJobConfiguration["every"]): {
+        everyValue: number | string;
+        firstInValue?: number | string;
+    };
+}
+import Logger from "../logger.js";
+//# sourceMappingURL=scheduler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/scheduler.js"],"names":[],"mappings":"AAuBA;;;;GAIG;AACH,8CAJW,MAAM,GAAG,MAAM,aACf,MAAM,GACJ,MAAM,CA8BlB;AAED,0DAA0D;AAC1D;IACE;;;;OAIG;IACH,2CAHG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QAC0H,UAAU,EAAzK,CAAS,IAA8H,EAA9H;YAAC,IAAI,EAAE,GAAG,EAAE,CAAC;YAAC,QAAQ,EAAE,cAAc,UAAU,EAAE,OAAO,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,OAAO,YAAY,EAAE,oBAAoB,CAAA;SAAC,KAAI,OAAO,CAAC,IAAI,CAAC;KAClK,EASA;IAPC,qDAAkC;IAClC,mBAJkB;QAAC,IAAI,EAAE,GAAG,EAAE,CAAC;QAAC,QAAQ,EAAE,cAAc,UAAU,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,YAAY,EAAE,oBAAoB,CAAA;KAAC,KAAI,OAAO,CAAC,IAAI,CAAC,CAIrI;IAC5B,eAA8B;IAC9B,oDAAoD;IACpD,aADW,KAAK,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,CAC3B;IACrB,mDAAmD;IACnD,YADW,KAAK,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,CAC3B;IAGtB,+BAA+B;IAC/B,SADc,OAAO,CAAC,IAAI,CAAC,CAiB1B;IAED,sBAAsB;IACtB,QADc,IAAI,CAYjB;IAED;;;;;OAKG;IACH,0CAJG;QAAsF,gBAAgB,EAA9F,OAAO,2BAA2B,EAAE,mCAAmC;QAC1D,MAAM,EAAnB,MAAM;KACd,GAAU,IAAI,CA0BhB;IAED;;;;;OAKG;IACH,kDAJG;QAAsF,gBAAgB,EAA9F,OAAO,2BAA2B,EAAE,mCAAmC;QAC1D,MAAM,EAAnB,MAAM;KACd,GAAU,OAAO,CAAC,IAAI,CAAC,CAazB;IAED;;;OAGG;IACH,sBAHW,OAAO,2BAA2B,EAAE,mCAAmC,CAAC,OAAO,CAAC,GAC9E;QAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAC,CAczE;CACF;mBA9KkB,cAAc"}

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

@@ -0,0 +1,148 @@
+// @ts-check
+import Logger from "../logger.js";
+const DURATION_MULTIPLIERS = {
+    d: 24 * 60 * 60 * 1000,
+    day: 24 * 60 * 60 * 1000,
+    days: 24 * 60 * 60 * 1000,
+    h: 60 * 60 * 1000,
+    hour: 60 * 60 * 1000,
+    hours: 60 * 60 * 1000,
+    m: 60 * 1000,
+    minute: 60 * 1000,
+    minutes: 60 * 1000,
+    ms: 1,
+    s: 1000,
+    second: 1000,
+    seconds: 1000,
+    w: 7 * 24 * 60 * 60 * 1000,
+    week: 7 * 24 * 60 * 60 * 1000,
+    weeks: 7 * 24 * 60 * 60 * 1000
+};
+/**
+ * @param {number | string} value - Duration value.
+ * @param {string} fieldName - Field name for errors.
+ * @returns {number} - Duration in milliseconds.
+ */
+export function parseScheduledDuration(value, fieldName) {
+    if (typeof value === "number") {
+        if (!Number.isFinite(value) || value < 1) {
+            throw new Error(`Scheduled background job ${fieldName} must be a positive number of milliseconds.`);
+        }
+        return value;
+    }
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`Scheduled background job ${fieldName} must be a non-empty string or number.`);
+    }
+    const normalizedValue = value.trim().toLowerCase();
+    const match = normalizedValue.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w|second|seconds|minute|minutes|hour|hours|day|days|week|weeks)$/);
+    if (!match) {
+        throw new Error(`Invalid scheduled background job ${fieldName}: ${value}`);
+    }
+    const numericValue = Number(match[1]);
+    const multiplier = DURATION_MULTIPLIERS[match[2]];
+    if (!multiplier) {
+        throw new Error(`Invalid scheduled background job ${fieldName}: ${value}`);
+    }
+    return Math.round(numericValue * multiplier);
+}
+/** Runs configured recurring background job schedules. */
+export default class BackgroundJobsScheduler {
+    /**
+     * @param {object} args - Options.
+     * @param {import("../configuration.js").default} args.configuration - Configuration.
+     * @param {function({args: any[], jobClass: typeof import("./job.js").default, jobKey: string, options: import("./types.js").BackgroundJobOptions}) : Promise<void>} args.enqueueJob - Enqueue callback.
+     */
+    constructor({ configuration, enqueueJob }) {
+        this.configuration = configuration;
+        this.enqueueJob = enqueueJob;
+        this.logger = new Logger(this);
+        /** @type {Array<ReturnType<typeof setInterval>>} */
+        this.intervalIds = [];
+        /** @type {Array<ReturnType<typeof setTimeout>>} */
+        this.timeoutIds = [];
+    }
+    /** @returns {Promise<void>} */
+    async start() {
+        const scheduledBackgroundJobsConfig = await this.configuration.getScheduledBackgroundJobsConfig();
+        if (!scheduledBackgroundJobsConfig?.jobs) {
+            return;
+        }
+        for (const jobKey of Object.keys(scheduledBackgroundJobsConfig.jobs)) {
+            const jobConfiguration = scheduledBackgroundJobsConfig.jobs[jobKey];
+            if (!jobConfiguration || jobConfiguration.enabled === false) {
+                continue;
+            }
+            this.scheduleJob({ jobConfiguration, jobKey });
+        }
+    }
+    /** @returns {void} */
+    stop() {
+        for (const intervalId of this.intervalIds) {
+            clearInterval(intervalId);
+        }
+        for (const timeoutId of this.timeoutIds) {
+            clearTimeout(timeoutId);
+        }
+        this.intervalIds = [];
+        this.timeoutIds = [];
+    }
+    /**
+     * @param {object} args - Options.
+     * @param {import("../configuration-types.js").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.
+     * @param {string} args.jobKey - Job key.
+     * @returns {void}
+     */
+    scheduleJob({ jobConfiguration, jobKey }) {
+        const { everyValue, firstInValue } = this.normalizeEvery(jobConfiguration.every);
+        const intervalMs = parseScheduledDuration(everyValue, `${jobKey}.every`);
+        const firstInMs = firstInValue !== undefined ? parseScheduledDuration(firstInValue, `${jobKey}.first_in`) : intervalMs;
+        if (intervalMs < 1) {
+            throw new Error(`Scheduled background job ${jobKey}.every must be at least 1 millisecond.`);
+        }
+        if (!jobConfiguration.class || typeof jobConfiguration.class.performLaterWithOptions !== "function") {
+            throw new Error(`Scheduled background job ${jobKey} must define a job class.`);
+        }
+        const timeoutId = setTimeout(() => {
+            void this.enqueueScheduledJob({ jobConfiguration, jobKey });
+            const intervalId = setInterval(() => {
+                void this.enqueueScheduledJob({ jobConfiguration, jobKey });
+            }, intervalMs);
+            this.intervalIds.push(intervalId);
+        }, firstInMs);
+        this.timeoutIds.push(timeoutId);
+    }
+    /**
+     * @param {object} args - Options.
+     * @param {import("../configuration-types.js").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.
+     * @param {string} args.jobKey - Job key.
+     * @returns {Promise<void>}
+     */
+    async enqueueScheduledJob({ jobConfiguration, jobKey }) {
+        try {
+            await this.enqueueJob({
+                args: Array.isArray(jobConfiguration.args) ? jobConfiguration.args : [],
+                jobClass: jobConfiguration.class,
+                jobKey,
+                options: jobConfiguration.options || {}
+            });
+        }
+        catch (error) {
+            await this.logger.error(() => ["Failed to enqueue scheduled background job", { jobKey, jobName: jobConfiguration.class.jobName() }, error]);
+        }
+    }
+    /**
+     * @param {import("../configuration-types.js").ScheduledBackgroundJobConfiguration["every"]} every - Every config.
+     * @returns {{everyValue: number | string, firstInValue?: number | string}} - Normalized interval and first-run delay values.
+     */
+    normalizeEvery(every) {
+        if (Array.isArray(every)) {
+            const [everyValue, everyOptions] = every;
+            if (!everyOptions || typeof everyOptions !== "object" || Array.isArray(everyOptions)) {
+                return { everyValue };
+            }
+            return { everyValue, firstInValue: everyOptions.firstIn ?? everyOptions.first_in };
+        }
+        return { everyValue: every };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../../../src/background-jobs/scheduler.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Logger from \"../logger.js\"\n\nconst DURATION_MULTIPLIERS = {\n  d: 24 * 60 * 60 * 1000,\n  day: 24 * 60 * 60 * 1000,\n  days: 24 * 60 * 60 * 1000,\n  h: 60 * 60 * 1000,\n  hour: 60 * 60 * 1000,\n  hours: 60 * 60 * 1000,\n  m: 60 * 1000,\n  minute: 60 * 1000,\n  minutes: 60 * 1000,\n  ms: 1,\n  s: 1000,\n  second: 1000,\n  seconds: 1000,\n  w: 7 * 24 * 60 * 60 * 1000,\n  week: 7 * 24 * 60 * 60 * 1000,\n  weeks: 7 * 24 * 60 * 60 * 1000\n}\n\n/**\n * @param {number | string} value - Duration value.\n * @param {string} fieldName - Field name for errors.\n * @returns {number} - Duration in milliseconds.\n */\nexport function parseScheduledDuration(value, fieldName) {\n  if (typeof value === \"number\") {\n    if (!Number.isFinite(value) || value < 1) {\n      throw new Error(`Scheduled background job ${fieldName} must be a positive number of milliseconds.`)\n    }\n\n    return value\n  }\n\n  if (typeof value !== \"string\" || !value.trim()) {\n    throw new Error(`Scheduled background job ${fieldName} must be a non-empty string or number.`)\n  }\n\n  const normalizedValue = value.trim().toLowerCase()\n  const match = normalizedValue.match(/^(\\d+(?:\\.\\d+)?)\\s*(ms|s|m|h|d|w|second|seconds|minute|minutes|hour|hours|day|days|week|weeks)$/)\n\n  if (!match) {\n    throw new Error(`Invalid scheduled background job ${fieldName}: ${value}`)\n  }\n\n  const numericValue = Number(match[1])\n  const multiplier = DURATION_MULTIPLIERS[match[2]]\n\n  if (!multiplier) {\n    throw new Error(`Invalid scheduled background job ${fieldName}: ${value}`)\n  }\n\n  return Math.round(numericValue * multiplier)\n}\n\n/** Runs configured recurring background job schedules. */\nexport default class BackgroundJobsScheduler {\n  /**\n   * @param {object} args - Options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration.\n   * @param {function({args: any[], jobClass: typeof import(\"./job.js\").default, jobKey: string, options: import(\"./types.js\").BackgroundJobOptions}) : Promise<void>} args.enqueueJob - Enqueue callback.\n   */\n  constructor({configuration, enqueueJob}) {\n    this.configuration = configuration\n    this.enqueueJob = enqueueJob\n    this.logger = new Logger(this)\n    /** @type {Array<ReturnType<typeof setInterval>>} */\n    this.intervalIds = []\n    /** @type {Array<ReturnType<typeof setTimeout>>} */\n    this.timeoutIds = []\n  }\n\n  /** @returns {Promise<void>} */\n  async start() {\n    const scheduledBackgroundJobsConfig = await this.configuration.getScheduledBackgroundJobsConfig()\n\n    if (!scheduledBackgroundJobsConfig?.jobs) {\n      return\n    }\n\n    for (const jobKey of Object.keys(scheduledBackgroundJobsConfig.jobs)) {\n      const jobConfiguration = scheduledBackgroundJobsConfig.jobs[jobKey]\n\n      if (!jobConfiguration || jobConfiguration.enabled === false) {\n        continue\n      }\n\n      this.scheduleJob({jobConfiguration, jobKey})\n    }\n  }\n\n  /** @returns {void} */\n  stop() {\n    for (const intervalId of this.intervalIds) {\n      clearInterval(intervalId)\n    }\n\n    for (const timeoutId of this.timeoutIds) {\n      clearTimeout(timeoutId)\n    }\n\n    this.intervalIds = []\n    this.timeoutIds = []\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {import(\"../configuration-types.js\").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.\n   * @param {string} args.jobKey - Job key.\n   * @returns {void}\n   */\n  scheduleJob({jobConfiguration, jobKey}) {\n    const {everyValue, firstInValue} = this.normalizeEvery(jobConfiguration.every)\n    const intervalMs = parseScheduledDuration(everyValue, `${jobKey}.every`)\n    const firstInMs = firstInValue !== undefined ? parseScheduledDuration(firstInValue, `${jobKey}.first_in`) : intervalMs\n\n    if (intervalMs < 1) {\n      throw new Error(`Scheduled background job ${jobKey}.every must be at least 1 millisecond.`)\n    }\n\n    if (!jobConfiguration.class || typeof jobConfiguration.class.performLaterWithOptions !== \"function\") {\n      throw new Error(`Scheduled background job ${jobKey} must define a job class.`)\n    }\n\n    const timeoutId = setTimeout(() => {\n      void this.enqueueScheduledJob({jobConfiguration, jobKey})\n\n      const intervalId = setInterval(() => {\n        void this.enqueueScheduledJob({jobConfiguration, jobKey})\n      }, intervalMs)\n\n      this.intervalIds.push(intervalId)\n    }, firstInMs)\n\n    this.timeoutIds.push(timeoutId)\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {import(\"../configuration-types.js\").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.\n   * @param {string} args.jobKey - Job key.\n   * @returns {Promise<void>}\n   */\n  async enqueueScheduledJob({jobConfiguration, jobKey}) {\n    try {\n      await this.enqueueJob({\n        args: Array.isArray(jobConfiguration.args) ? jobConfiguration.args : [],\n        jobClass: jobConfiguration.class,\n        jobKey,\n        options: jobConfiguration.options || {}\n      })\n    } catch (error) {\n      await this.logger.error(() => [\"Failed to enqueue scheduled background job\", {jobKey, jobName: jobConfiguration.class.jobName()}, error])\n    }\n  }\n\n  /**\n   * @param {import(\"../configuration-types.js\").ScheduledBackgroundJobConfiguration[\"every\"]} every - Every config.\n   * @returns {{everyValue: number | string, firstInValue?: number | string}} - Normalized interval and first-run delay values.\n   */\n  normalizeEvery(every) {\n    if (Array.isArray(every)) {\n      const [everyValue, everyOptions] = every\n\n      if (!everyOptions || typeof everyOptions !== \"object\" || Array.isArray(everyOptions)) {\n        return {everyValue}\n      }\n\n      return {everyValue, firstInValue: everyOptions.firstIn ?? everyOptions.first_in}\n    }\n\n    return {everyValue: every}\n  }\n}\n"]}