@sequoialabs/payload-plugin-reversia 0.1.4 → 0.1.6

package/dist/utils/fields.js

@@ -179,16 +179,23 @@ function describeTopLevelField(field) {
     }
     // Structured wrapper: group / array / blocks. Walk inside to collect
     // localized descendant leaves; emit a container only if any were found.
+    //
+    // When the top-level field itself is `localized: true`, ALL its inner
+    // translatable fields are inherently locale-specific (the whole container
+    // is stored per-locale). Payload may strip `localized: true` from inner
+    // fields in this case, so we pass `parentIsLocalized` to treat them as
+    // localized regardless.
+    const fieldIsLocalized = isLocalized(field);
     const innerLeaves = [];
     if (isGroupLikeField(field)) {
-        collectLeaves(field.fields, [], innerLeaves);
+        collectLeaves(field.fields, [], innerLeaves, fieldIsLocalized);
     }
     else if (isArrayField(field)) {
-        collectLeaves(field.fields, [{ kind: 'iterate' }], innerLeaves);
+        collectLeaves(field.fields, [{ kind: 'iterate' }], innerLeaves, fieldIsLocalized);
     }
     else if (isBlocksField(field)) {
         for (const block of field.blocks) {
-            collectLeaves(block.fields, [{ kind: 'iterateBlock', blockSlug: block.slug }], innerLeaves);
+            collectLeaves(block.fields, [{ kind: 'iterateBlock', blockSlug: block.slug }], innerLeaves, fieldIsLocalized);
         }
     }
     else {
@@ -211,7 +218,7 @@ function describeTopLevelField(field) {
         hasRequiredLeaf: true,
     };
 }
-function collectLeaves(fields, parentSegments, out) {
+function collectLeaves(fields, parentSegments, out, parentIsLocalized = false) {
     for (const field of fields) {
         if (!isNamed(field)) {
             if (isTabsField(field)) {
@@ -219,19 +226,23 @@ function collectLeaves(fields, parentSegments, out) {
                     const tabSegments = 'name' in tab && typeof tab.name === 'string' && tab.name.length > 0
                         ? [...parentSegments, { kind: 'key', name: tab.name }]
                         : parentSegments;
-                    collectLeaves(tab.fields, tabSegments, out);
+                    collectLeaves(tab.fields, tabSegments, out, parentIsLocalized);
                 }
             }
             if ((field.type === 'row' || field.type === 'collapsible') &&
                 'fields' in field &&
                 Array.isArray(field.fields)) {
-                collectLeaves(field.fields, parentSegments, out);
+                collectLeaves(field.fields, parentSegments, out, parentIsLocalized);
             }
             continue;
         }
         const segments = [...parentSegments, { kind: 'key', name: field.name }];
         const reversia = getReversiaCustom(field);
         const localized = isLocalized(field);
+        // Scalars (text, textarea, etc.) must be explicitly `localized: true` to
+        // be treated as translatable. Scalars inside a localized parent that
+        // aren't marked localized are structural (keys, enums) — translating
+        // "who" to "qui" would break app logic.
         if (localized && isScalarPayloadType(field.type)) {
             out.push({
                 segments,
@@ -241,7 +252,12 @@ function collectLeaves(fields, parentSegments, out) {
             });
             continue;
         }
-        if (localized && (field.type === 'richText' || field.type === 'json')) {
+        // RichText/json fields inherit localized status from their parent. Payload
+        // may strip `localized: true` from inner fields when the parent container
+        // is already localized (the whole container is per-locale, so inner
+        // localization is redundant). These are always translatable content.
+        const effectivelyLocalized = localized || parentIsLocalized;
+        if (effectivelyLocalized && (field.type === 'richText' || field.type === 'json')) {
             out.push({
                 segments,
                 kind: 'json',
@@ -251,16 +267,17 @@ function collectLeaves(fields, parentSegments, out) {
             continue;
         }
         if (isGroupLikeField(field)) {
-            collectLeaves(field.fields, segments, out);
+            collectLeaves(field.fields, segments, out, parentIsLocalized);
             continue;
         }
         if (isArrayField(field)) {
-            collectLeaves(field.fields, [...segments, { kind: 'iterate' }], out);
+            collectLeaves(field.fields, [...segments, { kind: 'iterate' }], out, parentIsLocalized || isLocalized(field));
             continue;
         }
         if (isBlocksField(field)) {
+            const blocksLocalized = parentIsLocalized || isLocalized(field);
             for (const block of field.blocks) {
-                collectLeaves(block.fields, [...segments, { kind: 'iterateBlock', blockSlug: block.slug }], out);
+                collectLeaves(block.fields, [...segments, { kind: 'iterateBlock', blockSlug: block.slug }], out, blocksLocalized);
             }
         }
     }
@@ -855,9 +872,13 @@ export function deflatePopulatedRelationships(value) {
     return out;
 }
 /**
- * Deflate a single value: if it's a populated doc, return its id. If it's a
- * polymorphic relationship `{ relationTo, value: <populated> }`, deflate the
- * inner value. Otherwise recurse.
+ * Deflate a single value: if it's a populated doc, return its id. If it's an
+ * object with a `relationTo` + populated `value` (polymorphic relationship OR
+ * Lexical upload/relationship node), deflate only the `value` property while
+ * preserving all other keys (`type`, `children`, `version`, `format`, …).
+ *
+ * Previous implementation returned `{ relationTo, value: id }` which stripped
+ * Lexical node metadata and corrupted richText trees.
  */
 function deflateValue(val) {
     if (val === null || val === undefined || typeof val !== 'object') {
@@ -866,30 +887,51 @@ function deflateValue(val) {
     if (Array.isArray(val)) {
         return val.map(deflateValue);
     }
-    // Direct populated doc → raw id  (e.g. upload field: { id, filename, ... })
-    if (isPopulatedDoc(val)) {
-        return val.id;
-    }
-    // Polymorphic relationship: { relationTo: 'x', value: <populated> }
     const obj = val;
-    if (typeof obj.relationTo === 'string' && 'value' in obj && isPopulatedDoc(obj.value)) {
-        return { relationTo: obj.relationTo, value: obj.value.id };
-    }
-    // hasMany polymorphic: { relationTo: 'x', value: [<populated>, ...] }
-    if (typeof obj.relationTo === 'string' && Array.isArray(obj.value)) {
-        return {
-            relationTo: obj.relationTo,
-            value: obj.value.map((item) => isPopulatedDoc(item) ? item.id : item),
-        };
+    // Direct populated doc → raw id (e.g. upload field stored as { id, filename, … })
+    // Only match when the object has NO other "structural" keys that indicate
+    // it's a Lexical node or rich object we shouldn't collapse.
+    if (isPopulatedDoc(obj) && !isStructuralNode(obj)) {
+        return obj.id;
+    }
+    // Object with `relationTo` + populated `value` — this matches both Payload
+    // polymorphic relationships AND Lexical upload/relationship nodes.
+    // Deflate only the `value` key; preserve everything else.
+    if (typeof obj.relationTo === 'string' && 'value' in obj) {
+        if (isPopulatedDoc(obj.value)) {
+            const out = {};
+            for (const [k, v] of Object.entries(obj)) {
+                out[k] = k === 'value' ? obj.value.id : deflateValue(v);
+            }
+            return out;
+        }
+        if (Array.isArray(obj.value)) {
+            const out = {};
+            for (const [k, v] of Object.entries(obj)) {
+                out[k] =
+                    k === 'value'
+                        ? v.map((item) => isPopulatedDoc(item) ? item.id : item)
+                        : deflateValue(v);
+            }
+            return out;
+        }
     }
     // Recurse into nested structure
     return deflatePopulatedRelationships(val);
 }
+/**
+ * A "structural node" is an object that carries its own semantics beyond being
+ * a populated relationship doc — e.g. a Lexical node with `type`, `children`,
+ * `version`. Collapsing it to just its `id` would destroy the tree.
+ */
+function isStructuralNode(obj) {
+    return typeof obj.type === 'string' || 'children' in obj || 'version' in obj;
+}
 function isPopulatedDoc(val) {
     if (!val || typeof val !== 'object' || Array.isArray(val)) {
         return false;
     }
     const obj = val;
-    return (typeof obj.id === 'string' &&
-        ('createdAt' in obj || 'updatedAt' in obj || 'filename' in obj || 'mimeType' in obj));
+    const hasId = typeof obj.id === 'string' || typeof obj.id === 'number';
+    return (hasId && ('createdAt' in obj || 'updatedAt' in obj || 'filename' in obj || 'mimeType' in obj));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sequoialabs/payload-plugin-reversia",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "author": {
     "name": "Jean Walrave",
     "email": "contact@reversia.tech",