@orion-js/dogs 4.6.4 → 4.6.6

package/dist/index.cjs

@@ -92,27 +92,170 @@ __export(index_exports, {
   startWorkers: () => startWorkers
 });
 module.exports = __toCommonJS(index_exports);
-var import_services5 = require("@orion-js/services");
+var import_services6 = require("@orion-js/services");
 
-// src/services/EventsService.ts
-var import_logger2 = require("@orion-js/logger");
-var import_services = require("@orion-js/services");
+// src/repos/JobsHistoryRepo.ts
+var import_mongodb = require("@orion-js/mongodb");
+
+// ../../node_modules/.bun/rambdax@11.3.1/node_modules/rambdax/src/_internals/isInteger.js
+function _isInteger(n) {
+  return n << 0 === n;
+}
+var isInteger = Number.isInteger || _isInteger;
+
+// ../../node_modules/.bun/rambdax@11.3.1/node_modules/rambdax/src/_internals/createPath.js
+function createPath(path, delimiter = ".") {
+  return typeof path === "string" ? path.split(delimiter).map((x) => isInteger(x) ? Number(x) : x) : path;
+}
+
+// ../../node_modules/.bun/rambdax@11.3.1/node_modules/rambdax/src/_internals/compare.js
+function compare(a, b) {
+  return String(a) === String(b);
+}
+
+// ../../node_modules/.bun/rambdax@11.3.1/node_modules/rambdax/src/_internals/includes.js
+function includes(a, list) {
+  let index = -1;
+  const { length } = list;
+  while (++index < length)
+    if (compare(list[index], a))
+      return true;
+  return false;
+}
+
+// ../../node_modules/.bun/rambdax@11.3.1/node_modules/rambdax/src/omit.js
+function omit(propsToOmit, obj) {
+  if (arguments.length === 1) return (_obj) => omit(propsToOmit, _obj);
+  if (obj === null || obj === void 0)
+    return void 0;
+  const propsToOmitValue = createPath(propsToOmit, ",");
+  const willReturn = {};
+  for (const key in obj)
+    if (!includes(key, propsToOmitValue))
+      willReturn[key] = obj[key];
+  return willReturn;
+}
+
+// src/types/HistoryRecord.ts
+var import_schema = require("@orion-js/schema");
+var HistoryRecordSchema = (0, import_schema.schemaWithName)("HistoryRecord", {
+  _id: { type: "string" },
+  jobId: { type: "string" },
+  executionId: { type: "string" },
+  jobName: { type: "string" },
+  type: { type: "string" },
+  priority: { type: "number" },
+  tries: { type: "number" },
+  uniqueIdentifier: { type: "string", optional: true },
+  startedAt: { type: "date" },
+  endedAt: { type: "date" },
+  duration: { type: "number" },
+  expiresAt: { type: "date", optional: true },
+  status: { type: "string", enum: ["success", "error", "stale"] },
+  errorMessage: { type: "string", optional: true },
+  params: { type: "blackbox", optional: true },
+  result: { type: "any", optional: true }
+});
+
+// src/repos/JobsHistoryRepo.ts
+var _history_dec, _JobsHistoryRepo_decorators, _init;
+_JobsHistoryRepo_decorators = [(0, import_mongodb.Repository)()], _history_dec = [(0, import_mongodb.MongoCollection)({
+  name: "orionjs.jobs_dogs_history",
+  idGeneration: "uuid",
+  schema: HistoryRecordSchema,
+  indexes: [
+    {
+      keys: {
+        jobName: 1,
+        startedAt: 1
+      }
+    },
+    {
+      keys: {
+        executionId: 1
+      }
+    },
+    {
+      keys: {
+        expiresAt: 1
+      },
+      options: {
+        expireAfterSeconds: 0
+      }
+    }
+  ]
+})];
+var JobsHistoryRepo = class {
+  constructor() {
+    __publicField(this, "history", __runInitializers(_init, 8, this)), __runInitializers(_init, 11, this);
+  }
+  async saveExecution(record) {
+    await this.history.upsert(
+      { executionId: record.executionId },
+      {
+        $setOnInsert: {
+          status: record.status
+        },
+        $set: {
+          ...omit(["status"], record)
+        }
+      }
+    );
+  }
+  async getExecutions(jobName, limit, skip) {
+    const cursor = this.history.find({ jobName }).sort({ startedAt: -1 });
+    if (skip) {
+      cursor.skip(skip);
+    }
+    if (limit) {
+      cursor.limit(limit);
+    }
+    return await cursor.toArray();
+  }
+};
+_init = __decoratorStart(null);
+__decorateElement(_init, 5, "history", _history_dec, JobsHistoryRepo);
+JobsHistoryRepo = __decorateElement(_init, 0, "JobsHistoryRepo", _JobsHistoryRepo_decorators, JobsHistoryRepo);
+__runInitializers(_init, 1, JobsHistoryRepo);
 
 // src/repos/JobsRepo.ts
 var import_helpers = require("@orion-js/helpers");
 var import_logger = require("@orion-js/logger");
-var import_mongodb = require("@orion-js/mongodb");
+var import_mongodb2 = require("@orion-js/mongodb");
+var import_schema3 = require("@orion-js/schema");
+
+// src/services/partitions.ts
+function validatePartitionsCount(nPartitions) {
+  if (!Number.isInteger(nPartitions) || nPartitions <= 0) {
+    throw new Error("nPartitions must be a positive integer");
+  }
+}
+function getRandomPartition(nPartitions) {
+  return Math.floor(Math.random() * nPartitions);
+}
+function createShuffledPartitions(nPartitions) {
+  const partitions = Array.from({ length: nPartitions }, (_, partition) => partition);
+  for (let index = partitions.length - 1; index > 0; index--) {
+    const swapIndex = Math.floor(Math.random() * (index + 1));
+    [partitions[index], partitions[swapIndex]] = [partitions[swapIndex], partitions[index]];
+  }
+  return partitions;
+}
 
 // src/types/JobRecord.ts
-var import_schema = require("@orion-js/schema");
-var JobStatusEnum = (0, import_schema.createEnum)("JobStatus", ["pending", "maxTriesReached"]);
-var JobRecordSchema = (0, import_schema.schemaWithName)("JobRecord", {
+var import_schema2 = require("@orion-js/schema");
+var JobStatusEnum = (0, import_schema2.createEnum)("JobStatus", ["pending", "maxTriesReached"]);
+var JobRecordSchema = (0, import_schema2.schemaWithName)("JobRecord", {
   _id: { type: "string" },
   jobName: { type: "string" },
-  type: { type: (0, import_schema.createEnum)("JobType", ["recurrent", "event"]) },
+  type: { type: (0, import_schema2.createEnum)("JobType", ["recurrent", "event"]) },
   priority: { type: "number" },
   uniqueIdentifier: { type: "string", optional: true },
   nextRunAt: { type: "date" },
+  /**
+   * Acquisition partition. Optional so records created by previous versions can be reconciled.
+   */
+  partition: { type: "number", optional: true },
   lastRunAt: { type: "date", optional: true },
   lockedUntil: { type: "date", optional: true },
   /**
@@ -120,6 +263,11 @@ var JobRecordSchema = (0, import_schema.schemaWithName)("JobRecord", {
    * this value so a stale execution cannot modify a newer claim.
    */
   lockId: { type: "string", optional: true },
+  /**
+   * Internal acquisition metadata used when MongoDB supports sorted updateOne. It preserves the
+   * pre-update stale state because updateOne intentionally does not return the previous document.
+   */
+  claimWasStale: { type: "boolean", optional: true },
   tries: { type: "number", optional: true },
   params: { type: "blackbox", optional: true },
   /**
@@ -144,23 +292,30 @@ var DEFAULT_MAX_TRIES_REACHED_RETENTION_MS = 1e3 * 60 * 60 * 24 * 7;
 // src/repos/JobsRepo.ts
 var JOB_ACQUISITION_HINTS = {
   byJobName: {
+    partition: 1,
     jobName: 1,
     priority: -1,
     nextRunAt: 1
   },
   globalPriority: {
+    partition: 1,
     priority: -1,
     nextRunAt: 1
   }
 };
 var INITIAL_JOB_ACQUISITION_HINT = "byJobName";
 var CANDIDATE_JOB_ACQUISITION_HINT = "globalPriority";
+var SORTED_UPDATE_ONE_MIN_WIRE_VERSION = 25;
+var LOCK_ID_INDEX_NAME = "jobs_dogs_records_lock_id";
+var PARTITION_JOB_NAME_INDEX_NAME = "jobs_dogs_records_partition_job_name_priority_next_run";
+var PARTITION_PRIORITY_INDEX_NAME = "jobs_dogs_records_partition_priority_next_run";
 var JOB_ACQUISITION_SORT = {
   priority: -1,
   nextRunAt: 1
 };
-function getJobAcquisitionSelector(jobNames, now) {
+function getJobAcquisitionSelector(jobNames, now, partition) {
   return {
+    partition,
     jobName: { $in: jobNames },
     nextRunAt: { $lte: now },
     $and: [
@@ -171,17 +326,19 @@ function getJobAcquisitionSelector(jobNames, now) {
     ]
   };
 }
-var _jobs_dec, _JobsRepo_decorators, _init;
-_JobsRepo_decorators = [(0, import_mongodb.Repository)()], _jobs_dec = [(0, import_mongodb.MongoCollection)({
+var _jobs_dec, _JobsRepo_decorators, _init2;
+_JobsRepo_decorators = [(0, import_mongodb2.Repository)()], _jobs_dec = [(0, import_mongodb2.MongoCollection)({
   idGeneration: "uuid",
   name: "orionjs.jobs_dogs_records",
   schema: JobRecordSchema,
   indexes: [
     {
-      keys: JOB_ACQUISITION_HINTS.byJobName
+      keys: JOB_ACQUISITION_HINTS.byJobName,
+      options: { name: PARTITION_JOB_NAME_INDEX_NAME }
     },
     {
-      keys: JOB_ACQUISITION_HINTS.globalPriority
+      keys: JOB_ACQUISITION_HINTS.globalPriority,
+      options: { name: PARTITION_PRIORITY_INDEX_NAME }
     },
     {
       keys: {
@@ -201,6 +358,15 @@ _JobsRepo_decorators = [(0, import_mongodb.Repository)()], _jobs_dec = [(0, impo
         sparse: true
       }
     },
+    {
+      keys: {
+        lockId: 1
+      },
+      options: {
+        name: LOCK_ID_INDEX_NAME,
+        sparse: true
+      }
+    },
     {
       keys: {
         expiresAt: 1
@@ -212,14 +378,55 @@ _JobsRepo_decorators = [(0, import_mongodb.Repository)()], _jobs_dec = [(0, impo
 })];
 var JobsRepo = class {
   constructor() {
-    __publicField(this, "jobs", __runInitializers(_init, 8, this)), __runInitializers(_init, 11, this);
+    __publicField(this, "jobs", __runInitializers(_init2, 8, this)), __runInitializers(_init2, 11, this);
+    __publicField(this, "sortedUpdateOneSupportPromise");
+    __publicField(this, "partitionsByJobName", /* @__PURE__ */ new Map());
+  }
+  configureJobPartitions(jobNames, nPartitions) {
+    for (const jobName of jobNames) {
+      this.partitionsByJobName.set(jobName, nPartitions);
+    }
+  }
+  getJobPartitionsCount(jobName) {
+    return this.partitionsByJobName.get(jobName);
   }
-  async getJobAndLock(jobNames, lockTime, hint = INITIAL_JOB_ACQUISITION_HINT) {
+  async supportsSortedUpdateOne() {
+    if (!this.sortedUpdateOneSupportPromise) {
+      this.sortedUpdateOneSupportPromise = this.detectSortedUpdateOneSupport();
+    }
+    return this.sortedUpdateOneSupportPromise;
+  }
+  async detectSortedUpdateOneSupport() {
+    const rawCollection = await this.jobs.getRawCollection();
+    await this.jobs.createIndexesPromise;
+    const hello = await rawCollection.db.admin().command({ hello: 1 });
+    const supportsSortedUpdateOne = typeof hello.maxWireVersion === "number" && hello.maxWireVersion >= SORTED_UPDATE_ONE_MIN_WIRE_VERSION;
+    if (!supportsSortedUpdateOne) {
+      import_logger.logger.info("MongoDB does not support sorted updateOne; using findOneAndUpdate for jobs.");
+      return false;
+    }
+    const hasLockIdIndex = await rawCollection.indexExists(LOCK_ID_INDEX_NAME);
+    if (!hasLockIdIndex) {
+      import_logger.logger.warn(
+        `MongoDB supports sorted updateOne but index "${LOCK_ID_INDEX_NAME}" is unavailable; using findOneAndUpdate for jobs.`
+      );
+      return false;
+    }
+    import_logger.logger.info("MongoDB supports sorted updateOne; using it for job acquisition.");
+    return true;
+  }
+  async getJobAndLock(jobNames, lockTime, hint = INITIAL_JOB_ACQUISITION_HINT, partition = 0) {
+    if (await this.supportsSortedUpdateOne()) {
+      return this.getJobAndLockWithSortedUpdateOne(jobNames, lockTime, hint, partition);
+    }
+    return this.getJobAndLockWithFindOneAndUpdate(jobNames, lockTime, hint, partition);
+  }
+  async getJobAndLockWithFindOneAndUpdate(jobNames, lockTime, hint, partition) {
     const executionId = (0, import_helpers.generateId)();
     const now = /* @__PURE__ */ new Date();
     const lockedUntil = new Date(now.getTime() + lockTime);
     const job = await this.jobs.findOneAndUpdate(
-      getJobAcquisitionSelector(jobNames, now),
+      getJobAcquisitionSelector(jobNames, now, partition),
       {
         $set: { lockId: executionId, lockedUntil, lastRunAt: now },
         $inc: { tries: 1 }
@@ -235,6 +442,37 @@ var JobsRepo = class {
     if (!job) return;
     const tries = (job.tries || 0) + 1;
     const wasStale = Boolean(job.lockedUntil);
+    return this.toJobToRun(job, executionId, lockTime, tries, wasStale);
+  }
+  async getJobAndLockWithSortedUpdateOne(jobNames, lockTime, hint, partition) {
+    const executionId = (0, import_helpers.generateId)();
+    const now = /* @__PURE__ */ new Date();
+    const lockedUntil = new Date(now.getTime() + lockTime);
+    const rawCollection = await this.jobs.getRawCollection();
+    const result = await rawCollection.updateOne(
+      getJobAcquisitionSelector(jobNames, now, partition),
+      [
+        {
+          $set: {
+            lockId: { $literal: executionId },
+            lockedUntil: { $literal: lockedUntil },
+            lastRunAt: { $literal: now },
+            tries: { $add: [{ $ifNull: ["$tries", 0] }, 1] },
+            claimWasStale: { $eq: [{ $type: "$lockedUntil" }, "date"] }
+          }
+        }
+      ],
+      {
+        hint: JOB_ACQUISITION_HINTS[hint],
+        sort: JOB_ACQUISITION_SORT
+      }
+    );
+    if (result.matchedCount === 0) return;
+    const job = await rawCollection.findOne({ lockId: executionId });
+    if (!job) return;
+    return this.toJobToRun(job, executionId, lockTime, job.tries || 0, Boolean(job.claimWasStale));
+  }
+  toJobToRun(job, executionId, lockTime, tries, wasStale) {
     if (wasStale) {
       import_logger.logger.info(`Running job "${job.jobName}" that was staled`);
     }
@@ -252,9 +490,9 @@ var JobsRepo = class {
       wasStale
     };
   }
-  async getJobAcquisitionExecutionTime(jobNames, hint) {
+  async getJobAcquisitionExecutionTime(jobNames, hint, partition = 0) {
     var _a;
-    const explain = await this.jobs.find(getJobAcquisitionSelector(jobNames, /* @__PURE__ */ new Date()), {
+    const explain = await this.jobs.find(getJobAcquisitionSelector(jobNames, /* @__PURE__ */ new Date(), partition), {
       hint: JOB_ACQUISITION_HINTS[hint],
       maxTimeMS: 1e3,
       readPreference: "primary"
@@ -278,7 +516,7 @@ var JobsRepo = class {
         priority: options.priority,
         ...options.resetTries ? { tries: 0 } : {}
       },
-      $unset: { lockId: "", lockedUntil: "" }
+      $unset: { lockId: "", lockedUntil: "", claimWasStale: "" }
     };
     const result = await this.jobs.updateOne(
       options.lockId ? { _id: options.jobId, lockId: options.lockId } : options.jobId,
@@ -312,6 +550,7 @@ var JobsRepo = class {
         $unset: {
           lockId: "",
           lockedUntil: "",
+          claimWasStale: "",
           ...retentionMs === null ? { expiresAt: "" } : {}
         }
       }
@@ -368,12 +607,12 @@ var JobsRepo = class {
         lockedUntil: { $exists: true }
       },
       {
-        $unset: { lockId: "", lockedUntil: "" }
+        $unset: { lockId: "", lockedUntil: "", claimWasStale: "" }
       }
     );
     return result.modifiedCount;
   }
-  async ensureJobRecord(job) {
+  async ensureJobRecord(job, partition = 0) {
     const result = await this.jobs.upsert(
       {
         jobName: job.name
@@ -387,7 +626,8 @@ var JobsRepo = class {
           status: ""
         },
         $setOnInsert: {
-          nextRunAt: /* @__PURE__ */ new Date()
+          nextRunAt: /* @__PURE__ */ new Date(),
+          partition
         }
       }
     );
@@ -405,7 +645,8 @@ var JobsRepo = class {
         params: options.params,
         nextRunAt: options.nextRunAt,
         priority: options.priority,
-        type: "event"
+        type: "event",
+        ...options.partition === void 0 ? {} : { partition: options.partition }
       });
     } catch (error) {
       if (error.isValidationError && Object.values(error.validationErrors).includes("notUnique") && options.uniqueIdentifier) {
@@ -421,30 +662,75 @@ var JobsRepo = class {
     if (jobs.length === 0) {
       return { scheduledCount: 0, skippedCount: 0, errors: [] };
     }
-    let scheduledCount = 0;
-    let skippedCount = 0;
     const errors = [];
+    const preparedJobs = [];
     for (let i = 0; i < jobs.length; i++) {
       const job = jobs[i];
       try {
-        await this.jobs.insertOne({
+        const record = await (0, import_schema3.clean)(JobRecordSchema, {
+          _id: this.jobs.generateId(),
           jobName: job.name,
           uniqueIdentifier: job.uniqueIdentifier,
           params: job.params,
           nextRunAt: job.nextRunAt,
           priority: job.priority,
-          type: "event"
+          type: "event",
+          ...job.partition === void 0 ? {} : { partition: job.partition }
         });
-        scheduledCount++;
+        await (0, import_schema3.validate)(JobRecordSchema, record);
+        preparedJobs.push({ index: i, job, record });
       } catch (error) {
-        if (error.isValidationError && Object.values(error.validationErrors).includes("notUnique") && job.uniqueIdentifier) {
-          import_logger.logger.info(`Job "${job.name}" with identifier "${job.uniqueIdentifier}" already exists`);
-          skippedCount++;
-        } else {
+        errors.push({
+          index: i,
+          error: error instanceof Error ? error : new Error(String(error)),
+          job
+        });
+      }
+    }
+    if (preparedJobs.length === 0) {
+      return { scheduledCount: 0, skippedCount: 0, errors };
+    }
+    const rawCollection = await this.jobs.getRawCollection();
+    await this.jobs.createIndexesPromise;
+    const operations = preparedJobs.map(
+      ({ record }) => record.uniqueIdentifier === void 0 ? { insertOne: { document: record } } : {
+        updateOne: {
+          filter: { uniqueIdentifier: record.uniqueIdentifier },
+          update: { $setOnInsert: record },
+          upsert: true
+        }
+      }
+    );
+    let scheduledCount = 0;
+    let skippedCount = 0;
+    try {
+      const result = await rawCollection.bulkWrite(operations, { ordered: false });
+      scheduledCount = result.insertedCount + result.upsertedCount;
+      skippedCount = result.matchedCount;
+    } catch (error) {
+      const writeErrors = error instanceof import_mongodb2.MongoDB.MongoBulkWriteError ? Array.isArray(error.writeErrors) ? error.writeErrors : [error.writeErrors] : [];
+      if (!(error instanceof import_mongodb2.MongoDB.MongoBulkWriteError) || writeErrors.length === 0) {
+        for (const preparedJob of preparedJobs) {
           errors.push({
-            index: i,
+            index: preparedJob.index,
             error: error instanceof Error ? error : new Error(String(error)),
-            job
+            job: preparedJob.job
+          });
+        }
+      } else {
+        scheduledCount = error.result.insertedCount + error.result.upsertedCount;
+        skippedCount = error.result.matchedCount;
+        for (const writeError of writeErrors) {
+          const preparedJob = preparedJobs[writeError.index];
+          if (!preparedJob) continue;
+          if (writeError.code === 11e3 && preparedJob.record.uniqueIdentifier !== void 0) {
+            skippedCount++;
+            continue;
+          }
+          errors.push({
+            index: preparedJob.index,
+            error: new Error(writeError.errmsg),
+            job: preparedJob.job
           });
         }
       }
@@ -458,11 +744,55 @@ var JobsRepo = class {
       errors
     };
   }
+  async reconcilePartitions(options) {
+    if (options.jobNames.length === 0) return 0;
+    const rawCollection = await this.jobs.getRawCollection();
+    await this.jobs.createIndexesPromise;
+    const now = /* @__PURE__ */ new Date();
+    const invalidPartition = {
+      $or: [
+        { partition: { $exists: false } },
+        { partition: { $lt: 0 } },
+        { partition: { $gte: options.nPartitions } }
+      ]
+    };
+    const availableLock = {
+      $or: [{ lockedUntil: { $exists: false } }, { lockedUntil: { $lte: now } }]
+    };
+    const runnableJob = {
+      $or: [{ type: { $ne: "event" } }, { status: { $ne: "maxTriesReached" } }]
+    };
+    const jobs = await rawCollection.find({
+      jobName: { $in: options.jobNames },
+      $and: [invalidPartition, availableLock, runnableJob]
+    }).project({ _id: 1 }).limit(options.batchSize).toArray();
+    if (jobs.length === 0) return 0;
+    const result = await rawCollection.bulkWrite(
+      jobs.map((job) => ({
+        updateOne: {
+          filter: {
+            _id: job._id,
+            $and: [invalidPartition, availableLock, runnableJob]
+          },
+          update: { $set: { partition: getRandomPartition(options.nPartitions) } }
+        }
+      })),
+      { ordered: false }
+    );
+    return result.modifiedCount;
+  }
 };
-_init = __decoratorStart(null);
-__decorateElement(_init, 5, "jobs", _jobs_dec, JobsRepo);
-JobsRepo = __decorateElement(_init, 0, "JobsRepo", _JobsRepo_decorators, JobsRepo);
-__runInitializers(_init, 1, JobsRepo);
+_init2 = __decoratorStart(null);
+__decorateElement(_init2, 5, "jobs", _jobs_dec, JobsRepo);
+JobsRepo = __decorateElement(_init2, 0, "JobsRepo", _JobsRepo_decorators, JobsRepo);
+__runInitializers(_init2, 1, JobsRepo);
+
+// src/schedule.ts
+var import_services2 = require("@orion-js/services");
+
+// src/services/EventsService.ts
+var import_logger2 = require("@orion-js/logger");
+var import_services = require("@orion-js/services");
 
 // src/services/getNextRunDate.ts
 var import_cron_parser = require("cron-parser");
@@ -492,176 +822,65 @@ var getNextRunDate = (options) => {
 };
 
 // src/services/EventsService.ts
-var _jobsRepo_dec, _EventsService_decorators, _init2;
+var _jobsRepo_dec, _EventsService_decorators, _init3;
 _EventsService_decorators = [(0, import_services.Service)()], _jobsRepo_dec = [(0, import_services.Inject)(() => JobsRepo)];
 var EventsService = class {
   constructor() {
-    __publicField(this, "jobsRepo", __runInitializers(_init2, 8, this)), __runInitializers(_init2, 11, this);
+    __publicField(this, "jobsRepo", __runInitializers(_init3, 8, this)), __runInitializers(_init3, 11, this);
   }
-  async scheduleJob(options) {
+  async scheduleJob(options, nPartitions) {
     import_logger2.logger.debug("Scheduling job...", options);
+    const configuredPartitions = nPartitions ?? this.jobsRepo.getJobPartitionsCount(options.name);
     await this.jobsRepo.scheduleJob({
       name: options.name,
       priority: options.priority || 100,
       nextRunAt: getNextRunDate(options),
       params: options.params || null,
-      uniqueIdentifier: options.uniqueIdentifier
+      uniqueIdentifier: options.uniqueIdentifier,
+      partition: configuredPartitions === void 0 ? void 0 : getRandomPartition(configuredPartitions)
     });
   }
-  async scheduleJobs(jobs) {
+  async scheduleJobs(jobs, nPartitions) {
     import_logger2.logger.debug(`Scheduling ${jobs.length} jobs...`);
-    const jobRecords = jobs.map((options) => ({
-      name: options.name,
-      priority: options.priority || 100,
-      nextRunAt: getNextRunDate(options),
-      params: options.params || null,
-      uniqueIdentifier: options.uniqueIdentifier
-    }));
+    const jobRecords = jobs.map((options) => {
+      const configuredPartitions = nPartitions ?? this.jobsRepo.getJobPartitionsCount(options.name);
+      return {
+        name: options.name,
+        priority: options.priority || 100,
+        nextRunAt: getNextRunDate(options),
+        params: options.params || null,
+        uniqueIdentifier: options.uniqueIdentifier,
+        partition: configuredPartitions === void 0 ? void 0 : getRandomPartition(configuredPartitions)
+      };
+    });
     return await this.jobsRepo.scheduleJobs(jobRecords);
   }
 };
-_init2 = __decoratorStart(null);
-__decorateElement(_init2, 5, "jobsRepo", _jobsRepo_dec, EventsService);
-EventsService = __decorateElement(_init2, 0, "EventsService", _EventsService_decorators, EventsService);
-__runInitializers(_init2, 1, EventsService);
+_init3 = __decoratorStart(null);
+__decorateElement(_init3, 5, "jobsRepo", _jobsRepo_dec, EventsService);
+EventsService = __decorateElement(_init3, 0, "EventsService", _EventsService_decorators, EventsService);
+__runInitializers(_init3, 1, EventsService);
+
+// src/schedule.ts
+var eventsService = (0, import_services2.getInstance)(EventsService);
+function scheduleJobInternal(options, nPartitions) {
+  return eventsService.scheduleJob(options, nPartitions);
+}
+function scheduleJobsInternal(jobs, nPartitions) {
+  return eventsService.scheduleJobs(jobs, nPartitions);
+}
 
 // src/services/WorkerService.ts
 var import_helpers2 = require("@orion-js/helpers");
 var import_logger4 = require("@orion-js/logger");
-var import_services3 = require("@orion-js/services");
+var import_services4 = require("@orion-js/services");
 
 // src/services/Executor.ts
 var import_api = require("@opentelemetry/api");
 var import_logger3 = require("@orion-js/logger");
-var import_services2 = require("@orion-js/services");
-
-// src/repos/JobsHistoryRepo.ts
-var import_mongodb2 = require("@orion-js/mongodb");
-
-// ../../node_modules/.bun/rambdax@11.3.1/node_modules/rambdax/src/_internals/isInteger.js
-function _isInteger(n) {
-  return n << 0 === n;
-}
-var isInteger = Number.isInteger || _isInteger;
-
-// ../../node_modules/.bun/rambdax@11.3.1/node_modules/rambdax/src/_internals/createPath.js
-function createPath(path, delimiter = ".") {
-  return typeof path === "string" ? path.split(delimiter).map((x) => isInteger(x) ? Number(x) : x) : path;
-}
-
-// ../../node_modules/.bun/rambdax@11.3.1/node_modules/rambdax/src/_internals/compare.js
-function compare(a, b) {
-  return String(a) === String(b);
-}
-
-// ../../node_modules/.bun/rambdax@11.3.1/node_modules/rambdax/src/_internals/includes.js
-function includes(a, list) {
-  let index = -1;
-  const { length } = list;
-  while (++index < length)
-    if (compare(list[index], a))
-      return true;
-  return false;
-}
-
-// ../../node_modules/.bun/rambdax@11.3.1/node_modules/rambdax/src/omit.js
-function omit(propsToOmit, obj) {
-  if (arguments.length === 1) return (_obj) => omit(propsToOmit, _obj);
-  if (obj === null || obj === void 0)
-    return void 0;
-  const propsToOmitValue = createPath(propsToOmit, ",");
-  const willReturn = {};
-  for (const key in obj)
-    if (!includes(key, propsToOmitValue))
-      willReturn[key] = obj[key];
-  return willReturn;
-}
-
-// src/types/HistoryRecord.ts
-var import_schema2 = require("@orion-js/schema");
-var HistoryRecordSchema = (0, import_schema2.schemaWithName)("HistoryRecord", {
-  _id: { type: "string" },
-  jobId: { type: "string" },
-  executionId: { type: "string" },
-  jobName: { type: "string" },
-  type: { type: "string" },
-  priority: { type: "number" },
-  tries: { type: "number" },
-  uniqueIdentifier: { type: "string", optional: true },
-  startedAt: { type: "date" },
-  endedAt: { type: "date" },
-  duration: { type: "number" },
-  expiresAt: { type: "date", optional: true },
-  status: { type: "string", enum: ["success", "error", "stale"] },
-  errorMessage: { type: "string", optional: true },
-  params: { type: "blackbox", optional: true },
-  result: { type: "any", optional: true }
-});
-
-// src/repos/JobsHistoryRepo.ts
-var _history_dec, _JobsHistoryRepo_decorators, _init3;
-_JobsHistoryRepo_decorators = [(0, import_mongodb2.Repository)()], _history_dec = [(0, import_mongodb2.MongoCollection)({
-  name: "orionjs.jobs_dogs_history",
-  idGeneration: "uuid",
-  schema: HistoryRecordSchema,
-  indexes: [
-    {
-      keys: {
-        jobName: 1,
-        startedAt: 1
-      }
-    },
-    {
-      keys: {
-        executionId: 1
-      }
-    },
-    {
-      keys: {
-        expiresAt: 1
-      },
-      options: {
-        expireAfterSeconds: 0
-      }
-    }
-  ]
-})];
-var JobsHistoryRepo = class {
-  constructor() {
-    __publicField(this, "history", __runInitializers(_init3, 8, this)), __runInitializers(_init3, 11, this);
-  }
-  async saveExecution(record) {
-    await this.history.upsert(
-      { executionId: record.executionId },
-      {
-        $setOnInsert: {
-          status: record.status
-        },
-        $set: {
-          ...omit(["status"], record)
-        }
-      }
-    );
-  }
-  async getExecutions(jobName, limit, skip) {
-    const cursor = this.history.find({ jobName }).sort({ startedAt: -1 });
-    if (skip) {
-      cursor.skip(skip);
-    }
-    if (limit) {
-      cursor.limit(limit);
-    }
-    return await cursor.toArray();
-  }
-};
-_init3 = __decoratorStart(null);
-__decorateElement(_init3, 5, "history", _history_dec, JobsHistoryRepo);
-JobsHistoryRepo = __decorateElement(_init3, 0, "JobsHistoryRepo", _JobsHistoryRepo_decorators, JobsHistoryRepo);
-__runInitializers(_init3, 1, JobsHistoryRepo);
-
-// src/services/Executor.ts
+var import_services3 = require("@orion-js/services");
 var _jobsHistoryRepo_dec, _jobsRepo_dec2, _Executor_decorators, _init4;
-_Executor_decorators = [(0, import_services2.Service)()], _jobsRepo_dec2 = [(0, import_services2.Inject)(() => JobsRepo)], _jobsHistoryRepo_dec = [(0, import_services2.Inject)(() => JobsHistoryRepo)];
+_Executor_decorators = [(0, import_services3.Service)()], _jobsRepo_dec2 = [(0, import_services3.Inject)(() => JobsRepo)], _jobsHistoryRepo_dec = [(0, import_services3.Inject)(() => JobsHistoryRepo)];
 var Executor = class {
   constructor() {
     __publicField(this, "jobsRepo", __runInitializers(_init4, 8, this)), __runInitializers(_init4, 11, this);
@@ -1001,10 +1220,14 @@ __runInitializers(_init4, 1, Executor);
 // src/services/WorkerService.ts
 var FILTERED_JOB_NAMES_ACQUISITION_HINT = "byJobName";
 var _executor_dec, _jobsRepo_dec3, _WorkerService_decorators, _init5;
-_WorkerService_decorators = [(0, import_services3.Service)()], _jobsRepo_dec3 = [(0, import_services3.Inject)(() => JobsRepo)], _executor_dec = [(0, import_services3.Inject)(() => Executor)];
+_WorkerService_decorators = [(0, import_services4.Service)()], _jobsRepo_dec3 = [(0, import_services4.Inject)(() => JobsRepo)], _executor_dec = [(0, import_services4.Inject)(() => Executor)];
 var WorkerService = class {
   constructor() {
     __publicField(this, "jobAcquisitionHintProbeIntervalMs", 30 * 60 * 1e3);
+    __publicField(this, "partitionReconcilerIntervalMs", 5 * 60 * 1e3);
+    __publicField(this, "partitionReconcilerJitterMs", 30 * 1e3);
+    __publicField(this, "partitionReconcilerBatchPauseMs", 250);
+    __publicField(this, "partitionReconcilerBatchSize", 500);
     __publicField(this, "jobsRepo", __runInitializers(_init5, 8, this)), __runInitializers(_init5, 11, this);
     __publicField(this, "executor", __runInitializers(_init5, 12, this)), __runInitializers(_init5, 15, this);
   }
@@ -1089,6 +1312,15 @@ var WorkerService = class {
     if (capacityPromises.length === 0) return;
     await Promise.race([...capacityPromises, workersInstance.stopSignal]);
   }
+  getNextPartition(config, workersInstance) {
+    const partition = workersInstance.partitionOrder[workersInstance.partitionCursor];
+    workersInstance.partitionCursor++;
+    if (workersInstance.partitionCursor >= config.nPartitions) {
+      workersInstance.partitionOrder = createShuffledPartitions(config.nPartitions);
+      workersInstance.partitionCursor = 0;
+    }
+    return partition;
+  }
   async runSchedulerLoop(config, workersInstance) {
     const jobNames = this.getJobNames(config.jobs);
     const executeConfig = {
@@ -1098,6 +1330,7 @@ var WorkerService = class {
       onMaxTriesReached: config.onMaxTriesReached
     };
     import_logger4.logger.debug(`Running scheduler loop for jobs "${jobNames.join(", ")}"...`);
+    let consecutivePartitionMisses = 0;
     while (workersInstance.running) {
       let didMiss = false;
       let allJobNamesAtCapacity = false;
@@ -1109,21 +1342,30 @@ var WorkerService = class {
             break;
           }
           const jobAcquisitionHint = availableJobNames.length < jobNames.length ? FILTERED_JOB_NAMES_ACQUISITION_HINT : workersInstance.jobAcquisitionHint;
+          const partition = this.getNextPartition(config, workersInstance);
           const jobToRun = await this.jobsRepo.getJobAndLock(
             availableJobNames,
             config.defaultLockTime,
-            jobAcquisitionHint
+            jobAcquisitionHint,
+            partition
           );
           if (!jobToRun) {
-            import_logger4.logger.debug("No job to run");
-            didMiss = true;
-            break;
+            consecutivePartitionMisses++;
+            import_logger4.logger.debug(`No job to run in partition ${partition}`);
+            if (consecutivePartitionMisses >= config.nPartitions) {
+              consecutivePartitionMisses = 0;
+              didMiss = true;
+              break;
+            }
+            continue;
           }
+          consecutivePartitionMisses = 0;
           this.startExecution(executeConfig, workersInstance, jobToRun);
           if (!workersInstance.running) break;
         }
       } catch (error) {
         import_logger4.logger.error("Error in job scheduler.", { error });
+        consecutivePartitionMisses = 0;
         didMiss = true;
       }
       if (!workersInstance.running) return;
@@ -1159,11 +1401,13 @@ var WorkerService = class {
     workersInstance.jobAcquisitionHintProbeCycle++;
     try {
       for (let sample = 0; sample < 3; sample++) {
+        const partition = getRandomPartition(config.nPartitions);
         for (const hint of [firstHint, secondHint]) {
           if (!workersInstance.running) return;
           const executionTimeMillis = await this.jobsRepo.getJobAcquisitionExecutionTime(
             jobNames,
-            hint
+            hint,
+            partition
           );
           if (!workersInstance.running) return;
           byHint[hint].push(executionTimeMillis);
@@ -1235,6 +1479,44 @@ var WorkerService = class {
       await this.waitForNextJobAcquisitionHintProbe(workersInstance);
     }
   }
+  async reconcilePartitionBatch(config) {
+    if (typeof this.jobsRepo.reconcilePartitions !== "function") return 0;
+    try {
+      return await this.jobsRepo.reconcilePartitions({
+        jobNames: this.getJobNames(config.jobs),
+        nPartitions: config.nPartitions,
+        batchSize: this.partitionReconcilerBatchSize
+      });
+    } catch (error) {
+      import_logger4.logger.warn("Job partition reconciliation failed; it will be retried.", { error });
+      return 0;
+    }
+  }
+  async waitForNextPartitionReconcile(workersInstance, delayMs) {
+    await new Promise((resolve) => {
+      let resolved = false;
+      const finishWait = () => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(workersInstance.partitionReconcilerTimer);
+        workersInstance.partitionReconcilerTimer = void 0;
+        workersInstance.cancelPartitionReconcilerWait = void 0;
+        resolve();
+      };
+      workersInstance.partitionReconcilerTimer = setTimeout(finishWait, delayMs);
+      workersInstance.cancelPartitionReconcilerWait = finishWait;
+    });
+  }
+  async runPartitionReconcilerLoop(config, workersInstance, initialReconcilePromise) {
+    let modifiedCount = await initialReconcilePromise;
+    while (workersInstance.running) {
+      const didFillBatch = modifiedCount >= this.partitionReconcilerBatchSize;
+      const delayMs = didFillBatch ? this.partitionReconcilerBatchPauseMs : this.partitionReconcilerIntervalMs + Math.floor(Math.random() * (this.partitionReconcilerJitterMs + 1));
+      await this.waitForNextPartitionReconcile(workersInstance, delayMs);
+      if (!workersInstance.running) return;
+      modifiedCount = await this.reconcilePartitionBatch(config);
+    }
+  }
   createWorkersInstanceDefinition(config) {
     let signalStop;
     const stopSignal = new Promise((resolve) => {
@@ -1250,7 +1532,10 @@ var WorkerService = class {
       jobAcquisitionHintProbeCycle: 0,
       hasCompletedInitialJobAcquisitionHintProbe: false,
       pendingJobAcquisitionHintWins: 0,
+      partitionOrder: createShuffledPartitions(config.nPartitions),
+      partitionCursor: 0,
       jobAcquisitionHintProbePromise: Promise.resolve(),
+      partitionReconcilerPromise: Promise.resolve(),
       schedulerPromise: Promise.resolve(),
       stopSignal,
       signalStop,
@@ -1260,14 +1545,16 @@ var WorkerService = class {
       stop: async () => {
         if (workersInstance.stopPromise) return workersInstance.stopPromise;
         workersInstance.stopPromise = (async () => {
-          var _a;
+          var _a, _b;
           import_logger4.logger.info("Stopping job scheduler...");
           workersInstance.running = false;
           workersInstance.signalStop();
           (_a = workersInstance.cancelJobAcquisitionHintProbeWait) == null ? void 0 : _a.call(workersInstance);
+          (_b = workersInstance.cancelPartitionReconcilerWait) == null ? void 0 : _b.call(workersInstance);
           await Promise.all([
             workersInstance.schedulerPromise,
-            workersInstance.jobAcquisitionHintProbePromise
+            workersInstance.jobAcquisitionHintProbePromise,
+            workersInstance.partitionReconcilerPromise
           ]);
           const activeCapacity = Array.from(
             workersInstance.activeExecutions.values(),
@@ -1285,7 +1572,7 @@ var WorkerService = class {
     await Promise.all(
       jobs.filter((job) => job.type === "recurrent").map(async (job) => {
         import_logger4.logger.debug(`Ensuring records for job "${job.name}"...`);
-        await this.jobsRepo.ensureJobRecord(job);
+        await this.jobsRepo.ensureJobRecord(job, getRandomPartition(config.nPartitions));
       })
     );
   }
@@ -1302,29 +1589,41 @@ var WorkerService = class {
    * @param userConfig - Configuration for the scheduler. Required field: jobs
    */
   startWorkers(userConfig) {
+    var _a, _b;
     const maxTriesReachedRetentionMs = userConfig.maxTriesReachedRetentionMs === void 0 ? DEFAULT_MAX_TRIES_REACHED_RETENTION_MS : userConfig.maxTriesReachedRetentionMs;
     if (maxTriesReachedRetentionMs !== null && (!Number.isFinite(maxTriesReachedRetentionMs) || maxTriesReachedRetentionMs < 0)) {
       throw new Error("maxTriesReachedRetentionMs must be null, zero, or a positive number");
     }
+    const nPartitions = userConfig.nPartitions ?? 1;
+    validatePartitionsCount(nPartitions);
     const config = {
       pollInterval: 3e3,
       workersCount: 4,
       defaultLockTime: 30 * 1e3,
       ...userConfig,
+      nPartitions,
       maxTriesReachedRetentionMs
     };
-    setNameToJobs(config.jobs);
+    setNameToJobs(config.jobs, config.nPartitions);
+    (_b = (_a = this.jobsRepo).configureJobPartitions) == null ? void 0 : _b.call(_a, this.getJobNames(config.jobs), config.nPartitions);
     const workersInstance = this.createWorkersInstanceDefinition(config);
     import_logger4.logger.debug("Starting job scheduler", config);
     workersInstance.jobAcquisitionHintProbePromise = this.runJobAcquisitionHintProbeLoop(
       config,
       workersInstance
     );
+    const initialReconcilePromise = this.reconcilePartitionBatch(config);
+    workersInstance.partitionReconcilerPromise = this.runPartitionReconcilerLoop(
+      config,
+      workersInstance,
+      initialReconcilePromise
+    );
     workersInstance.schedulerPromise = this.runScheduler(config, workersInstance).catch((error) => {
-      var _a;
+      var _a2, _b2;
       workersInstance.running = false;
       workersInstance.signalStop();
-      (_a = workersInstance.cancelJobAcquisitionHintProbeWait) == null ? void 0 : _a.call(workersInstance);
+      (_a2 = workersInstance.cancelJobAcquisitionHintProbeWait) == null ? void 0 : _a2.call(workersInstance);
+      (_b2 = workersInstance.cancelPartitionReconcilerWait) == null ? void 0 : _b2.call(workersInstance);
       import_logger4.logger.error("Job scheduler stopped after an unexpected error.", { error });
     });
     return workersInstance;
@@ -1335,17 +1634,15 @@ __decorateElement(_init5, 5, "jobsRepo", _jobsRepo_dec3, WorkerService);
 __decorateElement(_init5, 5, "executor", _executor_dec, WorkerService);
 WorkerService = __decorateElement(_init5, 0, "WorkerService", _WorkerService_decorators, WorkerService);
 __runInitializers(_init5, 1, WorkerService);
-function setNameToJobs(jobs) {
+function setNameToJobs(jobs, nPartitions) {
   for (const name of Object.keys(jobs)) {
     jobs[name].jobName = name;
+    jobs[name].nPartitions = nPartitions;
   }
 }
 
-// src/service/index.ts
-var import_services4 = require("@orion-js/services");
-
 // src/defineJob/index.ts
-var import_schema3 = require("@orion-js/schema");
+var import_schema4 = require("@orion-js/schema");
 var import_cron_parser2 = require("cron-parser");
 var import_parse_duration = __toESM(require("parse-duration"), 1);
 function createEventJob(options) {
@@ -1359,12 +1656,15 @@ function createEventJob(options) {
     if (!jobDefinition.jobName) {
       throw new Error("This job has not been registered in the workers");
     }
-    const params = jobDefinition.params ? await (0, import_schema3.cleanAndValidate)(jobDefinition.params, scheduleOptions.params) : scheduleOptions.params;
-    return await scheduleJob({
-      ...scheduleOptions,
-      name: jobDefinition.jobName,
-      params
-    });
+    const params = jobDefinition.params ? await (0, import_schema4.cleanAndValidate)(jobDefinition.params, scheduleOptions.params) : scheduleOptions.params;
+    return await scheduleJobInternal(
+      {
+        ...scheduleOptions,
+        name: jobDefinition.jobName,
+        params
+      },
+      jobDefinition.nPartitions
+    );
   };
   jobDefinition.scheduleJobs = async (jobs) => {
     if (!jobDefinition.jobName) {
@@ -1372,7 +1672,7 @@ function createEventJob(options) {
     }
     const processedJobs = await Promise.all(
       jobs.map(async (scheduleOptions) => {
-        const params = jobDefinition.params ? await (0, import_schema3.cleanAndValidate)(jobDefinition.params, scheduleOptions.params) : scheduleOptions.params;
+        const params = jobDefinition.params ? await (0, import_schema4.cleanAndValidate)(jobDefinition.params, scheduleOptions.params) : scheduleOptions.params;
         return {
           ...scheduleOptions,
           name: jobDefinition.jobName,
@@ -1380,7 +1680,7 @@ function createEventJob(options) {
         };
       })
     );
-    return await scheduleJobs(processedJobs);
+    return await scheduleJobsInternal(processedJobs, jobDefinition.nPartitions);
   };
   return jobDefinition;
 }
@@ -1409,13 +1709,14 @@ var defineJob = (options) => {
 };
 
 // src/service/index.ts
+var import_services5 = require("@orion-js/services");
 var serviceMetadata = /* @__PURE__ */ new WeakMap();
 var jobsMetadata = /* @__PURE__ */ new Map();
 var jobEntriesByClass = /* @__PURE__ */ new Map();
 var pendingJobEntries = {};
 function Jobs() {
   return (target, context) => {
-    (0, import_services4.Service)()(target, context);
+    (0, import_services5.Service)()(target, context);
     serviceMetadata.set(target, { _serviceType: "jobs" });
     if (Object.keys(pendingJobEntries).length > 0) {
       jobEntriesByClass.set(target, pendingJobEntries);
@@ -1464,7 +1765,7 @@ function initializeJobsIfNeeded(instance) {
   jobsMetadata.set(instance, jobs);
 }
 function getServiceJobs(target) {
-  const instance = (0, import_services4.getInstance)(target);
+  const instance = (0, import_services5.getInstance)(target);
   if (!serviceMetadata.has(instance.constructor)) {
     throw new Error("You must pass a class decorated with @Jobs to getServiceJobs");
   }
@@ -1478,18 +1779,17 @@ function getServiceJobs(target) {
 }
 
 // src/index.ts
-var workerService = (0, import_services5.getInstance)(WorkerService);
-var eventsService = (0, import_services5.getInstance)(EventsService);
-var jobsHistoryRepo = (0, import_services5.getInstance)(JobsHistoryRepo);
-var jobsRepo = (0, import_services5.getInstance)(JobsRepo);
+var workerService = (0, import_services6.getInstance)(WorkerService);
+var jobsHistoryRepo = (0, import_services6.getInstance)(JobsHistoryRepo);
+var jobsRepo = (0, import_services6.getInstance)(JobsRepo);
 var startWorkers = (config) => {
   return workerService.startWorkers(config);
 };
 var scheduleJob = (options) => {
-  return eventsService.scheduleJob(options);
+  return scheduleJobInternal(options);
 };
 var scheduleJobs = (jobs) => {
-  return eventsService.scheduleJobs(jobs);
+  return scheduleJobsInternal(jobs);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {