@sequoialabs/payload-plugin-reversia 0.1.7 → 0.1.8

package/dist/endpoints/resources-insert.js

@@ -124,6 +124,61 @@ function applyTranslations({ allowedFields, data, sourceDoc, previousDoc, }) {
     }
     return { updateData, diff, acceptedFields };
 }
+/**
+ * Payload's unique validator rejects an update when the new value already
+ * exists on another doc in the same locale. Reversia legitimately produces
+ * colliding translations (proper nouns, short phrases, numeric-suffix titles
+ * that don't change across locales), so without a pre-check the whole item
+ * fails with `ValidationError: <field>.<locale>: Value must be unique`.
+ *
+ * For every scalar field in `updateData` that the schema marks `unique: true`,
+ * query the target collection/locale for any OTHER doc with that value. When
+ * one exists, drop the field from the write so the rest of the update can go
+ * through. The source of truth stays on the first doc that claimed the value;
+ * the second doc's target-locale slot remains empty and can be edited
+ * manually later.
+ */
+async function dropUniqueCollisions(params) {
+    const { payload, collection, id, locale, fields, updateData, acceptedFields, diff } = params;
+    for (const field of fields) {
+        if (field.isContainer || !field.unique) {
+            continue;
+        }
+        if (!(field.name in updateData)) {
+            continue;
+        }
+        const value = updateData[field.name];
+        if (value === null || value === undefined || value === '') {
+            continue;
+        }
+        const existing = await payload.find({
+            collection: collection,
+            locale: locale,
+            depth: 0,
+            limit: 1,
+            pagination: false,
+            where: {
+                and: [{ [field.name]: { equals: value } }, { id: { not_equals: id } }],
+            },
+        });
+        if (existing.docs.length === 0) {
+            continue;
+        }
+        payload.logger.warn({
+            collection,
+            id,
+            targetLocale: locale,
+            field: field.name,
+            collidingDocId: existing.docs[0]?.id,
+        }, '[reversia] skipping field to avoid unique collision');
+        delete updateData[field.name];
+        const acceptedIdx = acceptedFields.indexOf(field.name);
+        if (acceptedIdx !== -1) {
+            acceptedFields.splice(acceptedIdx, 1);
+        }
+        delete diff[field.name];
+    }
+}
 export function createResourcesInsertEndpoint(pluginConfig, collectionsMap, globalsMap) {
     return {
         path: '/reversia/resources-insert',
@@ -238,6 +293,20 @@ export function createResourcesInsertEndpoint(pluginConfig, collectionsMap, glob
                         response.errors.push(`Item ${index}: no recognised fields in data (keys: ${Object.keys(item.data).join(', ')})`);
                         continue;
                     }
+                    await dropUniqueCollisions({
+                        payload: req.payload,
+                        collection: slug,
+                        id: itemId,
+                        locale: item.targetLocale,
+                        fields: allowedFields,
+                        updateData,
+                        acceptedFields,
+                        diff,
+                    });
+                    if (acceptedFields.length === 0 || Object.keys(updateData).length === 0) {
+                        response.errors.push(`Item ${index}: all translatable fields skipped due to unique-constraint collisions in ${item.targetLocale}`);
+                        continue;
+                    }
                     await withRetry(() => req.payload.update({
                         collection: slug,
                         id: itemId,

package/dist/endpoints/resources.d.ts

@@ -1,3 +1,3 @@
 import type { CollectionConfig, Endpoint, GlobalConfig } from 'payload';
 import type { ReversiaPluginConfig } from '../types.js';
-export declare function createResourcesEndpoint(pluginConfig: ReversiaPluginConfig, collectionsMap: Map<string, CollectionConfig>, _globalsMap: Map<string, GlobalConfig>): Endpoint;
+export declare function createResourcesEndpoint(pluginConfig: ReversiaPluginConfig, collectionsMap: Map<string, CollectionConfig>, globalsMap: Map<string, GlobalConfig>): Endpoint;

package/dist/endpoints/resources.js

@@ -25,7 +25,7 @@ function getLabelValue(doc, fields) {
     const value = doc?.[labelField.name];
     return typeof value === 'string' ? value : undefined;
 }
-export function createResourcesEndpoint(pluginConfig, collectionsMap, _globalsMap) {
+export function createResourcesEndpoint(pluginConfig, collectionsMap, globalsMap) {
     return {
         path: '/reversia/resources',
         method: 'get',
@@ -98,6 +98,47 @@ export function createResourcesEndpoint(pluginConfig, collectionsMap, _globalsMa
                     response.content.push({ type: resourceType, data: items });
                 }
             }
+            // Globals are singletons (one doc per slug, id = slug), emitted after
+            // collections so pagination via `cursor` resumes at the right slot.
+            // Each global counts as 1 toward `limit`. Cursor semantics mirror the
+            // collection loop: when we find the type the cursor points to, that
+            // slot has already been returned — advance past it and resume from
+            // the next iteration.
+            for (const [slug, global] of globalsMap) {
+                const resourceType = `payloadcms:global:${slug}`;
+                if (requestedTypes && !requestedTypes.includes(resourceType)) {
+                    continue;
+                }
+                if (!startFromCursor) {
+                    if (cursor && cursor.type === resourceType) {
+                        startFromCursor = true;
+                        continue;
+                    }
+                    continue;
+                }
+                if (totalFetched >= limit) {
+                    break;
+                }
+                const localizedFields = findLocalizedFields(global.fields);
+                if (localizedFields.length === 0) {
+                    continue;
+                }
+                const doc = await req.payload.findGlobal({ slug, locale: defaultLocale });
+                const { content, contentTypes } = extractContent(doc, localizedFields);
+                if (Object.keys(content).length === 0) {
+                    continue;
+                }
+                const item = {
+                    id: slug,
+                    label: getLabelValue(doc, localizedFields),
+                    content,
+                    contentTypes: Object.keys(contentTypes).length > 0 ? contentTypes : undefined,
+                };
+                response.content.push({ type: resourceType, data: [item] });
+                lastType = resourceType;
+                lastId = slug;
+                totalFetched++;
+            }
             if (lastType && lastId && totalFetched >= limit) {
                 response.cursor = encodeCursor(lastType, lastId);
             }

package/dist/types.d.ts

@@ -183,6 +183,15 @@ export interface LocalizedFieldInfo {
      * the update.
      */
     hasRequiredLeaf?: boolean;
+    /**
+     * True when a top-level localized scalar is `unique: true`. Used during
+     * insertion to pre-check for cross-document collisions in the target locale
+     * before writing — Reversia may translate two docs' source values to the
+     * same target string, and Payload's unique validator would reject the
+     * second write. Only meaningful for scalars; Payload doesn't support
+     * `unique` on containers.
+     */
+    unique?: boolean;
 }
 export interface ResourceItem {
     id: string;

package/dist/utils/fields.js

@@ -134,6 +134,7 @@ function describeTopLevelField(field) {
         const maxLength = getNumericProp(field, 'maxLength');
         const minLength = getNumericProp(field, 'minLength');
         const required = getBoolProp(field, 'required');
+        const unique = getBoolProp(field, 'unique');
         return {
             name,
             label,
@@ -151,6 +152,7 @@ function describeTopLevelField(field) {
             ...(maxLength !== undefined && { maxLength }),
             ...(minLength !== undefined && { minLength }),
             ...(required && { hasRequiredLeaf: true }),
+            ...(unique && { unique: true }),
         };
     }
     // Top-level richText / json (localized or not localized but containing

package/package.json

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