@lavoro/core 0.3.0

package/build/index.js

@@ -0,0 +1,984 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __reflectGet = Reflect.get;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/logger.ts
+import pino from "pino";
+var Logger = class _Logger {
+  constructor(internalLogger) {
+    __publicField(this, "internalLogger");
+    this.internalLogger = internalLogger;
+  }
+  child(obj) {
+    return new _Logger(this.internalLogger.child(obj));
+  }
+  trace(msg, obj) {
+    this.internalLogger.trace(msg, obj);
+  }
+  debug(msg, obj) {
+    this.internalLogger.debug(msg, obj);
+  }
+  warn(msg, obj) {
+    this.internalLogger.warn(msg, obj);
+  }
+  error(msg, obj) {
+    this.internalLogger.error(msg, obj);
+  }
+  fatal(msg, obj) {
+    this.internalLogger.fatal(msg, obj);
+  }
+  info(msg, obj) {
+    this.internalLogger.info(msg, obj);
+  }
+};
+function createDefaultLogger(name, level = "info") {
+  return new Logger(pino({ name, level }));
+}
+
+// src/queue/define_config.ts
+import { RuntimeException } from "@poppinss/utils";
+function defineConfig(config) {
+  if (!config.connection) {
+    throw new RuntimeException(
+      'Missing "connection" property in queue config file'
+    );
+  }
+  if (!config.connections) {
+    throw new RuntimeException(
+      'Missing "connections" property in queue config file'
+    );
+  }
+  if (!config.connections[config.connection]) {
+    throw new RuntimeException(
+      `Missing "connections.${String(config.connection)}". It is referenced by the "connection" property`
+    );
+  }
+  Object.keys(config.connections).forEach((connectionName) => {
+    const connection = config.connections[connectionName];
+    if (!connection.queues || Object.keys(connection.queues).length === 0) {
+      throw new RuntimeException(
+        `Connection "${connectionName}" must have at least one queue defined`
+      );
+    }
+  });
+  return config;
+}
+
+// src/queue/pending_dispatch.ts
+var PendingDispatch = class {
+  constructor(job, payload) {
+    this.job = job;
+    this.payload = payload;
+  }
+  onConnection(connection) {
+    this.job.options.connection = connection;
+    return this;
+  }
+  onQueue(queue) {
+    this.job.options.queue = queue;
+    return this;
+  }
+  // public withQueueServiceResolver(
+  //   queueServiceResolver: () => Promise<Queue>,
+  // ): this {
+  //   this.job.setQueueServiceResolver(queueServiceResolver)
+  //   return this
+  // }
+  execute() {
+    return __async(this, null, function* () {
+      if (!this.job.getQueueServiceResolver) {
+        throw new Error(
+          "Queue service resolver is not set.\nDid you forget to call Job.setDefaultQueueServiceResolver()?"
+        );
+      }
+      const queue = yield this.job.getQueueServiceResolver();
+      yield queue.enqueue(this.job, this.payload);
+    });
+  }
+  /**
+   * By defining the "then" method, PendingDispatch becomes "thenable",
+   * allowing it to trigger automatically when await is called.
+   */
+  then(onfulfilled, onrejected) {
+    return __async(this, null, function* () {
+      return this.execute().then(onfulfilled, onrejected);
+    });
+  }
+};
+
+// src/queue/contracts/job.ts
+import { randomUUID } from "crypto";
+var _Job = class _Job {
+  constructor() {
+    __publicField(this, "_id", randomUUID());
+    __publicField(this, "options", {
+      retries: 3,
+      delay: 0
+    });
+    __publicField(this, "queueServiceResolver");
+  }
+  static compileName(queue, name) {
+    return `${queue}_${name}`;
+  }
+  static parseName(name) {
+    const [q, n] = name.split(/_(.+)/);
+    return { queue: q, name: n };
+  }
+  get connection() {
+    return this.options.connection;
+  }
+  set connection(connection) {
+    this.options.connection = connection;
+  }
+  get queue() {
+    return this.options.queue;
+  }
+  set queue(queue) {
+    this.options.queue = queue;
+  }
+  get name() {
+    return this.constructor.name;
+  }
+  get id() {
+    return this._id;
+  }
+  set id(id) {
+    this._id = id;
+  }
+  get fullyQualifiedName() {
+    if (!this.options.queue) {
+      throw new Error("Queue is not set.");
+    }
+    return _Job.compileName(this.options.queue, this.name);
+  }
+  static setDefaultQueueServiceResolver(queueServiceResolver) {
+    this.defaultQueueServiceResolver = queueServiceResolver;
+  }
+  setQueueServiceResolver(queueServiceResolver) {
+    this.queueServiceResolver = queueServiceResolver;
+  }
+  get getQueueServiceResolver() {
+    return this.queueServiceResolver || _Job.defaultQueueServiceResolver;
+  }
+  /**
+   * Dispatch a job of type with a typed payload.
+   */
+  static dispatch(payload) {
+    const job = new this();
+    return new PendingDispatch(job, payload);
+  }
+};
+__publicField(_Job, "defaultQueueServiceResolver");
+var Job = _Job;
+
+// src/queue/contracts/queue_driver.ts
+var QueueDriver = class {
+  constructor(config, options, driverConfig = {}) {
+    this.config = config;
+    this.options = options;
+    this.driverConfig = driverConfig;
+    __publicField(this, "logger");
+    __publicField(this, "registeredQueues", /* @__PURE__ */ new Set());
+    __publicField(this, "registeredJobs", /* @__PURE__ */ new Map());
+    __publicField(this, "connection");
+    this.logger = createDefaultLogger("queue");
+  }
+  setLogger(logger) {
+    this.logger = logger;
+  }
+  getMergedWorkerOptions(queue, options) {
+    const base = this.options[queue] || {};
+    return __spreadValues(__spreadValues({}, base), options || {});
+  }
+  listen(queue, options) {
+    return __async(this, null, function* () {
+      if (this.registeredQueues.has(queue)) {
+        throw new Error(`Queue '${queue}' already registered`);
+      }
+      this.registeredQueues.add(queue);
+      const workerOptions = this.getMergedWorkerOptions(queue, options);
+      this.logger.trace(
+        { connection: this.connection, queue, options: workerOptions },
+        "Listening queue"
+      );
+    });
+  }
+  register(job) {
+    return __async(this, null, function* () {
+      if (this.registeredJobs.has(job.name)) {
+        return;
+      }
+      this.registeredJobs.set(job.name, job);
+      this.logger.trace(
+        { connection: this.connection, job: job.name },
+        "Registered job"
+      );
+    });
+  }
+  unregister(job) {
+    return __async(this, null, function* () {
+      if (!this.registeredJobs.has(job.name)) {
+        return;
+      }
+      this.registeredJobs.delete(job.name);
+      this.logger.trace(
+        { connection: this.connection, job: job.name },
+        "Unregistered job"
+      );
+    });
+  }
+  start() {
+    return __async(this, null, function* () {
+      for (const [queue, options] of Object.entries(this.options)) {
+        yield this.listen(queue, options);
+      }
+    });
+  }
+  stop(_options) {
+    return __async(this, null, function* () {
+      this.registeredQueues.clear();
+      this.registeredJobs.clear();
+    });
+  }
+  checkIfQueueIsRegistered(queue) {
+    if (!this.registeredQueues.has(queue)) {
+      throw new Error(`Queue '${queue}' is not registered.`);
+    }
+  }
+  checkIfJobIsRegistered(job) {
+    if (!this.registeredJobs.has(job)) {
+      throw new Error(`Job '${job}' is not registered.`);
+    }
+  }
+  getDefaultQueue() {
+    if (this.registeredQueues.size === 0) {
+      throw new Error(
+        `No queues registered for connection: ${this.connection}.`
+      );
+    }
+    return this.registeredQueues.values().next().value;
+  }
+  /**
+   * Parent method to be extended by the driver.
+   * It implements checks for the job and queue being registered.
+   */
+  enqueue(job, payload) {
+    return __async(this, null, function* () {
+      if (!job.options.queue) {
+        job.options.queue = this.getDefaultQueue();
+      }
+      this.checkIfQueueIsRegistered(job.options.queue);
+      this.checkIfJobIsRegistered(job.name);
+      return Promise.resolve();
+    });
+  }
+  /**
+   * Clean up resources associated with a lock factory created by this driver.
+   * This is called when the queue is stopped to ensure proper resource cleanup.
+   *
+   * @param lockFactory - The lock factory instance to clean up
+   */
+  destroyLockProvider(_lockFactory) {
+    return __async(this, null, function* () {
+    });
+  }
+};
+
+// src/schedule/schedule_interval.ts
+function parseTime(time) {
+  const [hour, minute] = time.split(":");
+  if (!hour || !minute || hour.length !== 2 || minute.length !== 2) {
+    throw new Error("Invalid time format");
+  }
+  return [Number(hour), Number(minute)];
+}
+function dayOfWeekToNumber(dayOfWeek) {
+  switch (dayOfWeek) {
+    case "sunday":
+      return 0;
+    case "monday":
+      return 1;
+    case "tuesday":
+      return 2;
+    case "wednesday":
+      return 3;
+    case "thursday":
+      return 4;
+    case "friday":
+      return 5;
+    case "saturday":
+      return 6;
+  }
+}
+function intervalToCron(interval, options = {}) {
+  const { minute = 0, hour = 0, dayOfMonth = 1, dayOfWeek } = options;
+  const dayOfWeekNumber = dayOfWeekToNumber(dayOfWeek != null ? dayOfWeek : "sunday");
+  const patterns = {
+    second: "* * * * * *",
+    "two seconds": "*/2 * * * * *",
+    "three seconds": "*/3 * * * * *",
+    "four seconds": "*/4 * * * * *",
+    "five seconds": "*/5 * * * * *",
+    "ten seconds": "*/10 * * * * *",
+    "fifteen seconds": "*/15 * * * * *",
+    "twenty seconds": "*/20 * * * * *",
+    "thirty seconds": "*/30 * * * * *",
+    minute: "* * * * *",
+    "two minutes": "*/2 * * * *",
+    "three minutes": "*/3 * * * *",
+    "four minutes": "*/4 * * * *",
+    "five minutes": "*/5 * * * *",
+    "ten minutes": "*/10 * * * *",
+    "fifteen minutes": "*/15 * * * *",
+    "twenty minutes": "*/20 * * * *",
+    "thirty minutes": "*/30 * * * *",
+    hour: `${minute} * * * *`,
+    "two hours": `${minute} */2 * * *`,
+    "three hours": `${minute} */3 * * *`,
+    "four hours": `${minute} */4 * * *`,
+    "five hours": `${minute} */5 * * *`,
+    "six hours": `${minute} */6 * * *`,
+    "seven hours": `${minute} */7 * * *`,
+    "eight hours": `${minute} */8 * * *`,
+    "nine hours": `${minute} */9 * * *`,
+    "ten hours": `${minute} */10 * * *`,
+    "eleven hours": `${minute} */11 * * *`,
+    "twelve hours": `${minute} */12 * * *`,
+    day: `${minute} ${hour} * * *`,
+    week: `${minute} ${hour} * * ${dayOfWeekNumber}`,
+    sunday: `${minute} ${hour} * * 0`,
+    monday: `${minute} ${hour} * * 1`,
+    tuesday: `${minute} ${hour} * * 2`,
+    wednesday: `${minute} ${hour} * * 3`,
+    thursday: `${minute} ${hour} * * 4`,
+    friday: `${minute} ${hour} * * 5`,
+    saturday: `${minute} ${hour} * * 6`,
+    month: `${minute} ${hour} ${dayOfWeek ? "*" : dayOfMonth} * ${dayOfWeek ? dayOfWeekNumber + "#1" : "*"}`,
+    "last day of month": `${minute} ${hour} L * *`
+    // quarter: `${minute} ${hour} ${dayOfWeek ? '*' : dayOfMonth} */3 ${dayOfWeek ? dayOfWeekNumber : '*'}`,
+    // year: `${minute} ${hour} ${dayOfMonth} 1 ${dayOfWeek ? dayOfWeekNumber : '*'}`,
+  };
+  return patterns[interval];
+}
+
+// src/schedule/schedule_registry.ts
+var ScheduleRegistry = class {
+  static add(name, cron) {
+    if (this.instances[name]) {
+      throw new Error(`Cron instance with name '${name}' already exists`);
+    }
+    this.instances[name] = cron;
+  }
+  static all() {
+    return this.instances;
+  }
+  static get(name) {
+    return this.instances[name];
+  }
+  static clear(name) {
+    var _a;
+    if (name) {
+      (_a = this.instances[name]) == null ? void 0 : _a.stop();
+      delete this.instances[name];
+    } else {
+      Object.values(this.instances).forEach((cron) => cron.stop());
+      this.instances = {};
+    }
+  }
+};
+__publicField(ScheduleRegistry, "instances", {});
+
+// src/schedule/pending_schedule.ts
+import { Cron } from "croner";
+import { createHash } from "crypto";
+var getDistributedLockKey = (name) => {
+  const hash = createHash("sha1").update(name).digest("hex").slice(0, 8);
+  return `lavoro:schedule:${hash}`;
+};
+var PendingSchedule = class {
+  constructor(name, cb, lockProviderResolver) {
+    this.name = name;
+    this.cb = cb;
+    this.lockProviderResolver = lockProviderResolver;
+    __publicField(this, "cronPattern");
+    __publicField(this, "interval", "day");
+    __publicField(this, "intervalOptions");
+    __publicField(this, "distributedLockOptions", {
+      key: getDistributedLockKey,
+      ttl: "1m",
+      // TODO: Decide on a default TTL
+      overlap: false,
+      handOff: false
+    });
+  }
+  /**
+   * Schedule using a cron pattern.
+   * You can use https://crontab.guru to generate a cron pattern.
+   *
+   * @param pattern - Cron pattern string
+   *
+   * @example
+   * Schedule.call('my-task', () => {}).cron('0 0 * * *')       // Daily at midnight
+   * Schedule.call('my-task', () => {}).cron('*\/5 * * * *')    // Every 5 minutes
+   * Schedule.call('my-task', () => {}).cron('0 *\/2 * * *')    // Every 2 hours
+   */
+  cron(pattern) {
+    this.cronPattern = pattern;
+    return this;
+  }
+  /**
+   * Schedule to run at a specific interval.
+   * For longer intervals (hour, day, week, etc.), you can customize when they run.
+   *
+   * @param interval - The schedule interval
+   * @param options - Options to customize the cron pattern
+   *
+   * @example
+   * Schedule.call('my-task', () => {}).every('minute')
+   * Schedule.call('my-task', () => {}).every('hour', { minute: 30 })
+   * Schedule.call('my-task', () => {}).every('day', { hour: 14, minute: 30 })
+   * Schedule.call('my-task', () => {}).every('week', { dayOfWeek: 1, hour: 9 })
+   */
+  every(interval, options) {
+    this.interval = interval;
+    this.intervalOptions = options;
+    this.cronPattern = intervalToCron(interval, options);
+    return this;
+  }
+  on(dayOfWeek) {
+    var _a;
+    const valid = [
+      //
+      "week",
+      "month"
+    ];
+    if (!valid.includes(this.interval)) {
+      throw new Error(
+        `.on() can only be used for weekly intervals or larger. Current interval: '${this.interval}'`
+      );
+    }
+    this.intervalOptions = __spreadProps(__spreadValues({}, (_a = this.intervalOptions) != null ? _a : {}), { dayOfWeek });
+    this.cronPattern = intervalToCron(this.interval, this.intervalOptions);
+    return this;
+  }
+  at(time) {
+    var _a;
+    const valid = [
+      "day",
+      "week",
+      "sunday",
+      "monday",
+      "tuesday",
+      "wednesday",
+      "thursday",
+      "friday",
+      "saturday",
+      "month",
+      "last day of month"
+    ];
+    if (!valid.includes(this.interval)) {
+      throw new Error(
+        `.at() can only be used for daily intervals or larger. Current interval: '${this.interval}'`
+      );
+    }
+    const [hour, minute] = parseTime(time);
+    this.intervalOptions = __spreadProps(__spreadValues({}, (_a = this.intervalOptions) != null ? _a : {}), { hour, minute });
+    this.cronPattern = intervalToCron(this.interval, this.intervalOptions);
+    return this;
+  }
+  /**
+   * Set the duration during which other instances
+   * of the same task will be prevented from running.
+   *
+   * This should be roughly the duration of the task execution or longer
+   * since the lock will be released automatically after the task execution.
+   *
+   * @param ttl - The lock duration
+   *
+   * @example
+   * Schedule.call('my-task', () => {}).lockFor('10s')
+   */
+  lockFor(ttl) {
+    this.distributedLockOptions.ttl = ttl;
+    return this;
+  }
+  /**
+   * Allow overlapping executions of the same task.
+   *
+   * @example
+   * Schedule.call('my-task', () => {}).overlapping()
+   */
+  overlapping() {
+    this.distributedLockOptions.overlap = true;
+    return this;
+  }
+  execute() {
+    return __async(this, null, function* () {
+      if (!this.cronPattern) {
+        throw new Error(
+          "No schedule pattern defined. To schedule a task, set interval explicitly."
+        );
+      }
+      ScheduleRegistry.add(
+        this.name,
+        new Cron(this.cronPattern, () => __async(this, null, function* () {
+          if (this.distributedLockOptions.overlap) {
+            yield this.cb();
+            return;
+          }
+          const key = this.distributedLockOptions.key(this.name);
+          const ttl = this.distributedLockOptions.ttl;
+          const lockProvider = this.lockProviderResolver();
+          const lock = lockProvider.createLock(key, ttl);
+          const acquired = yield lock.acquireImmediately();
+          if (!acquired) {
+            return;
+          }
+          try {
+            if (this.distributedLockOptions.handOff) {
+              yield this.cb(lock.serialize());
+            } else {
+              yield this.cb();
+              yield lock.forceRelease();
+            }
+          } catch (error) {
+            yield lock.forceRelease();
+            throw error;
+          } finally {
+          }
+        }))
+      );
+    });
+  }
+  /**
+   * By defining the "then" method, PendingDispatch becomes "thenable",
+   * allowing it to trigger automatically when await is called.
+   */
+  then(onfulfilled, onrejected) {
+    return __async(this, null, function* () {
+      return this.execute().then(onfulfilled, onrejected);
+    });
+  }
+};
+
+// src/schedule/pending_job_schedule.ts
+var PendingJobSchedule = class _PendingJobSchedule extends PendingSchedule {
+  constructor(job, payload, lockProviderResolver) {
+    super(
+      job.name,
+      (serializedLock) => __async(this, null, function* () {
+        if (serializedLock) {
+          this.payload._lock = serializedLock;
+        }
+        yield this.dispatch.then(void 0, (error) => {
+          throw error;
+        });
+      }),
+      lockProviderResolver
+    );
+    this.job = job;
+    this.payload = payload;
+    this.lockProviderResolver = lockProviderResolver;
+    /**
+     * Use composition pattern and store pending
+     * job dispatch inside a pending schedule.
+     */
+    __publicField(this, "dispatch");
+    __publicField(this, "_connection");
+    __publicField(this, "_queue");
+    this.job = job;
+    this.payload = payload;
+    this.dispatch = new PendingDispatch(job, payload);
+    this.distributedLockOptions.handOff = true;
+  }
+  get jobName() {
+    return `${this._connection}_${this._queue}_${this.job.name}`;
+  }
+  onConnection(connection) {
+    this._connection = connection;
+    this.dispatch.onConnection(connection);
+    return this;
+  }
+  onQueue(queue) {
+    this._queue = queue;
+    this.dispatch.onQueue(queue);
+    return this;
+  }
+  // public withQueueServiceResolver(queueServiceResolver: () => Promise<Queue>) {
+  //   this.dispatch.withQueueServiceResolver(queueServiceResolver)
+  //   return this
+  // }
+  execute() {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const queueServiceResolver = this.job.getQueueServiceResolver;
+      if (queueServiceResolver) {
+        const queue = yield queueServiceResolver();
+        const connection = (_a = this.job.options.connection) != null ? _a : queue.getDefaultConnection();
+        const connectionLockService = queue.getLockProvider(connection);
+        if (connectionLockService) {
+          this.lockProviderResolver = () => connectionLockService;
+        }
+        if (this.job.id) {
+          queue.registerScheduledJob(this.job.id);
+        }
+        this._connection = (_b = this._connection) != null ? _b : queue.getDefaultConnection();
+        this._queue = (_c = this._queue) != null ? _c : queue.getDefaultQueue();
+      }
+      this.name = this.jobName;
+      yield __superGet(_PendingJobSchedule.prototype, this, "execute").call(this);
+    });
+  }
+};
+
+// src/schedule/schedule.ts
+import { LockFactory } from "@verrou/core";
+import { memoryStore } from "@verrou/core/drivers/memory";
+var defaultScheduleLockProvider = new LockFactory(
+  memoryStore().factory()
+);
+var Schedule = class {
+  /**
+   * Set a custom lock provider resolver for distributed locking.
+   *
+   * This allows dynamic resolution of lock provider instances, useful when
+   * integrating with Queue or other services that manage lock instances.
+   *
+   * @param resolver - Function that returns a LockFactory instance
+   *
+   * @example
+   * import { LockFactory } from '@verrou/core'
+   * import { redisStore } from '@verrou/core/drivers/redis'
+   *
+   * const customLockProvider = new LockFactory(
+   *   redisStore({ connection: redisClient })
+   * )
+   *
+   * Schedule.setLockProviderResolver(() => customLockProvider)
+   */
+  static setLockProviderResolver(resolver) {
+    this.defaultLockProviderResolver = resolver;
+  }
+  /**
+   * Get the current lock provider instance from the resolver.
+   * @internal
+   */
+  static getLockProvider() {
+    return this.defaultLockProviderResolver();
+  }
+  /**
+   * Clear all scheduled tasks (or specific one if name is specified).
+   *
+   * @param name - The name of the task to clear
+   *
+   * @example
+   * Schedule.clear() // Clear all tasks
+   * Schedule.clear('my-task') // Clear specific task
+   */
+  static clear(name) {
+    if (name) {
+      ScheduleRegistry.clear(name);
+    } else {
+      Object.keys(ScheduleRegistry.all()).forEach(
+        (name2) => ScheduleRegistry.clear(name2)
+      );
+    }
+  }
+  /**
+   * Schedule a callback to run at specified intervals.
+   *
+   * @param name - Unique identifier for the task (required for distributed systems)
+   * @param cb - The callback function to execute
+   *
+   * @example
+   * // Using cron pattern
+   * const cleanupUsers = async () => { ... }
+   * Schedule.call('cleanup-users', cleanupUsers).cron('0 0 * * *')
+   *
+   * // Using convenience methods
+   * Schedule.call('hourly-task', () => { ... }).hourly()
+   * Schedule.call('daily-task', () => { ... }).daily()
+   */
+  static call(name, cb) {
+    return new PendingSchedule(name, cb, this.defaultLockProviderResolver);
+  }
+  /**
+   * Schedule a job to run at specified intervals.
+   *
+   * You can specify the connection and queue to use for the job
+   * the same way you would dispatch a job.
+   *
+   * @param job - The job class to schedule
+   * @param payload - The payload to pass to the job
+   *
+   * @example
+   * Schedule.job(TestJob, { arg1: 'hello', arg2: 1 }).every('minute')
+   * Schedule.job(TestJob, { arg1: 'hello', arg2: 1 })
+   *   .onConnection('main')
+   *   .onQueue('default')
+   *   .every('minute')
+   */
+  static job(job, payload) {
+    return new PendingJobSchedule(
+      new job(),
+      payload,
+      this.defaultLockProviderResolver
+    );
+  }
+};
+/**
+ * Default lock provider resolver for distributed locking.
+ * Returns the default memory-based instance if not overridden.
+ */
+__publicField(Schedule, "defaultLockProviderResolver", () => defaultScheduleLockProvider);
+
+// src/queue/queue.ts
+var Queue = class {
+  constructor(config) {
+    this.config = config;
+    __publicField(this, "drivers", /* @__PURE__ */ new Map());
+    __publicField(this, "started", false);
+    __publicField(this, "logger");
+    __publicField(this, "scheduledJobs", /* @__PURE__ */ new Set());
+    __publicField(this, "lockFactories", /* @__PURE__ */ new Map());
+    this.logger = (config == null ? void 0 : config.logger) || createDefaultLogger("queue");
+    for (const [connection, driverConfig] of Object.entries(
+      this.config.connections
+    )) {
+      this.logger.trace(
+        { connection, driver: driverConfig.driver },
+        "Creating queue driver"
+      );
+      const driver = this.createDriver(driverConfig);
+      driver.connection = connection;
+      this.drivers.set(driver.connection, driver);
+    }
+  }
+  createDriver(config) {
+    const { constructor: driverConstructor, config: driverConfig } = config.driver;
+    const driver = new driverConstructor(
+      this.config,
+      config.queues,
+      driverConfig
+    );
+    driver.setLogger(this.logger);
+    return driver;
+  }
+  start() {
+    return __async(this, null, function* () {
+      if (this.started) {
+        this.logger.warn("Queue service already started");
+        return;
+      }
+      for (const [connection, driverConfig] of Object.entries(
+        this.config.connections
+      )) {
+        const driver = this.drivers.get(connection);
+        if (!driver) {
+          throw new Error(`Driver not found for connection: ${connection}.`);
+        }
+        if (!driverConfig.lockProvider) {
+          const lockFactory = driver.createLockProvider();
+          if (lockFactory) {
+            this.lockFactories.set(connection, lockFactory);
+            this.logger.trace(
+              { connection, driver: driverConfig.driver },
+              "Created lock factory for driver"
+            );
+          }
+        } else {
+          this.lockFactories.set(
+            connection,
+            driverConfig.lockProvider
+          );
+          this.logger.trace(
+            { connection, driver: driverConfig.driver },
+            "Using explicitly configured lock provider for driver"
+          );
+        }
+      }
+      for (const job of this.config.jobs) {
+        yield this.register(job);
+      }
+      this.started = true;
+      for (const [connection, driver] of this.drivers) {
+        this.logger.trace({ connection }, "Starting queue connection");
+        yield driver.start();
+      }
+      this.logger.trace(
+        { connections: Array.from(this.drivers.keys()) },
+        "Queue service started"
+      );
+    });
+  }
+  stop() {
+    return __async(this, arguments, function* (options = {
+      graceful: true,
+      timeout: 3e4
+    }) {
+      if (!this.started) {
+        this.logger.warn("Queue service not started");
+        return;
+      }
+      this.logger.trace(
+        { count: this.scheduledJobs.size },
+        "Cleared scheduled jobs for the queue"
+      );
+      for (const id of this.scheduledJobs) {
+        Schedule.clear(id);
+      }
+      this.scheduledJobs.clear();
+      for (const [connection, driver] of this.drivers) {
+        this.logger.trace({ connection }, "Stopping queue connection");
+        yield driver.stop(options);
+      }
+      for (const job of this.config.jobs) {
+        yield this.unregister(job);
+      }
+      for (const [connection, lockFactory] of this.lockFactories) {
+        const driver = this.drivers.get(connection);
+        if (!driver) {
+          throw new Error(`Driver not found for connection: ${connection}.`);
+        }
+        yield driver.destroyLockProvider(lockFactory);
+        this.lockFactories.delete(connection);
+      }
+      this.started = false;
+      this.logger.trace("Queue service stopped");
+    });
+  }
+  register(job) {
+    return __async(this, null, function* () {
+      for (const [_, driver] of this.drivers) {
+        yield driver.register(job);
+      }
+    });
+  }
+  unregister(job) {
+    return __async(this, null, function* () {
+      for (const [_, driver] of this.drivers) {
+        yield driver.unregister(job);
+      }
+    });
+  }
+  enqueue(job, payload) {
+    return __async(this, null, function* () {
+      if (this.drivers.size === 0) {
+        throw new Error("No queue drivers available.");
+      }
+      const driver = job.options.connection ? this.drivers.get(job.options.connection) : this.drivers.values().next().value;
+      if (!driver) {
+        throw new Error(
+          `No driver found for connection: ${job.options.connection}.`
+        );
+      }
+      if (!job.options.queue) {
+        job.options.queue = driver.getDefaultQueue();
+      }
+      yield driver.enqueue(job, payload);
+    });
+  }
+  /**
+   * Get the default connection name.
+   *
+   * Returns the name of the first available connection.
+   * Throws an error if no connections are available.
+   */
+  getDefaultConnection() {
+    if (this.drivers.size === 0) {
+      throw new Error(`No queue drivers available.`);
+    }
+    return this.drivers.keys().next().value;
+  }
+  getDefaultQueue() {
+    var _a;
+    if (this.drivers.size === 0) {
+      throw new Error(`No queue drivers available.`);
+    }
+    return (_a = this.drivers.values().next().value) == null ? void 0 : _a.getDefaultQueue();
+  }
+  /**
+   * Get the lock factory instance for a specific connection.
+   * Returns the explicitly configured lock provider or the auto-created lock factory.
+   * Throws an error if no lock factory is available.
+   *
+   * @param connection - The connection name
+   * @returns The lock factory instance
+   */
+  getLockProvider(connection) {
+    const connectionConfig = this.config.connections[connection];
+    if (connectionConfig == null ? void 0 : connectionConfig.lockProvider) {
+      return connectionConfig.lockProvider;
+    }
+    const lockFactory = this.lockFactories.get(connection);
+    if (!lockFactory) {
+      throw new Error(`No lock provider found for connection: ${connection}.`);
+    }
+    return lockFactory;
+  }
+  /**
+   * Register a scheduled job ID with this Queue instance.
+   * This allows the Queue to clean up scheduled jobs when it stops.
+   */
+  registerScheduledJob(id) {
+    this.scheduledJobs.add(id);
+  }
+};
+export {
+  Job,
+  Logger,
+  PendingDispatch,
+  PendingJobSchedule,
+  PendingSchedule,
+  Queue,
+  QueueDriver,
+  Schedule,
+  ScheduleRegistry,
+  createDefaultLogger,
+  defaultScheduleLockProvider,
+  defineConfig,
+  getDistributedLockKey,
+  intervalToCron,
+  parseTime
+};
+//# sourceMappingURL=index.js.map