@sequoialabs/payload-plugin-reversia 0.1.3 → 0.1.5

package/dist/endpoints/resources-insert.js

@@ -18,7 +18,8 @@ async function withRetry(fn) {
         }
         catch (error) {
             if (attempt < WRITE_CONFLICT_MAX_RETRIES && isWriteConflict(error)) {
-                const delay = WRITE_CONFLICT_BASE_DELAY_MS * 2 ** attempt + Math.random() * WRITE_CONFLICT_BASE_DELAY_MS;
+                const delay = WRITE_CONFLICT_BASE_DELAY_MS * 2 ** attempt +
+                    Math.random() * WRITE_CONFLICT_BASE_DELAY_MS;
                 await new Promise((resolve) => setTimeout(resolve, delay));
                 continue;
             }
@@ -65,7 +66,19 @@ function applyTranslations({ allowedFields, data, sourceDoc, previousDoc, }) {
     const previous = previousDoc ?? null;
     const source = cleanSource ?? null;
     const dataKeys = new Set(Object.keys(data));
-    // Seed required fields that are empty in target and not being translated.
+    // Seed required fields not being translated so Payload's whole-document
+    // validation doesn't reject the update.
+    //
+    // Scalars: only seed when the target locale has no value at all (null /
+    // undefined / empty string). If the target already has something, leave it.
+    //
+    // Containers: always seed from source when not in `data`. The target might
+    // have a "structurally present but content-empty" value (e.g. Payload
+    // auto-creates 9 default block items from `defaultValue` but every block's
+    // required inner richText is null). A shallow null-check misses this; a
+    // deep check is impractical. Seeding writes source-locale content as a
+    // placeholder — once Reversia translates the field and sends it in `data`,
+    // the seed is overwritten with the real translation.
     for (const field of allowedFields) {
         if (!field.hasRequiredLeaf) {
             continue;
@@ -73,18 +86,22 @@ function applyTranslations({ allowedFields, data, sourceDoc, previousDoc, }) {
         if (dataKeys.has(field.name)) {
             continue; // Reversia is sending it — will be handled below
         }
-        const targetValue = previous ? previous[field.name] : undefined;
-        if (targetValue !== undefined && targetValue !== null) {
-            continue; // Target already has a value — don't overwrite
-        }
         const sourceValue = source ? source[field.name] : undefined;
         if (sourceValue === undefined || sourceValue === null) {
             continue; // Source is also empty — nothing we can do
         }
-        // Seed from source so Payload's required validation doesn't reject.
-        updateData[field.name] = field.isContainer
-            ? deflatePopulatedRelationships(structuredClone(sourceValue))
-            : sourceValue;
+        if (field.isContainer) {
+            // Always seed containers from source — inner required subfields may be
+            // empty even when the container itself is non-null in the target.
+            updateData[field.name] = deflatePopulatedRelationships(structuredClone(sourceValue));
+        }
+        else {
+            // Scalars: only seed when truly empty in target.
+            const targetValue = previous ? previous[field.name] : undefined;
+            if (targetValue === undefined || targetValue === null || targetValue === '') {
+                updateData[field.name] = sourceValue;
+            }
+        }
     }
     for (const [fieldName, translatedValue] of Object.entries(data)) {
         const field = fieldByName.get(fieldName);

package/dist/utils/fields.js

@@ -855,9 +855,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 +870,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.3",
+  "version": "0.1.5",
   "author": {
     "name": "Jean Walrave",
     "email": "contact@reversia.tech",