gt-sanity 0.0.5 → 1.0.0

package/src/sanity-api/findDocuments.ts

@@ -0,0 +1,44 @@
+import { SanityClient } from 'sanity';
+import { pluginConfig } from '../adapter/core';
+
+export async function findTranslatedDocuments(
+  documentId: string,
+  client: SanityClient
+) {
+  const documents = await client.fetch(
+    `*[_type == "translation.metadata" && references($documentId)]`
+  );
+  return documents;
+}
+
+export async function findTranslatedDocumentForLocale(
+  sourceDocumentId: string,
+  localeId: string,
+  client: SanityClient
+) {
+  const cleanDocId = sourceDocumentId.replace('drafts.', '');
+
+  // Try both clean and original IDs to be safe, and use -> to directly fetch the translated doc
+  const query = `*[
+    _type == "translation.metadata" &&
+    (
+      translations[_key == $sourceLocale][0].value._ref == $cleanDocId
+    ) &&
+    defined(translations[_key == $localeId])
+  ][0].translations[_key == $localeId][0].value->`;
+
+  const translatedDoc = await client.fetch(query, {
+    sourceLocale: pluginConfig.getSourceLocale(),
+    cleanDocId,
+    localeId,
+  });
+
+  return translatedDoc || null;
+}
+
+export async function findDocument(documentId: string, client: SanityClient) {
+  const query = `*[_id == $id]`;
+  const params = { id: documentId };
+  const document = await client.fetch(query, params);
+  return document[0] || null;
+}

package/src/sanity-api/publishDocuments.ts

@@ -0,0 +1,49 @@
+import { SanityClient } from 'sanity';
+import { processBatch } from '../utils/batchProcessor';
+import { findDocument } from './findDocuments';
+
+export async function publishDocument(
+  documentId: string,
+  client: SanityClient
+) {
+  try {
+    // only publish if the document is a draft
+    if (documentId.startsWith('drafts.')) {
+      await client.action(
+        {
+          actionType: 'sanity.action.document.publish',
+          draftId: documentId,
+          publishedId: documentId.replace('drafts.', ''),
+        },
+        {}
+      );
+    }
+  } catch (error) {
+    console.error('Error publishing document', error);
+  }
+}
+
+export async function publishTranslations(
+  documentIds: string[],
+  client: SanityClient
+) {
+  const publishedDocumentIds: string[] = [];
+  await processBatch(
+    documentIds,
+    async (documentId) => {
+      const document = await findDocument(`drafts.${documentId}`, client);
+      if (!document) {
+        return { documentId, published: false };
+      }
+      await publishDocument(document._id, client);
+      publishedDocumentIds.push(documentId);
+      return { documentId, published: true };
+    },
+    {
+      onItemFailure: (documentId, error) => {
+        console.error(`Failed to publish document ${documentId}:`, error);
+      },
+    }
+  );
+  return publishedDocumentIds;
+}

package/src/sanity-api/resolveRefs.ts

@@ -0,0 +1,146 @@
+import { SanityClient, SanityDocument } from 'sanity';
+import { pluginConfig } from '../adapter/core';
+
+interface Reference {
+  _type: 'reference';
+  _ref: string;
+}
+
+interface TranslationMetadata {
+  _id: string;
+  _type: 'translation.metadata';
+  translations: {
+    _key: string;
+    value: Reference;
+  }[];
+}
+
+/**
+ * Function that:
+ * 1. Finds all references in the document
+ * 2. Fetches the referenced documents, looks for the translation.metadata file for each reference
+ * 3. Updates the document reference with the other translated document reference
+ * 4. Returns the document with the updated references
+ */
+export async function resolveRefs(
+  doc: SanityDocument,
+  locale: string,
+  client: SanityClient
+) {
+  const references = findReferences(doc);
+
+  if (references.length === 0) {
+    return doc;
+  }
+
+  const translatedRefs = await resolveTranslatedReferences(
+    references,
+    locale,
+    client
+  );
+  return updateDocumentReferences(doc, translatedRefs);
+}
+
+/**
+ * Recursively finds all references in a document or object
+ */
+function findReferences(
+  obj: any,
+  path: string[] = []
+): { ref: Reference; path: string[] }[] {
+  if (!obj || typeof obj !== 'object') {
+    return [];
+  }
+
+  const references: { ref: Reference; path: string[] }[] = [];
+
+  if (obj._ref) {
+    references.push({ ref: obj as Reference, path });
+  }
+
+  if (Array.isArray(obj)) {
+    obj.forEach((item, index) => {
+      references.push(...findReferences(item, [...path, index.toString()]));
+    });
+  } else {
+    Object.keys(obj).forEach((key) => {
+      references.push(...findReferences(obj[key], [...path, key]));
+    });
+  }
+
+  return references;
+}
+
+/**
+ * Fetches translation metadata and resolves translated references
+ */
+async function resolveTranslatedReferences(
+  references: { ref: Reference; path: string[] }[],
+  locale: string,
+  client: SanityClient
+): Promise<Map<string, string>> {
+  const refIds = references.map((r) => r.ref._ref);
+  const translatedRefs = new Map<string, string>();
+
+  if (refIds.length === 0) {
+    return translatedRefs;
+  }
+
+  const sourceLocale = pluginConfig.getSourceLocale();
+
+  // Optimized GROQ query that directly returns only the needed translation pairs
+  const query = `*[_type == "translation.metadata" && count(translations[_key == $sourceLocale && value._ref in $refIds]) > 0] {
+    "originalRef": translations[_key == $sourceLocale][0].value._ref,
+    "translatedRef": translations[_key == $locale][0].value._ref
+  }[defined(originalRef) && defined(translatedRef)]`;
+
+  const translationPairs: { originalRef: string; translatedRef: string }[] =
+    await client.fetch(query, { refIds, sourceLocale, locale });
+
+  // Build the translation map
+  for (const { originalRef, translatedRef } of translationPairs) {
+    translatedRefs.set(originalRef, translatedRef);
+  }
+
+  return translatedRefs;
+}
+
+/**
+ * Updates document references with their translated versions
+ */
+function updateDocumentReferences(
+  doc: SanityDocument,
+  translatedRefs: Map<string, string>
+): SanityDocument {
+  return updateReferencesRecursive(doc, translatedRefs);
+}
+
+/**
+ * Recursively updates references in an object
+ */
+function updateReferencesRecursive(
+  obj: any,
+  translatedRefs: Map<string, string>
+): any {
+  if (!obj || typeof obj !== 'object') {
+    return obj;
+  }
+
+  if (obj._ref && translatedRefs.has(obj._ref)) {
+    return {
+      ...obj,
+      _ref: translatedRefs.get(obj._ref),
+    };
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map((item) => updateReferencesRecursive(item, translatedRefs));
+  }
+
+  const updated: any = {};
+  Object.keys(obj).forEach((key) => {
+    updated[key] = updateReferencesRecursive(obj[key], translatedRefs);
+  });
+
+  return updated;
+}

package/src/serialization/BaseDocumentMerger.ts

@@ -0,0 +1,138 @@
+// Adapted from https://github.com/sanity-io/sanity-naive-html-serializer
+
+import { Merger } from './types';
+import { SanityDocument } from 'sanity';
+import { extractWithPath, arrayToJSONMatchPath } from '@sanity/mutator';
+
+const reconcileArray = (origArray: any[], translatedArray: any[]): any[] => {
+  //arrays of strings don't have keys, so just replace the array and return
+  if (translatedArray && translatedArray.some((el) => typeof el === 'string')) {
+    return translatedArray;
+  }
+
+  //deep copy needed for field level patching
+  const combined = JSON.parse(JSON.stringify(origArray));
+
+  translatedArray.forEach((block) => {
+    if (!block._key) {
+      return;
+    }
+    const foundBlockIdx = origArray.findIndex(
+      (origBlock) => origBlock._key === block._key
+    );
+    if (foundBlockIdx < 0) {
+      //eslint-disable-next-line no-console
+      console.warn(
+        `This block no longer exists on the original document. Was it removed? ${JSON.stringify(
+          block
+        )}`
+      );
+    } else if (
+      origArray[foundBlockIdx]._type === 'block' ||
+      origArray[foundBlockIdx]._type === 'span'
+    ) {
+      combined[foundBlockIdx] = block;
+    } else if (Array.isArray(origArray[foundBlockIdx])) {
+      combined[foundBlockIdx] = reconcileArray(origArray[foundBlockIdx], block);
+    } else {
+      combined[foundBlockIdx] = reconcileObject(
+        origArray[foundBlockIdx],
+        block
+      );
+    }
+  });
+  return combined;
+};
+
+const reconcileObject = (
+  origObject: Record<string, any>,
+  translatedObject: Record<string, any>
+): Record<string, any> => {
+  if (
+    typeof translatedObject !== 'object' ||
+    !Object.keys(translatedObject).length
+  ) {
+    return origObject;
+  }
+
+  const updatedObj = JSON.parse(JSON.stringify(origObject));
+  Object.entries(translatedObject).forEach(([key, value]) => {
+    if (!value || key[0] === '_') {
+      return;
+    }
+    if (typeof value === 'string') {
+      updatedObj[key] = value;
+    } else if (Array.isArray(value)) {
+      updatedObj[key] = reconcileArray(origObject[key] ?? [], value);
+    } else {
+      updatedObj[key] = reconcileObject(origObject[key] ?? {}, value);
+    }
+  });
+  return updatedObj;
+};
+
+const fieldLevelMerge = (
+  translatedFields: Record<string, any>,
+  //should be fetched according to the revision and id of the translated obj above
+  baseDoc: SanityDocument,
+  localeId: string,
+  baseLang: string = 'en'
+): Record<string, any> => {
+  const merged: Record<string, any> = {};
+  const metaKeys = ['_rev', '_id', '_type'];
+  metaKeys.forEach((metaKey) => {
+    if (translatedFields[metaKey]) {
+      merged[metaKey] = translatedFields[metaKey];
+    }
+  });
+
+  //get any field that matches the base language, because it's been translated
+  const originPaths = extractWithPath(`..${baseLang}`, translatedFields);
+  originPaths.forEach((match) => {
+    const origVal = extractWithPath(
+      arrayToJSONMatchPath(match.path),
+      baseDoc
+    )[0].value;
+    const translatedVal = extractWithPath(
+      arrayToJSONMatchPath(match.path),
+      translatedFields
+    )[0].value;
+    let valToPatch;
+    if (typeof translatedVal === 'string') {
+      valToPatch = translatedVal;
+    } else if (Array.isArray(translatedVal) && translatedVal.length) {
+      valToPatch = reconcileArray((origVal as Array<any>) ?? [], translatedVal);
+    } else if (
+      typeof translatedVal === 'object' &&
+      Object.keys(translatedVal as Record<string, any>).length
+    ) {
+      valToPatch = reconcileObject(
+        origVal ?? {},
+        translatedVal as Record<string, any>
+      );
+    }
+    const destinationPath = [
+      ...match.path.slice(0, match.path.length - 1), //cut off the "en"
+      localeId.replace('-', '_'), // replace it with our locale
+    ];
+
+    merged[arrayToJSONMatchPath(destinationPath)] = valToPatch;
+  });
+
+  return merged;
+};
+
+const documentLevelMerge = (
+  translatedFields: Record<string, any>,
+  //should be fetched according to the revision and id of the translated obj above
+  baseDoc: SanityDocument
+): Record<string, any> => {
+  return reconcileObject(baseDoc, translatedFields);
+};
+
+export const BaseDocumentMerger: Merger = {
+  fieldLevelMerge,
+  documentLevelMerge,
+  reconcileArray,
+  reconcileObject,
+};

package/src/serialization/BaseSerializationConfig.ts

@@ -0,0 +1,220 @@
+// Adapted from https://github.com/sanity-io/sanity-naive-html-serializer
+
+import { PortableTextBlockStyle } from '@portabletext/types';
+
+import {
+  PortableTextBlockComponent,
+  PortableTextListComponent,
+  PortableTextListItemComponent,
+  PortableTextMarkComponent,
+  PortableTextHtmlComponents,
+} from '@portabletext/to-html';
+
+import { htmlToBlocks } from '@portabletext/block-tools';
+import { blockContentType } from './deserialize/helpers';
+import { PortableTextObject, PortableTextTextBlock, TypedObject } from 'sanity';
+import { attachGTData, detachGTData } from './data';
+
+export const defaultStopTypes = [
+  'reference',
+  'date',
+  'datetime',
+  'file',
+  'geopoint',
+  'image',
+  'number',
+  'crop',
+  'hotspot',
+  'boolean',
+  'url',
+  'color',
+  'code',
+];
+
+export const defaultMarks: Record<string, PortableTextMarkComponent> = {};
+
+export const defaultPortableTextBlockStyles: Record<
+  PortableTextBlockStyle,
+  PortableTextBlockComponent | undefined
+> = {
+  normal: ({ value, children }) => `<p id="${value._key}">${children}</p>`,
+  blockquote: ({ value, children }) =>
+    `<blockquote id="${value._key}">${children}</blockquote>`,
+  h1: ({ value, children }) => `<h1 id="${value._key}">${children}</h1>`,
+  h2: ({ value, children }) => `<h2 id="${value._key}">${children}</h2>`,
+  h3: ({ value, children }) => `<h3 id="${value._key}">${children}</h3>`,
+  h4: ({ value, children }) => `<h4 id="${value._key}">${children}</h4>`,
+  h5: ({ value, children }) => `<h5 id="${value._key}">${children}</h5>`,
+  h6: ({ value, children }) => `<h6 id="${value._key}">${children}</h6>`,
+};
+
+const defaultLists: Record<'number' | 'bullet', PortableTextListComponent> = {
+  number: ({ value, children }) =>
+    `<ol id="${value._key.replace('-parent', '')}">${children}</ol>`,
+  bullet: ({ value, children }) =>
+    `<ul id="${value._key.replace('-parent', '')}">${children}</ul>`,
+};
+
+const defaultListItem: PortableTextListItemComponent = ({
+  value,
+  children,
+}) => {
+  const { _key, level } = value;
+  return `<li id="${(_key || '').replace('-parent', '')}" data-level="${level}">${children}</li>`;
+};
+
+const unknownBlockFunc: PortableTextBlockComponent = ({ value, children }) =>
+  `<p id="${value._key}" data-type="unknown-block-style" data-style="${value.style}">${children}</p>`;
+
+export const customSerializers: Partial<PortableTextHtmlComponents> = {
+  unknownType: ({ value }: { value: Record<string, any> }) =>
+    `<div class="${value._type}"></div>`,
+  types: {},
+  marks: defaultMarks,
+  block: defaultPortableTextBlockStyles,
+  list: defaultLists,
+  listItem: defaultListItem,
+  unknownBlockStyle: unknownBlockFunc,
+};
+
+export const customDeserializers: Record<string, any> = { types: {} };
+
+export const customBlockDeserializers: Array<any> = [
+  // handle marks with data-gt-internal
+  {
+    deserialize(
+      el: HTMLParagraphElement,
+      next: (
+        elements: Node | Node[] | NodeList
+      ) => TypedObject | TypedObject[] | undefined
+    ): PortableTextTextBlock | TypedObject | undefined {
+      if (!el.hasChildNodes()) {
+        return undefined;
+      }
+
+      if (!el.getAttribute('data-gt-internal')) {
+        return undefined;
+      }
+
+      const { html, data } = detachGTData(el.outerHTML);
+      const block = htmlToBlocks(html, blockContentType)[0];
+
+      const children = next(el.childNodes);
+
+      let markDefs: PortableTextObject[] = [];
+      if ('markDefs' in block) {
+        markDefs = (block.markDefs as PortableTextObject[]) ?? [];
+      }
+      if (data?.markDef) {
+        markDefs.push(data.markDef as PortableTextObject);
+      }
+      if (children) {
+        (children as any).forEach((child: any) => {
+          child.marks = data?.markDef?._key
+            ? [...(child.marks || []), data.markDef._key]
+            : [...(child.marks || [])];
+        });
+      }
+      // Resolve marks in the child nodes
+      const output = {
+        ...block,
+        markDefs,
+        children,
+      };
+      return output;
+    },
+  },
+  //handle undeclared styles
+  {
+    deserialize(
+      el: HTMLParagraphElement,
+      next: (
+        elements: Node | Node[] | NodeList
+      ) => TypedObject | TypedObject[] | undefined
+    ): PortableTextTextBlock | TypedObject | undefined {
+      if (!el.hasChildNodes()) {
+        return undefined;
+      }
+
+      if (el.getAttribute('data-type') !== 'unknown-block-style') {
+        return undefined;
+      }
+
+      const style = el.getAttribute('data-style') ?? '';
+      const block = htmlToBlocks(el.outerHTML, blockContentType)[0];
+
+      return {
+        ...block,
+        style,
+        children: next(el.childNodes),
+      };
+    },
+  },
+  //handle list items
+  {
+    deserialize(
+      el: HTMLParagraphElement,
+      next: (
+        elements: Node | Node[] | NodeList
+      ) => TypedObject | TypedObject[] | undefined
+    ): PortableTextTextBlock | TypedObject | undefined {
+      if (!el.hasChildNodes()) {
+        return undefined;
+      }
+
+      if (el.tagName.toLowerCase() !== 'li') {
+        return undefined;
+      }
+
+      const tagsToStyle: Record<string, string> = {
+        ul: 'bullet',
+        ol: 'number',
+      };
+
+      const parent = el.parentNode as HTMLUListElement | HTMLOListElement;
+      if (!parent || !parent.tagName) {
+        return undefined;
+      }
+
+      const listItem = tagsToStyle[parent.tagName.toLowerCase()];
+      if (!listItem) {
+        return undefined;
+      }
+
+      const level =
+        el.getAttribute('data-level') &&
+        parseInt(el.getAttribute('data-level') || '0', 10);
+      const _key = el.id;
+      let block = htmlToBlocks(parent.outerHTML, blockContentType)[0];
+      const customStyle = el.children?.[0]?.getAttribute('data-style');
+
+      //check if the object inside is also serialized -- that means it has a style
+      //or custom annotation and we should use childNode serialization
+      const regex = new RegExp(/<("[^"]*"|'[^']*'|[^'">])*>/);
+      if (regex.test(el.innerHTML)) {
+        const newBlock = htmlToBlocks(el.innerHTML, blockContentType)[0];
+        if (newBlock) {
+          block = {
+            ...block,
+            ...newBlock,
+            // @ts-ignore
+            style: customStyle ?? (newBlock as PortableTextTextBlock).style,
+          };
+
+          //next(childNodes) plays poorly with custom styles, issue to be filed.
+          if (customStyle) {
+            return block as PortableTextTextBlock;
+          }
+        }
+      }
+
+      return {
+        ...block,
+        level,
+        _key,
+        listItem,
+        children: next(el.childNodes),
+      };
+    },
+  },
+];