@setzkasten-cms/astro-admin 0.6.0

package/src/init/__tests__/patcher-edge-cases.test.ts

@@ -0,0 +1,434 @@
+/**
+ * Patcher edge-case tests.
+ *
+ * Covers scenarios that have caused silent failures or build errors in
+ * production and are not covered by the page-mode regression tests:
+ *
+ *   1. UTF-8 / multi-byte characters (umlauts, em-dash, emoji)
+ *      AST byte offsets vs JS char offsets — wrong replacement if not converted.
+ *
+ *   2. Re-patching an already-integrated page
+ *      Calling patchTemplateForFields on a file that already has
+ *      `getSection()` must be idempotent (no duplicate imports, no errors).
+ *
+ *   3. Windows line-endings (CRLF)
+ *      Frontmatter extraction, offset arithmetic, and semicolon stripping
+ *      must work correctly when \r\n is used throughout.
+ *
+ *   4. Frontmatter without trailing newline
+ *      The patcher must not crash or produce a malformed result when the
+ *      source does not end with a newline.
+ *
+ *   5. Page with no patchable content
+ *      A template whose text nodes do not match any defaultValue should
+ *      still inject the getSection() call without throwing.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { patchTemplateForFields, stripTemplateFallbacks } from '../../init/template-patcher-v2'
+import type { PatchField } from '../../init/template-patcher-v2'
+
+// ---------------------------------------------------------------------------
+// Edge Case 1: UTF-8 / multi-byte characters
+//
+// If the patcher uses raw byte offsets from the AST instead of JS char offsets,
+// characters like ä (2 bytes in UTF-8) cause the replacement range to be off
+// by one or more positions, silently corrupting text around non-ASCII chars.
+// ---------------------------------------------------------------------------
+
+describe('Edge case 1: UTF-8 multi-byte characters', () => {
+  const source = `---
+export const prerender = true;
+import BaseLayout from '../layouts/BaseLayout.astro';
+---
+
+<BaseLayout>
+  <section class="py-16">
+    <h1>Über uns</h1>
+    <p>Wir entwickeln Lösungen für Unternehmen.</p>
+  </section>
+</BaseLayout>
+`
+
+  const fields: PatchField[] = [
+    { key: 'heading', type: 'text', defaultValue: 'Über uns' },
+    { key: 'body', type: 'text', defaultValue: 'Wir entwickeln Lösungen für Unternehmen.' },
+  ]
+
+  it('should produce valid output containing skData references', async () => {
+    const patched = await patchTemplateForFields(source, '_page_about', fields, [], { mode: 'page' })
+    expect(patched).toContain('skData')
+  })
+
+  it('should bind the heading field containing an umlaut', async () => {
+    const patched = await patchTemplateForFields(source, '_page_about', fields, [], { mode: 'page' })
+    expect(patched).toContain('skData?.heading')
+  })
+
+  it('should bind the body field containing umlauts', async () => {
+    const patched = await patchTemplateForFields(source, '_page_about', fields, [], { mode: 'page' })
+    expect(patched).toContain('skData?.body')
+  })
+
+  it('should not corrupt the surrounding markup', async () => {
+    const patched = await patchTemplateForFields(source, '_page_about', fields, [], { mode: 'page' })
+    // The <section> tag must still be intact
+    expect(patched).toMatch(/<section[^>]*>/)
+    // Closing tags must still be present
+    expect(patched).toContain('</section>')
+    expect(patched).toContain('</BaseLayout>')
+  })
+
+  it('should add data-sk-field to the heading element', async () => {
+    const patched = await patchTemplateForFields(source, '_page_about', fields, [], { mode: 'page' })
+    expect(patched).toMatch(/<h1[^>]*data-sk-field/)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Edge Case 2: Re-patching an already-integrated page (idempotency)
+//
+// If the user runs adoption twice, or if the patcher is called on a file that
+// was already patched (e.g. by a previous adoption commit), it must:
+//   - NOT add a second `import { getSection }` line
+//   - NOT add a second `const skData = getSection(...)` declaration
+//   - NOT break any existing bindings
+// ---------------------------------------------------------------------------
+
+describe('Edge case 2: Re-patching an already-integrated page is idempotent', () => {
+  // Simulate a page that was already patched by a previous adoption run
+  const alreadyPatched = `---
+export const prerender = true;
+import BaseLayout from '../layouts/BaseLayout.astro';
+import { getSection } from 'setzkasten:content'
+const skData = getSection('_page_about')
+---
+
+<BaseLayout>
+  <section id="section-_page_about" class="py-16">
+    <h1 data-sk-field="_page_about.heading" set:html={skData?.heading ?? 'Über uns'} />
+    <p data-sk-field="_page_about.body" set:html={skData?.body ?? 'Wir entwickeln Lösungen.'} />
+  </section>
+</BaseLayout>
+`
+
+  const fields: PatchField[] = [
+    { key: 'heading', type: 'text', defaultValue: 'Über uns' },
+    { key: 'body', type: 'text', defaultValue: 'Wir entwickeln Lösungen.' },
+  ]
+
+  it('should not duplicate the getSection import', async () => {
+    const patched = await patchTemplateForFields(alreadyPatched, '_page_about', fields, [], { mode: 'page' })
+    const importCount = (patched.match(/import \{ getSection \}/g) ?? []).length
+    expect(importCount).toBe(1)
+  })
+
+  it('should not duplicate the skData declaration', async () => {
+    const patched = await patchTemplateForFields(alreadyPatched, '_page_about', fields, [], { mode: 'page' })
+    const declCount = (patched.match(/const skData\s*=/g) ?? []).length
+    expect(declCount).toBe(1)
+  })
+
+  it('should preserve existing data-sk-field attributes', async () => {
+    const patched = await patchTemplateForFields(alreadyPatched, '_page_about', fields, [], { mode: 'page' })
+    expect(patched).toContain('data-sk-field="_page_about.heading"')
+    expect(patched).toContain('data-sk-field="_page_about.body"')
+  })
+
+  it('should not add a second section id', async () => {
+    const patched = await patchTemplateForFields(alreadyPatched, '_page_about', fields, [], { mode: 'page' })
+    const idCount = (patched.match(/id="section-_page_about"/g) ?? []).length
+    expect(idCount).toBe(1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Edge Case 3: Windows line-endings (CRLF)
+//
+// Source files checked out on Windows may use \r\n. The patcher uses
+// indexOf('---') and slice operations that must still work correctly.
+// The resulting output does not need to be CRLF; it just must be valid.
+// ---------------------------------------------------------------------------
+
+describe('Edge case 3: CRLF line endings', () => {
+  const lf = `---
+export const prerender = true;
+import BaseLayout from '../layouts/BaseLayout.astro';
+---
+
+<BaseLayout>
+  <section class="py-16">
+    <h1>Hello World</h1>
+  </section>
+</BaseLayout>
+`
+  // Convert all LF to CRLF
+  const crlf = lf.replace(/\n/g, '\r\n')
+
+  const fields: PatchField[] = [
+    { key: 'heading', type: 'text', defaultValue: 'Hello World' },
+  ]
+
+  it('should not throw on CRLF input', async () => {
+    await expect(
+      patchTemplateForFields(crlf, '_page_test', fields, [], { mode: 'page' })
+    ).resolves.toBeDefined()
+  })
+
+  it('should still inject getSection', async () => {
+    const patched = await patchTemplateForFields(crlf, '_page_test', fields, [], { mode: 'page' })
+    expect(patched).toContain('getSection')
+  })
+
+  it('should still bind the heading field', async () => {
+    const patched = await patchTemplateForFields(crlf, '_page_test', fields, [], { mode: 'page' })
+    expect(patched).toContain('skData?.heading')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Edge Case 4: Frontmatter without trailing newline before closing ---
+//
+// Some editors save files without a trailing newline. The patcher uses
+// `source.indexOf('---', start + 3)` to find the closing frontmatter marker;
+// this must still work even if the last frontmatter line has no newline.
+// ---------------------------------------------------------------------------
+
+describe('Edge case 4: frontmatter without trailing newline', () => {
+  // Note: no \n before closing ---
+  const source = `---
+export const prerender = true;
+import BaseLayout from '../layouts/BaseLayout.astro';---
+
+<BaseLayout>
+  <section class="py-16">
+    <h1>Tight Frontmatter</h1>
+  </section>
+</BaseLayout>
+`
+
+  const fields: PatchField[] = [
+    { key: 'heading', type: 'text', defaultValue: 'Tight Frontmatter' },
+  ]
+
+  it('should not throw', async () => {
+    await expect(
+      patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+    ).resolves.toBeDefined()
+  })
+
+  it('should return a string (graceful fallback at minimum)', async () => {
+    const result = await patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+    expect(typeof result).toBe('string')
+    expect(result.length).toBeGreaterThan(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Edge Case 5: No patchable content
+//
+// A template whose text nodes don't match any field defaultValue should:
+//   - Still inject getSection() in page mode
+//   - Not throw
+//   - Return a non-empty string
+// ---------------------------------------------------------------------------
+
+describe('Edge case 5: template with no matching content', () => {
+  const source = `---
+export const prerender = true;
+import BaseLayout from '../layouts/BaseLayout.astro';
+---
+
+<BaseLayout>
+  <section class="py-16">
+    <h1>Something completely different</h1>
+  </section>
+</BaseLayout>
+`
+
+  const fields: PatchField[] = [
+    { key: 'heading', type: 'text', defaultValue: 'Expected Heading That Does Not Appear' },
+  ]
+
+  it('should not throw', async () => {
+    await expect(
+      patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+    ).resolves.toBeDefined()
+  })
+
+  it('should inject getSection even with no matching content', async () => {
+    const patched = await patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+    expect(patched).toContain('getSection')
+  })
+
+  it('should not duplicate frontmatter markers', async () => {
+    const patched = await patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+    const markerCount = (patched.match(/^---$/gm) ?? []).length
+    // Should have exactly 2 frontmatter delimiters
+    expect(markerCount).toBe(2)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// stripTemplateFallbacks
+// ---------------------------------------------------------------------------
+describe('stripTemplateFallbacks', () => {
+  it('strips single-quoted string fallback and extracts value', () => {
+    const source = `<h1 set:html={skData?.heading ?? 'Lizenz'}></h1>`
+    const { source: result, fallbacks } = stripTemplateFallbacks(source)
+    expect(result).toBe(`<h1 set:html={skData?.heading}></h1>`)
+    expect(fallbacks['heading']).toBe('Lizenz')
+  })
+
+  it('strips double-quoted string fallback', () => {
+    const source = `<p set:html={skData?.desc ?? "Beschreibung"}></p>`
+    const { source: result, fallbacks } = stripTemplateFallbacks(source)
+    expect(result).toBe(`<p set:html={skData?.desc}></p>`)
+    expect(fallbacks['desc']).toBe('Beschreibung')
+  })
+
+  it('strips template-literal fallback (single line)', () => {
+    const source = `<p set:html={skData?.description ?? \`Setzkasten ist ein CMS.\`}></p>`
+    const { source: result, fallbacks } = stripTemplateFallbacks(source)
+    expect(result).toBe(`<p set:html={skData?.description}></p>`)
+    expect(fallbacks['description']).toBe('Setzkasten ist ein CMS.')
+  })
+
+  it('strips multi-line template-literal fallback', () => {
+    const source = `<p set:html={skData?.description ?? \`Es läuft vollständig im Browser und\n          kommuniziert über API-Routen.\`}></p>`
+    const { source: result, fallbacks } = stripTemplateFallbacks(source)
+    expect(result).toBe(`<p set:html={skData?.description}></p>`)
+    expect(fallbacks['description']).toContain('läuft vollständig')
+  })
+
+  it('strips array fallback and extracts items', () => {
+    const source = `{(skData?.items ?? ['Eintrag A', 'Eintrag B', 'Eintrag C']).map((`
+    const { source: result, fallbacks } = stripTemplateFallbacks(source)
+    expect(result).toBe(`{(skData?.items ?? []).map((`)
+    expect(fallbacks['items']).toEqual(['Eintrag A', 'Eintrag B', 'Eintrag C'])
+  })
+
+  it('strips array fallback with backtick HTML items', () => {
+    const source = "{(skData?.items ?? [`<strong>Label</strong> &mdash; Text.`]).map(("
+    const { source: result, fallbacks } = stripTemplateFallbacks(source)
+    expect(result).toBe(`{(skData?.items ?? []).map((`)
+    expect((fallbacks['items'] as string[])?.[0]).toContain('<strong>')
+  })
+
+  it('leaves elements without fallbacks untouched', () => {
+    const source = `<h1 set:html={skData?.heading}></h1>`
+    const { source: result, fallbacks } = stripTemplateFallbacks(source)
+    expect(result).toBe(source)
+    expect(Object.keys(fallbacks)).toHaveLength(0)
+  })
+
+  it('does not overwrite existing JSON values (caller responsibility)', () => {
+    // stripTemplateFallbacks just returns fallbacks — merging is done in add-section
+    // This test verifies multiple fallbacks are all extracted
+    const source = [
+      `<h1 set:html={skData?.heading ?? 'Titel'}></h1>`,
+      `<p set:html={skData?.description ?? 'Text'}></p>`,
+      `{(skData?.items ?? ['A', 'B']).map((`,
+    ].join('\n')
+    const { fallbacks } = stripTemplateFallbacks(source)
+    expect(fallbacks['heading']).toBe('Titel')
+    expect(fallbacks['description']).toBe('Text')
+    expect(fallbacks['items']).toEqual(['A', 'B'])
+  })
+
+  it('strips fallbacks from a realistic page fragment', () => {
+    const source = `---
+import { getSection } from 'setzkasten:content'
+const skData = getSection('_page_docs_license')
+---
+<h1 data-sk-field="_page_docs_license.heading" set:html={skData?.heading ?? 'Lizenz'}></h1>
+<p data-sk-field="_page_docs_license.description" set:html={skData?.description ?? 'Community License.'}></p>
+{(skData?.items ?? ['Eintrag A', 'Eintrag B']).map((item, _i) => (
+<li data-sk-field={\`_page_docs_license.items.\${_i}\`}>
+  <span set:html={item}></span>
+</li>
+))}`
+    const { source: result, fallbacks } = stripTemplateFallbacks(source)
+    expect(result).toContain(`set:html={skData?.heading}`)
+    expect(result).toContain(`set:html={skData?.description}`)
+    expect(result).toContain(`(skData?.items ?? []).map(`)
+    expect(result).not.toContain(`?? 'Lizenz'`)
+    expect(result).not.toContain(`?? 'Community License.'`)
+    expect(fallbacks['heading']).toBe('Lizenz')
+    expect(fallbacks['description']).toBe('Community License.')
+    expect(fallbacks['items']).toEqual(['Eintrag A', 'Eintrag B'])
+  })
+
+  it('preserves mailto link in backtick fallback', () => {
+    // Bug: <a href="mailto:"> was stripped from JSON on adoption because the merge
+    // logic wrote plain-text defaultValue first, then discarded the richer HTML fallback.
+    const source = [
+      `<div data-sk-field="_page.callout" set:html={skData?.callout ?? \`Für kommerzielle Lizenzen: <a href="mailto:hello@example.com" class="text-sk-accent">hello@example.com</a> — wir finden ein passendes Modell.\`}></div>`,
+    ].join('\n')
+    const { source: stripped, fallbacks } = stripTemplateFallbacks(source)
+    expect(stripped).toContain('set:html={skData?.callout}')
+    expect(fallbacks['callout']).toMatch(/href="mailto:hello@example\.com"/)
+    expect(fallbacks['callout']).toMatch(/<a /)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Merge logic: HTML fallback must win over plain-text defaultValue
+//
+// Bug: buildSectionData wrote plain-text defaultValue to sectionData first.
+// stripTemplateFallbacks then found richer HTML (e.g. with <a href="mailto:">),
+// but the merge condition "JSON wins if already set" discarded it.
+// Fix: HTML extracted from template wins over plain-text initial value.
+// ---------------------------------------------------------------------------
+describe('HTML fallback wins over plain-text default in sectionData merge', () => {
+  // Mirror the merge logic from init-add-section.ts
+  function mergeFallbacks(
+    sectionData: Record<string, unknown>,
+    fallbacks: Record<string, unknown>,
+  ): Record<string, unknown> {
+    const result = { ...sectionData }
+    for (const [key, value] of Object.entries(fallbacks)) {
+      const existing = result[key]
+      const existingIsPlain = typeof existing === 'string' && !/<[a-z]/.test(existing)
+      const newIsHtml = typeof value === 'string' && /<[a-z]/.test(value as string)
+      if (!(key in result) || existing === '' || existing === null || (existingIsPlain && newIsHtml)) {
+        result[key] = value
+      }
+    }
+    return result
+  }
+
+  it('HTML from template overwrites plain-text defaultValue', () => {
+    const sectionData = {
+      callout: 'Für kommerzielle Lizenzen: hello@example.com — text.',
+    }
+    const fallbacks = {
+      callout: 'Für kommerzielle Lizenzen: <a href="mailto:hello@example.com">hello@example.com</a> — text.',
+    }
+    const result = mergeFallbacks(sectionData, fallbacks)
+    expect(result['callout']).toMatch(/href="mailto:/)
+    expect(result['callout']).toMatch(/<a /)
+  })
+
+  it('does NOT overwrite when existing value is already HTML', () => {
+    const sectionData = {
+      callout: '<p>Existing <strong>HTML</strong> content.</p>',
+    }
+    const fallbacks = {
+      callout: 'Some plain text fallback.',
+    }
+    const result = mergeFallbacks(sectionData, fallbacks)
+    expect(result['callout']).toContain('<strong>')
+  })
+
+  it('does NOT overwrite when existing HTML is richer than fallback HTML', () => {
+    const sectionData = {
+      callout: '<p>Bearbeiteter <a href="mailto:x@y.com">Link</a> Text.</p>',
+    }
+    const fallbacks = {
+      callout: '<p>Original <a href="mailto:x@y.com">Link</a> Text.</p>',
+    }
+    const result = mergeFallbacks(sectionData, fallbacks)
+    expect(result['callout']).toContain('Bearbeiteter')
+  })
+})