@redmix/jobs 0.0.1

package/dist/bins/rw-jobs.js

@@ -0,0 +1,248 @@
+#!/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_exports = {};
+__export(rw_jobs_exports, {
+  buildNumWorkers: () => buildNumWorkers,
+  clearQueue: () => clearQueue,
+  startWorkers: () => startWorkers,
+  stopWorkers: () => stopWorkers
+});
+module.exports = __toCommonJS(rw_jobs_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_console = __toESM(require("node:console"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_process = __toESM(require("node:process"));
+var import_node_timers = require("node:timers");
+var import_helpers = require("yargs/helpers");
+var import_yargs = __toESM(require("yargs/yargs"));
+var import_consts = require("../consts.js");
+var import_loaders = require("../loaders.js");
+var import_setupEnv = require("../setupEnv.js");
+(0, import_setupEnv.setupEnv)();
+import_node_process.default.title = "rw-jobs";
+const WORKER_PATH = import_node_path.default.join(__dirname, "rw-jobs-worker.js");
+const parseArgs = (argv) => {
+  const commandString = (0, import_helpers.hideBin)(argv);
+  if (commandString.length === 1 && commandString[0] === "jobs") {
+    commandString.shift();
+  }
+  const parsed = (0, import_yargs.default)(commandString).usage(
+    "Starts the RedwoodJob runner to process background jobs\n\nUsage: rw jobs <command> [options]"
+  ).command("work", "Start a worker and process jobs").command("workoff", "Start a worker and exit after all jobs processed").command("start", "Start workers in daemon mode").command("stop", "Stop any daemonized job workers").command("restart", "Stop and start any daemonized job workers").command("clear", "Clear the job queue").demandCommand(1, "You must specify a mode to start in").example(
+    "rw jobs work",
+    "Start the job workers using the job config and work on jobs until manually stopped"
+  ).example(
+    "rw jobs start",
+    "Start the job workers using the job config and detach, running in daemon mode"
+  ).help().parse(commandString, (_err, _argv, output) => {
+    if (output) {
+      const newOutput = output.replaceAll("rw-jobs.js", "rw jobs");
+      import_node_console.default.log(newOutput);
+    }
+  });
+  return { command: parsed._[0] };
+};
+const buildNumWorkers = (config) => {
+  const workers = [];
+  config.map((worker, index) => {
+    for (let id = 0; id < worker.count; id++) {
+      workers.push([index, id]);
+    }
+  });
+  return workers;
+};
+const startWorkers = ({
+  numWorkers,
+  detach = false,
+  workoff = false,
+  logger
+}) => {
+  logger.warn(`Starting ${numWorkers.length} worker(s)...`);
+  return numWorkers.map(([index, id]) => {
+    const workerArgs = ["--index", index.toString(), "--id", id.toString()];
+    if (workoff) {
+      workerArgs.push("--workoff");
+    }
+    const worker = (0, import_node_child_process.fork)(WORKER_PATH, workerArgs, {
+      detached: detach,
+      stdio: detach ? "ignore" : "inherit",
+      env: import_node_process.default.env
+    });
+    if (detach) {
+      worker.unref();
+    } else {
+      worker.on("exit", (_code) => {
+      });
+    }
+    return worker;
+  });
+};
+const stopWorkers = async ({
+  numWorkers,
+  signal = "SIGINT",
+  logger
+}) => {
+  logger.warn(
+    `Stopping ${numWorkers.length} worker(s) gracefully (${signal})...`
+  );
+  const processIds = await findWorkerProcesses();
+  if (processIds.length === 0) {
+    logger.warn(`No running workers found.`);
+    return;
+  }
+  for (const processId of processIds) {
+    logger.info(`Stopping process id ${processId}...`);
+    import_node_process.default.kill(processId, signal);
+    while ((await findWorkerProcesses(processId)).length) {
+      await new Promise((resolve) => (0, import_node_timers.setTimeout)(resolve, 250));
+    }
+  }
+};
+const clearQueue = ({ logger }) => {
+  logger.warn(`Starting worker to clear job queue...`);
+  (0, import_node_child_process.fork)(WORKER_PATH, ["--clear", "--index", "0", "--id", "0"]);
+};
+const signalSetup = ({
+  workers,
+  logger
+}) => {
+  let sigtermCount = 0;
+  import_node_process.default.on("SIGINT", () => {
+    sigtermCount++;
+    let message = "SIGINT received: shutting down workers gracefully (press Ctrl-C again to exit immediately)...";
+    if (sigtermCount > 1) {
+      message = "SIGINT received again, exiting immediately...";
+    }
+    logger.info(message);
+    workers.forEach((worker) => {
+      if (sigtermCount > 1) {
+        worker.kill("SIGTERM");
+      } else {
+        worker.kill("SIGINT");
+      }
+    });
+  });
+};
+const findWorkerProcesses = async (id) => {
+  return new Promise(function(resolve, reject) {
+    const platform = import_node_process.default.platform;
+    const cmd = platform === "win32" ? "tasklist" : platform === "darwin" ? "ps -ax | grep " + import_consts.PROCESS_TITLE_PREFIX : platform === "linux" ? "ps -A" : "";
+    if (cmd === "") {
+      resolve([]);
+    }
+    (0, import_node_child_process.exec)(cmd, function(err, stdout) {
+      if (err) {
+        reject(err);
+      }
+      const list = stdout.trim().split("\n");
+      const matches = list.filter((line) => {
+        if (platform == "darwin" || platform == "linux") {
+          return !line.match("grep");
+        }
+        return true;
+      });
+      if (matches.length === 0) {
+        resolve([]);
+      }
+      const pids = matches.map((line) => parseInt(line.split(" ")[0]));
+      if (id) {
+        resolve(pids.filter((pid) => pid === id));
+      } else {
+        resolve(pids);
+      }
+    });
+  });
+};
+const main = async () => {
+  const { command } = parseArgs(import_node_process.default.argv);
+  let jobsConfig;
+  try {
+    jobsConfig = await (0, import_loaders.loadJobsManager)();
+  } catch (e) {
+    import_node_console.default.error(e);
+    import_node_process.default.exit(1);
+  }
+  const workerConfig = jobsConfig.workers;
+  const numWorkers = buildNumWorkers(workerConfig);
+  const logger = jobsConfig.logger ?? import_consts.DEFAULT_LOGGER;
+  logger.warn(`Starting RedwoodJob Runner at ${(/* @__PURE__ */ new Date()).toISOString()}...`);
+  switch (command) {
+    case "start":
+      startWorkers({
+        numWorkers,
+        detach: true,
+        logger
+      });
+      return import_node_process.default.exit(0);
+    case "stop":
+      return await stopWorkers({
+        numWorkers,
+        signal: "SIGINT",
+        logger
+      });
+    case "restart":
+      await stopWorkers({ numWorkers, signal: "SIGINT", logger });
+      startWorkers({
+        numWorkers,
+        detach: true,
+        logger
+      });
+      return import_node_process.default.exit(0);
+    case "work":
+      return signalSetup({
+        workers: startWorkers({
+          numWorkers,
+          logger
+        }),
+        logger
+      });
+    case "workoff":
+      return signalSetup({
+        workers: startWorkers({
+          numWorkers,
+          workoff: true,
+          logger
+        }),
+        logger
+      });
+    case "clear":
+      return clearQueue({ logger });
+  }
+};
+if (import_node_process.default.env.NODE_ENV !== "test") {
+  main();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildNumWorkers,
+  clearQueue,
+  startWorkers,
+  stopWorkers
+});

package/dist/consts.d.ts

@@ -0,0 +1,26 @@
+export declare const DEFAULT_MAX_ATTEMPTS = 24;
+/** 4 hours in seconds */
+export declare const DEFAULT_MAX_RUNTIME = 14400;
+/** 5 seconds */
+export declare const DEFAULT_SLEEP_DELAY = 5;
+export declare const DEFAULT_DELETE_SUCCESSFUL_JOBS = true;
+export declare const DEFAULT_DELETE_FAILED_JOBS = false;
+export declare const DEFAULT_LOGGER: Console;
+export declare const DEFAULT_QUEUE = "default";
+export declare const DEFAULT_WORK_QUEUE = "*";
+export declare const DEFAULT_PRIORITY = 50;
+export declare const DEFAULT_WAIT = 0;
+export declare const DEFAULT_WAIT_UNTIL: null;
+export declare const PROCESS_TITLE_PREFIX = "rw-jobs-worker";
+export declare const DEFAULT_MODEL_NAME = "BackgroundJob";
+/**
+ * The name of the exported variable from the jobs config file that contains
+ * the adapter
+ */
+export declare const DEFAULT_ADAPTER_NAME = "adapter";
+/**
+ * The name of the exported variable from the jobs config file that contains
+ * the logger
+ */
+export declare const DEFAULT_LOGGER_NAME = "logger";
+//# sourceMappingURL=consts.d.ts.map

package/dist/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,KAAK,CAAA;AACtC,yBAAyB;AACzB,eAAO,MAAM,mBAAmB,QAAS,CAAA;AACzC,gBAAgB;AAChB,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC,eAAO,MAAM,8BAA8B,OAAO,CAAA;AAClD,eAAO,MAAM,0BAA0B,QAAQ,CAAA;AAC/C,eAAO,MAAM,cAAc,SAAU,CAAA;AACrC,eAAO,MAAM,aAAa,YAAY,CAAA;AACtC,eAAO,MAAM,kBAAkB,MAAM,CAAA;AACrC,eAAO,MAAM,gBAAgB,KAAK,CAAA;AAClC,eAAO,MAAM,YAAY,IAAI,CAAA;AAC7B,eAAO,MAAM,kBAAkB,MAAO,CAAA;AACtC,eAAO,MAAM,oBAAoB,mBAAmB,CAAA;AACpD,eAAO,MAAM,kBAAkB,kBAAkB,CAAA;AAEjD;;;GAGG;AACH,eAAO,MAAM,oBAAoB,YAAY,CAAA;AAC7C;;;GAGG;AACH,eAAO,MAAM,mBAAmB,WAAW,CAAA"}

package/dist/consts.js

@@ -0,0 +1,81 @@
+"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 consts_exports = {};
+__export(consts_exports, {
+  DEFAULT_ADAPTER_NAME: () => DEFAULT_ADAPTER_NAME,
+  DEFAULT_DELETE_FAILED_JOBS: () => DEFAULT_DELETE_FAILED_JOBS,
+  DEFAULT_DELETE_SUCCESSFUL_JOBS: () => DEFAULT_DELETE_SUCCESSFUL_JOBS,
+  DEFAULT_LOGGER: () => DEFAULT_LOGGER,
+  DEFAULT_LOGGER_NAME: () => DEFAULT_LOGGER_NAME,
+  DEFAULT_MAX_ATTEMPTS: () => DEFAULT_MAX_ATTEMPTS,
+  DEFAULT_MAX_RUNTIME: () => DEFAULT_MAX_RUNTIME,
+  DEFAULT_MODEL_NAME: () => DEFAULT_MODEL_NAME,
+  DEFAULT_PRIORITY: () => DEFAULT_PRIORITY,
+  DEFAULT_QUEUE: () => DEFAULT_QUEUE,
+  DEFAULT_SLEEP_DELAY: () => DEFAULT_SLEEP_DELAY,
+  DEFAULT_WAIT: () => DEFAULT_WAIT,
+  DEFAULT_WAIT_UNTIL: () => DEFAULT_WAIT_UNTIL,
+  DEFAULT_WORK_QUEUE: () => DEFAULT_WORK_QUEUE,
+  PROCESS_TITLE_PREFIX: () => PROCESS_TITLE_PREFIX
+});
+module.exports = __toCommonJS(consts_exports);
+var import_node_console = __toESM(require("node:console"));
+const DEFAULT_MAX_ATTEMPTS = 24;
+const DEFAULT_MAX_RUNTIME = 14400;
+const DEFAULT_SLEEP_DELAY = 5;
+const DEFAULT_DELETE_SUCCESSFUL_JOBS = true;
+const DEFAULT_DELETE_FAILED_JOBS = false;
+const DEFAULT_LOGGER = import_node_console.default;
+const DEFAULT_QUEUE = "default";
+const DEFAULT_WORK_QUEUE = "*";
+const DEFAULT_PRIORITY = 50;
+const DEFAULT_WAIT = 0;
+const DEFAULT_WAIT_UNTIL = null;
+const PROCESS_TITLE_PREFIX = "rw-jobs-worker";
+const DEFAULT_MODEL_NAME = "BackgroundJob";
+const DEFAULT_ADAPTER_NAME = "adapter";
+const DEFAULT_LOGGER_NAME = "logger";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_ADAPTER_NAME,
+  DEFAULT_DELETE_FAILED_JOBS,
+  DEFAULT_DELETE_SUCCESSFUL_JOBS,
+  DEFAULT_LOGGER,
+  DEFAULT_LOGGER_NAME,
+  DEFAULT_MAX_ATTEMPTS,
+  DEFAULT_MAX_RUNTIME,
+  DEFAULT_MODEL_NAME,
+  DEFAULT_PRIORITY,
+  DEFAULT_QUEUE,
+  DEFAULT_SLEEP_DELAY,
+  DEFAULT_WAIT,
+  DEFAULT_WAIT_UNTIL,
+  DEFAULT_WORK_QUEUE,
+  PROCESS_TITLE_PREFIX
+});

package/dist/core/Executor.d.ts

@@ -0,0 +1,29 @@
+import type { BaseAdapter } from '../adapters/BaseAdapter/BaseAdapter.js';
+import type { BaseJob, BasicLogger } from '../types.js';
+export interface ExecutorOptions {
+    adapter: BaseAdapter;
+    job: BaseJob;
+    logger?: BasicLogger;
+    maxAttempts?: number;
+    deleteFailedJobs?: boolean;
+    deleteSuccessfulJobs?: boolean;
+}
+export declare const DEFAULTS: {
+    logger: Console;
+    maxAttempts: number;
+    deleteFailedJobs: boolean;
+    deleteSuccessfulJobs: boolean;
+};
+export declare class Executor {
+    options: Required<ExecutorOptions>;
+    adapter: ExecutorOptions['adapter'];
+    logger: NonNullable<ExecutorOptions['logger']>;
+    job: BaseJob;
+    maxAttempts: NonNullable<ExecutorOptions['maxAttempts']>;
+    deleteFailedJobs: NonNullable<ExecutorOptions['deleteFailedJobs']>;
+    deleteSuccessfulJobs: NonNullable<ExecutorOptions['deleteSuccessfulJobs']>;
+    constructor(options: ExecutorOptions);
+    get jobIdentifier(): string;
+    perform(): Promise<void>;
+}
+//# sourceMappingURL=Executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Executor.d.ts","sourceRoot":"","sources":["../../src/core/Executor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAA;AASzE,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAEvD,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,WAAW,CAAA;IACpB,GAAG,EAAE,OAAO,CAAA;IACZ,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B;AAED,eAAO,MAAM,QAAQ;;;;;CAKpB,CAAA;AAED,qBAAa,QAAQ;IACnB,OAAO,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAA;IAClC,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,CAAA;IACnC,MAAM,EAAE,WAAW,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAA;IAC9C,GAAG,EAAE,OAAO,CAAA;IACZ,WAAW,EAAE,WAAW,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CAAA;IACxD,gBAAgB,EAAE,WAAW,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAClE,oBAAoB,EAAE,WAAW,CAAC,eAAe,CAAC,sBAAsB,CAAC,CAAC,CAAA;gBAE9D,OAAO,EAAE,eAAe;IAmBpC,IAAI,aAAa,WAEhB;IAEK,OAAO;CAkCd"}

package/dist/core/Executor.js

@@ -0,0 +1,95 @@
+"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 Executor_exports = {};
+__export(Executor_exports, {
+  DEFAULTS: () => DEFAULTS,
+  Executor: () => Executor
+});
+module.exports = __toCommonJS(Executor_exports);
+var import_consts = require("../consts.js");
+var import_errors = require("../errors.js");
+var import_loaders = require("../loaders.js");
+const DEFAULTS = {
+  logger: import_consts.DEFAULT_LOGGER,
+  maxAttempts: import_consts.DEFAULT_MAX_ATTEMPTS,
+  deleteFailedJobs: import_consts.DEFAULT_DELETE_FAILED_JOBS,
+  deleteSuccessfulJobs: import_consts.DEFAULT_DELETE_SUCCESSFUL_JOBS
+};
+class Executor {
+  options;
+  adapter;
+  logger;
+  job;
+  maxAttempts;
+  deleteFailedJobs;
+  deleteSuccessfulJobs;
+  constructor(options) {
+    this.options = { ...DEFAULTS, ...options };
+    if (!this.options.adapter) {
+      throw new import_errors.AdapterRequiredError();
+    }
+    if (!this.options.job) {
+      throw new import_errors.JobRequiredError();
+    }
+    this.adapter = this.options.adapter;
+    this.logger = this.options.logger;
+    this.job = this.options.job;
+    this.maxAttempts = this.options.maxAttempts;
+    this.deleteFailedJobs = this.options.deleteFailedJobs;
+    this.deleteSuccessfulJobs = this.options.deleteSuccessfulJobs;
+  }
+  get jobIdentifier() {
+    return `${this.job.id} (${this.job.path}:${this.job.name})`;
+  }
+  async perform() {
+    this.logger.info(`[RedwoodJob] Started job ${this.jobIdentifier}`);
+    try {
+      const job = await (0, import_loaders.loadJob)({ name: this.job.name, path: this.job.path });
+      await job.perform(...this.job.args);
+      await this.adapter.success({
+        job: this.job,
+        deleteJob: this.deleteSuccessfulJobs
+      });
+    } catch (error) {
+      this.logger.error(
+        `[RedwoodJob] Error in job ${this.jobIdentifier}: ${error.message}`
+      );
+      this.logger.error(error.stack);
+      await this.adapter.error({
+        job: this.job,
+        error
+      });
+      if (this.job.attempts >= this.maxAttempts) {
+        this.logger.warn(
+          this.job,
+          `[RedwoodJob] Failed job ${this.jobIdentifier}: reached max attempts (${this.maxAttempts})`
+        );
+        await this.adapter.failure({
+          job: this.job,
+          deleteJob: this.deleteFailedJobs
+        });
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULTS,
+  Executor
+});

package/dist/core/JobManager.d.ts

@@ -0,0 +1,20 @@
+import type { Adapters, BasicLogger, CreateSchedulerArgs, CreateSchedulerConfig, Job, JobDefinition, JobManagerConfig, QueueNames, WorkerConfig } from '../types.js';
+import type { WorkerOptions } from './Worker.js';
+import { Worker } from './Worker.js';
+export interface CreateWorkerArgs {
+    index: number;
+    workoff: WorkerOptions['workoff'];
+    clear: WorkerOptions['clear'];
+    processName: string;
+}
+export declare class JobManager<TAdapters extends Adapters, TQueues extends QueueNames, TLogger extends BasicLogger> {
+    adapters: TAdapters;
+    queues: TQueues;
+    logger: TLogger;
+    workers: WorkerConfig<TAdapters, TQueues>[];
+    constructor(config: JobManagerConfig<TAdapters, TQueues extends string[] ? never : TQueues, TLogger>);
+    createScheduler(schedulerConfig: CreateSchedulerConfig<TAdapters>): <TJob extends Job<TQueues, any[]>>(job: TJob, ...argsAndOptions: CreateSchedulerArgs<TJob>) => Promise<boolean>;
+    createJob<TArgs extends unknown[]>(jobDefinition: JobDefinition<TQueues, TArgs>): Job<TQueues, TArgs>;
+    createWorker({ index, workoff, clear, processName }: CreateWorkerArgs): Worker;
+}
+//# sourceMappingURL=JobManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"JobManager.d.ts","sourceRoot":"","sources":["../../src/core/JobManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,QAAQ,EACR,WAAW,EACX,mBAAmB,EACnB,qBAAqB,EACrB,GAAG,EACH,aAAa,EACb,gBAAgB,EAChB,UAAU,EACV,YAAY,EACb,MAAM,aAAa,CAAA;AAGpB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEpC,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,CAAA;IACjC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;IAC7B,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,qBAAa,UAAU,CACrB,SAAS,SAAS,QAAQ,EAC1B,OAAO,SAAS,UAAU,EAC1B,OAAO,SAAS,WAAW;IAE3B,QAAQ,EAAE,SAAS,CAAA;IACnB,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,CAAA;gBAGzC,MAAM,EAAE,gBAAgB,CACtB,SAAS,EAGT,OAAO,SAAS,MAAM,EAAE,GAAG,KAAK,GAAG,OAAO,EAC1C,OAAO,CACR;IAQH,eAAe,CAAC,eAAe,EAAE,qBAAqB,CAAC,SAAS,CAAC,IAMvD,IAAI,SAAS,GAAG,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,OACjC,IAAI,qBACU,mBAAmB,CAAC,IAAI,CAAC;IAYhD,SAAS,CAAC,KAAK,SAAS,OAAO,EAAE,EAC/B,aAAa,EAAE,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC,GAC3C,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC;IAOtB,YAAY,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,gBAAgB;CAqBtE"}

package/dist/core/JobManager.js

@@ -0,0 +1,78 @@
+"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 JobManager_exports = {};
+__export(JobManager_exports, {
+  JobManager: () => JobManager
+});
+module.exports = __toCommonJS(JobManager_exports);
+var import_errors = require("../errors.js");
+var import_Scheduler = require("./Scheduler.js");
+var import_Worker = require("./Worker.js");
+class JobManager {
+  adapters;
+  queues;
+  logger;
+  workers;
+  constructor(config) {
+    this.adapters = config.adapters;
+    this.queues = config.queues;
+    this.logger = config.logger;
+    this.workers = config.workers;
+  }
+  createScheduler(schedulerConfig) {
+    const scheduler = new import_Scheduler.Scheduler({
+      adapter: this.adapters[schedulerConfig.adapter],
+      logger: this.logger
+    });
+    return (job, ...argsAndOptions) => {
+      const [possibleArgs, possibleOptions] = argsAndOptions;
+      const didPassArgs = Array.isArray(possibleArgs);
+      const args = didPassArgs ? possibleArgs : [];
+      const options = didPassArgs ? possibleOptions : possibleArgs;
+      return scheduler.schedule({ job, args, options });
+    };
+  }
+  createJob(jobDefinition) {
+    return jobDefinition;
+  }
+  createWorker({ index, workoff, clear, processName }) {
+    const config = this.workers[index];
+    const adapter = this.adapters[config.adapter];
+    if (!adapter) {
+      throw new import_errors.AdapterNotFoundError(config.adapter.toString());
+    }
+    return new import_Worker.Worker({
+      adapter: this.adapters[config.adapter],
+      logger: config.logger || this.logger,
+      maxAttempts: config.maxAttempts,
+      maxRuntime: config.maxRuntime,
+      sleepDelay: config.sleepDelay,
+      deleteFailedJobs: config.deleteFailedJobs,
+      deleteSuccessfulJobs: config.deleteSuccessfulJobs,
+      processName,
+      queues: [config.queue].flat(),
+      workoff,
+      clear
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JobManager
+});

package/dist/core/Scheduler.d.ts

@@ -0,0 +1,27 @@
+import type { BaseAdapter, SchedulePayload } from '../adapters/BaseAdapter/BaseAdapter.js';
+import type { BasicLogger, Job, QueueNames, ScheduleJobOptions } from '../types.js';
+interface SchedulerConfig<TAdapter extends BaseAdapter> {
+    adapter: TAdapter;
+    logger?: BasicLogger;
+}
+export declare class Scheduler<TAdapter extends BaseAdapter> {
+    adapter: TAdapter;
+    logger: NonNullable<SchedulerConfig<TAdapter>['logger']>;
+    constructor({ adapter, logger }: SchedulerConfig<TAdapter>);
+    computeRunAt({ wait, waitUntil }: {
+        wait: number;
+        waitUntil: Date | null;
+    }): Date;
+    buildPayload<TJob extends Job<QueueNames, unknown[]>>({ job, args, options, }: {
+        job: TJob;
+        args: Parameters<TJob['perform']> | never[];
+        options?: ScheduleJobOptions;
+    }): SchedulePayload;
+    schedule<TJob extends Job<QueueNames, unknown[]>>({ job, args, options, }: {
+        job: TJob;
+        args: Parameters<TJob['perform']> | never[];
+        options?: ScheduleJobOptions;
+    }): Promise<boolean>;
+}
+export {};
+//# sourceMappingURL=Scheduler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Scheduler.d.ts","sourceRoot":"","sources":["../../src/core/Scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EAChB,MAAM,wCAAwC,CAAA;AAY/C,OAAO,KAAK,EACV,WAAW,EACX,GAAG,EACH,UAAU,EACV,kBAAkB,EACnB,MAAM,aAAa,CAAA;AAEpB,UAAU,eAAe,CAAC,QAAQ,SAAS,WAAW;IACpD,OAAO,EAAE,QAAQ,CAAA;IACjB,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED,qBAAa,SAAS,CAAC,QAAQ,SAAS,WAAW;IACjD,OAAO,EAAE,QAAQ,CAAA;IACjB,MAAM,EAAE,WAAW,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAA;gBAE5C,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,eAAe,CAAC,QAAQ,CAAC;IAS1D,YAAY,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,IAAI,GAAG,IAAI,CAAA;KAAE;IAU1E,YAAY,CAAC,IAAI,SAAS,GAAG,CAAC,UAAU,EAAE,OAAO,EAAE,CAAC,EAAE,EACpD,GAAG,EACH,IAAI,EACJ,OAAO,GACR,EAAE;QACD,GAAG,EAAE,IAAI,CAAA;QACT,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,KAAK,EAAE,CAAA;QAC3C,OAAO,CAAC,EAAE,kBAAkB,CAAA;KAC7B,GAAG,eAAe;IAoBb,QAAQ,CAAC,IAAI,SAAS,GAAG,CAAC,UAAU,EAAE,OAAO,EAAE,CAAC,EAAE,EACtD,GAAG,EACH,IAAI,EACJ,OAAO,GACR,EAAE;QACD,GAAG,EAAE,IAAI,CAAA;QACT,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,KAAK,EAAE,CAAA;QAC3C,OAAO,CAAC,EAAE,kBAAkB,CAAA;KAC7B;CAmBF"}