@depup/payload 3.79.1-depup.0

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

@@ -0,0 +1,434 @@
+import { Forbidden } from '../../../errors/Forbidden.js';
+import { isolateObjectProperty } from '../../../utilities/isolateObjectProperty.js';
+import { jobsCollectionSlug } from '../../config/collection.js';
+import { JobCancelledError } from '../../errors/index.js';
+import { getCurrentDate } from '../../utilities/getCurrentDate.js';
+import { updateJob, updateJobs } from '../../utilities/updateJob.js';
+import { getUpdateJobFunction } from './runJob/getUpdateJobFunction.js';
+import { importHandlerPath } from './runJob/importHandlerPath.js';
+import { runJob } from './runJob/index.js';
+import { runJSONJob } from './runJSONJob/index.js';
+export const runJobs = async (args)=>{
+    const { id, allQueues = false, limit = 10, overrideAccess, processingOrder, queue = 'default', req, req: { payload, payload: { config: { jobs: jobsConfig } } }, sequential, silent = false, where: whereFromProps } = args;
+    if (!overrideAccess) {
+        /**
+     * By default, jobsConfig.access.run will be `defaultAccess` which is a function that returns `true` if the user is logged in.
+     */ const accessFn = jobsConfig?.access?.run ?? (()=>true);
+        const hasAccess = await accessFn({
+            req
+        });
+        if (!hasAccess) {
+            throw new Forbidden(req.t);
+        }
+    }
+    const and = [
+        {
+            completedAt: {
+                exists: false
+            }
+        },
+        {
+            hasError: {
+                not_equals: true
+            }
+        },
+        {
+            processing: {
+                equals: false
+            }
+        },
+        {
+            or: [
+                {
+                    waitUntil: {
+                        exists: false
+                    }
+                },
+                {
+                    waitUntil: {
+                        less_than: getCurrentDate().toISOString()
+                    }
+                }
+            ]
+        }
+    ];
+    if (allQueues !== true) {
+        and.push({
+            queue: {
+                equals: queue ?? 'default'
+            }
+        });
+    }
+    if (whereFromProps) {
+        and.push(whereFromProps);
+    }
+    // Only enforce concurrency controls if the feature is enabled
+    if (jobsConfig.enableConcurrencyControl) {
+        // Find currently running jobs with concurrency keys to enforce exclusive concurrency
+        // Jobs with the same concurrencyKey should not run in parallel
+        const runningJobsWithConcurrency = await payload.db.find({
+            collection: jobsCollectionSlug,
+            limit: 0,
+            pagination: false,
+            req: {
+                transactionID: undefined
+            },
+            select: {
+                concurrencyKey: true
+            },
+            where: {
+                and: [
+                    {
+                        processing: {
+                            equals: true
+                        }
+                    },
+                    {
+                        concurrencyKey: {
+                            exists: true
+                        }
+                    }
+                ]
+            }
+        });
+        const runningConcurrencyKeys = new Set();
+        if (runningJobsWithConcurrency?.docs) {
+            for (const doc of runningJobsWithConcurrency.docs){
+                const concurrencyKey = doc.concurrencyKey;
+                if (concurrencyKey) {
+                    runningConcurrencyKeys.add(concurrencyKey);
+                }
+            }
+        }
+        // Exclude jobs whose concurrencyKey is already running
+        if (runningConcurrencyKeys.size > 0) {
+            and.push({
+                or: [
+                    // Jobs without a concurrency key can always run
+                    {
+                        concurrencyKey: {
+                            exists: false
+                        }
+                    },
+                    // Jobs with a concurrency key that is not currently running can run
+                    {
+                        concurrencyKey: {
+                            not_in: [
+                                ...runningConcurrencyKeys
+                            ]
+                        }
+                    }
+                ]
+            });
+        }
+    }
+    // Find all jobs and ensure we set job to processing: true as early as possible to reduce the chance of
+    // the same job being picked up by another worker
+    let jobs = [];
+    if (id) {
+        // Only one job to run
+        const job = await updateJob({
+            id,
+            data: {
+                processing: true
+            },
+            depth: jobsConfig.depth,
+            disableTransaction: true,
+            req,
+            returning: true
+        });
+        if (job) {
+            jobs = [
+                job
+            ];
+        }
+    } else {
+        let defaultProcessingOrder = payload.collections[jobsCollectionSlug]?.config.defaultSort ?? 'createdAt';
+        const processingOrderConfig = jobsConfig.processingOrder;
+        if (typeof processingOrderConfig === 'function') {
+            defaultProcessingOrder = await processingOrderConfig(args);
+        } else if (typeof processingOrderConfig === 'object' && !Array.isArray(processingOrderConfig)) {
+            if (!allQueues && queue && processingOrderConfig.queues && processingOrderConfig.queues[queue]) {
+                defaultProcessingOrder = processingOrderConfig.queues[queue];
+            } else if (processingOrderConfig.default) {
+                defaultProcessingOrder = processingOrderConfig.default;
+            }
+        } else if (typeof processingOrderConfig === 'string') {
+            defaultProcessingOrder = processingOrderConfig;
+        }
+        const updatedDocs = await updateJobs({
+            data: {
+                processing: true
+            },
+            depth: jobsConfig.depth,
+            disableTransaction: true,
+            limit,
+            req,
+            returning: true,
+            sort: processingOrder ?? defaultProcessingOrder,
+            where: {
+                and
+            }
+        });
+        if (updatedDocs) {
+            jobs = updatedDocs;
+        }
+    }
+    if (!jobs.length) {
+        return {
+            noJobsRemaining: true,
+            remainingJobsFromQueried: 0
+        };
+    }
+    // Only handle concurrency deduplication if the feature is enabled
+    if (jobsConfig.enableConcurrencyControl) {
+        // Handle the case where multiple jobs with the same concurrencyKey were picked up in the same batch
+        // We should only run one job per concurrencyKey, release the others back to pending
+        const seenConcurrencyKeys = new Set();
+        const jobsToRun = [];
+        const jobsToRelease = [];
+        for (const job of jobs){
+            if (job.concurrencyKey) {
+                if (seenConcurrencyKeys.has(job.concurrencyKey)) {
+                    // This job has the same concurrencyKey as another job we're already running
+                    jobsToRelease.push(job);
+                } else {
+                    seenConcurrencyKeys.add(job.concurrencyKey);
+                    jobsToRun.push(job);
+                }
+            } else {
+                jobsToRun.push(job);
+            }
+        }
+        // Release duplicate concurrencyKey jobs back to pending state
+        if (jobsToRelease.length > 0) {
+            const releaseIds = jobsToRelease.map((job)=>job.id);
+            await updateJobs({
+                data: {
+                    processing: false
+                },
+                disableTransaction: true,
+                req,
+                returning: false,
+                where: {
+                    id: {
+                        in: releaseIds
+                    }
+                }
+            });
+        }
+        // Use only the filtered jobs going forward
+        jobs = jobsToRun;
+    }
+    if (!jobs.length) {
+        return {
+            noJobsRemaining: false,
+            remainingJobsFromQueried: 0
+        };
+    }
+    /**
+   * Just for logging purposes, we want to know how many jobs are new and how many are existing (= already been tried).
+   * This is only for logs - in the end we still want to run all jobs, regardless of whether they are new or existing.
+   */ const { existingJobs, newJobs } = jobs.reduce((acc, job)=>{
+        if (job.totalTried > 0) {
+            acc.existingJobs.push(job);
+        } else {
+            acc.newJobs.push(job);
+        }
+        return acc;
+    }, {
+        existingJobs: [],
+        newJobs: []
+    });
+    if (!silent || typeof silent === 'object' && !silent.info) {
+        payload.logger.info({
+            msg: `Running ${jobs.length} jobs.`,
+            new: newJobs?.length,
+            retrying: existingJobs?.length
+        });
+    }
+    const successfullyCompletedJobs = [];
+    const runSingleJob = async (job)=>{
+        if (!job.workflowSlug && !job.taskSlug) {
+            throw new Error('Job must have either a workflowSlug or a taskSlug');
+        }
+        const jobReq = isolateObjectProperty(req, 'transactionID');
+        const workflowConfig = job.workflowSlug && jobsConfig.workflows?.length ? jobsConfig.workflows.find(({ slug })=>slug === job.workflowSlug) : {
+            slug: 'singleTask',
+            handler: async ({ job, tasks })=>{
+                await tasks[job.taskSlug]('1', {
+                    input: job.input
+                });
+            }
+        };
+        if (!workflowConfig) {
+            return {
+                id: job.id,
+                result: {
+                    status: 'error'
+                }
+            } // Skip jobs with no workflow configuration
+            ;
+        }
+        try {
+            const updateJob = getUpdateJobFunction(job, jobReq);
+            // the runner will either be passed to the config
+            // OR it will be a path, which we will need to import via eval to avoid
+            // Next.js compiler dynamic import expression errors
+            let workflowHandler;
+            if (typeof workflowConfig.handler === 'function' || typeof workflowConfig.handler === 'object' && Array.isArray(workflowConfig.handler)) {
+                workflowHandler = workflowConfig.handler;
+            } else {
+                workflowHandler = await importHandlerPath(workflowConfig.handler);
+                if (!workflowHandler) {
+                    const jobLabel = job.workflowSlug || `Task: ${job.taskSlug}`;
+                    const errorMessage = `Can't find runner while importing with the path ${workflowConfig.handler} in job type ${jobLabel}.`;
+                    if (!silent || typeof silent === 'object' && !silent.error) {
+                        payload.logger.error(errorMessage);
+                    }
+                    await updateJob({
+                        error: {
+                            error: errorMessage
+                        },
+                        hasError: true,
+                        processing: false
+                    });
+                    return {
+                        id: job.id,
+                        result: {
+                            status: 'error-reached-max-retries'
+                        }
+                    };
+                }
+            }
+            if (typeof workflowHandler === 'function') {
+                const result = await runJob({
+                    job,
+                    req: jobReq,
+                    silent,
+                    updateJob,
+                    workflowConfig,
+                    workflowHandler
+                });
+                if (result.status === 'success') {
+                    successfullyCompletedJobs.push(job.id);
+                }
+                return {
+                    id: job.id,
+                    result
+                };
+            } else {
+                const result = await runJSONJob({
+                    job,
+                    req: jobReq,
+                    silent,
+                    updateJob,
+                    workflowConfig,
+                    workflowHandler
+                });
+                if (result.status === 'success') {
+                    successfullyCompletedJobs.push(job.id);
+                }
+                return {
+                    id: job.id,
+                    result
+                };
+            }
+        } catch (error) {
+            if (error instanceof JobCancelledError) {
+                if (!job.error?.cancelled || !job.hasError || job.processing || job.completedAt || job.waitUntil) {
+                    // When using the local API to cancel jobs, the local API will update the job data for us to ensure the job is cancelled.
+                    // But when throwing a JobCancelledError within a task or workflow handler, we are responsible for updating the job data ourselves.
+                    await updateJob({
+                        id: job.id,
+                        data: {
+                            completedAt: null,
+                            error: {
+                                cancelled: true,
+                                message: error.message
+                            },
+                            hasError: true,
+                            processing: false,
+                            waitUntil: null
+                        },
+                        depth: 0,
+                        disableTransaction: true,
+                        req,
+                        returning: false
+                    });
+                }
+                return {
+                    id: job.id,
+                    result: {
+                        status: 'error-reached-max-retries'
+                    }
+                };
+            }
+            throw error;
+        }
+    };
+    let resultsArray = [];
+    if (sequential) {
+        for (const job of jobs){
+            const result = await runSingleJob(job);
+            if (result) {
+                resultsArray.push(result);
+            }
+        }
+    } else {
+        const jobPromises = jobs.map(runSingleJob);
+        resultsArray = await Promise.all(jobPromises);
+    }
+    if (jobsConfig.deleteJobOnComplete && successfullyCompletedJobs.length) {
+        try {
+            if (jobsConfig.runHooks) {
+                await payload.delete({
+                    collection: jobsCollectionSlug,
+                    depth: 0,
+                    disableTransaction: true,
+                    where: {
+                        id: {
+                            in: successfullyCompletedJobs
+                        }
+                    }
+                });
+            } else {
+                await payload.db.deleteMany({
+                    collection: jobsCollectionSlug,
+                    where: {
+                        id: {
+                            in: successfullyCompletedJobs
+                        }
+                    }
+                });
+            }
+        } catch (err) {
+            if (!silent || typeof silent === 'object' && !silent.error) {
+                payload.logger.error({
+                    err,
+                    msg: `Failed to delete jobs ${successfullyCompletedJobs.join(', ')} on complete`
+                });
+            }
+        }
+    }
+    const resultsObject = resultsArray.reduce((acc, cur)=>{
+        if (cur !== null) {
+            // Check if there's a valid result to include
+            acc[cur.id] = cur.result;
+        }
+        return acc;
+    }, {});
+    let remainingJobsFromQueried = 0;
+    for(const jobID in resultsObject){
+        const jobResult = resultsObject[jobID];
+        if (jobResult?.status === 'error') {
+            remainingJobsFromQueried++; // Can be retried
+        }
+    }
+    return {
+        jobStatus: resultsObject,
+        remainingJobsFromQueried
+    };
+};
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/queues/operations/runJobs/index.ts"],"sourcesContent":["import type { Job } from '../../../index.js'\nimport type { PayloadRequest, Sort, Where } from '../../../types/index.js'\nimport type { WorkflowJSON } from '../../config/types/workflowJSONTypes.js'\nimport type { WorkflowConfig, WorkflowHandler } from '../../config/types/workflowTypes.js'\nimport type { RunJobsSilent } from '../../localAPI.js'\nimport type { RunJobResult } from './runJob/index.js'\n\nimport { Forbidden } from '../../../errors/Forbidden.js'\nimport { isolateObjectProperty } from '../../../utilities/isolateObjectProperty.js'\nimport { jobsCollectionSlug } from '../../config/collection.js'\nimport { JobCancelledError } from '../../errors/index.js'\nimport { getCurrentDate } from '../../utilities/getCurrentDate.js'\nimport { updateJob, updateJobs } from '../../utilities/updateJob.js'\nimport { getUpdateJobFunction } from './runJob/getUpdateJobFunction.js'\nimport { importHandlerPath } from './runJob/importHandlerPath.js'\nimport { runJob } from './runJob/index.js'\nimport { runJSONJob } from './runJSONJob/index.js'\n\nexport type RunJobsArgs = {\n  /**\n   * If you want to run jobs from all queues, set this to true.\n   * If you set this to true, the `queue` property will be ignored.\n   *\n   * @default false\n   */\n  allQueues?: boolean\n  /**\n   * ID of the job to run\n   */\n  id?: number | string\n  /**\n   * The maximum number of jobs to run in this invocation\n   *\n   * @default 10\n   */\n  limit?: number\n  overrideAccess?: boolean\n  /**\n   * Adjust the job processing order\n   *\n   * FIFO would equal `createdAt` and LIFO would equal `-createdAt`.\n   *\n   * @default all jobs for all queues will be executed in FIFO order.\n   */\n  processingOrder?: Sort\n  /**\n   * If you want to run jobs from a specific queue, set this to the queue name.\n   *\n   * @default jobs from the `default` queue will be executed.\n   */\n  queue?: string\n  req: PayloadRequest\n  /**\n   * By default, jobs are run in parallel.\n   * If you want to run them in sequence, set this to true.\n   */\n  sequential?: boolean\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  where?: Where\n}\n\nexport type RunJobsResult = {\n  jobStatus?: Record<string, RunJobResult>\n  /**\n   * If this is true, there for sure are no jobs remaining, regardless of the limit\n   */\n  noJobsRemaining?: boolean\n  /**\n   * Out of the jobs that were queried & processed (within the set limit), how many are remaining and retryable?\n   */\n  remainingJobsFromQueried: number\n}\n\nexport const runJobs = async (args: RunJobsArgs): Promise<RunJobsResult> => {\n  const {\n    id,\n    allQueues = false,\n    limit = 10,\n    overrideAccess,\n    processingOrder,\n    queue = 'default',\n    req,\n    req: {\n      payload,\n      payload: {\n        config: { jobs: jobsConfig },\n      },\n    },\n    sequential,\n    silent = false,\n    where: whereFromProps,\n  } = args\n\n  if (!overrideAccess) {\n    /**\n     * By default, jobsConfig.access.run will be `defaultAccess` which is a function that returns `true` if the user is logged in.\n     */\n    const accessFn = jobsConfig?.access?.run ?? (() => true)\n    const hasAccess = await accessFn({ req })\n    if (!hasAccess) {\n      throw new Forbidden(req.t)\n    }\n  }\n  const and: Where[] = [\n    {\n      completedAt: {\n        exists: false,\n      },\n    },\n    {\n      hasError: {\n        not_equals: true,\n      },\n    },\n    {\n      processing: {\n        equals: false,\n      },\n    },\n    {\n      or: [\n        {\n          waitUntil: {\n            exists: false,\n          },\n        },\n        {\n          waitUntil: {\n            less_than: getCurrentDate().toISOString(),\n          },\n        },\n      ],\n    },\n  ]\n\n  if (allQueues !== true) {\n    and.push({\n      queue: {\n        equals: queue ?? 'default',\n      },\n    })\n  }\n\n  if (whereFromProps) {\n    and.push(whereFromProps)\n  }\n\n  // Only enforce concurrency controls if the feature is enabled\n  if (jobsConfig.enableConcurrencyControl) {\n    // Find currently running jobs with concurrency keys to enforce exclusive concurrency\n    // Jobs with the same concurrencyKey should not run in parallel\n    const runningJobsWithConcurrency = await payload.db.find({\n      collection: jobsCollectionSlug,\n      limit: 0,\n      pagination: false,\n      req: { transactionID: undefined },\n      select: {\n        concurrencyKey: true,\n      },\n      where: {\n        and: [{ processing: { equals: true } }, { concurrencyKey: { exists: true } }],\n      },\n    })\n\n    const runningConcurrencyKeys = new Set<string>()\n    if (runningJobsWithConcurrency?.docs) {\n      for (const doc of runningJobsWithConcurrency.docs) {\n        const concurrencyKey = (doc as Job).concurrencyKey\n        if (concurrencyKey) {\n          runningConcurrencyKeys.add(concurrencyKey)\n        }\n      }\n    }\n\n    // Exclude jobs whose concurrencyKey is already running\n    if (runningConcurrencyKeys.size > 0) {\n      and.push({\n        or: [\n          // Jobs without a concurrency key can always run\n          { concurrencyKey: { exists: false } },\n          // Jobs with a concurrency key that is not currently running can run\n          { concurrencyKey: { not_in: [...runningConcurrencyKeys] } },\n        ],\n      })\n    }\n  }\n\n  // Find all jobs and ensure we set job to processing: true as early as possible to reduce the chance of\n  // the same job being picked up by another worker\n  let jobs: Job[] = []\n\n  if (id) {\n    // Only one job to run\n    const job = await updateJob({\n      id,\n      data: {\n        processing: true,\n      },\n      depth: jobsConfig.depth,\n      disableTransaction: true,\n      req,\n      returning: true,\n    })\n    if (job) {\n      jobs = [job]\n    }\n  } else {\n    let defaultProcessingOrder: Sort =\n      payload.collections[jobsCollectionSlug]?.config.defaultSort ?? 'createdAt'\n\n    const processingOrderConfig = jobsConfig.processingOrder\n    if (typeof processingOrderConfig === 'function') {\n      defaultProcessingOrder = await processingOrderConfig(args)\n    } else if (typeof processingOrderConfig === 'object' && !Array.isArray(processingOrderConfig)) {\n      if (\n        !allQueues &&\n        queue &&\n        processingOrderConfig.queues &&\n        processingOrderConfig.queues[queue]\n      ) {\n        defaultProcessingOrder = processingOrderConfig.queues[queue]\n      } else if (processingOrderConfig.default) {\n        defaultProcessingOrder = processingOrderConfig.default\n      }\n    } else if (typeof processingOrderConfig === 'string') {\n      defaultProcessingOrder = processingOrderConfig\n    }\n    const updatedDocs = await updateJobs({\n      data: {\n        processing: true,\n      },\n      depth: jobsConfig.depth,\n      disableTransaction: true,\n      limit,\n      req,\n      returning: true,\n      sort: processingOrder ?? defaultProcessingOrder,\n      where: { and },\n    })\n\n    if (updatedDocs) {\n      jobs = updatedDocs\n    }\n  }\n\n  if (!jobs.length) {\n    return {\n      noJobsRemaining: true,\n      remainingJobsFromQueried: 0,\n    }\n  }\n\n  // Only handle concurrency deduplication if the feature is enabled\n  if (jobsConfig.enableConcurrencyControl) {\n    // Handle the case where multiple jobs with the same concurrencyKey were picked up in the same batch\n    // We should only run one job per concurrencyKey, release the others back to pending\n    const seenConcurrencyKeys = new Set<string>()\n    const jobsToRun: Job[] = []\n    const jobsToRelease: Job[] = []\n\n    for (const job of jobs) {\n      if (job.concurrencyKey) {\n        if (seenConcurrencyKeys.has(job.concurrencyKey)) {\n          // This job has the same concurrencyKey as another job we're already running\n          jobsToRelease.push(job)\n        } else {\n          seenConcurrencyKeys.add(job.concurrencyKey)\n          jobsToRun.push(job)\n        }\n      } else {\n        jobsToRun.push(job)\n      }\n    }\n\n    // Release duplicate concurrencyKey jobs back to pending state\n    if (jobsToRelease.length > 0) {\n      const releaseIds = jobsToRelease.map((job) => job.id)\n      await updateJobs({\n        data: { processing: false },\n        disableTransaction: true,\n        req,\n        returning: false,\n        where: { id: { in: releaseIds } },\n      })\n    }\n\n    // Use only the filtered jobs going forward\n    jobs = jobsToRun\n  }\n\n  if (!jobs.length) {\n    return {\n      noJobsRemaining: false,\n      remainingJobsFromQueried: 0,\n    }\n  }\n\n  /**\n   * Just for logging purposes, we want to know how many jobs are new and how many are existing (= already been tried).\n   * This is only for logs - in the end we still want to run all jobs, regardless of whether they are new or existing.\n   */\n  const { existingJobs, newJobs } = jobs.reduce(\n    (acc, job) => {\n      if (job.totalTried > 0) {\n        acc.existingJobs.push(job)\n      } else {\n        acc.newJobs.push(job)\n      }\n      return acc\n    },\n    { existingJobs: [] as Job[], newJobs: [] as Job[] },\n  )\n\n  if (!silent || (typeof silent === 'object' && !silent.info)) {\n    payload.logger.info({\n      msg: `Running ${jobs.length} jobs.`,\n      new: newJobs?.length,\n      retrying: existingJobs?.length,\n    })\n  }\n\n  const successfullyCompletedJobs: (number | string)[] = []\n\n  const runSingleJob = async (\n    job: Job,\n  ): Promise<{\n    id: number | string\n    result: RunJobResult\n  }> => {\n    if (!job.workflowSlug && !job.taskSlug) {\n      throw new Error('Job must have either a workflowSlug or a taskSlug')\n    }\n    const jobReq = isolateObjectProperty(req, 'transactionID')\n\n    const workflowConfig: WorkflowConfig =\n      job.workflowSlug && jobsConfig.workflows?.length\n        ? jobsConfig.workflows.find(({ slug }) => slug === job.workflowSlug)!\n        : {\n            slug: 'singleTask',\n            handler: async ({ job, tasks }) => {\n              await tasks[job.taskSlug as string]!('1', {\n                input: job.input,\n              })\n            },\n          }\n\n    if (!workflowConfig) {\n      return {\n        id: job.id,\n        result: {\n          status: 'error',\n        },\n      } // Skip jobs with no workflow configuration\n    }\n\n    try {\n      const updateJob = getUpdateJobFunction(job, jobReq)\n\n      // the runner will either be passed to the config\n      // OR it will be a path, which we will need to import via eval to avoid\n      // Next.js compiler dynamic import expression errors\n      let workflowHandler: WorkflowHandler | WorkflowJSON\n      if (\n        typeof workflowConfig.handler === 'function' ||\n        (typeof workflowConfig.handler === 'object' && Array.isArray(workflowConfig.handler))\n      ) {\n        workflowHandler = workflowConfig.handler\n      } else {\n        workflowHandler = await importHandlerPath<typeof workflowHandler>(workflowConfig.handler)\n\n        if (!workflowHandler) {\n          const jobLabel = job.workflowSlug || `Task: ${job.taskSlug}`\n          const errorMessage = `Can't find runner while importing with the path ${workflowConfig.handler} in job type ${jobLabel}.`\n          if (!silent || (typeof silent === 'object' && !silent.error)) {\n            payload.logger.error(errorMessage)\n          }\n\n          await updateJob({\n            error: {\n              error: errorMessage,\n            },\n            hasError: true,\n            processing: false,\n          })\n\n          return {\n            id: job.id,\n            result: {\n              status: 'error-reached-max-retries',\n            },\n          }\n        }\n      }\n\n      if (typeof workflowHandler === 'function') {\n        const result = await runJob({\n          job,\n          req: jobReq,\n          silent,\n          updateJob,\n          workflowConfig,\n          workflowHandler,\n        })\n\n        if (result.status === 'success') {\n          successfullyCompletedJobs.push(job.id)\n        }\n\n        return { id: job.id, result }\n      } else {\n        const result = await runJSONJob({\n          job,\n          req: jobReq,\n          silent,\n          updateJob,\n          workflowConfig,\n          workflowHandler,\n        })\n\n        if (result.status === 'success') {\n          successfullyCompletedJobs.push(job.id)\n        }\n\n        return { id: job.id, result }\n      }\n    } catch (error) {\n      if (error instanceof JobCancelledError) {\n        if (\n          !(job.error as Record<string, unknown> | undefined)?.cancelled ||\n          !job.hasError ||\n          job.processing ||\n          job.completedAt ||\n          job.waitUntil\n        ) {\n          // When using the local API to cancel jobs, the local API will update the job data for us to ensure the job is cancelled.\n          // But when throwing a JobCancelledError within a task or workflow handler, we are responsible for updating the job data ourselves.\n          await updateJob({\n            id: job.id,\n            data: {\n              completedAt: null,\n              error: {\n                cancelled: true,\n                message: error.message,\n              },\n              hasError: true,\n              processing: false,\n              waitUntil: null,\n            },\n            depth: 0,\n            disableTransaction: true,\n            req,\n            returning: false,\n          })\n        }\n\n        return {\n          id: job.id,\n          result: {\n            status: 'error-reached-max-retries',\n          },\n        }\n      }\n      throw error\n    }\n  }\n\n  let resultsArray: { id: number | string; result: RunJobResult }[] = []\n  if (sequential) {\n    for (const job of jobs) {\n      const result = await runSingleJob(job)\n      if (result) {\n        resultsArray.push(result)\n      }\n    }\n  } else {\n    const jobPromises = jobs.map(runSingleJob)\n    resultsArray = (await Promise.all(jobPromises)) as {\n      id: number | string\n      result: RunJobResult\n    }[]\n  }\n\n  if (jobsConfig.deleteJobOnComplete && successfullyCompletedJobs.length) {\n    try {\n      if (jobsConfig.runHooks) {\n        await payload.delete({\n          collection: jobsCollectionSlug,\n          depth: 0, // can be 0 since we're not returning anything\n          disableTransaction: true,\n          where: { id: { in: successfullyCompletedJobs } },\n        })\n      } else {\n        await payload.db.deleteMany({\n          collection: jobsCollectionSlug,\n          where: { id: { in: successfullyCompletedJobs } },\n        })\n      }\n    } catch (err) {\n      if (!silent || (typeof silent === 'object' && !silent.error)) {\n        payload.logger.error({\n          err,\n          msg: `Failed to delete jobs ${successfullyCompletedJobs.join(', ')} on complete`,\n        })\n      }\n    }\n  }\n\n  const resultsObject: RunJobsResult['jobStatus'] = resultsArray.reduce(\n    (acc, cur) => {\n      if (cur !== null) {\n        // Check if there's a valid result to include\n        acc[cur.id] = cur.result\n      }\n      return acc\n    },\n    {} as Record<string, RunJobResult>,\n  )\n\n  let remainingJobsFromQueried = 0\n  for (const jobID in resultsObject) {\n    const jobResult = resultsObject[jobID]\n    if (jobResult?.status === 'error') {\n      remainingJobsFromQueried++ // Can be retried\n    }\n  }\n\n  return {\n    jobStatus: resultsObject,\n    remainingJobsFromQueried,\n  }\n}\n"],"names":["Forbidden","isolateObjectProperty","jobsCollectionSlug","JobCancelledError","getCurrentDate","updateJob","updateJobs","getUpdateJobFunction","importHandlerPath","runJob","runJSONJob","runJobs","args","id","allQueues","limit","overrideAccess","processingOrder","queue","req","payload","config","jobs","jobsConfig","sequential","silent","where","whereFromProps","accessFn","access","run","hasAccess","t","and","completedAt","exists","hasError","not_equals","processing","equals","or","waitUntil","less_than","toISOString","push","enableConcurrencyControl","runningJobsWithConcurrency","db","find","collection","pagination","transactionID","undefined","select","concurrencyKey","runningConcurrencyKeys","Set","docs","doc","add","size","not_in","job","data","depth","disableTransaction","returning","defaultProcessingOrder","collections","defaultSort","processingOrderConfig","Array","isArray","queues","default","updatedDocs","sort","length","noJobsRemaining","remainingJobsFromQueried","seenConcurrencyKeys","jobsToRun","jobsToRelease","has","releaseIds","map","in","existingJobs","newJobs","reduce","acc","totalTried","info","logger","msg","new","retrying","successfullyCompletedJobs","runSingleJob","workflowSlug","taskSlug","Error","jobReq","workflowConfig","workflows","slug","handler","tasks","input","result","status","workflowHandler","jobLabel","errorMessage","error","cancelled","message","resultsArray","jobPromises","Promise","all","deleteJobOnComplete","runHooks","delete","deleteMany","err","join","resultsObject","cur","jobID","jobResult","jobStatus"],"mappings":"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"}

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

@@ -0,0 +1,29 @@
+import type { Job } from '../../../../index.js';
+import type { PayloadRequest } from '../../../../types/index.js';
+import type { WorkflowJSON } from '../../../config/types/workflowJSONTypes.js';
+import type { WorkflowConfig } from '../../../config/types/workflowTypes.js';
+import type { RunJobsSilent } from '../../../localAPI.js';
+import type { UpdateJobFunction } from '../runJob/getUpdateJobFunction.js';
+import type { JobRunStatus } from '../runJob/index.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: WorkflowJSON;
+};
+export type RunJSONJobResult = {
+    status: JobRunStatus;
+};
+export declare const runJSONJob: ({ job, req, silent, updateJob, workflowConfig, workflowHandler, }: Args) => Promise<RunJSONJobResult>;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/queues/operations/runJobs/runJSONJob/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,YAAY,EAAgB,MAAM,4CAA4C,CAAA;AAC5F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAOtD,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,YAAY,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,YAAY,CAAA;CACrB,CAAA;AAED,eAAO,MAAM,UAAU,sEAOpB,IAAI,KAAG,OAAO,CAAC,gBAAgB,CAuGjC,CAAA"}

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

@@ -0,0 +1,98 @@
+import { handleWorkflowError } from '../../../errors/handleWorkflowError.js';
+import { WorkflowError } from '../../../errors/index.js';
+import { getCurrentDate } from '../../../utilities/getCurrentDate.js';
+import { getRunTaskFunction } from '../runJob/getRunTaskFunction.js';
+export const runJSONJob = async ({ job, req, silent = false, updateJob, workflowConfig, workflowHandler })=>{
+    const stepsToRun = [];
+    for (const step of workflowHandler){
+        if ('task' in step) {
+            if (job?.taskStatus?.[step.task]?.[step.id]?.complete) {
+                continue;
+            }
+        } else {
+            if (job?.taskStatus?.['inline']?.[step.id]?.complete) {
+                continue;
+            }
+        }
+        if (step.condition && !step.condition({
+            job
+        })) {
+            continue;
+        }
+        stepsToRun.push(step);
+    }
+    const tasks = getRunTaskFunction(job, workflowConfig, req, false, updateJob);
+    const inlineTask = getRunTaskFunction(job, workflowConfig, req, true, updateJob);
+    // Run the job
+    try {
+        await Promise.all(stepsToRun.map(async (step)=>{
+            if ('task' in step) {
+                await tasks[step.task](step.id, {
+                    input: step.input ? step.input({
+                        job
+                    }) : {},
+                    retries: step.retries
+                });
+            } else {
+                await inlineTask(step.id, {
+                    retries: step.retries,
+                    task: step.inlineTask
+                });
+            }
+        }));
+    } catch (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
+            }),
+            silent,
+            req,
+            updateJob
+        });
+        return {
+            status: hasFinalError ? 'error-reached-max-retries' : 'error'
+        };
+    }
+    // Check if workflow has completed
+    let workflowCompleted = false;
+    for (const [slug, map] of Object.entries(job.taskStatus)){
+        for (const [id, taskStatus] of Object.entries(map)){
+            if (taskStatus.complete) {
+                const step = workflowHandler.find((step)=>{
+                    if ('task' in step) {
+                        return step.task === slug && step.id === id;
+                    } else {
+                        return step.id === id && slug === 'inline';
+                    }
+                });
+                if (step?.completesJob) {
+                    workflowCompleted = true;
+                    break;
+                }
+            }
+        }
+    }
+    if (workflowCompleted) {
+        await updateJob({
+            completedAt: getCurrentDate().toISOString(),
+            processing: false,
+            totalTried: (job.totalTried ?? 0) + 1
+        });
+        return {
+            status: 'success'
+        };
+    } else {
+        // Retry the job - no need to bump processing or totalTried as this does not count as a retry. A condition of a different task might have just opened up!
+        return await runJSONJob({
+            job,
+            req,
+            updateJob,
+            workflowConfig,
+            workflowHandler
+        });
+    }
+};
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/queues/operations/runJobs/runJSONJob/index.ts"],"sourcesContent":["import type { Job } from '../../../../index.js'\nimport type { PayloadRequest } from '../../../../types/index.js'\nimport type { WorkflowJSON, WorkflowStep } from '../../../config/types/workflowJSONTypes.js'\nimport type { WorkflowConfig } from '../../../config/types/workflowTypes.js'\nimport type { RunJobsSilent } from '../../../localAPI.js'\nimport type { UpdateJobFunction } from '../runJob/getUpdateJobFunction.js'\nimport type { JobRunStatus } from '../runJob/index.js'\n\nimport { handleWorkflowError } from '../../../errors/handleWorkflowError.js'\nimport { WorkflowError } from '../../../errors/index.js'\nimport { getCurrentDate } from '../../../utilities/getCurrentDate.js'\nimport { getRunTaskFunction } from '../runJob/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: WorkflowJSON\n}\n\nexport type RunJSONJobResult = {\n  status: JobRunStatus\n}\n\nexport const runJSONJob = async ({\n  job,\n  req,\n  silent = false,\n  updateJob,\n  workflowConfig,\n  workflowHandler,\n}: Args): Promise<RunJSONJobResult> => {\n  const stepsToRun: WorkflowStep<string>[] = []\n\n  for (const step of workflowHandler) {\n    if ('task' in step) {\n      if (job?.taskStatus?.[step.task]?.[step.id]?.complete) {\n        continue\n      }\n    } else {\n      if (job?.taskStatus?.['inline']?.[step.id]?.complete) {\n        continue\n      }\n    }\n    if (step.condition && !step.condition({ job })) {\n      continue\n    }\n    stepsToRun.push(step)\n  }\n\n  const tasks = getRunTaskFunction(job, workflowConfig, req, false, updateJob)\n  const inlineTask = getRunTaskFunction(job, workflowConfig, req, true, updateJob)\n\n  // Run the job\n  try {\n    await Promise.all(\n      stepsToRun.map(async (step) => {\n        if ('task' in step) {\n          await tasks[step.task]!(step.id, {\n            input: step.input ? step.input({ job }) : {},\n            retries: step.retries,\n          })\n        } else {\n          await inlineTask(step.id, {\n            retries: step.retries,\n            task: step.inlineTask as any, // TODO: Fix type\n          })\n        }\n      }),\n    )\n  } catch (error) {\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      silent,\n\n      req,\n      updateJob,\n    })\n\n    return {\n      status: hasFinalError ? 'error-reached-max-retries' : 'error',\n    }\n  }\n\n  // Check if workflow has completed\n  let workflowCompleted = false\n  for (const [slug, map] of Object.entries(job.taskStatus)) {\n    for (const [id, taskStatus] of Object.entries(map)) {\n      if (taskStatus.complete) {\n        const step = workflowHandler.find((step) => {\n          if ('task' in step) {\n            return step.task === slug && step.id === id\n          } else {\n            return step.id === id && slug === 'inline'\n          }\n        })\n        if (step?.completesJob) {\n          workflowCompleted = true\n          break\n        }\n      }\n    }\n  }\n\n  if (workflowCompleted) {\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  } else {\n    // Retry the job - no need to bump processing or totalTried as this does not count as a retry. A condition of a different task might have just opened up!\n    return await runJSONJob({\n      job,\n      req,\n      updateJob,\n      workflowConfig,\n      workflowHandler,\n    })\n  }\n}\n"],"names":["handleWorkflowError","WorkflowError","getCurrentDate","getRunTaskFunction","runJSONJob","job","req","silent","updateJob","workflowConfig","workflowHandler","stepsToRun","step","taskStatus","task","id","complete","condition","push","tasks","inlineTask","Promise","all","map","input","retries","error","hasFinalError","message","status","workflowCompleted","slug","Object","entries","find","completesJob","completedAt","toISOString","processing","totalTried"],"mappings":"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"}

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

@@ -0,0 +1,11 @@
+import type { Job } from '../../../../index.js';
+import type { PayloadRequest } from '../../../../types/index.js';
+import type { RunInlineTaskFunction, RunTaskFunctions } from '../../../config/types/taskTypes.js';
+import type { WorkflowConfig } from '../../../config/types/workflowTypes.js';
+import type { UpdateJobFunction } from './getUpdateJobFunction.js';
+export type TaskParent = {
+    taskID: string;
+    taskSlug: string;
+};
+export declare const getRunTaskFunction: <TIsInline extends boolean>(job: Job, workflowConfig: WorkflowConfig, req: PayloadRequest, isInline: TIsInline, updateJob: UpdateJobFunction, parent?: TaskParent) => 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":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAA;AAC/C,OAAO,KAAK,EAAc,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAC5E,OAAO,KAAK,EAEV,qBAAqB,EAErB,gBAAgB,EAKjB,MAAM,oCAAoC,CAAA;AAC3C,OAAO,KAAK,EAGV,cAAc,EAEf,MAAM,wCAAwC,CAAA;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAQlE,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,SAAS,SAAS,OAAO,OACrD,GAAG,kBACQ,cAAc,OACzB,cAAc,YACT,SAAS,aACR,iBAAiB,WACnB,UAAU,KAClB,SAAS,SAAS,IAAI,GAAG,qBAAqB,GAAG,gBA4LnD,CAAA"}