payload 3.0.0-beta.13 → 3.0.0-beta.131

package/dist/queues/operations/runJobs/runJob/calculateBackoffWaitUntil.js

@@ -0,0 +1,26 @@
+export function calculateBackoffWaitUntil({ retriesConfig, totalTried }) {
+    let waitUntil = new Date();
+    if (typeof retriesConfig === 'object') {
+        if (retriesConfig.backoff) {
+            if (retriesConfig.backoff.type === 'fixed') {
+                waitUntil = retriesConfig.backoff.delay ? new Date(new Date().getTime() + retriesConfig.backoff.delay) : new Date();
+            } 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(new Date().getTime() + Math.pow(2, totalTried) * delay);
+            }
+        }
+    }
+    /*
+  const differenceInMSBetweenNowAndWaitUntil = waitUntil.getTime() - new Date().getTime()
+
+  const differenceInSBetweenNowAndWaitUntil = differenceInMSBetweenNowAndWaitUntil / 1000
+  console.log('Calculated backoff', {
+    differenceInMSBetweenNowAndWaitUntil,
+    differenceInSBetweenNowAndWaitUntil,
+    retriesConfig,
+    totalTried,
+  })*/ return waitUntil;
+}
+
+//# sourceMappingURL=calculateBackoffWaitUntil.js.map

package/dist/queues/operations/runJobs/runJob/calculateBackoffWaitUntil.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/queues/operations/runJobs/runJob/calculateBackoffWaitUntil.ts"],"sourcesContent":["import type { RetryConfig } from '../../../config/types/taskTypes.js'\n\nexport function calculateBackoffWaitUntil({\n  retriesConfig,\n  totalTried,\n}: {\n  retriesConfig: number | RetryConfig\n  totalTried: number\n}): Date {\n  let waitUntil: Date = new Date()\n  if (typeof retriesConfig === 'object') {\n    if (retriesConfig.backoff) {\n      if (retriesConfig.backoff.type === 'fixed') {\n        waitUntil = retriesConfig.backoff.delay\n          ? new Date(new Date().getTime() + retriesConfig.backoff.delay)\n          : new Date()\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(new Date().getTime() + Math.pow(2, totalTried) * delay)\n      }\n    }\n  }\n\n  /*\n  const differenceInMSBetweenNowAndWaitUntil = waitUntil.getTime() - new Date().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":["calculateBackoffWaitUntil","retriesConfig","totalTried","waitUntil","Date","backoff","type","delay","getTime","Math","pow"],"mappings":"AAEA,OAAO,SAASA,0BAA0B,EACxCC,aAAa,EACbC,UAAU,EAIX;IACC,IAAIC,YAAkB,IAAIC;IAC1B,IAAI,OAAOH,kBAAkB,UAAU;QACrC,IAAIA,cAAcI,OAAO,EAAE;YACzB,IAAIJ,cAAcI,OAAO,CAACC,IAAI,KAAK,SAAS;gBAC1CH,YAAYF,cAAcI,OAAO,CAACE,KAAK,GACnC,IAAIH,KAAK,IAAIA,OAAOI,OAAO,KAAKP,cAAcI,OAAO,CAACE,KAAK,IAC3D,IAAIH;YACV,OAAO,IAAIH,cAAcI,OAAO,CAACC,IAAI,KAAK,eAAe;gBACvD,kGAAkG;gBAClG,MAAMC,QAAQN,cAAcI,OAAO,CAACE,KAAK,GAAGN,cAAcI,OAAO,CAACE,KAAK,GAAG;gBAC1EJ,YAAY,IAAIC,KAAK,IAAIA,OAAOI,OAAO,KAAKC,KAAKC,GAAG,CAAC,GAAGR,cAAcK;YACxE;QACF;IACF;IAEA;;;;;;;;;IASE,GACF,OAAOJ;AACT"}

package/dist/queues/operations/runJobs/runJob/getRunTaskFunction.d.ts

@@ -0,0 +1,26 @@
+import type { PayloadRequest } from '../../../../types/index.js';
+import type { RetryConfig, RunInlineTaskFunction, RunTaskFunctions, TaskConfig, TaskHandlerResult } from '../../../config/types/taskTypes.js';
+import type { BaseJob, SingleTaskStatus, WorkflowConfig } from '../../../config/types/workflowTypes.js';
+import type { UpdateJobFunction } from './getUpdateJobFunction.js';
+export type RunTaskFunctionState = {
+    reachedMaxRetries: boolean;
+};
+export declare function handleTaskFailed({ error, executedAt, input, job, maxRetries, output, req, retriesConfig, runnerOutput, state, taskConfig, taskID, taskSlug, taskStatus, updateJob, }: {
+    error?: Error;
+    executedAt: Date;
+    input: object;
+    job: BaseJob;
+    maxRetries: number;
+    output: object;
+    req: PayloadRequest;
+    retriesConfig: number | RetryConfig;
+    runnerOutput?: TaskHandlerResult<string>;
+    state: RunTaskFunctionState;
+    taskConfig?: TaskConfig<string>;
+    taskID: string;
+    taskSlug: string;
+    taskStatus: null | SingleTaskStatus<string>;
+    updateJob: UpdateJobFunction;
+}): Promise<never>;
+export declare const getRunTaskFunction: <TIsInline extends boolean>(state: RunTaskFunctionState, job: BaseJob, workflowConfig: WorkflowConfig<string>, req: PayloadRequest, isInline: TIsInline, updateJob: UpdateJobFunction) => TIsInline extends true ? RunInlineTaskFunction : RunTaskFunctions;
+//# sourceMappingURL=getRunTaskFunction.d.ts.map

package/dist/queues/operations/runJobs/runJob/getRunTaskFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRunTaskFunction.d.ts","sourceRoot":"","sources":["../../../../../src/queues/operations/runJobs/runJob/getRunTaskFunction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAChE,OAAO,KAAK,EACV,WAAW,EACX,qBAAqB,EAErB,gBAAgB,EAChB,UAAU,EAEV,iBAAiB,EAElB,MAAM,oCAAoC,CAAA;AAC3C,OAAO,KAAK,EACV,OAAO,EAEP,gBAAgB,EAChB,cAAc,EAEf,MAAM,wCAAwC,CAAA;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAMlE,MAAM,MAAM,oBAAoB,GAAG;IACjC,iBAAiB,EAAE,OAAO,CAAA;CAC3B,CAAA;AAaD,wBAAsB,gBAAgB,CAAC,EACrC,KAAK,EACL,UAAU,EACV,KAAK,EACL,GAAG,EACH,UAAU,EACV,MAAM,EACN,GAAG,EACH,aAAa,EACb,YAAY,EACZ,KAAK,EACL,UAAU,EACV,MAAM,EACN,QAAQ,EACR,UAAU,EACV,SAAS,GACV,EAAE;IACD,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,UAAU,EAAE,IAAI,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,OAAO,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,cAAc,CAAA;IACnB,aAAa,EAAE,MAAM,GAAG,WAAW,CAAA;IACnC,YAAY,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAA;IACxC,KAAK,EAAE,oBAAoB,CAAA;IAC3B,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,SAAS,EAAE,iBAAiB,CAAA;CAC7B,GAAG,OAAO,CAAC,KAAK,CAAC,CA+DjB;AAED,eAAO,MAAM,kBAAkB,GAAI,SAAS,SAAS,OAAO,SACnD,oBAAoB,OACtB,OAAO,kBACI,cAAc,CAAC,MAAM,CAAC,OACjC,cAAc,YACT,SAAS,aACR,iBAAiB,KAC3B,SAAS,SAAS,IAAI,GAAG,qBAAqB,GAAG,gBAqKnD,CAAA"}

package/dist/queues/operations/runJobs/runJob/getRunTaskFunction.js

@@ -0,0 +1,204 @@
+import { calculateBackoffWaitUntil } from './calculateBackoffWaitUntil.js';
+import { importHandlerPath } from './importHandlerPath.js';
+async function getTaskHandlerFromConfig(taskConfig) {
+    let handler;
+    if (typeof taskConfig.handler === 'function') {
+        handler = taskConfig.handler;
+    } else {
+        handler = await importHandlerPath(taskConfig.handler);
+    }
+    return handler;
+}
+export async function handleTaskFailed({ error, executedAt, input, job, maxRetries, output, req, retriesConfig, runnerOutput, state, taskConfig, taskID, taskSlug, taskStatus, updateJob }) {
+    req.payload.logger.error({
+        err: error,
+        job,
+        msg: 'Error running task',
+        taskSlug
+    });
+    if (taskConfig?.onFail) {
+        await taskConfig.onFail();
+    }
+    if (!job.log) {
+        job.log = [];
+    }
+    job.log.push({
+        completedAt: new Date().toISOString(),
+        error: error ?? runnerOutput.state,
+        executedAt: executedAt.toISOString(),
+        input,
+        output,
+        state: 'failed',
+        taskID,
+        taskSlug
+    });
+    if (job.waitUntil) {
+        // Check if waitUntil is in the past
+        const waitUntil = new Date(job.waitUntil);
+        if (waitUntil < new Date()) {
+            // Outdated waitUntil, remove it
+            delete job.waitUntil;
+        }
+    }
+    if (taskStatus && !taskStatus.complete && taskStatus.totalTried >= maxRetries) {
+        state.reachedMaxRetries = true;
+        await updateJob({
+            error,
+            hasError: true,
+            log: job.log,
+            processing: false,
+            waitUntil: job.waitUntil
+        });
+        throw new Error(`Task ${taskSlug} has failed more than the allowed retries in workflow ${job.workflowSlug}${error ? `. Error: ${String(error)}` : ''}`);
+    } else {
+        // Job will retry. Let's determine when!
+        const waitUntil = calculateBackoffWaitUntil({
+            retriesConfig,
+            totalTried: taskStatus?.totalTried ?? 0
+        });
+        // Update job's waitUntil only if this waitUntil is later than the current one
+        if (!job.waitUntil || waitUntil > new Date(job.waitUntil)) {
+            job.waitUntil = waitUntil.toISOString();
+        }
+        await updateJob({
+            log: job.log,
+            processing: false,
+            waitUntil: job.waitUntil
+        });
+        throw error ?? new Error('Task failed');
+    }
+}
+export const getRunTaskFunction = (state, job, workflowConfig, req, isInline, updateJob)=>{
+    const runTask = (taskSlug)=>async (taskID, { input, retries, task })=>{
+            const executedAt = new Date();
+            let inlineRunner = null;
+            if (isInline) {
+                inlineRunner = task;
+            }
+            let retriesConfig = retries;
+            let taskConfig;
+            if (!isInline) {
+                taskConfig = req.payload.config.jobs.tasks.find((t)=>t.slug === taskSlug);
+                if (!retriesConfig) {
+                    retriesConfig = taskConfig.retries;
+                }
+                if (!taskConfig) {
+                    throw new Error(`Task ${taskSlug} not found in workflow ${job.workflowSlug}`);
+                }
+            }
+            const maxRetries = typeof retriesConfig === 'object' ? retriesConfig?.attempts : retriesConfig;
+            const taskStatus = job?.taskStatus?.[taskSlug] ? job.taskStatus[taskSlug][taskID] : null;
+            if (taskStatus && taskStatus.complete === true) {
+                return taskStatus.output;
+            }
+            let runner;
+            if (isInline) {
+                runner = inlineRunner;
+            } else {
+                if (!taskConfig) {
+                    throw new Error(`Task ${taskSlug} not found in workflow ${job.workflowSlug}`);
+                }
+                runner = await getTaskHandlerFromConfig(taskConfig);
+            }
+            if (!runner || typeof runner !== 'function') {
+                const errorMessage = isInline ? `Can't find runner for inline task with ID ${taskID}` : `Can't find runner while importing with the path ${typeof workflowConfig.handler === 'string' ? workflowConfig.handler : 'unknown - no string path'} in job type ${job.workflowSlug} for task ${taskSlug}.`;
+                req.payload.logger.error(errorMessage);
+                await updateJob({
+                    error: {
+                        error: errorMessage
+                    },
+                    hasError: true,
+                    log: [
+                        ...job.log,
+                        {
+                            completedAt: new Date().toISOString(),
+                            error: errorMessage,
+                            executedAt: executedAt.toISOString(),
+                            state: 'failed',
+                            taskID,
+                            taskSlug
+                        }
+                    ],
+                    processing: false
+                });
+                return;
+            }
+            let output;
+            try {
+                const runnerOutput = await runner({
+                    input,
+                    job: job,
+                    req
+                });
+                if (runnerOutput.state === 'failed') {
+                    await handleTaskFailed({
+                        executedAt,
+                        input,
+                        job,
+                        maxRetries,
+                        output,
+                        req,
+                        retriesConfig,
+                        runnerOutput,
+                        state,
+                        taskConfig,
+                        taskID,
+                        taskSlug,
+                        taskStatus,
+                        updateJob
+                    });
+                    throw new Error('Task failed');
+                } else {
+                    output = runnerOutput.output;
+                }
+            } catch (err) {
+                await handleTaskFailed({
+                    error: err,
+                    executedAt,
+                    input,
+                    job,
+                    maxRetries,
+                    output,
+                    req,
+                    retriesConfig,
+                    state,
+                    taskConfig,
+                    taskID,
+                    taskSlug,
+                    taskStatus,
+                    updateJob
+                });
+                throw new Error('Task failed');
+            }
+            if (taskConfig?.onSuccess) {
+                await taskConfig.onSuccess();
+            }
+            if (!job.log) {
+                job.log = [];
+            }
+            job.log.push({
+                completedAt: new Date().toISOString(),
+                executedAt: executedAt.toISOString(),
+                input,
+                output,
+                state: 'succeeded',
+                taskID,
+                taskSlug
+            });
+            await updateJob({
+                log: job.log
+            });
+            return output;
+        };
+    if (isInline) {
+        return runTask('inline');
+    } else {
+        const tasks = {};
+        for (const task of req?.payload?.config?.jobs?.tasks ?? []){
+            tasks[task.slug] = runTask(task.slug);
+        }
+        return tasks;
+    }
+};
+
+//# sourceMappingURL=getRunTaskFunction.js.map

package/dist/queues/operations/runJobs/runJob/getRunTaskFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/queues/operations/runJobs/runJob/getRunTaskFunction.ts"],"sourcesContent":["import type { PayloadRequest } from '../../../../types/index.js'\nimport type {\n  RetryConfig,\n  RunInlineTaskFunction,\n  RunTaskFunction,\n  RunTaskFunctions,\n  TaskConfig,\n  TaskHandler,\n  TaskHandlerResult,\n  TaskType,\n} from '../../../config/types/taskTypes.js'\nimport type {\n  BaseJob,\n  RunningJob,\n  SingleTaskStatus,\n  WorkflowConfig,\n  WorkflowTypes,\n} from '../../../config/types/workflowTypes.js'\nimport type { UpdateJobFunction } from './getUpdateJobFunction.js'\n\nimport { calculateBackoffWaitUntil } from './calculateBackoffWaitUntil.js'\nimport { importHandlerPath } from './importHandlerPath.js'\n\n// Helper object type to force being passed by reference\nexport type RunTaskFunctionState = {\n  reachedMaxRetries: boolean\n}\n\nasync function getTaskHandlerFromConfig(taskConfig: TaskConfig<string>) {\n  let handler: TaskHandler<TaskType>\n\n  if (typeof taskConfig.handler === 'function') {\n    handler = taskConfig.handler\n  } else {\n    handler = await importHandlerPath<TaskHandler<TaskType>>(taskConfig.handler)\n  }\n  return handler\n}\n\nexport async function handleTaskFailed({\n  error,\n  executedAt,\n  input,\n  job,\n  maxRetries,\n  output,\n  req,\n  retriesConfig,\n  runnerOutput,\n  state,\n  taskConfig,\n  taskID,\n  taskSlug,\n  taskStatus,\n  updateJob,\n}: {\n  error?: Error\n  executedAt: Date\n  input: object\n  job: BaseJob\n  maxRetries: number\n  output: object\n  req: PayloadRequest\n  retriesConfig: number | RetryConfig\n  runnerOutput?: TaskHandlerResult<string>\n  state: RunTaskFunctionState\n  taskConfig?: TaskConfig<string>\n  taskID: string\n  taskSlug: string\n  taskStatus: null | SingleTaskStatus<string>\n  updateJob: UpdateJobFunction\n}): Promise<never> {\n  req.payload.logger.error({ err: error, job, msg: 'Error running task', taskSlug })\n\n  if (taskConfig?.onFail) {\n    await taskConfig.onFail()\n  }\n\n  if (!job.log) {\n    job.log = []\n  }\n  job.log.push({\n    completedAt: new Date().toISOString(),\n    error: error ?? runnerOutput.state,\n    executedAt: executedAt.toISOString(),\n    input,\n    output,\n    state: 'failed',\n    taskID,\n    taskSlug,\n  })\n\n  if (job.waitUntil) {\n    // Check if waitUntil is in the past\n    const waitUntil = new Date(job.waitUntil)\n    if (waitUntil < new Date()) {\n      // Outdated waitUntil, remove it\n      delete job.waitUntil\n    }\n  }\n\n  if (taskStatus && !taskStatus.complete && taskStatus.totalTried >= maxRetries) {\n    state.reachedMaxRetries = true\n\n    await updateJob({\n      error,\n      hasError: true,\n      log: job.log,\n      processing: false,\n      waitUntil: job.waitUntil,\n    })\n\n    throw new Error(\n      `Task ${taskSlug} has failed more than the allowed retries in workflow ${job.workflowSlug}${error ? `. Error: ${String(error)}` : ''}`,\n    )\n  } else {\n    // Job will retry. Let's determine when!\n    const waitUntil: 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 || waitUntil > new Date(job.waitUntil)) {\n      job.waitUntil = waitUntil.toISOString()\n    }\n\n    await updateJob({\n      log: job.log,\n      processing: false,\n      waitUntil: job.waitUntil,\n    })\n    throw error ?? new Error('Task failed')\n  }\n}\n\nexport const getRunTaskFunction = <TIsInline extends boolean>(\n  state: RunTaskFunctionState,\n  job: BaseJob,\n  workflowConfig: WorkflowConfig<string>,\n  req: PayloadRequest,\n  isInline: TIsInline,\n  updateJob: UpdateJobFunction,\n): TIsInline extends true ? RunInlineTaskFunction : RunTaskFunctions => {\n  const runTask: <TTaskSlug extends string>(\n    taskSlug: TTaskSlug,\n  ) => TTaskSlug extends 'inline' ? RunInlineTaskFunction : RunTaskFunction<TTaskSlug> = (\n    taskSlug,\n  ) =>\n    (async (\n      taskID: Parameters<RunInlineTaskFunction>[0],\n      {\n        input,\n        retries,\n        task,\n      }: Parameters<RunInlineTaskFunction>[1] & Parameters<RunTaskFunction<string>>[1],\n    ) => {\n      const executedAt = new Date()\n\n      let inlineRunner: TaskHandler<TaskType> = null\n      if (isInline) {\n        inlineRunner = task\n      }\n\n      let retriesConfig: number | RetryConfig = retries\n      let taskConfig: TaskConfig<string>\n      if (!isInline) {\n        taskConfig = req.payload.config.jobs.tasks.find((t) => t.slug === taskSlug)\n        if (!retriesConfig) {\n          retriesConfig = taskConfig.retries\n        }\n\n        if (!taskConfig) {\n          throw new Error(`Task ${taskSlug} not found in workflow ${job.workflowSlug}`)\n        }\n      }\n      const maxRetries: number =\n        typeof retriesConfig === 'object' ? retriesConfig?.attempts : retriesConfig\n\n      const taskStatus: null | SingleTaskStatus<string> = job?.taskStatus?.[taskSlug]\n        ? job.taskStatus[taskSlug][taskID]\n        : null\n\n      if (taskStatus && taskStatus.complete === true) {\n        return taskStatus.output\n      }\n\n      let runner: TaskHandler<TaskType>\n      if (isInline) {\n        runner = inlineRunner\n      } else {\n        if (!taskConfig) {\n          throw new Error(`Task ${taskSlug} not found in workflow ${job.workflowSlug}`)\n        }\n        runner = await getTaskHandlerFromConfig(taskConfig)\n      }\n\n      if (!runner || typeof runner !== 'function') {\n        const errorMessage = isInline\n          ? `Can't find runner for inline task with ID ${taskID}`\n          : `Can't find runner while importing with the path ${typeof workflowConfig.handler === 'string' ? workflowConfig.handler : 'unknown - no string path'} in job type ${job.workflowSlug} for task ${taskSlug}.`\n        req.payload.logger.error(errorMessage)\n\n        await updateJob({\n          error: {\n            error: errorMessage,\n          },\n          hasError: true,\n          log: [\n            ...job.log,\n            {\n              completedAt: new Date().toISOString(),\n              error: errorMessage,\n              executedAt: executedAt.toISOString(),\n              state: 'failed',\n              taskID,\n              taskSlug,\n            },\n          ],\n          processing: false,\n        })\n\n        return\n      }\n\n      let output: object\n\n      try {\n        const runnerOutput = await runner({\n          input,\n          job: job as unknown as RunningJob<WorkflowTypes>, // TODO: Type this better\n          req,\n        })\n\n        if (runnerOutput.state === 'failed') {\n          await handleTaskFailed({\n            executedAt,\n            input,\n            job,\n            maxRetries,\n            output,\n            req,\n            retriesConfig,\n            runnerOutput,\n            state,\n            taskConfig,\n            taskID,\n            taskSlug,\n            taskStatus,\n            updateJob,\n          })\n          throw new Error('Task failed')\n        } else {\n          output = runnerOutput.output\n        }\n      } catch (err) {\n        await handleTaskFailed({\n          error: err,\n          executedAt,\n          input,\n          job,\n          maxRetries,\n          output,\n          req,\n          retriesConfig,\n          state,\n          taskConfig,\n          taskID,\n          taskSlug,\n          taskStatus,\n          updateJob,\n        })\n        throw new Error('Task failed')\n      }\n\n      if (taskConfig?.onSuccess) {\n        await taskConfig.onSuccess()\n      }\n\n      if (!job.log) {\n        job.log = []\n      }\n      job.log.push({\n        completedAt: new Date().toISOString(),\n        executedAt: executedAt.toISOString(),\n        input,\n        output,\n        state: 'succeeded',\n        taskID,\n        taskSlug,\n      })\n\n      await updateJob({\n        log: job.log,\n      })\n\n      return output\n    }) as any\n\n  if (isInline) {\n    return runTask('inline') as TIsInline extends true ? RunInlineTaskFunction : RunTaskFunctions\n  } else {\n    const tasks: RunTaskFunctions = {}\n    for (const task of req?.payload?.config?.jobs?.tasks ?? []) {\n      tasks[task.slug] = runTask(task.slug)\n    }\n    return tasks as TIsInline extends true ? RunInlineTaskFunction : RunTaskFunctions\n  }\n}\n"],"names":["calculateBackoffWaitUntil","importHandlerPath","getTaskHandlerFromConfig","taskConfig","handler","handleTaskFailed","error","executedAt","input","job","maxRetries","output","req","retriesConfig","runnerOutput","state","taskID","taskSlug","taskStatus","updateJob","payload","logger","err","msg","onFail","log","push","completedAt","Date","toISOString","waitUntil","complete","totalTried","reachedMaxRetries","hasError","processing","Error","workflowSlug","String","getRunTaskFunction","workflowConfig","isInline","runTask","retries","task","inlineRunner","config","jobs","tasks","find","t","slug","attempts","runner","errorMessage","onSuccess"],"mappings":"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"}

package/dist/queues/operations/runJobs/runJob/getUpdateJobFunction.d.ts

@@ -0,0 +1,5 @@
+import type { PayloadRequest } from '../../../../types/index.js';
+import type { BaseJob } from '../../../config/types/workflowTypes.js';
+export type UpdateJobFunction = (jobData: Partial<BaseJob>) => Promise<BaseJob>;
+export declare function getUpdateJobFunction(job: BaseJob, req: PayloadRequest): UpdateJobFunction;
+//# sourceMappingURL=getUpdateJobFunction.d.ts.map

package/dist/queues/operations/runJobs/runJob/getUpdateJobFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getUpdateJobFunction.d.ts","sourceRoot":"","sources":["../../../../../src/queues/operations/runJobs/runJob/getUpdateJobFunction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wCAAwC,CAAA;AAErE,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE/E,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,GAAG,iBAAiB,CAiBzF"}

package/dist/queues/operations/runJobs/runJob/getUpdateJobFunction.js

@@ -0,0 +1,18 @@
+export function getUpdateJobFunction(job, req) {
+    return async (jobData)=>{
+        const updatedJob = await req.payload.update({
+            id: job.id,
+            collection: 'payload-jobs',
+            data: jobData,
+            depth: 0,
+            disableTransaction: true
+        });
+        // Update job object like this to modify the original object - that way, incoming changes (e.g. taskStatus field that will be re-generated through the hook) will be reflected in the calling function
+        for(const key in updatedJob){
+            job[key] = updatedJob[key];
+        }
+        return updatedJob;
+    };
+}
+
+//# sourceMappingURL=getUpdateJobFunction.js.map

package/dist/queues/operations/runJobs/runJob/getUpdateJobFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/queues/operations/runJobs/runJob/getUpdateJobFunction.ts"],"sourcesContent":["import type { PayloadRequest } from '../../../../types/index.js'\nimport type { BaseJob } from '../../../config/types/workflowTypes.js'\n\nexport type UpdateJobFunction = (jobData: Partial<BaseJob>) => Promise<BaseJob>\n\nexport function getUpdateJobFunction(job: BaseJob, req: PayloadRequest): UpdateJobFunction {\n  return async (jobData) => {\n    const updatedJob = (await req.payload.update({\n      id: job.id,\n      collection: 'payload-jobs',\n      data: jobData,\n      depth: 0,\n      disableTransaction: true,\n    })) as BaseJob\n\n    // Update job object like this to modify the original object - that way, incoming changes (e.g. taskStatus field that will be re-generated through the hook) will be reflected in the calling function\n    for (const key in updatedJob) {\n      job[key] = updatedJob[key]\n    }\n\n    return updatedJob\n  }\n}\n"],"names":["getUpdateJobFunction","job","req","jobData","updatedJob","payload","update","id","collection","data","depth","disableTransaction","key"],"mappings":"AAKA,OAAO,SAASA,qBAAqBC,GAAY,EAAEC,GAAmB;IACpE,OAAO,OAAOC;QACZ,MAAMC,aAAc,MAAMF,IAAIG,OAAO,CAACC,MAAM,CAAC;YAC3CC,IAAIN,IAAIM,EAAE;YACVC,YAAY;YACZC,MAAMN;YACNO,OAAO;YACPC,oBAAoB;QACtB;QAEA,sMAAsM;QACtM,IAAK,MAAMC,OAAOR,WAAY;YAC5BH,GAAG,CAACW,IAAI,GAAGR,UAAU,CAACQ,IAAI;QAC5B;QAEA,OAAOR;IACT;AACF"}

package/dist/queues/operations/runJobs/runJob/handleWorkflowError.d.ts

@@ -0,0 +1,17 @@
+import type { PayloadRequest } from '../../../../types/index.js';
+import type { BaseJob, WorkflowConfig, WorkflowTypes } from '../../../config/types/workflowTypes.js';
+import type { RunTaskFunctionState } from './getRunTaskFunction.js';
+/**
+ * This is called if a workflow catches an error. It determines if it's a final error
+ * or not and handles logging.
+ */
+export declare function handleWorkflowError({ error, job, req, state, workflowConfig, }: {
+    error: Error;
+    job: BaseJob;
+    req: PayloadRequest;
+    state: RunTaskFunctionState;
+    workflowConfig: WorkflowConfig<WorkflowTypes>;
+}): {
+    hasFinalError: boolean;
+};
+//# sourceMappingURL=handleWorkflowError.d.ts.map

package/dist/queues/operations/runJobs/runJob/handleWorkflowError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleWorkflowError.d.ts","sourceRoot":"","sources":["../../../../../src/queues/operations/runJobs/runJob/handleWorkflowError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAA;AACpG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAInE;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,KAAK,EACL,GAAG,EACH,GAAG,EACH,KAAK,EACL,cAAc,GACf,EAAE;IACD,KAAK,EAAE,KAAK,CAAA;IACZ,GAAG,EAAE,OAAO,CAAA;IACZ,GAAG,EAAE,cAAc,CAAA;IACnB,KAAK,EAAE,oBAAoB,CAAA;IAC3B,cAAc,EAAE,cAAc,CAAC,aAAa,CAAC,CAAA;CAC9C,GAAG;IACF,aAAa,EAAE,OAAO,CAAA;CACvB,CAyCA"}

package/dist/queues/operations/runJobs/runJob/handleWorkflowError.js

@@ -0,0 +1,43 @@
+import { calculateBackoffWaitUntil } from './calculateBackoffWaitUntil.js';
+/**
+ * This is called if a workflow catches an error. It determines if it's a final error
+ * or not and handles logging.
+ */ export function handleWorkflowError({ error, job, req, state, workflowConfig }) {
+    let hasFinalError = state.reachedMaxRetries // If any TASK reached max retries, the job has an error
+    ;
+    const maxRetries = typeof workflowConfig.retries === 'object' ? workflowConfig.retries.attempts : workflowConfig.retries;
+    // Now let's handle workflow retries
+    if (!hasFinalError && workflowConfig.retries) {
+        if (job.waitUntil) {
+            // Check if waitUntil is in the past
+            const waitUntil = new Date(job.waitUntil);
+            if (waitUntil < new Date()) {
+                // Outdated waitUntil, remove it
+                delete job.waitUntil;
+            }
+        }
+        if (job.totalTried >= maxRetries) {
+            state.reachedMaxRetries = true;
+            hasFinalError = true;
+        } else {
+            // Job will retry. Let's determine when!
+            const waitUntil = calculateBackoffWaitUntil({
+                retriesConfig: workflowConfig.retries,
+                totalTried: job.totalTried ?? 0
+            });
+            // Update job's waitUntil only if this waitUntil is later than the current one
+            if (!job.waitUntil || waitUntil > new Date(job.waitUntil)) {
+                job.waitUntil = waitUntil.toISOString();
+            }
+        }
+    }
+    req.payload.logger.error({
+        err: error,
+        msg: `Error running job ${job.workflowSlug} ${job.taskSlug} id: ${job.id} attempt ${job.totalTried}/${maxRetries}`
+    });
+    return {
+        hasFinalError
+    };
+}
+
+//# sourceMappingURL=handleWorkflowError.js.map

package/dist/queues/operations/runJobs/runJob/handleWorkflowError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/queues/operations/runJobs/runJob/handleWorkflowError.ts"],"sourcesContent":["import type { PayloadRequest } from '../../../../types/index.js'\nimport type { BaseJob, WorkflowConfig, WorkflowTypes } from '../../../config/types/workflowTypes.js'\nimport type { RunTaskFunctionState } from './getRunTaskFunction.js'\n\nimport { calculateBackoffWaitUntil } from './calculateBackoffWaitUntil.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 */\nexport function handleWorkflowError({\n  error,\n  job,\n  req,\n  state,\n  workflowConfig,\n}: {\n  error: Error\n  job: BaseJob\n  req: PayloadRequest\n  state: RunTaskFunctionState\n  workflowConfig: WorkflowConfig<WorkflowTypes>\n}): {\n  hasFinalError: boolean\n} {\n  let hasFinalError = state.reachedMaxRetries // If any TASK reached max retries, the job has an error\n  const maxRetries =\n    typeof workflowConfig.retries === 'object'\n      ? workflowConfig.retries.attempts\n      : workflowConfig.retries\n  // Now let's handle workflow retries\n  if (!hasFinalError && workflowConfig.retries) {\n    if (job.waitUntil) {\n      // Check if waitUntil is in the past\n      const waitUntil = new Date(job.waitUntil)\n      if (waitUntil < new Date()) {\n        // Outdated waitUntil, remove it\n        delete job.waitUntil\n      }\n    }\n    if (job.totalTried >= maxRetries) {\n      state.reachedMaxRetries = true\n      hasFinalError = true\n    } else {\n      // Job will retry. Let's determine when!\n      const waitUntil: Date = calculateBackoffWaitUntil({\n        retriesConfig: workflowConfig.retries,\n        totalTried: job.totalTried ?? 0,\n      })\n\n      // Update job's waitUntil only if this waitUntil is later than the current one\n      if (!job.waitUntil || waitUntil > new Date(job.waitUntil)) {\n        job.waitUntil = waitUntil.toISOString()\n      }\n    }\n  }\n\n  req.payload.logger.error({\n    err: error,\n    msg: `Error running job ${job.workflowSlug} ${job.taskSlug} id: ${job.id} attempt ${job.totalTried}/${maxRetries}`,\n  })\n\n  return {\n    hasFinalError,\n  }\n}\n"],"names":["calculateBackoffWaitUntil","handleWorkflowError","error","job","req","state","workflowConfig","hasFinalError","reachedMaxRetries","maxRetries","retries","attempts","waitUntil","Date","totalTried","retriesConfig","toISOString","payload","logger","err","msg","workflowSlug","taskSlug","id"],"mappings":"AAIA,SAASA,yBAAyB,QAAQ,iCAAgC;AAE1E;;;CAGC,GACD,OAAO,SAASC,oBAAoB,EAClCC,KAAK,EACLC,GAAG,EACHC,GAAG,EACHC,KAAK,EACLC,cAAc,EAOf;IAGC,IAAIC,gBAAgBF,MAAMG,iBAAiB,CAAC,wDAAwD;;IACpG,MAAMC,aACJ,OAAOH,eAAeI,OAAO,KAAK,WAC9BJ,eAAeI,OAAO,CAACC,QAAQ,GAC/BL,eAAeI,OAAO;IAC5B,oCAAoC;IACpC,IAAI,CAACH,iBAAiBD,eAAeI,OAAO,EAAE;QAC5C,IAAIP,IAAIS,SAAS,EAAE;YACjB,oCAAoC;YACpC,MAAMA,YAAY,IAAIC,KAAKV,IAAIS,SAAS;YACxC,IAAIA,YAAY,IAAIC,QAAQ;gBAC1B,gCAAgC;gBAChC,OAAOV,IAAIS,SAAS;YACtB;QACF;QACA,IAAIT,IAAIW,UAAU,IAAIL,YAAY;YAChCJ,MAAMG,iBAAiB,GAAG;YAC1BD,gBAAgB;QAClB,OAAO;YACL,wCAAwC;YACxC,MAAMK,YAAkBZ,0BAA0B;gBAChDe,eAAeT,eAAeI,OAAO;gBACrCI,YAAYX,IAAIW,UAAU,IAAI;YAChC;YAEA,8EAA8E;YAC9E,IAAI,CAACX,IAAIS,SAAS,IAAIA,YAAY,IAAIC,KAAKV,IAAIS,SAAS,GAAG;gBACzDT,IAAIS,SAAS,GAAGA,UAAUI,WAAW;YACvC;QACF;IACF;IAEAZ,IAAIa,OAAO,CAACC,MAAM,CAAChB,KAAK,CAAC;QACvBiB,KAAKjB;QACLkB,KAAK,CAAC,kBAAkB,EAAEjB,IAAIkB,YAAY,CAAC,CAAC,EAAElB,IAAImB,QAAQ,CAAC,KAAK,EAAEnB,IAAIoB,EAAE,CAAC,SAAS,EAAEpB,IAAIW,UAAU,CAAC,CAAC,EAAEL,WAAW,CAAC;IACpH;IAEA,OAAO;QACLF;IACF;AACF"}

package/dist/queues/operations/runJobs/runJob/importHandlerPath.d.ts

@@ -0,0 +1,2 @@
+export declare function importHandlerPath<T>(path: string): Promise<T>;
+//# sourceMappingURL=importHandlerPath.d.ts.map

package/dist/queues/operations/runJobs/runJob/importHandlerPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"importHandlerPath.d.ts","sourceRoot":"","sources":["../../../../../src/queues/operations/runJobs/runJob/importHandlerPath.ts"],"names":[],"mappings":"AAEA,wBAAsB,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAyBnE"}

package/dist/queues/operations/runJobs/runJob/importHandlerPath.js

@@ -0,0 +1,21 @@
+import { pathToFileURL } from 'url';
+export async function importHandlerPath(path) {
+    let runner;
+    const [runnerPath, runnerImportName] = path.split('#');
+    const runnerModule = typeof require === 'function' ? await eval(`require('${runnerPath.replaceAll('\\', '/')}')`) : await eval(`import('${pathToFileURL(runnerPath).href}')`);
+    // If the path has indicated an #exportName, try to get it
+    if (runnerImportName && runnerModule[runnerImportName]) {
+        runner = runnerModule[runnerImportName];
+    }
+    // If there is a default export, use it
+    if (!runner && runnerModule.default) {
+        runner = runnerModule.default;
+    }
+    // Finally, use whatever was imported
+    if (!runner) {
+        runner = runnerModule;
+    }
+    return runner;
+}
+
+//# sourceMappingURL=importHandlerPath.js.map

package/dist/queues/operations/runJobs/runJob/importHandlerPath.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/queues/operations/runJobs/runJob/importHandlerPath.ts"],"sourcesContent":["import { pathToFileURL } from 'url'\n\nexport async function importHandlerPath<T>(path: string): Promise<T> {\n  let runner: T\n  const [runnerPath, runnerImportName] = path.split('#')\n\n  const runnerModule =\n    typeof require === 'function'\n      ? await eval(`require('${runnerPath.replaceAll('\\\\', '/')}')`)\n      : await eval(`import('${pathToFileURL(runnerPath).href}')`)\n\n  // If the path has indicated an #exportName, try to get it\n  if (runnerImportName && runnerModule[runnerImportName]) {\n    runner = runnerModule[runnerImportName]\n  }\n\n  // If there is a default export, use it\n  if (!runner && runnerModule.default) {\n    runner = runnerModule.default\n  }\n\n  // Finally, use whatever was imported\n  if (!runner) {\n    runner = runnerModule\n  }\n\n  return runner\n}\n"],"names":["pathToFileURL","importHandlerPath","path","runner","runnerPath","runnerImportName","split","runnerModule","require","eval","replaceAll","href","default"],"mappings":"AAAA,SAASA,aAAa,QAAQ,MAAK;AAEnC,OAAO,eAAeC,kBAAqBC,IAAY;IACrD,IAAIC;IACJ,MAAM,CAACC,YAAYC,iBAAiB,GAAGH,KAAKI,KAAK,CAAC;IAElD,MAAMC,eACJ,OAAOC,YAAY,aACf,MAAMC,KAAK,CAAC,SAAS,EAAEL,WAAWM,UAAU,CAAC,MAAM,KAAK,EAAE,CAAC,IAC3D,MAAMD,KAAK,CAAC,QAAQ,EAAET,cAAcI,YAAYO,IAAI,CAAC,EAAE,CAAC;IAE9D,0DAA0D;IAC1D,IAAIN,oBAAoBE,YAAY,CAACF,iBAAiB,EAAE;QACtDF,SAASI,YAAY,CAACF,iBAAiB;IACzC;IAEA,uCAAuC;IACvC,IAAI,CAACF,UAAUI,aAAaK,OAAO,EAAE;QACnCT,SAASI,aAAaK,OAAO;IAC/B;IAEA,qCAAqC;IACrC,IAAI,CAACT,QAAQ;QACXA,SAASI;IACX;IAEA,OAAOJ;AACT"}

package/dist/queues/operations/runJobs/runJob/index.d.ts

@@ -0,0 +1,17 @@
+import type { PayloadRequest } from '../../../../types/index.js';
+import type { BaseJob, WorkflowConfig, WorkflowHandler, WorkflowTypes } from '../../../config/types/workflowTypes.js';
+import type { UpdateJobFunction } from './getUpdateJobFunction.js';
+type Args = {
+    job: BaseJob;
+    req: PayloadRequest;
+    updateJob: UpdateJobFunction;
+    workflowConfig: WorkflowConfig<WorkflowTypes>;
+    workflowHandler: WorkflowHandler<WorkflowTypes>;
+};
+export type JobRunStatus = 'error' | 'error-reached-max-retries' | 'success';
+export type RunJobResult = {
+    status: JobRunStatus;
+};
+export declare const runJob: ({ job, req, updateJob, workflowConfig, workflowHandler, }: Args) => Promise<RunJobResult>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/queues/operations/runJobs/runJob/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/queues/operations/runJobs/runJob/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAChE,OAAO,KAAK,EACV,OAAO,EAEP,cAAc,EACd,eAAe,EACf,aAAa,EACd,MAAM,wCAAwC,CAAA;AAE/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAKlE,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,OAAO,CAAA;IACZ,GAAG,EAAE,cAAc,CAAA;IACnB,SAAS,EAAE,iBAAiB,CAAA;IAC5B,cAAc,EAAE,cAAc,CAAC,aAAa,CAAC,CAAA;IAC7C,eAAe,EAAE,eAAe,CAAC,aAAa,CAAC,CAAA;CAChD,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,2BAA2B,GAAG,SAAS,CAAA;AAE5E,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,YAAY,CAAA;CACrB,CAAA;AAED,eAAO,MAAM,MAAM,8DAMhB,IAAI,KAAG,OAAO,CAAC,YAAY,CAgD7B,CAAA"}

package/dist/queues/operations/runJobs/runJob/index.js

@@ -0,0 +1,48 @@
+import { getRunTaskFunction } from './getRunTaskFunction.js';
+import { handleWorkflowError } from './handleWorkflowError.js';
+export const runJob = async ({ job, req, updateJob, workflowConfig, workflowHandler })=>{
+    // Object so that we can pass contents by reference, not value.
+    // We want any mutations to be reflected in here.
+    const state = {
+        reachedMaxRetries: false
+    };
+    // Run the job
+    try {
+        await workflowHandler({
+            inlineTask: getRunTaskFunction(state, job, workflowConfig, req, true, updateJob),
+            job: job,
+            req,
+            tasks: getRunTaskFunction(state, job, workflowConfig, req, false, updateJob)
+        });
+    } catch (err) {
+        const { hasFinalError } = handleWorkflowError({
+            error: err,
+            job,
+            req,
+            state,
+            workflowConfig
+        });
+        // 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 ? err : undefined,
+            hasError: hasFinalError,
+            processing: false,
+            totalTried: (job.totalTried ?? 0) + 1
+        });
+        return {
+            status: hasFinalError ? 'error-reached-max-retries' : 'error'
+        };
+    }
+    // Workflow has completed
+    await updateJob({
+        completedAt: new Date().toISOString(),
+        processing: false,
+        totalTried: (job.totalTried ?? 0) + 1
+    });
+    return {
+        status: 'success'
+    };
+};
+
+//# sourceMappingURL=index.js.map

package/dist/queues/operations/runJobs/runJob/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/queues/operations/runJobs/runJob/index.ts"],"sourcesContent":["import type { PayloadRequest } from '../../../../types/index.js'\nimport type {\n  BaseJob,\n  RunningJob,\n  WorkflowConfig,\n  WorkflowHandler,\n  WorkflowTypes,\n} from '../../../config/types/workflowTypes.js'\nimport type { RunTaskFunctionState } from './getRunTaskFunction.js'\nimport type { UpdateJobFunction } from './getUpdateJobFunction.js'\n\nimport { getRunTaskFunction } from './getRunTaskFunction.js'\nimport { handleWorkflowError } from './handleWorkflowError.js'\n\ntype Args = {\n  job: BaseJob\n  req: PayloadRequest\n  updateJob: UpdateJobFunction\n  workflowConfig: WorkflowConfig<WorkflowTypes>\n  workflowHandler: WorkflowHandler<WorkflowTypes>\n}\n\nexport type JobRunStatus = 'error' | 'error-reached-max-retries' | 'success'\n\nexport type RunJobResult = {\n  status: JobRunStatus\n}\n\nexport const runJob = async ({\n  job,\n  req,\n  updateJob,\n  workflowConfig,\n  workflowHandler,\n}: Args): Promise<RunJobResult> => {\n  // Object so that we can pass contents by reference, not value.\n  // We want any mutations to be reflected in here.\n  const state: RunTaskFunctionState = {\n    reachedMaxRetries: false,\n  }\n\n  // Run the job\n  try {\n    await workflowHandler({\n      inlineTask: getRunTaskFunction(state, job, workflowConfig, req, true, updateJob),\n      job: job as unknown as RunningJob<WorkflowTypes>, //TODO: Type this better\n      req,\n      tasks: getRunTaskFunction(state, job, workflowConfig, req, false, updateJob),\n    })\n  } catch (err) {\n    const { hasFinalError } = handleWorkflowError({\n      error: err,\n      job,\n      req,\n      state,\n      workflowConfig,\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 ? err : undefined,\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    })\n\n    return {\n      status: hasFinalError ? 'error-reached-max-retries' : 'error',\n    }\n  }\n\n  // Workflow has completed\n  await updateJob({\n    completedAt: new Date().toISOString(),\n    processing: false,\n    totalTried: (job.totalTried ?? 0) + 1,\n  })\n\n  return {\n    status: 'success',\n  }\n}\n"],"names":["getRunTaskFunction","handleWorkflowError","runJob","job","req","updateJob","workflowConfig","workflowHandler","state","reachedMaxRetries","inlineTask","tasks","err","hasFinalError","error","undefined","hasError","processing","totalTried","status","completedAt","Date","toISOString"],"mappings":"AAWA,SAASA,kBAAkB,QAAQ,0BAAyB;AAC5D,SAASC,mBAAmB,QAAQ,2BAA0B;AAgB9D,OAAO,MAAMC,SAAS,OAAO,EAC3BC,GAAG,EACHC,GAAG,EACHC,SAAS,EACTC,cAAc,EACdC,eAAe,EACV;IACL,+DAA+D;IAC/D,iDAAiD;IACjD,MAAMC,QAA8B;QAClCC,mBAAmB;IACrB;IAEA,cAAc;IACd,IAAI;QACF,MAAMF,gBAAgB;YACpBG,YAAYV,mBAAmBQ,OAAOL,KAAKG,gBAAgBF,KAAK,MAAMC;YACtEF,KAAKA;YACLC;YACAO,OAAOX,mBAAmBQ,OAAOL,KAAKG,gBAAgBF,KAAK,OAAOC;QACpE;IACF,EAAE,OAAOO,KAAK;QACZ,MAAM,EAAEC,aAAa,EAAE,GAAGZ,oBAAoB;YAC5Ca,OAAOF;YACPT;YACAC;YACAI;YACAF;QACF;QAEA,4HAA4H;QAC5H,4DAA4D;QAC5D,MAAMD,UAAU;YACdS,OAAOD,gBAAgBD,MAAMG;YAC7BC,UAAUH;YACVI,YAAY;YACZC,YAAY,AAACf,CAAAA,IAAIe,UAAU,IAAI,CAAA,IAAK;QACtC;QAEA,OAAO;YACLC,QAAQN,gBAAgB,8BAA8B;QACxD;IACF;IAEA,yBAAyB;IACzB,MAAMR,UAAU;QACde,aAAa,IAAIC,OAAOC,WAAW;QACnCL,YAAY;QACZC,YAAY,AAACf,CAAAA,IAAIe,UAAU,IAAI,CAAA,IAAK;IACtC;IAEA,OAAO;QACLC,QAAQ;IACV;AACF,EAAC"}

package/dist/queues/restEndpointRun.d.ts

@@ -0,0 +1,3 @@
+import type { Endpoint } from '../config/types.js';
+export declare const runJobsEndpoint: Endpoint;
+//# sourceMappingURL=restEndpointRun.d.ts.map

package/dist/queues/restEndpointRun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restEndpointRun.d.ts","sourceRoot":"","sources":["../../src/queues/restEndpointRun.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAIlD,eAAO,MAAM,eAAe,EAAE,QA4E7B,CAAA"}

package/dist/queues/restEndpointRun.js

@@ -0,0 +1,66 @@
+import { runJobs } from './operations/runJobs/index.js';
+export const runJobsEndpoint = {
+    handler: async (req)=>{
+        if (!Array.isArray(req.payload.config.jobs.workflows) || !(req.payload.config.jobs?.workflows?.length > 0)) {
+            return Response.json({
+                message: 'No jobs to run.'
+            }, {
+                status: 200
+            });
+        }
+        const hasAccess = await req.payload.config.jobs.access.run({
+            req
+        });
+        if (!hasAccess) {
+            return Response.json({
+                message: req.i18n.t('error:unauthorized')
+            }, {
+                status: 401
+            });
+        }
+        const { limit, queue } = req.query;
+        const runJobsArgs = {
+            queue: 'default',
+            req,
+            // We are checking access above, so we can override it here
+            overrideAccess: true
+        };
+        if (typeof queue === 'string') {
+            runJobsArgs.queue = queue;
+        }
+        if (typeof limit !== 'undefined') {
+            runJobsArgs.limit = Number(limit);
+        }
+        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'
+};
+
+//# sourceMappingURL=restEndpointRun.js.map

package/dist/queues/restEndpointRun.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/queues/restEndpointRun.ts"],"sourcesContent":["import type { Endpoint } from '../config/types.js'\n\nimport { runJobs, type RunJobsArgs } from './operations/runJobs/index.js'\n\nexport const runJobsEndpoint: Endpoint = {\n  handler: async (req) => {\n    if (\n      !Array.isArray(req.payload.config.jobs.workflows) ||\n      !(req.payload.config.jobs?.workflows?.length > 0)\n    ) {\n      return Response.json(\n        {\n          message: 'No jobs to run.',\n        },\n        { status: 200 },\n      )\n    }\n\n    const hasAccess = await req.payload.config.jobs.access.run({ 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 { limit, queue } = req.query\n\n    const runJobsArgs: RunJobsArgs = {\n      queue: 'default',\n      req,\n      // We are checking access above, so we can override it here\n      overrideAccess: true,\n    }\n\n    if (typeof queue === 'string') {\n      runJobsArgs.queue = queue\n    }\n\n    if (typeof limit !== 'undefined') {\n      runJobsArgs.limit = Number(limit)\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"],"names":["runJobs","runJobsEndpoint","handler","req","Array","isArray","payload","config","jobs","workflows","length","Response","json","message","status","hasAccess","access","run","i18n","t","limit","queue","query","runJobsArgs","overrideAccess","Number","noJobsRemaining","remainingJobsFromQueried","result","err","logger","error","msg","method","path"],"mappings":"AAEA,SAASA,OAAO,QAA0B,gCAA+B;AAEzE,OAAO,MAAMC,kBAA4B;IACvCC,SAAS,OAAOC;QACd,IACE,CAACC,MAAMC,OAAO,CAACF,IAAIG,OAAO,CAACC,MAAM,CAACC,IAAI,CAACC,SAAS,KAChD,CAAEN,CAAAA,IAAIG,OAAO,CAACC,MAAM,CAACC,IAAI,EAAEC,WAAWC,SAAS,CAAA,GAC/C;YACA,OAAOC,SAASC,IAAI,CAClB;gBACEC,SAAS;YACX,GACA;gBAAEC,QAAQ;YAAI;QAElB;QAEA,MAAMC,YAAY,MAAMZ,IAAIG,OAAO,CAACC,MAAM,CAACC,IAAI,CAACQ,MAAM,CAACC,GAAG,CAAC;YAAEd;QAAI;QAEjE,IAAI,CAACY,WAAW;YACd,OAAOJ,SAASC,IAAI,CAClB;gBACEC,SAASV,IAAIe,IAAI,CAACC,CAAC,CAAC;YACtB,GACA;gBAAEL,QAAQ;YAAI;QAElB;QAEA,MAAM,EAAEM,KAAK,EAAEC,KAAK,EAAE,GAAGlB,IAAImB,KAAK;QAElC,MAAMC,cAA2B;YAC/BF,OAAO;YACPlB;YACA,2DAA2D;YAC3DqB,gBAAgB;QAClB;QAEA,IAAI,OAAOH,UAAU,UAAU;YAC7BE,YAAYF,KAAK,GAAGA;QACtB;QAEA,IAAI,OAAOD,UAAU,aAAa;YAChCG,YAAYH,KAAK,GAAGK,OAAOL;QAC7B;QAEA,IAAIM,kBAAkB;QACtB,IAAIC,2BAA2B;QAC/B,IAAI;YACF,MAAMC,SAAS,MAAM5B,QAAQuB;YAC7BG,kBAAkBE,OAAOF,eAAe;YACxCC,2BAA2BC,OAAOD,wBAAwB;QAC5D,EAAE,OAAOE,KAAK;YACZ1B,IAAIG,OAAO,CAACwB,MAAM,CAACC,KAAK,CAAC;gBACvBF;gBACAG,KAAK;gBACLX,OAAOE,YAAYF,KAAK;YAC1B;YAEA,OAAOV,SAASC,IAAI,CAClB;gBACEC,SAASV,IAAIe,IAAI,CAACC,CAAC,CAAC;gBACpBO,iBAAiB;gBACjBC;YACF,GACA;gBAAEb,QAAQ;YAAI;QAElB;QAEA,OAAOH,SAASC,IAAI,CAClB;YACEC,SAASV,IAAIe,IAAI,CAACC,CAAC,CAAC;YACpBO;YACAC;QACF,GACA;YAAEb,QAAQ;QAAI;IAElB;IACAmB,QAAQ;IACRC,MAAM;AACR,EAAC"}

package/dist/queues/utilities/getJobTaskStatus.d.ts

@@ -0,0 +1,9 @@
+import type { TaskConfig, TaskType } from '../config/types/taskTypes.js';
+import type { BaseJob, JobTaskStatus } from '../config/types/workflowTypes.js';
+type Args = {
+    jobLog: BaseJob['log'];
+    tasksConfig: TaskConfig<TaskType>[];
+};
+export declare const getJobTaskStatus: ({ jobLog }: Args) => JobTaskStatus;
+export {};
+//# sourceMappingURL=getJobTaskStatus.d.ts.map