@sequoialabs/payload-plugin-reversia 0.1.1 → 0.1.3

package/dist/endpoints/resources-insert.js

@@ -1,5 +1,31 @@
 import { unauthorizedResponse, validateApiKey } from '../utils/auth.js';
 import { deflatePopulatedRelationships, deserializeFieldValue, findLocalizedFields, } from '../utils/fields.js';
+const WRITE_CONFLICT_MAX_RETRIES = 3;
+const WRITE_CONFLICT_BASE_DELAY_MS = 50;
+function isWriteConflict(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const message = 'message' in error && typeof error.message === 'string'
+        ? error.message
+        : '';
+    return message.includes('Write conflict') || message.includes('write conflict');
+}
+async function withRetry(fn) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await 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;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                continue;
+            }
+            throw error;
+        }
+    }
+}
 function stringifyDiffValue(value) {
     if (typeof value === 'string') {
         return value;
@@ -29,15 +55,37 @@ function applyTranslations({ allowedFields, data, sourceDoc, previousDoc, }) {
     // 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.
+    // Build updateData from fields Reversia sent, plus any required fields that
+    // are empty in the target locale. Payload validates ALL required fields on
+    // every update (not just the ones in `data`), so an empty required field in
+    // the target locale would block the entire write. We seed those from source.
     const updateData = {};
     const diff = {};
     const acceptedFields = [];
     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.
+    for (const field of allowedFields) {
+        if (!field.hasRequiredLeaf) {
+            continue;
+        }
+        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;
+    }
     for (const [fieldName, translatedValue] of Object.entries(data)) {
         const field = fieldByName.get(fieldName);
         if (!field) {
@@ -118,12 +166,12 @@ export function createResourcesInsertEndpoint(pluginConfig, collectionsMap, glob
                             response.errors.push(`Item ${index}: no recognised fields in data (keys: ${Object.keys(item.data).join(', ')})`);
                             continue;
                         }
-                        await req.payload.updateGlobal({
+                        await withRetry(() => req.payload.updateGlobal({
                             slug: globalSlug,
                             locale: item.targetLocale,
                             data: updateData,
                             context: { reversiaInsertion: true },
-                        });
+                        }));
                         response[index] = { index, type: item.type, id: globalSlug, diff };
                         continue;
                     }
@@ -141,6 +189,7 @@ export function createResourcesInsertEndpoint(pluginConfig, collectionsMap, glob
                         response.errors.push(`Item ${index}: id is required for collection resources`);
                         continue;
                     }
+                    const itemId = item.id;
                     const allowedFields = findLocalizedFields(collection.fields);
                     const [sourceDoc, previousDoc] = await Promise.all([
                         req.payload.findByID({
@@ -166,14 +215,14 @@ export function createResourcesInsertEndpoint(pluginConfig, collectionsMap, glob
                         response.errors.push(`Item ${index}: no recognised fields in data (keys: ${Object.keys(item.data).join(', ')})`);
                         continue;
                     }
-                    await req.payload.update({
+                    await withRetry(() => req.payload.update({
                         collection: slug,
-                        id: item.id,
+                        id: itemId,
                         locale: item.targetLocale,
                         data: updateData,
                         context: { reversiaInsertion: true },
-                    });
-                    response[index] = { index, type: item.type, id: item.id, diff };
+                    }));
+                    response[index] = { index, type: item.type, id: itemId, diff };
                 }
                 catch (error) {
                     recordInsertionFailure(req, response, error, index, item);

package/dist/types.d.ts

@@ -110,6 +110,10 @@ export interface TranslatableFieldConfig {
     behavior?: ReversiaFieldBehavior;
     type?: ReversiaFieldType;
     selected?: boolean;
+    rules?: {
+        maxLength?: number;
+        minLength?: number;
+    };
 }
 export interface ResourceDefinition {
     type: string;
@@ -168,6 +172,17 @@ export interface LocalizedFieldInfo {
     reversia?: ReversiaFieldCustom;
     /** One descriptor per localized leaf inside the container. */
     leaves: LocalizedLeaf[];
+    /** Payload `maxLength` on the field (text / textarea / code). */
+    maxLength?: number;
+    /** Payload `minLength` on the field (text / textarea / code). */
+    minLength?: number;
+    /**
+     * True when Payload marks this field (or any required inner leaf) as
+     * `required`. Used during insertion to seed empty target-locale slots from
+     * the source locale so Payload's whole-document validation doesn't reject
+     * the update.
+     */
+    hasRequiredLeaf?: boolean;
 }
 export interface ResourceItem {
     id: string;

package/dist/utils/fields.js

@@ -2,9 +2,6 @@ import { ReversiaFieldType } from '../types.js';
 import { applyByKeys, compileKeyMatcher, DEFAULT_RICHTEXT_KEYS, extractByKeys, } from './json-extract.js';
 import { resolveStaticLabel } from './labels.js';
 import { applyTranslationsToContainer, joinPointers, resolveLeafLocations, } from './path-resolver.js';
-/* -------------------------------------------------------------------------- */
-/*  Schema introspection                                                      */
-/* -------------------------------------------------------------------------- */
 function getFieldLabel(field) {
     if (!('name' in field)) {
         return '';
@@ -59,6 +56,14 @@ const SCALAR_PAYLOAD_TYPES = new Set([
 function isScalarPayloadType(type) {
     return SCALAR_PAYLOAD_TYPES.has(type);
 }
+function getNumericProp(field, prop) {
+    const val = field[prop];
+    return typeof val === 'number' && Number.isFinite(val) ? val : undefined;
+}
+function getBoolProp(field, prop) {
+    const val = field[prop];
+    return typeof val === 'boolean' ? val : undefined;
+}
 /* -------------------------------------------------------------------------- */
 /*  Discovery: top-level localized fields                                     */
 /* -------------------------------------------------------------------------- */
@@ -126,6 +131,9 @@ function describeTopLevelField(field) {
     // Top-level scalar that is itself localized → non-container, value shipped
     // as a primitive.
     if (isLocalized(field) && isScalarPayloadType(payloadFieldType)) {
+        const maxLength = getNumericProp(field, 'maxLength');
+        const minLength = getNumericProp(field, 'minLength');
+        const required = getBoolProp(field, 'required');
         return {
             name,
             label,
@@ -140,6 +148,9 @@ function describeTopLevelField(field) {
                     reversia,
                 },
             ],
+            ...(maxLength !== undefined && { maxLength }),
+            ...(minLength !== undefined && { minLength }),
+            ...(required && { hasRequiredLeaf: true }),
         };
     }
     // Top-level richText / json (localized or not localized but containing
@@ -163,6 +174,7 @@ function describeTopLevelField(field) {
                     reversia,
                 },
             ],
+            ...(getBoolProp(field, 'required') && { hasRequiredLeaf: true }),
         };
     }
     // Structured wrapper: group / array / blocks. Walk inside to collect
@@ -192,6 +204,11 @@ function describeTopLevelField(field) {
         isContainer: true,
         reversia,
         leaves: innerLeaves,
+        // Containers (arrays, blocks, groups) almost always have required inner
+        // subfields we can't cheaply enumerate. Marking hasRequiredLeaf ensures we
+        // always seed empty target-locale containers from source so Payload's
+        // whole-document required-field validation doesn't reject the update.
+        hasRequiredLeaf: true,
     };
 }
 function collectLeaves(fields, parentSegments, out) {
@@ -272,6 +289,27 @@ function resolveAsLabel(field, hasLabelAlready) {
     }
     return false;
 }
+function resolveRules(field) {
+    // Rules only make sense for non-container scalars — containers ship as JSON
+    // pointer maps where the concept of "max length" doesn't apply at the
+    // top-level entry.
+    if (field.isContainer) {
+        return undefined;
+    }
+    const maxLength = field.maxLength;
+    const minLength = field.minLength;
+    if (maxLength === undefined && minLength === undefined) {
+        return undefined;
+    }
+    const rules = {};
+    if (maxLength !== undefined) {
+        rules.maxLength = maxLength;
+    }
+    if (minLength !== undefined) {
+        rules.minLength = minLength;
+    }
+    return rules;
+}
 function humanize(segment) {
     const spaced = segment
         .replace(/[_-]+/g, ' ')
@@ -309,6 +347,10 @@ export function buildTranslatableConfiguration(localizedFields) {
         if (field.reversia?.selected === false) {
             fieldConfig.selected = false;
         }
+        const rules = resolveRules(field);
+        if (rules) {
+            fieldConfig.rules = rules;
+        }
         config[field.name] = fieldConfig;
     }
     return config;
@@ -417,9 +459,6 @@ function resolveTranslatableKeys(leaf) {
     }
     return null;
 }
-/* -------------------------------------------------------------------------- */
-/*  Deserialization                                                           */
-/* -------------------------------------------------------------------------- */
 /**
  * Reverses `serializeField` for one top-level field.
  *
@@ -786,7 +825,7 @@ export function deflatePopulatedRelationships(value) {
         return value.map(deflatePopulatedRelationships);
     }
     const obj = value;
-    // Lexical block node — deflate populated fields
+    // Lexical block node — deflate populated fields inside `fields`.
     if (obj.type === 'block' && obj.fields && typeof obj.fields === 'object') {
         const fields = obj.fields;
         const deflated = {};
@@ -794,14 +833,8 @@ export function deflatePopulatedRelationships(value) {
             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;
+                deflated[key] = deflateValue(val);
             }
         }
         return {
@@ -812,22 +845,46 @@ export function deflatePopulatedRelationships(value) {
                 : {}),
         };
     }
-    // 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.
+    // Any other object — recurse all keys, deflating populated docs wherever
+    // they appear. This catches relationship / upload fields inside Payload
+    // array items, group subfields, etc. — not just Lexical blocks.
     const out = {};
     for (const [k, v] of Object.entries(obj)) {
-        out[k] = deflatePopulatedRelationships(v);
+        out[k] = deflateValue(v);
     }
     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.
+ */
+function deflateValue(val) {
+    if (val === null || val === undefined || typeof val !== 'object') {
+        return 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),
+        };
+    }
+    // Recurse into nested structure
+    return deflatePopulatedRelationships(val);
+}
 function isPopulatedDoc(val) {
     if (!val || typeof val !== 'object' || Array.isArray(val)) {
         return false;

package/package.json

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