gt-sanity 2.0.21 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gt-sanity",
-  "version": "2.0.21",
+  "version": "2.1.1",
   "description": "General Translation integration with Sanity",
   "keywords": [
     "sanity",
@@ -54,7 +54,7 @@
     "jsonpath-plus": "^10.3.0",
     "jsonpointer": "^5.0.1",
     "lodash.merge": "^4.6.2",
-    "generaltranslation": "8.2.19"
+    "generaltranslation": "9.0.1"
   },
   "devDependencies": {
     "@portabletext/types": "^2.0.15",

package/src/adapter/core.ts

@@ -6,6 +6,7 @@ import type {
   DedupeFields,
   IgnoreFields,
   SkipFields,
+  FieldLevelTranslationMode,
 } from './types';
 import { SECRETS_NAMESPACE } from '../utils/shared';
 import type { PortableTextHtmlComponents } from '@portabletext/to-html';
@@ -34,6 +35,9 @@ export class GTConfig {
   additionalSerializers: Partial<PortableTextHtmlComponents>;
   additionalDeserializers: CustomDeserializers;
   additionalBlockDeserializers: unknown[];
+  translationLevel: FieldLevelTranslationMode;
+  fieldLevelDocuments: TranslateDocumentFilter[];
+  fieldLevelTypePrefix: string;
 
   private static instance: GTConfig;
   constructor(
@@ -50,7 +54,10 @@ export class GTConfig {
     additionalStopTypes: string[] = [],
     additionalSerializers: Partial<PortableTextHtmlComponents> = {},
     additionalDeserializers: CustomDeserializers = { types: {} },
-    additionalBlockDeserializers: unknown[] = []
+    additionalBlockDeserializers: unknown[] = [],
+    translationLevel: FieldLevelTranslationMode = 'document',
+    fieldLevelDocuments: TranslateDocumentFilter[] = [],
+    fieldLevelTypePrefix: string = 'internationalizedArray'
   ) {
     this.secretsNamespace = secretsNamespace;
     this.languageField = languageField;
@@ -66,6 +73,9 @@ export class GTConfig {
     this.additionalSerializers = additionalSerializers;
     this.additionalDeserializers = additionalDeserializers;
     this.additionalBlockDeserializers = additionalBlockDeserializers;
+    this.translationLevel = translationLevel;
+    this.fieldLevelDocuments = fieldLevelDocuments;
+    this.fieldLevelTypePrefix = fieldLevelTypePrefix;
   }
 
   static getInstance() {
@@ -104,7 +114,10 @@ export class GTConfig {
     additionalStopTypes: string[] = [],
     additionalSerializers: Partial<PortableTextHtmlComponents> = {},
     additionalDeserializers: CustomDeserializers = { types: {} },
-    additionalBlockDeserializers: unknown[] = []
+    additionalBlockDeserializers: unknown[] = [],
+    translationLevel: FieldLevelTranslationMode = 'document',
+    fieldLevelDocuments: TranslateDocumentFilter[] = [],
+    fieldLevelTypePrefix: string = 'internationalizedArray'
   ) {
     this.secretsNamespace = secretsNamespace;
     this.languageField = languageField;
@@ -120,6 +133,9 @@ export class GTConfig {
     this.additionalSerializers = additionalSerializers;
     this.additionalDeserializers = additionalDeserializers;
     this.additionalBlockDeserializers = additionalBlockDeserializers;
+    this.translationLevel = translationLevel;
+    this.fieldLevelDocuments = fieldLevelDocuments;
+    this.fieldLevelTypePrefix = fieldLevelTypePrefix;
   }
 
   getSecretsNamespace() {
@@ -166,5 +182,14 @@ export class GTConfig {
   getAdditionalBlockDeserializers() {
     return this.additionalBlockDeserializers;
   }
+  getTranslationLevel() {
+    return this.translationLevel;
+  }
+  getFieldLevelDocuments() {
+    return this.fieldLevelDocuments;
+  }
+  getFieldLevelTypePrefix() {
+    return this.fieldLevelTypePrefix;
+  }
 }
 export const pluginConfig = GTConfig.getInstance();

package/src/adapter/types.ts

@@ -14,6 +14,15 @@ export type TranslateDocumentFilter = {
   type?: string;
 };
 
+// How matched documents are translated:
+// - 'document'               translate whole documents (per-locale documents).
+// - 'internationalizedArray' localize fields in place (array shape).
+// - 'mixed'                  array strategy for `fieldLevelDocuments`, else doc.
+export type FieldLevelTranslationMode =
+  | 'document'
+  | 'internationalizedArray'
+  | 'mixed';
+
 export type FileProperties = {
   versionId: string;
   fileId: string;

package/src/components/TranslationsProvider.tsx

@@ -18,7 +18,7 @@ import {
   TranslationFunctionContext,
 } from '../types';
 import { gt, overrideConfig, pluginConfig } from '../adapter/core';
-import { serializeDocument } from '../utils/serialize';
+import { getTranslationStrategy } from '../translation/strategy';
 import { uploadFiles } from '../translation/uploadFiles';
 import { initProject } from '../translation/initProject';
 import { createJobs } from '../translation/createJobs';
@@ -84,6 +84,11 @@ interface TranslationsContextType {
   loadingSecrets: boolean;
   secrets: Secrets | null;
   branchId: string | undefined;
+  // Version to use for translation status keys and GT file queries. Prefers
+  // the _rev pinned at upload time over the live _rev, so in-place imports
+  // (internationalized arrays) bumping the document _rev don't orphan the
+  // statuses of the version actually uploaded to GT.
+  getVersionId: (document: SanityDocument) => string;
 
   // Actions
   setLocales: (locales: TranslationLocale[]) => void;
@@ -106,6 +111,51 @@ interface TranslationsContextType {
 
 const TranslationsContext = createContext<TranslationsContextType | null>(null);
 
+// Pinned upload versions are mirrored to sessionStorage so they survive a
+// Studio page refresh: falling back to the live document._rev after a refresh
+// would query GT with a version that was never uploaded (in-place imports bump
+// the _rev), making completed translations show as "not started". Keyed by
+// project + dataset so Studios sharing an origin don't collide.
+const getUploadedVersionsStorageKey = (
+  projectId: string | undefined,
+  dataset: string | undefined
+) => `gt-sanity:uploadedVersions:${projectId ?? ''}:${dataset ?? ''}`;
+
+function readUploadedVersions(storageKey: string): Map<string, string> {
+  try {
+    const raw = window.sessionStorage.getItem(storageKey);
+    if (!raw) return new Map();
+    const parsed: unknown = JSON.parse(raw);
+    if (!isPlainRecord(parsed)) return new Map();
+    return new Map(
+      Object.entries(parsed).filter(
+        (entry): entry is [string, string] => typeof entry[1] === 'string'
+      )
+    );
+  } catch {
+    return new Map();
+  }
+}
+
+function writeUploadedVersions(
+  storageKey: string,
+  versions: Map<string, string>
+): void {
+  try {
+    window.sessionStorage.setItem(
+      storageKey,
+      JSON.stringify(Object.fromEntries(versions))
+    );
+  } catch {
+    // sessionStorage unavailable (SSR, private mode, quota) — pinned versions
+    // fall back to in-memory only.
+  }
+}
+
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
 export const useTranslations = () => {
   const context = useContext(TranslationsContext);
   if (!context) {
@@ -154,6 +204,14 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
   const [isRefreshing, setIsRefreshing] = useState(false);
 
   const client = useClient();
+  const { projectId, dataset } = client.config();
+  const uploadedVersionsStorageKey = getUploadedVersionsStorageKey(
+    projectId,
+    dataset
+  );
+  const [uploadedVersions, setUploadedVersions] = useState<Map<string, string>>(
+    () => readUploadedVersions(uploadedVersionsStorageKey)
+  );
   const schema = useSchema();
   const translationContext: TranslationFunctionContext = { client, schema };
   const toast = useToast();
@@ -166,6 +224,12 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
     downloadStatusRef.current = downloadStatus;
   }, [downloadStatus]);
 
+  const getVersionId = useCallback(
+    (document: SanityDocument) =>
+      uploadedVersions.get(getDocumentPublishedId(document)) ?? document._rev,
+    [uploadedVersions]
+  );
+
   const fetchDocuments = useCallback(async () => {
     setLoadingDocuments(true);
     try {
@@ -299,7 +363,8 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
           const { [pluginConfig.getLanguageField()]: _, ...cleanDoc } = doc;
           const baseLanguage = pluginConfig.getSourceLocale();
           try {
-            const serialized = serializeDocument(
+            const strategy = getTranslationStrategy(doc);
+            const serialized = strategy.serialize(
               cleanDoc as typeof doc,
               schema,
               baseLanguage
@@ -322,6 +387,19 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
       await initProject(uploadResult, { timeout: 600 }, secrets);
       await createJobs(uploadResult, availableLocaleIds, secrets);
 
+      // Pin the _rev each file was uploaded under. GT status queries need the
+      // exact uploaded versionId, and the live _rev moves on (in-place array
+      // imports bump it), so status lookups go through getVersionId instead.
+      // Persisted to sessionStorage so the pins survive a page refresh.
+      const nextUploadedVersions = new Map(uploadedVersions);
+      for (const { info } of transformedDocuments) {
+        if (info.versionId) {
+          nextUploadedVersions.set(info.documentId, info.versionId);
+        }
+      }
+      writeUploadedVersions(uploadedVersionsStorageKey, nextUploadedVersions);
+      setUploadedVersions(nextUploadedVersions);
+
       toast.push({
         title: `Translation tasks created for ${documents.length} documents`,
         status: 'success',
@@ -337,7 +415,14 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
     } finally {
       setIsBusy(false);
     }
-  }, [secrets, documents, locales, schema]);
+  }, [
+    secrets,
+    documents,
+    locales,
+    schema,
+    uploadedVersions,
+    uploadedVersionsStorageKey,
+  ]);
 
   const handleImportAll = useCallback(async () => {
     if (!secrets || documents.length === 0 || !branchId) return;
@@ -592,7 +677,7 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
         for (const localeId of availableLocaleIds) {
           const documentId = getDocumentPublishedId(doc);
           fileQueryData.push({
-            versionId: doc._rev,
+            versionId: getVersionId(doc),
             fileId: documentId,
             branchId: branchId,
             locale: localeId,
@@ -612,7 +697,7 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
         for (const doc of documents) {
           for (const localeId of availableLocaleIds) {
             const documentId = getDocumentPublishedId(doc);
-            const versionId = doc._rev;
+            const versionId = getVersionId(doc);
             const key = createTranslationStatusKey(
               branchId,
               documentId,
@@ -663,7 +748,7 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
     } finally {
       setIsRefreshing(false);
     }
-  }, [secrets, documents, locales, branchId]);
+  }, [secrets, documents, locales, branchId, getVersionId]);
 
   const handleImportDocument = useCallback(
     async (documentId: string, versionId: string, localeId: string) => {
@@ -1038,6 +1123,7 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
     loadingSecrets,
     secrets,
     branchId,
+    getVersionId,
 
     // Actions
     setLocales,

package/src/components/page/TranslationsTable.tsx

@@ -17,6 +17,7 @@ export const TranslationsTable: React.FC = () => {
     importedTranslations,
     handleImportDocument,
     branchId,
+    getVersionId,
   } = useTranslations();
 
   if (loadingDocuments) {
@@ -50,10 +51,11 @@ export const TranslationsTable: React.FC = () => {
                     .filter((locale) => locale.enabled !== false)
                     .map((locale) => {
                       const documentId = getDocumentPublishedId(document);
+                      const versionId = getVersionId(document);
                       const key = createTranslationStatusKey(
                         branchId,
                         documentId,
-                        document._rev,
+                        versionId,
                         locale.localeId
                       );
                       const status = translationStatuses.get(key);
@@ -62,14 +64,14 @@ export const TranslationsTable: React.FC = () => {
 
                       return (
                         <LanguageStatus
-                          key={`${document._id}-${document._rev}-${locale.localeId}`}
+                          key={`${document._id}-${versionId}-${locale.localeId}`}
                           title={locale.description || locale.localeId}
                           progress={status?.progress || 0}
                           isImported={isImported || isDownloaded}
                           importFile={async () => {
                             await handleImportDocument(
                               documentId,
-                              document._rev,
+                              versionId,
                               locale.localeId
                             );
                           }}

package/src/components/shared/SingleDocumentView.tsx

@@ -18,6 +18,7 @@ export const SingleDocumentView: React.FC = () => {
     importedTranslations,
     handleImportDocument,
     branchId,
+    getVersionId,
   } = useTranslations();
 
   // Get the first (and only) document in single document mode
@@ -78,10 +79,11 @@ export const SingleDocumentView: React.FC = () => {
                   .filter((locale) => locale.enabled !== false)
                   .map((locale) => {
                     const documentId = getDocumentPublishedId(document);
+                    const versionId = getVersionId(document);
                     const key = createTranslationStatusKey(
                       branchId,
                       documentId,
-                      document._rev,
+                      versionId,
                       locale.localeId
                     );
                     const status = translationStatuses.get(key);
@@ -90,14 +92,14 @@ export const SingleDocumentView: React.FC = () => {
 
                     return (
                       <LanguageStatus
-                        key={`${document._id}-${document._rev}-${locale.localeId}`}
+                        key={`${document._id}-${versionId}-${locale.localeId}`}
                         title={locale.description || locale.localeId}
                         progress={status?.progress || 0}
                         isImported={isImported || isDownloaded}
                         importFile={async () => {
                           await handleImportDocument(
                             documentId,
-                            document._rev,
+                            versionId,
                             locale.localeId
                           );
                         }}

package/src/components/tab/TranslationView.tsx

@@ -50,6 +50,7 @@ export const TranslationView = () => {
     setAutoPatchReferences,
     autoPublish,
     setAutoPublish,
+    getVersionId,
   } = useTranslations();
 
   const [isImporting, setIsImporting] = useState(false);
@@ -92,13 +93,21 @@ export const TranslationView = () => {
     return getDocumentPublishedId(document);
   }, [document]);
 
+  // Version the status entries are keyed under: the _rev pinned at upload
+  // time when available, so importing in place (which bumps the live _rev)
+  // doesn't detach the UI from the statuses of the uploaded version.
+  const versionId = useMemo(() => {
+    if (!document) return null;
+    return getVersionId(document);
+  }, [document, getVersionId]);
+
   // Unified import functionality
   const handleImportTranslations = useCallback(
     async (options: { autoOnly?: boolean } = {}) => {
       const { autoOnly = false } = options;
 
       // Check preconditions
-      if (isImporting || !documentId) return;
+      if (isImporting || !documentId || !versionId) return;
       if (autoOnly && !autoImport) return;
 
       // Find translations ready to import
@@ -106,7 +115,7 @@ export const TranslationView = () => {
         const key = createTranslationStatusKey(
           branchId,
           documentId,
-          document._rev,
+          versionId,
           locale.localeId
         );
         const status = translationStatuses.get(key);
@@ -117,12 +126,12 @@ export const TranslationView = () => {
 
       setIsImporting(true);
       try {
-        // Import all ready translations
-        await Promise.all(
-          readyTranslations.map((locale) =>
-            handleImportDocument(documentId, document._rev, locale.localeId)
-          )
-        );
+        // Import sequentially: internationalized-array imports patch this same
+        // document in place, so concurrent locale imports would overwrite each
+        // other and only the last locale would survive.
+        for (const locale of readyTranslations) {
+          await handleImportDocument(documentId, versionId, locale.localeId);
+        }
 
         // Auto patch document references if enabled
         if (autoPatchReferences) {
@@ -141,6 +150,7 @@ export const TranslationView = () => {
       autoImport,
       isImporting,
       documentId,
+      versionId,
       availableLocales,
       translationStatuses,
       importedTranslations,
@@ -261,7 +271,7 @@ export const TranslationView = () => {
       </Stack>
 
       {/* Translation Status Section */}
-      {documentId && availableLocales.length > 0 && (
+      {documentId && versionId && availableLocales.length > 0 && (
         <Stack space={4}>
           <Flex align='center' justify='space-between'>
             <Text as='h2' weight='semibold' size={2}>
@@ -290,7 +300,7 @@ export const TranslationView = () => {
               const key = createTranslationStatusKey(
                 branchId,
                 documentId,
-                document._rev,
+                versionId,
                 locale.localeId
               );
               const status = translationStatuses.get(key);
@@ -307,7 +317,7 @@ export const TranslationView = () => {
                     if (!isImported && status?.isReady) {
                       await handleImportDocument(
                         documentId,
-                        document._rev,
+                        versionId,
                         locale.localeId
                       );
                     }
@@ -333,7 +343,7 @@ export const TranslationView = () => {
                       const key = createTranslationStatusKey(
                         branchId,
                         documentId,
-                        document._rev,
+                        versionId,
                         locale.localeId
                       );
                       const status = translationStatuses.get(key);
@@ -358,7 +368,7 @@ export const TranslationView = () => {
                     const key = createTranslationStatusKey(
                       branchId,
                       documentId,
-                      document._rev,
+                      versionId,
                       locale.localeId
                     );
                     return importedTranslations.has(key);
@@ -370,7 +380,7 @@ export const TranslationView = () => {
                     const key = createTranslationStatusKey(
                       branchId,
                       documentId,
-                      document._rev,
+                      versionId,
                       locale.localeId
                     );
                     const status = translationStatuses.get(key);

package/src/configuration/baseDocumentLevelConfig/documentLevelPatch.ts

@@ -1,7 +1,7 @@
 // adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
 
 import { SanityClient, SanityDocument, SanityDocumentLike } from 'sanity';
-import { BaseDocumentMerger } from '../../serialization';
+import { BaseDocumentMerger } from '../../serialization/BaseDocumentMerger';
 
 import { findLatestDraft } from '../utils/findLatestDraft';
 import { findDocumentAtRevision } from '../utils/findDocumentAtRevision';

package/src/configuration/baseFieldLevelConfig.ts

@@ -1,7 +1,7 @@
 // adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
 
 import { SanityClient, SanityDocument } from 'sanity';
-import { BaseDocumentMerger } from '../serialization/';
+import { BaseDocumentMerger } from '../serialization/BaseDocumentMerger';
 
 import type {
   ExportForTranslation,

package/src/configuration/internationalizedArrayConfig/internationalizedArrayPatch.ts

@@ -0,0 +1,59 @@
+import { SanityClient, SanityDocument } from 'sanity';
+import { pluginConfig } from '../../adapter/core';
+import { mergeInternationalizedArrays } from '../../serialization/internationalizedArray/merge';
+import type { GTFile } from '../../types';
+import { getPublishedId } from '../../utils/documentIds';
+import { findLatestDraft } from '../utils/findLatestDraft';
+
+/**
+ * Import a translated internationalized-array document in place.
+ *
+ * Unlike document-level import (which creates per-locale documents and tracks
+ * translation metadata), array localization upserts the target-locale `value`
+ * into the same source document. We read the latest draft so concurrent edits
+ * to the source are not clobbered, merge only the changed top-level fields, and
+ * commit a single patch.
+ */
+export const internationalizedArrayPatch = async (
+  docInfo: GTFile,
+  translatedFields: SanityDocument,
+  localeId: string,
+  client: SanityClient
+): Promise<void> => {
+  const sourceLocale = pluginConfig.getSourceLocale();
+
+  const baseDoc = await findLatestDraft(docInfo.documentId, client);
+  if (!baseDoc) {
+    return;
+  }
+
+  const changes = mergeInternationalizedArrays(
+    baseDoc as Record<string, unknown>,
+    translatedFields as Record<string, unknown>,
+    localeId,
+    sourceLocale
+  );
+
+  if (Object.keys(changes).length === 0) {
+    return;
+  }
+
+  // Every key in `changes` already exists on the base document (merge only
+  // returns existing fields), so a full `set` of the merged field is safe and
+  // preserves all other locale items and their random `_key`s.
+  if (baseDoc._id.startsWith('drafts.')) {
+    await client.patch(baseDoc._id).set(changes).commit();
+    return;
+  }
+
+  // Only the published document exists. Mutations via the client write to the
+  // exact id given (drafts are a Studio convention, not created server-side),
+  // so patch a draft seeded from the published state instead of publishing
+  // translated content directly.
+  const draftId = `drafts.${getPublishedId(baseDoc._id)}`;
+  await client
+    .transaction()
+    .createIfNotExists({ ...baseDoc, _id: draftId })
+    .patch(draftId, (patch) => patch.set(changes))
+    .commit();
+};