@redmix/jobs 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Redmix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# RedwoodJob
+
+Provides background job scheduling and processing for Redwood.

package/dist/adapters/BaseAdapter/BaseAdapter.d.ts

@@ -0,0 +1,64 @@
+import type { BaseJob, BasicLogger, PossibleBaseJob } from '../../types.js';
+export interface SchedulePayload {
+    name: string;
+    path: string;
+    args: unknown[];
+    runAt: Date;
+    queue: string;
+    priority: number;
+}
+export interface FindArgs {
+    processName: string;
+    maxRuntime: number;
+    queues: string[];
+}
+export interface BaseAdapterOptions {
+    logger?: BasicLogger;
+}
+export interface SuccessOptions<TJob extends BaseJob = BaseJob> {
+    job: TJob;
+    deleteJob?: boolean;
+}
+export interface ErrorOptions<TJob extends BaseJob = BaseJob> {
+    job: TJob;
+    error: Error;
+}
+export interface FailureOptions<TJob extends BaseJob = BaseJob> {
+    job: TJob;
+    deleteJob?: boolean;
+}
+/**
+ * Base class for all job adapters. Provides a common interface for scheduling
+ * jobs. At a minimum, you must implement the `schedule` method in your adapter.
+ *
+ * Any object passed to the constructor is saved in `this.options` and should
+ * be used to configure your custom adapter. If `options.logger` is included
+ * you can access it via `this.logger`
+ */
+export declare abstract class BaseAdapter<TOptions extends BaseAdapterOptions = BaseAdapterOptions, TScheduleReturn = void | Promise<void>> {
+    options: TOptions;
+    logger: NonNullable<TOptions['logger']>;
+    constructor(options: TOptions);
+    abstract schedule(payload: SchedulePayload): TScheduleReturn;
+    /**
+     * Find a single job that's eligible to run with the given args
+     */
+    abstract find(args: FindArgs): PossibleBaseJob | Promise<PossibleBaseJob>;
+    /**
+     * Called when a job has successfully completed
+     */
+    abstract success(options: SuccessOptions): void | Promise<void>;
+    /**
+     * Called when an attempt to run a job produced an error
+     */
+    abstract error(options: ErrorOptions): void | Promise<void>;
+    /**
+     * Called when a job has errored more than maxAttempts and will not be retried
+     */
+    abstract failure(options: FailureOptions): void | Promise<void>;
+    /**
+     * Clear all jobs from storage
+     */
+    abstract clear(): void | Promise<void>;
+}
+//# sourceMappingURL=BaseAdapter.d.ts.map

package/dist/adapters/BaseAdapter/BaseAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/BaseAdapter/BaseAdapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAG3E,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,OAAO,EAAE,CAAA;IACf,KAAK,EAAE,IAAI,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,QAAQ;IACvB,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED,MAAM,WAAW,cAAc,CAAC,IAAI,SAAS,OAAO,GAAG,OAAO;IAC5D,GAAG,EAAE,IAAI,CAAA;IACT,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED,MAAM,WAAW,YAAY,CAAC,IAAI,SAAS,OAAO,GAAG,OAAO;IAC1D,GAAG,EAAE,IAAI,CAAA;IACT,KAAK,EAAE,KAAK,CAAA;CACb;AAED,MAAM,WAAW,cAAc,CAAC,IAAI,SAAS,OAAO,GAAG,OAAO;IAC5D,GAAG,EAAE,IAAI,CAAA;IACT,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED;;;;;;;GAOG;AACH,8BAAsB,WAAW,CAC/B,QAAQ,SAAS,kBAAkB,GAAG,kBAAkB,EACxD,eAAe,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAEtC,OAAO,EAAE,QAAQ,CAAA;IACjB,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAA;gBAE3B,OAAO,EAAE,QAAQ;IAU7B,QAAQ,CAAC,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,eAAe;IAE5D;;OAEG;IACH,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IAEzE;;OAEG;IACH,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAE/D;;OAEG;IACH,QAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAE3D;;OAEG;IACH,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAE/D;;OAEG;IACH,QAAQ,CAAC,KAAK,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CACvC"}

package/dist/adapters/BaseAdapter/BaseAdapter.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var BaseAdapter_exports = {};
+__export(BaseAdapter_exports, {
+  BaseAdapter: () => BaseAdapter
+});
+module.exports = __toCommonJS(BaseAdapter_exports);
+var import_consts = require("../../consts.js");
+class BaseAdapter {
+  options;
+  logger;
+  constructor(options) {
+    this.options = options;
+    this.logger = options?.logger ?? import_consts.DEFAULT_LOGGER;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseAdapter
+});

package/dist/adapters/PrismaAdapter/PrismaAdapter.d.ts

@@ -0,0 +1,68 @@
+import type { PrismaClient } from '@prisma/client';
+import type { BaseJob } from '../../types.js';
+import type { BaseAdapterOptions, SchedulePayload, FindArgs, SuccessOptions, ErrorOptions, FailureOptions } from '../BaseAdapter/BaseAdapter.js';
+import { BaseAdapter } from '../BaseAdapter/BaseAdapter.js';
+export interface PrismaJob extends BaseJob {
+    id: number;
+    handler: string;
+    runAt: Date;
+    lockedAt: Date;
+    lockedBy: string;
+    lastError: string | null;
+    failedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface PrismaAdapterOptions extends BaseAdapterOptions {
+    /**
+     * An instance of PrismaClient which will be used to talk to the database
+     */
+    db: PrismaClient;
+    /**
+     * The name of the model in the Prisma schema that represents the job table.
+     * @default 'BackgroundJob'
+     */
+    model?: string;
+}
+/**
+ * Implements a job adapter using Prisma ORM.
+ *
+ * Assumes a table exists with the following schema (the table name can be customized):
+ * ```prisma
+ * model BackgroundJob {
+ *   id        Int       \@id \@default(autoincrement())
+ *   attempts  Int       \@default(0)
+ *   handler   String
+ *   queue     String
+ *   priority  Int
+ *   runAt     DateTime
+ *   lockedAt  DateTime?
+ *   lockedBy  String?
+ *   lastError String?
+ *   failedAt  DateTime?
+ *   createdAt DateTime  \@default(now())
+ *   updatedAt DateTime  \@updatedAt
+ * }
+ * ```
+ */
+export declare class PrismaAdapter extends BaseAdapter<PrismaAdapterOptions> {
+    db: PrismaClient;
+    model: string;
+    accessor: PrismaClient[keyof PrismaClient];
+    provider: string;
+    constructor(options: PrismaAdapterOptions);
+    /**
+     * Finds the next job to run, locking it so that no other process can pick it
+     * The act of locking a job is dependant on the DB server, so we'll run some
+     * raw SQL to do it in each case—Prisma doesn't provide enough flexibility
+     * in their generated code to do this in a DB-agnostic way.
+     */
+    find({ processName, maxRuntime, queues, }: FindArgs): Promise<PrismaJob | undefined>;
+    success({ job, deleteJob }: SuccessOptions<PrismaJob>): Promise<void>;
+    error({ job, error }: ErrorOptions<PrismaJob>): Promise<void>;
+    failure({ job, deleteJob }: FailureOptions<PrismaJob>): Promise<void>;
+    schedule({ name, path, args, runAt, queue, priority, }: SchedulePayload): Promise<void>;
+    clear(): Promise<void>;
+    backoffMilliseconds(attempts: number): number;
+}
+//# sourceMappingURL=PrismaAdapter.d.ts.map

package/dist/adapters/PrismaAdapter/PrismaAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrismaAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/PrismaAdapter/PrismaAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAIlD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,KAAK,EACV,kBAAkB,EAClB,eAAe,EACf,QAAQ,EACR,cAAc,EACd,YAAY,EACZ,cAAc,EACf,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAI3D,MAAM,WAAW,SAAU,SAAQ,OAAO;IACxC,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,IAAI,CAAA;IACX,QAAQ,EAAE,IAAI,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAA;IACrB,SAAS,EAAE,IAAI,CAAA;IACf,SAAS,EAAE,IAAI,CAAA;CAChB;AAED,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC9D;;OAEG;IACH,EAAE,EAAE,YAAY,CAAA;IAEhB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAUD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,aAAc,SAAQ,WAAW,CAAC,oBAAoB,CAAC;IAClE,EAAE,EAAE,YAAY,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,YAAY,CAAC,MAAM,YAAY,CAAC,CAAA;IAC1C,QAAQ,EAAE,MAAM,CAAA;gBAEJ,OAAO,EAAE,oBAAoB;IAqBzC;;;;;OAKG;IACY,IAAI,CAAC,EAClB,WAAW,EACX,UAAU,EACV,MAAM,GACP,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IA4F7B,OAAO,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,cAAc,CAAC,SAAS,CAAC;IAkBrD,KAAK,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,YAAY,CAAC,SAAS,CAAC;IAmB7C,OAAO,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,cAAc,CAAC,SAAS,CAAC;IAYrD,QAAQ,CAAC,EACtB,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,KAAK,EACL,QAAQ,GACT,EAAE,eAAe;IAWH,KAAK;IAIpB,mBAAmB,CAAC,QAAQ,EAAE,MAAM;CAGrC"}

package/dist/adapters/PrismaAdapter/PrismaAdapter.js

@@ -0,0 +1,189 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PrismaAdapter_exports = {};
+__export(PrismaAdapter_exports, {
+  PrismaAdapter: () => PrismaAdapter
+});
+module.exports = __toCommonJS(PrismaAdapter_exports);
+var import_change_case = require("change-case");
+var import_consts = require("../../consts.js");
+var import_BaseAdapter = require("../BaseAdapter/BaseAdapter.js");
+var import_errors = require("./errors.js");
+class PrismaAdapter extends import_BaseAdapter.BaseAdapter {
+  db;
+  model;
+  accessor;
+  provider;
+  constructor(options) {
+    super(options);
+    this.db = options.db;
+    this.model = options.model || import_consts.DEFAULT_MODEL_NAME;
+    this.accessor = this.db[(0, import_change_case.camelCase)(this.model)];
+    this.provider = options.db._activeProvider;
+    if (!this.accessor) {
+      throw new import_errors.ModelNameError(this.model);
+    }
+  }
+  /**
+   * Finds the next job to run, locking it so that no other process can pick it
+   * The act of locking a job is dependant on the DB server, so we'll run some
+   * raw SQL to do it in each case—Prisma doesn't provide enough flexibility
+   * in their generated code to do this in a DB-agnostic way.
+   */
+  async find({
+    processName,
+    maxRuntime,
+    queues
+  }) {
+    const maxRuntimeExpire = new Date(
+      (/* @__PURE__ */ new Date()).getTime() + (maxRuntime || import_consts.DEFAULT_MAX_RUNTIME * 1e3)
+    );
+    const where = {
+      AND: [
+        {
+          OR: [
+            {
+              AND: [
+                { runAt: { lte: /* @__PURE__ */ new Date() } },
+                {
+                  OR: [
+                    { lockedAt: null },
+                    {
+                      lockedAt: {
+                        lt: maxRuntimeExpire
+                      }
+                    }
+                  ]
+                }
+              ]
+            },
+            { lockedBy: processName }
+          ]
+        },
+        { failedAt: null }
+      ]
+    };
+    const whereWithQueue = where;
+    if (queues.length > 1 || queues[0] !== "*") {
+      Object.assign(whereWithQueue, {
+        AND: [...where.AND, { queue: { in: queues } }]
+      });
+    }
+    const job = await this.accessor.findFirst({
+      select: { id: true, attempts: true },
+      where: whereWithQueue,
+      orderBy: [{ priority: "asc" }, { runAt: "asc" }],
+      take: 1
+    });
+    if (job) {
+      const whereWithQueueAndId = Object.assign(whereWithQueue, {
+        AND: [...whereWithQueue.AND, { id: job.id }]
+      });
+      const { count } = await this.accessor.updateMany({
+        where: whereWithQueueAndId,
+        data: {
+          lockedAt: /* @__PURE__ */ new Date(),
+          lockedBy: processName,
+          attempts: job.attempts + 1
+        }
+      });
+      if (count) {
+        const data = await this.accessor.findFirst({ where: { id: job.id } });
+        const { name, path, args } = JSON.parse(data.handler);
+        return { ...data, name, path, args };
+      }
+    }
+    return void 0;
+  }
+  // Prisma queries are lazily evaluated and only sent to the db when they are
+  // awaited, so do the await here to ensure they actually run (if the user
+  // doesn't await the Promise then the queries will never be executed!)
+  async success({ job, deleteJob }) {
+    this.logger.debug(`[RedwoodJob] Job ${job.id} success`);
+    if (deleteJob) {
+      await this.accessor.delete({ where: { id: job.id } });
+    } else {
+      await this.accessor.update({
+        where: { id: job.id },
+        data: {
+          lockedAt: null,
+          lockedBy: null,
+          lastError: null,
+          runAt: null
+        }
+      });
+    }
+  }
+  async error({ job, error }) {
+    this.logger.debug(`[RedwoodJob] Job ${job.id} failure`);
+    const data = {
+      lockedAt: null,
+      lockedBy: null,
+      lastError: `${error.message}
+
+${error.stack}`,
+      runAt: new Date(
+        (/* @__PURE__ */ new Date()).getTime() + this.backoffMilliseconds(job.attempts)
+      )
+    };
+    await this.accessor.update({
+      where: { id: job.id },
+      data
+    });
+  }
+  // Job has had too many attempts, it has now permanently failed.
+  async failure({ job, deleteJob }) {
+    if (deleteJob) {
+      await this.accessor.delete({ where: { id: job.id } });
+    } else {
+      await this.accessor.update({
+        where: { id: job.id },
+        data: { failedAt: /* @__PURE__ */ new Date() }
+      });
+    }
+  }
+  // Schedules a job by creating a new record in the background job table
+  async schedule({
+    name,
+    path,
+    args,
+    runAt,
+    queue,
+    priority
+  }) {
+    await this.accessor.create({
+      data: {
+        handler: JSON.stringify({ name, path, args }),
+        runAt,
+        queue,
+        priority
+      }
+    });
+  }
+  async clear() {
+    await this.accessor.deleteMany();
+  }
+  backoffMilliseconds(attempts) {
+    return 1e3 * attempts ** 4;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PrismaAdapter
+});

package/dist/adapters/PrismaAdapter/errors.d.ts

@@ -0,0 +1,8 @@
+import { RedwoodJobError } from '../../errors.js';
+/**
+ * Thrown when a given model name isn't actually available in the PrismaClient
+ */
+export declare class ModelNameError extends RedwoodJobError {
+    constructor(name: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/adapters/PrismaAdapter/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/adapters/PrismaAdapter/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEjD;;GAEG;AACH,qBAAa,cAAe,SAAQ,eAAe;gBACrC,IAAI,EAAE,MAAM;CAGzB"}

package/dist/adapters/PrismaAdapter/errors.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  ModelNameError: () => ModelNameError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_errors = require("../../errors.js");
+class ModelNameError extends import_errors.RedwoodJobError {
+  constructor(name) {
+    super(`Model \`${name}\` not found in PrismaClient`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModelNameError
+});

package/dist/bins/rw-jobs-worker.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import type { Worker } from '../core/Worker.js';
+export declare const processName: ({ id, queues, }: {
+    id: number;
+    queues: string | string[];
+}) => string;
+export declare const getWorker: ({ index, id, clear, workoff, }: {
+    index: number;
+    id: number;
+    clear: boolean;
+    workoff: boolean;
+}) => Promise<Worker>;
+//# sourceMappingURL=rw-jobs-worker.d.ts.map

package/dist/bins/rw-jobs-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rw-jobs-worker.d.ts","sourceRoot":"","sources":["../../src/bins/rw-jobs-worker.ts"],"names":[],"mappings":";AAWA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAqC/C,eAAO,MAAM,WAAW,oBAGrB;IACD,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAC1B,WAEA,CAAA;AAwBD,eAAO,MAAM,SAAS,mCAKnB;IACD,KAAK,EAAE,MAAM,CAAA;IACb,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;CACjB,oBAqBA,CAAA"}

package/dist/bins/rw-jobs-worker.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rw_jobs_worker_exports = {};
+__export(rw_jobs_worker_exports, {
+  getWorker: () => getWorker,
+  processName: () => processName
+});
+module.exports = __toCommonJS(rw_jobs_worker_exports);
+var import_node_process = __toESM(require("node:process"));
+var import_helpers = require("yargs/helpers");
+var import_yargs = __toESM(require("yargs/yargs"));
+var import_consts = require("../consts.js");
+var import_errors = require("../errors.js");
+var import_loaders = require("../loaders.js");
+var import_setupEnv = require("../setupEnv.js");
+(0, import_setupEnv.setupEnv)();
+const parseArgs = (argv) => {
+  return (0, import_yargs.default)((0, import_helpers.hideBin)(argv)).usage(
+    "Starts a single RedwoodJob worker to process background jobs\n\nUsage: $0 [options]"
+  ).option("index", {
+    type: "number",
+    required: true,
+    description: "The index of the `workers` array from the exported `jobs` config to use to configure this worker"
+  }).option("id", {
+    type: "number",
+    required: true,
+    description: "The worker count id to identify this worker. ie: if you had `count: 2` in your worker config, you would have two workers with ids 0 and 1"
+  }).option("workoff", {
+    type: "boolean",
+    default: false,
+    description: "Work off all jobs in the queue(s) and exit"
+  }).option("clear", {
+    type: "boolean",
+    default: false,
+    description: "Remove all jobs in all queues and exit"
+  }).help().argv;
+};
+const processName = ({
+  id,
+  queues
+}) => {
+  return `${import_consts.PROCESS_TITLE_PREFIX}.${[queues].flat().join("-")}.${id}`;
+};
+const setupSignals = ({ worker }) => {
+  import_node_process.default.on("SIGINT", () => {
+    worker.logger.warn(
+      `[${import_node_process.default.title}] SIGINT received at ${(/* @__PURE__ */ new Date()).toISOString()}, finishing work...`
+    );
+    worker.forever = false;
+  });
+  import_node_process.default.on("SIGTERM", () => {
+    worker.logger.warn(
+      `[${import_node_process.default.title}] SIGTERM received at ${(/* @__PURE__ */ new Date()).toISOString()}, exiting now!`
+    );
+    import_node_process.default.exit(0);
+  });
+};
+const getWorker = async ({
+  index,
+  id,
+  clear,
+  workoff
+}) => {
+  let manager;
+  try {
+    manager = await (0, import_loaders.loadJobsManager)();
+  } catch (e) {
+    console.error(e);
+    import_node_process.default.exit(1);
+  }
+  const workerConfig = manager.workers[index];
+  if (!workerConfig) {
+    throw new import_errors.WorkerConfigIndexNotFoundError(index);
+  }
+  return manager.createWorker({
+    index,
+    clear,
+    workoff,
+    processName: processName({ id, queues: workerConfig.queue })
+  });
+};
+const main = async () => {
+  const { index, id, clear, workoff } = await parseArgs(import_node_process.default.argv);
+  const worker = await getWorker({ index, id, clear, workoff });
+  import_node_process.default.title = processName({ id, queues: worker.queues });
+  worker.run().then(() => {
+    worker.logger.info(`[${import_node_process.default.title}] Worker finished, shutting down.`);
+    import_node_process.default.exit(0);
+  });
+  setupSignals({ worker });
+};
+if (import_node_process.default.env.NODE_ENV !== "test") {
+  main();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getWorker,
+  processName
+});

package/dist/bins/rw-jobs.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import type { ChildProcess } from 'node:child_process';
+import type { BasicLogger } from '../types.js';
+export type NumWorkersConfig = [number, number][];
+export declare const buildNumWorkers: (config: any) => NumWorkersConfig;
+export declare const startWorkers: ({ numWorkers, detach, workoff, logger, }: {
+    numWorkers: NumWorkersConfig;
+    detach?: boolean;
+    workoff?: boolean;
+    logger: BasicLogger;
+}) => ChildProcess[];
+export declare const stopWorkers: ({ numWorkers, signal, logger, }: {
+    numWorkers: NumWorkersConfig;
+    signal: string;
+    logger: BasicLogger;
+}) => Promise<void>;
+export declare const clearQueue: ({ logger }: {
+    logger: BasicLogger;
+}) => void;
+//# sourceMappingURL=rw-jobs.d.ts.map

package/dist/bins/rw-jobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rw-jobs.d.ts","sourceRoot":"","sources":["../../src/bins/rw-jobs.ts"],"names":[],"mappings":";AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAatD,OAAO,KAAK,EAEV,WAAW,EAGZ,MAAM,aAAa,CAAA;AAEpB,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;AAsEjD,eAAO,MAAM,eAAe,WAAY,GAAG,qBAU1C,CAAA;AAED,eAAO,MAAM,YAAY,6CAKtB;IACD,UAAU,EAAE,gBAAgB,CAAA;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,MAAM,EAAE,WAAW,CAAA;CACpB,mBA2BA,CAAA;AAGD,eAAO,MAAM,WAAW,oCAIrB;IACD,UAAU,EAAE,gBAAgB,CAAA;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,WAAW,CAAA;CACpB,kBAqBA,CAAA;AAED,eAAO,MAAM,UAAU,eAAgB;IAAE,MAAM,EAAE,WAAW,CAAA;CAAE,SAG7D,CAAA"}