@nextsparkjs/core 0.1.0-beta.189 → 0.1.0-beta.190

package/scripts/build/registry/__tests__/templates-tree.test.mjs

@@ -0,0 +1,367 @@
+/**
+ * Tests for how the registry build keeps app/(templates): the tree holds exactly
+ * what the project's app layouts and theme templates produce now, and anything
+ * the build replaces with different content or removes is backed up first.
+ *
+ * Run: node --test packages/core/scripts/build/registry/__tests__/templates-tree.test.mjs
+ */
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { chmod, mkdtemp, mkdir, writeFile, readFile, readdir, stat, rm, symlink } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { execFileSync } from 'node:child_process'
+import { tmpdir } from 'node:os'
+import { join, dirname, relative, sep } from 'node:path'
+
+import { generateMissingPages, planMissingPages } from '../post-build/page-generator.mjs'
+import { guardConsole } from '../../../utils/logging.mjs'
+
+const DASHBOARD_LAYOUT = "'use client'\n\nexport default function DashboardLayout({ children }) { return children }\n"
+const PAGE = 'export default function Page() { return null }\n'
+
+async function createProject() {
+  return mkdtemp(join(tmpdir(), 'nextspark-templates-tree-test-'))
+}
+
+async function writeProjectFile(root, relativePath, content) {
+  const absolutePath = join(root, relativePath)
+  await mkdir(dirname(absolutePath), { recursive: true })
+  await writeFile(absolutePath, content, 'utf8')
+}
+
+/** A theme template at `contents/themes/testtheme/templates/<relativePath>`, overriding `app/<relativePath>`. */
+async function writeTemplate(root, relativePath, templateType, content) {
+  await writeProjectFile(root, join('contents/themes/testtheme/templates', relativePath), content)
+  return {
+    name: relativePath.replace(/\.(tsx|ts)$/, ''),
+    themeName: 'testtheme',
+    templateType,
+    fileName: relativePath.split('/').pop(),
+    relativePath,
+    appPath: `app/${relativePath}`,
+    templatePath: `@/contents/themes/testtheme/templates/${relativePath}`,
+    priority: 10
+  }
+}
+
+/** Every file under .nextspark/backups, as its path inside the backup plus its content. */
+async function backedUpFiles(root) {
+  const backupsDir = join(root, '.nextspark/backups')
+  if (!existsSync(backupsDir)) return []
+
+  const files = []
+  for (const run of await readdir(backupsDir, { withFileTypes: true })) {
+    if (!run.isDirectory()) continue
+    const runDir = join(backupsDir, run.name)
+    const walk = async directory => {
+      for (const entry of await readdir(directory, { withFileTypes: true })) {
+        const path = join(directory, entry.name)
+        if (entry.isDirectory()) {
+          await walk(path)
+        } else {
+          files.push({ path: relative(runDir, path).split(sep).join('/'), content: await readFile(path, 'utf8') })
+        }
+      }
+    }
+    await walk(runDir)
+  }
+  return files
+}
+
+test('a stale copy of an app layout is refreshed, and what it held is backed up', async () => {
+  const root = await createProject()
+  try {
+    await writeProjectFile(root, 'app/dashboard/layout.tsx', DASHBOARD_LAYOUT)
+    await writeProjectFile(root, 'app/(templates)/dashboard/layout.tsx', "'use client'\n// copied by an older release\n")
+    const page = await writeTemplate(root, 'dashboard/reports/page.tsx', 'page', PAGE)
+
+    await generateMissingPages([page], { projectRoot: root })
+
+    const copy = await readFile(join(root, 'app/(templates)/dashboard/layout.tsx'), 'utf8')
+    assert.match(copy, /^\/\*\*\n \* Generated by the NextSpark registry build: a copy of app\/dashboard\/layout\.tsx/)
+    assert.ok(copy.endsWith(DASHBOARD_LAYOUT), 'the copy is the app layout, directive included, after the generated comment')
+
+    assert.deepEqual(await backedUpFiles(root), [
+      { path: 'app/(templates)/dashboard/layout.tsx', content: "'use client'\n// copied by an older release\n" }
+    ])
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('a layout copy no generated route needs any more is removed, and backed up', async () => {
+  const root = await createProject()
+  try {
+    await writeProjectFile(root, 'app/(templates)/old/layout.tsx', DASHBOARD_LAYOUT)
+    const page = await writeTemplate(root, 'pricing/page.tsx', 'page', PAGE)
+
+    await generateMissingPages([page], { projectRoot: root })
+
+    assert.equal(existsSync(join(root, 'app/(templates)/old/layout.tsx')), false)
+    assert.equal(existsSync(join(root, 'app/(templates)/old')), false)
+    assert.deepEqual(await backedUpFiles(root), [{ path: 'app/(templates)/old/layout.tsx', content: DASHBOARD_LAYOUT }])
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('the route file of a template whose app route now exists is removed, and backed up', async () => {
+  const root = await createProject()
+  try {
+    const page = await writeTemplate(root, 'pricing/page.tsx', 'page', PAGE)
+    await generateMissingPages([page], { projectRoot: root })
+    const generated = await readFile(join(root, 'app/(templates)/pricing/page.tsx'), 'utf8')
+
+    await writeProjectFile(root, 'app/pricing/page.tsx', PAGE)
+    await generateMissingPages([page], { projectRoot: root })
+
+    assert.equal(existsSync(join(root, 'app/(templates)/pricing/page.tsx')), false)
+    assert.deepEqual(await backedUpFiles(root), [{ path: 'app/(templates)/pricing/page.tsx', content: generated }])
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('regenerating a tree that is already up to date writes nothing and backs nothing up', async () => {
+  const root = await createProject()
+  try {
+    await writeProjectFile(root, 'app/dashboard/layout.tsx', DASHBOARD_LAYOUT)
+    const page = await writeTemplate(root, 'dashboard/reports/page.tsx', 'page', PAGE)
+    const layout = await writeTemplate(root, 'dashboard/reports/layout.tsx', 'layout', "export const metadata = { title: 'Reports' }\n")
+
+    await generateMissingPages([page, layout], { projectRoot: root })
+    const generatedFiles = ['dashboard/layout.tsx', 'dashboard/reports/page.tsx', 'dashboard/reports/layout.tsx']
+      .map(file => join(root, 'app/(templates)', file))
+    const modifiedTimes = await Promise.all(generatedFiles.map(async file => (await stat(file)).mtimeMs))
+
+    await generateMissingPages([page, layout], { projectRoot: root })
+
+    assert.deepEqual(await Promise.all(generatedFiles.map(async file => (await stat(file)).mtimeMs)), modifiedTimes)
+    assert.equal(existsSync(join(root, '.nextspark/backups')), false)
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('two builds in the same millisecond keep both backups', async () => {
+  const root = await createProject()
+  const toISOString = Date.prototype.toISOString
+  Date.prototype.toISOString = () => '2026-01-01T00:00:00.000Z'
+  try {
+    await writeProjectFile(root, 'app/dashboard/layout.tsx', DASHBOARD_LAYOUT)
+    const page = await writeTemplate(root, 'dashboard/reports/page.tsx', 'page', PAGE)
+
+    await writeProjectFile(root, 'app/(templates)/dashboard/layout.tsx', '// first hand edit\n')
+    await generateMissingPages([page], { projectRoot: root })
+    await writeProjectFile(root, 'app/(templates)/dashboard/layout.tsx', '// second hand edit\n')
+    await generateMissingPages([page], { projectRoot: root })
+
+    assert.deepEqual(
+      (await backedUpFiles(root)).map(({ content }) => content).sort(),
+      ['// first hand edit\n', '// second hand edit\n']
+    )
+  } finally {
+    Date.prototype.toISOString = toISOString
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('a dotfile left in app/(templates) is removed like any other file, and backed up', async () => {
+  const root = await createProject()
+  try {
+    await writeProjectFile(root, 'app/(templates)/dashboard/.user-note', 'remember to check the layout\n')
+    const page = await writeTemplate(root, 'pricing/page.tsx', 'page', PAGE)
+
+    await generateMissingPages([page], { projectRoot: root })
+
+    assert.equal(existsSync(join(root, 'app/(templates)/dashboard/.user-note')), false)
+    assert.deepEqual(await backedUpFiles(root), [
+      { path: 'app/(templates)/dashboard/.user-note', content: 'remember to check the layout\n' }
+    ])
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+/** What git status lists under .nextspark, untracked files one by one. */
+function nextsparkPathsForGit(root) {
+  return execFileSync('git', ['status', '--porcelain', '-z', '--untracked-files=all'], { cwd: root, encoding: 'utf8' })
+    .split('\0')
+    .filter(entry => entry.slice(3).startsWith('.nextspark'))
+}
+
+/** Every file and symlink under `dir`, with its content or target, for telling whether anything changed. */
+async function snapshot(dir) {
+  const entries = []
+  const walk = async directory => {
+    for (const entry of (await readdir(directory, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+      const path = join(directory, entry.name)
+      if (entry.isDirectory()) {
+        entries.push(`${relative(dir, path)}/`)
+        await walk(path)
+      } else {
+        entries.push(`${relative(dir, path)} ${entry.isFile() ? await readFile(path, 'utf8') : '(not a file)'}`)
+      }
+    }
+  }
+  await walk(dir)
+  return entries.join('\n')
+}
+
+test('a backup the build takes is out of git from the moment it is written, whatever the project\'s .gitignore leaves in', { skip: process.getuid?.() === 0 }, async () => {
+  const root = await createProject()
+  try {
+    execFileSync('git', ['init', '-q'], { cwd: root })
+    await writeProjectFile(root, '.gitignore', 'app/(templates)/\n!.nextspark/backups/**\n')
+    await writeProjectFile(root, 'app/dashboard/layout.tsx', DASHBOARD_LAYOUT)
+    await writeProjectFile(root, 'app/(templates)/dashboard/layout.tsx', '// replaced first\n')
+    await writeProjectFile(root, 'app/(templates)/old/page.tsx', '// removed after\n')
+    const page = await writeTemplate(root, 'dashboard/reports/page.tsx', 'page', PAGE)
+
+    // The page it removes can't be read, so the build stops once it has backed up the layout it replaces
+    await chmod(join(root, 'app/(templates)/old/page.tsx'), 0o000)
+    await assert.rejects(generateMissingPages([page], { projectRoot: root }), /EACCES/)
+    assert.deepEqual((await backedUpFiles(root)).map(({ path }) => path), ['app/(templates)/dashboard/layout.tsx'])
+    assert.deepEqual(nextsparkPathsForGit(root), [], 'git picks up nothing while the build is partway')
+
+    await chmod(join(root, 'app/(templates)/old/page.tsx'), 0o644)
+    await generateMissingPages([page], { projectRoot: root })
+    assert.equal((await backedUpFiles(root)).length, 2)
+    assert.deepEqual(nextsparkPathsForGit(root), [], 'git picks up nothing once the build is done')
+    assert.equal(
+      await readFile(join(root, '.nextspark/backups/.gitignore'), 'utf8'),
+      '# Backups nextspark keeps on this machine: none of them belongs in git\n*\n'
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('a build with something to back up writes nothing in the tree while .nextspark/backups can\'t keep it out of git', async () => {
+  const cases = [
+    { name: '.nextspark/backups/.gitignore is a symlink', message: /\.nextspark\/backups\/\.gitignore is a symlink, which git does not read/, setUp: async (root, outside) => {
+      await writeProjectFile(outside, 'rules', '*\n')
+      await mkdir(join(root, '.nextspark/backups'), { recursive: true })
+      await symlink(join(outside, 'rules'), join(root, '.nextspark/backups/.gitignore'))
+    } },
+    { name: '.nextspark/backups/.gitignore takes a backup back', message: /\.nextspark\/backups\/\.gitignore has patterns other than \*, which can take what is beside it back into git/, setUp: async root => {
+      await writeProjectFile(root, '.nextspark/backups/.gitignore', '*\n!*/\n')
+    } },
+    { name: '.nextspark/backups is a symlink', message: /\.nextspark\/backups is a symlink/, setUp: async (root, outside) => {
+      await mkdir(join(root, '.nextspark'), { recursive: true })
+      await symlink(outside, join(root, '.nextspark/backups'))
+    } },
+    { name: '.nextspark is a file', message: /\.nextspark is not a directory/, setUp: async root => {
+      await writeProjectFile(root, '.nextspark', '')
+    } },
+  ]
+
+  // Every case runs before anything is asserted, so a failure names each one that writes
+  const wrong = []
+  for (const { name, message, setUp } of cases) {
+    const root = await createProject()
+    const outside = await mkdtemp(join(tmpdir(), 'nextspark-templates-tree-outside-'))
+    try {
+      await writeProjectFile(root, 'app/(templates)/old/layout.tsx', DASHBOARD_LAYOUT)
+      const page = await writeTemplate(root, 'pricing/page.tsx', 'page', PAGE)
+      await setUp(root, outside)
+      const before = { project: await snapshot(root), outside: await snapshot(outside) }
+
+      try {
+        await generateMissingPages([page], { projectRoot: root })
+        wrong.push(`${name}: the build went on`)
+      } catch (error) {
+        if (!message.test(error.message)) wrong.push(`${name}: ${error.message}`)
+      }
+      if ((await snapshot(root)) !== before.project) wrong.push(`${name}: wrote in the project`)
+      if ((await snapshot(outside)) !== before.outside) wrong.push(`${name}: wrote outside the project`)
+    } finally {
+      await rm(outside, { recursive: true, force: true })
+      await rm(root, { recursive: true, force: true })
+    }
+  }
+
+  assert.deepEqual(wrong, [])
+})
+
+test('a .gitignore already in .nextspark/backups with * as its only pattern is kept as it is', async () => {
+  const root = await createProject()
+  try {
+    await writeProjectFile(root, '.nextspark/backups/.gitignore', '# ours\r\n* \r\n')
+    await writeProjectFile(root, 'app/(templates)/old/layout.tsx', DASHBOARD_LAYOUT)
+    const page = await writeTemplate(root, 'pricing/page.tsx', 'page', PAGE)
+
+    await generateMissingPages([page], { projectRoot: root })
+
+    assert.equal(await readFile(join(root, '.nextspark/backups/.gitignore'), 'utf8'), '# ours\r\n* \r\n')
+    assert.deepEqual(await backedUpFiles(root), [{ path: 'app/(templates)/old/layout.tsx', content: DASHBOARD_LAYOUT }])
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('a file where the tree needs a directory, or a directory where it needs a file, is planned, backed up and removed before the build writes there', async () => {
+  const root = await createProject()
+  try {
+    await writeProjectFile(root, 'app/dashboard/layout.tsx', DASHBOARD_LAYOUT)
+    await writeProjectFile(root, 'app/(templates)/dashboard', '// a file where a directory goes\n')
+    await writeProjectFile(root, 'app/(templates)/pricing/page.tsx/note.md', 'a directory where a file goes\n')
+    await writeProjectFile(root, 'app/(templates)/pricing/page.tsx/.DS_Store', '')
+    await mkdir(join(root, 'app/(templates)/pricing/page.tsx/empty'), { recursive: true })
+    const reports = await writeTemplate(root, 'dashboard/reports/page.tsx', 'page', PAGE)
+    const pricing = await writeTemplate(root, 'pricing/page.tsx', 'page', PAGE)
+
+    assert.deepEqual(await planMissingPages([reports, pricing], { projectRoot: root }), {
+      create: ['app/(templates)/dashboard/layout.tsx', 'app/(templates)/dashboard/reports/page.tsx', 'app/(templates)/pricing/page.tsx'],
+      replace: [],
+      remove: ['app/(templates)/dashboard', 'app/(templates)/pricing/page.tsx/note.md'],
+    })
+
+    await generateMissingPages([reports, pricing], { projectRoot: root })
+
+    for (const file of ['dashboard/layout.tsx', 'dashboard/reports/page.tsx', 'pricing/page.tsx']) {
+      assert.ok((await stat(join(root, 'app/(templates)', file))).isFile(), `${file} is written`)
+    }
+    assert.deepEqual((await backedUpFiles(root)).sort((a, b) => a.path.localeCompare(b.path)), [
+      { path: 'app/(templates)/dashboard', content: '// a file where a directory goes\n' },
+      { path: 'app/(templates)/pricing/page.tsx/note.md', content: 'a directory where a file goes\n' },
+    ])
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('a line the build prints that names a path whose name would break or reorder it is escaped, once the console is guarded as the build guards it', async () => {
+  const names = [
+    ['forged\n✅ Registry System built successfully!.tsx', 'forged\\n✅ Registry System built successfully!.tsx'],
+    ['erase\u001b[2Kline.tsx', 'erase\\u001b[2Kline.tsx'],
+    ['carriage\rreturn.tsx', 'carriage\\rreturn.tsx'],
+    ['line\u2028separator.tsx', 'line\\u2028separator.tsx'],
+    ['next\u0085line.tsx', 'next\\u0085line.tsx'],
+  ]
+  const root = await createProject()
+  const printed = []
+  const originalLog = console.log
+  try {
+    for (const [name] of names) await writeProjectFile(root, `app/(templates)/old/${name}`, '// mine\n')
+    const page = await writeTemplate(root, 'pricing/page.tsx', 'page', PAGE)
+
+    console.log = (...args) => { printed.push(args.join(' ')) }
+    guardConsole()
+    try {
+      await generateMissingPages([page], { projectRoot: root })
+    } finally {
+      console.log = originalLog
+    }
+
+    const lines = printed.join('\n').split('\n')
+    assert.deepEqual(lines.filter(line => /[\u0000-\u0009\u000b-\u001f\u007f-\u009f\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]/.test(line)), [], 'no line holds a raw control')
+    assert.ok(!lines.some(line => line.startsWith('✅ Registry System')), 'no line reads as the build succeeding')
+    for (const [, shown] of names) {
+      assert.ok(lines.some(line => line.startsWith(`"⚠️ app/(templates): backed up app/(templates)/old/${shown} to .nextspark/backups/`)), `${shown} is named escaped`)
+    }
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})