gt-sanity 0.0.6 → 1.0.0

package/src/translation/importDocument.ts

@@ -1,4 +1,4 @@
-import { gtConfig } from '../adapter/core';
+import { pluginConfig } from '../adapter/core';
 import { documentLevelPatch } from '../configuration/baseDocumentLevelConfig/documentLevelPatch';
 import type { GTFile, TranslationFunctionContext } from '../types';
 import { deserializeDocument } from '../utils/serialize';
@@ -8,7 +8,7 @@ export async function importDocument(
   localeId: string,
   document: string,
   context: TranslationFunctionContext,
-  publish: boolean = false
+  mergeWithTargetLocale: boolean = false
 ) {
   const { client } = context;
   const deserialized = deserializeDocument(document);
@@ -17,8 +17,7 @@ export async function importDocument(
     deserialized,
     localeId,
     client,
-    gtConfig.getLanguageField(),
-    false,
-    publish
+    pluginConfig.getLanguageField(),
+    mergeWithTargetLocale
   );
 }

package/src/translation/uploadFiles.ts

@@ -1,7 +1,7 @@
 import type { GTFile, Secrets } from '../types';
 import { gt, overrideConfig } from '../adapter/core';
 import { libraryDefaultLocale } from 'generaltranslation/internal';
-import type { SerializedDocument } from 'sanity-naive-html-serializer';
+import type { SerializedDocument } from '../serialization';
 
 // note: this function is used to create a new translation task
 // uploads files & calls the getTranslationTask function

package/src/types.ts

@@ -1,9 +1,9 @@
 // adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
 
 import { SanityClient, Schema, TypedObject } from 'sanity';
-import { SerializedDocument } from 'sanity-naive-html-serializer';
+import type { SerializedDocument } from './serialization';
 import { PortableTextTypeComponent } from '@portabletext/to-html';
-import { DeserializerRule } from '@sanity/block-tools';
+import type { DeserializerRule } from '@portabletext/block-tools';
 
 export type TranslationTaskLocaleStatus = {
   localeId: string;
@@ -74,15 +74,7 @@ export type GTSerializedDocument = Omit<SerializedDocument, 'name'> & GTFile;
 
 export type ExportForTranslation = (
   documentInfo: GTFile,
-  context: TranslationFunctionContext,
-  serializationOptions?: {
-    additionalStopTypes?: string[];
-    additionalSerializers?: Record<
-      string,
-      PortableTextTypeComponent | undefined
-    >;
-  },
-  languageField?: string
+  context: TranslationFunctionContext
 ) => Promise<GTSerializedDocument>;
 
 export type ImportTranslation = (
@@ -90,14 +82,6 @@ export type ImportTranslation = (
   localeId: string,
   document: string,
   context: TranslationFunctionContext,
-  serializationOptions?: {
-    additionalDeserializers?: Record<
-      string,
-      (value: HTMLElement) => TypedObject
-    >;
-    additionalBlockDeserializers?: DeserializerRule[];
-  },
-  languageField?: string,
   mergeWithTargetLocale?: boolean,
   publish?: boolean
 ) => Promise<void>;

package/src/utils/batchProcessor.ts

@@ -0,0 +1,111 @@
+import { GTFile, TranslationFunctionContext } from '../types';
+import { importDocument } from '../translation/importDocument';
+
+export interface BatchProcessorOptions {
+  batchSize?: number;
+  onProgress?: (current: number, total: number) => void;
+  onItemSuccess?: (item: any, result: any) => void;
+  onItemFailure?: (item: any, error: any) => void;
+}
+
+export interface ImportBatchItem {
+  docInfo: GTFile;
+  locale: string;
+  data: any;
+  translationContext: TranslationFunctionContext;
+  key: string;
+}
+
+export async function processBatch<T>(
+  items: T[],
+  processor: (item: T) => Promise<any>,
+  options: BatchProcessorOptions = {}
+): Promise<{
+  successCount: number;
+  failureCount: number;
+  successfulItems: any[];
+  failedItems: { item: T; error: any }[];
+}> {
+  const { batchSize = 20, onProgress, onItemSuccess, onItemFailure } = options;
+
+  let successCount = 0;
+  let failureCount = 0;
+  const successfulItems: any[] = [];
+  const failedItems: { item: T; error: any }[] = [];
+
+  for (let i = 0; i < items.length; i += batchSize) {
+    const batch = items.slice(i, i + batchSize);
+
+    const batchPromises = batch.map(async (item) => {
+      try {
+        const result = await processor(item);
+        onItemSuccess?.(item, result);
+        return { success: true, item, result };
+      } catch (error) {
+        onItemFailure?.(item, error);
+        return { success: false, item, error };
+      }
+    });
+
+    const batchResults = await Promise.all(batchPromises);
+
+    batchResults.forEach((result) => {
+      if (result.success) {
+        successCount++;
+        successfulItems.push(result.result);
+      } else {
+        failureCount++;
+        failedItems.push({ item: result.item, error: result.error });
+      }
+    });
+
+    onProgress?.(i + batch.length, items.length);
+  }
+
+  return { successCount, failureCount, successfulItems, failedItems };
+}
+
+export async function processImportBatch(
+  items: ImportBatchItem[],
+  options: BatchProcessorOptions = {}
+): Promise<{
+  successCount: number;
+  failureCount: number;
+  successfulImports: string[];
+  failedItems: { item: ImportBatchItem; error: any }[];
+}> {
+  const successfulImports: string[] = [];
+
+  const result = await processBatch(
+    items,
+    async (item: ImportBatchItem) => {
+      await importDocument(
+        item.docInfo,
+        item.locale,
+        item.data,
+        item.translationContext,
+        false
+      );
+      return item.key;
+    },
+    {
+      ...options,
+      onItemSuccess: (item: ImportBatchItem, key: string) => {
+        successfulImports.push(key);
+        options.onItemSuccess?.(item, key);
+      },
+      onItemFailure: (item: ImportBatchItem, error: any) => {
+        console.error(
+          `Failed to import ${item.docInfo.documentId} (${item.locale}):`,
+          error
+        );
+        options.onItemFailure?.(item, error);
+      },
+    }
+  );
+
+  return {
+    ...result,
+    successfulImports,
+  };
+}

package/src/utils/importUtils.ts

@@ -0,0 +1,95 @@
+import { SanityDocument } from 'sanity';
+import { GTFile, Secrets, TranslationFunctionContext } from '../types';
+import {
+  downloadTranslations,
+  BatchedFiles,
+} from '../translation/downloadTranslations';
+import { processImportBatch, ImportBatchItem } from './batchProcessor';
+
+export interface TranslationStatus {
+  progress: number;
+  isReady: boolean;
+  translationId?: string;
+}
+
+export interface ImportResult {
+  successCount: number;
+  failureCount: number;
+  successfulImports: string[];
+}
+
+export interface ImportOptions {
+  filterReadyFiles?: (key: string, status: TranslationStatus) => boolean;
+  onProgress?: (current: number, total: number) => void;
+  onImportSuccess?: (key: string) => void;
+}
+
+export async function getReadyFilesForImport(
+  documents: SanityDocument[],
+  translationStatuses: Map<string, TranslationStatus>,
+  options: ImportOptions = {}
+): Promise<BatchedFiles> {
+  const { filterReadyFiles = () => true } = options;
+  const readyFiles: BatchedFiles = [];
+
+  for (const [key, status] of translationStatuses.entries()) {
+    if (
+      status.isReady &&
+      status.translationId &&
+      filterReadyFiles(key, status)
+    ) {
+      const [documentId, locale] = key.split(':');
+      const document = documents.find(
+        (doc) => (doc._id?.replace('drafts.', '') || doc._id) === documentId
+      );
+
+      if (document) {
+        readyFiles.push({
+          documentId,
+          versionId: document._rev,
+          translationId: status.translationId,
+          locale,
+        });
+      }
+    }
+  }
+
+  return readyFiles;
+}
+
+export async function importTranslations(
+  readyFiles: BatchedFiles,
+  secrets: Secrets,
+  translationContext: TranslationFunctionContext,
+  options: ImportOptions = {}
+): Promise<ImportResult> {
+  if (readyFiles.length === 0) {
+    return { successCount: 0, failureCount: 0, successfulImports: [] };
+  }
+
+  const downloadedFiles = await downloadTranslations(readyFiles, secrets);
+
+  const importItems: ImportBatchItem[] = downloadedFiles.map((file) => ({
+    docInfo: {
+      documentId: file.docData.documentId,
+      versionId: file.docData.versionId,
+    },
+    locale: file.docData.locale,
+    data: file.data,
+    translationContext,
+    key: `${file.docData.documentId}:${file.docData.locale}`,
+  }));
+
+  const result = await processImportBatch(importItems, {
+    onProgress: options.onProgress,
+    onItemSuccess: (item, key) => {
+      options.onImportSuccess?.(key);
+    },
+  });
+
+  return {
+    successCount: result.successCount,
+    failureCount: result.failureCount,
+    successfulImports: result.successfulImports,
+  };
+}

package/src/utils/serialize.ts

@@ -5,13 +5,24 @@ import {
   defaultStopTypes,
   customSerializers,
   customBlockDeserializers,
-} from 'sanity-naive-html-serializer';
+} from '../serialization/';
+import { PortableTextHtmlComponents } from '@portabletext/to-html';
+import { pluginConfig } from '../adapter/core';
+import { merge } from 'lodash';
 
 export function deserializeDocument(document: string) {
+  const deserializers = merge(
+    { types: {} },
+    pluginConfig.getAdditionalDeserializers()
+  ) satisfies Partial<PortableTextHtmlComponents>;
+  const blockDeserializers = [
+    ...customBlockDeserializers,
+    ...pluginConfig.getAdditionalBlockDeserializers(),
+  ];
   const deserialized = BaseDocumentDeserializer.deserializeDocument(
     document,
-    { types: {} },
-    customBlockDeserializers
+    deserializers,
+    blockDeserializers
   ) as SanityDocument;
   return deserialized;
 }
@@ -21,12 +32,21 @@ export function serializeDocument(
   schema: Schema,
   baseLanguage: string
 ) {
+  const stopTypes = [
+    ...defaultStopTypes,
+    ...pluginConfig.getAdditionalStopTypes(),
+  ];
+  const serializers = merge(
+    customSerializers,
+    pluginConfig.getAdditionalSerializers()
+  ) satisfies Partial<PortableTextHtmlComponents>;
+
   const serialized = BaseDocumentSerializer(schema).serializeDocument(
     document,
     'document',
     baseLanguage,
-    defaultStopTypes,
-    customSerializers
+    stopTypes,
+    serializers
   );
   return serialized;
 }

package/src/utils/shared.ts

@@ -1 +1 @@
-export const SECRETS_NAMESPACE = 'generaltranslation';
+export const SECRETS_NAMESPACE = 'generaltranslation.secrets';

package/src/adapter/index.ts

@@ -1,13 +0,0 @@
-import type { Adapter } from '../types';
-
-import { getLocales } from './getLocales';
-import { getTranslationTask } from './getTranslationTask';
-import { getTranslation } from './getTranslation';
-import { createTask } from './createTask';
-
-export const GTAdapter: Adapter = {
-  getLocales,
-  getTranslationTask,
-  createTask,
-  getTranslation,
-};

package/src/components/NewTask.tsx

@@ -1,251 +0,0 @@
-// adapted from https://github.com/sanity-io/sanity-translations-tab. See LICENSE.md for more details.
-
-import React, {
-  useState,
-  useContext,
-  ChangeEvent,
-  useCallback,
-  useEffect,
-} from 'react';
-import styled from 'styled-components';
-import {
-  Button,
-  Box,
-  Flex,
-  Grid,
-  Select,
-  Stack,
-  Switch,
-  Text,
-  useToast,
-} from '@sanity/ui';
-
-import { TranslationContext } from './TranslationContext';
-import { TranslationLocale } from '../types';
-
-type Props = {
-  locales: TranslationLocale[];
-  refreshTask: () => Promise<void>;
-};
-
-type LocaleCheckboxProps = {
-  locale: TranslationLocale;
-  toggle: (locale: string, checked: boolean) => void;
-  checked: boolean;
-};
-
-const WrapText = styled(Box)`
-  white-space: normal;
-`;
-
-const LocaleCheckbox = ({ locale, toggle, checked }: LocaleCheckboxProps) => {
-  const onClick = useCallback(
-    () => toggle(locale.localeId, !checked),
-    [locale, toggle, checked]
-  );
-
-  return (
-    <Button
-      mode='ghost'
-      onClick={onClick}
-      disabled={locale.enabled === false}
-      style={{ cursor: `pointer` }}
-      radius={2}
-    >
-      <Flex align='center' gap={3}>
-        <Switch
-          style={{ pointerEvents: `none` }}
-          disabled={locale.enabled === false}
-          onChange={onClick}
-          checked={checked}
-        />
-        <WrapText>
-          <Text size={1} weight='semibold'>
-            {locale.description}
-          </Text>
-        </WrapText>
-      </Flex>
-    </Button>
-  );
-};
-
-export const NewTask = ({ locales, refreshTask }: Props) => {
-  const possibleLocales = locales.filter((locale) => locale.enabled !== false);
-  // Lets just stick to the canonical document id for keeping track of
-  // translations
-  const [selectedLocales, setSelectedLocales] = useState<React.ReactNode[]>(
-    locales
-      .filter((locale) => locale.enabled !== false)
-      .map((locale) => locale.localeId)
-  );
-
-  useEffect(() => {
-    setSelectedLocales(
-      locales
-        .filter((locale) => locale.enabled !== false)
-        .map((locale) => locale.localeId)
-    );
-  }, [locales]);
-
-  const [selectedWorkflowUid, setSelectedWorkflowUid] = useState<string>();
-  const [isBusy, setIsBusy] = useState(false);
-
-  const context = useContext(TranslationContext);
-  const toast = useToast();
-
-  const toggleLocale = useCallback(
-    (locale: string, selected: boolean) => {
-      if (!selected) {
-        setSelectedLocales(selectedLocales.filter((l) => l !== locale));
-      } else if (!selectedLocales.includes(locale)) {
-        setSelectedLocales([...selectedLocales, locale]);
-      }
-    },
-    [selectedLocales, setSelectedLocales]
-  );
-
-  const createTask = useCallback(() => {
-    if (!context) {
-      toast.push({
-        title: 'Unable to create task: missing context',
-        status: 'error',
-        closable: true,
-      });
-      return;
-    }
-
-    setIsBusy(true);
-
-    context
-      .exportForTranslation(context.documentInfo)
-      .then((serialized) =>
-        context.adapter.createTask(
-          context.documentInfo,
-          serialized,
-          selectedLocales as string[],
-          context.secrets,
-          selectedWorkflowUid,
-          context.callbackUrl
-        )
-      )
-      .then(() => {
-        toast.push({
-          title: 'Job successfully created',
-          status: 'success',
-          closable: true,
-        });
-
-        /** Reset form fields */
-        setSelectedLocales([]);
-        setSelectedWorkflowUid('');
-
-        /** Update task data in TranslationView */
-        refreshTask();
-      })
-      .catch((err) => {
-        let errorMsg;
-        if (err instanceof Error) {
-          errorMsg = err.message;
-        } else {
-          errorMsg = err ? String(err) : null;
-        }
-
-        toast.push({
-          title: `Error creating translation job`,
-          description: errorMsg,
-          status: 'error',
-          closable: true,
-        });
-      })
-      .finally(() => {
-        setIsBusy(false);
-      });
-  }, [context, selectedLocales, selectedWorkflowUid, toast, refreshTask]);
-
-  const onClick = useCallback(() => {
-    setSelectedLocales(
-      possibleLocales.length === selectedLocales.length
-        ? // Disable all
-          []
-        : // Enable all
-          locales
-            .filter((locale) => locale.enabled !== false)
-            .map((locale) => locale.localeId)
-    );
-  }, [possibleLocales, selectedLocales, setSelectedLocales, locales]);
-
-  const onToggle = useCallback(
-    (locale: string, checked: boolean) => {
-      toggleLocale(locale, checked);
-    },
-    [toggleLocale]
-  );
-
-  const onWorkflowChange = useCallback(
-    (e: ChangeEvent<HTMLSelectElement>) => {
-      setSelectedWorkflowUid(e.target.value);
-    },
-    [setSelectedWorkflowUid]
-  );
-
-  return (
-    <Stack paddingTop={4} space={4}>
-      <Text as='h2' weight='semibold' size={2}>
-        Generate New Translations
-      </Text>
-      <Stack space={3}>
-        <Flex align='center' justify='space-between'>
-          <Text weight='semibold' size={1}>
-            {possibleLocales.length === 1 ? `Select locale` : `Select locales`}
-          </Text>
-
-          <Button
-            fontSize={1}
-            padding={2}
-            text='Toggle All'
-            onClick={onClick}
-          />
-        </Flex>
-
-        <Grid columns={[1, 1, 2, 3]} gap={1}>
-          {(locales || []).map((l) => (
-            <LocaleCheckbox
-              key={l.localeId}
-              locale={l}
-              toggle={onToggle}
-              checked={selectedLocales.includes(l.localeId)}
-            />
-          ))}
-        </Grid>
-      </Stack>
-
-      {context?.workflowOptions && context.workflowOptions.length > 0 && (
-        <Stack space={3}>
-          <Text weight='semibold' size={1} as='label' htmlFor='workflow-select'>
-            Select translation workflow
-          </Text>
-          <Grid columns={[1, 1, 2]}>
-            <Select id='workflowSelect' onChange={onWorkflowChange}>
-              <option>Default locale workflows</option>
-              {context.workflowOptions.map((w) => (
-                <option
-                  key={`workflow-opt-${w.workflowUid}`}
-                  value={w.workflowUid}
-                >
-                  {w.workflowName}
-                </option>
-              ))}
-            </Select>
-          </Grid>
-        </Stack>
-      )}
-
-      <Button
-        onClick={createTask}
-        disabled={isBusy || !selectedLocales.length}
-        tone='positive'
-        text={isBusy ? 'Queueing translations...' : 'Generate Translations'}
-      />
-    </Stack>
-  );
-};