@depup/payload 3.79.1-depup.0

package/dist/queues/endpoints/run.js

@@ -0,0 +1,89 @@
+import { runJobs } from '../operations/runJobs/index.js';
+/**
+ * /api/payload-jobs/run endpoint
+ *
+ * This endpoint is GET instead of POST to allow it to be used in a Vercel Cron.
+ */ export const runJobsEndpoint = {
+    handler: async (req)=>{
+        const jobsConfig = req.payload.config.jobs;
+        if (!configHasJobs(jobsConfig)) {
+            return Response.json({
+                message: 'No jobs to run.'
+            }, {
+                status: 200
+            });
+        }
+        const accessFn = jobsConfig.access?.run ?? (()=>true);
+        const hasAccess = await accessFn({
+            req
+        });
+        if (!hasAccess) {
+            return Response.json({
+                message: req.i18n.t('error:unauthorized')
+            }, {
+                status: 401
+            });
+        }
+        const { allQueues, disableScheduling: disableSchedulingParam, limit, queue, silent: silentParam } = req.query;
+        const silent = silentParam === 'true';
+        const shouldHandleSchedules = disableSchedulingParam !== 'true';
+        const runAllQueues = allQueues && !(typeof allQueues === 'string' && allQueues === 'false');
+        if (shouldHandleSchedules && jobsConfig.scheduling) {
+            // If should handle schedules and schedules are defined
+            await req.payload.jobs.handleSchedules({
+                allQueues: runAllQueues,
+                queue,
+                req
+            });
+        }
+        const runJobsArgs = {
+            queue,
+            req,
+            // Access is validated above, so it's safe to override here
+            allQueues: runAllQueues,
+            overrideAccess: true,
+            silent
+        };
+        if (typeof queue === 'string') {
+            runJobsArgs.queue = queue;
+        }
+        const parsedLimit = Number(limit);
+        if (!isNaN(parsedLimit)) {
+            runJobsArgs.limit = parsedLimit;
+        }
+        let noJobsRemaining = false;
+        let remainingJobsFromQueried = 0;
+        try {
+            const result = await runJobs(runJobsArgs);
+            noJobsRemaining = !!result.noJobsRemaining;
+            remainingJobsFromQueried = result.remainingJobsFromQueried;
+        } catch (err) {
+            req.payload.logger.error({
+                err,
+                msg: 'There was an error running jobs:',
+                queue: runJobsArgs.queue
+            });
+            return Response.json({
+                message: req.i18n.t('error:unknown'),
+                noJobsRemaining: true,
+                remainingJobsFromQueried
+            }, {
+                status: 500
+            });
+        }
+        return Response.json({
+            message: req.i18n.t('general:success'),
+            noJobsRemaining,
+            remainingJobsFromQueried
+        }, {
+            status: 200
+        });
+    },
+    method: 'get',
+    path: '/run'
+};
+export const configHasJobs = (jobsConfig)=>{
+    return Boolean(jobsConfig.tasks?.length || jobsConfig.workflows?.length);
+};
+
+//# sourceMappingURL=run.js.map

package/dist/queues/endpoints/run.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/queues/endpoints/run.ts"],"sourcesContent":["import type { Endpoint } from '../../config/types.js'\nimport type { SanitizedJobsConfig } from '../config/types/index.js'\n\nimport { runJobs, type RunJobsArgs } from '../operations/runJobs/index.js'\n\n/**\n * /api/payload-jobs/run endpoint\n *\n * This endpoint is GET instead of POST to allow it to be used in a Vercel Cron.\n */\nexport const runJobsEndpoint: Endpoint = {\n  handler: async (req) => {\n    const jobsConfig = req.payload.config.jobs\n\n    if (!configHasJobs(jobsConfig)) {\n      return Response.json(\n        {\n          message: 'No jobs to run.',\n        },\n        { status: 200 },\n      )\n    }\n\n    const accessFn = jobsConfig.access?.run ?? (() => true)\n\n    const hasAccess = await accessFn({ req })\n\n    if (!hasAccess) {\n      return Response.json(\n        {\n          message: req.i18n.t('error:unauthorized'),\n        },\n        { status: 401 },\n      )\n    }\n\n    const {\n      allQueues,\n      disableScheduling: disableSchedulingParam,\n      limit,\n      queue,\n      silent: silentParam,\n    } = req.query as {\n      allQueues?: 'false' | 'true'\n      disableScheduling?: 'false' | 'true'\n      limit?: number\n      queue?: string\n      silent?: string\n    }\n\n    const silent = silentParam === 'true'\n\n    const shouldHandleSchedules = disableSchedulingParam !== 'true'\n\n    const runAllQueues = allQueues && !(typeof allQueues === 'string' && allQueues === 'false')\n\n    if (shouldHandleSchedules && jobsConfig.scheduling) {\n      // If should handle schedules and schedules are defined\n      await req.payload.jobs.handleSchedules({ allQueues: runAllQueues, queue, req })\n    }\n\n    const runJobsArgs: RunJobsArgs = {\n      queue,\n      req,\n      // Access is validated above, so it's safe to override here\n      allQueues: runAllQueues,\n      overrideAccess: true,\n      silent,\n    }\n\n    if (typeof queue === 'string') {\n      runJobsArgs.queue = queue\n    }\n\n    const parsedLimit = Number(limit)\n    if (!isNaN(parsedLimit)) {\n      runJobsArgs.limit = parsedLimit\n    }\n\n    let noJobsRemaining = false\n    let remainingJobsFromQueried = 0\n    try {\n      const result = await runJobs(runJobsArgs)\n      noJobsRemaining = !!result.noJobsRemaining\n      remainingJobsFromQueried = result.remainingJobsFromQueried\n    } catch (err) {\n      req.payload.logger.error({\n        err,\n        msg: 'There was an error running jobs:',\n        queue: runJobsArgs.queue,\n      })\n\n      return Response.json(\n        {\n          message: req.i18n.t('error:unknown'),\n          noJobsRemaining: true,\n          remainingJobsFromQueried,\n        },\n        { status: 500 },\n      )\n    }\n\n    return Response.json(\n      {\n        message: req.i18n.t('general:success'),\n        noJobsRemaining,\n        remainingJobsFromQueried,\n      },\n      { status: 200 },\n    )\n  },\n  method: 'get',\n  path: '/run',\n}\n\nexport const configHasJobs = (jobsConfig: SanitizedJobsConfig): boolean => {\n  return Boolean(jobsConfig.tasks?.length || jobsConfig.workflows?.length)\n}\n"],"names":["runJobs","runJobsEndpoint","handler","req","jobsConfig","payload","config","jobs","configHasJobs","Response","json","message","status","accessFn","access","run","hasAccess","i18n","t","allQueues","disableScheduling","disableSchedulingParam","limit","queue","silent","silentParam","query","shouldHandleSchedules","runAllQueues","scheduling","handleSchedules","runJobsArgs","overrideAccess","parsedLimit","Number","isNaN","noJobsRemaining","remainingJobsFromQueried","result","err","logger","error","msg","method","path","Boolean","tasks","length","workflows"],"mappings":"AAGA,SAASA,OAAO,QAA0B,iCAAgC;AAE1E;;;;CAIC,GACD,OAAO,MAAMC,kBAA4B;IACvCC,SAAS,OAAOC;QACd,MAAMC,aAAaD,IAAIE,OAAO,CAACC,MAAM,CAACC,IAAI;QAE1C,IAAI,CAACC,cAAcJ,aAAa;YAC9B,OAAOK,SAASC,IAAI,CAClB;gBACEC,SAAS;YACX,GACA;gBAAEC,QAAQ;YAAI;QAElB;QAEA,MAAMC,WAAWT,WAAWU,MAAM,EAAEC,OAAQ,CAAA,IAAM,IAAG;QAErD,MAAMC,YAAY,MAAMH,SAAS;YAAEV;QAAI;QAEvC,IAAI,CAACa,WAAW;YACd,OAAOP,SAASC,IAAI,CAClB;gBACEC,SAASR,IAAIc,IAAI,CAACC,CAAC,CAAC;YACtB,GACA;gBAAEN,QAAQ;YAAI;QAElB;QAEA,MAAM,EACJO,SAAS,EACTC,mBAAmBC,sBAAsB,EACzCC,KAAK,EACLC,KAAK,EACLC,QAAQC,WAAW,EACpB,GAAGtB,IAAIuB,KAAK;QAQb,MAAMF,SAASC,gBAAgB;QAE/B,MAAME,wBAAwBN,2BAA2B;QAEzD,MAAMO,eAAeT,aAAa,CAAE,CAAA,OAAOA,cAAc,YAAYA,cAAc,OAAM;QAEzF,IAAIQ,yBAAyBvB,WAAWyB,UAAU,EAAE;YAClD,uDAAuD;YACvD,MAAM1B,IAAIE,OAAO,CAACE,IAAI,CAACuB,eAAe,CAAC;gBAAEX,WAAWS;gBAAcL;gBAAOpB;YAAI;QAC/E;QAEA,MAAM4B,cAA2B;YAC/BR;YACApB;YACA,2DAA2D;YAC3DgB,WAAWS;YACXI,gBAAgB;YAChBR;QACF;QAEA,IAAI,OAAOD,UAAU,UAAU;YAC7BQ,YAAYR,KAAK,GAAGA;QACtB;QAEA,MAAMU,cAAcC,OAAOZ;QAC3B,IAAI,CAACa,MAAMF,cAAc;YACvBF,YAAYT,KAAK,GAAGW;QACtB;QAEA,IAAIG,kBAAkB;QACtB,IAAIC,2BAA2B;QAC/B,IAAI;YACF,MAAMC,SAAS,MAAMtC,QAAQ+B;YAC7BK,kBAAkB,CAAC,CAACE,OAAOF,eAAe;YAC1CC,2BAA2BC,OAAOD,wBAAwB;QAC5D,EAAE,OAAOE,KAAK;YACZpC,IAAIE,OAAO,CAACmC,MAAM,CAACC,KAAK,CAAC;gBACvBF;gBACAG,KAAK;gBACLnB,OAAOQ,YAAYR,KAAK;YAC1B;YAEA,OAAOd,SAASC,IAAI,CAClB;gBACEC,SAASR,IAAIc,IAAI,CAACC,CAAC,CAAC;gBACpBkB,iBAAiB;gBACjBC;YACF,GACA;gBAAEzB,QAAQ;YAAI;QAElB;QAEA,OAAOH,SAASC,IAAI,CAClB;YACEC,SAASR,IAAIc,IAAI,CAACC,CAAC,CAAC;YACpBkB;YACAC;QACF,GACA;YAAEzB,QAAQ;QAAI;IAElB;IACA+B,QAAQ;IACRC,MAAM;AACR,EAAC;AAED,OAAO,MAAMpC,gBAAgB,CAACJ;IAC5B,OAAOyC,QAAQzC,WAAW0C,KAAK,EAAEC,UAAU3C,WAAW4C,SAAS,EAAED;AACnE,EAAC"}

package/dist/queues/errors/calculateBackoffWaitUntil.d.ts

@@ -0,0 +1,6 @@
+import type { RetryConfig } from '../config/types/taskTypes.js';
+export declare function calculateBackoffWaitUntil({ retriesConfig, totalTried, }: {
+    retriesConfig: number | RetryConfig;
+    totalTried: number;
+}): Date;
+//# sourceMappingURL=calculateBackoffWaitUntil.d.ts.map

package/dist/queues/errors/calculateBackoffWaitUntil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateBackoffWaitUntil.d.ts","sourceRoot":"","sources":["../../../src/queues/errors/calculateBackoffWaitUntil.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA;AAI/D,wBAAgB,yBAAyB,CAAC,EACxC,aAAa,EACb,UAAU,GACX,EAAE;IACD,aAAa,EAAE,MAAM,GAAG,WAAW,CAAA;IACnC,UAAU,EAAE,MAAM,CAAA;CACnB,GAAG,IAAI,CA2BP"}

package/dist/queues/errors/calculateBackoffWaitUntil.js

@@ -0,0 +1,27 @@
+import { getCurrentDate } from '../utilities/getCurrentDate.js';
+export function calculateBackoffWaitUntil({ retriesConfig, totalTried }) {
+    let waitUntil = getCurrentDate();
+    if (typeof retriesConfig === 'object') {
+        if (retriesConfig.backoff) {
+            if (retriesConfig.backoff.type === 'fixed') {
+                waitUntil = retriesConfig.backoff.delay ? new Date(getCurrentDate().getTime() + retriesConfig.backoff.delay) : getCurrentDate();
+            } else if (retriesConfig.backoff.type === 'exponential') {
+                // 2 ^ (attempts - 1) * delay (current attempt is not included in totalTried, thus no need for -1)
+                const delay = retriesConfig.backoff.delay ? retriesConfig.backoff.delay : 0;
+                waitUntil = new Date(getCurrentDate().getTime() + Math.pow(2, totalTried) * delay);
+            }
+        }
+    }
+    /*
+  const differenceInMSBetweenNowAndWaitUntil = waitUntil.getTime() - getCurrentDate().getTime()
+
+  const differenceInSBetweenNowAndWaitUntil = differenceInMSBetweenNowAndWaitUntil / 1000
+  console.log('Calculated backoff', {
+    differenceInMSBetweenNowAndWaitUntil,
+    differenceInSBetweenNowAndWaitUntil,
+    retriesConfig,
+    totalTried,
+  })*/ return waitUntil;
+}
+
+//# sourceMappingURL=calculateBackoffWaitUntil.js.map

package/dist/queues/errors/calculateBackoffWaitUntil.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/queues/errors/calculateBackoffWaitUntil.ts"],"sourcesContent":["import type { RetryConfig } from '../config/types/taskTypes.js'\n\nimport { getCurrentDate } from '../utilities/getCurrentDate.js'\n\nexport function calculateBackoffWaitUntil({\n  retriesConfig,\n  totalTried,\n}: {\n  retriesConfig: number | RetryConfig\n  totalTried: number\n}): Date {\n  let waitUntil: Date = getCurrentDate()\n  if (typeof retriesConfig === 'object') {\n    if (retriesConfig.backoff) {\n      if (retriesConfig.backoff.type === 'fixed') {\n        waitUntil = retriesConfig.backoff.delay\n          ? new Date(getCurrentDate().getTime() + retriesConfig.backoff.delay)\n          : getCurrentDate()\n      } else if (retriesConfig.backoff.type === 'exponential') {\n        // 2 ^ (attempts - 1) * delay (current attempt is not included in totalTried, thus no need for -1)\n        const delay = retriesConfig.backoff.delay ? retriesConfig.backoff.delay : 0\n        waitUntil = new Date(getCurrentDate().getTime() + Math.pow(2, totalTried) * delay)\n      }\n    }\n  }\n\n  /*\n  const differenceInMSBetweenNowAndWaitUntil = waitUntil.getTime() - getCurrentDate().getTime()\n\n  const differenceInSBetweenNowAndWaitUntil = differenceInMSBetweenNowAndWaitUntil / 1000\n  console.log('Calculated backoff', {\n    differenceInMSBetweenNowAndWaitUntil,\n    differenceInSBetweenNowAndWaitUntil,\n    retriesConfig,\n    totalTried,\n  })*/\n  return waitUntil\n}\n"],"names":["getCurrentDate","calculateBackoffWaitUntil","retriesConfig","totalTried","waitUntil","backoff","type","delay","Date","getTime","Math","pow"],"mappings":"AAEA,SAASA,cAAc,QAAQ,iCAAgC;AAE/D,OAAO,SAASC,0BAA0B,EACxCC,aAAa,EACbC,UAAU,EAIX;IACC,IAAIC,YAAkBJ;IACtB,IAAI,OAAOE,kBAAkB,UAAU;QACrC,IAAIA,cAAcG,OAAO,EAAE;YACzB,IAAIH,cAAcG,OAAO,CAACC,IAAI,KAAK,SAAS;gBAC1CF,YAAYF,cAAcG,OAAO,CAACE,KAAK,GACnC,IAAIC,KAAKR,iBAAiBS,OAAO,KAAKP,cAAcG,OAAO,CAACE,KAAK,IACjEP;YACN,OAAO,IAAIE,cAAcG,OAAO,CAACC,IAAI,KAAK,eAAe;gBACvD,kGAAkG;gBAClG,MAAMC,QAAQL,cAAcG,OAAO,CAACE,KAAK,GAAGL,cAAcG,OAAO,CAACE,KAAK,GAAG;gBAC1EH,YAAY,IAAII,KAAKR,iBAAiBS,OAAO,KAAKC,KAAKC,GAAG,CAAC,GAAGR,cAAcI;YAC9E;QACF;IACF;IAEA;;;;;;;;;IASE,GACF,OAAOH;AACT"}

package/dist/queues/errors/getWorkflowRetryBehavior.d.ts

@@ -0,0 +1,20 @@
+import type { Job } from '../../index.js';
+import type { RetryConfig } from '../config/types/taskTypes.js';
+/**
+ * Assuming there is no task that has already reached max retries,
+ * this function determines if the workflow should retry the job
+ * and if so, when it should retry.
+ */
+export declare function getWorkflowRetryBehavior({ job, retriesConfig, }: {
+    job: Job;
+    retriesConfig?: number | RetryConfig;
+}): {
+    hasFinalError: false;
+    maxWorkflowRetries?: number;
+    waitUntil?: Date;
+} | {
+    hasFinalError: true;
+    maxWorkflowRetries?: number;
+    waitUntil?: Date;
+};
+//# sourceMappingURL=getWorkflowRetryBehavior.d.ts.map

package/dist/queues/errors/getWorkflowRetryBehavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getWorkflowRetryBehavior.d.ts","sourceRoot":"","sources":["../../../src/queues/errors/getWorkflowRetryBehavior.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA;AAI/D;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,EACvC,GAAG,EACH,aAAa,GACd,EAAE;IACD,GAAG,EAAE,GAAG,CAAA;IACR,aAAa,CAAC,EAAE,MAAM,GAAG,WAAW,CAAA;CACrC,GACG;IACE,aAAa,EAAE,KAAK,CAAA;IACpB,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,SAAS,CAAC,EAAE,IAAI,CAAA;CACjB,GACD;IACE,aAAa,EAAE,IAAI,CAAA;IACnB,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,SAAS,CAAC,EAAE,IAAI,CAAA;CACjB,CAoCJ"}

package/dist/queues/errors/getWorkflowRetryBehavior.js

@@ -0,0 +1,34 @@
+import { calculateBackoffWaitUntil } from './calculateBackoffWaitUntil.js';
+/**
+ * Assuming there is no task that has already reached max retries,
+ * this function determines if the workflow should retry the job
+ * and if so, when it should retry.
+ */ export function getWorkflowRetryBehavior({ job, retriesConfig }) {
+    const maxWorkflowRetries = typeof retriesConfig === 'object' ? retriesConfig.attempts : retriesConfig;
+    if (maxWorkflowRetries !== undefined && maxWorkflowRetries !== null && job.totalTried >= maxWorkflowRetries) {
+        return {
+            hasFinalError: true,
+            maxWorkflowRetries
+        };
+    }
+    if (!retriesConfig) {
+        // No retries provided => assuming no task reached max retries, we can retry
+        return {
+            hasFinalError: false,
+            maxWorkflowRetries: undefined,
+            waitUntil: undefined
+        };
+    }
+    // Job will retry. Let's determine when!
+    const waitUntil = calculateBackoffWaitUntil({
+        retriesConfig,
+        totalTried: job.totalTried ?? 0
+    });
+    return {
+        hasFinalError: false,
+        maxWorkflowRetries,
+        waitUntil
+    };
+}
+
+//# sourceMappingURL=getWorkflowRetryBehavior.js.map

package/dist/queues/errors/getWorkflowRetryBehavior.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/queues/errors/getWorkflowRetryBehavior.ts"],"sourcesContent":["import type { Job } from '../../index.js'\nimport type { RetryConfig } from '../config/types/taskTypes.js'\n\nimport { calculateBackoffWaitUntil } from './calculateBackoffWaitUntil.js'\n\n/**\n * Assuming there is no task that has already reached max retries,\n * this function determines if the workflow should retry the job\n * and if so, when it should retry.\n */\nexport function getWorkflowRetryBehavior({\n  job,\n  retriesConfig,\n}: {\n  job: Job\n  retriesConfig?: number | RetryConfig\n}):\n  | {\n      hasFinalError: false\n      maxWorkflowRetries?: number\n      waitUntil?: Date\n    }\n  | {\n      hasFinalError: true\n      maxWorkflowRetries?: number\n      waitUntil?: Date\n    } {\n  const maxWorkflowRetries = (\n    typeof retriesConfig === 'object' ? retriesConfig.attempts : retriesConfig\n  )!\n\n  if (\n    maxWorkflowRetries !== undefined &&\n    maxWorkflowRetries !== null &&\n    job.totalTried >= maxWorkflowRetries\n  ) {\n    return {\n      hasFinalError: true,\n      maxWorkflowRetries,\n    }\n  }\n\n  if (!retriesConfig) {\n    // No retries provided => assuming no task reached max retries, we can retry\n    return {\n      hasFinalError: false,\n      maxWorkflowRetries: undefined,\n      waitUntil: undefined,\n    }\n  }\n\n  // Job will retry. Let's determine when!\n  const waitUntil: Date = calculateBackoffWaitUntil({\n    retriesConfig,\n    totalTried: job.totalTried ?? 0,\n  })\n\n  return {\n    hasFinalError: false,\n    maxWorkflowRetries,\n    waitUntil,\n  }\n}\n"],"names":["calculateBackoffWaitUntil","getWorkflowRetryBehavior","job","retriesConfig","maxWorkflowRetries","attempts","undefined","totalTried","hasFinalError","waitUntil"],"mappings":"AAGA,SAASA,yBAAyB,QAAQ,iCAAgC;AAE1E;;;;CAIC,GACD,OAAO,SAASC,yBAAyB,EACvCC,GAAG,EACHC,aAAa,EAId;IAWC,MAAMC,qBACJ,OAAOD,kBAAkB,WAAWA,cAAcE,QAAQ,GAAGF;IAG/D,IACEC,uBAAuBE,aACvBF,uBAAuB,QACvBF,IAAIK,UAAU,IAAIH,oBAClB;QACA,OAAO;YACLI,eAAe;YACfJ;QACF;IACF;IAEA,IAAI,CAACD,eAAe;QAClB,4EAA4E;QAC5E,OAAO;YACLK,eAAe;YACfJ,oBAAoBE;YACpBG,WAAWH;QACb;IACF;IAEA,wCAAwC;IACxC,MAAMG,YAAkBT,0BAA0B;QAChDG;QACAI,YAAYL,IAAIK,UAAU,IAAI;IAChC;IAEA,OAAO;QACLC,eAAe;QACfJ;QACAK;IACF;AACF"}

package/dist/queues/errors/handleTaskError.d.ts

@@ -0,0 +1,21 @@
+import type { PayloadRequest } from '../../index.js';
+import type { RunJobsSilent } from '../localAPI.js';
+import type { UpdateJobFunction } from '../operations/runJobs/runJob/getUpdateJobFunction.js';
+import type { TaskError } from './index.js';
+export declare function handleTaskError({ error, req, silent, updateJob, }: {
+    error: TaskError;
+    req: PayloadRequest;
+    /**
+     * If set to true, the job system will not log any output to the console (for both info and error logs).
+     * Can be an option for more granular control over logging.
+     *
+     * This will not automatically affect user-configured logs (e.g. if you call `console.log` or `payload.logger.info` in your job code).
+     *
+     * @default false
+     */
+    silent?: RunJobsSilent;
+    updateJob: UpdateJobFunction;
+}): Promise<{
+    hasFinalError: boolean;
+}>;
+//# sourceMappingURL=handleTaskError.d.ts.map

package/dist/queues/errors/handleTaskError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleTaskError.d.ts","sourceRoot":"","sources":["../../../src/queues/errors/handleTaskError.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAU,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sDAAsD,CAAA;AAC7F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAQ3C,wBAAsB,eAAe,CAAC,EACpC,KAAK,EACL,GAAG,EACH,MAAc,EACd,SAAS,GACV,EAAE;IACD,KAAK,EAAE,SAAS,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;IACnB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,aAAa,CAAA;IACtB,SAAS,EAAE,iBAAiB,CAAA;CAC7B,GAAG,OAAO,CAAC;IACV,aAAa,EAAE,OAAO,CAAA;CACvB,CAAC,CA0JD"}

package/dist/queues/errors/handleTaskError.js

@@ -0,0 +1,125 @@
+import ObjectIdImport from 'bson-objectid';
+import { getCurrentDate } from '../utilities/getCurrentDate.js';
+import { calculateBackoffWaitUntil } from './calculateBackoffWaitUntil.js';
+import { getWorkflowRetryBehavior } from './getWorkflowRetryBehavior.js';
+const ObjectId = 'default' in ObjectIdImport ? ObjectIdImport.default : ObjectIdImport;
+export async function handleTaskError({ error, req, silent = false, updateJob }) {
+    const { executedAt, input, job, output, parent, retriesConfig, taskConfig, taskID, taskSlug, taskStatus, workflowConfig } = error.args;
+    if (taskConfig?.onFail) {
+        await taskConfig.onFail({
+            input,
+            job,
+            req,
+            taskStatus
+        });
+    }
+    const errorJSON = {
+        name: error.name,
+        cancelled: Boolean('cancelled' in error && error.cancelled),
+        message: error.message,
+        stack: error.stack
+    };
+    const currentDate = getCurrentDate();
+    if (job.waitUntil) {
+        // Check if waitUntil is in the past
+        const waitUntil = new Date(job.waitUntil);
+        if (waitUntil < currentDate) {
+            // Outdated waitUntil, remove it
+            delete job.waitUntil;
+        }
+    }
+    let maxRetries = 0;
+    if (retriesConfig?.attempts === undefined || retriesConfig?.attempts === null) {
+        // Inherit retries from workflow config, if they are undefined and the workflow config has retries configured
+        if (workflowConfig.retries !== undefined && workflowConfig.retries !== null) {
+            maxRetries = typeof workflowConfig.retries === 'object' ? typeof workflowConfig.retries.attempts === 'number' ? workflowConfig.retries.attempts : 0 : workflowConfig.retries;
+        } else {
+            maxRetries = 0;
+        }
+    } else {
+        maxRetries = retriesConfig.attempts;
+    }
+    const taskLogToPush = {
+        id: new ObjectId().toHexString(),
+        completedAt: currentDate.toISOString(),
+        error: errorJSON,
+        executedAt: executedAt.toISOString(),
+        input,
+        output: output ?? {},
+        parent: req.payload.config.jobs.addParentToTaskLog ? parent : undefined,
+        state: 'failed',
+        taskID,
+        taskSlug
+    };
+    if (!taskStatus?.complete && (taskStatus?.totalTried ?? 0) >= maxRetries) {
+        /**
+     * Task reached max retries => workflow will not retry
+     */ await updateJob({
+            error: errorJSON,
+            hasError: true,
+            log: {
+                $push: taskLogToPush
+            },
+            processing: false,
+            totalTried: (job.totalTried ?? 0) + 1,
+            waitUntil: job.waitUntil
+        });
+        if (!silent || typeof silent === 'object' && !silent.error) {
+            req.payload.logger.error({
+                err: error,
+                job,
+                msg: `Error running task ${taskID}. Attempt ${job.totalTried} - max retries reached`,
+                taskSlug
+            });
+        }
+        return {
+            hasFinalError: true
+        };
+    }
+    /**
+   * Task can retry:
+   * - If workflow can retry, allow it to retry
+   * - If workflow reached max retries, do not retry and set final error
+   */ // First set task waitUntil - if the workflow waitUntil is later, it will be updated later
+    const taskWaitUntil = calculateBackoffWaitUntil({
+        retriesConfig,
+        totalTried: taskStatus?.totalTried ?? 0
+    });
+    // Update job's waitUntil only if this waitUntil is later than the current one
+    if (!job.waitUntil || taskWaitUntil > new Date(job.waitUntil)) {
+        job.waitUntil = taskWaitUntil.toISOString();
+    }
+    const { hasFinalError, maxWorkflowRetries, waitUntil } = getWorkflowRetryBehavior({
+        job,
+        retriesConfig: workflowConfig.retries
+    });
+    if (!silent || typeof silent === 'object' && !silent.error) {
+        req.payload.logger.error({
+            err: error,
+            job,
+            msg: `Error running task ${taskID}. Attempt ${job.totalTried + 1}${maxWorkflowRetries !== undefined ? '/' + (maxWorkflowRetries + 1) : ''}`,
+            taskSlug
+        });
+    }
+    // Update job's waitUntil only if this waitUntil is later than the current one
+    if (waitUntil && (!job.waitUntil || waitUntil > new Date(job.waitUntil))) {
+        job.waitUntil = waitUntil.toISOString();
+    }
+    // Tasks update the job if they error - but in case there is an unhandled error (e.g. in the workflow itself, not in a task)
+    // we need to ensure the job is updated to reflect the error
+    await updateJob({
+        error: hasFinalError ? errorJSON : undefined,
+        hasError: hasFinalError,
+        log: {
+            $push: taskLogToPush
+        },
+        processing: false,
+        totalTried: (job.totalTried ?? 0) + 1,
+        waitUntil: job.waitUntil
+    });
+    return {
+        hasFinalError
+    };
+}
+
+//# sourceMappingURL=handleTaskError.js.map

package/dist/queues/errors/handleTaskError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/queues/errors/handleTaskError.ts"],"sourcesContent":["import ObjectIdImport from 'bson-objectid'\n\nimport type { JobLog, PayloadRequest } from '../../index.js'\nimport type { RunJobsSilent } from '../localAPI.js'\nimport type { UpdateJobFunction } from '../operations/runJobs/runJob/getUpdateJobFunction.js'\nimport type { TaskError } from './index.js'\n\nimport { getCurrentDate } from '../utilities/getCurrentDate.js'\nimport { calculateBackoffWaitUntil } from './calculateBackoffWaitUntil.js'\nimport { getWorkflowRetryBehavior } from './getWorkflowRetryBehavior.js'\n\nconst ObjectId = 'default' in ObjectIdImport ? ObjectIdImport.default : ObjectIdImport\n\nexport async function handleTaskError({\n  error,\n  req,\n  silent = false,\n  updateJob,\n}: {\n  error: TaskError\n  req: PayloadRequest\n  /**\n   * If set to true, the job system will not log any output to the console (for both info and error logs).\n   * Can be an option for more granular control over logging.\n   *\n   * This will not automatically affect user-configured logs (e.g. if you call `console.log` or `payload.logger.info` in your job code).\n   *\n   * @default false\n   */\n  silent?: RunJobsSilent\n  updateJob: UpdateJobFunction\n}): Promise<{\n  hasFinalError: boolean\n}> {\n  const {\n    executedAt,\n    input,\n    job,\n    output,\n    parent,\n    retriesConfig,\n    taskConfig,\n    taskID,\n    taskSlug,\n    taskStatus,\n    workflowConfig,\n  } = error.args\n\n  if (taskConfig?.onFail) {\n    await taskConfig.onFail({\n      input,\n      job,\n      req,\n      taskStatus,\n    })\n  }\n\n  const errorJSON = {\n    name: error.name,\n    cancelled: Boolean('cancelled' in error && error.cancelled),\n    message: error.message,\n    stack: error.stack,\n  }\n\n  const currentDate = getCurrentDate()\n\n  if (job.waitUntil) {\n    // Check if waitUntil is in the past\n    const waitUntil = new Date(job.waitUntil)\n    if (waitUntil < currentDate) {\n      // Outdated waitUntil, remove it\n      delete job.waitUntil\n    }\n  }\n\n  let maxRetries: number = 0\n\n  if (retriesConfig?.attempts === undefined || retriesConfig?.attempts === null) {\n    // Inherit retries from workflow config, if they are undefined and the workflow config has retries configured\n    if (workflowConfig.retries !== undefined && workflowConfig.retries !== null) {\n      maxRetries =\n        typeof workflowConfig.retries === 'object'\n          ? typeof workflowConfig.retries.attempts === 'number'\n            ? workflowConfig.retries.attempts\n            : 0\n          : workflowConfig.retries\n    } else {\n      maxRetries = 0\n    }\n  } else {\n    maxRetries = retriesConfig.attempts\n  }\n\n  const taskLogToPush: JobLog = {\n    id: new ObjectId().toHexString(),\n    completedAt: currentDate.toISOString(),\n    error: errorJSON,\n    executedAt: executedAt.toISOString(),\n    input,\n    output: output ?? {},\n    parent: req.payload.config.jobs.addParentToTaskLog ? parent : undefined,\n    state: 'failed',\n    taskID,\n    taskSlug,\n  }\n\n  if (!taskStatus?.complete && (taskStatus?.totalTried ?? 0) >= maxRetries) {\n    /**\n     * Task reached max retries => workflow will not retry\n     */\n\n    await updateJob({\n      error: errorJSON,\n      hasError: true,\n      log: {\n        $push: taskLogToPush,\n      } as any,\n      processing: false,\n      totalTried: (job.totalTried ?? 0) + 1,\n      waitUntil: job.waitUntil,\n    })\n\n    if (!silent || (typeof silent === 'object' && !silent.error)) {\n      req.payload.logger.error({\n        err: error,\n        job,\n        msg: `Error running task ${taskID}. Attempt ${job.totalTried} - max retries reached`,\n        taskSlug,\n      })\n    }\n    return {\n      hasFinalError: true,\n    }\n  }\n\n  /**\n   * Task can retry:\n   * - If workflow can retry, allow it to retry\n   * - If workflow reached max retries, do not retry and set final error\n   */\n\n  // First set task waitUntil - if the workflow waitUntil is later, it will be updated later\n  const taskWaitUntil: Date = calculateBackoffWaitUntil({\n    retriesConfig,\n    totalTried: taskStatus?.totalTried ?? 0,\n  })\n\n  // Update job's waitUntil only if this waitUntil is later than the current one\n  if (!job.waitUntil || taskWaitUntil > new Date(job.waitUntil)) {\n    job.waitUntil = taskWaitUntil.toISOString()\n  }\n\n  const { hasFinalError, maxWorkflowRetries, waitUntil } = getWorkflowRetryBehavior({\n    job,\n    retriesConfig: workflowConfig.retries,\n  })\n\n  if (!silent || (typeof silent === 'object' && !silent.error)) {\n    req.payload.logger.error({\n      err: error,\n      job,\n      msg: `Error running task ${taskID}. Attempt ${job.totalTried + 1}${maxWorkflowRetries !== undefined ? '/' + (maxWorkflowRetries + 1) : ''}`,\n      taskSlug,\n    })\n  }\n\n  // Update job's waitUntil only if this waitUntil is later than the current one\n  if (waitUntil && (!job.waitUntil || waitUntil > new Date(job.waitUntil))) {\n    job.waitUntil = waitUntil.toISOString()\n  }\n\n  // Tasks update the job if they error - but in case there is an unhandled error (e.g. in the workflow itself, not in a task)\n  // we need to ensure the job is updated to reflect the error\n  await updateJob({\n    error: hasFinalError ? errorJSON : undefined,\n    hasError: hasFinalError, // If reached max retries => final error. If hasError is true this job will not be retried\n    log: {\n      $push: taskLogToPush,\n    } as any,\n    processing: false,\n    totalTried: (job.totalTried ?? 0) + 1,\n    waitUntil: job.waitUntil,\n  })\n\n  return {\n    hasFinalError,\n  }\n}\n"],"names":["ObjectIdImport","getCurrentDate","calculateBackoffWaitUntil","getWorkflowRetryBehavior","ObjectId","default","handleTaskError","error","req","silent","updateJob","executedAt","input","job","output","parent","retriesConfig","taskConfig","taskID","taskSlug","taskStatus","workflowConfig","args","onFail","errorJSON","name","cancelled","Boolean","message","stack","currentDate","waitUntil","Date","maxRetries","attempts","undefined","retries","taskLogToPush","id","toHexString","completedAt","toISOString","payload","config","jobs","addParentToTaskLog","state","complete","totalTried","hasError","log","$push","processing","logger","err","msg","hasFinalError","taskWaitUntil","maxWorkflowRetries"],"mappings":"AAAA,OAAOA,oBAAoB,gBAAe;AAO1C,SAASC,cAAc,QAAQ,iCAAgC;AAC/D,SAASC,yBAAyB,QAAQ,iCAAgC;AAC1E,SAASC,wBAAwB,QAAQ,gCAA+B;AAExE,MAAMC,WAAW,aAAaJ,iBAAiBA,eAAeK,OAAO,GAAGL;AAExE,OAAO,eAAeM,gBAAgB,EACpCC,KAAK,EACLC,GAAG,EACHC,SAAS,KAAK,EACdC,SAAS,EAcV;IAGC,MAAM,EACJC,UAAU,EACVC,KAAK,EACLC,GAAG,EACHC,MAAM,EACNC,MAAM,EACNC,aAAa,EACbC,UAAU,EACVC,MAAM,EACNC,QAAQ,EACRC,UAAU,EACVC,cAAc,EACf,GAAGd,MAAMe,IAAI;IAEd,IAAIL,YAAYM,QAAQ;QACtB,MAAMN,WAAWM,MAAM,CAAC;YACtBX;YACAC;YACAL;YACAY;QACF;IACF;IAEA,MAAMI,YAAY;QAChBC,MAAMlB,MAAMkB,IAAI;QAChBC,WAAWC,QAAQ,eAAepB,SAASA,MAAMmB,SAAS;QAC1DE,SAASrB,MAAMqB,OAAO;QACtBC,OAAOtB,MAAMsB,KAAK;IACpB;IAEA,MAAMC,cAAc7B;IAEpB,IAAIY,IAAIkB,SAAS,EAAE;QACjB,oCAAoC;QACpC,MAAMA,YAAY,IAAIC,KAAKnB,IAAIkB,SAAS;QACxC,IAAIA,YAAYD,aAAa;YAC3B,gCAAgC;YAChC,OAAOjB,IAAIkB,SAAS;QACtB;IACF;IAEA,IAAIE,aAAqB;IAEzB,IAAIjB,eAAekB,aAAaC,aAAanB,eAAekB,aAAa,MAAM;QAC7E,6GAA6G;QAC7G,IAAIb,eAAee,OAAO,KAAKD,aAAad,eAAee,OAAO,KAAK,MAAM;YAC3EH,aACE,OAAOZ,eAAee,OAAO,KAAK,WAC9B,OAAOf,eAAee,OAAO,CAACF,QAAQ,KAAK,WACzCb,eAAee,OAAO,CAACF,QAAQ,GAC/B,IACFb,eAAee,OAAO;QAC9B,OAAO;YACLH,aAAa;QACf;IACF,OAAO;QACLA,aAAajB,cAAckB,QAAQ;IACrC;IAEA,MAAMG,gBAAwB;QAC5BC,IAAI,IAAIlC,WAAWmC,WAAW;QAC9BC,aAAaV,YAAYW,WAAW;QACpClC,OAAOiB;QACPb,YAAYA,WAAW8B,WAAW;QAClC7B;QACAE,QAAQA,UAAU,CAAC;QACnBC,QAAQP,IAAIkC,OAAO,CAACC,MAAM,CAACC,IAAI,CAACC,kBAAkB,GAAG9B,SAASoB;QAC9DW,OAAO;QACP5B;QACAC;IACF;IAEA,IAAI,CAACC,YAAY2B,YAAY,AAAC3B,CAAAA,YAAY4B,cAAc,CAAA,KAAMf,YAAY;QACxE;;KAEC,GAED,MAAMvB,UAAU;YACdH,OAAOiB;YACPyB,UAAU;YACVC,KAAK;gBACHC,OAAOd;YACT;YACAe,YAAY;YACZJ,YAAY,AAACnC,CAAAA,IAAImC,UAAU,IAAI,CAAA,IAAK;YACpCjB,WAAWlB,IAAIkB,SAAS;QAC1B;QAEA,IAAI,CAACtB,UAAW,OAAOA,WAAW,YAAY,CAACA,OAAOF,KAAK,EAAG;YAC5DC,IAAIkC,OAAO,CAACW,MAAM,CAAC9C,KAAK,CAAC;gBACvB+C,KAAK/C;gBACLM;gBACA0C,KAAK,CAAC,mBAAmB,EAAErC,OAAO,UAAU,EAAEL,IAAImC,UAAU,CAAC,sBAAsB,CAAC;gBACpF7B;YACF;QACF;QACA,OAAO;YACLqC,eAAe;QACjB;IACF;IAEA;;;;GAIC,GAED,0FAA0F;IAC1F,MAAMC,gBAAsBvD,0BAA0B;QACpDc;QACAgC,YAAY5B,YAAY4B,cAAc;IACxC;IAEA,8EAA8E;IAC9E,IAAI,CAACnC,IAAIkB,SAAS,IAAI0B,gBAAgB,IAAIzB,KAAKnB,IAAIkB,SAAS,GAAG;QAC7DlB,IAAIkB,SAAS,GAAG0B,cAAchB,WAAW;IAC3C;IAEA,MAAM,EAAEe,aAAa,EAAEE,kBAAkB,EAAE3B,SAAS,EAAE,GAAG5B,yBAAyB;QAChFU;QACAG,eAAeK,eAAee,OAAO;IACvC;IAEA,IAAI,CAAC3B,UAAW,OAAOA,WAAW,YAAY,CAACA,OAAOF,KAAK,EAAG;QAC5DC,IAAIkC,OAAO,CAACW,MAAM,CAAC9C,KAAK,CAAC;YACvB+C,KAAK/C;YACLM;YACA0C,KAAK,CAAC,mBAAmB,EAAErC,OAAO,UAAU,EAAEL,IAAImC,UAAU,GAAG,IAAIU,uBAAuBvB,YAAY,MAAOuB,CAAAA,qBAAqB,CAAA,IAAK,IAAI;YAC3IvC;QACF;IACF;IAEA,8EAA8E;IAC9E,IAAIY,aAAc,CAAA,CAAClB,IAAIkB,SAAS,IAAIA,YAAY,IAAIC,KAAKnB,IAAIkB,SAAS,CAAA,GAAI;QACxElB,IAAIkB,SAAS,GAAGA,UAAUU,WAAW;IACvC;IAEA,4HAA4H;IAC5H,4DAA4D;IAC5D,MAAM/B,UAAU;QACdH,OAAOiD,gBAAgBhC,YAAYW;QACnCc,UAAUO;QACVN,KAAK;YACHC,OAAOd;QACT;QACAe,YAAY;QACZJ,YAAY,AAACnC,CAAAA,IAAImC,UAAU,IAAI,CAAA,IAAK;QACpCjB,WAAWlB,IAAIkB,SAAS;IAC1B;IAEA,OAAO;QACLyB;IACF;AACF"}

package/dist/queues/errors/handleWorkflowError.d.ts

@@ -0,0 +1,29 @@
+import type { PayloadRequest } from '../../index.js';
+import type { RunJobsSilent } from '../localAPI.js';
+import type { UpdateJobFunction } from '../operations/runJobs/runJob/getUpdateJobFunction.js';
+import type { WorkflowError } from './index.js';
+/**
+ * This is called if a workflow catches an error. It determines if it's a final error
+ * or not and handles logging.
+ * A Workflow error = error that happens anywhere in between running tasks.
+ *
+ * This function assumes that the error is not a TaskError, but a WorkflowError. If a task errors,
+ * only a TaskError should be thrown, not a WorkflowError.
+ */
+export declare function handleWorkflowError({ error, req, silent, updateJob, }: {
+    error: WorkflowError;
+    req: PayloadRequest;
+    /**
+     * If set to true, the job system will not log any output to the console (for both info and error logs).
+     * Can be an option for more granular control over logging.
+     *
+     * This will not automatically affect user-configured logs (e.g. if you call `console.log` or `payload.logger.info` in your job code).
+     *
+     * @default false
+     */
+    silent?: RunJobsSilent;
+    updateJob: UpdateJobFunction;
+}): Promise<{
+    hasFinalError: boolean;
+}>;
+//# sourceMappingURL=handleWorkflowError.d.ts.map

package/dist/queues/errors/handleWorkflowError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleWorkflowError.d.ts","sourceRoot":"","sources":["../../../src/queues/errors/handleWorkflowError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sDAAsD,CAAA;AAC7F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAK/C;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CAAC,EACxC,KAAK,EACL,GAAG,EACH,MAAc,EACd,SAAS,GACV,EAAE;IACD,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,cAAc,CAAA;IACnB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,aAAa,CAAA;IACtB,SAAS,EAAE,iBAAiB,CAAA;CAC7B,GAAG,OAAO,CAAC;IACV,aAAa,EAAE,OAAO,CAAA;CACvB,CAAC,CAqDD"}

package/dist/queues/errors/handleWorkflowError.js

@@ -0,0 +1,57 @@
+import { getCurrentDate } from '../utilities/getCurrentDate.js';
+import { getWorkflowRetryBehavior } from './getWorkflowRetryBehavior.js';
+/**
+ * This is called if a workflow catches an error. It determines if it's a final error
+ * or not and handles logging.
+ * A Workflow error = error that happens anywhere in between running tasks.
+ *
+ * This function assumes that the error is not a TaskError, but a WorkflowError. If a task errors,
+ * only a TaskError should be thrown, not a WorkflowError.
+ */ export async function handleWorkflowError({ error, req, silent = false, updateJob }) {
+    const { job, workflowConfig } = error.args;
+    const errorJSON = {
+        name: error.name,
+        cancelled: Boolean('cancelled' in error && error.cancelled),
+        message: error.message,
+        stack: error.stack
+    };
+    const { hasFinalError, maxWorkflowRetries, waitUntil } = getWorkflowRetryBehavior({
+        job,
+        retriesConfig: workflowConfig.retries
+    });
+    if (!hasFinalError) {
+        if (job.waitUntil) {
+            // Check if waitUntil is in the past
+            const waitUntil = new Date(job.waitUntil);
+            if (waitUntil < getCurrentDate()) {
+                // Outdated waitUntil, remove it
+                delete job.waitUntil;
+            }
+        }
+        // Update job's waitUntil only if this waitUntil is later than the current one
+        if (waitUntil && (!job.waitUntil || waitUntil > new Date(job.waitUntil))) {
+            job.waitUntil = waitUntil.toISOString();
+        }
+    }
+    const jobLabel = job.workflowSlug || `Task: ${job.taskSlug}`;
+    if (!silent || typeof silent === 'object' && !silent.error) {
+        req.payload.logger.error({
+            err: error,
+            msg: `Error running job ${jobLabel} id: ${job.id} attempt ${job.totalTried + 1}${maxWorkflowRetries !== undefined ? '/' + (maxWorkflowRetries + 1) : ''}`
+        });
+    }
+    // Tasks update the job if they error - but in case there is an unhandled error (e.g. in the workflow itself, not in a task)
+    // we need to ensure the job is updated to reflect the error
+    await updateJob({
+        error: errorJSON,
+        hasError: hasFinalError,
+        processing: false,
+        totalTried: (job.totalTried ?? 0) + 1,
+        waitUntil: job.waitUntil
+    });
+    return {
+        hasFinalError
+    };
+}
+
+//# sourceMappingURL=handleWorkflowError.js.map

package/dist/queues/errors/handleWorkflowError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/queues/errors/handleWorkflowError.ts"],"sourcesContent":["import type { PayloadRequest } from '../../index.js'\nimport type { RunJobsSilent } from '../localAPI.js'\nimport type { UpdateJobFunction } from '../operations/runJobs/runJob/getUpdateJobFunction.js'\nimport type { WorkflowError } from './index.js'\n\nimport { getCurrentDate } from '../utilities/getCurrentDate.js'\nimport { getWorkflowRetryBehavior } from './getWorkflowRetryBehavior.js'\n\n/**\n * This is called if a workflow catches an error. It determines if it's a final error\n * or not and handles logging.\n * A Workflow error = error that happens anywhere in between running tasks.\n *\n * This function assumes that the error is not a TaskError, but a WorkflowError. If a task errors,\n * only a TaskError should be thrown, not a WorkflowError.\n */\nexport async function handleWorkflowError({\n  error,\n  req,\n  silent = false,\n  updateJob,\n}: {\n  error: WorkflowError\n  req: PayloadRequest\n  /**\n   * If set to true, the job system will not log any output to the console (for both info and error logs).\n   * Can be an option for more granular control over logging.\n   *\n   * This will not automatically affect user-configured logs (e.g. if you call `console.log` or `payload.logger.info` in your job code).\n   *\n   * @default false\n   */\n  silent?: RunJobsSilent\n  updateJob: UpdateJobFunction\n}): Promise<{\n  hasFinalError: boolean\n}> {\n  const { job, workflowConfig } = error.args\n\n  const errorJSON = {\n    name: error.name,\n    cancelled: Boolean('cancelled' in error && error.cancelled),\n    message: error.message,\n    stack: error.stack,\n  }\n\n  const { hasFinalError, maxWorkflowRetries, waitUntil } = getWorkflowRetryBehavior({\n    job,\n    retriesConfig: workflowConfig.retries!,\n  })\n\n  if (!hasFinalError) {\n    if (job.waitUntil) {\n      // Check if waitUntil is in the past\n      const waitUntil = new Date(job.waitUntil)\n      if (waitUntil < getCurrentDate()) {\n        // Outdated waitUntil, remove it\n        delete job.waitUntil\n      }\n    }\n\n    // Update job's waitUntil only if this waitUntil is later than the current one\n    if (waitUntil && (!job.waitUntil || waitUntil > new Date(job.waitUntil))) {\n      job.waitUntil = waitUntil.toISOString()\n    }\n  }\n\n  const jobLabel = job.workflowSlug || `Task: ${job.taskSlug}`\n\n  if (!silent || (typeof silent === 'object' && !silent.error)) {\n    req.payload.logger.error({\n      err: error,\n      msg: `Error running job ${jobLabel} id: ${job.id} attempt ${job.totalTried + 1}${maxWorkflowRetries !== undefined ? '/' + (maxWorkflowRetries + 1) : ''}`,\n    })\n  }\n\n  // Tasks update the job if they error - but in case there is an unhandled error (e.g. in the workflow itself, not in a task)\n  // we need to ensure the job is updated to reflect the error\n  await updateJob({\n    error: errorJSON,\n    hasError: hasFinalError, // If reached max retries => final error. If hasError is true this job will not be retried\n    processing: false,\n    totalTried: (job.totalTried ?? 0) + 1,\n    waitUntil: job.waitUntil,\n  })\n\n  return {\n    hasFinalError,\n  }\n}\n"],"names":["getCurrentDate","getWorkflowRetryBehavior","handleWorkflowError","error","req","silent","updateJob","job","workflowConfig","args","errorJSON","name","cancelled","Boolean","message","stack","hasFinalError","maxWorkflowRetries","waitUntil","retriesConfig","retries","Date","toISOString","jobLabel","workflowSlug","taskSlug","payload","logger","err","msg","id","totalTried","undefined","hasError","processing"],"mappings":"AAKA,SAASA,cAAc,QAAQ,iCAAgC;AAC/D,SAASC,wBAAwB,QAAQ,gCAA+B;AAExE;;;;;;;CAOC,GACD,OAAO,eAAeC,oBAAoB,EACxCC,KAAK,EACLC,GAAG,EACHC,SAAS,KAAK,EACdC,SAAS,EAcV;IAGC,MAAM,EAAEC,GAAG,EAAEC,cAAc,EAAE,GAAGL,MAAMM,IAAI;IAE1C,MAAMC,YAAY;QAChBC,MAAMR,MAAMQ,IAAI;QAChBC,WAAWC,QAAQ,eAAeV,SAASA,MAAMS,SAAS;QAC1DE,SAASX,MAAMW,OAAO;QACtBC,OAAOZ,MAAMY,KAAK;IACpB;IAEA,MAAM,EAAEC,aAAa,EAAEC,kBAAkB,EAAEC,SAAS,EAAE,GAAGjB,yBAAyB;QAChFM;QACAY,eAAeX,eAAeY,OAAO;IACvC;IAEA,IAAI,CAACJ,eAAe;QAClB,IAAIT,IAAIW,SAAS,EAAE;YACjB,oCAAoC;YACpC,MAAMA,YAAY,IAAIG,KAAKd,IAAIW,SAAS;YACxC,IAAIA,YAAYlB,kBAAkB;gBAChC,gCAAgC;gBAChC,OAAOO,IAAIW,SAAS;YACtB;QACF;QAEA,8EAA8E;QAC9E,IAAIA,aAAc,CAAA,CAACX,IAAIW,SAAS,IAAIA,YAAY,IAAIG,KAAKd,IAAIW,SAAS,CAAA,GAAI;YACxEX,IAAIW,SAAS,GAAGA,UAAUI,WAAW;QACvC;IACF;IAEA,MAAMC,WAAWhB,IAAIiB,YAAY,IAAI,CAAC,MAAM,EAAEjB,IAAIkB,QAAQ,EAAE;IAE5D,IAAI,CAACpB,UAAW,OAAOA,WAAW,YAAY,CAACA,OAAOF,KAAK,EAAG;QAC5DC,IAAIsB,OAAO,CAACC,MAAM,CAACxB,KAAK,CAAC;YACvByB,KAAKzB;YACL0B,KAAK,CAAC,kBAAkB,EAAEN,SAAS,KAAK,EAAEhB,IAAIuB,EAAE,CAAC,SAAS,EAAEvB,IAAIwB,UAAU,GAAG,IAAId,uBAAuBe,YAAY,MAAOf,CAAAA,qBAAqB,CAAA,IAAK,IAAI;QAC3J;IACF;IAEA,4HAA4H;IAC5H,4DAA4D;IAC5D,MAAMX,UAAU;QACdH,OAAOO;QACPuB,UAAUjB;QACVkB,YAAY;QACZH,YAAY,AAACxB,CAAAA,IAAIwB,UAAU,IAAI,CAAA,IAAK;QACpCb,WAAWX,IAAIW,SAAS;IAC1B;IAEA,OAAO;QACLF;IACF;AACF"}

package/dist/queues/errors/index.d.ts

@@ -0,0 +1,38 @@
+import type { Job, SingleTaskStatus, WorkflowConfig } from '../../index.js';
+import type { RetryConfig, TaskConfig } from '../config/types/taskTypes.js';
+import type { TaskParent } from '../operations/runJobs/runJob/getRunTaskFunction.js';
+export type TaskErrorArgs = {
+    executedAt: Date;
+    input?: object;
+    job: Job;
+    message: string;
+    output?: object;
+    parent?: TaskParent;
+    retriesConfig: RetryConfig;
+    taskConfig?: TaskConfig<string>;
+    taskID: string;
+    taskSlug: string;
+    taskStatus: null | SingleTaskStatus<string>;
+    workflowConfig: WorkflowConfig;
+};
+export type WorkflowErrorArgs = {
+    job: Job;
+    message: string;
+    workflowConfig: WorkflowConfig;
+};
+export declare class TaskError extends Error {
+    args: TaskErrorArgs;
+    constructor(args: TaskErrorArgs);
+}
+export declare class WorkflowError extends Error {
+    args: WorkflowErrorArgs;
+    constructor(args: WorkflowErrorArgs);
+}
+/**
+ * Throw this error from within a task or workflow handler to cancel the job.
+ * Unlike failing a job (e.g. by throwing any other error), a cancelled job will not be retried.
+ */
+export declare class JobCancelledError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/queues/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/queues/errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAC3E,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oDAAoD,CAAA;AAEpF,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,IAAI,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,GAAG,CAAA;IACR,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,UAAU,CAAA;IACnB,aAAa,EAAE,WAAW,CAAA;IAC1B,UAAU,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC/B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,IAAI,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAC3C,cAAc,EAAE,cAAc,CAAA;CAC/B,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,GAAG,CAAA;IACR,OAAO,EAAE,MAAM,CAAA;IACf,cAAc,EAAE,cAAc,CAAA;CAC/B,CAAA;AAED,qBAAa,SAAU,SAAQ,KAAK;IAClC,IAAI,EAAE,aAAa,CAAA;gBACP,IAAI,EAAE,aAAa;CAIhC;AACD,qBAAa,aAAc,SAAQ,KAAK;IACtC,IAAI,EAAE,iBAAiB,CAAA;gBAEX,IAAI,EAAE,iBAAiB;CAIpC;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;gBAC9B,OAAO,EAAE,MAAM;CAG5B"}

package/dist/queues/errors/index.js

@@ -0,0 +1,24 @@
+export class TaskError extends Error {
+    args;
+    constructor(args){
+        super(args.message);
+        this.args = args;
+    }
+}
+export class WorkflowError extends Error {
+    args;
+    constructor(args){
+        super(args.message);
+        this.args = args;
+    }
+}
+/**
+ * Throw this error from within a task or workflow handler to cancel the job.
+ * Unlike failing a job (e.g. by throwing any other error), a cancelled job will not be retried.
+ */ export class JobCancelledError extends Error {
+    constructor(message){
+        super(message);
+    }
+}
+
+//# sourceMappingURL=index.js.map

package/dist/queues/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/queues/errors/index.ts"],"sourcesContent":["import type { Job, SingleTaskStatus, WorkflowConfig } from '../../index.js'\nimport type { RetryConfig, TaskConfig } from '../config/types/taskTypes.js'\nimport type { TaskParent } from '../operations/runJobs/runJob/getRunTaskFunction.js'\n\nexport type TaskErrorArgs = {\n  executedAt: Date\n  input?: object\n  job: Job\n  message: string\n  output?: object\n  parent?: TaskParent\n  retriesConfig: RetryConfig\n  taskConfig?: TaskConfig<string>\n  taskID: string\n  taskSlug: string\n  taskStatus: null | SingleTaskStatus<string>\n  workflowConfig: WorkflowConfig\n}\n\nexport type WorkflowErrorArgs = {\n  job: Job\n  message: string\n  workflowConfig: WorkflowConfig\n}\n\nexport class TaskError extends Error {\n  args: TaskErrorArgs\n  constructor(args: TaskErrorArgs) {\n    super(args.message)\n    this.args = args\n  }\n}\nexport class WorkflowError extends Error {\n  args: WorkflowErrorArgs\n\n  constructor(args: WorkflowErrorArgs) {\n    super(args.message)\n    this.args = args\n  }\n}\n\n/**\n * Throw this error from within a task or workflow handler to cancel the job.\n * Unlike failing a job (e.g. by throwing any other error), a cancelled job will not be retried.\n */\nexport class JobCancelledError extends Error {\n  constructor(message: string) {\n    super(message)\n  }\n}\n"],"names":["TaskError","Error","args","message","WorkflowError","JobCancelledError"],"mappings":"AAyBA,OAAO,MAAMA,kBAAkBC;IAC7BC,KAAmB;IACnB,YAAYA,IAAmB,CAAE;QAC/B,KAAK,CAACA,KAAKC,OAAO;QAClB,IAAI,CAACD,IAAI,GAAGA;IACd;AACF;AACA,OAAO,MAAME,sBAAsBH;IACjCC,KAAuB;IAEvB,YAAYA,IAAuB,CAAE;QACnC,KAAK,CAACA,KAAKC,OAAO;QAClB,IAAI,CAACD,IAAI,GAAGA;IACd;AACF;AAEA;;;CAGC,GACD,OAAO,MAAMG,0BAA0BJ;IACrC,YAAYE,OAAe,CAAE;QAC3B,KAAK,CAACA;IACR;AACF"}