@focus-reactive/payload-plugin-translator 0.10.1 → 0.10.2

package/dist/server/features/enqueue-translation/handler.js

@@ -18,20 +18,23 @@ import { resolveTargetLocales } from "./resolveTargetLocales";
         const { source_lng, target_lng, collection_slug, collection_id, select_all, strategy, publish_on_translation } = validationResult.data;
         const collectionSlug = isCollectionAvailable(collection_slug, this.config.availableCollections);
         if (!collectionSlug) return ServerResponse.badRequest("Content of this collection is not available for translation");
-        // Normalize the scalar-or-array target into the concrete locales to fan out to: de-dup, exclude the
-        // source, and drop locales that are not configured (unknown locales would burn a provider call and
-        // corrupt data — Postgres locale enum / orphaned Mongo rows). `config` is optional-chained because a
-        // localization-less (or minimally-mocked) payload has none, which correctly disables the filter.
+        // A localization-less config has no valid target locale: a phantom locale would burn a provider
+        // call and corrupt data — orphaned rows on Mongo/SQLite, a locale-enum error on Postgres, or (with
+        // no localization at all) overwrite the single unlocalized field and wipe the source. Reject before
+        // anything is enqueued.
         const knownLocales = extractLocaleCodes(req.payload.config?.localization);
+        if (!knownLocales) return ServerResponse.badRequest("Localization is not enabled in this Payload config; there are no target locales to translate into");
+        // Normalize the scalar-or-array target into the concrete locales to fan out to: de-dup, exclude the
+        // source, and drop locales that are not configured.
         const { targets, droppedUnknown } = resolveTargetLocales({
             target_lng,
             source_lng,
             knownLocales
         });
         if (droppedUnknown.length > 0) {
-            req.payload.logger?.warn(`[payload-plugin-translator] enqueue on "${collectionSlug}": ignoring unknown target locale(s) ${droppedUnknown.join(", ")} (configured locales: ${knownLocales ? [
+            req.payload.logger?.warn(`[payload-plugin-translator] enqueue on "${collectionSlug}": ignoring unknown target locale(s) ${droppedUnknown.join(", ")} (configured locales: ${[
                 ...knownLocales
-            ].join(", ") : "n/a"}).`);
+            ].join(", ")}).`);
         }
         if (targets.length === 0) return ServerResponse.badRequest("No valid target locales to translate into (all requested locales were the source or unknown)");
         const collectionIds = select_all ? await getAllCollectionIds(req.payload, collectionSlug) : collection_id;

package/dist/server/features/enqueue-translation/resolveTargetLocales.d.ts

@@ -4,7 +4,7 @@
 export type ResolvedTargetLocales = {
     /** The concrete locales to fan out to — de-duplicated, source excluded, unknown removed. */
     targets: string[];
-    /** Requested locales that are not configured (dropped) — empty when localization is unknown/disabled. */
+    /** Requested locales that are not configured (dropped). */
     droppedUnknown: string[];
     /** Whether the source locale was requested as a target and excluded. */
     droppedSource: boolean;
@@ -12,18 +12,19 @@ export type ResolvedTargetLocales = {
 /**
  * Normalize the enqueue `target_lng` input (scalar or array) into the concrete list of target locales
  * to translate into. Applies, in order: array-coercion, de-duplication (first-seen order preserved),
- * source-locale exclusion, and — when the configured locale set is known — dropping unknown locales.
+ * source-locale exclusion, and dropping unknown (unconfigured) locales.
  *
  * De-dup and unknown-dropping are the manual-enqueue counterparts of the auto-translate policy filter:
  * the runner only supersedes against already-stored jobs, so duplicates within one enqueue must be
  * collapsed here; and an unknown locale must never reach the pipeline — it burns a provider call and
  * either errors on a Postgres locale enum or writes orphaned, invisible data on Mongo/SQLite.
  *
- * @param knownLocales - the configured locale codes, or `null` when localization is disabled/absent
- *   (then no unknown-dropping is applied — every requested locale except the source is kept).
+ * @param knownLocales - the configured locale codes. Never null: the caller must reject a
+ *   localization-less config before reaching here (translating without localization has no valid
+ *   target and would corrupt data), so "no localization" is not representable as an input.
  */
 export declare function resolveTargetLocales(args: {
     target_lng: string | string[];
     source_lng: string;
-    knownLocales: Set<string> | null;
+    knownLocales: Set<string>;
 }): ResolvedTargetLocales;

package/dist/server/features/enqueue-translation/resolveTargetLocales.js

@@ -3,15 +3,16 @@
  */ /**
  * Normalize the enqueue `target_lng` input (scalar or array) into the concrete list of target locales
  * to translate into. Applies, in order: array-coercion, de-duplication (first-seen order preserved),
- * source-locale exclusion, and — when the configured locale set is known — dropping unknown locales.
+ * source-locale exclusion, and dropping unknown (unconfigured) locales.
  *
  * De-dup and unknown-dropping are the manual-enqueue counterparts of the auto-translate policy filter:
  * the runner only supersedes against already-stored jobs, so duplicates within one enqueue must be
  * collapsed here; and an unknown locale must never reach the pipeline — it burns a provider call and
  * either errors on a Postgres locale enum or writes orphaned, invisible data on Mongo/SQLite.
  *
- * @param knownLocales - the configured locale codes, or `null` when localization is disabled/absent
- *   (then no unknown-dropping is applied — every requested locale except the source is kept).
+ * @param knownLocales - the configured locale codes. Never null: the caller must reject a
+ *   localization-less config before reaching here (translating without localization has no valid
+ *   target and would corrupt data), so "no localization" is not representable as an input.
  */ export function resolveTargetLocales(args) {
     const { target_lng, source_lng, knownLocales } = args;
     const requested = Array.isArray(target_lng) ? target_lng : [
@@ -22,13 +23,6 @@
     ];
     const droppedSource = deduped.includes(source_lng);
     const withoutSource = deduped.filter((target)=>target !== source_lng);
-    if (!knownLocales) {
-        return {
-            targets: withoutSource,
-            droppedUnknown: [],
-            droppedSource
-        };
-    }
     const droppedUnknown = withoutSource.filter((target)=>!knownLocales.has(target));
     const targets = withoutSource.filter((target)=>knownLocales.has(target));
     return {

package/dist/server/features/translate-field/handler.js

@@ -62,6 +62,9 @@ const noop = (value, level, message)=>({
         if (resolution.status === "not-translatable") {
             return ServerResponse.success(noop(sourceValue, "info", "Nothing to translate in this field"));
         }
+        if (resolution.status === "excluded") {
+            return ServerResponse.success(noop(sourceValue, "info", "This field is excluded from translation"));
+        }
         // No `strategy`/`targetData`: a per-field translate is an explicit "translate this field now",
         // so `translateContent` always overwrites (its default). skip_existing has no meaning here.
         const translated = await translateContent({

package/dist/server/features/translate-field/resolveFieldSubtree.d.ts

@@ -6,6 +6,10 @@ import type { FieldLike } from "../../../core/kernel/field-traversal";
  *   are ready for `translateContent`, and `fieldName` is the key to unwrap the result.
  * - `not-found` — the path resolves to no field at all (a typo) → caller returns 400.
  * - `not-translatable` — resolves to a field that isn't a text-like leaf → caller no-ops.
+ * - `excluded` — resolves to a translatable leaf that opted out via `withFieldTranslation({ exclude })`
+ *   → caller no-ops. Kept distinct from `not-translatable` so the notice can say *why* (a deliberate
+ *   opt-out, not a wrong type), and because this route must honor the same exclude the whole-document
+ *   path honors via `isTranslatableLeaf` — otherwise naming the path directly bypasses the opt-out.
  * - `inside-blocks` — the path descends through a polymorphic `blocks` field that couldn't be
  *   resolved: no `doc` was supplied to read the element's `blockType` from → caller no-ops.
  * - `localized-list-ancestor` — the path descends through a `localized` `blocks`/`array` field,
@@ -21,6 +25,8 @@ export type FieldSubtreeResolution = {
     status: "not-found";
 } | {
     status: "not-translatable";
+} | {
+    status: "excluded";
 } | {
     status: "inside-blocks";
 } | {

package/dist/server/features/translate-field/resolveFieldSubtree.js

@@ -1,4 +1,4 @@
-import { isTranslatableField } from "../../shared";
+import { isFieldExcludedFromTranslation, isTranslatableField } from "../../shared";
 import { findFieldByPath } from "../../../core/kernel/field-traversal";
 /**
  * Map a declared `fieldPath` to the `{ schema, sourceData }` pair `translateContent` expects.
@@ -17,7 +17,13 @@ import { findFieldByPath } from "../../../core/kernel/field-traversal";
     const result = findFieldByPath(rootFields, segments, doc);
     switch(result.status){
         case "leaf":
-            return isTranslatableField(result.field) ? {
+            if (!isTranslatableField(result.field)) return {
+                status: "not-translatable"
+            };
+            if (isFieldExcludedFromTranslation(result.field)) return {
+                status: "excluded"
+            };
+            return {
                 status: "resolved",
                 schema: [
                     result.field
@@ -26,8 +32,6 @@ import { findFieldByPath } from "../../../core/kernel/field-traversal";
                     [result.field.name]: value
                 },
                 fieldName: result.field.name
-            } : {
-                status: "not-translatable"
             };
         case "container":
             return {

package/dist/server/modules/translation-levels/PluginConfigBuilder.js

@@ -1,4 +1,9 @@
 const endpointKey = (endpoint)=>`${endpoint.method} ${endpoint.path}`;
+/**
+ * Identity of a collection admin component for dedup: its slot plus its module path (+ export name).
+ * `serverProps` (per-collection data) are excluded, so the same control registered by a level declared
+ * twice collapses to one — while genuinely different controls (distinct path or slot) do not.
+ */ const componentKey = (slot, component)=>`${slot} ${component.path}#${component.exportName ?? ""}`;
 function attachToSlot(collection, slot, component) {
     if (!collection.admin) collection.admin = {};
     if (!collection.admin.components) collection.admin.components = {};
@@ -92,8 +97,13 @@ function attachToSlot(collection, slot, component) {
         const managed = new Set(this.collections.map((collection)=>collection.slug));
         config.collections?.forEach((collection)=>{
             if (!managed.has(collection.slug)) return;
+            const seen = new Set();
             for (const { slot, make } of this.collectionComponents){
-                attachToSlot(collection, slot, make(collection));
+                const component = make(collection);
+                const key = componentKey(slot, component);
+                if (seen.has(key)) continue;
+                seen.add(key);
+                attachToSlot(collection, slot, component);
             }
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@focus-reactive/payload-plugin-translator",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "description": "Translation plugin for Payload CMS 3.x. Automatically translate your localized content using any translation provider.",
   "type": "module",
   "license": "MIT",