@orion-js/dogs 4.6.5 → 4.6.7

package/dist/index.js

@@ -177,7 +177,8 @@ __runInitializers(_init, 1, JobsHistoryRepo);
 // src/repos/JobsRepo.ts
 import { generateId } from "@orion-js/helpers";
 import { logger } from "@orion-js/logger";
-import { MongoCollection as MongoCollection2, Repository as Repository2 } from "@orion-js/mongodb";
+import { MongoCollection as MongoCollection2, MongoDB as MongoDB2, Repository as Repository2 } from "@orion-js/mongodb";
+import { clean, validate } from "@orion-js/schema";
 
 // src/services/partitions.ts
 function validatePartitionsCount(nPartitions) {
@@ -617,13 +618,13 @@ 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 clean(JobRecordSchema, {
+          _id: this.jobs.generateId(),
           jobName: job.name,
           uniqueIdentifier: job.uniqueIdentifier,
           params: job.params,
@@ -632,16 +633,60 @@ var JobsRepo = class {
           type: "event",
           ...job.partition === void 0 ? {} : { partition: job.partition }
         });
-        scheduledCount++;
+        await validate(JobRecordSchema, record);
+        preparedJobs.push({ index: i, job, record });
       } catch (error) {
-        if (error.isValidationError && Object.values(error.validationErrors).includes("notUnique") && job.uniqueIdentifier) {
-          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 MongoDB2.MongoBulkWriteError ? Array.isArray(error.writeErrors) ? error.writeErrors : [error.writeErrors] : [];
+      if (!(error instanceof MongoDB2.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
           });
         }
       }
@@ -805,39 +850,102 @@ var Executor = class {
     return job.lockTime ?? jobToRun.lockTime;
   }
   getContext(job, jobToRun, onStale, isExecutionActive) {
-    var _a;
     const effectiveLockTime = this.getEffectiveLockTime(job, jobToRun);
-    let staleTimeout = setTimeout(() => onStale(), effectiveLockTime);
-    (_a = staleTimeout.unref) == null ? void 0 : _a.call(staleTimeout);
     const contextLogger = logger3.addMetadata({
       jobName: jobToRun.name,
       jobId: jobToRun.jobId
     });
+    let staleTimeout;
+    let watchdogCleared = false;
+    let staleReported = false;
+    let pendingExtraTime;
+    let renewalRunning = false;
+    let renewalPromise;
+    const clearCurrentStaleTimeout = () => {
+      if (staleTimeout === void 0) return;
+      clearTimeout(staleTimeout);
+      staleTimeout = void 0;
+    };
+    const reportStale = () => {
+      if (staleReported) return;
+      staleReported = true;
+      watchdogCleared = true;
+      pendingExtraTime = void 0;
+      clearCurrentStaleTimeout();
+      onStale();
+    };
+    const armStaleTimeout = (lockedUntil) => {
+      var _a;
+      if (watchdogCleared || staleReported || !isExecutionActive()) return;
+      clearCurrentStaleTimeout();
+      staleTimeout = setTimeout(
+        () => {
+          staleTimeout = void 0;
+          reportStale();
+        },
+        Math.max(0, lockedUntil - Date.now())
+      );
+      (_a = staleTimeout.unref) == null ? void 0 : _a.call(staleTimeout);
+    };
+    const runRenewals = async () => {
+      try {
+        while (pendingExtraTime !== void 0) {
+          const extraTime = pendingExtraTime;
+          pendingExtraTime = void 0;
+          if (watchdogCleared || staleReported || !isExecutionActive()) {
+            clearCurrentStaleTimeout();
+            return;
+          }
+          clearCurrentStaleTimeout();
+          const lockedUntil = Date.now() + extraTime;
+          let didExtend = false;
+          try {
+            didExtend = await this.jobsRepo.extendLockTime(
+              jobToRun.jobId,
+              extraTime,
+              jobToRun.lockId
+            );
+          } catch (error) {
+            reportStale();
+            throw error;
+          }
+          if (!didExtend) {
+            reportStale();
+            return;
+          }
+          if (watchdogCleared || staleReported || !isExecutionActive()) {
+            pendingExtraTime = void 0;
+            clearCurrentStaleTimeout();
+            return;
+          }
+          armStaleTimeout(lockedUntil);
+        }
+      } finally {
+        renewalRunning = false;
+        renewalPromise = void 0;
+      }
+    };
+    armStaleTimeout(Date.now() + effectiveLockTime);
     return {
       definition: job,
       record: jobToRun,
       tries: jobToRun.tries || 0,
-      clearStaleTimeout: () => clearTimeout(staleTimeout),
-      extendLockTime: async (extraTime) => {
-        var _a2;
-        if (!isExecutionActive()) {
+      clearStaleTimeout: () => {
+        watchdogCleared = true;
+        pendingExtraTime = void 0;
+        clearCurrentStaleTimeout();
+      },
+      extendLockTime: (extraTime) => {
+        if (watchdogCleared || staleReported || !isExecutionActive()) {
           contextLogger.warn(`Will not extend lock for stale execution "${jobToRun.executionId}"`);
-          return;
-        }
-        clearTimeout(staleTimeout);
-        let didExtend = false;
-        try {
-          didExtend = await this.jobsRepo.extendLockTime(jobToRun.jobId, extraTime, jobToRun.lockId);
-        } catch (error) {
-          onStale();
-          throw error;
+          return Promise.resolve();
         }
-        if (!didExtend) {
-          onStale();
-          return;
+        pendingExtraTime = Math.max(pendingExtraTime ?? extraTime, extraTime);
+        if (!renewalRunning) {
+          renewalRunning = true;
+          renewalPromise = runRenewals();
         }
-        staleTimeout = setTimeout(() => onStale(), extraTime);
-        (_a2 = staleTimeout.unref) == null ? void 0 : _a2.call(staleTimeout);
+        return renewalPromise ?? Promise.resolve();
       },
       logger: contextLogger
     };