@justanarthur/payload-plugin-translator 1.3.21 → 3.0.3

package/dist/shared/chunk-q51q8rd2.js

@@ -0,0 +1,855 @@
+// src/jobs/constants.ts
+var TRANSLATE_TASK_SLUG = "translateEntityToLocale";
+var TRANSLATE_WORKFLOW_SLUG = "translateEntityToLocales";
+
+// src/jobs/createAutoTranslateCollectionHook.ts
+function createAutoTranslateCollectionHook(options) {
+  const {
+    collectionSlug,
+    defaultLocale: defaultLocaleOption,
+    targetLocales: targetLocalesOption,
+    onlyOnPublished = true,
+    workflowSlug = TRANSLATE_WORKFLOW_SLUG
+  } = options;
+  const afterChange = async ({ doc, req }) => {
+    if (shouldSkipAutoTranslate(req.context))
+      return doc;
+    const typed = doc;
+    const requestLocale = readRequestLocale(req);
+    const defaultLocale = defaultLocaleOption ?? readConfigDefaultLocale(req) ?? "";
+    if (!requestLocale || !defaultLocale || requestLocale !== defaultLocale)
+      return doc;
+    if (!req.user)
+      return doc;
+    if (onlyOnPublished && typed._status && typed._status !== "published")
+      return doc;
+    const targetLocales = targetLocalesOption ?? readTargetLocales(req, defaultLocale);
+    if (targetLocales.length === 0)
+      return doc;
+    const resolverKey = options.resolverKey ?? readFirstResolverKey(req);
+    if (!resolverKey) {
+      req.payload.logger.error({
+        msg: `auto-translate: no resolver key available for collection ${collectionSlug} — pass \`resolverKey\` to \`createAutoTranslateCollectionHook\` or configure \`translator.resolvers\` in \`translator({...})\``
+      });
+      return doc;
+    }
+    const updatedAt = typed.updatedAt ?? new Date().toISOString();
+    const toLocales = targetLocales.filter((toLocale) => toLocale !== defaultLocale);
+    if (toLocales.length === 0)
+      return doc;
+    try {
+      const job = await req.payload.jobs.queue({
+        workflow: workflowSlug,
+        input: {
+          id: typed.id,
+          updatedAt,
+          collection: collectionSlug,
+          fromLocale: defaultLocale,
+          resolver: resolverKey || undefined,
+          toLocales
+        }
+      });
+      req.payload.logger.info({
+        msg: `auto-translate: queued translation of ${collectionSlug}#${typed.id} → [${toLocales.join(", ")}] (job ${job.id})`
+      });
+    } catch (error) {
+      req.payload.logger.error({
+        msg: `auto-translate: failed to queue ${collectionSlug}#${typed.id}: ${String(error)}`
+      });
+    }
+    return doc;
+  };
+  return { afterChange };
+}
+function shouldSkipAutoTranslate(context) {
+  return Boolean(context?.disableAutoTranslate);
+}
+function readRequestLocale(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const locale = req.locale;
+  return typeof locale === "string" && locale.length > 0 ? locale : "";
+}
+function readConfigDefaultLocale(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const config = req.payload?.config;
+  const def = config?.localization?.defaultLocale;
+  return typeof def === "string" && def.length > 0 ? def : "";
+}
+function readTargetLocales(req, defaultLocale) {
+  if (!req || typeof req !== "object")
+    return [];
+  const list = req.payload?.config?.localization?.locales;
+  if (!Array.isArray(list) || list.length === 0)
+    return [];
+  const out = [];
+  for (const entry of list) {
+    const code = typeof entry === "string" ? entry : entry?.code;
+    if (typeof code === "string" && code.length > 0 && code !== defaultLocale) {
+      out.push(code);
+    }
+  }
+  return out;
+}
+function readFirstResolverKey(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const custom = req.payload?.config?.custom?.translator?.resolvers;
+  if (!Array.isArray(custom) || custom.length === 0)
+    return "";
+  const first = custom[0];
+  return typeof first?.key === "string" ? first.key : "";
+}
+
+// src/jobs/createAutoTranslateGlobalHook.ts
+function createAutoTranslateGlobalHook(options) {
+  const {
+    globalSlug,
+    defaultLocale: defaultLocaleOption,
+    targetLocales: targetLocalesOption,
+    workflowSlug = TRANSLATE_WORKFLOW_SLUG
+  } = options;
+  return async ({ doc, req }) => {
+    if (shouldSkipAutoTranslate2(req.context))
+      return doc;
+    const typed = doc;
+    const requestLocale = readRequestLocale2(req);
+    const defaultLocale = defaultLocaleOption ?? readConfigDefaultLocale2(req) ?? "";
+    if (!requestLocale || !defaultLocale || requestLocale !== defaultLocale)
+      return doc;
+    if (!req.user)
+      return doc;
+    const targetLocales = targetLocalesOption ?? readTargetLocales2(req, defaultLocale);
+    if (targetLocales.length === 0)
+      return doc;
+    const resolverKey = options.resolverKey ?? readFirstResolverKey2(req);
+    if (!resolverKey) {
+      req.payload.logger.error({
+        msg: `auto-translate: no resolver key available for global ${globalSlug} — pass \`resolverKey\` to \`createAutoTranslateGlobalHook\` or configure \`translator.resolvers\` in \`translator({...})\``
+      });
+      return doc;
+    }
+    const updatedAt = typed.updatedAt ?? new Date().toISOString();
+    const toLocales = targetLocales.filter((toLocale) => toLocale !== defaultLocale);
+    if (toLocales.length === 0)
+      return doc;
+    try {
+      const job = await req.payload.jobs.queue({
+        workflow: workflowSlug,
+        input: {
+          updatedAt,
+          global: globalSlug,
+          fromLocale: defaultLocale,
+          resolver: resolverKey || undefined,
+          toLocales
+        }
+      });
+      req.payload.logger.info({
+        msg: `auto-translate: queued translation of ${globalSlug} → [${toLocales.join(", ")}] (job ${job.id})`
+      });
+    } catch (error) {
+      req.payload.logger.error({
+        msg: `auto-translate: failed to queue ${globalSlug}: ${String(error)}`
+      });
+    }
+    return doc;
+  };
+}
+function shouldSkipAutoTranslate2(context) {
+  return Boolean(context?.disableAutoTranslate);
+}
+function readRequestLocale2(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const locale = req.locale;
+  return typeof locale === "string" && locale.length > 0 ? locale : "";
+}
+function readConfigDefaultLocale2(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const config = req.payload?.config;
+  const def = config?.localization?.defaultLocale;
+  return typeof def === "string" && def.length > 0 ? def : "";
+}
+function readTargetLocales2(req, defaultLocale) {
+  if (!req || typeof req !== "object")
+    return [];
+  const list = req.payload?.config?.localization?.locales;
+  if (!Array.isArray(list) || list.length === 0)
+    return [];
+  const out = [];
+  for (const entry of list) {
+    const code = typeof entry === "string" ? entry : entry?.code;
+    if (typeof code === "string" && code.length > 0 && code !== defaultLocale) {
+      out.push(code);
+    }
+  }
+  return out;
+}
+function readFirstResolverKey2(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const custom = req.payload?.config?.custom?.translator?.resolvers;
+  if (!Array.isArray(custom) || custom.length === 0)
+    return "";
+  const first = custom[0];
+  return typeof first?.key === "string" ? first.key : "";
+}
+
+// src/translate/operation.ts
+import he from "he";
+import { APIError as APIError3 } from "payload";
+
+// src/translate/findEntityWithConfig.ts
+import { APIError } from "payload";
+var findConfigBySlug = (slug, enities) => enities.find((entity) => entity.slug === slug);
+var findEntityWithConfig = async (args) => {
+  const { collectionSlug, globalSlug, id, locale, overrideAccess, req } = args;
+  if (!collectionSlug && !globalSlug)
+    throw new APIError("Bad Request", 400);
+  const { payload } = req;
+  const { config } = payload;
+  const isGlobal = !!globalSlug;
+  if (!isGlobal && !id)
+    throw new APIError("Bad Request", 400);
+  const entityConfig = isGlobal ? findConfigBySlug(globalSlug, config.globals) : findConfigBySlug(collectionSlug, config.collections);
+  if (!entityConfig)
+    throw new APIError("Bad Request", 400);
+  const docPromise = isGlobal ? payload.findGlobal({
+    depth: 0,
+    fallbackLocale: undefined,
+    locale,
+    overrideAccess,
+    req,
+    slug: args.globalSlug
+  }) : payload.findByID({
+    collection: collectionSlug,
+    depth: 0,
+    fallbackLocale: undefined,
+    id,
+    locale,
+    overrideAccess,
+    req
+  });
+  const doc = await docPromise;
+  return {
+    config: entityConfig,
+    doc
+  };
+};
+
+// src/translate/traverseFields.ts
+import ObjectID from "bson-objectid";
+import { tabHasName } from "payload/shared";
+
+// src/utils/isEmpty.ts
+var isEmpty = (value) => {
+  if (Array.isArray(value))
+    return value.length === 0;
+  if (value === null || typeof value === "undefined")
+    return true;
+  if (typeof value === "object" && Object.keys(value).length === 0)
+    return true;
+  return false;
+};
+
+// src/utils/sanitizeSlug.ts
+var sanitizeSlug = (text) => text.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9-_]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+
+// src/translate/traverseRichText.ts
+var traverseRichText = ({
+  onText,
+  root,
+  siblingData,
+  additionalTraverseRichText
+}) => {
+  siblingData = siblingData ?? root;
+  if (siblingData.text) {
+    onText(siblingData);
+  }
+  if (Array.isArray(siblingData?.children)) {
+    for (const child of siblingData.children) {
+      traverseRichText({
+        onText,
+        root,
+        siblingData: child,
+        additionalTraverseRichText
+      });
+    }
+  } else {
+    additionalTraverseRichText?.({ onText, root, siblingData });
+  }
+};
+
+// src/translate/traverseFields.ts
+var joinPath = (base, segment) => base ? `${base}.${segment}` : segment;
+var traverseFields = ({
+  dataFrom,
+  emptyOnly,
+  fields,
+  localizedParent,
+  path,
+  siblingDataFrom,
+  siblingDataTranslated,
+  translatedData,
+  valuesToTranslate,
+  _options
+}) => {
+  const { additionalTraverseRichText } = _options ?? {};
+  siblingDataFrom = siblingDataFrom ?? dataFrom;
+  siblingDataTranslated = siblingDataTranslated ?? translatedData;
+  for (const field of fields) {
+    switch (field.type) {
+      case "tabs":
+        for (const tab of field.tabs) {
+          const hasName = tabHasName(tab);
+          const tabDataFrom = hasName ? siblingDataFrom[tab.name] : siblingDataFrom;
+          if (!tabDataFrom)
+            return;
+          let tabDataTranslated;
+          if (hasName) {
+            if (!siblingDataTranslated[tab.name])
+              siblingDataTranslated[tab.name] = {};
+            tabDataTranslated = siblingDataTranslated[tab.name];
+          } else {
+            tabDataTranslated = siblingDataTranslated;
+          }
+          traverseFields({
+            dataFrom,
+            emptyOnly,
+            fields: tab.fields,
+            localizedParent: localizedParent ?? tab.localized,
+            path: hasName ? joinPath(path, tab.name) : path,
+            siblingDataFrom: tabDataFrom,
+            siblingDataTranslated: tabDataTranslated,
+            translatedData,
+            valuesToTranslate,
+            _options
+          });
+        }
+        break;
+      case "group": {
+        if (!("name" in field))
+          break;
+        const groupDataFrom = siblingDataFrom[field.name];
+        if (!groupDataFrom)
+          break;
+        if (!siblingDataTranslated[field.name])
+          siblingDataTranslated[field.name] = {};
+        const groupDataTranslated = siblingDataTranslated[field.name];
+        traverseFields({
+          dataFrom,
+          emptyOnly,
+          fields: field.fields,
+          localizedParent: localizedParent ?? field.localized,
+          path: joinPath(path, field.name),
+          siblingDataFrom: groupDataFrom,
+          siblingDataTranslated: groupDataTranslated,
+          translatedData,
+          valuesToTranslate,
+          _options
+        });
+        break;
+      }
+      case "array": {
+        const arrayDataFrom = siblingDataFrom[field.name];
+        if (isEmpty(arrayDataFrom))
+          break;
+        if (!siblingDataTranslated[field.name])
+          siblingDataTranslated[field.name] = [];
+        let arrayDataTranslated = siblingDataTranslated[field.name];
+        if (field.localized || localizedParent) {
+          if (arrayDataTranslated.length > 0 && emptyOnly)
+            break;
+          arrayDataTranslated = arrayDataFrom.map(() => ({
+            id: ObjectID().toHexString()
+          }));
+        }
+        arrayDataTranslated.forEach((item, index) => {
+          traverseFields({
+            dataFrom,
+            emptyOnly,
+            fields: field.fields,
+            localizedParent: localizedParent ?? field.localized,
+            path: `${joinPath(path, field.name)}[${index}]`,
+            siblingDataFrom: arrayDataFrom[index],
+            siblingDataTranslated: item,
+            translatedData,
+            valuesToTranslate,
+            _options
+          });
+        });
+        siblingDataTranslated[field.name] = arrayDataTranslated;
+        break;
+      }
+      case "blocks": {
+        const blocksDataFrom = siblingDataFrom[field.name];
+        if (isEmpty(blocksDataFrom))
+          break;
+        if (!siblingDataTranslated[field.name])
+          siblingDataTranslated[field.name] = [];
+        let blocksDataTranslated = siblingDataTranslated[field.name];
+        if (field.localized || localizedParent) {
+          if (blocksDataTranslated.length > 0 && emptyOnly)
+            break;
+          blocksDataTranslated = blocksDataFrom.map(({ blockType }) => ({
+            blockType,
+            id: ObjectID().toHexString()
+          }));
+        }
+        blocksDataTranslated.forEach((item, index) => {
+          const block = field.blocks.find((each) => each.slug === item.blockType);
+          if (!block)
+            return;
+          traverseFields({
+            dataFrom,
+            emptyOnly,
+            fields: block.fields,
+            localizedParent: localizedParent ?? field.localized,
+            path: `${joinPath(path, field.name)}[${index}](${item.blockType})`,
+            siblingDataFrom: blocksDataFrom[index],
+            siblingDataTranslated: item,
+            translatedData,
+            valuesToTranslate,
+            _options
+          });
+        });
+        siblingDataTranslated[field.name] = blocksDataTranslated;
+        break;
+      }
+      case "collapsible":
+      case "row":
+        traverseFields({
+          dataFrom,
+          emptyOnly,
+          fields: field.fields,
+          localizedParent,
+          path,
+          siblingDataFrom,
+          siblingDataTranslated,
+          translatedData,
+          valuesToTranslate,
+          _options
+        });
+        break;
+      case "date":
+      case "checkbox":
+      case "code":
+      case "email":
+      case "number":
+      case "point":
+      case "radio":
+      case "relationship":
+      case "select":
+      case "upload":
+        siblingDataTranslated[field.name] = siblingDataFrom[field.name];
+        break;
+      case "json":
+        let traverseObject = function(obj, objPath) {
+          if (!obj || typeof obj !== "object")
+            return;
+          for (const key in obj) {
+            const value = obj[key];
+            if (typeof value === "string" && value.trim()) {
+              ((parentObj, parentKey, parentValue, parentPath) => {
+                valuesToTranslate.push({
+                  onTranslate: (translated) => {
+                    parentObj[parentKey] = translated;
+                  },
+                  value: parentValue,
+                  path: parentPath
+                });
+              })(obj, key, value, joinPath(objPath, key));
+            } else if (typeof value === "object" && value !== null) {
+              traverseObject(value, joinPath(objPath, key));
+            }
+          }
+        };
+        if (!(field.localized || localizedParent))
+          break;
+        if (isEmpty(siblingDataFrom[field.name]))
+          break;
+        if (emptyOnly && siblingDataTranslated[field.name])
+          break;
+        const jsonDataFrom = siblingDataFrom[field.name];
+        const jsonDataTranslated = JSON.parse(JSON.stringify(jsonDataFrom));
+        siblingDataTranslated[field.name] = jsonDataTranslated;
+        traverseObject(jsonDataTranslated, joinPath(path, field.name));
+        break;
+      case "text":
+      case "textarea":
+        if (field.custom && typeof field.custom === "object" && field.custom.translatorSkip)
+          break;
+        if (!(field.localized || localizedParent) || isEmpty(siblingDataFrom[field.name]))
+          break;
+        if (emptyOnly && siblingDataTranslated[field.name])
+          break;
+        if (field.name === "blockName" || field.name === "id") {
+          break;
+        }
+        valuesToTranslate.push({
+          onTranslate: (translated) => {
+            siblingDataTranslated[field.name] = field.name === "slug" ? sanitizeSlug(translated) : translated;
+          },
+          value: siblingDataFrom[field.name],
+          path: joinPath(path, field.name)
+        });
+        break;
+      case "richText": {
+        if (!(field.localized || localizedParent) || isEmpty(siblingDataFrom[field.name]))
+          break;
+        if (emptyOnly && siblingDataTranslated[field.name])
+          break;
+        const richTextDataFrom = siblingDataFrom[field.name];
+        siblingDataTranslated[field.name] = richTextDataFrom;
+        if (!richTextDataFrom)
+          break;
+        const isSlate = Array.isArray(richTextDataFrom);
+        const isLexical = "root" in richTextDataFrom;
+        if (!isSlate && !isLexical)
+          break;
+        const richTextPath = joinPath(path, field.name);
+        let richTextNodeIndex = 0;
+        if (isLexical) {
+          const root = siblingDataTranslated[field.name]?.root;
+          if (root)
+            traverseRichText({
+              onText: (siblingData, attribute = "text") => {
+                valuesToTranslate.push({
+                  onTranslate: (translated) => {
+                    siblingData[attribute] = translated;
+                  },
+                  value: siblingData[attribute],
+                  path: `${richTextPath}#${richTextNodeIndex++}`
+                });
+              },
+              root,
+              additionalTraverseRichText
+            });
+        } else {
+          for (const root of siblingDataTranslated[field.name]) {
+            traverseRichText({
+              onText: (siblingData, attribute = "text") => {
+                valuesToTranslate.push({
+                  onTranslate: (translated) => {
+                    siblingData[attribute] = translated;
+                  },
+                  value: siblingData[attribute],
+                  path: `${richTextPath}#${richTextNodeIndex++}`
+                });
+              },
+              root,
+              additionalTraverseRichText
+            });
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+};
+
+// src/translate/updateEntity.ts
+import { APIError as APIError2 } from "payload";
+var updateEntity = ({
+  collectionSlug,
+  data,
+  depth: incomingDepth,
+  globalSlug,
+  id,
+  locale,
+  overrideAccess,
+  req
+}) => {
+  if (!collectionSlug && !globalSlug)
+    throw new APIError2("Bad Request", 400);
+  const isGlobal = !!globalSlug;
+  if (!isGlobal && !id)
+    throw new APIError2("Bad Request", 400);
+  const depth = incomingDepth ?? req.payload.config.defaultDepth;
+  const promise = isGlobal ? req.payload.updateGlobal({
+    data,
+    depth,
+    locale,
+    overrideAccess,
+    req,
+    slug: globalSlug
+  }) : req.payload.update({
+    collection: collectionSlug,
+    data,
+    depth,
+    id,
+    locale,
+    overrideAccess,
+    req
+  });
+  return promise;
+};
+
+// src/translate/operation.ts
+var preview = (value) => {
+  const flat = (typeof value === "string" ? value : String(value ?? "")).replace(/\s+/g, " ").trim();
+  return JSON.stringify(flat.length > 60 ? `${flat.slice(0, 57)}…` : flat);
+};
+var translateOperation = async (args) => {
+  const req = "req" in args ? args.req : {
+    payload: args.payload
+  };
+  const { collectionSlug, globalSlug, id, locale, localeFrom, overrideAccess } = args;
+  const { config, doc: dataFrom } = await findEntityWithConfig({
+    collectionSlug,
+    globalSlug,
+    id,
+    locale: localeFrom,
+    req
+  });
+  const resolver = (req.payload.config.custom?.translator?.resolvers ?? []).find((each) => each.key === args.resolver);
+  if (!resolver)
+    throw new APIError3(`Resolver with the key ${args.resolver} was not found`);
+  const valuesToTranslate = [];
+  let translatedData = args.data;
+  if (!translatedData) {
+    const { doc } = await findEntityWithConfig({
+      collectionSlug,
+      globalSlug,
+      id,
+      locale,
+      overrideAccess,
+      req
+    });
+    translatedData = doc;
+  }
+  traverseFields({
+    dataFrom,
+    emptyOnly: args.emptyOnly,
+    fields: config.fields,
+    translatedData,
+    valuesToTranslate,
+    _options: req.payload.config.custom?.translator?._options
+  });
+  const entityLabel = `${collectionSlug || globalSlug}#${id ?? ""}`;
+  const direction = `${args.localeFrom}→${args.locale}`;
+  req.payload.logger.info({
+    msg: `[translate] ${entityLabel} ${direction}: traversed ${valuesToTranslate.length} translatable value(s)`
+  });
+  const resolveResult = await resolver.resolve({
+    localeFrom: args.localeFrom,
+    localeTo: args.locale,
+    req,
+    texts: valuesToTranslate.map((each) => each.value)
+  });
+  let result;
+  if (!resolveResult.success) {
+    req.payload.logger.warn({
+      msg: `[translate] ${entityLabel} ${direction}: resolver failed — ${valuesToTranslate.length} value(s) traversed but NOT translated` + (valuesToTranslate.length ? `
+${valuesToTranslate.map((v) => `  ${v.path ?? "(unknown)"}: ${preview(v.value)}`).join(`
+`)}` : "")
+    });
+    result = {
+      success: false
+    };
+  } else {
+    const summary = [];
+    resolveResult.translatedTexts.forEach((translated, index) => {
+      const formattedValue = he.decode(translated);
+      const entry = valuesToTranslate[index];
+      summary.push(`  ${entry.path ?? "(unknown)"}: ${preview(entry.value)} → ${preview(formattedValue)}`);
+      entry.onTranslate(formattedValue);
+    });
+    req.payload.logger.info({
+      msg: `[translate] ${entityLabel} ${direction}: translated ${resolveResult.translatedTexts.length} value(s)` + (summary.length ? `
+${summary.join(`
+`)}` : "")
+    });
+    if (args.update) {
+      await updateEntity({
+        collectionSlug,
+        data: translatedData,
+        depth: 0,
+        globalSlug,
+        id,
+        locale,
+        overrideAccess,
+        req
+      });
+    }
+    result = {
+      success: true,
+      translatedData,
+      dataFrom
+    };
+  }
+  return result;
+};
+
+// src/jobs/createTranslateTask.ts
+function createTranslateTask(options = {}) {
+  const { slug = "translateEntityToLocale" } = options;
+  return {
+    slug,
+    inputSchema: [
+      { name: "id", type: "number", required: false },
+      { name: "collection", type: "text", required: false },
+      { name: "global", type: "text", required: false },
+      { name: "fromLocale", type: "text", required: true },
+      { name: "toLocale", type: "text", required: true },
+      { name: "resolver", type: "text", required: false }
+    ],
+    outputSchema: [],
+    retries: 3,
+    handler: async (args) => {
+      const { input, job, req } = args;
+      const { id, collection, global, fromLocale, toLocale, resolver: inputResolver } = input;
+      if (!collection && !global) {
+        throw new Error("translateTask: either `collection` or `global` must be provided");
+      }
+      const resolverKey = options.resolverKey ?? inputResolver ?? readFirstResolverKey3(req);
+      if (!resolverKey) {
+        throw new Error(`translateTask: no resolver key available — pass \`resolverKey\` to \`createTranslateTask\` or queue the workflow with a \`resolver\` input. Did you forget to pass \`translator.resolvers\` to \`translator({...})\`?`);
+      }
+      const entityLabel = collection || global;
+      req.payload.logger.info({
+        jobId: job.id,
+        msg: `translating ${entityLabel} to locale ${toLocale}`
+      });
+      let result;
+      try {
+        result = await translateOperation({
+          req,
+          collectionSlug: collection,
+          globalSlug: global,
+          emptyOnly: false,
+          id,
+          locale: toLocale,
+          localeFrom: fromLocale,
+          overrideAccess: true,
+          resolver: resolverKey,
+          update: false
+        });
+      } catch (error) {
+        req.payload.logger.error({
+          jobId: job.id,
+          msg: `translateOperation threw for ${entityLabel} → ${toLocale}: ${String(error)}`
+        });
+        throw error;
+      }
+      if (!result.success) {
+        req.payload.logger.error({
+          jobId: job.id,
+          msg: `translation for ${entityLabel} to ${toLocale} failed (resolver returned success=false)`
+        });
+        throw new Error(`translateTask: resolver returned success=false for ${entityLabel} → ${toLocale}`);
+      }
+      const translated = result.translatedData ?? {};
+      const { _locale: _dropLocale, _parent_id: _dropParent, ...data } = translated;
+      req.payload.logger.info({
+        jobId: job.id,
+        msg: `[translate] persisting ${entityLabel}#${id ?? global} → ${toLocale}`
+      });
+      try {
+        if (collection) {
+          await req.payload.update({
+            collection,
+            data,
+            id,
+            locale: toLocale,
+            overrideAccess: true,
+            req
+          });
+        } else {
+          await req.payload.updateGlobal({
+            slug: global,
+            data,
+            locale: toLocale,
+            overrideAccess: true,
+            req
+          });
+        }
+      } catch (error) {
+        req.payload.logger.error({
+          jobId: job.id,
+          msg: `persist failed for ${entityLabel} (id=${id ?? global}) at locale ${toLocale}: ${String(error)}`
+        });
+        throw error;
+      }
+      req.payload.logger.info({
+        jobId: job.id,
+        msg: `translation complete for ${entityLabel} → ${toLocale}`
+      });
+      return { output: { success: true } };
+    }
+  };
+}
+function readFirstResolverKey3(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const custom = req.payload?.config?.custom?.translator?.resolvers;
+  if (!Array.isArray(custom) || custom.length === 0)
+    return "";
+  const first = custom[0];
+  return typeof first?.key === "string" ? first.key : "";
+}
+
+// src/jobs/createTranslateWorkflow.ts
+function createTranslateWorkflow(options = {}) {
+  const { slug = "translateEntityToLocales", taskSlug = "translateEntityToLocale" } = options;
+  return {
+    slug,
+    inputSchema: [
+      { name: "id", type: "number", required: false },
+      { name: "updatedAt", type: "date", required: true },
+      { name: "collection", type: "text", required: false },
+      { name: "global", type: "text", required: false },
+      { name: "fromLocale", type: "text", required: true },
+      { name: "toLocales", type: "json", required: false },
+      { name: "toLocale", type: "text", required: false },
+      { name: "resolver", type: "text", required: false }
+    ],
+    handler: async (args) => {
+      const { job, req, tasks } = args;
+      const { id, collection, global, fromLocale, toLocales, toLocale, updatedAt, resolver } = job.input;
+      if (!collection && !global) {
+        throw new Error("translateWorkflow: either `collection` or `global` must be provided");
+      }
+      if (typeof req.payload.config.localization !== "object") {
+        req.payload.logger.error({
+          jobId: job.id,
+          msg: "localization is not enabled — skipping auto-translation workflow"
+        });
+        return;
+      }
+      const entityKey = collection ? `${collection}-${id}` : global;
+      const updatedAtIso = updatedAt instanceof Date ? updatedAt.toISOString() : String(updatedAt);
+      const requested = Array.isArray(toLocales) && toLocales.length > 0 ? toLocales : toLocale ? [toLocale] : [];
+      const targets = requested.filter((locale) => typeof locale === "string" && locale && locale !== fromLocale);
+      if (targets.length === 0) {
+        req.payload.logger.warn({
+          jobId: job.id,
+          msg: `translateWorkflow: no target locales for ${entityKey} — nothing to translate`
+        });
+        return;
+      }
+      req.payload.logger.info({
+        jobId: job.id,
+        msg: `scheduling translation of ${entityKey}: ${fromLocale} → [${targets.join(", ")}]`
+      });
+      for (const target of targets) {
+        await tasks[taskSlug](`${entityKey}-${fromLocale}-${target}-${updatedAtIso}`, {
+          input: {
+            id,
+            collection,
+            global,
+            fromLocale,
+            toLocale: target,
+            resolver
+          }
+        });
+      }
+    }
+  };
+}
+
+export { TRANSLATE_TASK_SLUG, TRANSLATE_WORKFLOW_SLUG, createAutoTranslateCollectionHook, createAutoTranslateGlobalHook, translateOperation, createTranslateTask, createTranslateWorkflow };