@focus-reactive/payload-plugin-translator 0.1.0

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

@@ -0,0 +1,165 @@
+import { normalizeJob } from './normalizeJob';
+/**
+ * TaskRunner implementation using Payload Jobs.
+ *
+ * Handles queuing, cancellation, status tracking, and execution of translation tasks.
+ */ export class PayloadJobsTaskRunner {
+    payload;
+    config;
+    constructor(payload, config){
+        this.payload = payload;
+        this.config = config;
+    }
+    async enqueue(tasks) {
+        const byCollection = this.groupByCollection(tasks);
+        for (const [collectionSlug, items] of byCollection){
+            const documentIds = items.map((t)=>t.collectionId);
+            const existing = await this.findJobsInternal({
+                and: [
+                    {
+                        'input.collection.relationTo': {
+                            equals: collectionSlug
+                        }
+                    },
+                    {
+                        'input.collection.value': {
+                            in: documentIds
+                        }
+                    }
+                ]
+            });
+            if (existing.length > 0) {
+                await this.cancelInternal(existing.map((t)=>t.id));
+            }
+        }
+        await Promise.all(tasks.map((task)=>this.payload.jobs.queue({
+                task: this.config.taskName,
+                queue: this.config.queueName,
+                input: {
+                    collection: {
+                        relationTo: task.collectionSlug,
+                        value: task.collectionId
+                    },
+                    source_lng: task.sourceLng,
+                    target_lng: task.targetLng,
+                    strategy: task.strategy,
+                    publish_on_translation: task.publishOnTranslation
+                }
+            })));
+    }
+    async cancel(taskIds) {
+        if (taskIds.length === 0) return;
+        await this.cancelInternal(taskIds);
+    }
+    async run(taskId) {
+        const tasks = await this.findJobsInternal({
+            id: {
+                equals: taskId
+            }
+        }, {
+            limit: 1
+        });
+        const task = tasks[0];
+        if (!task) {
+            return {
+                success: false,
+                error: 'not_found'
+            };
+        }
+        if (task.completedAt) {
+            return {
+                success: false,
+                error: 'already_completed'
+            };
+        }
+        if (task.status === 'running') {
+            return {
+                success: false,
+                error: 'already_running'
+            };
+        }
+        this.payload.jobs.runByID({
+            id: taskId
+        });
+        return {
+            success: true
+        };
+    }
+    async findByCollection(collectionSlug, documentIds) {
+        const where = documentIds?.length ? {
+            and: [
+                {
+                    'input.collection.relationTo': {
+                        equals: collectionSlug
+                    }
+                },
+                {
+                    'input.collection.value': {
+                        in: documentIds
+                    }
+                }
+            ]
+        } : {
+            'input.collection.relationTo': {
+                equals: collectionSlug
+            }
+        };
+        return this.findJobsInternal(where, {
+            pagination: false
+        });
+    }
+    /**
+   * Group tasks by collection slug
+   */ groupByCollection(tasks) {
+        const map = new Map();
+        for (const task of tasks){
+            const existing = map.get(task.collectionSlug) ?? [];
+            existing.push(task);
+            map.set(task.collectionSlug, existing);
+        }
+        return map;
+    }
+    /**
+   * Internal cancel implementation
+   */ async cancelInternal(taskIds) {
+        if (taskIds.length === 0) return;
+        await this.payload.jobs.cancel({
+            where: {
+                id: {
+                    in: taskIds
+                }
+            },
+            queue: this.config.queueName
+        });
+        await this.payload.delete({
+            collection: this.config.jobsCollection,
+            where: {
+                id: {
+                    in: taskIds
+                }
+            }
+        });
+    }
+    /**
+   * Internal method to find jobs with where clause
+   */ async findJobsInternal(where, params) {
+        const response = await this.payload.find({
+            collection: this.config.jobsCollection,
+            limit: params?.limit,
+            pagination: params?.pagination,
+            where: {
+                and: [
+                    {
+                        taskSlug: {
+                            equals: this.config.taskName
+                        }
+                    },
+                    where
+                ]
+            }
+        });
+        return response.docs.map(normalizeJob);
+    }
+}
+
+//# sourceMappingURL=PayloadJobsTaskRunner.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/modules/task-runner/payload-jobs-runner/PayloadJobsTaskRunner.ts"],"sourcesContent":["import type { Payload, Where, CollectionSlug } from 'payload'\n\nimport type { TaskRunner } from '../TaskRunner.interface'\nimport type { Task, TaskInput, RunResult } from '../types'\nimport type { PayloadJobsRunnerConfig, PayloadJob } from './types'\nimport { normalizeJob } from './normalizeJob'\n\n/**\n * TaskRunner implementation using Payload Jobs.\n *\n * Handles queuing, cancellation, status tracking, and execution of translation tasks.\n */\nexport class PayloadJobsTaskRunner implements TaskRunner {\n  constructor(\n    private readonly payload: Payload,\n    private readonly config: PayloadJobsRunnerConfig,\n  ) {}\n\n  async enqueue(tasks: TaskInput[]): Promise<void> {\n    const byCollection = this.groupByCollection(tasks)\n\n    for (const [collectionSlug, items] of byCollection) {\n      const documentIds = items.map((t) => t.collectionId)\n      const existing = await this.findJobsInternal({\n        and: [\n          { 'input.collection.relationTo': { equals: collectionSlug } },\n          { 'input.collection.value': { in: documentIds } },\n        ],\n      })\n      if (existing.length > 0) {\n        await this.cancelInternal(existing.map((t) => t.id))\n      }\n    }\n\n    await Promise.all(\n      tasks.map((task) =>\n        this.payload.jobs.queue({\n          task: this.config.taskName,\n          queue: this.config.queueName,\n          input: {\n            collection: {\n              relationTo: task.collectionSlug,\n              value: task.collectionId,\n            },\n            source_lng: task.sourceLng,\n            target_lng: task.targetLng,\n            strategy: task.strategy,\n            publish_on_translation: task.publishOnTranslation,\n          },\n        }),\n      ),\n    )\n  }\n\n  async cancel(taskIds: string[]): Promise<void> {\n    if (taskIds.length === 0) return\n    await this.cancelInternal(taskIds)\n  }\n\n  async run(taskId: string): Promise<RunResult> {\n    const tasks = await this.findJobsInternal({ id: { equals: taskId } }, { limit: 1 })\n    const task = tasks[0]\n\n    if (!task) {\n      return { success: false, error: 'not_found' }\n    }\n    if (task.completedAt) {\n      return { success: false, error: 'already_completed' }\n    }\n    if (task.status === 'running') {\n      return { success: false, error: 'already_running' }\n    }\n\n    this.payload.jobs.runByID({ id: taskId })\n    return { success: true }\n  }\n\n  async findByCollection(collectionSlug: CollectionSlug, documentIds?: Array<string | number>): Promise<Task[]> {\n    const where: Where = documentIds?.length\n      ? {\n          and: [\n            { 'input.collection.relationTo': { equals: collectionSlug } },\n            { 'input.collection.value': { in: documentIds } },\n          ],\n        }\n      : { 'input.collection.relationTo': { equals: collectionSlug } }\n\n    return this.findJobsInternal(where, { pagination: false })\n  }\n\n  /**\n   * Group tasks by collection slug\n   */\n  private groupByCollection(tasks: TaskInput[]): Map<CollectionSlug, TaskInput[]> {\n    const map = new Map<CollectionSlug, TaskInput[]>()\n    for (const task of tasks) {\n      const existing = map.get(task.collectionSlug) ?? []\n      existing.push(task)\n      map.set(task.collectionSlug, existing)\n    }\n    return map\n  }\n\n  /**\n   * Internal cancel implementation\n   */\n  private async cancelInternal(taskIds: string[]): Promise<void> {\n    if (taskIds.length === 0) return\n\n    await this.payload.jobs.cancel({\n      where: { id: { in: taskIds } },\n      queue: this.config.queueName,\n    })\n\n    await this.payload.delete({\n      collection: this.config.jobsCollection,\n      where: { id: { in: taskIds } },\n    })\n  }\n\n  /**\n   * Internal method to find jobs with where clause\n   */\n  private async findJobsInternal(where: Where, params?: { limit?: number; pagination?: boolean }): Promise<Task[]> {\n    const response = await this.payload.find({\n      collection: this.config.jobsCollection,\n      limit: params?.limit,\n      pagination: params?.pagination,\n      where: {\n        and: [{ taskSlug: { equals: this.config.taskName } }, where],\n      },\n    })\n\n    return (response.docs as PayloadJob[]).map(normalizeJob)\n  }\n}\n"],"names":["normalizeJob","PayloadJobsTaskRunner","payload","config","enqueue","tasks","byCollection","groupByCollection","collectionSlug","items","documentIds","map","t","collectionId","existing","findJobsInternal","and","equals","in","length","cancelInternal","id","Promise","all","task","jobs","queue","taskName","queueName","input","collection","relationTo","value","source_lng","sourceLng","target_lng","targetLng","strategy","publish_on_translation","publishOnTranslation","cancel","taskIds","run","taskId","limit","success","error","completedAt","status","runByID","findByCollection","where","pagination","Map","get","push","set","delete","jobsCollection","params","response","find","taskSlug","docs"],"mappings":"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"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=PayloadJobsTaskRunner.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PayloadJobsTaskRunner.test.d.ts","sourceRoot":"","sources":["../../../../../src/server/modules/task-runner/payload-jobs-runner/PayloadJobsTaskRunner.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,188 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { PayloadJobsTaskRunner } from './PayloadJobsTaskRunner';
+describe('PayloadJobsTaskRunner', () => {
+    let mockPayload;
+    let config;
+    let runner;
+    beforeEach(() => {
+        mockPayload = {
+            find: vi.fn().mockResolvedValue({ docs: [] }),
+            delete: vi.fn().mockResolvedValue(undefined),
+            jobs: {
+                queue: vi.fn().mockResolvedValue(undefined),
+                cancel: vi.fn().mockResolvedValue(undefined),
+                runByID: vi.fn().mockResolvedValue(undefined),
+            },
+        };
+        config = {
+            taskName: 'translate_document',
+            queueName: 'translations',
+            jobsCollection: 'payload-jobs',
+            autoRun: {
+                cron: '* * * * *',
+                limit: 50,
+            },
+        };
+        runner = new PayloadJobsTaskRunner(mockPayload, config);
+    });
+    const createInput = (overrides = {}) => ({
+        collectionSlug: 'posts',
+        collectionId: 'doc-123',
+        sourceLng: 'en',
+        targetLng: 'de',
+        strategy: 'overwrite',
+        publishOnTranslation: false,
+        ...overrides,
+    });
+    const createJob = (overrides = {}) => ({
+        id: 'job-123',
+        createdAt: '2024-01-01T00:00:00Z',
+        updatedAt: '2024-01-01T00:00:00Z',
+        input: {
+            collection: { relationTo: 'posts', value: 'doc-123' },
+            source_lng: 'en',
+            target_lng: 'de',
+            strategy: 'overwrite',
+        },
+        ...overrides,
+    });
+    describe('enqueue', () => {
+        it('queues tasks with correct input', async () => {
+            const input = createInput();
+            await runner.enqueue([input]);
+            expect(mockPayload.jobs.queue).toHaveBeenCalledWith({
+                task: 'translate_document',
+                queue: 'translations',
+                input: {
+                    collection: { relationTo: 'posts', value: 'doc-123' },
+                    source_lng: 'en',
+                    target_lng: 'de',
+                    strategy: 'overwrite',
+                    publish_on_translation: false,
+                },
+            });
+        });
+        it('queues multiple tasks', async () => {
+            const inputs = [createInput({ collectionId: 'doc-1' }), createInput({ collectionId: 'doc-2' })];
+            await runner.enqueue(inputs);
+            expect(mockPayload.jobs.queue).toHaveBeenCalledTimes(2);
+        });
+        it('cancels existing jobs before queuing new ones', async () => {
+            const existingJob = createJob({ id: 'existing-job' });
+            mockPayload.find.mockResolvedValueOnce({ docs: [existingJob] });
+            const input = createInput();
+            await runner.enqueue([input]);
+            expect(mockPayload.jobs.cancel).toHaveBeenCalledWith({
+                where: { id: { in: ['existing-job'] } },
+                queue: 'translations',
+            });
+            expect(mockPayload.delete).toHaveBeenCalledWith({
+                collection: 'payload-jobs',
+                where: { id: { in: ['existing-job'] } },
+            });
+        });
+        it('does not cancel when no existing jobs', async () => {
+            mockPayload.find.mockResolvedValue({ docs: [] });
+            const input = createInput();
+            await runner.enqueue([input]);
+            expect(mockPayload.jobs.cancel).not.toHaveBeenCalled();
+            expect(mockPayload.delete).not.toHaveBeenCalled();
+        });
+        it('groups tasks by collection', async () => {
+            const inputs = [
+                createInput({ collectionSlug: 'posts', collectionId: 'post-1' }),
+                createInput({ collectionSlug: 'posts', collectionId: 'post-2' }),
+                createInput({ collectionSlug: 'pages', collectionId: 'page-1' }),
+            ];
+            await runner.enqueue(inputs);
+            // Should check for existing jobs per collection
+            expect(mockPayload.find).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('cancel', () => {
+        it('cancels jobs by ids', async () => {
+            await runner.cancel(['job-1', 'job-2']);
+            expect(mockPayload.jobs.cancel).toHaveBeenCalledWith({
+                where: { id: { in: ['job-1', 'job-2'] } },
+                queue: 'translations',
+            });
+            expect(mockPayload.delete).toHaveBeenCalledWith({
+                collection: 'payload-jobs',
+                where: { id: { in: ['job-1', 'job-2'] } },
+            });
+        });
+        it('does nothing for empty array', async () => {
+            await runner.cancel([]);
+            expect(mockPayload.jobs.cancel).not.toHaveBeenCalled();
+            expect(mockPayload.delete).not.toHaveBeenCalled();
+        });
+    });
+    describe('run', () => {
+        it('returns not_found when task does not exist', async () => {
+            mockPayload.find.mockResolvedValue({ docs: [] });
+            const result = await runner.run('nonexistent');
+            expect(result).toEqual({ success: false, error: 'not_found' });
+        });
+        it('returns already_completed when task is completed', async () => {
+            const completedJob = createJob({ completedAt: '2024-01-01T01:00:00Z' });
+            mockPayload.find.mockResolvedValue({ docs: [completedJob] });
+            const result = await runner.run('job-123');
+            expect(result).toEqual({ success: false, error: 'already_completed' });
+        });
+        it('returns already_running when task is running', async () => {
+            const runningJob = createJob({ processing: true });
+            mockPayload.find.mockResolvedValue({ docs: [runningJob] });
+            const result = await runner.run('job-123');
+            expect(result).toEqual({ success: false, error: 'already_running' });
+        });
+        it('runs task and returns success', async () => {
+            const pendingJob = createJob();
+            mockPayload.find.mockResolvedValue({ docs: [pendingJob] });
+            const result = await runner.run('job-123');
+            expect(result).toEqual({ success: true });
+            expect(mockPayload.jobs.runByID).toHaveBeenCalledWith({ id: 'job-123' });
+        });
+    });
+    describe('findByCollection', () => {
+        it('finds tasks by collection slug', async () => {
+            // Mock returns only jobs matching the collection (simulating DB where clause)
+            const jobs = [
+                createJob({ id: 'job-1', input: { collection: { relationTo: 'posts', value: 'doc-1' } } }),
+                createJob({ id: 'job-2', input: { collection: { relationTo: 'posts', value: 'doc-2' } } }),
+            ];
+            mockPayload.find.mockResolvedValue({ docs: jobs });
+            const tasks = await runner.findByCollection('posts');
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0].id).toBe('job-1');
+            expect(tasks[1].id).toBe('job-2');
+        });
+        it('filters by document ids when provided', async () => {
+            // Mock returns only jobs matching collection and document ids (simulating DB where clause)
+            const jobs = [
+                createJob({ id: 'job-1', input: { collection: { relationTo: 'posts', value: 'doc-1' } } }),
+                createJob({ id: 'job-2', input: { collection: { relationTo: 'posts', value: 'doc-2' } } }),
+            ];
+            mockPayload.find.mockResolvedValue({ docs: jobs });
+            const tasks = await runner.findByCollection('posts', ['doc-1', 'doc-2']);
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0].id).toBe('job-1');
+            expect(tasks[1].id).toBe('job-2');
+        });
+        it('returns normalized tasks', async () => {
+            const job = createJob({
+                id: 'job-123',
+                completedAt: '2024-01-01T01:00:00Z',
+            });
+            mockPayload.find.mockResolvedValue({ docs: [job] });
+            const tasks = await runner.findByCollection('posts');
+            expect(tasks[0]).toMatchObject({
+                id: 'job-123',
+                status: 'completed',
+                input: {
+                    collectionSlug: 'posts',
+                    collectionId: 'doc-123',
+                },
+            });
+        });
+    });
+});

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

@@ -0,0 +1,3 @@
+export { createPayloadJobsRunner } from './PayloadJobsRunnerProvider';
+export type { PayloadJobsRunnerOptions } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/server/modules/task-runner/payload-jobs-runner/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AACrE,YAAY,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA"}

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

@@ -0,0 +1,3 @@
+export { createPayloadJobsRunner } from './PayloadJobsRunnerProvider';
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/modules/task-runner/payload-jobs-runner/index.ts"],"sourcesContent":["export { createPayloadJobsRunner } from './PayloadJobsRunnerProvider'\nexport type { PayloadJobsRunnerOptions } from './types'\n"],"names":["createPayloadJobsRunner"],"mappings":"AAAA,SAASA,uBAAuB,QAAQ,8BAA6B"}

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

@@ -0,0 +1,7 @@
+import type { Task } from '../types';
+import type { PayloadJob } from './types';
+/**
+ * Transform Payload job to normalized Task
+ */
+export declare function normalizeJob(job: PayloadJob): Task;
+//# sourceMappingURL=normalizeJob.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeJob.d.ts","sourceRoot":"","sources":["../../../../../src/server/modules/task-runner/payload-jobs-runner/normalizeJob.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAc,MAAM,UAAU,CAAA;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAkBlD"}

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

@@ -0,0 +1,40 @@
+/**
+ * Transform Payload job to normalized Task
+ */ export function normalizeJob(job) {
+    return {
+        id: job.id,
+        status: getJobStatus(job),
+        input: {
+            collectionSlug: job.input?.collection?.relationTo ?? '',
+            collectionId: job.input?.collection?.value ?? '',
+            sourceLng: job.input?.source_lng ?? '',
+            targetLng: job.input?.target_lng ?? '',
+            strategy: job.input?.strategy ?? 'overwrite',
+            publishOnTranslation: job.input?.publish_on_translation ?? false
+        },
+        createdAt: job.createdAt,
+        updatedAt: job.updatedAt,
+        completedAt: job.completedAt ?? undefined,
+        error: job.error ? {
+            message: extractErrorMessage(job.error)
+        } : undefined,
+        cancelled: isCancelled(job.error)
+    };
+}
+function getJobStatus(job) {
+    if (job.completedAt) return 'completed';
+    if (job.processing) return 'running';
+    if (job.error) return 'failed';
+    return 'pending';
+}
+function extractErrorMessage(error) {
+    if (error && typeof error === 'object' && 'message' in error && typeof error.message === 'string') {
+        return error.message;
+    }
+    return 'Unknown error';
+}
+function isCancelled(error) {
+    return error !== null && typeof error === 'object' && 'cancelled' in error && typeof error.cancelled === 'boolean' && error.cancelled;
+}
+
+//# sourceMappingURL=normalizeJob.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/modules/task-runner/payload-jobs-runner/normalizeJob.ts"],"sourcesContent":["import type { CollectionSlug } from 'payload'\n\nimport type { Task, TaskStatus } from '../types'\nimport type { PayloadJob } from './types'\n\n/**\n * Transform Payload job to normalized Task\n */\nexport function normalizeJob(job: PayloadJob): Task {\n  return {\n    id: job.id,\n    status: getJobStatus(job),\n    input: {\n      collectionSlug: job.input?.collection?.relationTo ?? ('' as CollectionSlug),\n      collectionId: job.input?.collection?.value ?? '',\n      sourceLng: job.input?.source_lng ?? '',\n      targetLng: job.input?.target_lng ?? '',\n      strategy: (job.input?.strategy as 'overwrite' | 'skip_existing') ?? 'overwrite',\n      publishOnTranslation: job.input?.publish_on_translation ?? false,\n    },\n    createdAt: job.createdAt,\n    updatedAt: job.updatedAt,\n    completedAt: job.completedAt ?? undefined,\n    error: job.error ? { message: extractErrorMessage(job.error) } : undefined,\n    cancelled: isCancelled(job.error),\n  }\n}\n\nfunction getJobStatus(job: PayloadJob): TaskStatus {\n  if (job.completedAt) return 'completed'\n  if (job.processing) return 'running'\n  if (job.error) return 'failed'\n  return 'pending'\n}\n\nfunction extractErrorMessage(error: unknown): string {\n  if (error && typeof error === 'object' && 'message' in error && typeof error.message === 'string') {\n    return error.message\n  }\n  return 'Unknown error'\n}\n\nfunction isCancelled(error: unknown): boolean {\n  return (\n    error !== null &&\n    typeof error === 'object' &&\n    'cancelled' in error &&\n    typeof error.cancelled === 'boolean' &&\n    error.cancelled\n  )\n}\n"],"names":["normalizeJob","job","id","status","getJobStatus","input","collectionSlug","collection","relationTo","collectionId","value","sourceLng","source_lng","targetLng","target_lng","strategy","publishOnTranslation","publish_on_translation","createdAt","updatedAt","completedAt","undefined","error","message","extractErrorMessage","cancelled","isCancelled","processing"],"mappings":"AAKA;;CAEC,GACD,OAAO,SAASA,aAAaC,GAAe;IAC1C,OAAO;QACLC,IAAID,IAAIC,EAAE;QACVC,QAAQC,aAAaH;QACrBI,OAAO;YACLC,gBAAgBL,IAAII,KAAK,EAAEE,YAAYC,cAAe;YACtDC,cAAcR,IAAII,KAAK,EAAEE,YAAYG,SAAS;YAC9CC,WAAWV,IAAII,KAAK,EAAEO,cAAc;YACpCC,WAAWZ,IAAII,KAAK,EAAES,cAAc;YACpCC,UAAU,AAACd,IAAII,KAAK,EAAEU,YAA8C;YACpEC,sBAAsBf,IAAII,KAAK,EAAEY,0BAA0B;QAC7D;QACAC,WAAWjB,IAAIiB,SAAS;QACxBC,WAAWlB,IAAIkB,SAAS;QACxBC,aAAanB,IAAImB,WAAW,IAAIC;QAChCC,OAAOrB,IAAIqB,KAAK,GAAG;YAAEC,SAASC,oBAAoBvB,IAAIqB,KAAK;QAAE,IAAID;QACjEI,WAAWC,YAAYzB,IAAIqB,KAAK;IAClC;AACF;AAEA,SAASlB,aAAaH,GAAe;IACnC,IAAIA,IAAImB,WAAW,EAAE,OAAO;IAC5B,IAAInB,IAAI0B,UAAU,EAAE,OAAO;IAC3B,IAAI1B,IAAIqB,KAAK,EAAE,OAAO;IACtB,OAAO;AACT;AAEA,SAASE,oBAAoBF,KAAc;IACzC,IAAIA,SAAS,OAAOA,UAAU,YAAY,aAAaA,SAAS,OAAOA,MAAMC,OAAO,KAAK,UAAU;QACjG,OAAOD,MAAMC,OAAO;IACtB;IACA,OAAO;AACT;AAEA,SAASG,YAAYJ,KAAc;IACjC,OACEA,UAAU,QACV,OAAOA,UAAU,YACjB,eAAeA,SACf,OAAOA,MAAMG,SAAS,KAAK,aAC3BH,MAAMG,SAAS;AAEnB"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=normalizeJob.test.d.ts.map

package/dist/server/modules/task-runner/payload-jobs-runner/normalizeJob.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeJob.test.d.ts","sourceRoot":"","sources":["../../../../../src/server/modules/task-runner/payload-jobs-runner/normalizeJob.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,169 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeJob } from './normalizeJob';
+describe('normalizeJob', () => {
+    const baseJob = {
+        id: 'job-123',
+        createdAt: '2024-01-01T00:00:00Z',
+        updatedAt: '2024-01-01T00:00:00Z',
+        input: {
+            collection: {
+                relationTo: 'posts',
+                value: 'doc-456',
+            },
+            source_lng: 'en',
+            target_lng: 'de',
+            strategy: 'overwrite',
+        },
+    };
+    describe('basic transformation', () => {
+        it('transforms job to task with correct id', () => {
+            const task = normalizeJob(baseJob);
+            expect(task.id).toBe('job-123');
+        });
+        it('transforms job to task with correct input', () => {
+            const task = normalizeJob(baseJob);
+            expect(task.input).toEqual({
+                collectionSlug: 'posts',
+                collectionId: 'doc-456',
+                sourceLng: 'en',
+                targetLng: 'de',
+                strategy: 'overwrite',
+                publishOnTranslation: false,
+            });
+        });
+        it('transforms job to task with correct timestamps', () => {
+            const task = normalizeJob(baseJob);
+            expect(task.createdAt).toBe('2024-01-01T00:00:00Z');
+            expect(task.updatedAt).toBe('2024-01-01T00:00:00Z');
+        });
+    });
+    describe('status detection', () => {
+        it('returns pending status for new job', () => {
+            const task = normalizeJob(baseJob);
+            expect(task.status).toBe('pending');
+        });
+        it('returns running status when processing is true', () => {
+            const job = { ...baseJob, processing: true };
+            const task = normalizeJob(job);
+            expect(task.status).toBe('running');
+        });
+        it('returns completed status when completedAt is set', () => {
+            const job = { ...baseJob, completedAt: '2024-01-01T01:00:00Z' };
+            const task = normalizeJob(job);
+            expect(task.status).toBe('completed');
+            expect(task.completedAt).toBe('2024-01-01T01:00:00Z');
+        });
+        it('returns failed status when error is set', () => {
+            const job = { ...baseJob, error: { message: 'Something went wrong' } };
+            const task = normalizeJob(job);
+            expect(task.status).toBe('failed');
+        });
+        it('completed takes precedence over processing', () => {
+            const job = { ...baseJob, completedAt: '2024-01-01T01:00:00Z', processing: true };
+            const task = normalizeJob(job);
+            expect(task.status).toBe('completed');
+        });
+        it('completed takes precedence over error', () => {
+            const job = {
+                ...baseJob,
+                completedAt: '2024-01-01T01:00:00Z',
+                error: { message: 'err' },
+            };
+            const task = normalizeJob(job);
+            expect(task.status).toBe('completed');
+        });
+    });
+    describe('error handling', () => {
+        it('extracts error message from error object', () => {
+            const job = { ...baseJob, error: { message: 'Translation failed' } };
+            const task = normalizeJob(job);
+            expect(task.error).toEqual({ message: 'Translation failed' });
+        });
+        it('returns unknown error for non-standard error', () => {
+            const job = { ...baseJob, error: 'some string error' };
+            const task = normalizeJob(job);
+            expect(task.error).toEqual({ message: 'Unknown error' });
+        });
+        it('returns unknown error for error without message', () => {
+            const job = { ...baseJob, error: { code: 500 } };
+            const task = normalizeJob(job);
+            expect(task.error).toEqual({ message: 'Unknown error' });
+        });
+        it('sets error to undefined when no error', () => {
+            const task = normalizeJob(baseJob);
+            expect(task.error).toBeUndefined();
+        });
+    });
+    describe('cancelled detection', () => {
+        it('detects cancelled job', () => {
+            const job = { ...baseJob, error: { cancelled: true, message: 'Cancelled' } };
+            const task = normalizeJob(job);
+            expect(task.cancelled).toBe(true);
+        });
+        it('returns false for non-cancelled error', () => {
+            const job = { ...baseJob, error: { message: 'Failed' } };
+            const task = normalizeJob(job);
+            expect(task.cancelled).toBe(false);
+        });
+        it('returns false for cancelled: false', () => {
+            const job = { ...baseJob, error: { cancelled: false, message: 'Error' } };
+            const task = normalizeJob(job);
+            expect(task.cancelled).toBe(false);
+        });
+        it('returns false for no error', () => {
+            const task = normalizeJob(baseJob);
+            expect(task.cancelled).toBe(false);
+        });
+    });
+    describe('missing input fields', () => {
+        it('handles missing input gracefully', () => {
+            const job = { ...baseJob, input: undefined };
+            const task = normalizeJob(job);
+            expect(task.input).toEqual({
+                collectionSlug: '',
+                collectionId: '',
+                sourceLng: '',
+                targetLng: '',
+                strategy: 'overwrite',
+                publishOnTranslation: false,
+            });
+        });
+        it('handles missing collection in input', () => {
+            const job = {
+                ...baseJob,
+                input: { source_lng: 'en', target_lng: 'de' },
+            };
+            const task = normalizeJob(job);
+            expect(task.input.collectionSlug).toBe('');
+            expect(task.input.collectionId).toBe('');
+        });
+        it('handles missing strategy with default', () => {
+            const job = {
+                ...baseJob,
+                input: { ...baseJob.input, strategy: undefined },
+            };
+            const task = normalizeJob(job);
+            expect(task.input.strategy).toBe('overwrite');
+        });
+        it('handles skip_existing strategy', () => {
+            const job = {
+                ...baseJob,
+                input: { ...baseJob.input, strategy: 'skip_existing' },
+            };
+            const task = normalizeJob(job);
+            expect(task.input.strategy).toBe('skip_existing');
+        });
+    });
+    describe('completedAt handling', () => {
+        it('sets completedAt to undefined when null', () => {
+            const job = { ...baseJob, completedAt: null };
+            const task = normalizeJob(job);
+            expect(task.completedAt).toBeUndefined();
+        });
+        it('sets completedAt to value when provided', () => {
+            const job = { ...baseJob, completedAt: '2024-01-02T00:00:00Z' };
+            const task = normalizeJob(job);
+            expect(task.completedAt).toBe('2024-01-02T00:00:00Z');
+        });
+    });
+});