@smartcat/sanity-plugin 1.2.1 → 1.4.0

package/src/tool/processing.ts

@@ -14,7 +14,7 @@ import {serializeToLocjson} from '../lib/locjson/serialize'
 import {buildLocjsonFilename} from '../lib/locjson/filename'
 import {deserializeFromLocjson} from '../lib/locjson/deserialize'
 import {requireSourceLanguage} from '../lib/constants'
-import {buildLanguageMappings, findDuplicateSmartcatLanguages} from '../lib/languageMap'
+import {buildLanguageMappings, findDuplicateSmartcatLanguages, toSmartcatLanguage} from '../lib/languageMap'
 import type {LocalizationMode, LocJSON} from '../lib/locjson/types'
 import {summarizeCompletion, type DocProgress} from '../progress/core'
 import type {SmartcatLanguage} from '../types'
@@ -142,10 +142,28 @@ const ITEMS_QUERY = `*[_id == $id][0]{
   items[]{
     "docId": ${ITEM_ID},
     "docType": docType,
+    sendExistingTranslations,
     "doc": ${itemDocDerefRespectingDraft()}
   }
 }`
 
+/**
+ * Target-locale sibling documents for a set of source ids, via
+ * document-internationalization's `translation.metadata`. Returns, per metadata
+ * group, every locale variant's `{language, doc}` — the send-existing flow reads
+ * each target language's sibling as the translation to upload. Document-level
+ * only; field-level types keep all languages inline on the same document.
+ *
+ * The variant's locale lives in its language field (v5+, with a uuid `_key`) or
+ * in `_key` itself (v4.x); `coalesce` reads whichever applies per the configured
+ * {@link fieldLanguageKey}. Reading only `_key` misses v5+ siblings entirely.
+ */
+export function siblingsQuery(fieldLanguageKey: string): string {
+  return `*[_type == "translation.metadata" && references($ids)]{
+  "variants": translations[]{ "language": coalesce(${fieldLanguageKey}, _key), "doc": value-> }
+}`
+}
+
 export async function prepareExport({
   client,
   schema,
@@ -165,6 +183,7 @@ export async function prepareExport({
     items?: {
       docId?: string
       docType?: string
+      sendExistingTranslations?: boolean
       doc: (Record<string, unknown> & {_id: string; _type: string}) | null
     }[]
   } | null>(ITEMS_QUERY, {id: projectId})
@@ -195,6 +214,37 @@ export async function prepareExport({
     .map((item) => item.doc)
     .filter((d): d is Record<string, unknown> & {_id: string; _type: string} => Boolean(d))
 
+  // For "send existing translations" document-level items, fetch each source's
+  // target-locale sibling documents up front (one query), keyed by
+  // bare-source-id → (Sanity locale → sibling doc). Field-level types need none —
+  // their translations live inline on the same document.
+  type TargetDoc = Record<string, unknown> & {_id: string; _type: string}
+  const siblingsByDocId = new Map<string, Map<string, TargetDoc>>()
+  const flaggedDocLevelIds = items
+    .filter(
+      (item) =>
+        item.doc && item.sendExistingTranslations === true && localizationMode(schema.get(item.doc._type)) === 'document',
+    )
+    .map((item) => publishedId((item.doc as {_id: string})._id))
+  if (flaggedDocLevelIds.length > 0) {
+    const groups = await client.fetch<{variants: {language: string; doc: TargetDoc | null}[]}[]>(
+      siblingsQuery(fieldLanguageKey),
+      {ids: flaggedDocLevelIds},
+    )
+    for (const group of groups ?? []) {
+      const byLang = new Map<string, TargetDoc>()
+      const groupSourceIds: string[] = []
+      for (const variant of group.variants ?? []) {
+        if (!variant.doc) continue
+        byLang.set(variant.language, variant.doc)
+        groupSourceIds.push(publishedId(variant.doc._id))
+      }
+      // Every member of a translation group can reach the same sibling set, so key
+      // the map by each variant's id — the source doc looks up its own group.
+      for (const sid of groupSourceIds) siblingsByDocId.set(sid, byLang)
+    }
+  }
+
   // The translatable field list is per-type, so compute it once per type even
   // when a project holds many documents of the same type.
   const fieldsByType = new Map<string, ReturnType<typeof getTranslatableFields>>()
@@ -228,17 +278,79 @@ export async function prepareExport({
     })
   }
 
-  const outbox: {_key: string; sourceDocId: string; title?: string; filename: string; locjson: string}[] = []
-  for (const rawDoc of docs) {
+  const outbox: {
+    _key: string
+    sourceDocId: string
+    title?: string
+    filename: string
+    locjson: string
+    /** Present for per-language bilingual files (send-existing flow). */
+    targetLanguage?: string
+  }[] = []
+
+  /**
+   * Queue one bilingual LocJSON per target language for a "send existing
+   * translations" item. Each file carries the source plus that language's
+   * existing translation (field-level: the inline member; document-level: the
+   * locale-sibling document), is named `…_{smartcatCode}.locjson` so Smartcat
+   * groups the languages as one document, and records its single target language.
+   */
+  const queueBilingual = (
+    doc: Record<string, unknown> & {_id: string; _type: string},
+    name: string | undefined,
+    fields: TranslatableField[],
+    isDraft: boolean,
+  ): void => {
+    const mode = localizationMode(schema.get(doc._type))
+    const byLang = mode === 'document' ? siblingsByDocId.get(doc._id) : undefined
+    let queued = 0
+    for (const targetSanityId of targetLanguages) {
+      const smartcatCode = toSmartcatLanguage(smartcatLanguages, targetSanityId)
+      const target =
+        mode === 'field' ? {language: targetSanityId} : {language: targetSanityId, doc: byLang?.get(targetSanityId)}
+      const locjson = serializeToLocjson(doc as never, fields, {sourceLanguage: source, fieldLanguageKey, target})
+      if (locjson.units.length === 0) {
+        log({level: 'skip', indent: true, message: `${targetSanityId}: no translatable content — not sent`})
+        continue
+      }
+      const prefilled = locjson.units.filter((u) => u.target.length > 0).length
+      outbox.push({
+        _key: uuid(),
+        sourceDocId: doc._id,
+        title: name,
+        filename: buildLocjsonFilename(doc._type, doc._id, name, {draft: isDraft, language: smartcatCode}),
+        locjson: JSON.stringify(locjson),
+        targetLanguage: smartcatCode,
+      })
+      queued++
+      log({
+        level: 'success',
+        indent: true,
+        message: `${targetSanityId} → ${smartcatCode}: queued ${locjson.units.length} unit(s), ${prefilled} with existing translation`,
+      })
+    }
+    if (queued === 0) log({level: 'skip', indent: true, message: 'no translatable content — not sent'})
+  }
+  for (const item of items) {
+    const rawDoc = item.doc
+    if (!rawDoc) continue
     // Serialize under the canonical (bare) id so identity, metadata and progress
     // stay stable, even when the *content* came from the draft. Mark draft-sourced
     // files so they're recognizable in Smartcat.
     const isDraft = rawDoc._id.startsWith('drafts.')
     const doc = isDraft ? {...rawDoc, _id: publishedId(rawDoc._id)} : rawDoc
     const name = resolveDocumentTitle(schema, doc)
-    log({level: 'info', message: `${name || doc._id}  ·  ${doc._type}${isDraft ? ' (draft)' : ''}`})
+    const sendExisting = item.sendExistingTranslations === true
+    log({
+      level: 'info',
+      message: `${name || doc._id}  ·  ${doc._type}${isDraft ? ' (draft)' : ''}${sendExisting ? ' · sending existing translations' : ''}`,
+    })
     try {
       const fields = fieldsFor(doc._type)
+      if (sendExisting) {
+        queueBilingual(doc, name, fields, isDraft)
+        continue
+      }
       // Fields skipped because they hold a block type that can't be serialized
       // (e.g. a custom `table`): left untranslated on purpose, reported as errors
       // below so the editor knows to act rather than lose content silently.