gt-sanity 0.0.5

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

@@ -0,0 +1,43 @@
+import {
+  KeyedObject,
+  Reference,
+  SanityClient,
+  SanityDocumentLike,
+} from 'sanity';
+
+type TranslationReference = KeyedObject & {
+  _type: 'internationalizedArrayReferenceValue';
+  value: Reference;
+};
+
+export const createTranslationMetadata = (
+  document: SanityDocumentLike,
+  client: SanityClient,
+  baseLanguage: string
+): Promise<SanityDocumentLike> => {
+  const baseLangEntry: TranslationReference = {
+    _key: baseLanguage,
+    _type: 'internationalizedArrayReferenceValue',
+    value: {
+      _type: 'reference',
+      _ref: document._id.replace('drafts.', ''),
+    },
+  };
+
+  if (document._id.startsWith('drafts.')) {
+    baseLangEntry.value = {
+      ...baseLangEntry.value,
+      _weak: true,
+      //this should reflect doc i18n config when this
+      //plugin is able to take that as a config option
+      _strengthenOnPublish: {
+        type: document._type,
+      },
+    };
+  }
+
+  return client.create({
+    _type: 'translation.metadata',
+    translations: [baseLangEntry],
+  });
+};

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

@@ -0,0 +1,77 @@
+import {
+  KeyedObject,
+  Reference,
+  SanityClient,
+  SanityDocumentLike,
+} from 'sanity';
+
+type TranslationReference = KeyedObject & {
+  _type: 'internationalizedArrayReferenceValue';
+  value: Reference;
+};
+
+export const getOrCreateTranslationMetadata = async (
+  documentId: string,
+  baseDocument: SanityDocumentLike,
+  client: SanityClient,
+  baseLanguage: string
+): Promise<SanityDocumentLike> => {
+  // First, try to get existing metadata
+  const existingMetadata = await client.fetch(
+    `*[
+        _type == 'translation.metadata' &&
+        translations[_key == $baseLanguage][0].value._ref == $id
+      ][0]`,
+    { baseLanguage, id: documentId.replace('drafts.', '') }
+  );
+
+  if (existingMetadata) {
+    return existingMetadata;
+  }
+
+  // If no metadata exists, create it atomically
+  const baseLangEntry: TranslationReference = {
+    _key: baseLanguage,
+    _type: 'internationalizedArrayReferenceValue',
+    value: {
+      _type: 'reference',
+      _ref: baseDocument._id.replace('drafts.', ''),
+    },
+  };
+
+  if (baseDocument._id.startsWith('drafts.')) {
+    baseLangEntry.value = {
+      ...baseLangEntry.value,
+      _weak: true,
+      //this should reflect doc i18n config when this
+      //plugin is able to take that as a config option
+      _strengthenOnPublish: {
+        type: baseDocument._type,
+      },
+    };
+  }
+
+  try {
+    // Use createIfNotExists to handle race conditions
+    return await client.createIfNotExists({
+      _id: `translation.metadata.${documentId.replace('drafts.', '')}`,
+      _type: 'translation.metadata',
+      translations: [baseLangEntry],
+    });
+  } catch (error) {
+    // If creation fails due to race condition, fetch the existing document
+    const metadata = await client.fetch(
+      `*[
+          _type == 'translation.metadata' &&
+          translations[_key == $baseLanguage][0].value._ref == $id
+        ][0]`,
+      { baseLanguage, id: documentId.replace('drafts.', '') }
+    );
+
+    if (metadata) {
+      return metadata;
+    }
+
+    throw error;
+  }
+};

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

@@ -0,0 +1,15 @@
+import { SanityClient, SanityDocumentLike } from 'sanity';
+
+export const getTranslationMetadata = (
+  id: string,
+  client: SanityClient,
+  baseLanguage: string
+): Promise<SanityDocumentLike | null> => {
+  return client.fetch(
+    `*[
+        _type == 'translation.metadata' &&
+        translations[_key == $baseLanguage][0].value._ref == $id
+      ][0]`,
+    { baseLanguage, id: id.replace('drafts.', '') }
+  );
+};

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

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

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

@@ -0,0 +1,25 @@
+import { SanityClient, SanityDocumentLike } from 'sanity';
+
+export const patchI18nDoc = (
+  i18nDocId: string,
+  mergedDocument: SanityDocumentLike,
+  translatedFields: Record<string, any>,
+  client: SanityClient
+): 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)
+    ) {
+      cleanedMerge[key] = value;
+    }
+  });
+
+  client
+    .transaction()
+    .patch(i18nDocId, (p) => p.set(cleanedMerge))
+    .commit();
+};

package/src/configuration/baseDocumentLevelConfig/index.ts

@@ -0,0 +1,129 @@
+import {
+  ExportForTranslation,
+  GTSerializedDocument,
+  ImportTranslation,
+} from '../../types';
+import { SanityDocument } from 'sanity';
+import { findLatestDraft } from '../utils';
+import { documentLevelPatch } from './documentLevelPatch';
+import { legacyDocumentLevelPatch } from './legacyDocumentLevelPatch';
+import {
+  BaseDocumentDeserializer,
+  BaseDocumentSerializer,
+  defaultStopTypes,
+  customSerializers,
+  customBlockDeserializers,
+} from 'sanity-naive-html-serializer';
+import { gtConfig } from '../../adapter/core';
+
+export const baseDocumentLevelConfig = {
+  exportForTranslation: async (
+    ...params: Parameters<ExportForTranslation>
+  ): Promise<GTSerializedDocument> => {
+    const [
+      docInfo,
+      context,
+      serializationOptions = {},
+      languageField = 'language',
+    ] = params;
+    const { client, schema } = context;
+    const stopTypes = [
+      ...(serializationOptions.additionalStopTypes ?? []),
+      ...defaultStopTypes,
+    ];
+    const serializers = {
+      ...customSerializers,
+      types: {
+        ...customSerializers.types,
+        ...(serializationOptions.additionalSerializers ?? {}),
+      },
+    };
+    const doc = await findLatestDraft(docInfo.documentId, client);
+    delete doc[languageField];
+    const baseLanguage = gtConfig.getSourceLocale();
+    const serialized = BaseDocumentSerializer(schema).serializeDocument(
+      doc,
+      'document',
+      baseLanguage,
+      stopTypes,
+      serializers
+    );
+    return {
+      content: serialized.content,
+      documentId: docInfo.documentId,
+      versionId: docInfo.versionId,
+    };
+  },
+  importTranslation: (
+    ...params: Parameters<ImportTranslation>
+  ): Promise<void> => {
+    const [
+      docInfo,
+      localeId,
+      document,
+      context,
+      serializationOptions = {},
+      languageField = 'language',
+      mergeWithTargetLocale = false,
+    ] = params;
+    const { client } = context;
+    const deserializers = {
+      types: {
+        ...(serializationOptions.additionalDeserializers ?? {}),
+      },
+    };
+    const blockDeserializers = [
+      ...(serializationOptions.additionalBlockDeserializers ?? []),
+      ...customBlockDeserializers,
+    ];
+
+    const deserialized = BaseDocumentDeserializer.deserializeDocument(
+      document,
+      deserializers,
+      blockDeserializers
+    ) as SanityDocument;
+    return documentLevelPatch(
+      docInfo, // versionId is not used here, since we just use the _rev id in the deserialized HTML itself
+      deserialized,
+      localeId,
+      client,
+      languageField,
+      mergeWithTargetLocale
+    );
+  },
+  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/baseDocumentLevelConfig/legacyDocumentLevelPatch.ts

@@ -0,0 +1,69 @@
+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/baseFieldLevelConfig.ts

@@ -0,0 +1,118 @@
+import { SanityClient, SanityDocument } from 'sanity';
+import {
+  BaseDocumentSerializer,
+  BaseDocumentDeserializer,
+  BaseDocumentMerger,
+  defaultStopTypes,
+  customSerializers,
+  customBlockDeserializers,
+} from 'sanity-naive-html-serializer';
+
+import type {
+  ExportForTranslation,
+  GTFile,
+  GTSerializedDocument,
+  ImportTranslation,
+} from '../types';
+import { findLatestDraft, findDocumentAtRevision } from './utils';
+import { gtConfig } from '../adapter/core';
+
+export const fieldLevelPatch = async (
+  docInfo: GTFile,
+  translatedFields: SanityDocument,
+  localeId: string,
+  client: SanityClient,
+  mergeWithTargetLocale: boolean = false
+): Promise<void> => {
+  let baseDoc: SanityDocument;
+  const baseLanguage = gtConfig.getSourceLocale();
+  if (docInfo.documentId && docInfo.versionId) {
+    baseDoc = await findDocumentAtRevision(
+      docInfo.documentId,
+      docInfo.versionId,
+      client
+    );
+  } else {
+    baseDoc = await findLatestDraft(docInfo.documentId, client);
+  }
+
+  const merged = BaseDocumentMerger.fieldLevelMerge(
+    translatedFields,
+    baseDoc,
+    localeId,
+    mergeWithTargetLocale ? baseLanguage : localeId
+  );
+
+  await client.patch(baseDoc._id).set(merged).commit();
+};
+
+export const baseFieldLevelConfig = {
+  exportForTranslation: async (
+    ...params: Parameters<ExportForTranslation>
+  ): Promise<GTSerializedDocument> => {
+    const [docInfo, context, serializationOptions = {}] = params;
+    const baseLanguage = gtConfig.getSourceLocale();
+    const { client, schema } = context;
+    const stopTypes = [
+      ...(serializationOptions.additionalStopTypes ?? []),
+      ...defaultStopTypes,
+    ];
+    const serializers = {
+      ...customSerializers,
+      types: {
+        ...customSerializers.types,
+        ...(serializationOptions.additionalSerializers ?? {}),
+      },
+    };
+    const doc = await findLatestDraft(docInfo.documentId, client);
+    const serialized = BaseDocumentSerializer(schema).serializeDocument(
+      doc,
+      'field',
+      baseLanguage,
+      stopTypes,
+      serializers
+    );
+    return {
+      content: serialized.content,
+      documentId: docInfo.documentId,
+      versionId: docInfo.versionId,
+    };
+  },
+  importTranslation: (
+    ...params: Parameters<ImportTranslation>
+  ): Promise<void> => {
+    const [
+      docInfo,
+      localeId,
+      document,
+      context,
+      serializationOptions = {},
+      ,
+      mergeWithTargetLocale,
+    ] = params;
+    const { client } = context;
+    const deserializers = {
+      types: {
+        ...(serializationOptions.additionalDeserializers ?? {}),
+      },
+    };
+    const blockDeserializers = [
+      ...(serializationOptions.additionalBlockDeserializers ?? []),
+      ...customBlockDeserializers,
+    ];
+
+    const deserialized = BaseDocumentDeserializer.deserializeDocument(
+      document,
+      deserializers,
+      blockDeserializers
+    ) as SanityDocument;
+    return fieldLevelPatch(
+      docInfo,
+      deserialized,
+      localeId,
+      client,
+      mergeWithTargetLocale
+    );
+  },
+  secretsNamespace: 'translationService',
+};

package/src/configuration/index.ts

@@ -0,0 +1,18 @@
+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/checkSerializationVersion.ts

@@ -0,0 +1,13 @@
+export const checkSerializationVersion = (HTMLdoc: string): string | null => {
+  const parser = new DOMParser();
+  const node = parser.parseFromString(HTMLdoc, 'text/html');
+  const versionMetaTag = Array.from(node.head.children).find(
+    (metaTag) => metaTag.getAttribute('name') === 'version'
+  );
+  if (!versionMetaTag) {
+    return null;
+  }
+
+  const version = versionMetaTag.getAttribute('content');
+  return version;
+};

package/src/configuration/utils/findDocumentAtRevision.ts

@@ -0,0 +1,22 @@
+import { SanityClient, SanityDocument } from 'sanity';
+
+//revision fetch
+export const findDocumentAtRevision = async (
+  documentId: string,
+  rev: string,
+  client: SanityClient
+): Promise<SanityDocument> => {
+  const dataset = client.config().dataset;
+  const baseUrl = `/data/history/${dataset}/documents/${documentId}?revision=${rev}`;
+  const url = client.getUrl(baseUrl);
+  const revisionDoc = await fetch(url, { credentials: 'include' })
+    .then((req) => req.json())
+    .then((req) => {
+      if (req.documents && req.documents.length) {
+        return req.documents[0];
+      }
+      return null;
+    });
+
+  return revisionDoc;
+};

package/src/configuration/utils/findLatestDraft.ts

@@ -0,0 +1,16 @@
+import { SanityClient, SanityDocument } from 'sanity';
+
+//use perspectives in the future
+export const findLatestDraft = (
+  documentId: string,
+  client: SanityClient
+): Promise<SanityDocument> => {
+  const query = `*[_id == $id || _id == $draftId]`;
+  const params = { id: documentId, draftId: `drafts.${documentId}` };
+  return client
+    .fetch(query, params)
+    .then(
+      (docs: SanityDocument[]) =>
+        docs.find((doc) => doc._id.startsWith('drafts.')) ?? docs[0]
+    );
+};

package/src/configuration/utils/index.ts

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

package/src/hooks/useClient.ts

@@ -0,0 +1,5 @@
+import { SanityClient, useClient as useSanityClient } from 'sanity';
+
+export const useClient = (): SanityClient => {
+  return useSanityClient({ apiVersion: '2022-12-07' });
+};

package/src/hooks/useSecrets.ts

@@ -0,0 +1,33 @@
+import { useState, useEffect } from 'react';
+import { SanityDocumentLike } from 'sanity';
+import { useClient } from './useClient';
+
+interface ReturnProps<T> {
+  loading: boolean;
+  secrets: T | null;
+}
+export function useSecrets<T>(id: string): ReturnProps<T> {
+  const [loading, setLoading] = useState<boolean>(true);
+  const [secrets, setSecrets] = useState<T | null>(null);
+  const client = useClient();
+
+  useEffect(() => {
+    function fetchData() {
+      client
+        .fetch('* [_id == $id][0]', { id })
+        .then((doc: SanityDocumentLike) => {
+          const result: Record<string, any> = {};
+          for (const key in doc) {
+            if (key[0] !== '_') {
+              result[key] = doc[key];
+            }
+          }
+          setSecrets(result as T);
+          setLoading(false);
+        });
+    }
+    fetchData();
+  }, [id, client]);
+
+  return { loading, secrets };
+}