@focus-reactive/payload-plugin-translator 0.1.0

package/dist/server/modules/translation-pipeline/TranslationPipeline.js

@@ -0,0 +1,55 @@
+import { DataReconcilerStage, FieldChunkCollectorStage, TranslationStage, TextChunkExpanderStage, TranslationMutatorStage } from './stages';
+/**
+ * Main orchestrator for the translation pipeline.
+ * Coordinates all stages in sequence via PipelineContext.
+ *
+ * Pipeline stages:
+ * 1. DataReconcilerStage - Reconcile source/target data preserving full document shape
+ * 2. FieldChunkCollectorStage - Collect FieldChunks (schema-aware)
+ * 3. TextChunkExpanderStage - Expand FieldChunks to TextChunks (schema-free)
+ * 4. TranslationStage - Call translation provider
+ * 5. TranslationMutatorStage - Apply translations via mutation
+ *
+ * Pipeline only transforms data. Saving is the caller's responsibility.
+ */ export class TranslationPipeline {
+    stages;
+    constructor(options){
+        this.stages = [
+            new DataReconcilerStage(),
+            new FieldChunkCollectorStage(options.translationStrategy),
+            new TextChunkExpanderStage(options.textExpanders),
+            new TranslationStage(options.translationProvider),
+            new TranslationMutatorStage()
+        ];
+    }
+    /**
+   * Executes the translation pipeline.
+   * Returns transformed data ready to be saved, or null if nothing to translate.
+   */ async execute(config) {
+        let ctx = {
+            schema: config.schema,
+            sourceData: config.sourceData,
+            targetData: config.targetData,
+            sourceLng: config.sourceLng,
+            targetLng: config.targetLng
+        };
+        for (const stage of this.stages){
+            ctx = await stage.execute(ctx);
+            // Early exit checks
+            if (ctx.fieldChunks !== undefined && ctx.fieldChunks.length === 0) {
+                return null;
+            }
+            if (ctx.textMap !== undefined && Object.keys(ctx.textMap).length === 0) {
+                return null;
+            }
+        }
+        if (!ctx.filteredData) {
+            return null;
+        }
+        return {
+            translatedData: ctx.filteredData
+        };
+    }
+}
+
+//# sourceMappingURL=TranslationPipeline.js.map

package/dist/server/modules/translation-pipeline/TranslationPipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/modules/translation-pipeline/TranslationPipeline.ts"],"sourcesContent":["import type { TranslationProvider } from '../translation-providers'\nimport type { PipelineConfig, PipelineResult, PipelineContext, PipelineStage } from './types'\nimport type { TranslationStrategy } from './strategies'\nimport type { TextExpander } from './stages'\nimport {\n  DataReconcilerStage,\n  FieldChunkCollectorStage,\n  TranslationStage,\n  TextChunkExpanderStage,\n  TranslationMutatorStage,\n} from './stages'\n\n/**\n * Options for TranslationPipeline.\n */\nexport type TranslationPipelineOptions = {\n  translationProvider: TranslationProvider\n  translationStrategy: TranslationStrategy\n  textExpanders?: TextExpander[]\n}\n\n/**\n * Main orchestrator for the translation pipeline.\n * Coordinates all stages in sequence via PipelineContext.\n *\n * Pipeline stages:\n * 1. DataReconcilerStage - Reconcile source/target data preserving full document shape\n * 2. FieldChunkCollectorStage - Collect FieldChunks (schema-aware)\n * 3. TextChunkExpanderStage - Expand FieldChunks to TextChunks (schema-free)\n * 4. TranslationStage - Call translation provider\n * 5. TranslationMutatorStage - Apply translations via mutation\n *\n * Pipeline only transforms data. Saving is the caller's responsibility.\n */\nexport class TranslationPipeline {\n  private readonly stages: PipelineStage[]\n\n  constructor(options: TranslationPipelineOptions) {\n    this.stages = [\n      new DataReconcilerStage(),\n      new FieldChunkCollectorStage(options.translationStrategy),\n      new TextChunkExpanderStage(options.textExpanders),\n      new TranslationStage(options.translationProvider),\n      new TranslationMutatorStage(),\n    ]\n  }\n\n  /**\n   * Executes the translation pipeline.\n   * Returns transformed data ready to be saved, or null if nothing to translate.\n   */\n  async execute(config: PipelineConfig): Promise<PipelineResult | null> {\n    let ctx: PipelineContext = {\n      schema: config.schema,\n      sourceData: config.sourceData,\n      targetData: config.targetData,\n      sourceLng: config.sourceLng,\n      targetLng: config.targetLng,\n    }\n\n    for (const stage of this.stages) {\n      ctx = await stage.execute(ctx)\n\n      // Early exit checks\n      if (ctx.fieldChunks !== undefined && ctx.fieldChunks.length === 0) {\n        return null\n      }\n      if (ctx.textMap !== undefined && Object.keys(ctx.textMap).length === 0) {\n        return null\n      }\n    }\n\n    if (!ctx.filteredData) {\n      return null\n    }\n\n    return {\n      translatedData: ctx.filteredData,\n    }\n  }\n}\n"],"names":["DataReconcilerStage","FieldChunkCollectorStage","TranslationStage","TextChunkExpanderStage","TranslationMutatorStage","TranslationPipeline","stages","options","translationStrategy","textExpanders","translationProvider","execute","config","ctx","schema","sourceData","targetData","sourceLng","targetLng","stage","fieldChunks","undefined","length","textMap","Object","keys","filteredData","translatedData"],"mappings":"AAIA,SACEA,mBAAmB,EACnBC,wBAAwB,EACxBC,gBAAgB,EAChBC,sBAAsB,EACtBC,uBAAuB,QAClB,WAAU;AAWjB;;;;;;;;;;;;CAYC,GACD,OAAO,MAAMC;IACMC,OAAuB;IAExC,YAAYC,OAAmC,CAAE;QAC/C,IAAI,CAACD,MAAM,GAAG;YACZ,IAAIN;YACJ,IAAIC,yBAAyBM,QAAQC,mBAAmB;YACxD,IAAIL,uBAAuBI,QAAQE,aAAa;YAChD,IAAIP,iBAAiBK,QAAQG,mBAAmB;YAChD,IAAIN;SACL;IACH;IAEA;;;GAGC,GACD,MAAMO,QAAQC,MAAsB,EAAkC;QACpE,IAAIC,MAAuB;YACzBC,QAAQF,OAAOE,MAAM;YACrBC,YAAYH,OAAOG,UAAU;YAC7BC,YAAYJ,OAAOI,UAAU;YAC7BC,WAAWL,OAAOK,SAAS;YAC3BC,WAAWN,OAAOM,SAAS;QAC7B;QAEA,KAAK,MAAMC,SAAS,IAAI,CAACb,MAAM,CAAE;YAC/BO,MAAM,MAAMM,MAAMR,OAAO,CAACE;YAE1B,oBAAoB;YACpB,IAAIA,IAAIO,WAAW,KAAKC,aAAaR,IAAIO,WAAW,CAACE,MAAM,KAAK,GAAG;gBACjE,OAAO;YACT;YACA,IAAIT,IAAIU,OAAO,KAAKF,aAAaG,OAAOC,IAAI,CAACZ,IAAIU,OAAO,EAAED,MAAM,KAAK,GAAG;gBACtE,OAAO;YACT;QACF;QAEA,IAAI,CAACT,IAAIa,YAAY,EAAE;YACrB,OAAO;QACT;QAEA,OAAO;YACLC,gBAAgBd,IAAIa,YAAY;QAClC;IACF;AACF"}

package/dist/server/modules/translation-pipeline/TranslationPipeline.test.d.ts

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

package/dist/server/modules/translation-pipeline/TranslationPipeline.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TranslationPipeline.test.d.ts","sourceRoot":"","sources":["../../../../src/server/modules/translation-pipeline/TranslationPipeline.test.ts"],"names":[],"mappings":""}

package/dist/server/modules/translation-pipeline/TranslationPipeline.test.js

@@ -0,0 +1,552 @@
+import { describe, it, expect, vi } from 'vitest';
+import { TranslationPipeline } from './TranslationPipeline';
+import { OverwriteStrategy } from './strategies/Overwrite.strategy';
+import { SkipExistingStrategy } from './strategies/SkipExisting.strategy';
+const createMockProvider = (translationFn) => ({
+    translate: vi.fn().mockImplementation(async (textMap) => {
+        if (translationFn)
+            return translationFn(textMap);
+        // Default: prefix each value with "TR_"
+        const result = {};
+        for (const [key, value] of Object.entries(textMap)) {
+            result[Number(key)] = `TR_${value}`;
+        }
+        return result;
+    }),
+});
+describe('TranslationPipeline', () => {
+    describe('basic translation', () => {
+        it('translates simple text fields', async () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const sourceData = { title: 'Hello' };
+            const targetData = {};
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new OverwriteStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result).not.toBeNull();
+            expect(result.translatedData).toEqual({ title: 'TR_Hello' });
+            expect(provider.translate).toHaveBeenCalledWith({ 0: 'Hello' }, 'en', 'ru');
+        });
+        it('translates multiple fields', async () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'description', type: 'textarea', localized: true },
+            ];
+            const sourceData = { title: 'Hello', description: 'World' };
+            const targetData = {};
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new OverwriteStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result).not.toBeNull();
+            expect(result.translatedData).toEqual({ title: 'TR_Hello', description: 'TR_World' });
+        });
+        it('translates nested fields in groups', async () => {
+            const schema = [
+                {
+                    name: 'meta',
+                    type: 'group',
+                    fields: [{ name: 'title', type: 'text', localized: true }],
+                },
+            ];
+            const sourceData = { meta: { title: 'Hello' } };
+            const targetData = {};
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new OverwriteStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result).not.toBeNull();
+            expect(result.translatedData).toEqual({ meta: { title: 'TR_Hello' } });
+        });
+        it('translates array items', async () => {
+            const schema = [
+                {
+                    name: 'items',
+                    type: 'array',
+                    fields: [{ name: 'label', type: 'text', localized: true }],
+                },
+            ];
+            const sourceData = {
+                items: [
+                    { id: '1', label: 'First' },
+                    { id: '2', label: 'Second' },
+                ],
+            };
+            const targetData = {};
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new OverwriteStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result).not.toBeNull();
+            // Note: id is not included in result - Postgres rejects it on update
+            expect(result.translatedData).toEqual({
+                items: [{ label: 'TR_First' }, { label: 'TR_Second' }],
+            });
+        });
+    });
+    describe('richText translation', () => {
+        it('translates richText text nodes', async () => {
+            const schema = [{ name: 'content', type: 'richText', localized: true }];
+            const sourceData = {
+                content: {
+                    root: {
+                        type: 'root',
+                        children: [
+                            {
+                                type: 'paragraph',
+                                children: [{ type: 'text', text: 'Hello', version: 1 }],
+                                version: 1,
+                            },
+                        ],
+                        version: 1,
+                    },
+                },
+            };
+            const targetData = {};
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new OverwriteStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result).not.toBeNull();
+            // The richText structure should have translated text nodes
+            const content = result.translatedData.content;
+            expect(content.root.children[0].children[0].text).toBe('TR_Hello');
+        });
+    });
+    describe('strategy filtering', () => {
+        it('OverwriteStrategy translates all fields', async () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const sourceData = { title: 'Hello' };
+            const targetData = { title: 'Existing translation' };
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new OverwriteStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result).not.toBeNull();
+            expect(result.translatedData.title).toBe('TR_Hello');
+        });
+        it('SkipExistingStrategy skips fields with existing translations', async () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'description', type: 'text', localized: true },
+            ];
+            const sourceData = { title: 'Hello', description: 'World' };
+            const targetData = { title: 'Existing', description: '' };
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new SkipExistingStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result).not.toBeNull();
+            // Result contains full document shape
+            // title: kept from target (already translated)
+            // description: translated from source
+            expect(result.translatedData).toEqual({
+                title: 'Existing',
+                description: 'TR_World',
+            });
+        });
+    });
+    describe('early exit conditions', () => {
+        it('returns null when no localized fields', async () => {
+            const schema = [{ name: 'slug', type: 'text', localized: false }];
+            const sourceData = { slug: 'hello' };
+            const targetData = {};
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new OverwriteStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result).toBeNull();
+            expect(provider.translate).not.toHaveBeenCalled();
+        });
+        it('returns null when all fields already translated (SkipExisting)', async () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const sourceData = { title: 'Hello' };
+            const targetData = { title: 'Already translated' };
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new SkipExistingStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result).toBeNull();
+            expect(provider.translate).not.toHaveBeenCalled();
+        });
+        it('returns null when source fields are empty', async () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const sourceData = { title: '' };
+            const targetData = {};
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new OverwriteStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result).toBeNull();
+        });
+    });
+    describe('error handling', () => {
+        it('throws when translation provider returns null', async () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const sourceData = { title: 'Hello' };
+            const targetData = {};
+            const provider = {
+                translate: vi.fn().mockResolvedValue(null),
+            };
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new OverwriteStrategy(),
+            });
+            await expect(pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            })).rejects.toThrow('Translation provider returned null');
+        });
+    });
+    describe('data mutation', () => {
+        it('returns translated data without mutating original sourceData', async () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const sourceData = { title: 'Hello' };
+            const targetData = {};
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new OverwriteStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            // Result contains translated data
+            expect(result.translatedData.title).toBe('TR_Hello');
+            // Original sourceData is NOT mutated (pipeline works on filtered copy)
+            expect(sourceData.title).toBe('Hello');
+        });
+    });
+    describe('full document shape preservation', () => {
+        it('preserves non-localized fields in result', async () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'slug', type: 'text', localized: false },
+                { name: 'order', type: 'number', localized: false },
+            ];
+            const sourceData = { title: 'Hello', slug: 'hello', order: 1 };
+            const targetData = {};
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new OverwriteStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result.translatedData).toEqual({
+                title: 'TR_Hello',
+                slug: 'hello',
+                order: 1,
+            });
+        });
+        it('preserves existing target non-localized values', async () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'slug', type: 'text', localized: false },
+            ];
+            const sourceData = { title: 'Hello', slug: 'hello' };
+            const targetData = { title: '', slug: 'other-slug' };
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new OverwriteStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result.translatedData).toEqual({
+                title: 'TR_Hello',
+                slug: 'other-slug',
+            });
+        });
+        it('preserves existing target values with SkipExisting', async () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'description', type: 'text', localized: true },
+                { name: 'slug', type: 'text', localized: false },
+            ];
+            const sourceData = { title: 'Hello', description: 'World', slug: 'hello' };
+            const targetData = { title: 'Translated', description: '', slug: 'other' };
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new SkipExistingStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result.translatedData).toEqual({
+                title: 'Translated',
+                description: 'TR_World',
+                slug: 'other',
+            });
+        });
+    });
+    describe('nested structures with strategy', () => {
+        it('applies SkipExisting to nested array fields', async () => {
+            const schema = [
+                {
+                    name: 'items',
+                    type: 'array',
+                    fields: [{ name: 'label', type: 'text', localized: true }],
+                },
+            ];
+            const sourceData = {
+                items: [
+                    { id: '1', label: 'First' },
+                    { id: '2', label: 'Second' },
+                ],
+            };
+            const targetData = {
+                items: [
+                    { id: '1', label: 'Translated' },
+                    { id: '2', label: '' },
+                ],
+            };
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new SkipExistingStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            // Note: id is not included in result - Postgres rejects it on update
+            expect(result.translatedData.items).toEqual([{ label: 'Translated' }, { label: 'TR_Second' }]);
+        });
+        it('applies SkipExisting to nested group fields', async () => {
+            const schema = [
+                {
+                    name: 'meta',
+                    type: 'group',
+                    fields: [
+                        { name: 'title', type: 'text', localized: true },
+                        { name: 'description', type: 'text', localized: true },
+                    ],
+                },
+            ];
+            const sourceData = { meta: { title: 'Hello', description: 'World' } };
+            const targetData = { meta: { title: 'Translated', description: '' } };
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new SkipExistingStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result.translatedData.meta).toEqual({
+                title: 'Translated',
+                description: 'TR_World',
+            });
+        });
+        it('applies SkipExisting to blocks fields', async () => {
+            const schema = [
+                {
+                    name: 'layout',
+                    type: 'blocks',
+                    blocks: [
+                        {
+                            slug: 'text',
+                            fields: [{ name: 'content', type: 'text', localized: true }],
+                        },
+                    ],
+                },
+            ];
+            const sourceData = {
+                layout: [
+                    { id: '1', blockType: 'text', content: 'Hello' },
+                    { id: '2', blockType: 'text', content: 'World' },
+                ],
+            };
+            const targetData = {
+                layout: [
+                    { id: '1', blockType: 'text', content: 'Translated' },
+                    { id: '2', blockType: 'text', content: '' },
+                ],
+            };
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new SkipExistingStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            // Note: id is not included in result - Postgres rejects it on update
+            expect(result.translatedData.layout).toEqual([
+                { blockType: 'text', content: 'Translated' },
+                { blockType: 'text', content: 'TR_World' },
+            ]);
+        });
+    });
+    describe('translateKit.exclude handling', () => {
+        it('skips excluded fields from translation', async () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                {
+                    name: 'sku',
+                    type: 'text',
+                    localized: true,
+                    custom: { translateKit: { exclude: true } },
+                },
+            ];
+            const sourceData = { title: 'Hello', sku: 'SKU-123' };
+            const targetData = { sku: 'SKU-456' };
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new OverwriteStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result.translatedData.title).toBe('TR_Hello');
+            expect(result.translatedData.sku).toBe('SKU-456');
+        });
+        it('uses source value for excluded fields when target is empty', async () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                {
+                    name: 'sku',
+                    type: 'text',
+                    localized: true,
+                    custom: { translateKit: { exclude: true } },
+                },
+            ];
+            const sourceData = { title: 'Hello', sku: 'SKU-123' };
+            const targetData = {};
+            const provider = createMockProvider();
+            const pipeline = new TranslationPipeline({
+                translationProvider: provider,
+                translationStrategy: new OverwriteStrategy(),
+            });
+            const result = await pipeline.execute({
+                schema,
+                sourceData,
+                targetData,
+                sourceLng: 'en',
+                targetLng: 'ru',
+            });
+            expect(result.translatedData.title).toBe('TR_Hello');
+            expect(result.translatedData.sku).toBe('SKU-123');
+        });
+    });
+});

package/dist/server/modules/translation-pipeline/index.d.ts

@@ -0,0 +1,4 @@
+export { TranslationPipeline } from './TranslationPipeline';
+export type { TranslationStrategy } from './strategies';
+export { OverwriteStrategy, SkipExistingStrategy } from './strategies';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/modules/translation-pipeline/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/server/modules/translation-pipeline/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAC3D,YAAY,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AACvD,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA"}

package/dist/server/modules/translation-pipeline/index.js

@@ -0,0 +1,4 @@
+export { TranslationPipeline } from './TranslationPipeline';
+export { OverwriteStrategy, SkipExistingStrategy } from './strategies';
+
+//# sourceMappingURL=index.js.map

package/dist/server/modules/translation-pipeline/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/modules/translation-pipeline/index.ts"],"sourcesContent":["export { TranslationPipeline } from './TranslationPipeline'\nexport type { TranslationStrategy } from './strategies'\nexport { OverwriteStrategy, SkipExistingStrategy } from './strategies'\n"],"names":["TranslationPipeline","OverwriteStrategy","SkipExistingStrategy"],"mappings":"AAAA,SAASA,mBAAmB,QAAQ,wBAAuB;AAE3D,SAASC,iBAAiB,EAAEC,oBAAoB,QAAQ,eAAc"}

package/dist/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.d.ts

@@ -0,0 +1,26 @@
+import type { Field } from 'payload';
+/**
+ * Deep merges source and target data with target priority.
+ * Creates full document shape needed for Payload validation.
+ *
+ * Logic:
+ * - If targetValue exists and is not empty → use targetValue
+ * - Otherwise → use sourceValue
+ *
+ * Stage 1 of the translation pipeline.
+ */
+export declare class DataReconciler {
+    private readonly schema;
+    constructor(schema: Field[]);
+    /**
+     * Reconciles source and target data into a complete document shape.
+     * The result contains all fields needed for Payload validation.
+     *
+     * @param sourceData - Source locale document data
+     * @param targetData - Target locale document data (may be empty/partial)
+     * @returns Complete document shape with reconciled field values
+     */
+    reconcile(sourceData: Record<string, unknown>, targetData: Record<string, unknown>): Record<string, unknown>;
+    private reconcileFields;
+}
+//# sourceMappingURL=DataReconciler.d.ts.map

package/dist/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataReconciler.d.ts","sourceRoot":"","sources":["../../../../../../src/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAKpC;;;;;;;;;GASG;AACH,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,KAAK,EAAE;IAE5C;;;;;;;OAOG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAI5G,OAAO,CAAC,eAAe;CAiFxB"}