@focus-reactive/payload-plugin-translator 0.7.0 → 0.7.2

package/README.md

@@ -370,6 +370,9 @@ import type {
   FieldTranslationConfig,
   AccessGuard,
   AccessGuardRequest,
+  TranslationTask, // descriptor passed to the lifecycle callbacks — Since v0.7.0
+  TranslationLifecycleCallbacks, // shape of the `lifecycle` config — Since v0.7.0
+  TranslationProvenanceRecord, // a stored provenance row — Since v0.7.0
 } from "@focus-reactive/payload-plugin-translator";
 ```
 
@@ -379,9 +382,11 @@ Every public API is annotated with `@since x.y.z` in its JSDoc, and features car
 
 ## Roadmap
 
+Planned features building on the v0.7.0 provenance foundation:
+
+- **Stale-translation detection** — surface which target locales are out of sync with their source, using the recorded provenance fingerprint.
 - **Global translation dashboard** — translate across all collections from one place, with project-wide progress.
-- **Vercel Cron runner** — a built-in runner for serverless deploys without manual API-route wiring.
-- **Auto-translate on source change** — trigger translation automatically when default-locale content changes.
+- **Auto-translate on source change** — retranslate automatically when default-locale content changes.
 
 ## License
 

package/dist/core/field-traversal/types.d.ts

@@ -11,13 +11,15 @@ export interface BlockLike {
 }
 /**
  * A tab as this layer needs to read it: an optional `name` (present → it opens a data boundary;
- * absent → it flattens into the parent scope) and its child `fields`. Payload's `Tab`
- * (`NamedTab | UnnamedTab`) is assignable to this.
+ * absent → it flattens into the parent scope), its child `fields`, and `localized` (a *named* tab
+ * may be `localized`, partitioning its subtree per locale — Payload's sanitizer propagates it the
+ * same as a group). Payload's `Tab` (`NamedTab | UnnamedTab`) is assignable to this.
  *
  * @public
  */
 export interface TabLike {
     name?: string;
+    localized?: boolean;
     fields: FieldLike[];
 }
 /**

package/dist/core/translation-pipeline/stages/data-reconciler/DataReconciler.js

@@ -5,9 +5,9 @@ const asObject = (value)=>isObject(value) ? value : {};
 /**
  * Reconcile walker: produces the full document shape from source + target, with target
  * priority (source fills empty target slots). Iteration is driven by `source`; a field with
- * no source value is dropped, `id` is stripped from array/block elements (Postgres rejects it
- * on update), `blockType` is preserved, and non-object array items / unknown blocks pass
- * through unchanged.
+ * no source value is dropped, `blockType` is preserved, non-object array items / unknown blocks
+ * pass through unchanged, and array/block `id` is kept for shared rows but stripped for per-locale
+ * rows (see {@link Cursor.sharedRow} — the data-loss-critical bit).
  *
  * Array/block elements are paired with their target counterpart by `id`, not by position (see
  * {@link matchElementById}); output order always follows `source`.
@@ -15,9 +15,12 @@ const asObject = (value)=>isObject(value) ? value : {};
     enterObject (field, cursor) {
         const sourceValue = cursor.source[field.name];
         if (!isObject(sourceValue)) return "skip"; // undefined / non-object source → drop the field
+        // A localized group or named tab partitions its whole subtree per locale → descendants are
+        // per-locale rows (Payload's sanitizer propagates `tab.localized` the same as a group).
         return {
             source: sourceValue,
-            target: asObject(cursor.target[field.name])
+            target: asObject(cursor.target[field.name]),
+            sharedRow: cursor.sharedRow && !field.localized
         };
     },
     enterList (field, cursor) {
@@ -26,6 +29,8 @@ const asObject = (value)=>isObject(value) ? value : {};
         const targetValue = cursor.target[field.name];
         const targetArr = Array.isArray(targetValue) ? targetValue : [];
         const isBlocks = field.type === "blocks";
+        // Elements are shared rows only when this container AND every ancestor is non-localized.
+        const childShared = cursor.sharedRow && !field.localized;
         const children = [];
         sourceValue.forEach((item, index)=>{
             if (!isObject(item)) return; // non-object element → passthrough (rebuilt in combine)
@@ -35,7 +40,8 @@ const asObject = (value)=>isObject(value) ? value : {};
             children.push({
                 cursor: {
                     source: item,
-                    target: matchElementById(targetArr, item, isBlocks)
+                    target: matchElementById(targetArr, item, isBlocks),
+                    sharedRow: childShared
                 },
                 fields,
                 key: index
@@ -58,13 +64,29 @@ const asObject = (value)=>isObject(value) ? value : {};
                     child.key,
                     child.out
                 ]));
-            return sourceArr.map((item, index)=>byIndex.has(index) ? byIndex.get(index) : item);
+            // Passthrough items (unknown blockType / unresolved fields) never reach the element branch's
+            // id guard, so apply the same rule here: strip a per-locale row's id to avoid an insert
+            // collision. Elements are shared only when this container and every ancestor is non-localized.
+            const childShared = cursor.sharedRow && !container.field.localized;
+            return sourceArr.map((item, index)=>{
+                if (byIndex.has(index)) return byIndex.get(index);
+                if (!childShared && isObject(item) && item.id != null) {
+                    const { id: _dropped, ...rest } = item;
+                    return rest;
+                }
+                return item;
+            });
         }
         const result = {};
         for (const child of children)result[child.key] = child.out;
-        // Block elements keep their blockType; id is intentionally stripped (Postgres rejects it on update).
-        if (container.kind === "element" && container.field.type === "blocks") {
-            result.blockType = cursor.source.blockType;
+        if (container.kind === "element") {
+            // Block elements keep their blockType.
+            if (container.field.type === "blocks") result.blockType = cursor.source.blockType;
+            // Keep `id` only for a shared (non-localized, no localized ancestor) row so Payload updates it
+            // in place; stripping it there makes Payload recreate the row and wipe other locales. Under a
+            // localized container/ancestor the rows are per-locale, so the id is dropped to avoid an
+            // insert collision with the source locale's row. Guard against writing `id: undefined`.
+            if (cursor.sharedRow && cursor.source.id != null) result.id = cursor.source.id;
         }
         return result;
     }
@@ -88,7 +110,8 @@ const asObject = (value)=>isObject(value) ? value : {};
    */ reconcile(sourceData, targetData) {
         const root = {
             source: sourceData,
-            target: targetData ?? {}
+            target: targetData ?? {},
+            sharedRow: true
         };
         return walkFields(this.schema, root, reconcileWalker) ?? {};
     }

package/package.json

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