@smartcat/sanity-plugin 1.0.0 → 1.0.1

package/src/tool/processing.test.ts

@@ -0,0 +1,623 @@
+import {beforeAll, describe, expect, it} from 'vitest'
+import {Schema} from '@sanity/schema'
+import {JSDOM} from 'jsdom'
+import {applyImportedTranslations, prepareExport, type ProcessingClient} from './processing'
+
+// processing.ts uses the browser's global DOMParser; provide one via jsdom.
+beforeAll(() => {
+  ;(globalThis as {DOMParser?: unknown}).DOMParser = new JSDOM().window.DOMParser
+})
+
+const schema = Schema.compile({
+  name: 'test',
+  types: [
+    {
+      type: 'document',
+      name: 'page',
+      fields: [
+        {name: 'language', type: 'string', options: {documentInternationalization: {exclude: true}}},
+        {name: 'title', type: 'string'},
+        {name: 'body', type: 'array', of: [{type: 'block'}]},
+      ],
+    },
+  ],
+})
+
+const faqSchema = Schema.compile({
+  name: 'faqTest',
+  types: [
+    {name: 'internationalizedArrayStringValue', type: 'object', fields: [{name: 'value', type: 'string'}]},
+    {name: 'internationalizedArrayString', type: 'array', of: [{type: 'internationalizedArrayStringValue'}]},
+    {
+      name: 'internationalizedArraySimpleBlockContentValue',
+      type: 'object',
+      fields: [{name: 'value', type: 'array', of: [{type: 'block'}]}],
+    },
+    {
+      name: 'internationalizedArraySimpleBlockContent',
+      type: 'array',
+      of: [{type: 'internationalizedArraySimpleBlockContentValue'}],
+    },
+    {
+      name: 'faq',
+      type: 'document',
+      fields: [
+        {name: 'question', type: 'internationalizedArrayString'},
+        {name: 'answer', type: 'internationalizedArraySimpleBlockContent'},
+        {name: 'metadata', type: 'internationalizedArrayString'},
+      ],
+    },
+  ],
+})
+
+const block = (text: string) => ({
+  _type: 'block',
+  _key: 'b1',
+  style: 'normal',
+  markDefs: [],
+  children: [{_type: 'span', _key: 's1', text, marks: []}],
+})
+
+const sourceDoc = {
+  _id: 'page-1',
+  _type: 'page',
+  _rev: 'r1',
+  language: 'en',
+  title: 'About Us',
+  body: [block('We build delightful things.')],
+}
+
+/** Routing fake client with a record of creates/patches. */
+function makeClient(opts: {project: unknown; source?: unknown; draft?: unknown}) {
+  const created: Record<string, unknown>[] = []
+  const ensured: Record<string, unknown>[] = []
+  const patches: Record<string, unknown>[] = []
+  let metadata: {_id: string; translations: unknown[]} | null = null
+  const client: ProcessingClient = {
+    fetch: (async (query: string, params?: Record<string, unknown>) => {
+      if (query.includes('translation.metadata')) return metadata
+      if (query.includes('items[]') || query.includes('inbox[]')) return opts.project
+      // A draft is served when provided (its id carries the `drafts.` prefix).
+      if (opts.draft && params?.id === (opts.draft as {_id?: string})?._id) return opts.draft
+      if (params?.id === (opts.source as {_id?: string})?._id) return opts.source
+      return null
+    }) as never,
+    create: async (doc) => {
+      const _id = (doc._id as string) ?? (doc._type === 'translation.metadata' ? 'meta-1' : 'variant-1')
+      created.push(doc)
+      if (doc._type === 'translation.metadata') metadata = {_id, translations: doc.translations as unknown[]}
+      return {_id}
+    },
+    // Draft seeding; tracked apart from real creates so `created` reflects only
+    // new variant/metadata documents.
+    createIfNotExists: async (doc) => {
+      ensured.push(doc)
+      return {_id: doc._id as string}
+    },
+    patch: (id: string) => {
+      const attrs: Record<string, unknown> = {__patchTarget: id}
+      const p = {
+        set: (a: Record<string, unknown>) => (Object.assign(attrs, a), p),
+        setIfMissing: () => p,
+        insert: () => p,
+        unset: () => p,
+        commit: async () => (patches.push(attrs), {}),
+      }
+      return p
+    },
+  }
+  return {client, created, ensured, patches, getMetadata: () => metadata}
+}
+
+const LANGUAGES = [
+  {id: 'en', title: 'English'},
+  {id: 'fr', title: 'French'},
+  {id: 'PL-PL', title: 'Polish', smartcatLanguage: 'pl'},
+]
+
+describe('prepareExport', () => {
+  it('serializes items into outbox in schema order, with status queued', async () => {
+    const {client, patches} = makeClient({project: {sourceLanguage: 'en', items: [{doc: sourceDoc}]}})
+
+    const {prepared} = await prepareExport({
+      client,
+      schema,
+      projectId: 'p1',
+      targetLanguages: ['fr'],
+      sourceLanguage: 'en',
+      languages: LANGUAGES,
+      fieldLanguageKey: 'language',
+    })
+
+    expect(prepared).toBe(1)
+    const set = patches.at(-1)!
+    expect(set.status).toBe('queued')
+    expect(set.targetLanguages).toEqual(['fr'])
+
+    const outbox = set.outbox as {filename: string; locjson: string}[]
+    expect(outbox[0].filename).toBe('page/About Us-page-1.locjson')
+    const locjson = JSON.parse(outbox[0].locjson)
+    expect(locjson.units.map((u: {key: string}) => u.key)).toEqual(['title', 'body']) // schema order
+    expect(locjson.properties['x-sanity'].documentId).toBe('page-1')
+  })
+
+  const table = {_type: 'table', _key: 't1', rows: [{_key: 'r1', _type: 'tableRow', cells: ['A', 'B']}]}
+
+  it('leaves out a field with an unserializable block but still sends the rest of the document', async () => {
+    const doc = {_id: 'page-2', _type: 'page', language: 'en', title: 'About Us', body: [block('Intro.'), table]}
+    const {client, patches} = makeClient({project: {sourceLanguage: 'en', items: [{doc}]}})
+    const logs: {level: string; message: string}[] = []
+
+    const {prepared} = await prepareExport({
+      client, schema, projectId: 'p1', targetLanguages: ['fr'], sourceLanguage: 'en',
+      languages: LANGUAGES, fieldLanguageKey: 'language', onLog: (l) => logs.push(l),
+    })
+
+    expect(prepared).toBe(1)
+    const outbox = patches.at(-1)!.outbox as {locjson: string}[]
+    const locjson = JSON.parse(outbox[0].locjson)
+    expect(locjson.units.map((u: {key: string}) => u.key)).toEqual(['title']) // body left out
+    expect(logs.some((l) => l.level === 'error' && /Body: not translated.*table/.test(l.message))).toBe(true)
+  })
+
+  it('does not emit a zero-unit LocJSON when the only content is in an unserializable field', async () => {
+    // A single-field document whose one field can't be serialized: it must not be
+    // sent at all (no empty LocJSON), and the whole document is flagged.
+    const doc = {_id: 'page-3', _type: 'page', language: 'en', title: '', body: [table]}
+    const {client, patches} = makeClient({project: {sourceLanguage: 'en', items: [{doc}]}})
+    const logs: {level: string; message: string}[] = []
+
+    const {prepared} = await prepareExport({
+      client, schema, projectId: 'p1', targetLanguages: ['fr'], sourceLanguage: 'en',
+      languages: LANGUAGES, fieldLanguageKey: 'language', onLog: (l) => logs.push(l),
+    })
+
+    expect(prepared).toBe(0)
+    expect(patches.at(-1)!.outbox).toEqual([]) // nothing sent — no empty LocJSON
+    expect(logs.some((l) => l.level === 'error' && /not sent — its only translatable content/.test(l.message))).toBe(true)
+  })
+
+  it('stamps the id → Smartcat-code mapping for source + targets onto the project', async () => {
+    const {client, patches} = makeClient({project: {sourceLanguage: 'en', items: [{doc: sourceDoc}]}})
+
+    await prepareExport({
+      client,
+      schema,
+      projectId: 'p1',
+      targetLanguages: ['fr', 'PL-PL'],
+      sourceLanguage: 'en',
+      languages: LANGUAGES,
+      fieldLanguageKey: 'language',
+    })
+
+    expect(patches.at(-1)!.smartcatLanguages).toEqual([
+      {sanityId: 'en', smartcatLanguage: 'en'},
+      {sanityId: 'fr', smartcatLanguage: 'fr'},
+      {sanityId: 'PL-PL', smartcatLanguage: 'pl'},
+    ])
+  })
+
+  it('rejects targets that collapse to the same Smartcat code', async () => {
+    const {client} = makeClient({project: {sourceLanguage: 'en', items: [{doc: sourceDoc}]}})
+
+    await expect(
+      prepareExport({
+        client,
+        schema,
+        projectId: 'p1',
+        targetLanguages: ['PL-PL', 'pl'],
+        sourceLanguage: 'en',
+        languages: [...LANGUAGES, {id: 'pl', title: 'Polish (plain)', smartcatLanguage: 'pl'}],
+        fieldLanguageKey: 'language',
+      }),
+    ).rejects.toThrow(/same Smartcat language/i)
+  })
+})
+
+describe('applyImportedTranslations', () => {
+  it('turns inbox LocJSON into a locale variant + metadata, status completed', async () => {
+    // Produce LocJSON via prepareExport, then feed it back as a translated inbox item.
+    const exp = makeClient({project: {sourceLanguage: 'en', items: [{doc: sourceDoc}]}})
+    await prepareExport({client: exp.client, schema, projectId: 'p1', targetLanguages: ['fr'], sourceLanguage: 'en', languages: LANGUAGES, fieldLanguageKey: 'language'})
+    const outbox = exp.patches.at(-1)!.outbox as {locjson: string}[]
+    const locjson = JSON.parse(outbox[0].locjson)
+    // Simulate translation: copy source → target.
+    locjson.units.forEach((u: {source: string[]; target: string[]}) => (u.target = [...u.source]))
+
+    const {client, created, patches, getMetadata} = makeClient({
+      project: {
+        sourceLanguage: 'en',
+        inbox: [{sourceDocId: 'page-1', targetLanguage: 'fr', locjson: JSON.stringify(locjson)}],
+        // Single complete target → importing it should complete the project.
+        progress: [
+          {
+            _key: 'd1',
+            sourceDocId: 'page-1',
+            targets: [{_key: 'page-1__fr', language: 'fr', stages: [{name: 'Translation', percent: 100}], complete: true, imported: false}],
+          },
+        ],
+      },
+      source: sourceDoc,
+    })
+
+    const {imported, status} = await applyImportedTranslations({client, schema, projectId: 'p1', documentLanguageField: 'language', fieldLanguageKey: 'language'})
+    expect(imported).toBe(1)
+    expect(status).toBe('completed')
+
+    const variant = created.find((d) => d._type === 'page')!
+    expect(variant.language).toBe('fr')
+    expect(variant.title).toBe('About Us')
+    // The new variant is created as a draft so it accumulates for review.
+    expect(variant._id).toMatch(/^drafts\./)
+    const body = variant.body as Array<Record<string, unknown>>
+    expect(body[0]._key).toBeTruthy()
+
+    expect((getMetadata()!.translations as {language: string}[]).map((t) => t.language)).toEqual(['en', 'fr'])
+    expect(patches.at(-1)!.status).toBe('completed')
+  })
+
+  it('field-level: patches the same document inline, no variant or metadata', async () => {
+    const faqDoc = {
+      _id: 'faq-1',
+      _type: 'faq',
+      question: [{_key: 'q-en', _type: 'internationalizedArrayStringValue', language: 'en', value: 'How?'}],
+      answer: [
+        {
+          _key: 'a-en',
+          _type: 'internationalizedArraySimpleBlockContentValue',
+          language: 'en',
+          value: [block('Like this.')],
+        },
+      ],
+    }
+
+    // Produce LocJSON via prepareExport, then feed it back as a translated inbox item.
+    const exp = makeClient({project: {sourceLanguage: 'en', items: [{doc: faqDoc}]}})
+    await prepareExport({client: exp.client, schema: faqSchema, projectId: 'p1', targetLanguages: ['fr'], sourceLanguage: 'en', languages: LANGUAGES, fieldLanguageKey: 'language'})
+    const outbox = exp.patches.at(-1)!.outbox as {locjson: string}[]
+    const locjson = JSON.parse(outbox[0].locjson)
+    locjson.units.forEach((u: {key: string; source: string[]; target: string[]}) => {
+      u.target = u.key === 'question' ? ['Comment ?'] : [...u.source]
+    })
+
+    const {client, created, ensured, patches} = makeClient({
+      project: {
+        sourceLanguage: 'en',
+        inbox: [{sourceDocId: 'faq-1', targetLanguage: 'fr', locjson: JSON.stringify(locjson)}],
+        progress: [
+          {
+            _key: 'd1',
+            sourceDocId: 'faq-1',
+            targets: [{_key: 'faq-1__fr', language: 'fr', stages: [{name: 'Translation', percent: 100}], complete: true, imported: false}],
+          },
+        ],
+      },
+      source: faqDoc,
+    })
+
+    const {imported, status} = await applyImportedTranslations({client, schema: faqSchema, projectId: 'p1', documentLanguageField: 'language', fieldLanguageKey: 'language'})
+    expect(imported).toBe(1)
+    expect(status).toBe('completed')
+
+    // No locale variant document and no translation.metadata were created.
+    expect(created).toHaveLength(0)
+
+    // The write targets the document's DRAFT, seeded from the published version
+    // (no draft existed), so the published doc is left untouched.
+    expect(ensured.map((d) => d._id)).toContain('drafts.faq-1')
+    const docPatch = patches.find((p) => 'question' in p)!
+    expect(docPatch.__patchTarget).toBe('drafts.faq-1')
+    const question = docPatch.question as {language: string; value: unknown; _key: string}[]
+    expect(question.map((m) => m.language)).toEqual(['en', 'fr'])
+    expect(question.find((m) => m.language === 'fr')!.value).toBe('Comment ?')
+    expect(question.find((m) => m.language === 'en')!._key).toBe('q-en')
+
+    const answer = docPatch.answer as {_key: string; language: string; value: Array<Record<string, unknown>>}[]
+    const fr = answer.find((m) => m.language === 'fr')!
+    expect(fr._key).toBeTruthy()
+    expect((fr.value[0].children as Array<{text: string}>)[0].text).toBe('Like this.')
+  })
+
+  it('field-level: skips a member whose translated value is unchanged', async () => {
+    // The doc already has a French member equal to what the import would write,
+    // so no document patch should be made.
+    const faqDoc = {
+      _id: 'faq-1',
+      _type: 'faq',
+      question: [
+        {_key: 'q-en', _type: 'internationalizedArrayStringValue', language: 'en', value: 'How?'},
+        {_key: 'q-fr', _type: 'internationalizedArrayStringValue', language: 'fr', value: 'How?'},
+      ],
+    }
+
+    const exp = makeClient({project: {sourceLanguage: 'en', items: [{doc: faqDoc}]}})
+    await prepareExport({client: exp.client, schema: faqSchema, projectId: 'p1', targetLanguages: ['fr'], sourceLanguage: 'en', languages: LANGUAGES, fieldLanguageKey: 'language'})
+    const outbox = exp.patches.at(-1)!.outbox as {locjson: string}[]
+    const locjson = JSON.parse(outbox[0].locjson)
+    // No actual translation: target mirrors source, so the value is identical.
+    locjson.units.forEach((u: {source: string[]; target: string[]}) => (u.target = [...u.source]))
+
+    const {client, patches} = makeClient({
+      project: {
+        sourceLanguage: 'en',
+        inbox: [{sourceDocId: 'faq-1', targetLanguage: 'fr', locjson: JSON.stringify(locjson)}],
+        progress: [
+          {_key: 'd1', sourceDocId: 'faq-1', targets: [{_key: 'faq-1__fr', language: 'fr', stages: [{name: 'Translation', percent: 100}], complete: true, imported: false}]},
+        ],
+      },
+      source: faqDoc,
+    })
+
+    const {imported} = await applyImportedTranslations({client, schema: faqSchema, projectId: 'p1', documentLanguageField: 'language', fieldLanguageKey: 'language'})
+    expect(imported).toBe(1)
+    // Nothing changed, so the source document was never patched.
+    expect(patches.find((p) => 'question' in p)).toBeUndefined()
+  })
+
+  it('field-level: accumulates onto an existing draft without re-seeding it', async () => {
+    const published = {
+      _id: 'faq-1',
+      _type: 'faq',
+      question: [{_key: 'q-en', _type: 'internationalizedArrayStringValue', language: 'en', value: 'How?'}],
+    }
+    // The editor already has a draft with an in-progress edit to the English value.
+    const draft = {
+      _id: 'drafts.faq-1',
+      _type: 'faq',
+      question: [{_key: 'q-en', _type: 'internationalizedArrayStringValue', language: 'en', value: 'How (edited)?'}],
+    }
+
+    const exp = makeClient({project: {sourceLanguage: 'en', items: [{doc: published}]}})
+    await prepareExport({client: exp.client, schema: faqSchema, projectId: 'p1', targetLanguages: ['fr'], sourceLanguage: 'en', languages: LANGUAGES, fieldLanguageKey: 'language'})
+    const outbox = exp.patches.at(-1)!.outbox as {locjson: string}[]
+    const locjson = JSON.parse(outbox[0].locjson)
+    locjson.units.forEach((u: {key: string; target: string[]}) => (u.target = ['Comment ?']))
+
+    const {client, ensured, patches} = makeClient({
+      project: {
+        sourceLanguage: 'en',
+        inbox: [{sourceDocId: 'faq-1', targetLanguage: 'fr', locjson: JSON.stringify(locjson)}],
+        progress: [
+          {_key: 'd1', sourceDocId: 'faq-1', targets: [{_key: 'faq-1__fr', language: 'fr', stages: [{name: 'Translation', percent: 100}], complete: true, imported: false}]},
+        ],
+      },
+      source: published,
+      draft,
+    })
+
+    await applyImportedTranslations({client, schema: faqSchema, projectId: 'p1', documentLanguageField: 'language', fieldLanguageKey: 'language'})
+
+    // A draft already existed, so it is NOT re-seeded from published…
+    expect(ensured).toHaveLength(0)
+    // …and the French member is appended onto the draft's array (preserving the
+    // editor's in-progress English edit).
+    const docPatch = patches.find((p) => 'question' in p)!
+    expect(docPatch.__patchTarget).toBe('drafts.faq-1')
+    const question = docPatch.question as {language: string; value: string}[]
+    expect(question.find((m) => m.language === 'en')!.value).toBe('How (edited)?')
+    expect(question.find((m) => m.language === 'fr')!.value).toBe('Comment ?')
+  })
+})
+
+describe('i18n language conventions', () => {
+  it('field-level v4: matches and writes members by _key, with no language field', async () => {
+    const faqDoc = {
+      _id: 'faq-1',
+      _type: 'faq',
+      question: [{_key: 'en', _type: 'internationalizedArrayStringValue', value: 'How?'}],
+      answer: [{_key: 'en', _type: 'internationalizedArraySimpleBlockContentValue', value: [block('Like this.')]}],
+    }
+
+    // Export reads the source member by _key.
+    const exp = makeClient({project: {sourceLanguage: 'en', items: [{doc: faqDoc}]}})
+    await prepareExport({
+      client: exp.client,
+      schema: faqSchema,
+      projectId: 'p1',
+      targetLanguages: ['fr'],
+      sourceLanguage: 'en',
+      languages: LANGUAGES,
+      fieldLanguageKey: '_key',
+    })
+    const outbox = exp.patches.at(-1)!.outbox as {locjson: string}[]
+    const locjson = JSON.parse(outbox[0].locjson)
+    expect(locjson.units.map((u: {key: string}) => u.key)).toEqual(['question', 'answer'])
+    locjson.units.forEach((u: {key: string; source: string[]; target: string[]}) => {
+      u.target = u.key === 'question' ? ['Comment ?'] : [...u.source]
+    })
+
+    const {client, patches} = makeClient({
+      project: {
+        sourceLanguage: 'en',
+        inbox: [{sourceDocId: 'faq-1', targetLanguage: 'fr', locjson: JSON.stringify(locjson)}],
+        progress: [
+          {
+            _key: 'd1',
+            sourceDocId: 'faq-1',
+            targets: [{_key: 'faq-1__fr', language: 'fr', stages: [{name: 'Translation', percent: 100}], complete: true, imported: false}],
+          },
+        ],
+      },
+      source: faqDoc,
+    })
+    await applyImportedTranslations({client, schema: faqSchema, projectId: 'p1', documentLanguageField: 'language', fieldLanguageKey: '_key'})
+
+    const docPatch = patches.find((p) => 'question' in p)!
+    const question = docPatch.question as {_key: string; language?: string; value: unknown}[]
+    expect(question.map((m) => m._key)).toEqual(['en', 'fr']) // fr keyed by _key, en preserved
+    expect(question.find((m) => m._key === 'fr')!.value).toBe('Comment ?')
+    expect(question.every((m) => m.language === undefined)).toBe(true) // no language field written
+  })
+
+  it('document-level: creates the variant using a custom languageField', async () => {
+    const exp = makeClient({project: {sourceLanguage: 'en', items: [{doc: sourceDoc}]}})
+    await prepareExport({client: exp.client, schema, projectId: 'p1', targetLanguages: ['fr'], sourceLanguage: 'en', languages: LANGUAGES, fieldLanguageKey: 'language'})
+    const outbox = exp.patches.at(-1)!.outbox as {locjson: string}[]
+    const locjson = JSON.parse(outbox[0].locjson)
+    locjson.units.forEach((u: {source: string[]; target: string[]}) => (u.target = [...u.source]))
+
+    const {client, created} = makeClient({
+      project: {
+        sourceLanguage: 'en',
+        inbox: [{sourceDocId: 'page-1', targetLanguage: 'fr', locjson: JSON.stringify(locjson)}],
+        progress: [
+          {
+            _key: 'd1',
+            sourceDocId: 'page-1',
+            targets: [{_key: 'page-1__fr', language: 'fr', stages: [{name: 'Translation', percent: 100}], complete: true, imported: false}],
+          },
+        ],
+      },
+      source: sourceDoc,
+    })
+    await applyImportedTranslations({client, schema, projectId: 'p1', documentLanguageField: 'lang', fieldLanguageKey: 'language'})
+
+    const variant = created.find((d) => d._type === 'page')!
+    expect(variant.lang).toBe('fr')
+  })
+})
+
+describe('JSON field validation on import', () => {
+  // A faq with a `metadata` field whose source is well-formed JSON.
+  const faqWithJson = {
+    _id: 'faq-1',
+    _type: 'faq',
+    question: [{_key: 'en', _type: 'internationalizedArrayStringValue', language: 'en', value: 'How?'}],
+    metadata: [
+      {
+        _key: 'en',
+        _type: 'internationalizedArrayStringValue',
+        language: 'en',
+        value: '{"id":"m1","description":"Hello there, friend."}',
+      },
+    ],
+  }
+
+  /** Build an inbox LocJSON for faqWithJson with a custom metadata translation. */
+  async function inboxWith(metadataTarget: string) {
+    const exp = makeClient({project: {sourceLanguage: 'en', items: [{doc: faqWithJson}]}})
+    await prepareExport({client: exp.client, schema: faqSchema, projectId: 'p1', targetLanguages: ['fr'], sourceLanguage: 'en', languages: LANGUAGES, fieldLanguageKey: 'language'})
+    const outbox = exp.patches.at(-1)!.outbox as {locjson: string}[]
+    const locjson = JSON.parse(outbox[0].locjson)
+    locjson.units.forEach((u: {key: string; source: string[]; target: string[]}) => {
+      u.target = u.key === 'metadata' ? [metadataTarget] : ['Comment ?']
+    })
+    return JSON.stringify(locjson)
+  }
+
+  function project(locjson: string) {
+    return {
+      sourceLanguage: 'en',
+      inbox: [{sourceDocId: 'faq-1', targetLanguage: 'fr', locjson}],
+      progress: [
+        {_key: 'd1', sourceDocId: 'faq-1', targets: [{_key: 'faq-1__fr', language: 'fr', stages: [{name: 'Translation', percent: 100}], complete: true, imported: false}]},
+      ],
+    }
+  }
+
+  it('skips a field whose source is JSON but whose translation is malformed, logging the parse error', async () => {
+    // Missing closing brace → invalid JSON.
+    const {client, patches} = makeClient({project: project(await inboxWith('{"id":"m1","description":"Bonjour."')), source: faqWithJson})
+    const logs: {level: string; message: string; value?: string; error?: string}[] = []
+
+    await applyImportedTranslations({client, schema: faqSchema, projectId: 'p1', documentLanguageField: 'language', fieldLanguageKey: 'language', onLog: (l) => logs.push(l)})
+
+    // The malformed metadata is not written; the valid `question` still is.
+    const docPatch = patches.find((p) => 'question' in p || 'metadata' in p)!
+    expect('metadata' in docPatch).toBe(false)
+    expect('question' in docPatch).toBe(true)
+
+    // Short message; the raw attempted value (after) and the parse error are
+    // carried separately for the expandable boxes.
+    const err = logs.find((l) => l.level === 'error' && /metadata/.test(l.message))!
+    expect(err).toBeTruthy()
+    expect(err.message).toMatch(/not valid JSON — skipped$/)
+    expect(err.value).toContain('description') // raw attempted JSON
+    expect(err.error).toBeTruthy() // JSON parse error in its own box
+  })
+
+  it('imports a field whose JSON translation is well-formed', async () => {
+    const {client, patches} = makeClient({
+      project: project(await inboxWith('{"id":"m1","description":"Bonjour, mon ami."}')),
+      source: faqWithJson,
+    })
+
+    await applyImportedTranslations({client, schema: faqSchema, projectId: 'p1', documentLanguageField: 'language', fieldLanguageKey: 'language'})
+
+    const docPatch = patches.find((p) => 'metadata' in p)!
+    const metadata = docPatch.metadata as {language: string; value: string}[]
+    expect(metadata.find((m) => m.language === 'fr')!.value).toBe('{"id":"m1","description":"Bonjour, mon ami."}')
+  })
+})
+
+// A HUEL-shaped block with translatable content nested inside a plain object AND
+// inside an internationalized-array whose member value is an array of objects.
+const scienceSchema = Schema.compile({
+  name: 'sci',
+  types: [
+    {name: 'internationalizedArrayStringValue', type: 'object', fields: [{name: 'value', type: 'string'}]},
+    {name: 'internationalizedArrayString', type: 'array', of: [{type: 'internationalizedArrayStringValue'}]},
+    {name: 'benefitItem', type: 'object', fields: [{name: 'key', type: 'string'}, {name: 'value', type: 'string'}]},
+    {name: 'internationalizedArrayBenefitsValue', type: 'object', fields: [{name: 'value', type: 'array', of: [{type: 'benefitItem'}]}]},
+    {name: 'internationalizedArrayBenefits', type: 'array', of: [{type: 'internationalizedArrayBenefitsValue'}]},
+    {name: 'benefits', type: 'object', fields: [{name: 'items', type: 'internationalizedArrayBenefits'}]},
+    {name: 'homePageScienceBlock', type: 'document', fields: [
+      {name: 'heading', type: 'internationalizedArrayString'},
+      {name: 'benefits', type: 'benefits'},
+    ]},
+  ],
+})
+
+describe('nested + array-member field-level translation', () => {
+  const sciDoc = {
+    _id: 'sci-1',
+    _type: 'homePageScienceBlock',
+    _rev: 'r1',
+    heading: [{_key: 'en', _type: 'internationalizedArrayStringValue', language: 'en', value: 'The science'}],
+    benefits: {
+      items: [
+        {_key: 'en', _type: 'internationalizedArrayBenefitsValue', language: 'en', value: [
+          {_key: 'b1', _type: 'benefitItem', key: 'protein', value: 'High in protein'},
+          {_key: 'b2', _type: 'benefitItem', key: 'fibre', value: 'Rich in fibre'},
+        ]},
+      ],
+    },
+  }
+
+  it('serializes nested benefit copy and imports it back into a fr member, preserving structure', async () => {
+    const exp = makeClient({project: {sourceLanguage: 'en', items: [{doc: sciDoc}]}})
+    await prepareExport({client: exp.client, schema: scienceSchema, projectId: 'p1', targetLanguages: ['fr'], sourceLanguage: 'en', languages: LANGUAGES, fieldLanguageKey: 'language'})
+    const outbox = exp.patches.at(-1)!.outbox as {locjson: string}[]
+    const locjson = JSON.parse(outbox[0].locjson)
+
+    // The nested benefit values are serialized (previously dropped entirely).
+    const keys = locjson.units.map((u: {key: string}) => u.key).sort()
+    expect(keys).toContain('benefits.items[b1].value')
+    expect(keys).toContain('benefits.items[b2].value')
+
+    // Translate only the `value` leaves (uppercase); leave `key`/`heading` as source
+    // to show non-translated leaves and structure survive the round-trip.
+    locjson.units.forEach((u: {key: string; source: string[]; target: string[]}) => {
+      u.target = u.key.endsWith('.value') ? u.source.map((s) => s.toUpperCase()) : [...u.source]
+    })
+
+    const {client, patches} = makeClient({
+      project: {sourceLanguage: 'en', inbox: [{sourceDocId: 'sci-1', targetLanguage: 'fr', locjson: JSON.stringify(locjson)}], progress: [
+        {_key: 'd1', sourceDocId: 'sci-1', targets: [{_key: 'sci-1__fr', language: 'fr', stages: [{name: 'Translation', percent: 100}], complete: true, imported: false}]},
+      ]},
+      source: sciDoc,
+    })
+    const {imported} = await applyImportedTranslations({client, schema: scienceSchema, projectId: 'p1', documentLanguageField: 'language', fieldLanguageKey: 'language'})
+    expect(imported).toBe(1)
+
+    // The draft patch adds a fr member to benefits.items with translated values,
+    // preserving inner _keys and the non-text `key` field.
+    const docPatch = patches.find((p) => 'benefits.items' in p)!
+    const members = docPatch['benefits.items'] as {language: string; value: {_key: string; key: string; value: string}[]}[]
+    const fr = members.find((m) => m.language === 'fr')!
+    expect(fr.value).toEqual([
+      {_key: 'b1', _type: 'benefitItem', key: 'protein', value: 'HIGH IN PROTEIN'},
+      {_key: 'b2', _type: 'benefitItem', key: 'fibre', value: 'RICH IN FIBRE'},
+    ])
+  })
+})