@redmix/jobs 0.0.1

package/dist/core/Scheduler.js

@@ -0,0 +1,91 @@
+"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 Scheduler_exports = {};
+__export(Scheduler_exports, {
+  Scheduler: () => Scheduler
+});
+module.exports = __toCommonJS(Scheduler_exports);
+var import_consts = require("../consts.js");
+var import_errors = require("../errors.js");
+class Scheduler {
+  adapter;
+  logger;
+  constructor({ adapter, logger }) {
+    this.logger = logger ?? import_consts.DEFAULT_LOGGER;
+    this.adapter = adapter;
+    if (!this.adapter) {
+      throw new import_errors.AdapterNotConfiguredError();
+    }
+  }
+  computeRunAt({ wait, waitUntil }) {
+    if (wait && wait > 0) {
+      return new Date(Date.now() + wait * 1e3);
+    } else if (waitUntil) {
+      return waitUntil;
+    } else {
+      return /* @__PURE__ */ new Date();
+    }
+  }
+  buildPayload({
+    job,
+    args,
+    options
+  }) {
+    const queue = job.queue;
+    const priority = job.priority ?? import_consts.DEFAULT_PRIORITY;
+    const wait = options?.wait ?? import_consts.DEFAULT_WAIT;
+    const waitUntil = options?.waitUntil ?? import_consts.DEFAULT_WAIT_UNTIL;
+    if (!queue) {
+      throw new import_errors.QueueNotDefinedError();
+    }
+    return {
+      name: job.name,
+      path: job.path,
+      args: args ?? [],
+      runAt: this.computeRunAt({ wait, waitUntil }),
+      queue,
+      priority
+    };
+  }
+  async schedule({
+    job,
+    args,
+    options
+  }) {
+    const payload = this.buildPayload({
+      job,
+      args,
+      options
+    });
+    this.logger.info(payload, `[RedwoodJob] Scheduling ${job.name}`);
+    try {
+      await this.adapter.schedule(payload);
+      return true;
+    } catch (e) {
+      throw new import_errors.SchedulingError(
+        `[RedwoodJob] Exception when scheduling ${payload.name}`,
+        e
+      );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Scheduler
+});

package/dist/core/Worker.d.ts

@@ -0,0 +1,49 @@
+import type { BaseAdapter } from '../adapters/BaseAdapter/BaseAdapter.js';
+import type { BasicLogger, WorkerSharedOptions } from '../types.js';
+export interface WorkerOptions extends WorkerSharedOptions {
+    adapter: BaseAdapter;
+    /** Used to set the `lockedBy` field in the database */
+    processName: string;
+    /** If not given a queue name then will work on jobs in any queue */
+    queues: string[];
+    logger?: BasicLogger;
+    /** If true, will clear the queue of all jobs and then exit */
+    clear?: boolean;
+    /**
+     * Set to `false` and the work loop will quit when the current job is done
+     * running (regardless of how many outstanding jobs there are to be worked
+     * on). The worker process will set this to `false` as soon as the user hits
+     * ctrl-c so any current job will complete before exiting.
+     */
+    workoff?: boolean;
+    /**
+     * If set to `true` will run the worker forever looking for new jobs. Otherwise
+     * will only look for jobs one time and then exit.
+     *
+     * Useful for testing to avoid infinite loops!
+     */
+    forever?: boolean;
+}
+type CompleteOptions = Required<WorkerOptions>;
+export declare class Worker {
+    #private;
+    options: CompleteOptions;
+    adapter: CompleteOptions['adapter'];
+    logger: CompleteOptions['logger'];
+    clear: CompleteOptions['clear'];
+    processName: CompleteOptions['processName'];
+    queues: CompleteOptions['queues'];
+    maxAttempts: CompleteOptions['maxAttempts'];
+    maxRuntime: CompleteOptions['maxRuntime'];
+    deleteSuccessfulJobs: CompleteOptions['deleteSuccessfulJobs'];
+    deleteFailedJobs: CompleteOptions['deleteFailedJobs'];
+    sleepDelay: CompleteOptions['sleepDelay'];
+    forever: CompleteOptions['forever'];
+    workoff: CompleteOptions['workoff'];
+    lastCheckTime: Date;
+    constructor(options: WorkerOptions);
+    run(): Promise<void>;
+    get queueNames(): string;
+}
+export {};
+//# sourceMappingURL=Worker.d.ts.map

package/dist/core/Worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Worker.d.ts","sourceRoot":"","sources":["../../src/core/Worker.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAA;AAUzE,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAInE,MAAM,WAAW,aAAc,SAAQ,mBAAmB;IAGxD,OAAO,EAAE,WAAW,CAAA;IACpB,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAA;IACnB,oEAAoE;IACpE,MAAM,EAAE,MAAM,EAAE,CAAA;IAIhB,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,8DAA8D;IAC9D,KAAK,CAAC,EAAE,OAAO,CAAA;IAEf;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,KAAK,eAAe,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAA;AAc9C,qBAAa,MAAM;;IACjB,OAAO,EAAE,eAAe,CAAA;IACxB,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,CAAA;IACnC,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,CAAA;IAC/B,WAAW,EAAE,eAAe,CAAC,aAAa,CAAC,CAAA;IAC3C,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAA;IACjC,WAAW,EAAE,eAAe,CAAC,aAAa,CAAC,CAAA;IAC3C,UAAU,EAAE,eAAe,CAAC,YAAY,CAAC,CAAA;IACzC,oBAAoB,EAAE,eAAe,CAAC,sBAAsB,CAAC,CAAA;IAC7D,gBAAgB,EAAE,eAAe,CAAC,kBAAkB,CAAC,CAAA;IACrD,UAAU,EAAE,eAAe,CAAC,YAAY,CAAC,CAAA;IACzC,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,CAAA;IACnC,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,CAAA;IACnC,aAAa,EAAE,IAAI,CAAA;gBAEP,OAAO,EAAE,aAAa;IAwElC,GAAG;IAQH,IAAI,UAAU,WAMb;CAmDF"}

package/dist/core/Worker.js

@@ -0,0 +1,143 @@
+"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 Worker_exports = {};
+__export(Worker_exports, {
+  Worker: () => Worker
+});
+module.exports = __toCommonJS(Worker_exports);
+var import_node_timers = require("node:timers");
+var import_consts = require("../consts.js");
+var import_errors = require("../errors.js");
+var import_Executor = require("./Executor.js");
+const DEFAULT_OPTIONS = {
+  logger: import_consts.DEFAULT_LOGGER,
+  clear: false,
+  maxAttempts: import_consts.DEFAULT_MAX_ATTEMPTS,
+  maxRuntime: import_consts.DEFAULT_MAX_RUNTIME,
+  deleteSuccessfulJobs: import_consts.DEFAULT_DELETE_SUCCESSFUL_JOBS,
+  deleteFailedJobs: import_consts.DEFAULT_DELETE_FAILED_JOBS,
+  sleepDelay: import_consts.DEFAULT_SLEEP_DELAY,
+  workoff: false,
+  forever: true
+};
+class Worker {
+  options;
+  adapter;
+  logger;
+  clear;
+  processName;
+  queues;
+  maxAttempts;
+  maxRuntime;
+  deleteSuccessfulJobs;
+  deleteFailedJobs;
+  sleepDelay;
+  forever;
+  workoff;
+  lastCheckTime;
+  constructor(options) {
+    const nonUndefinedOptions = Object.fromEntries(
+      Object.entries(options ?? {}).filter(([_, value]) => value !== void 0)
+    );
+    this.options = {
+      ...DEFAULT_OPTIONS,
+      ...nonUndefinedOptions,
+      adapter: options?.adapter,
+      processName: options?.processName,
+      queues: options?.queues
+    };
+    if (!options?.adapter) {
+      throw new import_errors.AdapterRequiredError();
+    }
+    if (!options?.queues || options.queues.length === 0) {
+      throw new import_errors.QueuesRequiredError();
+    }
+    this.adapter = this.options.adapter;
+    this.logger = this.options.logger;
+    this.clear = this.options.clear;
+    this.processName = this.options.processName;
+    this.queues = this.options.queues;
+    this.maxAttempts = this.options.maxAttempts;
+    this.maxRuntime = this.options.maxRuntime;
+    this.deleteSuccessfulJobs = this.options.deleteSuccessfulJobs;
+    this.deleteFailedJobs = this.options.deleteFailedJobs;
+    this.sleepDelay = (this.options.sleepDelay ?? DEFAULT_OPTIONS.sleepDelay) * 1e3;
+    this.forever = this.options.forever;
+    this.workoff = this.options.workoff;
+    this.lastCheckTime = /* @__PURE__ */ new Date();
+  }
+  // Workers run forever unless:
+  // `this.forever` to false (loop only runs once, then exits)
+  // `this.workoff` is true (run all jobs in the queue, then exits)
+  run() {
+    if (this.clear) {
+      return this.#clearQueue();
+    } else {
+      return this.#work();
+    }
+  }
+  get queueNames() {
+    if (this.queues.length === 1 && this.queues[0] === "*") {
+      return "all (*)";
+    } else {
+      return this.queues.join(", ");
+    }
+  }
+  async #clearQueue() {
+    return await this.adapter.clear();
+  }
+  async #work() {
+    do {
+      this.lastCheckTime = /* @__PURE__ */ new Date();
+      this.logger.debug(
+        `[${this.processName}] Checking for jobs in ${this.queueNames} queues...`
+      );
+      const job = await this.adapter.find({
+        processName: this.processName,
+        maxRuntime: this.maxRuntime,
+        queues: this.queues
+      });
+      if (job) {
+        await new import_Executor.Executor({
+          adapter: this.adapter,
+          logger: this.logger,
+          job,
+          maxAttempts: this.maxAttempts,
+          deleteSuccessfulJobs: this.deleteSuccessfulJobs,
+          deleteFailedJobs: this.deleteFailedJobs
+        }).perform();
+      } else if (this.workoff) {
+        break;
+      }
+      if (!job && this.forever) {
+        const millsSinceLastCheck = (/* @__PURE__ */ new Date()).getTime() - this.lastCheckTime.getTime();
+        if (millsSinceLastCheck < this.sleepDelay) {
+          await this.#wait(this.sleepDelay - millsSinceLastCheck);
+        }
+      }
+    } while (this.forever);
+  }
+  #wait(ms) {
+    return new Promise((resolve) => (0, import_node_timers.setTimeout)(resolve, ms));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Worker
+});

package/dist/errors.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Parent class for any RedwoodJob-related error
+ */
+export declare class RedwoodJobError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when trying to configure a scheduler without an adapter
+ */
+export declare class AdapterNotConfiguredError extends RedwoodJobError {
+    constructor();
+}
+/**
+ * Thrown when the Worker or Executor is instantiated without an adapter
+ */
+export declare class AdapterRequiredError extends RedwoodJobError {
+    constructor();
+}
+/**
+ * Thrown when the Worker is instantiated without an array of queues
+ */
+export declare class QueuesRequiredError extends RedwoodJobError {
+    constructor();
+}
+/**
+ * Thrown when the Executor is instantiated without a job
+ */
+export declare class JobRequiredError extends RedwoodJobError {
+    constructor();
+}
+/**
+ * Thrown when a job with the given handler is not found in the filesystem
+ */
+export declare class JobNotFoundError extends RedwoodJobError {
+    constructor(name: string);
+}
+/**
+ * Thrown when a job file exists, but the export does not match the filename
+ */
+export declare class JobExportNotFoundError extends RedwoodJobError {
+    constructor(name: string);
+}
+/**
+ * Thrown when the runner tries to import `adapter` from api/src/lib/jobs.js|ts and
+ * the file does not exist
+ */
+export declare class JobsLibNotFoundError extends RedwoodJobError {
+    constructor();
+}
+/**
+ * Thrown when the runner tries to import `adapter` from api/src/lib/jobs.js|ts
+ */
+export declare class AdapterNotFoundError extends RedwoodJobError {
+    constructor(name: string);
+}
+/**
+ * Thrown when the runner tries to import `logger` from api/src/lib/jobs.js|ts
+ */
+export declare class LoggerNotFoundError extends RedwoodJobError {
+    constructor(name: string);
+}
+/**
+ * Thrown when the runner tries to import `workerConfig` from api/src/lib/jobs.js|ts
+ */
+export declare class WorkerConfigNotFoundError extends RedwoodJobError {
+    constructor(name: string);
+}
+/**
+ * Parent class for any job error where we want to wrap the underlying error
+ * in our own. Use by extending this class and passing the original error to
+ * the constructor:
+ *
+ * ```typescript
+ * try {
+ *   throw new Error('Generic error')
+ * } catch (e) {
+ *    throw new RethrowJobError('Custom Error Message', e)
+ * }
+ * ```
+ */
+export declare class RethrownJobError extends RedwoodJobError {
+    originalError: Error;
+    stackBeforeRethrow: string | undefined;
+    constructor(message: string, error: Error);
+}
+/**
+ * Thrown when there is an error scheduling a job, wraps the underlying error
+ */
+export declare class SchedulingError extends RethrownJobError {
+    constructor(message: string, error: Error);
+}
+/**
+ * Thrown when there is an error performing a job, wraps the underlying error
+ */
+export declare class PerformError extends RethrownJobError {
+    constructor(message: string, error: Error);
+}
+export declare class QueueNotDefinedError extends RedwoodJobError {
+    constructor();
+}
+export declare class WorkerConfigIndexNotFoundError extends RedwoodJobError {
+    constructor(index: number);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,qBAAa,eAAgB,SAAQ,KAAK;gBAC5B,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,eAAe;;CAI7D;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,eAAe;;CAIxD;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,eAAe;;CAIvD;AAED;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,eAAe;;CAIpD;AAED;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,eAAe;gBACvC,IAAI,EAAE,MAAM;CAGzB;AAED;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,eAAe;gBAC7C,IAAI,EAAE,MAAM;CAGzB;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,eAAe;;CAMxD;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,eAAe;gBAC3C,IAAI,EAAE,MAAM;CAKzB;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,eAAe;gBAC1C,IAAI,EAAE,MAAM;CAKzB;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,eAAe;gBAChD,IAAI,EAAE,MAAM;CAGzB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,gBAAiB,SAAQ,eAAe;IACnD,aAAa,EAAE,KAAK,CAAA;IACpB,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAA;gBAE1B,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;CAqB1C;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,gBAAgB;gBACvC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;CAG1C;AAED;;GAEG;AACH,qBAAa,YAAa,SAAQ,gBAAgB;gBACpC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;CAG1C;AAED,qBAAa,oBAAqB,SAAQ,eAAe;;CAIxD;AAED,qBAAa,8BAA+B,SAAQ,eAAe;gBACrD,KAAK,EAAE,MAAM;CAG1B"}

package/dist/errors.js

@@ -0,0 +1,156 @@
+"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, {
+  AdapterNotConfiguredError: () => AdapterNotConfiguredError,
+  AdapterNotFoundError: () => AdapterNotFoundError,
+  AdapterRequiredError: () => AdapterRequiredError,
+  JobExportNotFoundError: () => JobExportNotFoundError,
+  JobNotFoundError: () => JobNotFoundError,
+  JobRequiredError: () => JobRequiredError,
+  JobsLibNotFoundError: () => JobsLibNotFoundError,
+  LoggerNotFoundError: () => LoggerNotFoundError,
+  PerformError: () => PerformError,
+  QueueNotDefinedError: () => QueueNotDefinedError,
+  QueuesRequiredError: () => QueuesRequiredError,
+  RedwoodJobError: () => RedwoodJobError,
+  RethrownJobError: () => RethrownJobError,
+  SchedulingError: () => SchedulingError,
+  WorkerConfigIndexNotFoundError: () => WorkerConfigIndexNotFoundError,
+  WorkerConfigNotFoundError: () => WorkerConfigNotFoundError
+});
+module.exports = __toCommonJS(errors_exports);
+const JOBS_CONFIG_FILENAME = "jobs.{ts,js}";
+class RedwoodJobError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+}
+class AdapterNotConfiguredError extends RedwoodJobError {
+  constructor() {
+    super("No adapter configured for the job scheduler");
+  }
+}
+class AdapterRequiredError extends RedwoodJobError {
+  constructor() {
+    super("`adapter` is required to perform a job");
+  }
+}
+class QueuesRequiredError extends RedwoodJobError {
+  constructor() {
+    super("`queues` is required to find a job to run");
+  }
+}
+class JobRequiredError extends RedwoodJobError {
+  constructor() {
+    super("`job` is required to perform a job");
+  }
+}
+class JobNotFoundError extends RedwoodJobError {
+  constructor(name) {
+    super(`Job \`${name}\` not found in the filesystem`);
+  }
+}
+class JobExportNotFoundError extends RedwoodJobError {
+  constructor(name) {
+    super(`Job file \`${name}\` does not export a class with the same name`);
+  }
+}
+class JobsLibNotFoundError extends RedwoodJobError {
+  constructor() {
+    super(
+      `api/src/lib/${JOBS_CONFIG_FILENAME} not found. Run \`yarn rw setup jobs\` to create this file and configure background jobs. Already did that? You'll need to run \`yarn rw dev\` or \`yarn rw build\` before you can start the job workers!`
+    );
+  }
+}
+class AdapterNotFoundError extends RedwoodJobError {
+  constructor(name) {
+    super(
+      `api/src/lib/${JOBS_CONFIG_FILENAME} does not export an adapter named \`${name}\``
+    );
+  }
+}
+class LoggerNotFoundError extends RedwoodJobError {
+  constructor(name) {
+    super(
+      `api/src/lib/${JOBS_CONFIG_FILENAME} does not export a logger named \`${name}\``
+    );
+  }
+}
+class WorkerConfigNotFoundError extends RedwoodJobError {
+  constructor(name) {
+    super(`api/src/lib/#{JOBS_CONFIG_FILENAME} does not export \`${name}\``);
+  }
+}
+class RethrownJobError extends RedwoodJobError {
+  originalError;
+  stackBeforeRethrow;
+  constructor(message, error) {
+    super(message);
+    if (!error) {
+      throw new Error(
+        "RethrownJobError requires a message and existing error object"
+      );
+    }
+    this.originalError = error;
+    this.stackBeforeRethrow = this.stack;
+    const messageLines = (this.message.match(/\n/g) || []).length + 1;
+    this.stack = this.stack?.split("\n").slice(0, messageLines + 1).join("\n") + "\n" + error.stack;
+  }
+}
+class SchedulingError extends RethrownJobError {
+  constructor(message, error) {
+    super(message, error);
+  }
+}
+class PerformError extends RethrownJobError {
+  constructor(message, error) {
+    super(message, error);
+  }
+}
+class QueueNotDefinedError extends RedwoodJobError {
+  constructor() {
+    super("Scheduler requires a named `queue` to place jobs in");
+  }
+}
+class WorkerConfigIndexNotFoundError extends RedwoodJobError {
+  constructor(index) {
+    super(`Worker index ${index} not found in jobs config`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdapterNotConfiguredError,
+  AdapterNotFoundError,
+  AdapterRequiredError,
+  JobExportNotFoundError,
+  JobNotFoundError,
+  JobRequiredError,
+  JobsLibNotFoundError,
+  LoggerNotFoundError,
+  PerformError,
+  QueueNotDefinedError,
+  QueuesRequiredError,
+  RedwoodJobError,
+  RethrownJobError,
+  SchedulingError,
+  WorkerConfigIndexNotFoundError,
+  WorkerConfigNotFoundError
+});

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './errors.js';
+export { JobManager } from './core/JobManager.js';
+export { Executor } from './core/Executor.js';
+export { Worker } from './core/Worker.js';
+export { BaseAdapter } from './adapters/BaseAdapter/BaseAdapter.js';
+export { PrismaAdapter } from './adapters/PrismaAdapter/PrismaAdapter.js';
+export type * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAE3B,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAEzC,OAAO,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAA;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,2CAA2C,CAAA;AAEzE,mBAAmB,YAAY,CAAA"}

package/dist/index.js

@@ -0,0 +1,43 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  BaseAdapter: () => import_BaseAdapter.BaseAdapter,
+  Executor: () => import_Executor.Executor,
+  JobManager: () => import_JobManager.JobManager,
+  PrismaAdapter: () => import_PrismaAdapter.PrismaAdapter,
+  Worker: () => import_Worker.Worker
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./errors.js"), module.exports);
+var import_JobManager = require("./core/JobManager.js");
+var import_Executor = require("./core/Executor.js");
+var import_Worker = require("./core/Worker.js");
+var import_BaseAdapter = require("./adapters/BaseAdapter/BaseAdapter.js");
+var import_PrismaAdapter = require("./adapters/PrismaAdapter/PrismaAdapter.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseAdapter,
+  Executor,
+  JobManager,
+  PrismaAdapter,
+  Worker,
+  ...require("./errors.js")
+});

package/dist/loaders.d.ts

@@ -0,0 +1,13 @@
+import type { JobManager } from './core/JobManager.js';
+import type { Adapters, BasicLogger, Job, JobComputedProperties, QueueNames } from './types.js';
+/**
+ * Loads the job manager from the users project
+ *
+ * @returns JobManager
+ */
+export declare const loadJobsManager: () => Promise<JobManager<Adapters, QueueNames, BasicLogger>>;
+/**
+ * Load a specific job implementation from the users project
+ */
+export declare const loadJob: ({ name: jobName, path: jobPath, }: JobComputedProperties) => Promise<Job<QueueNames, unknown[]>>;
+//# sourceMappingURL=loaders.d.ts.map

package/dist/loaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loaders.d.ts","sourceRoot":"","sources":["../src/loaders.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAEtD,OAAO,KAAK,EACV,QAAQ,EACR,WAAW,EACX,GAAG,EACH,qBAAqB,EACrB,UAAU,EACX,MAAM,YAAY,CAAA;AAGnB;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAAa,OAAO,CAC9C,UAAU,CAAC,QAAQ,EAAE,UAAU,EAAE,WAAW,CAAC,CAgB9C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,OAAO,sCAGjB,qBAAqB,KAAG,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,EAAE,CAAC,CAgB5D,CAAA"}