gt-sanity 0.0.5 → 0.0.6

package/src/translation/importDocument.ts

@@ -0,0 +1,24 @@
+import { gtConfig } from '../adapter/core';
+import { documentLevelPatch } from '../configuration/baseDocumentLevelConfig/documentLevelPatch';
+import type { GTFile, TranslationFunctionContext } from '../types';
+import { deserializeDocument } from '../utils/serialize';
+
+export async function importDocument(
+  docInfo: GTFile,
+  localeId: string,
+  document: string,
+  context: TranslationFunctionContext,
+  publish: boolean = false
+) {
+  const { client } = context;
+  const deserialized = deserializeDocument(document);
+  return documentLevelPatch(
+    docInfo, // versionId is not used here, since we just use the _rev id in the deserialized HTML itself
+    deserialized,
+    localeId,
+    client,
+    gtConfig.getLanguageField(),
+    false,
+    publish
+  );
+}

package/src/translation/initProject.ts

@@ -0,0 +1,61 @@
+import { gt, overrideConfig } from '../adapter/core';
+import type { Secrets } from '../types';
+
+export async function initProject(
+  uploadResult: Awaited<ReturnType<typeof gt.uploadSourceFiles>>,
+  options: { timeout?: number },
+  secrets: Secrets
+): Promise<boolean> {
+  overrideConfig(secrets);
+  const setupDecision = await Promise.resolve(gt.shouldSetupProject?.())
+    .then((v: any) => v)
+    .catch(() => ({ shouldSetupProject: false }));
+  const shouldSetupProject = Boolean(setupDecision?.shouldSetupProject);
+
+  // Step 2: Setup if needed and poll until complete
+  if (shouldSetupProject) {
+    // Calculate timeout once for setup fetching
+    // Accept number or numeric string, default to 600s
+    const timeoutVal =
+      options?.timeout !== undefined ? Number(options.timeout) : 600;
+    const setupTimeoutMs =
+      (Number.isFinite(timeoutVal) ? timeoutVal : 600) * 1000;
+
+    const { setupJobId } = await gt.setupProject(uploadResult.uploadedFiles);
+
+    const start = Date.now();
+    const pollInterval = 2000;
+
+    let setupCompleted = false;
+    let setupFailedMessage: string | null = null;
+
+    while (true) {
+      const status = await gt.checkSetupStatus(setupJobId);
+
+      if (status.status === 'completed') {
+        setupCompleted = true;
+        break;
+      }
+      if (status.status === 'failed') {
+        setupFailedMessage = status.error?.message || 'Unknown error';
+        break;
+      }
+      if (Date.now() - start > setupTimeoutMs) {
+        setupFailedMessage = 'Timed out while waiting for setup generation';
+        break;
+      }
+      await new Promise((r) => setTimeout(r, pollInterval));
+    }
+
+    if (setupCompleted) {
+      console.log('Setup successfully completed');
+      return true;
+    } else {
+      console.log(`Setup ${setupFailedMessage ? 'failed' : 'timed out'} `);
+      return false;
+    }
+  } else {
+    console.log('Setup not needed');
+  }
+  return true;
+}

package/src/translation/uploadFiles.ts

@@ -0,0 +1,32 @@
+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';
+
+// note: this function is used to create a new translation task
+// uploads files & calls the getTranslationTask function
+export async function uploadFiles(
+  documents: {
+    info: GTFile;
+    serializedDocument: SerializedDocument;
+  }[],
+  secrets: Secrets | null
+): Promise<Awaited<ReturnType<typeof gt.uploadSourceFiles>>> {
+  overrideConfig(secrets);
+  const uploadResult = await gt.uploadSourceFiles(
+    documents.map(({ info, serializedDocument }) => ({
+      source: {
+        content: serializedDocument.content,
+        fileName: `sanity/${info.documentId}`,
+        fileId: info.documentId,
+        fileFormat: 'HTML',
+        locale: gt.sourceLocale || libraryDefaultLocale,
+        versionId: info.versionId || undefined,
+      },
+    })),
+    {
+      sourceLocale: gt.sourceLocale || libraryDefaultLocale,
+    }
+  );
+  return uploadResult;
+}

package/src/types.ts

@@ -1,3 +1,5 @@
+// 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 { PortableTextTypeComponent } from '@portabletext/to-html';
@@ -96,7 +98,8 @@ export type ImportTranslation = (
     additionalBlockDeserializers?: DeserializerRule[];
   },
   languageField?: string,
-  mergeWithTargetLocale?: boolean
+  mergeWithTargetLocale?: boolean,
+  publish?: boolean
 ) => Promise<void>;
 
 export type TranslationsTabConfigOptions = {

package/src/utils/applyDocuments.ts

@@ -0,0 +1,72 @@
+import { JSONPath } from 'jsonpath-plus';
+import JSONPointer from 'jsonpointer';
+import type { IgnoreFields } from '../adapter/types';
+
+export function applyDocuments(
+  documentId: string,
+  sourceDocument: Record<string, any>,
+  targetDocument: Record<string, any>,
+  ignore: IgnoreFields[]
+) {
+  const ignoreFields = ignore.filter(
+    (field) =>
+      field.documentId === documentId ||
+      field.documentId === undefined ||
+      field.documentId === null
+  );
+
+  // Start with a shallow copy of the source document
+  const mergedDocument = { ...sourceDocument };
+
+  // Merge top-level properties of targetDocument
+  for (const [key, value] of Object.entries(targetDocument)) {
+    mergedDocument[key] = value;
+  }
+
+  // Process ignored fields and restore them from source document
+  for (const ignoreField of ignoreFields) {
+    if (!ignoreField.fields) continue;
+
+    for (const field of ignoreField.fields) {
+      const { property, type } = field;
+
+      try {
+        // Use JSONPath to find matching paths, then JSONPointer to get/set values
+        const sourceResults = JSONPath({
+          json: sourceDocument,
+          path: property,
+          resultType: 'all',
+          flatten: true,
+          wrap: true,
+        });
+
+        if (sourceResults && sourceResults.length > 0) {
+          // Process each matching path
+          sourceResults.forEach((result: { pointer: string; value: any }) => {
+            const sourceValue = result.value;
+
+            // If type is specified, check if it matches the object's _type property
+            if (type !== undefined) {
+              if (
+                typeof sourceValue === 'object' &&
+                sourceValue !== null &&
+                sourceValue._type === type
+              ) {
+                // Type matches, restore the entire object using JSONPointer
+                JSONPointer.set(mergedDocument, result.pointer, sourceValue);
+              }
+            } else {
+              // No type specified, restore the value using JSONPointer
+              JSONPointer.set(mergedDocument, result.pointer, sourceValue);
+            }
+          });
+        }
+      } catch (error) {
+        // Invalid JSONPath, skip this field
+        console.warn(`Invalid JSONPath: ${property}`, error);
+      }
+    }
+  }
+
+  return mergedDocument;
+}

package/src/utils/serialize.ts

@@ -0,0 +1,32 @@
+import { SanityDocument, Schema } from 'sanity';
+import {
+  BaseDocumentDeserializer,
+  BaseDocumentSerializer,
+  defaultStopTypes,
+  customSerializers,
+  customBlockDeserializers,
+} from 'sanity-naive-html-serializer';
+
+export function deserializeDocument(document: string) {
+  const deserialized = BaseDocumentDeserializer.deserializeDocument(
+    document,
+    { types: {} },
+    customBlockDeserializers
+  ) as SanityDocument;
+  return deserialized;
+}
+
+export function serializeDocument(
+  document: SanityDocument,
+  schema: Schema,
+  baseLanguage: string
+) {
+  const serialized = BaseDocumentSerializer(schema).serializeDocument(
+    document,
+    'document',
+    baseLanguage,
+    defaultStopTypes,
+    customSerializers
+  );
+  return serialized;
+}

package/src/utils/shared.ts

@@ -0,0 +1 @@
+export const SECRETS_NAMESPACE = 'generaltranslation';

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

@@ -1,5 +0,0 @@
-export { createI18nDocAndPatchMetadata } from './createI18nDocAndPatchMetadata';
-export { createTranslationMetadata } from './createTranslationMetadata';
-export { getTranslationMetadata } from './getTranslationMetadata';
-export { getOrCreateTranslationMetadata } from './getOrCreateTranslationMetadata';
-export { patchI18nDoc } from './patchI18nDoc';

package/src/configuration/baseDocumentLevelConfig/legacyDocumentLevelPatch.ts

@@ -1,69 +0,0 @@
-import { SanityClient, SanityDocument, SanityDocumentLike } from 'sanity';
-import { BaseDocumentMerger } from 'sanity-naive-html-serializer';
-
-import { findLatestDraft, findDocumentAtRevision } from '../utils';
-import type { GTFile } from '../../types';
-
-export const legacyDocumentLevelPatch = async (
-  docInfo: GTFile,
-  translatedFields: SanityDocument,
-  localeId: string,
-  client: SanityClient
-): Promise<void> => {
-  let baseDoc: SanityDocument | null = null;
-
-  /*
-   * we send over the _rev with our translation file so we can
-   * accurately coalesce the translations in case something has
-   * changed in the base document since translating
-   */
-  if (docInfo.documentId && docInfo.versionId) {
-    baseDoc = await findDocumentAtRevision(
-      docInfo.documentId,
-      docInfo.versionId,
-      client
-    );
-  }
-  if (!baseDoc) {
-    baseDoc = await findLatestDraft(docInfo.documentId, client);
-  }
-
-  /*
-   * we then merge the translation with the base document
-   * to create a document that contains the translation and everything
-   * that wasn't sent over for translation
-   */
-  const merged = BaseDocumentMerger.documentLevelMerge(
-    translatedFields,
-    baseDoc
-  ) as SanityDocumentLike;
-
-  /* we now need to check if we have a translated document
-   * if not, we create it
-   */
-  const targetId = `drafts.${docInfo.documentId}__i18n_${localeId}`;
-  const i18nDoc = await findLatestDraft(targetId, client);
-  if (i18nDoc) {
-    const cleanedMerge: Record<string, any> = {};
-    //don't overwrite any existing system values on the i18n doc
-    Object.entries(merged).forEach(([key, value]) => {
-      if (
-        Object.keys(translatedFields).includes(key) &&
-        !['_id', '_rev', '_updatedAt'].includes(key)
-      ) {
-        cleanedMerge[key] = value;
-      }
-    });
-
-    await client
-      .transaction()
-      //@ts-ignore
-      .patch(i18nDoc._id, (p) => p.set(cleanedMerge))
-      .commit();
-  } else {
-    merged._id = targetId;
-
-    merged.__i18n_lang = localeId;
-    await client.create(merged);
-  }
-};

package/src/configuration/index.ts

@@ -1,18 +0,0 @@
-import {
-  baseDocumentLevelConfig,
-  documentLevelPatch,
-  legacyDocumentLevelConfig,
-  legacyDocumentLevelPatch,
-} from './baseDocumentLevelConfig';
-import { baseFieldLevelConfig, fieldLevelPatch } from './baseFieldLevelConfig';
-import { findLatestDraft } from './utils';
-
-export {
-  baseDocumentLevelConfig,
-  legacyDocumentLevelConfig,
-  baseFieldLevelConfig,
-  findLatestDraft,
-  legacyDocumentLevelPatch,
-  documentLevelPatch,
-  fieldLevelPatch,
-};

package/src/configuration/utils/index.ts

@@ -1,3 +0,0 @@
-export * from './findDocumentAtRevision';
-export * from './findLatestDraft';
-export * from './checkSerializationVersion';