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

package/dist/index.d.ts

@@ -476,6 +476,7 @@ declare type TelemetryEvent =
   | TranslationBatchStartedEvent
   | TranslationBatchCompletedEvent
   | TranslationJobCompletedEvent
+  | TranslationJobFailedEvent
   | OpenAIApiCallEvent;
 
 /**
@@ -678,6 +679,28 @@ declare interface TranslationJobCompletedEvent extends TelemetryEventBase {
   };
 }
 
+/**
+ * Event emitted when an individual translation job fails.
+ * This is emitted alongside the detailed error bundle (via onError) to enable
+ * easy error rate calculations by comparing job_completed vs job_failed counts.
+ * @public
+ */
+declare interface TranslationJobFailedEvent extends TelemetryEventBase {
+  name: "translation.job_failed";
+  data: {
+    documentId: string;
+    documentType: string;
+    sourceLanguage: string;
+    targetLanguage: string;
+    translationMode: TranslationMode;
+    durationMs: number;
+    /** Categorized error type for filtering/grouping */
+    errorType: TranslationErrorType;
+    /** Error message (kept short for metrics; full details in error bundle) */
+    errorMessage: string;
+  };
+}
+
 declare type TranslationMode = "sanity-only" | "openai-only";
 
 /**

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)
@@ -2892,7 +2905,8 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       telemetryConfig
     }), newDocument = translationResult?.document;
     if (!newDocument) {
-      devLog.error("Translation failed: no document returned", new Error("Translation returned null"), logContext), setJobStatus(
+      const failureError = new Error("Translation returned null");
+      devLog.error("Translation failed: no document returned", failureError, logContext), setJobStatus(
         dispatch,
         sourceDocument._id,
         targetLanguage,
@@ -2901,7 +2915,20 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
           errorMessage: "Translation failed"
         },
         mainSourceDocumentId
-      ), devLog.timeEnd("translateDocument"), devLog.groupEnd();
+      ), emitTelemetryEvent(telemetryConfig, {
+        name: "translation.job_failed",
+        timestamp: createTimestamp(),
+        data: {
+          documentId: sourceDocument._id,
+          documentType: sourceDocument._type,
+          sourceLanguage,
+          targetLanguage,
+          translationMode,
+          durationMs: Date.now() - jobStartTime,
+          errorType: classifyError(failureError),
+          errorMessage: "Translation failed"
+        }
+      }), devLog.timeEnd("translateDocument"), devLog.groupEnd();
       return;
     }
     return setJobStatus(
@@ -2950,8 +2977,8 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       }
     }), devLog.timeEnd("translateDocument"), devLog.groupEnd(), newDocument._id;
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    devLog.error("Translation failed", error instanceof Error ? error : new Error(String(error)), logContext), setJobStatus(
+    const errorMessage = error instanceof Error ? error.message : String(error), errorObj = error instanceof Error ? error : new Error(String(error));
+    devLog.error("Translation failed", errorObj, logContext), setJobStatus(
       dispatch,
       sourceDocument._id,
       targetLanguage,
@@ -2960,7 +2987,20 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
         errorMessage
       },
       mainSourceDocumentId
-    ), devLog.timeEnd("translateDocument"), devLog.groupEnd();
+    ), emitTelemetryEvent(telemetryConfig, {
+      name: "translation.job_failed",
+      timestamp: createTimestamp(),
+      data: {
+        documentId: sourceDocument._id,
+        documentType: sourceDocument._type,
+        sourceLanguage,
+        targetLanguage,
+        translationMode,
+        durationMs: Date.now() - jobStartTime,
+        errorType: classifyError(errorObj),
+        errorMessage
+      }
+    }), devLog.timeEnd("translateDocument"), devLog.groupEnd();
     return;
   }
 }, translationSemaphore = new Semaphore(2), translateDocumentSet = async ({
@@ -3149,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,