@focus-reactive/payload-plugin-translator 0.11.1 → 0.11.3

package/README.md

@@ -618,6 +618,40 @@ Payload lets a wrapper field (group, array, blocks, tabs) be `localized`, which
 
 See the `deleteJobOnComplete: false` note under [Runners](#createpayloadjobsrunneroptions-recommended).
 
+Keeping them means they accumulate: nothing in the plugin removes a completed translation job, and the
+status panels read a collection's jobs on every open. How long that history is worth keeping is your
+call, not the plugin's, so pruning is left to you — the same way `deleteJobOnComplete` is.
+
+_Applies only to `createPayloadJobsRunner`._ `createSyncRunner` translates inline and writes no jobs at
+all, so there is nothing to prune.
+
+```ts
+// Run from your own cron / scheduled task.
+// Must match the `taskName` you passed to createPayloadJobsRunner — "translate_document" by default.
+const TRANSLATOR_TASK = "translate_document";
+
+const cutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+
+await payload.delete({
+  collection: "payload-jobs",
+  where: {
+    and: [
+      { taskSlug: { equals: TRANSLATOR_TASK } },
+      { completedAt: { exists: true } },
+      { completedAt: { less_than: cutoff } },
+    ],
+  },
+});
+```
+
+Three things the clauses buy you, in order: only this plugin's jobs, only finished ones — so nothing
+queued or in flight is touched — and only those older than your cutoff, so a run someone may still want
+to look at survives. Keep a cutoff of at least a day for that last reason; deleting everything
+completed would erase a translation that finished minutes ago.
+
+All three filter on real columns rather than paths inside the job's JSON input, so this behaves the same
+on SQLite, Postgres and MongoDB.
+
 ## TypeScript
 
 The package ships its types. Besides the factories, the following are exported for typing your own code:

package/dist/index.d.ts

@@ -11,8 +11,8 @@ export { createTranslationProvider } from "./translation-providers";
 export type { CompletionFn, CompletionRequest, TranslationProviderConfig, JsonSchemaObject, SystemPromptBuilder, SystemPromptContext, } from "./translation-providers";
 export { TranslationProviderError, NoContentError, UnparseableReplyError, KeySetMismatchError, TransportError, ProviderConfigurationError, } from "./translation-providers";
 export type { TranslationFailureCode } from "./translation-providers";
-export { createPayloadJobsRunner, createSyncRunner } from "./server/modules/task-runner";
-export type { TaskRunnerProvider, PayloadJobsRunnerOptions } from "./server/modules/task-runner";
+export { createPayloadJobsRunner, createSyncRunner, toTaskFilter, } from "./server/modules/task-runner";
+export type { TaskRunnerProvider, PayloadJobsRunnerOptions, TaskFilter, } from "./server/modules/task-runner";
 export { documentLevel, collectionLevel, fieldLevel } from "./composition/levels";
 export type { TranslationLevel } from "./server/modules/translation-levels";
 export { withFieldTranslation } from "./field-config";

package/dist/index.js

@@ -4,7 +4,7 @@ export { openAIComplete } from "./translation-providers";
 export { createTranslationProvider } from "./translation-providers";
 export { TranslationProviderError, NoContentError, UnparseableReplyError, KeySetMismatchError, TransportError, ProviderConfigurationError } from "./translation-providers";
 // Task runners
-export { createPayloadJobsRunner, createSyncRunner } from "./server/modules/task-runner";
+export { createPayloadJobsRunner, createSyncRunner, toTaskFilter } from "./server/modules/task-runner";
 // Translation levels
 export { documentLevel, collectionLevel, fieldLevel } from "./composition/levels";
 // Field config

package/dist/server/modules/lifecycle/withQueuedNotification.js

@@ -1,3 +1,4 @@
+import { toTaskFilter } from "../task-runner/toTaskFilter";
 import { taskFromInput } from "./taskMapping";
 /**
  * Decorate a {@link TaskRunner} so `enqueue` fires the `queued` lifecycle callback for each task.
@@ -12,7 +13,9 @@ import { taskFromInput } from "./taskMapping";
         },
         cancel: (taskIds)=>runner.cancel(taskIds),
         run: (taskId)=>runner.run(taskId),
-        findByCollection: (collectionSlug, documentIds)=>runner.findByCollection(collectionSlug, documentIds)
+        // Normalized rather than forwarded as-is: the wrapper's own signature comes from the overload
+        // pair, so it cannot pass the deprecated array form straight through.
+        findByCollection: (collectionSlug, filter)=>runner.findByCollection(collectionSlug, toTaskFilter(filter))
     };
 }
 

package/dist/server/modules/task-runner/TaskRunner.interface.d.ts

@@ -24,7 +24,25 @@ export interface TaskRunner {
      */
     run(taskId: string): Promise<RunResult>;
     /**
-     * Find tasks by collection and optionally filter by document IDs.
+     * @deprecated Pass `{ documentIds }` instead. Removed in the next major.
+     * See docs/DEPRECATIONS.md#find-by-collection-document-ids-array
      */
-    findByCollection(collectionSlug: CollectionSlug, documentIds?: Array<string | number>): Promise<Task[]>;
+    findByCollection(collectionSlug: CollectionSlug, documentIds: Array<string | number>): Promise<Task[]>;
+    /** Find tasks for a collection, optionally narrowed by a {@link TaskFilter}. */
+    findByCollection(collectionSlug: CollectionSlug, filter?: TaskFilter): Promise<Task[]>;
 }
+/**
+ * How a {@link TaskRunner.findByCollection} call is narrowed. Each field says whether it reaches the
+ * database or is applied in memory over everything the database returned.
+ *
+ * @since 0.11.2
+ */
+export type TaskFilter = {
+    /** Keep only tasks for these documents. Applied in memory — see `PayloadJobsTaskRunner.findByCollection`. */
+    documentIds?: Array<string | number>;
+    /**
+     * Drop tasks that have finished. Keeps running and failed ones — everything a re-enqueue can still
+     * supersede — so it is wider than the `pending` status.
+     */
+    excludeCompleted?: boolean;
+};

package/dist/server/modules/task-runner/TaskRunner.interface.js

@@ -1,10 +1,8 @@
 /**
- * Interface for task execution backends.
+ * How a {@link TaskRunner.findByCollection} call is narrowed. Each field says whether it reaches the
+ * database or is applied in memory over everything the database returned.
  *
- * Implementations handle queuing, cancellation, status tracking,
- * and execution of translation tasks. All business logic
- * (like cancelling existing tasks before enqueue) is encapsulated
- * within the implementation.
+ * @since 0.11.2
  */ export { };
 
 //# sourceMappingURL=TaskRunner.interface.js.map

package/dist/server/modules/task-runner/index.d.ts

@@ -3,4 +3,5 @@ export type { Task, TaskStatus } from "./types";
 export { createPayloadJobsRunner } from "./payload-jobs-runner";
 export type { PayloadJobsRunnerOptions } from "./payload-jobs-runner";
 export { createSyncRunner } from "./sync-runner";
-export type { TaskRunner } from "./TaskRunner.interface";
+export type { TaskFilter, TaskRunner } from "./TaskRunner.interface";
+export { toTaskFilter } from "./toTaskFilter";

package/dist/server/modules/task-runner/index.js

@@ -1,4 +1,5 @@
 export { createPayloadJobsRunner } from "./payload-jobs-runner";
 export { createSyncRunner } from "./sync-runner";
+export { toTaskFilter } from "./toTaskFilter";
 
 //# sourceMappingURL=index.js.map

package/dist/server/modules/task-runner/payload-jobs-runner/PayloadJobsTaskRunner.d.ts

@@ -1,5 +1,5 @@
 import type { Payload, CollectionSlug } from "payload";
-import type { TaskRunner } from "../TaskRunner.interface";
+import type { TaskFilter, TaskRunner } from "../TaskRunner.interface";
 import type { Task, TaskInput, RunResult } from "../types";
 import type { PayloadJobsRunnerConfig } from "./types";
 /**
@@ -15,87 +15,26 @@ export declare class PayloadJobsTaskRunner implements TaskRunner {
     cancel(taskIds: string[]): Promise<void>;
     run(taskId: string): Promise<RunResult>;
     /**
-     * Reset stale processing locks so abandoned jobs become eligible for the
-     * autorun picker again. The picker requires processing:false, no error, and
-     * no pending waitUntil; a job abandoned mid-run (no error, no waitUntil)
-     * satisfies the rest, so clearing processing is sufficient for that case.
-     * A job that already exhausted retries (hasError:true) stays excluded from
-     * autorun and is only recoverable via a manual run().
-     *
-     * A job is stale when it is still `processing: true`, not yet completed, and
-     * its `updatedAt` is older than `staleJobTimeoutMs` — i.e. a process was
-     * killed mid-run (deploy/crash/timeout). Threshold-based, so a job genuinely
-     * in flight on another live instance (fresh `updatedAt`) is left alone.
-     * Filters on real `payload-jobs` columns only (no JSON-path traversal), so
-     * the drizzle SQLite issue in `findByCollection` does not apply here.
-     * @returns the number of jobs reclaimed.
+     * Clear stale `processing` locks — still processing, not completed, `updatedAt` older than
+     * `staleJobTimeoutMs` — so abandoned jobs are eligible for the autorun picker again. A job that
+     * exhausted its retries carries `hasError: true` and stays excluded from autorun even after its
+     * lock is cleared; only a manual `run()` recovers it.
+     * @returns how many locks were cleared.
      */
     reclaimStaleJobs(): Promise<number>;
-    /**
-     * Clear the `processing` lock on every job matching `where`, returning how
-     * many were reset. Shared by the per-job reset in `run()` (a stale lock) and
-     * the bulk boot/recovery reset in `reclaimStaleJobs()`. `depth: 0` because
-     * only the count is needed — no relationships to populate.
-     */
+    /** Clears the `processing` lock on every job matching `where`. `depth: 0` — only the count is read. */
     private resetProcessing;
-    /**
-     * A processing lock is stale once `updatedAt` is older than the configured
-     * timeout — the owning run is presumed dead.
-     */
     private isStale;
     /**
-     * Find translation jobs for a collection, optionally narrowed by document IDs.
-     *
-     * Narrowing is by `taskSlug` only in SQL; the collection slug and document
-     * IDs are matched in memory (via the normalized `Task`, which reads both the
-     * current flat-text shape and the legacy relationship shape). This is the
-     * one path that must transparently span both stored shapes during the
-     * ID-agnostic migration — see docs/DEPRECATIONS.md#jobs-input-collection-field.
-     *
-     * IMPORTANT — why slug/id are matched in memory, not in the SQL WHERE
-     * ------------------------------------------------------------------------
-     * The "natural" implementation would push `input.collection_id` into the
-     * where clause. This DOES NOT work on SQLite (and is unreliable on any
-     * adapter) because of two compounding bugs in Payload's drizzle layer.
-     *
-     * 1. The `input` field on `payload-jobs` is declared `type: 'json'`. The
-     *    drizzle path resolver (`@payloadcms/drizzle/queries/getTableColumnFromPath`)
-     *    has no `case 'json'` branch, so the value is left as a raw column and
-     *    the path segments are passed through to `parseParams.js`, which on
-     *    SQLite builds raw SQL using `convertPathToJSONTraversal` — generating
-     *    expressions like `input->>'collection_id'`.
+     * Find translation jobs for a collection.
      *
-     * 2. When `parseParams.js` formats the right-hand side of `in`/`not_in`
-     *    (and even `equals` when `!isNaN(val)`), it inlines values via JS
-     *    template literals WITHOUT wrapping strings in quotes. The string
-     *    `'1'` from our WHERE becomes raw `1` in the SQL. Drizzle therefore
-     *    emits queries like `WHERE input->>'collection_id' IN (1)` even though
-     *    the caller passed `['1']` (an array of strings).
-     *
-     * On SQLite, `->>` preserves the JSON value's type and `IN (...)` does NOT
-     * coerce between TEXT and INTEGER, so a numeric-looking string id never
-     * matches once bug #2 strips its quotes. Storing the id as text (this
-     * migration) does not fix the SQL path — drizzle re-numbers it anyway — so
-     * we keep matching in memory.
-     *
-     * Why in-memory filtering is acceptable here
-     * ------------------------------------------
-     * Per-task job sets are small (typically <100 rows; the plugin actively
-     * cancels superseded jobs so they don't accumulate), so the JS filtering
-     * is effectively free. If/when the upstream drizzle bug is fixed, this can
-     * collapse back to a single SQL query.
-     */
-    findByCollection(collectionSlug: CollectionSlug, documentIds?: Array<string | number>): Promise<Task[]>;
-    /**
-     * Group tasks by collection slug
+     * Only `taskSlug` and `completedAt` reach the database; slug and document ids are matched in memory
+     * because a job's collection reference may sit in either the flat-text fields or the legacy
+     * relationship shape (`readCollectionRef`), so a `where` on `input.collection_slug` would silently
+     * drop every pre-migration job. `excludeCompleted` is what bounds the read — see issue #108.
      */
+    findByCollection(collectionSlug: CollectionSlug, filter?: Array<string | number> | TaskFilter): Promise<Task[]>;
     private groupByCollection;
-    /**
-     * Internal cancel implementation
-     */
-    private cancelInternal;
-    /**
-     * Internal method to find jobs with where clause
-     */
+    private cancelAndDeleteJobs;
     private findJobsInternal;
 }

package/dist/server/modules/task-runner/payload-jobs-runner/PayloadJobsTaskRunner.js

@@ -1,3 +1,4 @@
+import { toTaskFilter } from "../toTaskFilter";
 import { normalizeJob } from "./normalizeJob";
 // A translation job's supersession identity: same document AND same target locale. IDs are
 // String()-normalized to match the stored (string) form, so a number id compares equal to its
@@ -18,14 +19,20 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
         const byCollection = this.groupByCollection(tasks);
         for (const [collectionSlug, items] of byCollection){
             const documentIds = items.map((t)=>t.collectionId);
-            const existing = await this.findByCollection(collectionSlug, documentIds);
+            // Finished jobs must stay out of this set: superseding deletes (`cancelAndDeleteJobs` reaches
+            // `payload.delete`), so a completed job for the same (document, locale) would be erased along
+            // with the pending one.
+            const existing = await this.findByCollection(collectionSlug, {
+                documentIds,
+                excludeCompleted: true
+            });
             // Supersede only jobs for the SAME (document, target locale) being re-enqueued — never a
             // concurrent job for a *different* locale of the same document. Cancelling per-document would
             // kill an in-flight translation of another locale (the concurrent re-translate bug).
             const supersededKeys = new Set(items.map((t)=>documentLocaleKey(t.collectionId, t.targetLng)));
             const toCancel = existing.filter((t)=>supersededKeys.has(documentLocaleKey(t.input.collectionId, t.input.targetLng)));
             if (toCancel.length > 0) {
-                await this.cancelInternal(toCancel.map((t)=>t.id));
+                await this.cancelAndDeleteJobs(toCancel.map((t)=>t.id));
             }
         }
         await Promise.all(tasks.map((task)=>this.payload.jobs.queue({
@@ -52,7 +59,7 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
     }
     async cancel(taskIds) {
         if (taskIds.length === 0) return;
-        await this.cancelInternal(taskIds);
+        await this.cancelAndDeleteJobs(taskIds);
     }
     async run(taskId) {
         const tasks = await this.findJobsInternal({
@@ -76,9 +83,7 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
             };
         }
         if (task.status === "running") {
-            // A genuinely in-flight job is refused. A stale processing lock (left by
-            // a process killed mid-run) is reclaimable: clear it first so the queue
-            // picker below — which only selects `processing: false` — can re-run it.
+            // The picker below selects only `processing: false`, so a stale lock must be cleared first.
             if (!this.isStale(task.updatedAt)) {
                 return {
                     success: false,
@@ -91,17 +96,10 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
                 }
             });
         }
-        // Execute synchronously via the queue + `where` picker so the job runs to
-        // completion within this request (nothing is abandoned after the HTTP
-        // response — reliable on serverless too).
-        //
-        // NOT `payload.jobs.runByID({ id })`: on the drizzle adapter the id-path
-        // (`db.updateJobs({ id })`) writes `processing: true` but returns no rows,
-        // so `runJobs` reports `noJobsRemaining` and the handler never runs —
-        // leaving the job stuck at `processing: true` forever. The `where`-based
-        // picker selects, runs, and finalizes the job correctly (verified against
-        // sqlite). The picker also enforces processing:false / no-error / no
-        // pending waitUntil, so a failed (max-retries) job is not re-run here.
+        // `where` picker, not `payload.jobs.runByID({ id })`: in `runJobs` the guard block
+        // (processing:false, hasError not true, waitUntil due) is built only for the non-id branch, so
+        // the id path would re-run a job that already exhausted its retries. Checked against payload
+        // 3.84.1.
         await this.payload.jobs.run({
             queue: this.config.queueName,
             where: {
@@ -116,20 +114,11 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
         };
     }
     /**
-   * Reset stale processing locks so abandoned jobs become eligible for the
-   * autorun picker again. The picker requires processing:false, no error, and
-   * no pending waitUntil; a job abandoned mid-run (no error, no waitUntil)
-   * satisfies the rest, so clearing processing is sufficient for that case.
-   * A job that already exhausted retries (hasError:true) stays excluded from
-   * autorun and is only recoverable via a manual run().
-   *
-   * A job is stale when it is still `processing: true`, not yet completed, and
-   * its `updatedAt` is older than `staleJobTimeoutMs` — i.e. a process was
-   * killed mid-run (deploy/crash/timeout). Threshold-based, so a job genuinely
-   * in flight on another live instance (fresh `updatedAt`) is left alone.
-   * Filters on real `payload-jobs` columns only (no JSON-path traversal), so
-   * the drizzle SQLite issue in `findByCollection` does not apply here.
-   * @returns the number of jobs reclaimed.
+   * Clear stale `processing` locks — still processing, not completed, `updatedAt` older than
+   * `staleJobTimeoutMs` — so abandoned jobs are eligible for the autorun picker again. A job that
+   * exhausted its retries carries `hasError: true` and stays excluded from autorun even after its
+   * lock is cleared; only a manual `run()` recovers it.
+   * @returns how many locks were cleared.
    */ async reclaimStaleJobs() {
         const cutoff = new Date(Date.now() - this.config.staleJobTimeoutMs).toISOString();
         return this.resetProcessing({
@@ -157,12 +146,7 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
             ]
         });
     }
-    /**
-   * Clear the `processing` lock on every job matching `where`, returning how
-   * many were reset. Shared by the per-job reset in `run()` (a stale lock) and
-   * the bulk boot/recovery reset in `reclaimStaleJobs()`. `depth: 0` because
-   * only the count is needed — no relationships to populate.
-   */ async resetProcessing(where) {
+    /** Clears the `processing` lock on every job matching `where`. `depth: 0` — only the count is read. */ async resetProcessing(where) {
         const result = await this.payload.update({
             collection: this.config.jobsCollection,
             depth: 0,
@@ -173,10 +157,7 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
         });
         return result.docs.length;
     }
-    /**
-   * A processing lock is stale once `updatedAt` is older than the configured
-   * timeout — the owning run is presumed dead.
-   */ isStale(updatedAt) {
+    isStale(updatedAt) {
         const parsed = Date.parse(updatedAt);
         // Unknown/corrupt timestamp → treat as stale so the job can be recovered
         // rather than permanently refused as already-running.
@@ -184,60 +165,28 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
         return Date.now() - parsed > this.config.staleJobTimeoutMs;
     }
     /**
-   * Find translation jobs for a collection, optionally narrowed by document IDs.
-   *
-   * Narrowing is by `taskSlug` only in SQL; the collection slug and document
-   * IDs are matched in memory (via the normalized `Task`, which reads both the
-   * current flat-text shape and the legacy relationship shape). This is the
-   * one path that must transparently span both stored shapes during the
-   * ID-agnostic migration — see docs/DEPRECATIONS.md#jobs-input-collection-field.
-   *
-   * IMPORTANT — why slug/id are matched in memory, not in the SQL WHERE
-   * ------------------------------------------------------------------------
-   * The "natural" implementation would push `input.collection_id` into the
-   * where clause. This DOES NOT work on SQLite (and is unreliable on any
-   * adapter) because of two compounding bugs in Payload's drizzle layer.
-   *
-   * 1. The `input` field on `payload-jobs` is declared `type: 'json'`. The
-   *    drizzle path resolver (`@payloadcms/drizzle/queries/getTableColumnFromPath`)
-   *    has no `case 'json'` branch, so the value is left as a raw column and
-   *    the path segments are passed through to `parseParams.js`, which on
-   *    SQLite builds raw SQL using `convertPathToJSONTraversal` — generating
-   *    expressions like `input->>'collection_id'`.
+   * Find translation jobs for a collection.
    *
-   * 2. When `parseParams.js` formats the right-hand side of `in`/`not_in`
-   *    (and even `equals` when `!isNaN(val)`), it inlines values via JS
-   *    template literals WITHOUT wrapping strings in quotes. The string
-   *    `'1'` from our WHERE becomes raw `1` in the SQL. Drizzle therefore
-   *    emits queries like `WHERE input->>'collection_id' IN (1)` even though
-   *    the caller passed `['1']` (an array of strings).
-   *
-   * On SQLite, `->>` preserves the JSON value's type and `IN (...)` does NOT
-   * coerce between TEXT and INTEGER, so a numeric-looking string id never
-   * matches once bug #2 strips its quotes. Storing the id as text (this
-   * migration) does not fix the SQL path — drizzle re-numbers it anyway — so
-   * we keep matching in memory.
-   *
-   * Why in-memory filtering is acceptable here
-   * ------------------------------------------
-   * Per-task job sets are small (typically <100 rows; the plugin actively
-   * cancels superseded jobs so they don't accumulate), so the JS filtering
-   * is effectively free. If/when the upstream drizzle bug is fixed, this can
-   * collapse back to a single SQL query.
-   */ async findByCollection(collectionSlug, documentIds) {
-        const all = await this.findJobsInternal(undefined, {
+   * Only `taskSlug` and `completedAt` reach the database; slug and document ids are matched in memory
+   * because a job's collection reference may sit in either the flat-text fields or the legacy
+   * relationship shape (`readCollectionRef`), so a `where` on `input.collection_slug` would silently
+   * drop every pre-migration job. `excludeCompleted` is what bounds the read — see issue #108.
+   */ async findByCollection(collectionSlug, filter) {
+        const { documentIds, excludeCompleted } = toTaskFilter(filter);
+        const where = excludeCompleted ? {
+            completedAt: {
+                exists: false
+            }
+        } : undefined;
+        const all = await this.findJobsInternal(where, {
             pagination: false
         });
         const bySlug = all.filter((t)=>t.input.collectionSlug === collectionSlug);
         if (!documentIds?.length) return bySlug;
-        // `documentIds` is the public `Array<string | number>` param, so normalize
-        // it here; `t.input.collectionId` is already `ID` (string) via normalizeJob.
         const wanted = new Set(documentIds.map(String));
         return bySlug.filter((t)=>wanted.has(t.input.collectionId));
     }
-    /**
-   * Group tasks by collection slug
-   */ groupByCollection(tasks) {
+    groupByCollection(tasks) {
         const map = new Map();
         for (const task of tasks){
             const existing = map.get(task.collectionSlug) ?? [];
@@ -246,10 +195,12 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
         }
         return map;
     }
-    /**
-   * Internal cancel implementation
-   */ async cancelInternal(taskIds) {
+    async cancelAndDeleteJobs(taskIds) {
         if (taskIds.length === 0) return;
+        // Both, in this order: `jobs.cancel` only writes `{ error: { cancelled: true }, hasError: true,
+        // processing: false }`, which is what signals a running handler to abort. The delete then removes
+        // the row — under `deleteJobOnComplete: false` a cancelled job would otherwise sit in the status
+        // feed forever.
         await this.payload.jobs.cancel({
             where: {
                 id: {
@@ -267,9 +218,7 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
             }
         });
     }
-    /**
-   * Internal method to find jobs with where clause
-   */ async findJobsInternal(where, params) {
+    async findJobsInternal(where, params) {
         const and = [
             {
                 taskSlug: {

package/dist/server/modules/task-runner/sync-runner/SyncTaskRunner.d.ts

@@ -1,5 +1,5 @@
 import type { Payload, CollectionSlug } from "payload";
-import type { TaskRunner } from "../TaskRunner.interface";
+import type { TaskFilter, TaskRunner } from "../TaskRunner.interface";
 import type { TaskHandler } from "../TaskRunnerProvider.interface";
 import type { Task, TaskInput, RunResult } from "../types";
 import type { LazyMap } from "../../../shared/utils";
@@ -17,6 +17,6 @@ export declare class SyncTaskRunner implements TaskRunner {
     enqueue(inputs: TaskInput[]): Promise<void>;
     cancel(_taskIds: string[]): Promise<void>;
     run(_taskId: string): Promise<RunResult>;
-    findByCollection(collectionSlug: CollectionSlug, documentIds?: Array<string | number>): Promise<Task[]>;
+    findByCollection(collectionSlug: CollectionSlug, filter?: Array<string | number> | TaskFilter): Promise<Task[]>;
     private getKey;
 }

package/dist/server/modules/task-runner/sync-runner/SyncTaskRunner.js

@@ -1,3 +1,4 @@
+import { toTaskFilter } from "../toTaskFilter";
 /**
  * Synchronous TaskRunner implementation.
  *
@@ -55,12 +56,17 @@
             error: "not_found"
         };
     }
-    async findByCollection(collectionSlug, documentIds) {
+    async findByCollection(collectionSlug, filter) {
+        const { documentIds, excludeCompleted } = toTaskFilter(filter);
         const results = [];
         const wanted = documentIds ? new Set(documentIds.map(String)) : undefined;
         for (const [, task] of this.tasks){
             if (task.input.collectionSlug !== collectionSlug) continue;
             if (wanted && !wanted.has(task.input.collectionId)) continue;
+            // Keyed on `completedAt`, the same field the jobs runner pushes into its where clause. Keying
+            // on `status` instead would agree only by accident: `getJobStatus` happens to check
+            // `completedAt` before `error`, and reordering it would silently split the two runners.
+            if (excludeCompleted && task.completedAt) continue;
             results.push(task);
         }
         return results;

package/dist/server/modules/task-runner/toTaskFilter.d.ts

@@ -0,0 +1,11 @@
+import type { TaskFilter } from "./TaskRunner.interface";
+/**
+ * Normalize the two accepted shapes of {@link TaskRunner.findByCollection}'s second argument.
+ *
+ * Every implementation of {@link TaskRunner} owes this, so it ships alongside the contract rather
+ * than being re-derived: the array form is deprecated and will be removed, and a hand-written
+ * `Array.isArray` branch in someone else's runner would outlive it.
+ *
+ * @since 0.11.2
+ */
+export declare function toTaskFilter(filter?: Array<string | number> | TaskFilter): TaskFilter;

package/dist/server/modules/task-runner/toTaskFilter.js

@@ -0,0 +1,15 @@
+/**
+ * Normalize the two accepted shapes of {@link TaskRunner.findByCollection}'s second argument.
+ *
+ * Every implementation of {@link TaskRunner} owes this, so it ships alongside the contract rather
+ * than being re-derived: the array form is deprecated and will be removed, and a hand-written
+ * `Array.isArray` branch in someone else's runner would outlive it.
+ *
+ * @since 0.11.2
+ */ export function toTaskFilter(filter) {
+    return Array.isArray(filter) ? {
+        documentIds: filter
+    } : filter ?? {};
+}
+
+//# sourceMappingURL=toTaskFilter.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@focus-reactive/payload-plugin-translator",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "description": "Translation plugin for Payload CMS 3.x. Automatically translate your localized content using any translation provider.",
   "type": "module",
   "license": "MIT",