@sequoialabs/payload-plugin-reversia 0.1.0 → 0.1.1

package/dist/endpoints/resources-insert.js

@@ -1,5 +1,5 @@
 import { unauthorizedResponse, validateApiKey } from '../utils/auth.js';
-import { cloneLocalizedContainersFromSource, deserializeFieldValue, findLocalizedFields, } from '../utils/fields.js';
+import { deflatePopulatedRelationships, deserializeFieldValue, findLocalizedFields, } from '../utils/fields.js';
 function stringifyDiffValue(value) {
     if (typeof value === 'string') {
         return value;
@@ -21,14 +21,23 @@ function indexFieldsByName(fields) {
 }
 function applyTranslations({ allowedFields, data, sourceDoc, previousDoc, }) {
     const fieldByName = indexFieldsByName(allowedFields);
-    // Source clone is the base — required nested siblings are preserved even
-    // when Reversia only sends a subset of leaves (mirrors the PrestaShop
-    // module's "clone source, replace with what we got" approach).
-    const updateData = cloneLocalizedContainersFromSource(sourceDoc, allowedFields);
+    // Deflate the source doc ONCE before anything reads from it. Payload's
+    // Lexical `afterRead` populates relationship/upload fields inside block
+    // nodes even at `depth: 0`, and the internal `payloadDataLoader` cache can
+    // serve a populated version from a prior higher-depth fetch. Deflating here
+    // guarantees `deserializeFieldValue` sees plain string IDs everywhere — not
+    // populated `{ id, filename, url }` objects that Payload's update validator
+    // rejects.
+    const cleanSource = sourceDoc ? deflatePopulatedRelationships(sourceDoc) : null;
+    // Build updateData ONLY from fields Reversia actually sent translations for.
+    // Never pre-clone containers that aren't being translated — writing them
+    // back would overwrite other locales' existing values with source-language
+    // content, because Payload's update replaces the entire localized slot.
+    const updateData = {};
     const diff = {};
     const acceptedFields = [];
     const previous = previousDoc ?? null;
-    const source = sourceDoc ?? null;
+    const source = cleanSource ?? null;
     for (const [fieldName, translatedValue] of Object.entries(data)) {
         const field = fieldByName.get(fieldName);
         if (!field) {
@@ -91,11 +100,13 @@ export function createResourcesInsertEndpoint(pluginConfig, collectionsMap, glob
                             continue;
                         }
                         const allowedFields = findLocalizedFields(globalConfig.fields);
-                        // Always fetch source — required to populate non-localized siblings
-                        // and to deserialize JSON-pointer maps. Target fetch is for diff.
+                        // depth: 0 is critical — without it, Payload populates relationship
+                        // and upload fields as full objects instead of raw IDs. Our clone
+                        // would then write those objects back, which Payload's validator
+                        // rejects with "invalid relationships: [object Object]".
                         const [sourceDoc, previousDoc] = await Promise.all([
-                            req.payload.findGlobal({ slug: globalSlug, locale: item.sourceLocale }),
-                            req.payload.findGlobal({ slug: globalSlug, locale: item.targetLocale }),
+                            req.payload.findGlobal({ slug: globalSlug, locale: item.sourceLocale, depth: 0 }),
+                            req.payload.findGlobal({ slug: globalSlug, locale: item.targetLocale, depth: 0 }),
                         ]);
                         const { updateData, diff, acceptedFields } = applyTranslations({
                             allowedFields,
@@ -136,11 +147,13 @@ export function createResourcesInsertEndpoint(pluginConfig, collectionsMap, glob
                             collection: slug,
                             id: item.id,
                             locale: item.sourceLocale,
+                            depth: 0,
                         }),
                         req.payload.findByID({
                             collection: slug,
                             id: item.id,
                             locale: item.targetLocale,
+                            depth: 0,
                         }),
                     ]);
                     const { updateData, diff, acceptedFields } = applyTranslations({
@@ -163,12 +176,61 @@ export function createResourcesInsertEndpoint(pluginConfig, collectionsMap, glob
                     response[index] = { index, type: item.type, id: item.id, diff };
                 }
                 catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    req.payload.logger.error({ err: error, item: { type: item.type, id: item.id, targetLocale: item.targetLocale } }, '[reversia] insertion failed');
-                    response.errors.push(`Item ${index} (${item.type}${item.id ? ` ${item.id}` : ''} → ${item.targetLocale}): ${message}`);
+                    recordInsertionFailure(req, response, error, index, item);
                 }
             }
             return Response.json(response);
         },
     };
 }
+/**
+ * Payload's ValidationError stashes structured field-level diagnostics on
+ * `error.data.errors` (`[{ field, message }]`). Pull them out so the Reversia
+ * warn log carries enough context to pinpoint which field blew up on which
+ * item without needing to tail the Payload server logs.
+ */
+function extractPayloadFieldErrors(error) {
+    if (!error || typeof error !== 'object') {
+        return undefined;
+    }
+    const data = error.data;
+    if (!data || typeof data !== 'object') {
+        return undefined;
+    }
+    const errors = data.errors;
+    if (!Array.isArray(errors)) {
+        return undefined;
+    }
+    const out = [];
+    for (const entry of errors) {
+        if (!entry || typeof entry !== 'object') {
+            continue;
+        }
+        const field = entry.field;
+        const path = entry.path;
+        const message = entry.message;
+        out.push({
+            field: typeof field === 'string' ? field : typeof path === 'string' ? path : '(unknown)',
+            message: typeof message === 'string' ? message : '(unknown)',
+        });
+    }
+    return out.length > 0 ? out : undefined;
+}
+function recordInsertionFailure(req, response, error, index, item) {
+    const message = error instanceof Error ? error.message : String(error);
+    const fieldErrors = extractPayloadFieldErrors(error);
+    req.payload.logger.error({
+        err: error,
+        item: {
+            type: item.type,
+            id: item.id,
+            targetLocale: item.targetLocale,
+            dataKeys: Object.keys(item.data ?? {}),
+        },
+        fieldErrors,
+    }, '[reversia] insertion failed');
+    const fieldSummary = fieldErrors
+        ? ` [${fieldErrors.map((e) => `${e.field}: ${e.message}`).join('; ')}]`
+        : '';
+    response.errors.push(`Item ${index} (${item.type}${item.id ? ` ${item.id}` : ''} → ${item.targetLocale}): ${message}${fieldSummary}`);
+}

package/dist/utils/fields.d.ts

@@ -56,3 +56,17 @@ export declare function deserializeFieldValue(field: LocalizedFieldInfo, sourceV
  * a subset of leaves.
  */
 export declare function cloneLocalizedContainersFromSource(sourceDoc: unknown, fields: readonly LocalizedFieldInfo[]): Record<string, unknown>;
+/**
+ * Payload's Lexical `afterRead` populates relationship / upload fields inside
+ * block nodes even when the top-level query uses `depth: 0`. This means a
+ * source-locale clone can contain
+ *   `media: { id: '...', filename: '...', url: '...' }`
+ * where Payload's `update()` expects a plain string ID. On write, Payload's
+ * relationship validator sees `[object Object]` and rejects.
+ *
+ * This utility walks ANY value tree and replaces populated-looking objects
+ * (plain objects with a string `id` property at positions where a raw ID is
+ * expected — i.e. inside Lexical block node `fields`) with just their `id`.
+ * Top-level and non-block objects are left untouched.
+ */
+export declare function deflatePopulatedRelationships(value: unknown): unknown;

package/dist/utils/fields.js

@@ -502,8 +502,7 @@ export function deserializeFieldValue(field, sourceValue, translatedRaw) {
 }
 function bucketTranslationsByLeaf(field, translations) {
     // Order leaves by descending segment length so deeper / more specific leaves
-    // claim pointers before broader catch-alls. (Stable for the common
-    // shallow-only schema.)
+    // claim pointers before broader catch-alls.
     const ordered = [...field.leaves].sort((a, b) => b.segments.length - a.segments.length);
     const remaining = new Map(Object.entries(translations));
     const buckets = [];
@@ -518,10 +517,17 @@ function bucketTranslationsByLeaf(field, translations) {
                 }
                 continue;
             }
-            if (leafPath === null) {
-                continue;
+            // json leaf: match by static prefix when possible (key-only segments),
+            // or by structural pattern when the leaf is under an iterate/block
+            // segment (leafPath is null because we can't build a static prefix —
+            // the pointer contains a numeric array index that varies per instance).
+            if (leafPath !== null) {
+                if (leafPath === '' || pointerStartsWith(pointer, leafPath)) {
+                    entries[pointer] = value;
+                    remaining.delete(pointer);
+                }
             }
-            if (leafPath === '' || pointerStartsWith(pointer, leafPath)) {
+            else if (matchesJsonLeafPattern(pointer, leaf)) {
                 entries[pointer] = value;
                 remaining.delete(pointer);
             }
@@ -532,6 +538,40 @@ function bucketTranslationsByLeaf(field, translations) {
     }
     return buckets;
 }
+/**
+ * For json leaves under iterate/iterateBlock segments, check if a pointer
+ * structurally matches the leaf's pattern: key segments match literally,
+ * iterate/iterateBlock segments match any numeric index, and the pointer
+ * may extend deeper (sub-pointers inside the json value).
+ */
+function matchesJsonLeafPattern(pointer, leaf) {
+    if (pointer === '') {
+        return leaf.segments.length === 0;
+    }
+    const parts = pointer.slice(1).split('/');
+    let p = 0;
+    for (const seg of leaf.segments) {
+        if (p >= parts.length) {
+            return false;
+        }
+        if (seg.kind === 'key') {
+            if (parts[p] !== seg.name) {
+                return false;
+            }
+            p++;
+        }
+        else {
+            // iterate / iterateBlock: expect a numeric index
+            if (!/^\d+$/.test(parts[p])) {
+                return false;
+            }
+            p++;
+        }
+    }
+    // The pointer matched all leaf segments and may extend deeper into the
+    // json value (sub-pointers like /root/children/0/text). That's expected.
+    return true;
+}
 /**
  * For a scalar leaf, the incoming pointer must address exactly the leaf's
  * structural shape: every `key` segment becomes a literal pointer segment;
@@ -702,6 +742,18 @@ export function cloneLocalizedContainersFromSource(sourceDoc, fields) {
     }
     const src = sourceDoc;
     for (const field of fields) {
+        // Only containers need a source-clone base — they carry required nested
+        // siblings (array/block ids, blockType, non-localized subfields) that
+        // Payload will re-validate on update. Top-level scalars are independent
+        // per-locale values: if Reversia hasn't translated one yet, leaving it out
+        // of `updateData` preserves whatever the target locale already has.
+        // Writing the source-locale scalar into the target locale is actively
+        // harmful — any `validate: (value, { locale }) => …` on the field (common
+        // on `title`, `slug`, etc.) would see the wrong-language value and reject
+        // the update.
+        if (!field.isContainer) {
+            continue;
+        }
         if (!(field.name in src)) {
             continue;
         }
@@ -709,7 +761,78 @@ export function cloneLocalizedContainersFromSource(sourceDoc, fields) {
         if (value === undefined || value === null) {
             continue;
         }
-        out[field.name] = field.isContainer ? structuredClone(value) : value;
+        out[field.name] = deflatePopulatedRelationships(structuredClone(value));
     }
     return out;
 }
+/**
+ * Payload's Lexical `afterRead` populates relationship / upload fields inside
+ * block nodes even when the top-level query uses `depth: 0`. This means a
+ * source-locale clone can contain
+ *   `media: { id: '...', filename: '...', url: '...' }`
+ * where Payload's `update()` expects a plain string ID. On write, Payload's
+ * relationship validator sees `[object Object]` and rejects.
+ *
+ * This utility walks ANY value tree and replaces populated-looking objects
+ * (plain objects with a string `id` property at positions where a raw ID is
+ * expected — i.e. inside Lexical block node `fields`) with just their `id`.
+ * Top-level and non-block objects are left untouched.
+ */
+export function deflatePopulatedRelationships(value) {
+    if (value === null || value === undefined || typeof value !== 'object') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(deflatePopulatedRelationships);
+    }
+    const obj = value;
+    // Lexical block node — deflate populated fields
+    if (obj.type === 'block' && obj.fields && typeof obj.fields === 'object') {
+        const fields = obj.fields;
+        const deflated = {};
+        for (const [key, val] of Object.entries(fields)) {
+            if (key === 'id' || key === 'blockType' || key === 'blockName') {
+                deflated[key] = val;
+            }
+            else if (Array.isArray(val)) {
+                deflated[key] = val.map((item) => isPopulatedDoc(item) ? item.id : item);
+            }
+            else if (isPopulatedDoc(val)) {
+                deflated[key] = val.id;
+            }
+            else {
+                deflated[key] = val;
+            }
+        }
+        return {
+            ...obj,
+            fields: deflated,
+            ...(Array.isArray(obj.children)
+                ? { children: obj.children.map(deflatePopulatedRelationships) }
+                : {}),
+        };
+    }
+    // Non-block node — recurse into children only (don't touch field values at
+    // other levels, they come from the DB via depth: 0 which handles them).
+    if (Array.isArray(obj.children)) {
+        return {
+            ...obj,
+            children: obj.children.map(deflatePopulatedRelationships),
+        };
+    }
+    // Plain object (group value, etc.) — recurse all keys in case there are
+    // nested Lexical trees or arrays.
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        out[k] = deflatePopulatedRelationships(v);
+    }
+    return out;
+}
+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));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sequoialabs/payload-plugin-reversia",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "author": {
     "name": "Jean Walrave",
     "email": "contact@reversia.tech",
@@ -54,4 +54,4 @@
     "payload": "^3.0.0",
     "typescript": "^5.0.0"
   }
-}
+}