@sequoialabs/payload-plugin-reversia 0.2.1 → 0.3.0

package/dist/endpoints/resource.js

@@ -1,6 +1,6 @@
 import { unauthorizedResponse, validateApiKey } from '../utils/auth';
 import { findLocalizedFields, serializeField } from '../utils/fields';
-import { resolveDefaultLocale } from '../utils/payload-helpers';
+import { resolveDefaultLocale, shouldUseDrafts } from '../utils/payload-helpers';
 function extract(doc, fields) {
     const content = {};
     const contentTypes = {};
@@ -45,7 +45,11 @@ export function createResourceEndpoint(pluginConfig, collectionsMap, globalsMap)
                     return Response.json({ error: `Global ${globalSlug} not found` }, { status: 404 });
                 }
                 const localizedFields = findLocalizedFields(globalConfig.fields);
-                const doc = await req.payload.findGlobal({ slug: globalSlug, locale: defaultLocale });
+                const doc = await req.payload.findGlobal({
+                    slug: globalSlug,
+                    locale: defaultLocale,
+                    draft: shouldUseDrafts(pluginConfig, 'global', globalConfig),
+                });
                 const { content, contentTypes } = extract(doc, localizedFields);
                 return Response.json({
                     id: globalSlug,
@@ -69,6 +73,7 @@ export function createResourceEndpoint(pluginConfig, collectionsMap, globalsMap)
                 collection: slug,
                 id: resourceId,
                 locale: defaultLocale,
+                draft: shouldUseDrafts(pluginConfig, 'collection', collection),
             });
             const { content, contentTypes } = extract(doc, localizedFields);
             return Response.json({

package/dist/endpoints/resources-insert.js

@@ -1,5 +1,6 @@
 import { unauthorizedResponse, validateApiKey } from '../utils/auth';
 import { deflatePopulatedRelationships, deserializeFieldValue, findLocalizedFields, } from '../utils/fields';
+import { shouldUseDrafts } from '../utils/payload-helpers';
 const WRITE_CONFLICT_MAX_RETRIES = 3;
 const WRITE_CONFLICT_BASE_DELAY_MS = 50;
 function isWriteConflict(error) {
@@ -156,7 +157,7 @@ function applyTranslations({ allowedFields, data, sourceDoc, previousDoc, }) {
  * manually later.
  */
 async function dropUniqueCollisions(params) {
-    const { payload, collection, id, locale, fields, updateData, acceptedFields, diff } = params;
+    const { payload, collection, id, locale, draft, fields, updateData, acceptedFields, diff } = params;
     const dropped = [];
     for (const field of fields) {
         if (field.isContainer || !field.unique) {
@@ -175,6 +176,7 @@ async function dropUniqueCollisions(params) {
             depth: 0,
             limit: 1,
             pagination: false,
+            draft,
             where: {
                 and: [{ [field.name]: { equals: value } }, { id: { not_equals: id } }],
             },
@@ -241,16 +243,26 @@ export function createResourcesInsertEndpoint(pluginConfig, collectionsMap, glob
                             continue;
                         }
                         const allowedFields = findLocalizedFields(globalConfig.fields);
+                        // When draft-aware, read the source and previous values from the
+                        // latest draft and save the translation as a draft too, so nothing
+                        // reaches the published global until an editor publishes it.
+                        const draft = shouldUseDrafts(pluginConfig, 'global', globalConfig);
                         // 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, depth: 0 }),
+                            req.payload.findGlobal({
+                                slug: globalSlug,
+                                locale: item.sourceLocale,
+                                depth: 0,
+                                draft,
+                            }),
                             req.payload.findGlobal({
                                 slug: globalSlug,
                                 locale: item.targetLocale,
                                 depth: 0,
+                                draft,
                                 fallbackLocale: false,
                             }),
                         ]);
@@ -268,6 +280,7 @@ export function createResourcesInsertEndpoint(pluginConfig, collectionsMap, glob
                             slug: globalSlug,
                             locale: item.targetLocale,
                             data: updateData,
+                            draft,
                             context: { reversiaInsertion: true },
                         }));
                         response[index] = { index, type: item.type, id: globalSlug, diff };
@@ -289,18 +302,22 @@ export function createResourcesInsertEndpoint(pluginConfig, collectionsMap, glob
                     }
                     const itemId = item.id;
                     const allowedFields = findLocalizedFields(collection.fields);
+                    // See the global branch above: draft-aware reads + draft write.
+                    const draft = shouldUseDrafts(pluginConfig, 'collection', collection);
                     const [sourceDoc, previousDoc] = await Promise.all([
                         req.payload.findByID({
                             collection: slug,
                             id: item.id,
                             locale: item.sourceLocale,
                             depth: 0,
+                            draft,
                         }),
                         req.payload.findByID({
                             collection: slug,
                             id: item.id,
                             locale: item.targetLocale,
                             depth: 0,
+                            draft,
                             fallbackLocale: false,
                         }),
                     ]);
@@ -319,6 +336,7 @@ export function createResourcesInsertEndpoint(pluginConfig, collectionsMap, glob
                         collection: slug,
                         id: itemId,
                         locale: item.targetLocale,
+                        draft,
                         fields: allowedFields,
                         updateData,
                         acceptedFields,
@@ -333,6 +351,7 @@ export function createResourcesInsertEndpoint(pluginConfig, collectionsMap, glob
                         id: itemId,
                         locale: item.targetLocale,
                         data: updateData,
+                        draft,
                         context: { reversiaInsertion: true },
                     }));
                     response[index] = { index, type: item.type, id: itemId, diff };

package/dist/endpoints/resources.js

@@ -1,7 +1,7 @@
 import { unauthorizedResponse, validateApiKey } from '../utils/auth';
 import { decodeCursor, encodeCursor } from '../utils/cursor';
 import { findLocalizedFields, serializeField } from '../utils/fields';
-import { parseLimit, resolveDefaultLocale } from '../utils/payload-helpers';
+import { parseLimit, resolveDefaultLocale, shouldUseDrafts } from '../utils/payload-helpers';
 function extractContent(doc, fields) {
     const content = {};
     const contentTypes = {};
@@ -68,12 +68,17 @@ export function createResourcesEndpoint(pluginConfig, collectionsMap, globalsMap
                 if (cursor && cursor.type === resourceType && cursor.id) {
                     where.id = { greater_than: cursor.id };
                 }
+                // With `draft: true` Payload queries the versions table and returns
+                // the latest version per document (draft or published). It rewrites
+                // `id` in `where`/`sort` to the version's `parent`, so the cursor keeps
+                // pointing at document ids.
                 const docs = await req.payload.find({
                     collection: slug,
                     locale: defaultLocale,
                     limit: limit - totalFetched,
                     sort: 'id',
                     where,
+                    draft: shouldUseDrafts(pluginConfig, 'collection', collection),
                 });
                 if (docs.docs.length === 0) {
                     continue;
@@ -123,7 +128,11 @@ export function createResourcesEndpoint(pluginConfig, collectionsMap, globalsMap
                 if (localizedFields.length === 0) {
                     continue;
                 }
-                const doc = await req.payload.findGlobal({ slug, locale: defaultLocale });
+                const doc = await req.payload.findGlobal({
+                    slug,
+                    locale: defaultLocale,
+                    draft: shouldUseDrafts(pluginConfig, 'global', global),
+                });
                 const { content, contentTypes } = extractContent(doc, localizedFields);
                 if (Object.keys(content).length === 0) {
                     continue;

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import type { Config } from 'payload';
 import type { ReversiaPluginConfig } from './types';
 export type { TriggerCrawlOptions, TriggerCrawlResult } from './trigger-crawl';
 export { triggerCrawl } from './trigger-crawl';
-export type { ConfirmResourcesSyncResponse, InsertionRequest, InsertionResponse, ResourceDefinition, ResourceItem, ResourceResponse, ReversiaErrorResponse, ReversiaFieldCustom, ReversiaPluginConfig, SettingsResponse, StreamResponse, TranslatableFieldConfig, } from './types';
+export type { ConfirmResourcesSyncResponse, EnabledResource, EnabledResourceOptions, InsertionRequest, InsertionResponse, ResourceDefinition, ResourceItem, ResourceResponse, ReversiaErrorResponse, ReversiaFieldCustom, ReversiaPluginConfig, SettingsResponse, StreamResponse, TranslatableFieldConfig, } from './types';
 export { ReversiaFieldBehavior, ReversiaFieldType } from './types';
 export declare const reversiaPlugin: (pluginConfig: ReversiaPluginConfig) => (config: Config) => Config;
 export default reversiaPlugin;

package/dist/index.js

@@ -9,6 +9,7 @@ import { createSettingsEndpoint } from './endpoints/settings';
 import { createTriggerCrawlDashboardEndpoint } from './endpoints/trigger-crawl-dashboard';
 import { createAfterChangeHook } from './hooks/after-change';
 import { findLocalizedFields } from './utils/fields';
+import { resourceSlug } from './utils/payload-helpers';
 export { triggerCrawl } from './trigger-crawl';
 export { ReversiaFieldBehavior, ReversiaFieldType } from './types';
 const APPLIED_MARKER = Symbol.for('payload-plugin-reversia.applied');
@@ -25,10 +26,10 @@ export const reversiaPlugin = (pluginConfig) => (config) => {
     }
     marked[APPLIED_MARKER] = true;
     const enabledCollectionSlugs = pluginConfig.enabledCollections
-        ? new Set(pluginConfig.enabledCollections.map((s) => String(s)))
+        ? new Set(pluginConfig.enabledCollections.map(resourceSlug))
         : null;
     const enabledGlobalSlugs = pluginConfig.enabledGlobals
-        ? new Set(pluginConfig.enabledGlobals)
+        ? new Set(pluginConfig.enabledGlobals.map(resourceSlug))
         : null;
     const collectionsMap = new Map();
     const globalsMap = new Map();

package/dist/types.d.ts

@@ -1,5 +1,18 @@
 import type { CollectionSlug } from 'payload';
 import type { LeafSegment } from './utils/path-resolver';
+/**
+ * An entry of `enabledCollections` / `enabledGlobals`: either the bare slug,
+ * or an object carrying per-resource options.
+ */
+export interface EnabledResourceOptions<Slug extends string = string> {
+    slug: Slug;
+    /**
+     * Per-resource override of the root `useDrafts` flag. Only meaningful when
+     * the collection or global enables `versions.drafts`.
+     */
+    useDrafts?: boolean;
+}
+export type EnabledResource<Slug extends string = string> = EnabledResourceOptions<Slug> | Slug;
 export interface ReversiaPluginConfig {
     /**
      * API key used by Reversia SaaS to authenticate requests.
@@ -9,13 +22,19 @@ export interface ReversiaPluginConfig {
     /**
      * Optional: restrict which collections are exposed to Reversia.
      * If omitted, all collections with localized fields are exposed.
+     *
+     * Each entry is a slug, or `{ slug, useDrafts }` to override the root
+     * `useDrafts` flag for that collection.
      */
-    enabledCollections?: CollectionSlug[];
+    enabledCollections?: EnabledResource<CollectionSlug>[];
     /**
      * Optional: restrict which globals are exposed to Reversia.
      * If omitted, all globals with localized fields are exposed.
+     *
+     * Each entry is a slug, or `{ slug, useDrafts }` to override the root
+     * `useDrafts` flag for that global.
      */
-    enabledGlobals?: string[];
+    enabledGlobals?: EnabledResource[];
     /**
      * Whether the plugin is disabled. Defaults to false.
      */
@@ -26,6 +45,27 @@ export interface ReversiaPluginConfig {
      * built-in production URL.
      */
     baseUrl?: string;
+    /**
+     * Make the plugin draft-aware for collections and globals that enable
+     * `versions.drafts`. Defaults to false. Can be overridden per resource via
+     * `{ slug, useDrafts }` entries in `enabledCollections` / `enabledGlobals`.
+     *
+     * When enabled, for those entities:
+     * - `GET /reversia/resources` and `GET /reversia/resource` return the latest
+     *   draft (falling back to the published document when no newer draft
+     *   exists), so Reversia translates what editors are currently working on.
+     * - `PUT /reversia/resources-insert` reads the source locale from the draft
+     *   and saves the translation as a new draft version. The published document
+     *   is never touched — publishing stays an editorial action in Payload.
+     *
+     * Entities without drafts are unaffected either way.
+     *
+     * When disabled (the default), every read and write targets the published
+     * document. Note that Payload bases a non-draft update on the latest
+     * version, so on a draft-enabled entity an insertion also publishes any
+     * pending source-locale draft — enable this flag if that is not desired.
+     */
+    useDrafts?: boolean;
 }
 export declare enum ReversiaFieldType {
     TEXT = "TEXT",

package/dist/utils/payload-helpers.d.ts

@@ -1,4 +1,5 @@
-import type { PayloadRequest } from 'payload';
+import type { CollectionConfig, GlobalConfig, PayloadRequest } from 'payload';
+import type { EnabledResource, ReversiaPluginConfig } from '../types';
 /**
  * Parses a caller-supplied `limit` query parameter and clamps it to a safe
  * range. NaN, zero, and negatives fall back to the default.
@@ -9,6 +10,29 @@ export declare function parseLimit(raw: string | null, fallback?: number): numbe
  * when localization is not configured.
  */
 export declare function resolveDefaultLocale(req: PayloadRequest): string;
+/**
+ * True when a collection or global enables `versions.drafts`. Accepts both
+ * the raw config shape (`versions: { drafts: true }`) and Payload's sanitized
+ * one (`versions: { drafts: { autosave: false, … } }`).
+ */
+export declare function hasDraftsEnabled(entity: CollectionConfig | GlobalConfig): boolean;
+/**
+ * Slug of an `enabledCollections` / `enabledGlobals` entry, whichever form
+ * it was written in.
+ */
+export declare function resourceSlug(entry: EnabledResource): string;
+/**
+ * Resolves the configured `useDrafts` value for one resource: the
+ * per-resource override from its `enabledCollections` / `enabledGlobals`
+ * entry when present, otherwise the root `useDrafts` flag (default false).
+ */
+export declare function resolveUseDrafts(pluginConfig: ReversiaPluginConfig, kind: 'collection' | 'global', slug: string): boolean;
+/**
+ * Whether reads and writes for `entity` should target its draft rather than
+ * the published document: requires both `useDrafts` resolving to true for
+ * this resource and `versions.drafts` on the entity.
+ */
+export declare function shouldUseDrafts(pluginConfig: ReversiaPluginConfig, kind: 'collection' | 'global', entity: CollectionConfig | GlobalConfig): boolean;
 /**
  * Plain dot-path lookup on an object, returning `undefined` for any missing
  * segment or non-object traversal. Does not walk into arrays.

package/dist/utils/payload-helpers.js

@@ -28,6 +28,43 @@ export function resolveDefaultLocale(req) {
     }
     return 'en';
 }
+/**
+ * True when a collection or global enables `versions.drafts`. Accepts both
+ * the raw config shape (`versions: { drafts: true }`) and Payload's sanitized
+ * one (`versions: { drafts: { autosave: false, … } }`).
+ */
+export function hasDraftsEnabled(entity) {
+    const versions = entity.versions;
+    return Boolean(versions && typeof versions === 'object' && versions.drafts);
+}
+/**
+ * Slug of an `enabledCollections` / `enabledGlobals` entry, whichever form
+ * it was written in.
+ */
+export function resourceSlug(entry) {
+    return typeof entry === 'string' ? entry : entry.slug;
+}
+/**
+ * Resolves the configured `useDrafts` value for one resource: the
+ * per-resource override from its `enabledCollections` / `enabledGlobals`
+ * entry when present, otherwise the root `useDrafts` flag (default false).
+ */
+export function resolveUseDrafts(pluginConfig, kind, slug) {
+    const entries = kind === 'collection' ? pluginConfig.enabledCollections : pluginConfig.enabledGlobals;
+    const entry = entries?.find((e) => resourceSlug(e) === slug);
+    if (entry && typeof entry !== 'string' && typeof entry.useDrafts === 'boolean') {
+        return entry.useDrafts;
+    }
+    return pluginConfig.useDrafts === true;
+}
+/**
+ * Whether reads and writes for `entity` should target its draft rather than
+ * the published document: requires both `useDrafts` resolving to true for
+ * this resource and `versions.drafts` on the entity.
+ */
+export function shouldUseDrafts(pluginConfig, kind, entity) {
+    return resolveUseDrafts(pluginConfig, kind, entity.slug) && hasDraftsEnabled(entity);
+}
 /**
  * Plain dot-path lookup on an object, returning `undefined` for any missing
  * segment or non-object traversal. Does not walk into arrays.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sequoialabs/payload-plugin-reversia",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "author": {
     "name": "Jean Walrave",
     "email": "contact@reversia.tech",
@@ -61,4 +61,4 @@
     "react": "^19.0.0",
     "typescript": "^5.0.0"
   }
-}
+}