@smartcat/sanity-plugin 1.0.0 → 1.0.1

package/src/import/index.ts

@@ -0,0 +1,418 @@
+import type {SmartcatDocument, SmartcatProject} from '../smartcat/types'
+import {buildProgress, hasConfirmedContent, itemsFromProject, type DocProgress} from '../progress/core'
+import {itemDocDeref} from '../lib/projectItems'
+import type {SmartcatLanguageMapping} from '../lib/languageMap'
+import type {LogLine} from '../lib/log'
+
+/** The Smartcat document's full path (folder + filename), extension stripped. */
+function smartcatDocPath(scDoc: SmartcatDocument | undefined): string {
+  const raw = scDoc?.fullPath || scDoc?.name || scDoc?.filename || ''
+  return raw.replace(/\.[^./]+$/, '')
+}
+
+/** Minimal structural subset of @sanity/client used by the import download. */
+export interface SanityLikeClient {
+  fetch<T = unknown>(query: string, params?: Record<string, unknown>): Promise<T>
+  patch(id: string): {
+    set(attrs: Record<string, unknown>): {commit(): Promise<unknown>}
+  }
+}
+
+/** Structural subset of SmartcatClient the import download needs. */
+export interface SmartcatImportClient {
+  getProject(projectId: string): Promise<SmartcatProject>
+  exportDocument(documentId: string): Promise<string>
+  /**
+   * Batch export: one Smartcat task for many documents (ZIP result). Optional
+   * so custom/legacy clients keep working — without it every document falls
+   * back to a single {@link exportDocument} round-trip.
+   */
+  exportDocumentsBatch?(documentIds: string[]): Promise<{filename: string; content: string}[]>
+}
+
+export interface RunImportDownloadOptions {
+  sanity: SanityLikeClient
+  smartcat: SmartcatImportClient
+  /** `_id` of the `smartcat.translationProject` to import. */
+  projectId: string
+  now?: () => string
+  /** Documents per Smartcat batch-export task. */
+  batchSize?: number
+  /**
+   * Soft cap on the total LocJSON bytes stored in the project's `inbox` per
+   * run. The inbox lives on the Sanity project document, which has a practical
+   * size limit — targets beyond the cap are reported as `remaining` and picked
+   * up by the next import run.
+   */
+  maxInboxBytes?: number
+  /** How many batch-export tasks run against Smartcat concurrently. */
+  concurrency?: number
+  /**
+   * Soft time budget for the download phase, in ms. Once exceeded, batches not
+   * yet started are deferred as `remaining` and the run exits cleanly — so the
+   * Function always finishes well before its hard platform timeout instead of
+   * being killed mid-run (which would leave the project stuck in "importing").
+   */
+  timeBudgetMs?: number
+  /** Clock override for tests (ms). */
+  nowMs?: () => number
+  /**
+   * Receives every log line as it is emitted (in addition to the functionLog
+   * stored on the project document) — the Function forwards these to console
+   * so `sanity functions logs` shows the run without reading the document.
+   */
+  onLog?: (line: LogLine) => void
+}
+
+export interface RunImportDownloadResult {
+  /** Number of complete targets downloaded into the inbox. */
+  downloaded: number
+  /** Number of targets skipped because they are not yet fully translated. */
+  skipped: number
+  /** Targets ready to download but deferred to the next run (inbox size cap). */
+  remaining: number
+  /** Targets already imported in a previous run and therefore not re-downloaded. */
+  alreadyImported: number
+}
+
+const DEFAULT_BATCH_SIZE = 50
+/** Keeps the project document comfortably below Sanity's document size limits. */
+const DEFAULT_MAX_INBOX_BYTES = 1_500_000
+/**
+ * Parallel Smartcat export tasks. High enough to divide the download time ~4×,
+ * low enough not to crowd the account's export-task queue.
+ */
+const DEFAULT_CONCURRENCY = 4
+/** Exit-early margin against the 15-minute Sanity Function timeout. */
+const DEFAULT_TIME_BUDGET_MS = 10 * 60_000
+
+const PROJECT_QUERY = `*[_id == $id][0]{
+  _id,
+  smartcatProjectId,
+  smartcatLanguages[]{sanityId, smartcatLanguage},
+  "items": items[]{ "doc": ${itemDocDeref('{_id, title}')} },
+  progress[]{_key, sourceDocId, title, targets[]{_key, language, smartcatDocumentId, stages, complete, imported, syncedAt}}
+}`
+
+interface ProjectData {
+  _id: string
+  smartcatProjectId?: string
+  smartcatLanguages?: SmartcatLanguageMapping[]
+  items?: {doc: {_id: string; title?: string} | null}[]
+  progress?: DocProgress[]
+}
+
+interface InboxItem {
+  _key: string
+  sourceDocId: string
+  targetLanguage: string
+  smartcatDocumentId: string
+  locjson: string
+}
+
+/** A (document × language) target selected for download this run. */
+interface ReadyTarget {
+  key: string
+  sourceDocId: string
+  language: string
+  smartcatDocumentId: string
+  label: string
+}
+
+function stripDraft(id: string): string {
+  return id.replace(/^drafts\./, '')
+}
+
+/** The Sanity source-document id a LocJSON carries in its `x-sanity` metadata. */
+function sanityDocIdOf(locjson: string): string | undefined {
+  try {
+    const parsed = JSON.parse(locjson) as {properties?: {'x-sanity'?: {documentId?: string}}}
+    return parsed.properties?.['x-sanity']?.documentId
+  } catch {
+    return undefined
+  }
+}
+
+interface BatchDownloadResult {
+  files: {target: ReadyTarget; locjson: string}[]
+  /** Targets fetched one-by-one because the batched call failed or its archive missed them. */
+  fallbackCount: number
+  /** The batched export call itself failed (the error line is already emitted). */
+  batchFailed: boolean
+}
+
+/**
+ * Downloads a batch of same-language targets. Uses one batched export task
+ * (ZIP) when the client supports it, correlating each returned file back to
+ * its target via the LocJSON's own `x-sanity.documentId`. Targets the archive
+ * didn't cover — and the whole batch when the batched call fails — fall back
+ * to per-document exports, so a batch problem degrades to the old (slow but
+ * proven) path instead of failing the run. Every degradation is logged loudly:
+ * a silent fallback looks exactly like "batching deployed but nothing faster".
+ */
+async function downloadBatch(
+  smartcat: SmartcatImportClient,
+  batch: ReadyTarget[],
+  emit: (line: LogLine) => void,
+): Promise<BatchDownloadResult> {
+  const contentByTarget = new Map<ReadyTarget, string>()
+  const batchAttempted = Boolean(smartcat.exportDocumentsBatch && batch.length > 1)
+  let batchFailed = false
+
+  if (batchAttempted) {
+    try {
+      const files = await smartcat.exportDocumentsBatch!(batch.map((t) => t.smartcatDocumentId))
+      const targetByDocId = new Map(batch.map((t) => [stripDraft(t.sourceDocId), t]))
+      for (const file of files) {
+        const docId = sanityDocIdOf(file.content)
+        const target = docId ? targetByDocId.get(stripDraft(docId)) : undefined
+        if (target && !contentByTarget.has(target)) contentByTarget.set(target, file.content)
+      }
+      if (contentByTarget.size < batch.length) {
+        emit({
+          level: 'info',
+          message: `${batch.length - contentByTarget.size} of ${batch.length} file(s) missing from the batch archive — fetching them per-document`,
+        })
+      }
+    } catch (err) {
+      batchFailed = true
+      emit({
+        level: 'error',
+        message: `Batch export of ${batch.length} document(s) failed — falling back to per-document export: ${err instanceof Error ? err.message : String(err)}`,
+      })
+    }
+  }
+
+  const files: {target: ReadyTarget; locjson: string}[] = []
+  let fallbackCount = 0
+  for (const target of batch) {
+    let locjson = contentByTarget.get(target)
+    if (locjson === undefined) {
+      locjson = await smartcat.exportDocument(target.smartcatDocumentId)
+      if (batchAttempted) fallbackCount++
+    }
+    files.push({target, locjson})
+  }
+  return {files, fallbackCount, batchFailed}
+}
+
+/**
+ * Thin import step run by a Sanity Function: refreshes per-stage progress from
+ * Smartcat, then downloads the ready targets into the project's `inbox` and
+ * sets status to `downloaded`. The browser turns the inbox into locale
+ * variants and decides final completion.
+ *
+ * Downloads happen in **batches** (one Smartcat export task per ~50 documents,
+ * returned as a ZIP), so run time no longer scales with per-document polling —
+ * large projects fit comfortably inside the Function timeout. The inbox is
+ * size-capped per run; overflow targets are reported as `remaining` and the
+ * next import run picks them up (already-imported targets are skipped).
+ *
+ * Targets with nothing confirmed are skipped, so no untranslated variants are
+ * created. Does no content processing, so it depends only on the Smartcat client.
+ */
+export async function runImportDownload(
+  options: RunImportDownloadOptions,
+): Promise<RunImportDownloadResult> {
+  const {
+    sanity,
+    smartcat,
+    projectId,
+    now = () => new Date().toISOString(),
+    batchSize = DEFAULT_BATCH_SIZE,
+    maxInboxBytes = DEFAULT_MAX_INBOX_BYTES,
+    concurrency = DEFAULT_CONCURRENCY,
+    timeBudgetMs = DEFAULT_TIME_BUDGET_MS,
+    nowMs = Date.now,
+    onLog,
+  } = options
+  const log: LogLine[] = []
+  const emit = (line: LogLine) => {
+    log.push(line)
+    onLog?.(line)
+  }
+
+  const project = await sanity.fetch<ProjectData | null>(PROJECT_QUERY, {id: projectId})
+  if (!project) throw new Error(`Translation project ${projectId} not found`)
+
+  try {
+    if (!project.smartcatProjectId) {
+      throw new Error('Project has no smartcatProjectId — export it first')
+    }
+
+    const timestamp = now()
+    const scProject = await smartcat.getProject(project.smartcatProjectId)
+    emit({level: 'info', message: 'Checking Smartcat for completed translations'})
+    // Look up each target's Smartcat document by its id, for full-path logging.
+    const scDocById = new Map((scProject.documents ?? []).filter((d) => d.id).map((d) => [d.id, d]))
+
+    // Rebuild progress from Smartcat + the project's items, so the dashboard
+    // reflects the latest state even for targets we don't import this round.
+    const progress = buildProgress(
+      itemsFromProject(project),
+      scProject,
+      project.progress,
+      timestamp,
+      project.smartcatLanguages,
+    )
+
+    // Collect every target that has confirmed content (at any stage); targets
+    // with nothing confirmed are skipped. Targets already imported in an
+    // earlier run are not re-downloaded, so capped runs make forward progress.
+    const ready: ReadyTarget[] = []
+    let skipped = 0
+    let alreadyImported = 0
+    for (const docProgress of progress) {
+      for (const target of docProgress.targets) {
+        const id = target.smartcatDocumentId
+        // Prefer the Smartcat full path; fall back to the resolved title / source id.
+        const label =
+          (id && smartcatDocPath(scDocById.get(id))) || docProgress.title || docProgress.sourceDocId
+        if (!id || !hasConfirmedContent(target.stages)) {
+          if (id && !target.imported) {
+            skipped++
+            emit({level: 'skip', message: `${label} (Smartcat ID: ${id}) → ${target.language}: not ready, skipped`})
+          }
+          continue
+        }
+        if (target.imported) {
+          alreadyImported++
+          continue
+        }
+        ready.push({
+          key: target._key,
+          sourceDocId: docProgress.sourceDocId,
+          language: target.language,
+          smartcatDocumentId: id,
+          label,
+        })
+      }
+    }
+
+    // Download in batches: one Smartcat export task per batch (ZIP result)
+    // instead of a request+poll round-trip per document. Batches are grouped
+    // by language so each source document appears at most once per archive.
+    const inbox: InboxItem[] = []
+    let inboxBytes = 0
+    let remaining = 0
+    const byLanguage = new Map<string, ReadyTarget[]>()
+    for (const target of ready) {
+      const group = byLanguage.get(target.language) ?? []
+      group.push(target)
+      byLanguage.set(target.language, group)
+    }
+
+    const batches: ReadyTarget[][] = []
+    for (const group of byLanguage.values()) {
+      for (let i = 0; i < group.length; i += batchSize) {
+        batches.push(group.slice(i, i + batchSize))
+      }
+    }
+
+    // Worker pool: up to `concurrency` batch-export tasks in flight at once —
+    // Smartcat assembles the archives in parallel, dividing the download time.
+    // Each worker re-checks the caps before claiming the next batch:
+    // - inbox byte cap: the inbox lives on the project document, which must
+    //   stay below Sanity's document size limit;
+    // - time budget: exit cleanly before the platform kills the Function, so a
+    //   slow Smartcat day degrades to "continue in the next run", never to a
+    //   project stuck in "importing".
+    const effectiveConcurrency = Math.max(1, Math.min(concurrency, batches.length))
+    if (batches.length > 0) {
+      emit({
+        level: 'info',
+        message: `Downloading ${ready.length} target(s) in ${batches.length} batch(es) of up to ${batchSize}, ${effectiveConcurrency} in parallel`,
+      })
+    }
+    const startedAtMs = nowMs()
+    let deferredByBytes = 0
+    let deferredByTime = 0
+    let fallbackDownloads = 0
+    let failedBatches = 0
+    let nextBatch = 0
+    const worker = async () => {
+      while (nextBatch < batches.length) {
+        const index = nextBatch++
+        const batch = batches[index]
+        if (inboxBytes >= maxInboxBytes) {
+          deferredByBytes += batch.length
+          continue
+        }
+        if (nowMs() - startedAtMs >= timeBudgetMs) {
+          deferredByTime += batch.length
+          continue
+        }
+        const batchStartMs = nowMs()
+        const {files, fallbackCount, batchFailed} = await downloadBatch(smartcat, batch, emit)
+        fallbackDownloads += fallbackCount
+        if (batchFailed) failedBatches++
+        for (const {target, locjson} of files) {
+          inbox.push({
+            _key: target.key,
+            sourceDocId: target.sourceDocId,
+            targetLanguage: target.language,
+            smartcatDocumentId: target.smartcatDocumentId,
+            locjson,
+          })
+          inboxBytes += locjson.length
+        }
+        emit({
+          level: 'success',
+          message:
+            `Batch ${index + 1}/${batches.length} (${batch[0].language}): ${files.length} doc(s) in ` +
+            `${((nowMs() - batchStartMs) / 1000).toFixed(1)}s` +
+            `${fallbackCount ? ` — ${fallbackCount} via per-document fallback` : ''}`,
+        })
+      }
+    }
+    await Promise.all(Array.from({length: effectiveConcurrency}, worker))
+    remaining = deferredByBytes + deferredByTime
+
+    // One line that answers "where did the time go and why was anything left
+    // behind" — the silent-degradation postmortems start here.
+    if (ready.length > 0) {
+      emit({
+        level: failedBatches || fallbackDownloads ? 'error' : 'info',
+        message:
+          `Download phase: ${((nowMs() - startedAtMs) / 1000).toFixed(1)}s — ` +
+          `${batches.length} batch(es), ${failedBatches} failed, ${fallbackDownloads} per-document fallback download(s); ` +
+          `deferred ${deferredByBytes} (inbox size cap) + ${deferredByTime} (time budget)`,
+      })
+    }
+
+    emit({
+      level: 'info',
+      message:
+        `Downloaded ${inbox.length} target(s)` +
+        `${skipped ? `, skipped ${skipped} not ready` : ''}` +
+        `${alreadyImported ? `, ${alreadyImported} already imported` : ''}` +
+        `${remaining ? `, ${remaining} deferred — run Import again to continue` : ''}`,
+    })
+
+    await sanity
+      .patch(projectId)
+      .set({
+        inbox,
+        progress,
+        progressSyncedAt: timestamp,
+        status: 'downloaded',
+        // Deferred-target count for the dashboard: after applying this batch it
+        // auto-continues the import instead of asking for another click.
+        importRemaining: remaining,
+        lastError: null,
+        functionLog: JSON.stringify(log),
+      })
+      .commit()
+
+    return {downloaded: inbox.length, skipped, remaining, alreadyImported}
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    emit({level: 'error', message})
+    await sanity
+      .patch(projectId)
+      .set({status: 'error', lastError: message, lastImportAt: now(), functionLog: JSON.stringify(log)})
+      .commit()
+      .catch(() => {})
+    throw err
+  }
+}

package/src/index.ts

@@ -0,0 +1,63 @@
+import {definePlugin} from 'sanity'
+import {createTranslationProjectType} from './schema/translationProject'
+import {createSettingsType} from './schema/settings'
+import {createAddToProjectAction} from './actions/AddToProjectAction'
+import {createTranslationStatusInput} from './form/TranslationStatusInput'
+import {createTranslationsTool} from './tool'
+import {StudioInit} from './tool/StudioInit'
+import {resolveConfig} from './lib/resolveConfig'
+import type {SmartcatPluginConfig} from './types'
+
+export type {SmartcatPluginConfig, SmartcatLanguage, TranslationProjectStatus} from './types'
+// Re-exported so the `declare module 'sanity'` augmentation (adding
+// `options.smartcatTranslation`) is loaded for consumers of the plugin types.
+export type {SmartcatTranslationSchemaOptions} from './schema/translatableOptions'
+export {TRANSLATION_PROJECT_TYPE} from './lib/constants'
+
+/**
+ * Smartcat translation plugin for Sanity Studio.
+ *
+ * - Adds a `smartcat.translationProject` document type (a named set of items).
+ * - Adds an "Add to translation project" document action on the configured
+ *   `translatableTypes`.
+ * - Shows a status line on those types when the document belongs to one or more
+ *   translation projects.
+ *
+ * @public
+ */
+export const smartcatTranslation = definePlugin<SmartcatPluginConfig>((config) => {
+  // Resolve all config defaults once, here at the boundary; everything below
+  // receives concrete values.
+  const resolved = resolveConfig(config)
+  const projectType = createTranslationProjectType()
+  const settingsType = createSettingsType()
+  const addToProjectAction = createAddToProjectAction(resolved)
+  const translationStatusInput = createTranslationStatusInput(resolved)
+  const translationsTool = createTranslationsTool(resolved)
+
+  // The plugin's customizations apply to translatable types (all types by
+  // default), but never to the plugin's own `smartcat.*` documents.
+  const isTranslatable = resolved.isTranslatableType
+
+  return {
+    name: 'sanity-plugin-smartcat-translation',
+    schema: {
+      types: [projectType, settingsType],
+    },
+    studio: {
+      components: {
+        // Bootstraps the template cache on first Studio load.
+        layout: StudioInit,
+      },
+    },
+    tools: [translationsTool],
+    document: {
+      actions: (prev, context) => (isTranslatable(context.schemaType) ? [...prev, addToProjectAction] : prev),
+    },
+    form: {
+      components: {
+        input: translationStatusInput,
+      },
+    },
+  }
+})

package/src/lib/constants.ts

@@ -0,0 +1,23 @@
+/**
+ * Document type for a translation project (a named set of items to translate).
+ *
+ * @public
+ */
+export const TRANSLATION_PROJECT_TYPE = 'smartcat.translationProject'
+
+/** Singleton document holding workspace-wide Smartcat settings (template cache). */
+export const SETTINGS_TYPE = 'smartcat.settings'
+
+/** Fixed `_id` of the settings singleton. */
+export const SETTINGS_DOC_ID = 'smartcat.settings'
+
+/** Sanity API version used by the plugin's client calls. */
+export const API_VERSION = '2025-02-01'
+
+/** Resolves the configured source language, failing if it's not set. */
+export function requireSourceLanguage(sourceLanguage: string | undefined): string {
+  if (!sourceLanguage) {
+    throw new Error('Smartcat plugin: `sourceLanguage` is not configured')
+  }
+  return sourceLanguage
+}

package/src/lib/documentTitle.test.ts

@@ -0,0 +1,43 @@
+import {describe, expect, it} from 'vitest'
+import {Schema} from '@sanity/schema'
+import {resolveDocumentTitle} from './documentTitle'
+
+// A `page` whose title is a field-level internationalized array and whose preview
+// selects a plain-string `internalName` — the shape that crashed React #31.
+const schema = Schema.compile({
+  name: 'test',
+  types: [
+    {name: 'internationalizedArrayStringValue', type: 'object', fields: [{name: 'value', type: 'string'}]},
+    {name: 'internationalizedArrayString', type: 'array', of: [{type: 'internationalizedArrayStringValue'}]},
+    {
+      name: 'page',
+      type: 'document',
+      fields: [
+        {name: 'internalName', type: 'string'},
+        {name: 'title', type: 'internationalizedArrayString'},
+      ],
+      preview: {select: {title: 'internalName'}},
+    },
+  ],
+})
+
+const localizedTitle = [
+  {_key: 'en', _type: 'internationalizedArrayStringValue', language: 'en', value: 'About us'},
+]
+
+describe('resolveDocumentTitle', () => {
+  it('returns the schema preview title, never the localized array', () => {
+    const title = resolveDocumentTitle(schema, {_type: 'page', internalName: 'About', title: localizedTitle})
+    expect(title).toBe('About')
+    expect(typeof title).toBe('string')
+  })
+
+  it('returns undefined (not the array object) when no string title resolves', () => {
+    const title = resolveDocumentTitle(schema, {_type: 'page', title: localizedTitle})
+    expect(title).toBeUndefined()
+  })
+
+  it('returns undefined for an unknown type', () => {
+    expect(resolveDocumentTitle(schema, {_type: 'nope'})).toBeUndefined()
+  })
+})

package/src/lib/documentTitle.ts

@@ -0,0 +1,30 @@
+import {prepareForPreview} from 'sanity'
+
+/** Fallback label for a document whose schema preview yields no title. */
+export const UNTITLED = 'Untitled'
+
+/** Minimal schema shape: just enough to look a type up by name. */
+export interface TitleSchema {
+  get(typeName: string): unknown
+}
+
+/**
+ * Document display title, resolved the Sanity-native way — by running the schema
+ * type's `preview.prepare` (same as the Studio list/structure tree) — so types
+ * without a literal `title` field (e.g. field-level i18n) get a real label. Always
+ * returns a string or `undefined`, never a raw field value (an internationalized
+ * array is an object that crashes React #31 if rendered as a child).
+ */
+export function resolveDocumentTitle(
+  schema: TitleSchema,
+  doc: Record<string, unknown> & {_type: string},
+): string | undefined {
+  const type = schema.get(doc._type)
+  if (!type) return undefined
+  try {
+    const preview = prepareForPreview(doc as never, type as never)
+    return typeof preview?.title === 'string' ? preview.title : undefined
+  } catch {
+    return undefined
+  }
+}

package/src/lib/languageMap.test.ts

@@ -0,0 +1,56 @@
+import {describe, expect, it} from 'vitest'
+import {
+  buildLanguageMappings,
+  findDuplicateSmartcatLanguages,
+  toSanityLanguage,
+  toSmartcatLanguage,
+} from './languageMap'
+
+const LANGUAGES = [
+  {id: 'en', title: 'English'},
+  {id: 'fr', title: 'French'},
+  {id: 'PL-PL', title: 'Polish', smartcatLanguage: 'pl'},
+]
+
+describe('buildLanguageMappings', () => {
+  it('resolves each id to its smartcatLanguage, defaulting to the id', () => {
+    expect(buildLanguageMappings(LANGUAGES, ['en', 'PL-PL'])).toEqual([
+      {sanityId: 'en', smartcatLanguage: 'en'},
+      {sanityId: 'PL-PL', smartcatLanguage: 'pl'},
+    ])
+  })
+
+  it('falls back to the id for languages not in the config', () => {
+    expect(buildLanguageMappings(LANGUAGES, ['de'])).toEqual([{sanityId: 'de', smartcatLanguage: 'de'}])
+  })
+})
+
+describe('toSmartcatLanguage / toSanityLanguage', () => {
+  const mappings = buildLanguageMappings(LANGUAGES, ['en', 'PL-PL'])
+
+  it('maps forward and inverse', () => {
+    expect(toSmartcatLanguage(mappings, 'PL-PL')).toBe('pl')
+    expect(toSanityLanguage(mappings, 'pl')).toBe('PL-PL')
+  })
+
+  it('is identity for unmapped values or no mapping', () => {
+    expect(toSmartcatLanguage(mappings, 'de')).toBe('de')
+    expect(toSanityLanguage(mappings, 'de')).toBe('de')
+    expect(toSmartcatLanguage(undefined, 'fr')).toBe('fr')
+    expect(toSanityLanguage(undefined, 'fr')).toBe('fr')
+  })
+})
+
+describe('findDuplicateSmartcatLanguages', () => {
+  it('returns nothing when all codes are distinct', () => {
+    expect(findDuplicateSmartcatLanguages(buildLanguageMappings(LANGUAGES, ['en', 'fr', 'PL-PL']))).toEqual([])
+  })
+
+  it('groups Sanity ids that collapse to the same code', () => {
+    const dups = findDuplicateSmartcatLanguages([
+      {sanityId: 'PL-PL', smartcatLanguage: 'pl'},
+      {sanityId: 'pl', smartcatLanguage: 'pl'},
+    ])
+    expect(dups).toEqual([{smartcatLanguage: 'pl', sanityIds: ['PL-PL', 'pl']}])
+  })
+})