@braze/sanity-plugin-ai-translation 0.2.72 → 0.2.73

package/dist/index.js

@@ -482,8 +482,8 @@ function isNetworkError(error) {
       return response.status >= 500 || response.status === 429;
   }
   if (error instanceof Error) {
-    const message = error.message;
-    if (/\b(50[0-9]|429)\b/.test(message))
+    const message = error.message.toLowerCase();
+    if (/\b(50[0-9]|429)\b/.test(message) || message.includes("rate limit"))
       return !0;
   }
   return !1;
@@ -870,7 +870,14 @@ const fetchTranslationPrompts = async ({
   languageFieldName
 }) => {
   try {
-    const doc = await client.fetch("*[_id == $documentId][0]", { documentId });
+    const doc = await retryWithBackoff(
+      () => client.fetch("*[_id == $documentId][0]", { documentId }),
+      {
+        maxAttempts: 3,
+        initialDelayMs: 1e3,
+        context: { operation: "localizeReferences.fetchDocument", documentId }
+      }
+    );
     if (!doc) {
       devLog.error("Document not found", new Error("Document not found"), {
         documentId,
@@ -900,17 +907,24 @@ const fetchTranslationPrompts = async ({
 }, updateReferences = async (documentId, client, refs, sourceLanguage, targetLanguage) => {
   if (!refs?.length)
     return [];
-  const refIds = refs.map((r) => getPublishedId(r.value)), translations = await client.fetch(
-    `*[_type == $translationMetadataSchemaType && array::intersects(translations[].value._ref, $refIds)] {
+  const refIds = refs.map((r) => getPublishedId(r.value)), translations = await retryWithBackoff(
+    () => client.fetch(
+      `*[_type == $translationMetadataSchemaType && array::intersects(translations[].value._ref, $refIds)] {
       "sourceId": translations[_key == $sourceLanguage][0].value._ref,
       "targetId": translations[_key == $targetLanguage][0].value._ref,
       "targetType": translations[_key == $sourceLanguage][0].value -> _type
     }`,
+      {
+        translationMetadataSchemaType: TRANSLATION_METADATA_TYPE,
+        refIds,
+        sourceLanguage,
+        targetLanguage
+      }
+    ),
     {
-      translationMetadataSchemaType: TRANSLATION_METADATA_TYPE,
-      refIds,
-      sourceLanguage,
-      targetLanguage
+      maxAttempts: 3,
+      initialDelayMs: 1e3,
+      context: { operation: "localizeReferences.fetchTranslations", refCount: refIds.length }
     }
   ), translationMap = /* @__PURE__ */ new Map();
   for (const t of translations)
@@ -948,81 +962,80 @@ const fetchTranslationPrompts = async ({
 }, updateBackwardReferences = async ({
   client,
   releaseId,
-  sourceDocumentIds,
   targetLanguages,
   sourceLanguage,
   languageFieldName,
   excludeDocumentIds
 }) => {
-  if (!sourceDocumentIds.length || !targetLanguages.length)
-    return;
-  const normalizedSourceIds = sourceDocumentIds.map((id) => getPublishedId(id));
-  devLog.debug("Starting backward reference update", {
-    releaseId,
-    sourceDocumentCount: normalizedSourceIds.length,
-    targetLanguages,
-    excludeCount: excludeDocumentIds.length,
-    component: "updateBackwardReferences"
-  });
-  try {
-    for (const targetLanguage of targetLanguages) {
-      const existingDocsWithStaleRefs = await client.fetch(
+  if (targetLanguages.length) {
+    devLog.debug("Starting backward reference update", {
+      releaseId,
+      targetLanguages,
+      excludeCount: excludeDocumentIds.length,
+      component: "updateBackwardReferences"
+    });
+    try {
+      const existingDocs = await client.fetch(
         `*[
-          _id match "versions." + $releaseId + ".*" &&
-          @[$languageFieldName] == $targetLanguage &&
-          !(_id in $excludeIds)
-        ] {
-          _id,
-          "hasStaleRefs": count(*[
-            _id in $sourceDocumentIds && 
-            ^references(@._id)
-          ]) > 0
-        }[hasStaleRefs == true]`,
+        sanity::partOfRelease($releaseId) &&
+        @[$languageFieldName] in $targetLanguages &&
+        !(_id in $excludeIds)
+      ]{
+        _id,
+        "language": @[$languageFieldName]
+      }`,
         {
           releaseId,
-          targetLanguage,
+          targetLanguages,
           languageFieldName,
-          excludeIds: excludeDocumentIds,
-          sourceDocumentIds: normalizedSourceIds
+          excludeIds: excludeDocumentIds
         }
       );
-      if (existingDocsWithStaleRefs.length === 0) {
-        devLog.debug("No existing documents with stale references found", {
+      if (existingDocs.length === 0) {
+        devLog.debug("No existing documents found in release for target languages", {
           releaseId,
-          targetLanguage,
+          targetLanguages,
           component: "updateBackwardReferences"
         });
-        continue;
+        return;
       }
-      devLog.info("Found existing documents with stale references", {
+      devLog.info("Processing existing documents for backward reference updates", {
         releaseId,
-        targetLanguage,
-        count: existingDocsWithStaleRefs.length,
-        documentIds: existingDocsWithStaleRefs.map((d) => d._id),
+        targetLanguages,
+        count: existingDocs.length,
         component: "updateBackwardReferences"
-      }), await Promise.all(
-        existingDocsWithStaleRefs.map(async ({ _id }) => {
+      });
+      let updated = 0, errors = 0;
+      for (const { _id } of existingDocs)
+        try {
           await localizeReferences({
             client,
             documentId: _id,
             sourceLanguage,
             languageFieldName
+          }), updated++;
+        } catch (error) {
+          errors++, devLog.warn("Failed to update references for document", {
+            documentId: _id,
+            error: error instanceof Error ? error.message : String(error),
+            component: "updateBackwardReferences"
           });
-        })
-      ), devLog.info("Updated backward references", {
+        }
+      devLog.info("Backward reference update complete", {
         releaseId,
-        targetLanguage,
-        updatedCount: existingDocsWithStaleRefs.length,
+        targetLanguages,
+        processed: existingDocs.length,
+        updated,
+        errors,
+        component: "updateBackwardReferences"
+      });
+    } catch (error) {
+      devLog.error("Error updating backward references", error instanceof Error ? error : new Error(String(error)), {
+        releaseId,
+        targetLanguages,
         component: "updateBackwardReferences"
       });
     }
-  } catch (error) {
-    devLog.error("Error updating backward references", error instanceof Error ? error : new Error(String(error)), {
-      releaseId,
-      sourceDocumentIds: normalizedSourceIds,
-      targetLanguages,
-      component: "updateBackwardReferences"
-    });
   }
 }, setupTranslationJobStatuses = (dispatch, sourceDocuments, targetLanguages, mainSourceDocumentId) => {
   for (const sourceDocument of sourceDocuments)
@@ -3176,10 +3189,14 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
           languageFieldName
         });
       })
-    ), releaseConfig.mode === "existing" && releaseId && await updateBackwardReferences({
+    ), devLog.debug("Checking if backward reference update is needed", {
+      releaseMode: releaseConfig.mode,
+      releaseId,
+      willUpdate: releaseConfig.mode === "existing" && !!releaseId,
+      component: "translateDocumentSet"
+    }), releaseConfig.mode === "existing" && releaseId && await updateBackwardReferences({
       client,
       releaseId,
-      sourceDocumentIds,
       targetLanguages,
       sourceLanguage,
       languageFieldName,