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

package/scripts/build/registry/__tests__/template-registry.test.mjs

@@ -13,11 +13,15 @@
 
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, dirname } from 'node:path'
 
 import {
   generateTemplateRegistry,
   generateTemplateRegistryClient
 } from '../generators/template-registry.mjs'
+import { analyzeTemplates } from '../post-build/page-generator.mjs'
 
 const pageTemplate = {
   name: '(public)/page',
@@ -42,8 +46,18 @@ const protectedTemplate = {
 
 const config = { outputDir: '/tmp/registries', projectRoot: '/tmp/project' }
 
-test('server registry defers the import instead of hoisting a static one', () => {
-  const out = generateTemplateRegistry([pageTemplate], config)
+// The registry build parses the templates once, with analyzeTemplates, and
+// hands the same analysis to both registries. These do the same.
+async function generateServerRegistry(templates, config) {
+  return generateTemplateRegistry(templates, config, await analyzeTemplates(templates, config))
+}
+
+async function generateClientRegistry(templates, config) {
+  return generateTemplateRegistryClient(templates, config, await analyzeTemplates(templates, config))
+}
+
+test('server registry defers the import instead of hoisting a static one', async () => {
+  const out = await generateServerRegistry([pageTemplate], config)
 
   assert.match(
     out,
@@ -52,8 +66,8 @@ test('server registry defers the import instead of hoisting a static one', () =>
   assert.doesNotMatch(out, /^import Template_\d+ from/m)
 })
 
-test('names the template in the error when it has no default export', () => {
-  const out = generateTemplateRegistry([pageTemplate], config)
+test('names the template in the error when it has no default export', async () => {
+  const out = await generateServerRegistry([pageTemplate], config)
 
   // Without the module loaded up front, React would otherwise fail with a bare
   // "invalid element type" and no clue which template is at fault
@@ -61,8 +75,8 @@ test('names the template in the error when it has no default export', () => {
   assert.match(out, /if \(!templateModule\.default\)/)
 })
 
-test('server registry loads templates without a Suspense boundary', () => {
-  const out = generateTemplateRegistry([pageTemplate], config)
+test('server registry loads templates without a Suspense boundary', async () => {
+  const out = await generateServerRegistry([pageTemplate], config)
 
   // An async Server Component awaits inline; next/dynamic would wrap the
   // template in Suspense and break notFound()'s hold on the status code.
@@ -70,15 +84,15 @@ test('server registry loads templates without a Suspense boundary', () => {
   assert.doesNotMatch(out, /^import .* from 'next\/dynamic'/m)
 })
 
-test('metadata-only templates still carry no component', () => {
-  const out = generateTemplateRegistry([protectedTemplate], config)
+test('metadata-only templates still carry no component', async () => {
+  const out = await generateServerRegistry([protectedTemplate], config)
 
   assert.match(out, /component: null/)
   assert.doesNotMatch(out, /layout\.meta'\)\)/)
 })
 
 test('client registry defers the import through next/dynamic', async () => {
-  const out = await generateTemplateRegistryClient([pageTemplate], config)
+  const out = await generateClientRegistry([pageTemplate], config)
 
   assert.match(out, /import dynamic from 'next\/dynamic'/)
   assert.match(
@@ -87,3 +101,259 @@ test('client registry defers the import through next/dynamic', async () => {
   )
   assert.doesNotMatch(out, /^import ClientTemplate_\d+ from/m)
 })
+
+// --- a template file with no default export registers as metadata-only (#197) --
+
+async function writeThemeTemplate(root, relativePath, content) {
+  const absolutePath = join(root, 'contents/themes/testtheme/templates', relativePath)
+  await mkdir(dirname(absolutePath), { recursive: true })
+  await writeFile(absolutePath, content, 'utf8')
+  return `@/contents/themes/testtheme/templates/${relativePath}`
+}
+
+async function writeAppRoute(root, appPath, content = 'export default function Page() { return null }\n') {
+  const absolutePath = join(root, appPath)
+  await mkdir(dirname(absolutePath), { recursive: true })
+  await writeFile(absolutePath, content, 'utf8')
+}
+
+test('a layout template with no default export is registered as metadata-only, like a .meta.ts file', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'nextspark-template-registry-test-'))
+  try {
+    const templatePath = await writeThemeTemplate(
+      root,
+      'docs/layout.tsx',
+      "export const metadata = { title: 'Docs' }\n"
+    )
+    const template = {
+      name: 'docs/layout',
+      themeName: 'testtheme',
+      templateType: 'layout',
+      fileName: 'layout.tsx',
+      relativePath: 'docs/layout.tsx',
+      appPath: 'app/docs/layout.tsx',
+      templatePath,
+      priority: 10
+    }
+
+    const out = await generateServerRegistry([template], { outputDir: '/tmp/registries', projectRoot: root })
+
+    assert.match(out, /'app\/docs\/layout\.tsx': \{\n\s*appPath: 'app\/docs\/layout\.tsx',\n\s*component: null,/)
+    assert.doesNotMatch(out, /layout'\)\)/)
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('a layout template exported through `export { X as default }` is registered as a deferred import', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'nextspark-template-registry-test-'))
+  try {
+    const templatePath = await writeThemeTemplate(
+      root,
+      'docs/layout.tsx',
+      'function DocsLayout({ children }) { return children }\nexport { DocsLayout as default }\n'
+    )
+    const template = {
+      name: 'docs/layout',
+      themeName: 'testtheme',
+      templateType: 'layout',
+      fileName: 'layout.tsx',
+      relativePath: 'docs/layout.tsx',
+      appPath: 'app/docs/layout.tsx',
+      templatePath,
+      priority: 10
+    }
+
+    const out = await generateServerRegistry([template], { outputDir: '/tmp/registries', projectRoot: root })
+
+    assert.match(
+      out,
+      /component: lazyTemplate\('app\/docs\/layout\.tsx', \(\) => import\('@\/contents\/themes\/testtheme\/templates\/docs\/layout'\)\)/
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+// --- a page template with no default export is metadata-only only over an app page that already exists (#197) --
+
+test('a page template with no default export and no existing app page fails the registry build with a clear message', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'nextspark-template-registry-test-'))
+  try {
+    const templatePath = await writeThemeTemplate(root, 'docs/page.tsx', "export const metadata = { title: 'Docs' }\n")
+    const template = {
+      name: 'docs/page',
+      themeName: 'testtheme',
+      templateType: 'page',
+      fileName: 'page.tsx',
+      relativePath: 'docs/page.tsx',
+      appPath: 'app/docs/page.tsx',
+      templatePath,
+      priority: 10
+    }
+
+    // No app/docs/page.tsx written - the page generator would write one importing
+    // this template's (missing) default export.
+    await assert.rejects(
+      () => generateServerRegistry([template], { outputDir: '/tmp/registries', projectRoot: root }),
+      error => {
+        assert.match(error.message, new RegExp(templatePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')))
+        assert.match(error.message, /no existing route at "app\/docs\/page\.tsx"/)
+        assert.match(error.message, /default export/)
+        assert.match(error.message, /\.meta\.ts/)
+        return true
+      }
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('a page template with no default export overriding an existing app page is registered as metadata-only', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'nextspark-template-registry-test-'))
+  try {
+    const templatePath = await writeThemeTemplate(root, 'docs/page.tsx', "export const metadata = { title: 'Docs' }\n")
+    await writeAppRoute(root, 'app/docs/page.tsx')
+    const template = {
+      name: 'docs/page',
+      themeName: 'testtheme',
+      templateType: 'page',
+      fileName: 'page.tsx',
+      relativePath: 'docs/page.tsx',
+      appPath: 'app/docs/page.tsx',
+      templatePath,
+      priority: 10
+    }
+
+    const out = await generateServerRegistry([template], { outputDir: '/tmp/registries', projectRoot: root })
+
+    assert.match(out, /'app\/docs\/page\.tsx': \{\n\s*appPath: 'app\/docs\/page\.tsx',\n\s*component: null,/)
+    assert.doesNotMatch(out, /page'\)\)/)
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+// --- segment config is only validated for a template the page generator writes a route file for (#197) --
+
+test('a page template with a default export and an invalid segment config export does not fail the registry build', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'nextspark-template-registry-test-'))
+  try {
+    // revalidate = 60 * 60 is an expression, not a literal - a generated route
+    // file couldn't carry it, but this app page already exists, so none is generated.
+    const templatePath = await writeThemeTemplate(
+      root,
+      'pricing/page.tsx',
+      'export const revalidate = 60 * 60\nexport default function Page() { return null }\n'
+    )
+    await writeAppRoute(root, 'app/pricing/page.tsx')
+    const template = {
+      name: 'pricing/page',
+      themeName: 'testtheme',
+      templateType: 'page',
+      fileName: 'page.tsx',
+      relativePath: 'pricing/page.tsx',
+      appPath: 'app/pricing/page.tsx',
+      templatePath,
+      priority: 10
+    }
+
+    const out = await generateServerRegistry([template], { outputDir: '/tmp/registries', projectRoot: root })
+
+    assert.match(
+      out,
+      /component: lazyTemplate\('app\/pricing\/page\.tsx', \(\) => import\('@\/contents\/themes\/testtheme\/templates\/pricing\/page'\)\)/
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+// --- a standalone .meta.ts page needs an existing app page too, same as a .tsx with no default export (#197) --
+
+test('a standalone .meta.ts page template with no existing app page fails the registry build with a clear message', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'nextspark-template-registry-test-'))
+  try {
+    // A standalone .meta.ts never has a default export - it only exports metadata.
+    const templatePath = await writeThemeTemplate(root, 'docs/page.meta.ts', "export const metadata = { title: 'Docs' }\n")
+    const template = {
+      name: 'docs/page',
+      themeName: 'testtheme',
+      templateType: 'page',
+      fileName: 'page.meta.ts',
+      relativePath: 'docs/page.meta.ts',
+      appPath: 'app/docs/page.tsx',
+      templatePath,
+      priority: 10
+    }
+
+    // No app/docs/page.tsx - the page generator would write one importing this
+    // .meta.ts file's (nonexistent) default export.
+    await assert.rejects(
+      () => generateServerRegistry([template], { outputDir: '/tmp/registries', projectRoot: root }),
+      error => {
+        assert.match(error.message, new RegExp(templatePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')))
+        assert.match(error.message, /no existing route at "app\/docs\/page\.tsx"/)
+        return true
+      }
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('a standalone .meta.ts page template overriding an existing app page is registered as metadata-only', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'nextspark-template-registry-test-'))
+  try {
+    const templatePath = await writeThemeTemplate(root, 'docs/page.meta.ts', "export const metadata = { title: 'Docs' }\n")
+    await writeAppRoute(root, 'app/docs/page.tsx')
+    const template = {
+      name: 'docs/page',
+      themeName: 'testtheme',
+      templateType: 'page',
+      fileName: 'page.meta.ts',
+      relativePath: 'docs/page.meta.ts',
+      appPath: 'app/docs/page.tsx',
+      templatePath,
+      priority: 10
+    }
+
+    const out = await generateServerRegistry([template], { outputDir: '/tmp/registries', projectRoot: root })
+
+    assert.match(out, /'app\/docs\/page\.tsx': \{\n\s*appPath: 'app\/docs\/page\.tsx',\n\s*component: null,/)
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+// --- both registries take the default-export answer from the same analysis (#197) --
+
+test('a layout with no default export is component: null on the server and has no entry at all on the client', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'nextspark-template-registry-test-'))
+  try {
+    // viewport isn't one of hasServerOnlyExports' patterns, so nothing but the
+    // default-export answer keeps this out of the client registry.
+    const templatePath = await writeThemeTemplate(root, 'docs/layout.tsx', "export const viewport = { themeColor: 'black' }\n")
+    const template = {
+      name: 'docs/layout',
+      themeName: 'testtheme',
+      templateType: 'layout',
+      fileName: 'layout.tsx',
+      relativePath: 'docs/layout.tsx',
+      appPath: 'app/docs/layout.tsx',
+      templatePath,
+      priority: 10
+    }
+    const config = { outputDir: '/tmp/registries', projectRoot: root }
+    const analysis = await analyzeTemplates([template], config)
+
+    const serverOut = await generateTemplateRegistry([template], config, analysis)
+    assert.match(serverOut, /'app\/docs\/layout\.tsx': \{\n\s*appPath: 'app\/docs\/layout\.tsx',\n\s*component: null,/)
+
+    const clientOut = await generateTemplateRegistryClient([template], config, analysis)
+    assert.doesNotMatch(clientOut, /app\/docs\/layout\.tsx/)
+    assert.doesNotMatch(clientOut, /docs\/layout'\)\)/)
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})

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

@@ -0,0 +1,128 @@
+/**
+ * Tests for the plan of app/(templates) that sync:app asks core for: what the
+ * registry build would create, replace and remove, worked out against app/ as
+ * the sync about to run leaves it, with nothing written.
+ *
+ * Run: node --test packages/core/scripts/build/registry/__tests__/templates-plan.test.mjs
+ */
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { execFileSync } from 'node:child_process'
+import { mkdtemp, mkdir, writeFile, readFile, rm } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { generateMissingPages } from '../post-build/page-generator.mjs'
+
+const coreDir = join(dirname(fileURLToPath(import.meta.url)), '../../../..')
+const SHOP_LAYOUT = 'export default function ShopLayout({ children }) { return children }\n'
+const PAGE = 'export default function Page() { return null }\n'
+
+async function writeProjectFile(root, relativePath, content) {
+  await mkdir(dirname(join(root, relativePath)), { recursive: true })
+  await writeFile(join(root, relativePath), content, 'utf8')
+}
+
+/** A project whose theme has a page template under app/shop, which has a layout of its own. */
+async function createProject() {
+  const root = await mkdtemp(join(tmpdir(), 'nextspark-templates-plan-test-'))
+  await writeProjectFile(root, 'app/shop/layout.tsx', SHOP_LAYOUT)
+  await writeProjectFile(root, 'contents/themes/testtheme/templates/shop/pricing/page.tsx', PAGE)
+  return root
+}
+
+/** The page template as template discovery reports it. */
+const pricingTemplate = {
+  name: 'shop/pricing/page',
+  themeName: 'testtheme',
+  templateType: 'page',
+  fileName: 'page.tsx',
+  relativePath: 'shop/pricing/page.tsx',
+  appPath: 'app/shop/pricing/page.tsx',
+  templatePath: '@/contents/themes/testtheme/templates/shop/pricing/page.tsx',
+  priority: 10
+}
+
+/** Run templates-plan.mjs for `root`, with `appFiles` on stdin, and return its result. */
+function plan(root, appFiles = {}) {
+  const output = execFileSync(process.execPath, ['scripts/build/templates-plan.mjs'], {
+    cwd: coreDir,
+    input: JSON.stringify(appFiles),
+    encoding: 'utf8',
+    env: { ...process.env, NEXTSPARK_PROJECT_ROOT: root, NEXT_PUBLIC_ACTIVE_THEME: 'testtheme' }
+  })
+  const line = output.split('\n').find(candidate => candidate.startsWith('nextspark-templates-plan:'))
+  assert.ok(line, `no result in:\n${output}`)
+  return JSON.parse(line.slice('nextspark-templates-plan:'.length))
+}
+
+test('a tree not generated yet is planned as created, and a stray file in it as removed, with nothing written', async () => {
+  const root = await createProject()
+  try {
+    await writeProjectFile(root, 'app/(templates)/no-confirm.txt', 'mine\n')
+
+    assert.deepEqual(plan(root), {
+      create: ['app/(templates)/shop/layout.tsx', 'app/(templates)/shop/pricing/page.tsx'],
+      replace: [],
+      remove: ['app/(templates)/no-confirm.txt']
+    })
+    assert.equal(await readFile(join(root, 'app/(templates)/no-confirm.txt'), 'utf8'), 'mine\n')
+    assert.equal(existsSync(join(root, 'app/(templates)/shop')), false)
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('the copy of an app layout the sync is about to change is planned as replaced, though the layout on disk still matches it', async () => {
+  const root = await createProject()
+  try {
+    await generateMissingPages([pricingTemplate], { projectRoot: root })
+    const copy = await readFile(join(root, 'app/(templates)/shop/layout.tsx'), 'utf8')
+
+    assert.deepEqual(plan(root), { create: [], replace: [], remove: [] })
+    assert.deepEqual(plan(root, { 'app/shop/layout.tsx': `// @nextspark-generated tag line\n${SHOP_LAYOUT}` }), {
+      create: [],
+      replace: ['app/(templates)/shop/layout.tsx'],
+      remove: []
+    })
+    assert.equal(await readFile(join(root, 'app/(templates)/shop/layout.tsx'), 'utf8'), copy)
+    assert.equal(existsSync(join(root, '.nextspark/backups')), false)
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('a route the sync is about to create takes the template route file out of the plan as removed', async () => {
+  const root = await createProject()
+  try {
+    await generateMissingPages([pricingTemplate], { projectRoot: root })
+
+    assert.deepEqual(plan(root, { 'app/shop/pricing/page.tsx': PAGE }), {
+      create: [],
+      replace: [],
+      remove: ['app/(templates)/shop/pricing/page.tsx']
+    })
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('a route the sync is about to remove puts the template route file back in the plan as created', async () => {
+  const root = await createProject()
+  try {
+    await writeProjectFile(root, 'app/shop/pricing/page.tsx', PAGE)
+    await generateMissingPages([pricingTemplate], { projectRoot: root })
+
+    assert.deepEqual(plan(root), { create: [], replace: [], remove: [] })
+    assert.deepEqual(plan(root, { 'app/shop/pricing/page.tsx': null }), {
+      create: ['app/(templates)/shop/pricing/page.tsx'],
+      replace: [],
+      remove: []
+    })
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})