@depup/payload 3.79.1-depup.0

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

@@ -0,0 +1,155 @@
+import ObjectIdImport from 'bson-objectid';
+import { JobCancelledError, TaskError } from '../../../errors/index.js';
+import { getCurrentDate } from '../../../utilities/getCurrentDate.js';
+import { getTaskHandlerFromConfig } from './importHandlerPath.js';
+const ObjectId = 'default' in ObjectIdImport ? ObjectIdImport.default : ObjectIdImport;
+export const getRunTaskFunction = (job, workflowConfig, req, isInline, updateJob, parent)=>{
+    const jobConfig = req.payload.config.jobs;
+    const runTask = (taskSlug)=>async (taskID, { input, retries, // Only available for inline tasks:
+        task })=>{
+            const executedAt = getCurrentDate();
+            let taskConfig;
+            if (!isInline) {
+                taskConfig = jobConfig.tasks?.length && jobConfig.tasks.find((t)=>t.slug === taskSlug);
+                if (!taskConfig) {
+                    throw new Error(`Task ${taskSlug} not found in workflow ${job.workflowSlug}`);
+                }
+            }
+            const retriesConfigFromPropsNormalized = retries == undefined || retries == null ? {} : typeof retries === 'number' ? {
+                attempts: retries
+            } : retries;
+            const retriesConfigFromTaskConfigNormalized = taskConfig ? typeof taskConfig.retries === 'number' ? {
+                attempts: taskConfig.retries
+            } : taskConfig.retries : {};
+            const finalRetriesConfig = {
+                ...retriesConfigFromTaskConfigNormalized,
+                ...retriesConfigFromPropsNormalized
+            };
+            const taskStatus = job?.taskStatus?.[taskSlug] ? job.taskStatus[taskSlug][taskID] : null;
+            // Handle restoration of task if it succeeded in a previous run
+            if (taskStatus && taskStatus.complete === true) {
+                let shouldRestore = true;
+                if (finalRetriesConfig?.shouldRestore === false) {
+                    shouldRestore = false;
+                } else if (typeof finalRetriesConfig?.shouldRestore === 'function') {
+                    shouldRestore = await finalRetriesConfig.shouldRestore({
+                        input,
+                        job,
+                        req,
+                        taskStatus
+                    });
+                }
+                if (shouldRestore) {
+                    return taskStatus.output;
+                }
+            }
+            const runner = isInline ? task : await getTaskHandlerFromConfig(taskConfig);
+            if (!runner || typeof runner !== 'function') {
+                throw new TaskError({
+                    executedAt,
+                    input,
+                    job,
+                    message: isInline ? `Inline task with ID ${taskID} does not have a valid handler.` : `Task with slug ${taskSlug} in workflow ${job.workflowSlug} does not have a valid handler.`,
+                    parent,
+                    retriesConfig: finalRetriesConfig,
+                    taskConfig,
+                    taskID,
+                    taskSlug,
+                    taskStatus,
+                    workflowConfig
+                });
+            }
+            let taskHandlerResult;
+            let output = {};
+            try {
+                taskHandlerResult = await runner({
+                    inlineTask: getRunTaskFunction(job, workflowConfig, req, true, updateJob, {
+                        taskID,
+                        taskSlug
+                    }),
+                    input,
+                    job: job,
+                    req,
+                    tasks: getRunTaskFunction(job, workflowConfig, req, false, updateJob, {
+                        taskID,
+                        taskSlug
+                    })
+                });
+            } catch (err) {
+                if (err instanceof JobCancelledError) {
+                    // Re-throw JobCancelledError to be handled by the top-level error handler
+                    throw err;
+                }
+                throw new TaskError({
+                    executedAt,
+                    input: input,
+                    job,
+                    message: err.message || 'Task handler threw an error',
+                    output,
+                    parent,
+                    retriesConfig: finalRetriesConfig,
+                    taskConfig,
+                    taskID,
+                    taskSlug,
+                    taskStatus,
+                    workflowConfig
+                });
+            }
+            if (taskHandlerResult.state === 'failed') {
+                throw new TaskError({
+                    executedAt,
+                    input: input,
+                    job,
+                    message: taskHandlerResult.errorMessage ?? 'Task handler returned a failed state',
+                    output,
+                    parent,
+                    retriesConfig: finalRetriesConfig,
+                    taskConfig,
+                    taskID,
+                    taskSlug,
+                    taskStatus,
+                    workflowConfig
+                });
+            } else {
+                output = taskHandlerResult.output;
+            }
+            if (taskConfig?.onSuccess) {
+                await taskConfig.onSuccess({
+                    input,
+                    job,
+                    req,
+                    taskStatus
+                });
+            }
+            const newLogItem = {
+                id: new ObjectId().toHexString(),
+                completedAt: getCurrentDate().toISOString(),
+                executedAt: executedAt.toISOString(),
+                input,
+                output,
+                parent: jobConfig.addParentToTaskLog ? parent : undefined,
+                state: 'succeeded',
+                taskID,
+                taskSlug
+            };
+            await updateJob({
+                log: {
+                    $push: newLogItem
+                },
+                // Set to null to skip main row update on postgres. 2 => 1 db round trips
+                updatedAt: null
+            });
+            return output;
+        };
+    if (isInline) {
+        return runTask('inline');
+    } else {
+        const tasks = {};
+        for (const task of jobConfig.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 ObjectIdImport from 'bson-objectid'\n\nimport type { Job } from '../../../../index.js'\nimport type { JsonObject, 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  JobLog,\n  SingleTaskStatus,\n  WorkflowConfig,\n  WorkflowTypes,\n} from '../../../config/types/workflowTypes.js'\nimport type { UpdateJobFunction } from './getUpdateJobFunction.js'\n\nimport { JobCancelledError, TaskError } from '../../../errors/index.js'\nimport { getCurrentDate } from '../../../utilities/getCurrentDate.js'\nimport { getTaskHandlerFromConfig } from './importHandlerPath.js'\n\nconst ObjectId = 'default' in ObjectIdImport ? ObjectIdImport.default : ObjectIdImport\n\nexport type TaskParent = {\n  taskID: string\n  taskSlug: string\n}\n\nexport const getRunTaskFunction = <TIsInline extends boolean>(\n  job: Job,\n  workflowConfig: WorkflowConfig,\n  req: PayloadRequest,\n  isInline: TIsInline,\n  updateJob: UpdateJobFunction,\n  parent?: TaskParent,\n): TIsInline extends true ? RunInlineTaskFunction : RunTaskFunctions => {\n  const jobConfig = req.payload.config.jobs\n\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        // Only available for inline tasks:\n        task,\n      }: Parameters<RunInlineTaskFunction>[1] & Parameters<RunTaskFunction<string>>[1],\n    ) => {\n      const executedAt = getCurrentDate()\n\n      let taskConfig: TaskConfig | undefined\n      if (!isInline) {\n        taskConfig = (jobConfig.tasks?.length &&\n          jobConfig.tasks.find((t) => t.slug === taskSlug)) as TaskConfig<string>\n\n        if (!taskConfig) {\n          throw new Error(`Task ${taskSlug} not found in workflow ${job.workflowSlug}`)\n        }\n      }\n\n      const retriesConfigFromPropsNormalized =\n        retries == undefined || retries == null\n          ? {}\n          : typeof retries === 'number'\n            ? { attempts: retries }\n            : retries\n      const retriesConfigFromTaskConfigNormalized = taskConfig\n        ? typeof taskConfig.retries === 'number'\n          ? { attempts: taskConfig.retries }\n          : taskConfig.retries\n        : {}\n\n      const finalRetriesConfig: RetryConfig = {\n        ...retriesConfigFromTaskConfigNormalized,\n        ...retriesConfigFromPropsNormalized, // Retry config from props takes precedence\n      }\n\n      const taskStatus: null | SingleTaskStatus<string> = job?.taskStatus?.[taskSlug]\n        ? job.taskStatus[taskSlug][taskID]!\n        : null\n\n      // Handle restoration of task if it succeeded in a previous run\n      if (taskStatus && taskStatus.complete === true) {\n        let shouldRestore = true\n        if (finalRetriesConfig?.shouldRestore === false) {\n          shouldRestore = false\n        } else if (typeof finalRetriesConfig?.shouldRestore === 'function') {\n          shouldRestore = await finalRetriesConfig.shouldRestore({\n            input,\n            job,\n            req,\n            taskStatus,\n          })\n        }\n        if (shouldRestore) {\n          return taskStatus.output\n        }\n      }\n\n      const runner = isInline\n        ? (task as TaskHandler<TaskType>)\n        : await getTaskHandlerFromConfig(taskConfig)\n\n      if (!runner || typeof runner !== 'function') {\n        throw new TaskError({\n          executedAt,\n          input,\n          job,\n          message: isInline\n            ? `Inline task with ID ${taskID} does not have a valid handler.`\n            : `Task with slug ${taskSlug} in workflow ${job.workflowSlug} does not have a valid handler.`,\n          parent,\n          retriesConfig: finalRetriesConfig,\n          taskConfig,\n          taskID,\n          taskSlug,\n          taskStatus,\n          workflowConfig,\n        })\n      }\n\n      let taskHandlerResult: TaskHandlerResult<string>\n      let output: JsonObject | undefined = {}\n\n      try {\n        taskHandlerResult = await runner({\n          inlineTask: getRunTaskFunction(job, workflowConfig, req, true, updateJob, {\n            taskID,\n            taskSlug,\n          }),\n          input,\n          job: job as unknown as Job<WorkflowTypes>,\n          req,\n          tasks: getRunTaskFunction(job, workflowConfig, req, false, updateJob, {\n            taskID,\n            taskSlug,\n          }),\n        })\n      } catch (err: any) {\n        if (err instanceof JobCancelledError) {\n          // Re-throw JobCancelledError to be handled by the top-level error handler\n          throw err\n        }\n        throw new TaskError({\n          executedAt,\n          input: input!,\n          job,\n          message: err.message || 'Task handler threw an error',\n          output,\n          parent,\n          retriesConfig: finalRetriesConfig,\n          taskConfig,\n          taskID,\n          taskSlug,\n          taskStatus,\n          workflowConfig,\n        })\n      }\n\n      if (taskHandlerResult.state === 'failed') {\n        throw new TaskError({\n          executedAt,\n          input: input!,\n          job,\n          message: taskHandlerResult.errorMessage ?? 'Task handler returned a failed state',\n          output,\n          parent,\n          retriesConfig: finalRetriesConfig,\n          taskConfig,\n          taskID,\n          taskSlug,\n          taskStatus,\n          workflowConfig,\n        })\n      } else {\n        output = taskHandlerResult.output\n      }\n\n      if (taskConfig?.onSuccess) {\n        await taskConfig.onSuccess({\n          input,\n          job,\n          req,\n          taskStatus,\n        })\n      }\n\n      const newLogItem: JobLog = {\n        id: new ObjectId().toHexString(),\n        completedAt: getCurrentDate().toISOString(),\n        executedAt: executedAt.toISOString(),\n        input,\n        output,\n        parent: jobConfig.addParentToTaskLog ? parent : undefined,\n        state: 'succeeded',\n        taskID,\n        taskSlug,\n      }\n\n      await updateJob({\n        log: {\n          $push: newLogItem,\n        } as any,\n        // Set to null to skip main row update on postgres. 2 => 1 db round trips\n        updatedAt: null as any,\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 jobConfig.tasks ?? []) {\n      tasks[task.slug] = runTask(task.slug) as RunTaskFunction<string>\n    }\n    return tasks as TIsInline extends true ? RunInlineTaskFunction : RunTaskFunctions\n  }\n}\n"],"names":["ObjectIdImport","JobCancelledError","TaskError","getCurrentDate","getTaskHandlerFromConfig","ObjectId","default","getRunTaskFunction","job","workflowConfig","req","isInline","updateJob","parent","jobConfig","payload","config","jobs","runTask","taskSlug","taskID","input","retries","task","executedAt","taskConfig","tasks","length","find","t","slug","Error","workflowSlug","retriesConfigFromPropsNormalized","undefined","attempts","retriesConfigFromTaskConfigNormalized","finalRetriesConfig","taskStatus","complete","shouldRestore","output","runner","message","retriesConfig","taskHandlerResult","inlineTask","err","state","errorMessage","onSuccess","newLogItem","id","toHexString","completedAt","toISOString","addParentToTaskLog","log","$push","updatedAt"],"mappings":"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"}

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

@@ -0,0 +1,10 @@
+import type { Job } from '../../../../index.js';
+import type { PayloadRequest } from '../../../../types/index.js';
+export type UpdateJobFunction = (jobData: Partial<Job>) => Promise<Job>;
+/**
+ * Helper for updating a job that does the following, additionally to updating the job:
+ * - Merges incoming data from the updated job into the original job object
+ * - Handles job cancellation by throwing a `JobCancelledError` if the job was cancelled.
+ */
+export declare function getUpdateJobFunction(job: Job, 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,GAAG,EAAE,MAAM,sBAAsB,CAAA;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAKhE,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;AAEvE;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,cAAc,GAAG,iBAAiB,CAmCrF"}

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

@@ -0,0 +1,42 @@
+import { JobCancelledError } from '../../../errors/index.js';
+import { updateJob } from '../../../utilities/updateJob.js';
+/**
+ * Helper for updating a job that does the following, additionally to updating the job:
+ * - Merges incoming data from the updated job into the original job object
+ * - Handles job cancellation by throwing a `JobCancelledError` if the job was cancelled.
+ */ export function getUpdateJobFunction(job, req) {
+    return async (jobData)=>{
+        const updatedJob = await updateJob({
+            id: job.id,
+            data: jobData,
+            depth: req.payload.config.jobs.depth,
+            disableTransaction: true,
+            req
+        });
+        if (!updatedJob) {
+            return job;
+        }
+        // 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){
+            if (key === 'log') {
+                // Add all new log entries to the original job.log object. Do not delete any existing log entries.
+                // Do not update existing log entries, as existing log entries should be immutable.
+                for (const logEntry of updatedJob?.log ?? []){
+                    if (!job.log || !job.log.some((entry)=>entry.id === logEntry.id)) {
+                        ;
+                        (job.log ??= []).push(logEntry);
+                    }
+                }
+            } else {
+                ;
+                job[key] = updatedJob[key];
+            }
+        }
+        if (updatedJob?.error?.cancelled) {
+            throw new JobCancelledError(`Job ${job.id} was cancelled`);
+        }
+        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 { Job } from '../../../../index.js'\nimport type { PayloadRequest } from '../../../../types/index.js'\n\nimport { JobCancelledError } from '../../../errors/index.js'\nimport { updateJob } from '../../../utilities/updateJob.js'\n\nexport type UpdateJobFunction = (jobData: Partial<Job>) => Promise<Job>\n\n/**\n * Helper for updating a job that does the following, additionally to updating the job:\n * - Merges incoming data from the updated job into the original job object\n * - Handles job cancellation by throwing a `JobCancelledError` if the job was cancelled.\n */\nexport function getUpdateJobFunction(job: Job, req: PayloadRequest): UpdateJobFunction {\n  return async (jobData) => {\n    const updatedJob = await updateJob({\n      id: job.id,\n      data: jobData,\n      depth: req.payload.config.jobs.depth,\n      disableTransaction: true,\n      req,\n    })\n\n    if (!updatedJob) {\n      return job\n    }\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      if (key === 'log') {\n        // Add all new log entries to the original job.log object. Do not delete any existing log entries.\n        // Do not update existing log entries, as existing log entries should be immutable.\n        for (const logEntry of updatedJob?.log ?? []) {\n          if (!job.log || !job.log.some((entry) => entry.id === logEntry.id)) {\n            ;(job.log ??= []).push(logEntry)\n          }\n        }\n      } else {\n        ;(job as any)[key] = updatedJob[key as keyof Job]\n      }\n    }\n\n    if ((updatedJob?.error as Record<string, unknown>)?.cancelled) {\n      throw new JobCancelledError(`Job ${job.id} was cancelled`)\n    }\n\n    return updatedJob\n  }\n}\n"],"names":["JobCancelledError","updateJob","getUpdateJobFunction","job","req","jobData","updatedJob","id","data","depth","payload","config","jobs","disableTransaction","key","logEntry","log","some","entry","push","error","cancelled"],"mappings":"AAGA,SAASA,iBAAiB,QAAQ,2BAA0B;AAC5D,SAASC,SAAS,QAAQ,kCAAiC;AAI3D;;;;CAIC,GACD,OAAO,SAASC,qBAAqBC,GAAQ,EAAEC,GAAmB;IAChE,OAAO,OAAOC;QACZ,MAAMC,aAAa,MAAML,UAAU;YACjCM,IAAIJ,IAAII,EAAE;YACVC,MAAMH;YACNI,OAAOL,IAAIM,OAAO,CAACC,MAAM,CAACC,IAAI,CAACH,KAAK;YACpCI,oBAAoB;YACpBT;QACF;QAEA,IAAI,CAACE,YAAY;YACf,OAAOH;QACT;QAEA,sMAAsM;QACtM,IAAK,MAAMW,OAAOR,WAAY;YAC5B,IAAIQ,QAAQ,OAAO;gBACjB,kGAAkG;gBAClG,mFAAmF;gBACnF,KAAK,MAAMC,YAAYT,YAAYU,OAAO,EAAE,CAAE;oBAC5C,IAAI,CAACb,IAAIa,GAAG,IAAI,CAACb,IAAIa,GAAG,CAACC,IAAI,CAAC,CAACC,QAAUA,MAAMX,EAAE,KAAKQ,SAASR,EAAE,GAAG;;wBAChEJ,CAAAA,IAAIa,GAAG,KAAK,EAAE,AAAD,EAAGG,IAAI,CAACJ;oBACzB;gBACF;YACF,OAAO;;gBACHZ,GAAW,CAACW,IAAI,GAAGR,UAAU,CAACQ,IAAiB;YACnD;QACF;QAEA,IAAKR,YAAYc,OAAmCC,WAAW;YAC7D,MAAM,IAAIrB,kBAAkB,CAAC,IAAI,EAAEG,IAAII,EAAE,CAAC,cAAc,CAAC;QAC3D;QAEA,OAAOD;IACT;AACF"}

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

@@ -0,0 +1,12 @@
+import type { TaskConfig, TaskHandler } from '../../../config/types/taskTypes.js';
+/**
+ * Imports a handler function from a given path.
+ */
+export declare function importHandlerPath<T>(path: string): Promise<T>;
+/**
+ * The `handler` property of a task config can either be a function or a path to a module that exports a function.
+ * This function resolves the handler to a function, either by importing it from the path or returning the function directly
+ * if it is already a function.
+ */
+export declare function getTaskHandlerFromConfig(taskConfig?: TaskConfig): Promise<TaskHandler<string, string>>;
+//# 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":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAY,MAAM,oCAAoC,CAAA;AAI3F;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CA6BnE;AAED;;;;GAIG;AACH,wBAAsB,wBAAwB,CAAC,UAAU,CAAC,EAAE,UAAU,wCASrE"}

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

@@ -0,0 +1,42 @@
+import { dynamicImport } from '../../../../utilities/dynamicImport.js';
+/**
+ * Imports a handler function from a given path.
+ */ export async function importHandlerPath(path) {
+    let runner;
+    const [runnerPath, runnerImportName] = path.split('#');
+    let runnerModule;
+    try {
+        runnerModule = await dynamicImport(runnerPath);
+    } catch (e) {
+        throw new Error(`Error importing job queue handler module for path ${path}. This is an advanced feature that may require a sophisticated build pipeline, especially when using it in production or within Next.js, e.g. by calling opening the /api/payload-jobs/run endpoint. You will have to transpile the handler files separately and ensure they are available in the same location when the job is run. If you're using an endpoint to execute your jobs, it's recommended to define your handlers as functions directly in your Payload Config, or use import paths handlers outside of Next.js. Import Error: \n${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+    // 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;
+}
+/**
+ * The `handler` property of a task config can either be a function or a path to a module that exports a function.
+ * This function resolves the handler to a function, either by importing it from the path or returning the function directly
+ * if it is already a function.
+ */ export async function getTaskHandlerFromConfig(taskConfig) {
+    if (!taskConfig) {
+        throw new Error('Task config is required to get the task handler');
+    }
+    if (typeof taskConfig.handler === 'function') {
+        return taskConfig.handler;
+    } else {
+        return await importHandlerPath(taskConfig.handler);
+    }
+}
+
+//# 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 type { TaskConfig, TaskHandler, TaskType } from '../../../config/types/taskTypes.js'\n\nimport { dynamicImport } from '../../../../utilities/dynamicImport.js'\n\n/**\n * Imports a handler function from a given path.\n */\nexport async function importHandlerPath<T>(path: string): Promise<T> {\n  let runner!: T\n  const [runnerPath, runnerImportName] = path.split('#')\n\n  let runnerModule: Record<string, unknown>\n  try {\n    runnerModule = await dynamicImport<Record<string, unknown>>(runnerPath!)\n  } catch (e) {\n    throw new Error(\n      `Error importing job queue handler module for path ${path}. This is an advanced feature that may require a sophisticated build pipeline, especially when using it in production or within Next.js, e.g. by calling opening the /api/payload-jobs/run endpoint. You will have to transpile the handler files separately and ensure they are available in the same location when the job is run. If you're using an endpoint to execute your jobs, it's recommended to define your handlers as functions directly in your Payload Config, or use import paths handlers outside of Next.js. Import Error: \\n${e instanceof Error ? e.message : 'Unknown error'}`,\n    )\n  }\n\n  // If the path has indicated an #exportName, try to get it\n  if (runnerImportName && runnerModule[runnerImportName]) {\n    runner = runnerModule[runnerImportName] as T\n  }\n\n  // If there is a default export, use it\n  if (!runner && runnerModule.default) {\n    runner = runnerModule.default as T\n  }\n\n  // Finally, use whatever was imported\n  if (!runner) {\n    runner = runnerModule as T\n  }\n\n  return runner\n}\n\n/**\n * The `handler` property of a task config can either be a function or a path to a module that exports a function.\n * This function resolves the handler to a function, either by importing it from the path or returning the function directly\n * if it is already a function.\n */\nexport async function getTaskHandlerFromConfig(taskConfig?: TaskConfig) {\n  if (!taskConfig) {\n    throw new Error('Task config is required to get the task handler')\n  }\n  if (typeof taskConfig.handler === 'function') {\n    return taskConfig.handler\n  } else {\n    return await importHandlerPath<TaskHandler<TaskType>>(taskConfig.handler)\n  }\n}\n"],"names":["dynamicImport","importHandlerPath","path","runner","runnerPath","runnerImportName","split","runnerModule","e","Error","message","default","getTaskHandlerFromConfig","taskConfig","handler"],"mappings":"AAEA,SAASA,aAAa,QAAQ,yCAAwC;AAEtE;;CAEC,GACD,OAAO,eAAeC,kBAAqBC,IAAY;IACrD,IAAIC;IACJ,MAAM,CAACC,YAAYC,iBAAiB,GAAGH,KAAKI,KAAK,CAAC;IAElD,IAAIC;IACJ,IAAI;QACFA,eAAe,MAAMP,cAAuCI;IAC9D,EAAE,OAAOI,GAAG;QACV,MAAM,IAAIC,MACR,CAAC,kDAAkD,EAAEP,KAAK,+gBAA+gB,EAAEM,aAAaC,QAAQD,EAAEE,OAAO,GAAG,iBAAiB;IAEjoB;IAEA,0DAA0D;IAC1D,IAAIL,oBAAoBE,YAAY,CAACF,iBAAiB,EAAE;QACtDF,SAASI,YAAY,CAACF,iBAAiB;IACzC;IAEA,uCAAuC;IACvC,IAAI,CAACF,UAAUI,aAAaI,OAAO,EAAE;QACnCR,SAASI,aAAaI,OAAO;IAC/B;IAEA,qCAAqC;IACrC,IAAI,CAACR,QAAQ;QACXA,SAASI;IACX;IAEA,OAAOJ;AACT;AAEA;;;;CAIC,GACD,OAAO,eAAeS,yBAAyBC,UAAuB;IACpE,IAAI,CAACA,YAAY;QACf,MAAM,IAAIJ,MAAM;IAClB;IACA,IAAI,OAAOI,WAAWC,OAAO,KAAK,YAAY;QAC5C,OAAOD,WAAWC,OAAO;IAC3B,OAAO;QACL,OAAO,MAAMb,kBAAyCY,WAAWC,OAAO;IAC1E;AACF"}

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

@@ -0,0 +1,28 @@
+import type { Job } from '../../../../index.js';
+import type { PayloadRequest } from '../../../../types/index.js';
+import type { WorkflowConfig, WorkflowHandler } from '../../../config/types/workflowTypes.js';
+import type { RunJobsSilent } from '../../../localAPI.js';
+import type { UpdateJobFunction } from './getUpdateJobFunction.js';
+type Args = {
+    job: Job;
+    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;
+    workflowConfig: WorkflowConfig;
+    workflowHandler: WorkflowHandler;
+};
+export type JobRunStatus = 'error' | 'error-reached-max-retries' | 'success';
+export type RunJobResult = {
+    status: JobRunStatus;
+};
+export declare const runJob: ({ job, req, silent, 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,GAAG,EAAE,MAAM,sBAAsB,CAAA;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AAC7F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAQlE,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,GAAG,CAAA;IACR,GAAG,EAAE,cAAc,CAAA;IACnB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,aAAa,CAAA;IACtB,SAAS,EAAE,iBAAiB,CAAA;IAC5B,cAAc,EAAE,cAAc,CAAA;IAC9B,eAAe,EAAE,eAAe,CAAA;CACjC,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,sEAOhB,IAAI,KAAG,OAAO,CAAC,YAAY,CA6D7B,CAAA"}

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

@@ -0,0 +1,59 @@
+import { handleTaskError } from '../../../errors/handleTaskError.js';
+import { handleWorkflowError } from '../../../errors/handleWorkflowError.js';
+import { JobCancelledError, TaskError, WorkflowError } from '../../../errors/index.js';
+import { getCurrentDate } from '../../../utilities/getCurrentDate.js';
+import { getRunTaskFunction } from './getRunTaskFunction.js';
+export const runJob = async ({ job, req, silent, updateJob, workflowConfig, workflowHandler })=>{
+    // Run the job
+    try {
+        await workflowHandler({
+            inlineTask: getRunTaskFunction(job, workflowConfig, req, true, updateJob),
+            job,
+            req,
+            tasks: getRunTaskFunction(job, workflowConfig, req, false, updateJob)
+        });
+    } catch (error) {
+        if (error instanceof JobCancelledError) {
+            throw error // Job cancellation is handled in a top-level error handler, as higher up code may themselves throw this error
+            ;
+        }
+        if (error instanceof TaskError) {
+            const { hasFinalError } = await handleTaskError({
+                error,
+                req,
+                silent,
+                updateJob
+            });
+            return {
+                status: hasFinalError ? 'error-reached-max-retries' : 'error'
+            };
+        }
+        const { hasFinalError } = await handleWorkflowError({
+            error: error instanceof WorkflowError ? error : new WorkflowError({
+                job,
+                message: typeof error === 'object' && error && 'message' in error ? error.message : 'An unhandled error occurred',
+                workflowConfig
+            }),
+            req,
+            silent,
+            updateJob
+        });
+        return {
+            status: hasFinalError ? 'error-reached-max-retries' : 'error'
+        };
+    }
+    // Workflow has completed successfully
+    // Do not update the job log here, as that would result in unnecessary db calls when using postgres.
+    // Solely updating simple fields here will result in optimized db calls.
+    // Job log modifications are already updated at the end of the runTask function.
+    await updateJob({
+        completedAt: getCurrentDate().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 { Job } from '../../../../index.js'\nimport type { PayloadRequest } from '../../../../types/index.js'\nimport type { WorkflowConfig, WorkflowHandler } from '../../../config/types/workflowTypes.js'\nimport type { RunJobsSilent } from '../../../localAPI.js'\nimport type { UpdateJobFunction } from './getUpdateJobFunction.js'\n\nimport { handleTaskError } from '../../../errors/handleTaskError.js'\nimport { handleWorkflowError } from '../../../errors/handleWorkflowError.js'\nimport { JobCancelledError, TaskError, WorkflowError } from '../../../errors/index.js'\nimport { getCurrentDate } from '../../../utilities/getCurrentDate.js'\nimport { getRunTaskFunction } from './getRunTaskFunction.js'\n\ntype Args = {\n  job: Job\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  workflowConfig: WorkflowConfig\n  workflowHandler: WorkflowHandler\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  silent,\n  updateJob,\n  workflowConfig,\n  workflowHandler,\n}: Args): Promise<RunJobResult> => {\n  // Run the job\n  try {\n    await workflowHandler({\n      inlineTask: getRunTaskFunction(job, workflowConfig, req, true, updateJob),\n      job,\n      req,\n      tasks: getRunTaskFunction(job, workflowConfig, req, false, updateJob),\n    })\n  } catch (error) {\n    if (error instanceof JobCancelledError) {\n      throw error // Job cancellation is handled in a top-level error handler, as higher up code may themselves throw this error\n    }\n    if (error instanceof TaskError) {\n      const { hasFinalError } = await handleTaskError({\n        error,\n        req,\n        silent,\n        updateJob,\n      })\n\n      return {\n        status: hasFinalError ? 'error-reached-max-retries' : 'error',\n      }\n    }\n\n    const { hasFinalError } = await handleWorkflowError({\n      error:\n        error instanceof WorkflowError\n          ? error\n          : new WorkflowError({\n              job,\n              message:\n                typeof error === 'object' && error && 'message' in error\n                  ? (error.message as string)\n                  : 'An unhandled error occurred',\n              workflowConfig,\n            }),\n      req,\n      silent,\n      updateJob,\n    })\n\n    return {\n      status: hasFinalError ? 'error-reached-max-retries' : 'error',\n    }\n  }\n\n  // Workflow has completed successfully\n  // Do not update the job log here, as that would result in unnecessary db calls when using postgres.\n  // Solely updating simple fields here will result in optimized db calls.\n  // Job log modifications are already updated at the end of the runTask function.\n  await updateJob({\n    completedAt: getCurrentDate().toISOString(),\n    processing: false,\n    totalTried: (job.totalTried ?? 0) + 1,\n  })\n\n  return {\n    status: 'success',\n  }\n}\n"],"names":["handleTaskError","handleWorkflowError","JobCancelledError","TaskError","WorkflowError","getCurrentDate","getRunTaskFunction","runJob","job","req","silent","updateJob","workflowConfig","workflowHandler","inlineTask","tasks","error","hasFinalError","status","message","completedAt","toISOString","processing","totalTried"],"mappings":"AAMA,SAASA,eAAe,QAAQ,qCAAoC;AACpE,SAASC,mBAAmB,QAAQ,yCAAwC;AAC5E,SAASC,iBAAiB,EAAEC,SAAS,EAAEC,aAAa,QAAQ,2BAA0B;AACtF,SAASC,cAAc,QAAQ,uCAAsC;AACrE,SAASC,kBAAkB,QAAQ,0BAAyB;AAyB5D,OAAO,MAAMC,SAAS,OAAO,EAC3BC,GAAG,EACHC,GAAG,EACHC,MAAM,EACNC,SAAS,EACTC,cAAc,EACdC,eAAe,EACV;IACL,cAAc;IACd,IAAI;QACF,MAAMA,gBAAgB;YACpBC,YAAYR,mBAAmBE,KAAKI,gBAAgBH,KAAK,MAAME;YAC/DH;YACAC;YACAM,OAAOT,mBAAmBE,KAAKI,gBAAgBH,KAAK,OAAOE;QAC7D;IACF,EAAE,OAAOK,OAAO;QACd,IAAIA,iBAAiBd,mBAAmB;YACtC,MAAMc,MAAM,8GAA8G;;QAC5H;QACA,IAAIA,iBAAiBb,WAAW;YAC9B,MAAM,EAAEc,aAAa,EAAE,GAAG,MAAMjB,gBAAgB;gBAC9CgB;gBACAP;gBACAC;gBACAC;YACF;YAEA,OAAO;gBACLO,QAAQD,gBAAgB,8BAA8B;YACxD;QACF;QAEA,MAAM,EAAEA,aAAa,EAAE,GAAG,MAAMhB,oBAAoB;YAClDe,OACEA,iBAAiBZ,gBACbY,QACA,IAAIZ,cAAc;gBAChBI;gBACAW,SACE,OAAOH,UAAU,YAAYA,SAAS,aAAaA,QAC9CA,MAAMG,OAAO,GACd;gBACNP;YACF;YACNH;YACAC;YACAC;QACF;QAEA,OAAO;YACLO,QAAQD,gBAAgB,8BAA8B;QACxD;IACF;IAEA,sCAAsC;IACtC,oGAAoG;IACpG,wEAAwE;IACxE,gFAAgF;IAChF,MAAMN,UAAU;QACdS,aAAaf,iBAAiBgB,WAAW;QACzCC,YAAY;QACZC,YAAY,AAACf,CAAAA,IAAIe,UAAU,IAAI,CAAA,IAAK;IACtC;IAEA,OAAO;QACLL,QAAQ;IACV;AACF,EAAC"}

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

@@ -0,0 +1,12 @@
+/**
+ * Globals that are used by our integration tests to modify the behavior of the job system during runtime.
+ * This is useful to avoid having to wait for the cron jobs to run, or to pause auto-running jobs.
+ */
+export declare const _internal_jobSystemGlobals: {
+    getCurrentDate: () => Date;
+    shouldAutoRun: boolean;
+    shouldAutoSchedule: boolean;
+};
+export declare function _internal_resetJobSystemGlobals(): void;
+export declare const getCurrentDate: () => Date;
+//# sourceMappingURL=getCurrentDate.d.ts.map

package/dist/queues/utilities/getCurrentDate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getCurrentDate.d.ts","sourceRoot":"","sources":["../../../src/queues/utilities/getCurrentDate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;;CAMtC,CAAA;AAED,wBAAgB,+BAA+B,SAI9C;AAED,eAAO,MAAM,cAAc,EAAE,MAAM,IAElC,CAAA"}

package/dist/queues/utilities/getCurrentDate.js

@@ -0,0 +1,20 @@
+/**
+ * Globals that are used by our integration tests to modify the behavior of the job system during runtime.
+ * This is useful to avoid having to wait for the cron jobs to run, or to pause auto-running jobs.
+ */ export const _internal_jobSystemGlobals = {
+    getCurrentDate: ()=>{
+        return new Date();
+    },
+    shouldAutoRun: true,
+    shouldAutoSchedule: true
+};
+export function _internal_resetJobSystemGlobals() {
+    _internal_jobSystemGlobals.getCurrentDate = ()=>new Date();
+    _internal_jobSystemGlobals.shouldAutoRun = true;
+    _internal_jobSystemGlobals.shouldAutoSchedule = true;
+}
+export const getCurrentDate = ()=>{
+    return _internal_jobSystemGlobals.getCurrentDate();
+};
+
+//# sourceMappingURL=getCurrentDate.js.map

package/dist/queues/utilities/getCurrentDate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/queues/utilities/getCurrentDate.ts"],"sourcesContent":["/**\n * Globals that are used by our integration tests to modify the behavior of the job system during runtime.\n * This is useful to avoid having to wait for the cron jobs to run, or to pause auto-running jobs.\n */\nexport const _internal_jobSystemGlobals = {\n  getCurrentDate: () => {\n    return new Date()\n  },\n  shouldAutoRun: true,\n  shouldAutoSchedule: true,\n}\n\nexport function _internal_resetJobSystemGlobals() {\n  _internal_jobSystemGlobals.getCurrentDate = () => new Date()\n  _internal_jobSystemGlobals.shouldAutoRun = true\n  _internal_jobSystemGlobals.shouldAutoSchedule = true\n}\n\nexport const getCurrentDate: () => Date = () => {\n  return _internal_jobSystemGlobals.getCurrentDate()\n}\n"],"names":["_internal_jobSystemGlobals","getCurrentDate","Date","shouldAutoRun","shouldAutoSchedule","_internal_resetJobSystemGlobals"],"mappings":"AAAA;;;CAGC,GACD,OAAO,MAAMA,6BAA6B;IACxCC,gBAAgB;QACd,OAAO,IAAIC;IACb;IACAC,eAAe;IACfC,oBAAoB;AACtB,EAAC;AAED,OAAO,SAASC;IACdL,2BAA2BC,cAAc,GAAG,IAAM,IAAIC;IACtDF,2BAA2BG,aAAa,GAAG;IAC3CH,2BAA2BI,kBAAkB,GAAG;AAClD;AAEA,OAAO,MAAMH,iBAA6B;IACxC,OAAOD,2BAA2BC,cAAc;AAClD,EAAC"}

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

@@ -0,0 +1,8 @@
+import type { Job } from '../../index.js';
+import type { JobTaskStatus } from '../config/types/workflowTypes.js';
+type Args = {
+    jobLog: Job['log'];
+};
+export declare const getJobTaskStatus: ({ jobLog }: Args) => JobTaskStatus;
+export {};
+//# sourceMappingURL=getJobTaskStatus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getJobTaskStatus.d.ts","sourceRoot":"","sources":["../../../src/queues/utilities/getJobTaskStatus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAA;AAErE,KAAK,IAAI,GAAG;IACV,MAAM,EAAE,GAAG,CAAC,KAAK,CAAC,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,gBAAgB,eAAgB,IAAI,KAAG,aAsCnD,CAAA"}

package/dist/queues/utilities/getJobTaskStatus.js

@@ -0,0 +1,37 @@
+export const getJobTaskStatus = ({ jobLog })=>{
+    const taskStatus = {};
+    if (!jobLog || !Array.isArray(jobLog)) {
+        return taskStatus;
+    }
+    // First, add (in order) the steps from the config to
+    // our status map
+    for (const loggedJob of jobLog){
+        if (!taskStatus[loggedJob.taskSlug]) {
+            taskStatus[loggedJob.taskSlug] = {};
+        }
+        if (!taskStatus[loggedJob.taskSlug]?.[loggedJob.taskID]) {
+            taskStatus[loggedJob.taskSlug][loggedJob.taskID] = {
+                complete: loggedJob.state === 'succeeded',
+                input: loggedJob.input,
+                output: loggedJob.output,
+                taskSlug: loggedJob.taskSlug,
+                totalTried: 1
+            };
+        } else {
+            const newTaskStatus = taskStatus[loggedJob.taskSlug][loggedJob.taskID];
+            newTaskStatus.totalTried += 1;
+            if (loggedJob.state === 'succeeded') {
+                newTaskStatus.complete = true;
+                // As the task currently saved in taskStatus has likely failed and thus has no
+                // Output data, we need to update it with the new data from the successful task
+                newTaskStatus.output = loggedJob.output;
+                newTaskStatus.input = loggedJob.input;
+                newTaskStatus.taskSlug = loggedJob.taskSlug;
+            }
+            taskStatus[loggedJob.taskSlug][loggedJob.taskID] = newTaskStatus;
+        }
+    }
+    return taskStatus;
+};
+
+//# sourceMappingURL=getJobTaskStatus.js.map

package/dist/queues/utilities/getJobTaskStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/queues/utilities/getJobTaskStatus.ts"],"sourcesContent":["import type { Job } from '../../index.js'\nimport type { JobTaskStatus } from '../config/types/workflowTypes.js'\n\ntype Args = {\n  jobLog: Job['log']\n}\n\nexport const getJobTaskStatus = ({ jobLog }: Args): JobTaskStatus => {\n  const taskStatus: JobTaskStatus = {}\n\n  if (!jobLog || !Array.isArray(jobLog)) {\n    return taskStatus\n  }\n\n  // First, add (in order) the steps from the config to\n  // our status map\n  for (const loggedJob of jobLog) {\n    if (!taskStatus[loggedJob.taskSlug]) {\n      taskStatus[loggedJob.taskSlug] = {}\n    }\n    if (!taskStatus[loggedJob.taskSlug]?.[loggedJob.taskID]) {\n      taskStatus[loggedJob.taskSlug]![loggedJob.taskID] = {\n        complete: loggedJob.state === 'succeeded',\n        input: loggedJob.input,\n        output: loggedJob.output,\n        taskSlug: loggedJob.taskSlug,\n        totalTried: 1,\n      }\n    } else {\n      const newTaskStatus = taskStatus[loggedJob.taskSlug]![loggedJob.taskID]!\n      newTaskStatus.totalTried += 1\n\n      if (loggedJob.state === 'succeeded') {\n        newTaskStatus.complete = true\n        // As the task currently saved in taskStatus has likely failed and thus has no\n        // Output data, we need to update it with the new data from the successful task\n        newTaskStatus.output = loggedJob.output\n        newTaskStatus.input = loggedJob.input\n        newTaskStatus.taskSlug = loggedJob.taskSlug\n      }\n      taskStatus[loggedJob.taskSlug]![loggedJob.taskID] = newTaskStatus\n    }\n  }\n\n  return taskStatus\n}\n"],"names":["getJobTaskStatus","jobLog","taskStatus","Array","isArray","loggedJob","taskSlug","taskID","complete","state","input","output","totalTried","newTaskStatus"],"mappings":"AAOA,OAAO,MAAMA,mBAAmB,CAAC,EAAEC,MAAM,EAAQ;IAC/C,MAAMC,aAA4B,CAAC;IAEnC,IAAI,CAACD,UAAU,CAACE,MAAMC,OAAO,CAACH,SAAS;QACrC,OAAOC;IACT;IAEA,qDAAqD;IACrD,iBAAiB;IACjB,KAAK,MAAMG,aAAaJ,OAAQ;QAC9B,IAAI,CAACC,UAAU,CAACG,UAAUC,QAAQ,CAAC,EAAE;YACnCJ,UAAU,CAACG,UAAUC,QAAQ,CAAC,GAAG,CAAC;QACpC;QACA,IAAI,CAACJ,UAAU,CAACG,UAAUC,QAAQ,CAAC,EAAE,CAACD,UAAUE,MAAM,CAAC,EAAE;YACvDL,UAAU,CAACG,UAAUC,QAAQ,CAAC,AAAC,CAACD,UAAUE,MAAM,CAAC,GAAG;gBAClDC,UAAUH,UAAUI,KAAK,KAAK;gBAC9BC,OAAOL,UAAUK,KAAK;gBACtBC,QAAQN,UAAUM,MAAM;gBACxBL,UAAUD,UAAUC,QAAQ;gBAC5BM,YAAY;YACd;QACF,OAAO;YACL,MAAMC,gBAAgBX,UAAU,CAACG,UAAUC,QAAQ,CAAC,AAAC,CAACD,UAAUE,MAAM,CAAC;YACvEM,cAAcD,UAAU,IAAI;YAE5B,IAAIP,UAAUI,KAAK,KAAK,aAAa;gBACnCI,cAAcL,QAAQ,GAAG;gBACzB,8EAA8E;gBAC9E,+EAA+E;gBAC/EK,cAAcF,MAAM,GAAGN,UAAUM,MAAM;gBACvCE,cAAcH,KAAK,GAAGL,UAAUK,KAAK;gBACrCG,cAAcP,QAAQ,GAAGD,UAAUC,QAAQ;YAC7C;YACAJ,UAAU,CAACG,UAAUC,QAAQ,CAAC,AAAC,CAACD,UAAUE,MAAM,CAAC,GAAGM;QACtD;IACF;IAEA,OAAOX;AACT,EAAC"}

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

@@ -0,0 +1,35 @@
+import type { Job } from '../../index.js';
+import type { PayloadRequest, Sort, Where } from '../../types/index.js';
+type BaseArgs = {
+    data: Partial<Job>;
+    depth?: number;
+    disableTransaction?: boolean;
+    limit?: number;
+    req: PayloadRequest;
+    returning?: boolean;
+};
+type ArgsByID = {
+    id: number | string;
+    limit?: never;
+    sort?: never;
+    where?: never;
+};
+type ArgsWhere = {
+    id?: never;
+    limit?: number;
+    sort?: Sort;
+    where: Where;
+};
+type RunJobsArgs = (ArgsByID | ArgsWhere) & BaseArgs;
+/**
+ * Convenience method for updateJobs by id
+ */
+export declare function updateJob(args: ArgsByID & BaseArgs): Promise<Job | undefined>;
+/**
+ * Helper for updating jobs in the most performant way possible.
+ * Handles deciding whether it can used direct db methods or not, and if so,
+ * manually runs the afterRead hook that populates the `taskStatus` property.
+ */
+export declare function updateJobs({ id, data, depth, disableTransaction, limit: limitArg, req, returning, sort, where: whereArg, }: RunJobsArgs): Promise<Job[] | null>;
+export {};
+//# sourceMappingURL=updateJob.d.ts.map

package/dist/queues/utilities/updateJob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateJob.d.ts","sourceRoot":"","sources":["../../../src/queues/utilities/updateJob.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAA;AAIvE,KAAK,QAAQ,GAAG;IACd,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,CAAA;IAClB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,cAAc,CAAA;IACnB,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,KAAK,QAAQ,GAAG;IACd,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,IAAI,CAAC,EAAE,KAAK,CAAA;IACZ,KAAK,CAAC,EAAE,KAAK,CAAA;CACd,CAAA;AAED,KAAK,SAAS,GAAG;IACf,EAAE,CAAC,EAAE,KAAK,CAAA;IACV,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,KAAK,EAAE,KAAK,CAAA;CACb,CAAA;AAED,KAAK,WAAW,GAAG,CAAC,QAAQ,GAAG,SAAS,CAAC,GAAG,QAAQ,CAAA;AAEpD;;GAEG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,4BAKxD;AAED;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,EAC/B,EAAE,EACF,IAAI,EACJ,KAAK,EACL,kBAAkB,EAClB,KAAK,EAAE,QAAQ,EACf,GAAG,EACH,SAAS,EACT,IAAI,EACJ,KAAK,EAAE,QAAQ,GAChB,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAiErC"}