gt-sanity 1.0.11 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gt-sanity",
-  "version": "1.0.11",
+  "version": "1.1.1",
   "description": "General Translation integration with Sanity",
   "keywords": [
     "sanity",
@@ -51,7 +51,7 @@
     "jsonpath-plus": "^10.3.0",
     "jsonpointer": "^5.0.1",
     "lodash.merge": "^4.6.2",
-    "generaltranslation": "7.9.1"
+    "generaltranslation": "8.0.1"
   },
   "devDependencies": {
     "@portabletext/types": "^2.0.15",

package/src/adapter/getTranslation.ts

@@ -11,7 +11,7 @@ export const getTranslation: Adapter['getTranslation'] = async (
     return '';
   }
   overrideConfig(secrets);
-  const text = await gt.downloadTranslatedFile({
+  const text = await gt.downloadFile({
     fileId: documentInfo.documentId,
     versionId: documentInfo.versionId || undefined,
     locale: localeId,

package/src/adapter/types.ts

@@ -7,3 +7,15 @@ export type TranslateDocumentFilter = {
   documentId?: string;
   type?: string;
 };
+
+export type FileProperties = {
+  versionId: string;
+  fileId: string;
+  locale: string;
+  branchId: string;
+};
+export type TranslationStatus = {
+  progress: number;
+  isReady: boolean;
+  fileData: FileProperties;
+};

package/src/components/TranslationsProvider.tsx

@@ -16,7 +16,7 @@ import {
   TranslationLocale,
   TranslationFunctionContext,
 } from '../types';
-import { pluginConfig } from '../adapter/core';
+import { gt, overrideConfig, pluginConfig } from '../adapter/core';
 import { serializeDocument } from '../utils/serialize';
 import { uploadFiles } from '../translation/uploadFiles';
 import { initProject } from '../translation/initProject';
@@ -34,6 +34,7 @@ import {
 import { processBatch } from '../utils/batchProcessor';
 import { publishTranslations } from '../sanity-api/publishDocuments';
 import { getLocales } from '../adapter/getLocales';
+import type { FileProperties, TranslationStatus } from '../adapter/types';
 
 interface ImportProgress {
   current: number;
@@ -47,18 +48,15 @@ interface DownloadStatus {
   skipped: Set<string>;
 }
 
-interface TranslationStatus {
-  progress: number;
-  isReady: boolean;
-  translationId?: string;
-}
-
 interface TranslationsContextType {
   // State
   isBusy: boolean;
   documents: SanityDocument[];
   locales: TranslationLocale[];
   autoRefresh: boolean;
+  autoImport: boolean;
+  autoPatchReferences: boolean;
+  autoPublish: boolean;
   loadingDocuments: boolean;
   importProgress: ImportProgress;
   importedTranslations: Set<string>;
@@ -68,15 +66,23 @@ interface TranslationsContextType {
   isRefreshing: boolean;
   loadingSecrets: boolean;
   secrets: Secrets | null;
+  branchId: string | undefined;
 
   // Actions
   setLocales: (locales: TranslationLocale[]) => void;
   setAutoRefresh: (value: boolean) => void;
+  setAutoImport: (value: boolean) => void;
+  setAutoPatchReferences: (value: boolean) => void;
+  setAutoPublish: (value: boolean) => void;
   handleTranslateAll: () => Promise<void>;
   handleImportAll: () => Promise<void>;
   handleImportMissing: () => Promise<void>;
   handleRefreshAll: () => Promise<void>;
-  handleImportDocument: (documentId: string, localeId: string) => Promise<void>;
+  handleImportDocument: (
+    documentId: string,
+    versionId: string,
+    localeId: string
+  ) => Promise<void>;
   handlePatchDocumentReferences: () => Promise<number>;
   handlePublishAllTranslations: () => Promise<number>;
 }
@@ -104,6 +110,9 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
   const [documents, setDocuments] = useState<SanityDocument[]>([]);
   const [locales, setLocales] = useState<TranslationLocale[]>([]);
   const [autoRefresh, setAutoRefresh] = useState(false);
+  const [autoImport, setAutoImport] = useState(false);
+  const [autoPatchReferences, setAutoPatchReferences] = useState(false);
+  const [autoPublish, setAutoPublish] = useState(false);
   const [loadingDocuments, setLoadingDocuments] = useState(false);
   const [importProgress, setImportProgress] = useState<ImportProgress>({
     current: 0,
@@ -133,6 +142,7 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
   const { loading: loadingSecrets, secrets } = useSecrets<Secrets>(
     pluginConfig.getSecretsNamespace()
   );
+  const [branchId, setBranchId] = useState<string | undefined>(undefined);
 
   const fetchDocuments = useCallback(async () => {
     setLoadingDocuments(true);
@@ -294,15 +304,12 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
   }, [secrets, documents, locales, schema]);
 
   const handleImportAll = useCallback(async () => {
-    if (!secrets || documents.length === 0) return;
+    if (!secrets || documents.length === 0 || !branchId) return;
 
     setIsBusy(true);
 
     try {
-      const readyFiles = await getReadyFilesForImport(
-        documents,
-        translationStatuses
-      );
+      const readyFiles = await getReadyFilesForImport(translationStatuses);
 
       if (readyFiles.length === 0) {
         toast.push({
@@ -371,12 +378,14 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
     translationStatuses,
     downloadStatus,
     translationContext,
+    branchId,
   ]);
 
-  const getMissingTranslations = useCallback(
+  const getExistingTranslations = useCallback(
     async (
       documentIds: string[],
-      localeIds: string[]
+      localeIds: string[],
+      branchId: string
     ): Promise<Set<string>> => {
       const sourceLocale = pluginConfig.getSourceLocale();
 
@@ -384,6 +393,7 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
       _type == 'translation.metadata' &&
       translations[_key == $sourceLocale][0].value._ref in $documentIds
     ] {
+      _rev,
       'sourceDocId': translations[_key == $sourceLocale][0].value._ref,
       'existingTranslations': translations[_key in $localeIds]._key
     }`;
@@ -398,30 +408,20 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
       existingMetadata.forEach((metadata: any) => {
         metadata.existingTranslations?.forEach((localeId: string) => {
           if (localeId !== sourceLocale) {
-            existing.add(`${metadata.sourceDocId}:${localeId}`);
-          }
-        });
-      });
-
-      const missing = new Set<string>();
-      documentIds.forEach((docId) => {
-        localeIds.forEach((localeId) => {
-          if (localeId !== sourceLocale) {
-            const key = `${docId}:${localeId}`;
-            if (!existing.has(key)) {
-              missing.add(key);
-            }
+            existing.add(
+              `${branchId}:${metadata.sourceDocId}:${metadata._rev}:${localeId}`
+            );
           }
         });
       });
 
-      return missing;
+      return existing;
     },
     [client]
   );
 
   const handleImportMissing = useCallback(async () => {
-    if (!secrets || documents.length === 0) return;
+    if (!secrets || documents.length === 0 || !branchId) return;
 
     setIsBusy(true);
 
@@ -434,19 +434,15 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
         (doc) => doc._id?.replace('drafts.', '') || doc._id
       );
 
-      const missingTranslations = await getMissingTranslations(
+      const existingTranslations = await getExistingTranslations(
         documentIds,
-        availableLocaleIds
+        availableLocaleIds,
+        branchId
       );
 
-      console.log('missingTranslations', missingTranslations);
-      const readyFiles = await getReadyFilesForImport(
-        documents,
-        translationStatuses,
-        {
-          filterReadyFiles: (key) => missingTranslations.has(key),
-        }
-      );
+      const readyFiles = await getReadyFilesForImport(translationStatuses, {
+        filterReadyFiles: (key) => !existingTranslations.has(key),
+      });
 
       if (readyFiles.length === 0) {
         toast.push({
@@ -517,12 +513,24 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
     translationStatuses,
     downloadStatus,
     translationContext,
-    getMissingTranslations,
+    getExistingTranslations,
+    branchId,
   ]);
 
-  const handleRefreshAll = useCallback(async () => {
-    if (!secrets || documents.length === 0) return;
+  const handleGetBranchId = useCallback(
+    async (secrets: Secrets) => {
+      overrideConfig(secrets);
+      const defaultBranch = await gt.createBranch({
+        branchName: 'main',
+        defaultBranch: true,
+      });
+      setBranchId(defaultBranch.branch.id);
+    },
+    [secrets]
+  );
 
+  const handleRefreshAll = useCallback(async () => {
+    if (!secrets || documents.length === 0 || !branchId) return;
     setIsRefreshing(true);
 
     try {
@@ -530,13 +538,14 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
         .filter((locale) => locale.enabled !== false)
         .map((locale) => locale.localeId);
 
-      const fileQueryData = [];
+      const fileQueryData: FileProperties[] = [];
       for (const doc of documents) {
         for (const localeId of availableLocaleIds) {
           const documentId = doc._id?.replace('drafts.', '') || doc._id;
           fileQueryData.push({
             versionId: doc._rev,
             fileId: documentId,
+            branchId: branchId,
             locale: localeId,
           });
         }
@@ -554,18 +563,24 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
         for (const doc of documents) {
           for (const localeId of availableLocaleIds) {
             const documentId = doc._id?.replace('drafts.', '') || doc._id;
-            const key = `${documentId}:${localeId}`;
+            const versionId = doc._rev;
+            const key = `${branchId}:${documentId}:${versionId}:${localeId}`;
             newStatuses.set(key, { progress: 0, isReady: false });
           }
         }
 
         if (Array.isArray(readyTranslations)) {
           for (const translation of readyTranslations) {
-            const key = `${translation.fileId}:${translation.locale}`;
+            const key = `${branchId}:${translation.fileId}:${translation.versionId}:${translation.locale}`;
             newStatuses.set(key, {
               progress: 100,
               isReady: true,
-              translationId: translation.id,
+              fileData: {
+                versionId: translation.versionId,
+                fileId: translation.fileId,
+                branchId: translation.branchId,
+                locale: translation.locale,
+              },
             });
           }
         }
@@ -588,16 +603,16 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
     } finally {
       setIsRefreshing(false);
     }
-  }, [secrets, documents, locales]);
+  }, [secrets, documents, locales, branchId]);
 
   const handleImportDocument = useCallback(
-    async (documentId: string, localeId: string) => {
+    async (documentId: string, versionId: string, localeId: string) => {
       if (!secrets) return;
 
-      const key = `${documentId}:${localeId}`;
+      const key = `${branchId}:${documentId}:${versionId}:${localeId}`;
       const status = translationStatuses.get(key);
 
-      if (!status?.isReady || !status.translationId) {
+      if (!status?.isReady || !status.fileData) {
         toast.push({
           title: `Translation not ready for ${documentId} (${localeId})`,
           status: 'warning',
@@ -623,10 +638,10 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
         const downloadedFiles = await downloadTranslations(
           [
             {
-              documentId,
-              versionId: document._rev,
-              translationId: status.translationId,
-              locale: localeId,
+              fileId: status.fileData.fileId,
+              branchId: status.fileData.branchId,
+              versionId: status.fileData.versionId,
+              locale: status.fileData.locale,
             },
           ],
           secrets
@@ -682,7 +697,7 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
         });
       }
     },
-    [secrets, documents, translationContext, translationStatuses]
+    [secrets, documents, translationContext, translationStatuses, branchId]
   );
 
   const handlePatchDocumentReferences = useCallback(async () => {
@@ -789,7 +804,7 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
       setIsBusy(false);
       setImportProgress({ current: 0, total: 0, isImporting: false });
     }
-  }, [secrets, documents, locales, client]);
+  }, [secrets, documents, locales, client, branchId]);
 
   const handlePublishAllTranslations = useCallback(async () => {
     if (!secrets || documents.length === 0) return 0;
@@ -869,7 +884,7 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
     } finally {
       setIsBusy(false);
     }
-  }, [secrets, documents, client]);
+  }, [secrets, documents, client, branchId]);
 
   useEffect(() => {
     fetchDocuments();
@@ -912,12 +927,18 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
     setImportedTranslations(new Set(downloadStatus.downloaded));
   }, [downloadStatus.downloaded]);
 
+  if (secrets) {
+    handleGetBranchId(secrets);
+  }
   const contextValue: TranslationsContextType = {
     // State
     isBusy,
     documents,
     locales,
     autoRefresh,
+    autoImport,
+    autoPatchReferences,
+    autoPublish,
     loadingDocuments,
     importProgress,
     importedTranslations,
@@ -927,10 +948,14 @@ export const TranslationsProvider: React.FC<TranslationsProviderProps> = ({
     isRefreshing,
     loadingSecrets,
     secrets,
+    branchId,
 
     // Actions
     setLocales,
     setAutoRefresh,
+    setAutoImport,
+    setAutoPatchReferences,
+    setAutoPublish,
     handleTranslateAll,
     handleImportAll,
     handleImportMissing,

package/src/components/page/TranslationsTable.tsx

@@ -12,6 +12,7 @@ export const TranslationsTable: React.FC = () => {
     downloadStatus,
     importedTranslations,
     handleImportDocument,
+    branchId,
   } = useTranslations();
 
   if (loadingDocuments) {
@@ -46,20 +47,21 @@ export const TranslationsTable: React.FC = () => {
                     .map((locale) => {
                       const documentId =
                         document._id?.replace('drafts.', '') || document._id;
-                      const key = `${documentId}:${locale.localeId}`;
+                      const key = `${branchId}:${documentId}:${document._rev}:${locale.localeId}`;
                       const status = translationStatuses.get(key);
                       const isDownloaded = downloadStatus.downloaded.has(key);
                       const isImported = importedTranslations.has(key);
 
                       return (
                         <LanguageStatus
-                          key={`${document._id}-${locale.localeId}`}
+                          key={`${document._id}-${document._rev}-${locale.localeId}`}
                           title={locale.description || locale.localeId}
                           progress={status?.progress || 0}
                           isImported={isImported || isDownloaded}
                           importFile={async () => {
                             await handleImportDocument(
                               documentId,
+                              document._rev,
                               locale.localeId
                             );
                           }}

package/src/components/shared/SingleDocumentView.tsx

@@ -13,6 +13,7 @@ export const SingleDocumentView: React.FC = () => {
     downloadStatus,
     importedTranslations,
     handleImportDocument,
+    branchId,
   } = useTranslations();
 
   // Get the first (and only) document in single document mode
@@ -74,20 +75,21 @@ export const SingleDocumentView: React.FC = () => {
                   .map((locale) => {
                     const documentId =
                       document._id?.replace('drafts.', '') || document._id;
-                    const key = `${documentId}:${locale.localeId}`;
+                    const key = `${branchId}:${documentId}:${document._rev}:${locale.localeId}`;
                     const status = translationStatuses.get(key);
                     const isDownloaded = downloadStatus.downloaded.has(key);
                     const isImported = importedTranslations.has(key);
 
                     return (
                       <LanguageStatus
-                        key={`${document._id}-${locale.localeId}`}
+                        key={`${document._id}-${document._rev}-${locale.localeId}`}
                         title={locale.description || locale.localeId}
                         progress={status?.progress || 0}
                         isImported={isImported || isDownloaded}
                         importFile={async () => {
                           await handleImportDocument(
                             documentId,
+                            document._rev,
                             locale.localeId
                           );
                         }}

package/src/components/tab/TranslationView.tsx

@@ -28,6 +28,7 @@ export const TranslationView = () => {
     documents,
     locales,
     translationStatuses,
+    branchId,
     isBusy,
     handleTranslateAll,
     handleImportDocument,
@@ -37,13 +38,17 @@ export const TranslationView = () => {
     setLocales,
     handlePatchDocumentReferences,
     handlePublishAllTranslations,
+    autoRefresh,
+    setAutoRefresh,
+    autoImport,
+    setAutoImport,
+    autoPatchReferences,
+    setAutoPatchReferences,
+    autoPublish,
+    setAutoPublish,
   } = useTranslations();
 
-  const [autoImport, setAutoImport] = useState(false);
   const [isImporting, setIsImporting] = useState(false);
-  const [autoRefresh, setAutoRefresh] = useState(true);
-  const [autoPatchReferences, setAutoPatchReferences] = useState(true);
-  const [autoPublish, setAutoPublish] = useState(true);
   const [isPublishing, setIsPublishing] = useState(false);
 
   const toast = useToast();
@@ -94,7 +99,7 @@ export const TranslationView = () => {
 
       // Find translations ready to import
       const readyTranslations = availableLocales.filter((locale) => {
-        const key = `${documentId}:${locale.localeId}`;
+        const key = `${branchId}:${documentId}:${document._rev}:${locale.localeId}`;
         const status = translationStatuses.get(key);
         return status?.isReady && !importedTranslations.has(key);
       });
@@ -106,7 +111,7 @@ export const TranslationView = () => {
         // Import all ready translations
         await Promise.all(
           readyTranslations.map((locale) =>
-            handleImportDocument(documentId, locale.localeId)
+            handleImportDocument(documentId, document._rev, locale.localeId)
           )
         );
 
@@ -144,31 +149,12 @@ export const TranslationView = () => {
     handleImportTranslations({ autoOnly: true });
   }, [handleImportTranslations]);
 
-  // Auto refresh functionality
-  useEffect(() => {
-    if (!autoRefresh || !documentId || availableLocales.length === 0) return;
-
-    const interval = setInterval(async () => {
-      await handleRefreshAll();
-      await handleImportTranslations({ autoOnly: true });
-    }, 10000);
-
-    return () => clearInterval(interval);
-  }, [
-    autoRefresh,
-    documentId,
-    availableLocales.length,
-    handleRefreshAll,
-    handleImportTranslations,
-  ]);
-
+  // Enable auto features on mount
   useEffect(() => {
-    const initialRefresh = async () => {
-      await handleRefreshAll();
-      await handleImportTranslations({ autoOnly: true });
-    };
-    initialRefresh();
-  }, []);
+    setAutoRefresh(true);
+    setAutoPatchReferences(true);
+    setAutoPublish(true);
+  }, [setAutoRefresh, setAutoPatchReferences, setAutoPublish]);
 
   // Locale toggle functionality
   const toggleLocale = useCallback(
@@ -285,14 +271,14 @@ export const TranslationView = () => {
                 padding={2}
                 text='Refresh Status'
                 onClick={handleRefreshAll}
-                disabled={isRefreshing}
+                disabled={isRefreshing || isBusy}
               />
             </Flex>
           </Flex>
 
           <Box>
             {availableLocales.map((locale) => {
-              const key = `${documentId}:${locale.localeId}`;
+              const key = `${branchId}:${documentId}:${document._rev}:${locale.localeId}`;
               const status = translationStatuses.get(key);
               const progress = status?.progress || 0;
               const isImported = importedTranslations.has(key);
@@ -305,7 +291,11 @@ export const TranslationView = () => {
                   isImported={isImported}
                   importFile={async () => {
                     if (!isImported && status?.isReady) {
-                      await handleImportDocument(documentId, locale.localeId);
+                      await handleImportDocument(
+                        documentId,
+                        document._rev,
+                        locale.localeId
+                      );
                     }
                   }}
                 />
@@ -326,7 +316,7 @@ export const TranslationView = () => {
                   disabled={
                     isImporting ||
                     availableLocales.every((locale) => {
-                      const key = `${documentId}:${locale.localeId}`;
+                      const key = `${branchId}:${documentId}:${document._rev}:${locale.localeId}`;
                       const status = translationStatuses.get(key);
                       return !status?.isReady || importedTranslations.has(key);
                     })
@@ -346,14 +336,14 @@ export const TranslationView = () => {
                 Imported{' '}
                 {
                   availableLocales.filter((locale) => {
-                    const key = `${documentId}:${locale.localeId}`;
+                    const key = `${branchId}:${documentId}:${document._rev}:${locale.localeId}`;
                     return importedTranslations.has(key);
                   }).length
                 }
                 /
                 {
                   availableLocales.filter((locale) => {
-                    const key = `${documentId}:${locale.localeId}`;
+                    const key = `${branchId}:${documentId}:${document._rev}:${locale.localeId}`;
                     const status = translationStatuses.get(key);
                     return status?.isReady;
                   }).length

package/src/translation/checkTranslationStatus.ts

@@ -1,8 +1,9 @@
 import type { Secrets } from '../types';
 import { gt, overrideConfig } from '../adapter/core';
+import { FileProperties } from '../adapter/types';
 
 export async function checkTranslationStatus(
-  fileQueryData: { versionId: string; fileId: string; locale: string }[],
+  fileQueryData: FileProperties[],
   downloadStatus: {
     downloaded: Set<string>;
     failed: Set<string>;
@@ -25,13 +26,15 @@ export async function checkTranslationStatus(
       return true;
     }
     // Check for translations
-    const responseData = await gt.checkFileTranslations(currentQueryData);
+    const responseData = await gt.queryFileData({
+      translatedFiles: currentQueryData,
+    });
 
-    const translations = responseData.translations || [];
+    const translations = responseData.translatedFiles || [];
 
     // Filter for ready translations
     const readyTranslations = translations.filter(
-      (translation) => translation.isReady && translation.fileId
+      (translation) => translation.completedAt
     );
 
     return readyTranslations;