gt-sanity 0.0.5 → 0.0.6

package/src/configuration/baseDocumentLevelConfig/documentLevelPatch.ts

@@ -1,12 +1,13 @@
+// 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 'sanity-naive-html-serializer';
 
-import { findLatestDraft, findDocumentAtRevision } from '../utils';
-import {
-  createI18nDocAndPatchMetadata,
-  getOrCreateTranslationMetadata,
-  patchI18nDoc,
-} from './helpers';
+import { findLatestDraft } from '../utils/findLatestDraft';
+import { findDocumentAtRevision } from '../utils/findDocumentAtRevision';
+import { createI18nDocAndPatchMetadata } from './helpers/createI18nDocAndPatchMetadata';
+import { getOrCreateTranslationMetadata } from './helpers/getOrCreateTranslationMetadata';
+import { patchI18nDoc } from './helpers/patchI18nDoc';
 import type { GTFile } from '../../types';
 import { gtConfig } from '../../adapter/core';
 
@@ -16,7 +17,8 @@ export const documentLevelPatch = async (
   localeId: string,
   client: SanityClient,
   languageField: string = 'language',
-  mergeWithTargetLocale: boolean = false
+  mergeWithTargetLocale: boolean = false,
+  publish: boolean = false
 ): Promise<void> => {
   const baseLanguage = gtConfig.getSourceLocale();
   //this is the document we use to merge with the translated fields
@@ -92,17 +94,28 @@ export const documentLevelPatch = async (
   ) as SanityDocumentLike;
 
   if (i18nDoc) {
-    patchI18nDoc(docInfo.documentId, merged, translatedFields, client);
+    await patchI18nDoc(
+      docInfo.documentId,
+      i18nDoc._id,
+      baseDoc,
+      merged,
+      translatedFields,
+      client,
+      publish
+    );
   }
   //otherwise, create a new document
   //and add the document reference to the metadata document
   else {
-    createI18nDocAndPatchMetadata(
+    await createI18nDocAndPatchMetadata(
+      baseDoc,
       merged,
       localeId,
       client,
       translationMetadata,
-      languageField
+      docInfo.documentId,
+      languageField,
+      publish
     );
   }
 };

package/src/configuration/baseDocumentLevelConfig/helpers/createI18nDocAndPatchMetadata.ts

@@ -1,12 +1,19 @@
+// adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
+
 import { SanityClient, SanityDocumentLike } from 'sanity';
+import { gtConfig } from '../../../adapter/core';
+import { applyDocuments } from '../../../utils/applyDocuments';
 
-export const createI18nDocAndPatchMetadata = (
+export async function createI18nDocAndPatchMetadata(
+  sourceDocument: SanityDocumentLike,
   translatedDoc: SanityDocumentLike,
   localeId: string,
   client: SanityClient,
   translationMetadata: SanityDocumentLike,
-  languageField: string = 'language'
-): void => {
+  sourceDocumentId: string,
+  languageField: string = 'language',
+  publish: boolean = false
+): Promise<void> {
   translatedDoc[languageField] = localeId;
   const translations = translationMetadata.translations as Record<
     string,
@@ -22,26 +29,72 @@ export const createI18nDocAndPatchMetadata = (
 
   //remove system fields
   const { _updatedAt, _createdAt, ...rest } = translatedDoc;
-  client.create({ ...rest, _id: 'drafts.' }).then((doc) => {
-    const _ref = doc._id.replace('drafts.', '');
-    client
-      .transaction()
-      .patch(translationMetadata._id, (p) =>
-        p.insert(operation, location, [
-          {
-            _key: localeId,
-            _type: 'internationalizedArrayReferenceValue',
-            value: {
-              _type: 'reference',
-              _ref,
-              _weak: true,
-              _strengthenOnPublish: {
-                type: doc._type,
-              },
+
+  const appliedDocument = applyDocuments(
+    sourceDocumentId,
+    sourceDocument,
+    rest,
+    gtConfig.getIgnoreFields()
+  );
+
+  // Check if this is a singleton document and apply singleton mapping
+  const singletons = gtConfig.getSingletons();
+  const isSingleton = singletons.includes(sourceDocumentId);
+
+  let createDocumentPromise;
+  if (isSingleton) {
+    const singletonMapping = gtConfig.getSingletonMapping();
+    const translatedDocId = singletonMapping(sourceDocumentId, localeId);
+    createDocumentPromise = client.create({
+      ...appliedDocument,
+      _type: rest._type,
+      _id: `drafts.${translatedDocId}`,
+    });
+  } else {
+    createDocumentPromise = client.create({
+      ...appliedDocument,
+      _type: rest._type,
+      _id: 'drafts.',
+    });
+  }
+
+  const doc = await createDocumentPromise;
+  const _ref = doc._id.replace('drafts.', '');
+  const result = await client
+    .transaction()
+    .patch(translationMetadata._id, (p) =>
+      p.insert(operation, location, [
+        {
+          _key: localeId,
+          _type: 'internationalizedArrayReferenceValue',
+          value: {
+            _type: 'reference',
+            _ref,
+            _weak: true,
+            _strengthenOnPublish: {
+              type: doc._type,
             },
           },
-        ])
-      )
-      .commit();
-  });
-};
+        },
+      ])
+    )
+    .commit();
+
+  if (publish) {
+    try {
+      // only publish if the document is a draft
+      if (doc._id.startsWith('drafts.')) {
+        await client.action(
+          {
+            actionType: 'sanity.action.document.publish',
+            draftId: doc._id,
+            publishedId: doc._id.replace('drafts.', ''),
+          },
+          {}
+        );
+      }
+    } catch (error) {
+      console.error('Error publishing document', error);
+    }
+  }
+}

package/src/configuration/baseDocumentLevelConfig/helpers/createTranslationMetadata.ts

@@ -1,3 +1,5 @@
+// adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
+
 import {
   KeyedObject,
   Reference,

package/src/configuration/baseDocumentLevelConfig/helpers/getOrCreateTranslationMetadata.ts

@@ -1,3 +1,5 @@
+// adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
+
 import {
   KeyedObject,
   Reference,

package/src/configuration/baseDocumentLevelConfig/helpers/getTranslationMetadata.ts

@@ -1,3 +1,5 @@
+// adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
+
 import { SanityClient, SanityDocumentLike } from 'sanity';
 
 export const getTranslationMetadata = (

package/src/configuration/baseDocumentLevelConfig/helpers/patchI18nDoc.ts

@@ -1,25 +1,68 @@
+// adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
+
 import { SanityClient, SanityDocumentLike } from 'sanity';
+import { applyDocuments } from '../../../utils/applyDocuments';
+import { gtConfig } from '../../../adapter/core';
+
+const SYSTEM_FIELDS = ['_id', '_rev', '_updatedAt', 'language'];
+
+const isSystemField = (field: string) => SYSTEM_FIELDS.includes(field);
 
-export const patchI18nDoc = (
+export async function patchI18nDoc(
+  sourceDocumentId: string,
   i18nDocId: string,
+  sourceDocument: SanityDocumentLike,
   mergedDocument: SanityDocumentLike,
   translatedFields: Record<string, any>,
-  client: SanityClient
-): void => {
+  client: SanityClient,
+  publish: boolean = false
+): Promise<void> {
   const cleanedMerge: Record<string, any> = {};
   Object.entries(mergedDocument).forEach(([key, value]) => {
     if (
       //only patch those fields that had translated strings
       key in translatedFields &&
       //don't overwrite any existing system values on the i18n doc
-      !['_id', '_rev', '_updatedAt', 'language'].includes(key)
+      !isSystemField(key)
     ) {
       cleanedMerge[key] = value;
     }
   });
+  const cleanedSourceDocument: Record<string, any> = {};
+  Object.entries(sourceDocument).forEach(([key, value]) => {
+    if (
+      // extract only the fields that are not system fields
+      !isSystemField(key)
+    ) {
+      cleanedSourceDocument[key] = value;
+    }
+  });
 
-  client
-    .transaction()
-    .patch(i18nDocId, (p) => p.set(cleanedMerge))
+  const appliedDocument = applyDocuments(
+    sourceDocumentId,
+    cleanedSourceDocument,
+    cleanedMerge,
+    gtConfig.getIgnoreFields()
+  );
+  const newDocument = await client
+    .patch(i18nDocId, { set: appliedDocument })
     .commit();
-};
+
+  if (publish) {
+    try {
+      // only publish if the document is a draft
+      if (newDocument._id.startsWith('drafts.')) {
+        await client.action(
+          {
+            actionType: 'sanity.action.document.publish',
+            draftId: newDocument._id,
+            publishedId: newDocument._id.replace('drafts.', ''),
+          },
+          {}
+        );
+      }
+    } catch (error) {
+      console.error('Error publishing document', error);
+    }
+  }
+}

package/src/configuration/baseDocumentLevelConfig/index.ts

@@ -1,12 +1,13 @@
+// adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
+
 import {
   ExportForTranslation,
   GTSerializedDocument,
   ImportTranslation,
 } from '../../types';
 import { SanityDocument } from 'sanity';
-import { findLatestDraft } from '../utils';
+import { findLatestDraft } from '../utils/findLatestDraft';
 import { documentLevelPatch } from './documentLevelPatch';
-import { legacyDocumentLevelPatch } from './legacyDocumentLevelPatch';
 import {
   BaseDocumentDeserializer,
   BaseDocumentSerializer,
@@ -65,6 +66,7 @@ export const baseDocumentLevelConfig = {
       serializationOptions = {},
       languageField = 'language',
       mergeWithTargetLocale = false,
+      publish = false,
     ] = params;
     const { client } = context;
     const deserializers = {
@@ -88,42 +90,9 @@ export const baseDocumentLevelConfig = {
       localeId,
       client,
       languageField,
-      mergeWithTargetLocale
+      mergeWithTargetLocale,
+      publish
     );
   },
   secretsNamespace: 'translationService',
 };
-
-export const legacyDocumentLevelConfig = {
-  ...baseDocumentLevelConfig,
-  importTranslation: (
-    ...params: Parameters<ImportTranslation>
-  ): Promise<void> => {
-    const [docInfo, localeId, document, context, serializationOptions = {}] =
-      params;
-    const { client } = context;
-    const deserializers = {
-      types: {
-        ...(serializationOptions.additionalDeserializers ?? {}),
-      },
-    };
-    const blockDeserializers = [
-      ...(serializationOptions.additionalBlockDeserializers ?? []),
-      ...customBlockDeserializers,
-    ];
-
-    const deserialized = BaseDocumentDeserializer.deserializeDocument(
-      document,
-      deserializers,
-      blockDeserializers
-    ) as SanityDocument;
-    return legacyDocumentLevelPatch(
-      docInfo, // versionId is not used here, since we just use the _rev id in the deserialized HTML itself
-      deserialized,
-      localeId,
-      client
-    );
-  },
-};
-
-export { documentLevelPatch, legacyDocumentLevelPatch };

package/src/configuration/baseFieldLevelConfig.ts

@@ -1,3 +1,5 @@
+// adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
+
 import { SanityClient, SanityDocument } from 'sanity';
 import {
   BaseDocumentSerializer,
@@ -14,7 +16,8 @@ import type {
   GTSerializedDocument,
   ImportTranslation,
 } from '../types';
-import { findLatestDraft, findDocumentAtRevision } from './utils';
+import { findLatestDraft } from './utils/findLatestDraft';
+import { findDocumentAtRevision } from './utils/findDocumentAtRevision';
 import { gtConfig } from '../adapter/core';
 
 export const fieldLevelPatch = async (

package/src/configuration/utils/checkSerializationVersion.ts

@@ -1,3 +1,5 @@
+// adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
+
 export const checkSerializationVersion = (HTMLdoc: string): string | null => {
   const parser = new DOMParser();
   const node = parser.parseFromString(HTMLdoc, 'text/html');

package/src/configuration/utils/findDocumentAtRevision.ts

@@ -1,3 +1,5 @@
+// adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
+
 import { SanityClient, SanityDocument } from 'sanity';
 
 //revision fetch

package/src/configuration/utils/findLatestDraft.ts

@@ -1,3 +1,5 @@
+// adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
+
 import { SanityClient, SanityDocument } from 'sanity';
 
 //use perspectives in the future

package/src/hooks/useClient.ts

@@ -1,5 +1,7 @@
+// adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
+
 import { SanityClient, useClient as useSanityClient } from 'sanity';
 
 export const useClient = (): SanityClient => {
-  return useSanityClient({ apiVersion: '2022-12-07' });
+  return useSanityClient({ apiVersion: '2025-09-15' });
 };

package/src/hooks/useSecrets.ts

@@ -1,3 +1,5 @@
+// adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
+
 import { useState, useEffect } from 'react';
 import { SanityDocumentLike } from 'sanity';
 import { useClient } from './useClient';

package/src/index.ts

@@ -8,15 +8,11 @@ import {
   TranslationsTabConfigOptions,
   GTFile,
 } from './types';
-import {
-  baseDocumentLevelConfig,
-  legacyDocumentLevelConfig as baseLegacyDocumentLevelConfig,
-  legacyDocumentLevelPatch,
-  baseFieldLevelConfig,
-  findLatestDraft,
-  documentLevelPatch,
-  fieldLevelPatch,
-} from './configuration';
+import { baseDocumentLevelConfig } from './configuration/baseDocumentLevelConfig';
+import { baseFieldLevelConfig } from './configuration/baseFieldLevelConfig';
+import { findLatestDraft } from './configuration/utils/findLatestDraft';
+import { documentLevelPatch } from './configuration/baseDocumentLevelConfig/documentLevelPatch';
+import { fieldLevelPatch } from './configuration/baseFieldLevelConfig';
 import {
   BaseDocumentSerializer,
   BaseDocumentDeserializer,
@@ -39,7 +35,6 @@ export {
   TranslationsTab,
   //helpers for end developers who may need to customize serialization
   findLatestDraft,
-  legacyDocumentLevelPatch,
   documentLevelPatch,
   fieldLevelPatch,
   BaseDocumentSerializer,
@@ -51,9 +46,13 @@ export {
 
 import { GTAdapter } from './adapter';
 import { definePlugin } from 'sanity';
+import { route } from 'sanity/router';
 import { gt, gtConfig } from './adapter/core';
 import { GTSerializedDocument } from './types';
 import { libraryDefaultLocale } from 'generaltranslation/internal';
+import type { IgnoreFields, TranslateDocumentFilter } from './adapter/types';
+import TranslationsTool from './components/page/TranslationsTool';
+import { SECRETS_NAMESPACE } from './utils/shared';
 
 interface ConfigOptions {
   adapter: Adapter;
@@ -76,12 +75,6 @@ export const defaultDocumentLevelConfig: ConfigOptions = {
   secretsNamespace: 'generaltranslation',
 };
 
-export const legacyDocumentLevelConfig: ConfigOptions = {
-  ...baseLegacyDocumentLevelConfig,
-  adapter: GTAdapter,
-  secretsNamespace: 'generaltranslation',
-};
-
 export const defaultFieldLevelConfig: ConfigOptions = {
   ...baseFieldLevelConfig,
   adapter: GTAdapter,
@@ -90,12 +83,27 @@ export const defaultFieldLevelConfig: ConfigOptions = {
 
 export { GTAdapter };
 
+export type GTPluginConfig = Omit<
+  Parameters<typeof gt.setConfig>[0],
+  'locales'
+> & {
+  locales: string[];
+  singletons?: string[];
+  // Optional mapping function to map source document ids to translated singleton document ids
+  // By default, the translated singleton document is is `${sourceDocumentId}-${locale}`
+  singletonMapping?: (sourceDocumentId: string, locale: string) => string;
+  ignoreFields?: IgnoreFields[];
+  languageField?: string;
+  translateDocuments?: TranslateDocumentFilter[];
+  secretsNamespace?: string;
+};
+
 /**
  * Usage in `sanity.config.ts` (or .js)
  *
  * ```ts
  * import {defineConfig} from 'sanity'
- * import {gtPlugin} from '@generaltranslation/sanity'
+ * import {gtPlugin} from 'gt-sanity'
  *
  * export default defineConfig({
  *   // ...
@@ -103,18 +111,48 @@ export { GTAdapter };
  * })
  * ```
  */
-export const gtPlugin = definePlugin<
-  Omit<Parameters<typeof gt.setConfig>[0], 'locales'> & { locales: string[] }
->(({ sourceLocale, locales, customMapping, apiKey, projectId }) => {
-  gtConfig.setLocales(locales);
-  gtConfig.setSourceLocale(sourceLocale || libraryDefaultLocale);
-  gt.setConfig({
-    sourceLocale: sourceLocale,
-    customMapping: customMapping,
-    apiKey: apiKey,
-    projectId: projectId,
-  });
-  return {
-    name: '@generaltranslation/sanity',
-  };
-});
+export const gtPlugin = definePlugin<GTPluginConfig>(
+  ({
+    languageField = 'language',
+    sourceLocale = libraryDefaultLocale,
+    locales,
+    customMapping,
+    apiKey,
+    projectId,
+    singletons,
+    singletonMapping,
+    ignoreFields,
+    translateDocuments,
+    secretsNamespace = SECRETS_NAMESPACE,
+  }) => {
+    // Validate the translateDocuments
+    translateDocuments = translateDocuments?.filter((filter) => {
+      if (filter.documentId || filter.type) {
+        return true;
+      }
+      return false;
+    });
+
+    gtConfig.init(
+      secretsNamespace,
+      languageField,
+      sourceLocale,
+      locales,
+      singletons || [],
+      // singletons is a string array of singleton document ids
+      singletonMapping ||
+        ((sourceDocumentId, locale) => `${sourceDocumentId}-${locale}`),
+      ignoreFields || [],
+      translateDocuments || []
+    );
+    gt.setConfig({
+      sourceLocale: sourceLocale,
+      customMapping: customMapping,
+      apiKey: apiKey,
+      projectId: projectId,
+    });
+    return {
+      name: 'gt-sanity',
+    };
+  }
+);

package/src/translation/checkTranslationStatus.ts

@@ -0,0 +1,42 @@
+import type { Secrets } from '../types';
+import { gt, overrideConfig } from '../adapter/core';
+
+export async function checkTranslationStatus(
+  fileQueryData: { versionId: string; fileId: string; locale: string }[],
+  downloadStatus: {
+    downloaded: Set<string>;
+    failed: Set<string>;
+    skipped: Set<string>;
+  },
+  secrets: Secrets
+) {
+  overrideConfig(secrets);
+  try {
+    // Only query for files that haven't been downloaded yet
+    const currentQueryData = fileQueryData.filter(
+      (item) =>
+        !downloadStatus.downloaded.has(`${item.fileId}:${item.locale}`) &&
+        !downloadStatus.failed.has(`${item.fileId}:${item.locale}`) &&
+        !downloadStatus.skipped.has(`${item.fileId}:${item.locale}`)
+    );
+
+    // If all files have been downloaded, we're done
+    if (currentQueryData.length === 0) {
+      return true;
+    }
+    // Check for translations
+    const responseData = await gt.checkFileTranslations(currentQueryData);
+
+    const translations = responseData.translations || [];
+
+    // Filter for ready translations
+    const readyTranslations = translations.filter(
+      (translation) => translation.isReady && translation.fileId
+    );
+
+    return readyTranslations;
+  } catch (error) {
+    console.error('Error checking translation status', error);
+    return [];
+  }
+}

package/src/translation/createJobs.ts

@@ -0,0 +1,16 @@
+import { libraryDefaultLocale } from 'generaltranslation/internal';
+import { gt, overrideConfig } from '../adapter/core';
+import type { Secrets } from '../types';
+
+export async function createJobs(
+  uploadResult: Awaited<ReturnType<typeof gt.uploadSourceFiles>>,
+  localeIds: string[],
+  secrets: Secrets
+): Promise<Awaited<ReturnType<typeof gt.enqueueFiles>>> {
+  overrideConfig(secrets);
+  const enqueueResult = await gt.enqueueFiles(uploadResult.uploadedFiles, {
+    sourceLocale: gt.sourceLocale || libraryDefaultLocale,
+    targetLocales: localeIds,
+  });
+  return enqueueResult;
+}

package/src/translation/downloadTranslations.ts

@@ -0,0 +1,68 @@
+import { gt, overrideConfig } from '../adapter/core';
+import type { Secrets } from '../types';
+
+export type BatchedFiles = Array<{
+  documentId: string;
+  versionId: string;
+  translationId: string;
+  locale: string;
+}>;
+
+export type DownloadedFile = {
+  docData: {
+    documentId: string;
+    versionId: string;
+    translationId: string;
+    locale: string;
+  };
+  data: string;
+};
+/**
+ * Downloads multiple translation files in a single batch request
+ * @param files - Array of files to download with their output paths
+ * @param maxRetries - Maximum number of retry attempts
+ * @param retryDelay - Delay between retries in milliseconds
+ * @returns Object containing successful and failed file IDs
+ */
+export async function downloadTranslations(
+  files: BatchedFiles,
+  secrets: Secrets,
+  maxRetries = 3,
+  retryDelay = 1000
+): Promise<DownloadedFile[]> {
+  overrideConfig(secrets);
+  let retries = 0;
+  const fileIds = files.map((file) => file.translationId);
+
+  const map = new Map(files.map((file) => [file.translationId, file]));
+  const result = [] as DownloadedFile[];
+
+  while (retries <= maxRetries) {
+    try {
+      // Download the files
+      const responseData = await gt.downloadFileBatch(fileIds);
+      const downloadedFiles = responseData.files || [];
+
+      // Process each file in the response
+      for (const file of downloadedFiles) {
+        const documentData = map.get(file.id);
+        if (!documentData) {
+          continue;
+        }
+
+        result.push({
+          docData: documentData,
+          data: file.data,
+        });
+      }
+
+      return result;
+    } catch (error) {
+      // Increment retry counter and wait before next attempt
+      retries++;
+      await new Promise((resolve) => setTimeout(resolve, retryDelay));
+    }
+  }
+
+  return result;
+}