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

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

@@ -0,0 +1,209 @@
+/**
+ * Tests for what the registry build and its plan print: every call to the
+ * console is escaped where it prints, once the console is guarded - as the
+ * scripts that run the build guard it before anything loads - so a name that
+ * holds a character that breaks or reorders a line, in a file of the project
+ * or in the project's own path, starts no line of its own.
+ *
+ * Run: node --test packages/core/scripts/build/registry/__tests__/build-output.test.mjs
+ */
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import { copyFile, chmod, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { errorWithLines, guardConsole, logFailure, messageLines, shownLine, stackLines } from '../../../utils/index.mjs'
+
+const CORE_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', '..')
+
+/** A name that, printed raw, starts lines of its own - one reading as the build succeeding - erases a line, returns the carriage and separates or reorders lines. */
+const FORGED = 'forged\n✅ Registry System built successfully!\n\u001b[2K\r\u2028\u0085\u202e'
+const SHOWN = 'forged\\n✅ Registry System built successfully!\\n\\u001b[2K\\r\\u2028\\u0085\\u202e'
+
+const RAW_CONTROL = /[\u0000-\u0009\u000b-\u001f\u007f-\u009f\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]/
+
+async function createProject(parent = tmpdir(), name = 'nextspark-build-output-test-') {
+  const root = await mkdtemp(join(parent, name))
+  await writeFile(join(root, '.env'), 'NEXT_PUBLIC_ACTIVE_THEME=acme\n')
+  await writeFile(join(root, 'package.json'), '{}')
+  await mkdir(join(root, 'app'))
+  return root
+}
+
+/** What a script of core's build printed for the project, stdout and stderr, as lines, and its exit code. */
+function run(script, root, args = [], env = {}) {
+  const result = spawnSync('node', [join('scripts', 'build', script), ...args], {
+    cwd: CORE_DIR,
+    env: { ...process.env, NEXTSPARK_PROJECT_ROOT: root, ...env },
+    encoding: 'utf8',
+    input: '{}',
+  })
+  return { status: result.status, lines: `${result.stdout}${result.stderr}`.split('\n') }
+}
+
+/** What is wrong with the lines a script printed: a raw control, or more lines reading as the build succeeding than it printed itself. */
+function wrongLines(label, lines, successes = 0) {
+  return [
+    ...lines.filter(line => RAW_CONTROL.test(line)).map(line => `${label}: ${JSON.stringify(line)} holds a raw control`),
+    ...(lines.filter(line => line.trim() === '✅ Registry System built successfully!').length > successes ? [`${label}: a line reads as the build succeeding that it did not print`] : []),
+  ]
+}
+
+/** Run `print` with the console captured and guarded, returning each line printed. */
+function printedBy(print) {
+  const printed = []
+  const original = { log: console.log, error: console.error }
+  const capture = (...args) => { printed.push(args.join(' ')) }
+  console.log = capture
+  console.error = capture
+  guardConsole()
+  try {
+    print()
+  } finally {
+    Object.assign(console, original)
+  }
+  return printed.join('\n').split('\n')
+}
+
+test('a line the console prints is escaped whole, keeping the blank lines and the indent around it', () => {
+  assert.equal(shownLine('   plain line'), '   plain line')
+  assert.equal(shownLine('\n   blank line before and after\n'), '\n   blank line before and after\n')
+  assert.equal(shownLine(`   named ${FORGED} here`), `   "named ${SHOWN} here"`)
+  assert.equal(shownLine(`\n✅ ${FORGED}\n`), `\n"✅ ${SHOWN}"\n`)
+
+  const lines = printedBy(() => {
+    console.log('📦 Output: %s', FORGED)
+    console.error(`   ${FORGED}`)
+    console.log()
+  })
+  assert.deepEqual(lines, [`"📦 Output: ${SHOWN}"`, `   "${SHOWN}"`, ''])
+})
+
+test("an error's own lines are printed one by one, and a newline anywhere else in its message, or in a path its stack names, stays on its line", async () => {
+  const multiline = errorWithLines(['permissions.config.ts has keys no entity matches:', '  ❌ "tasks" - No entity found with this slug', '\u001b[2Kerased'])
+  assert.deepEqual(messageLines(multiline), multiline.lines)
+  assert.deepEqual(messageLines(new Error(`one line ${FORGED}`)), [`one line ${FORGED}`])
+  assert.deepEqual(printedBy(() => logFailure('Build failed', multiline)), [
+    '❌ Build failed: permissions.config.ts has keys no entity matches:',
+    '  ❌ "tasks" - No entity found with this slug',
+    '"\\u001b[2Kerased"',
+  ])
+
+  const root = await mkdtemp(join(tmpdir(), 'nextspark-build-output-test-'))
+  try {
+    const error = await copyFile(join(root, `missing${FORGED}`), join(root, `copy\n${FORGED}`)).then(() => null, error => error)
+    assert.ok(error, 'copying a missing file fails')
+    const stack = stackLines(error)
+    assert.equal(stack[0], `Error: ${error.message}`)
+    assert.ok(stack.slice(1).every(line => line.startsWith('    at ')), 'each other line is a frame')
+
+    const lines = printedBy(() => logFailure('Build failed', error, true))
+    assert.deepEqual(lines.filter(line => RAW_CONTROL.test(line)), [])
+    assert.deepEqual(lines.filter(line => line.trim() === '✅ Registry System built successfully!'), [])
+    assert.equal(lines[0], `"❌ Build failed: ENOENT: no such file or directory, copyfile '${root}/missing${SHOWN}' -> '${root}/copy\\n${SHOWN}'"`)
+    assert.equal(lines[1], `"Error: ENOENT: no such file or directory, copyfile '${root}/missing${SHOWN}' -> '${root}/copy\\n${SHOWN}'"`)
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('a directory in app/(templates) the build cannot read is named escaped where the build stops before writing and where its plan fails', { skip: process.getuid?.() === 0 }, async () => {
+  const root = await createProject()
+  const unreadable = join(root, 'app', '(templates)', FORGED)
+  try {
+    await mkdir(join(root, 'contents/themes/acme/templates/pricing'), { recursive: true })
+    await writeFile(join(root, 'contents/themes/acme/templates/pricing/page.tsx'), 'export default function Page() { return null }\n')
+    await mkdir(unreadable, { recursive: true })
+    await chmod(unreadable, 0)
+
+    const build = run('registry.mjs', root, ['--verbose'])
+    const plan = run('templates-plan.mjs', root)
+
+    const wrong = [...wrongLines('build', build.lines), ...wrongLines('plan', plan.lines)]
+    if (!build.lines.includes(`   "app/(templates)/${SHOWN} can't be read"`)) wrong.push('build: the check does not name the directory escaped')
+    if (!plan.lines.some(line => line.startsWith('"EACCES: permission denied, scandir ') && line.endsWith(`/app/(templates)/${SHOWN}'"`))) wrong.push('plan: the failure does not name the directory escaped')
+    assert.equal(build.status, 1)
+    assert.equal(plan.status, 1)
+    assert.deepEqual(wrong, [])
+  } finally {
+    await chmod(unreadable, 0o755).catch(() => {})
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('a theme template the build rejects is named escaped where it is discovered and where the build and its plan reject it', async () => {
+  const root = await createProject()
+  try {
+    await mkdir(join(root, 'contents/themes/acme/templates', FORGED), { recursive: true })
+    await writeFile(join(root, 'contents/themes/acme/templates', FORGED, 'page.tsx'), 'export const metadata = { title: "no default export" }\n')
+
+    const build = run('registry.mjs', root, ['--verbose'])
+    const plan = run('templates-plan.mjs', root)
+
+    const wrong = [...wrongLines('build', build.lines), ...wrongLines('plan', plan.lines)]
+    const rejected = `@/contents/themes/acme/templates/${SHOWN}/page.tsx has no default export, and the app has no existing route at \\"app/${SHOWN}/page.tsx\\"`
+    if (!build.lines.includes(`   "Template: app/${SHOWN}/page.tsx → @/contents/themes/acme/templates/${SHOWN}/page.tsx"`)) wrong.push('build: discovery does not name the template escaped')
+    if (!build.lines.some(line => line.startsWith(`"❌ Build failed: ${rejected}`))) wrong.push('build: the failure does not name the template escaped')
+    if (!plan.lines.some(line => line.startsWith(`"${rejected}`))) wrong.push('plan: the failure does not name the template escaped')
+    assert.equal(build.status, 1)
+    assert.equal(plan.status, 1)
+    assert.deepEqual(wrong, [])
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('a theme template whose route-level exports the build cannot read is named escaped where the build and its plan reject it', async () => {
+  const sources = [
+    ['segment config it would not read', 'export default function Page() { return null }\nconst revalidate = 60\nexport { revalidate }\n', ':3: segment config export \\"revalidate\\"'],
+    ['source that does not parse', 'export default function Page( { return null\n', ':1: the template does not parse'],
+  ]
+  const wrong = []
+  for (const [label, source, problem] of sources) {
+    const root = await createProject()
+    try {
+      await mkdir(join(root, 'contents/themes/acme/templates', FORGED), { recursive: true })
+      await writeFile(join(root, 'contents/themes/acme/templates', FORGED, 'page.tsx'), source)
+
+      const build = run('registry.mjs', root, ['--verbose'])
+      const plan = run('templates-plan.mjs', root)
+
+      wrong.push(...wrongLines(`${label}, build`, build.lines), ...wrongLines(`${label}, plan`, plan.lines))
+      const named = `${join(root, 'contents/themes/acme/templates')}/${SHOWN}/page.tsx${problem}`
+      if (!build.lines.some(line => line.startsWith(`"❌ Build failed: ${named}`))) wrong.push(`${label}, build: the failure does not name the template escaped`)
+      if (!plan.lines.some(line => line.startsWith(`"${named}`))) wrong.push(`${label}, plan: the failure does not name the template escaped`)
+      if (build.status !== 1 || plan.status !== 1) wrong.push(`${label}: build exited ${build.status} and plan ${plan.status}`)
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  }
+  assert.deepEqual(wrong, [])
+})
+
+test("a project whose own path holds characters that break or reorder a line starts no line of its own in what the build prints, built or refused for its environment", async () => {
+  const parent = await mkdtemp(join(tmpdir(), 'nextspark-build-output-test-'))
+  try {
+    const root = await createProject(parent, `${FORGED}-`)
+    await mkdir(join(root, 'contents/themes/acme/templates/pricing'), { recursive: true })
+    await writeFile(join(root, 'contents/themes/acme/templates/pricing/page.tsx'), 'export default function Page() { return null }\n')
+
+    const built = run('registry.mjs', root, ['--verbose'])
+    const wrong = wrongLines('built', built.lines, 1)
+    if (built.status !== 0) wrong.push(`built: exited ${built.status}`)
+    if (!built.lines.some(line => line.startsWith('"[dotenv@') && line.includes(SHOWN))) wrong.push("built: dotenv's line does not name the project escaped")
+
+    const bare = await mkdtemp(join(parent, `${FORGED}-bare-`))
+    const refused = run('registry.mjs', bare, [], { NEXT_PUBLIC_ACTIVE_THEME: '' })
+    wrong.push(...wrongLines('refused', refused.lines))
+    if (refused.status !== 1) wrong.push(`refused: exited ${refused.status}`)
+    if (!refused.lines.some(line => line.includes('Create a .env file in your project root: ') && line.includes(SHOWN))) wrong.push('refused: the fix does not name the project escaped')
+
+    assert.deepEqual(wrong, [])
+  } finally {
+    await rm(parent, { recursive: true, force: true })
+  }
+})

package/scripts/build/registry/__tests__/copy-race-child.mjs

@@ -0,0 +1,14 @@
+/**
+ * Runs `copyFileSync` from a project's `projectFiles`, from a FIFO source into a
+ * destination that the parent process swaps for a symlink while this process is
+ * blocked opening that FIFO - after safe-fs's own check already ran.
+ */
+import { projectFiles } from '../../safe-fs.mjs'
+
+const [, , root, source, destination] = process.argv
+try {
+  projectFiles(root).copyFileSync(source, destination)
+  process.stdout.write(JSON.stringify({ ok: true }))
+} catch (error) {
+  process.stdout.write(JSON.stringify({ code: error.code }))
+}

package/scripts/build/registry/__tests__/direct-fs-writes.mjs

@@ -0,0 +1,203 @@
+/**
+ * Finds where a source file can change the file system without going through
+ * core's safe-fs: an fs module imported whole, a named import of anything
+ * other than a call that only reads, an fs module re-exported, and an fs module
+ * named as the argument of a call - require, import(), createRequire(...)(),
+ * process.binding - whose result can't be followed. Reads are listed by name,
+ * so a call fs adds that changes things is found without being listed.
+ *
+ * And which files are the generator's: the ones under the directories given,
+ * less tests, and every file they import from under the same package, however
+ * deep, so a module added to what those files load is looked at too.
+ *
+ * @module core/scripts/build/registry/__tests__/direct-fs-writes
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
+import { dirname, join, relative, resolve, sep } from 'path'
+import ts from 'typescript'
+
+/** The modules that reach the file system. */
+export const FS_MODULES = new Set(['fs', 'node:fs', 'fs/promises', 'node:fs/promises', 'fs-extra', 'graceful-fs'])
+
+/** What may be imported by name from them: calls and values that read, and nothing that writes, creates, renames or removes. */
+export const READ_ONLY = new Set([
+  'access',
+  'accessSync',
+  'constants',
+  'createReadStream',
+  'Dirent',
+  'existsSync',
+  'lstat',
+  'lstatSync',
+  'opendir',
+  'opendirSync',
+  'pathExists',
+  'pathExistsSync',
+  'readdir',
+  'readdirSync',
+  'readFile',
+  'readFileSync',
+  'readJson',
+  'readJsonSync',
+  'readlink',
+  'readlinkSync',
+  'realpath',
+  'realpathSync',
+  'stat',
+  'Stats',
+  'statSync',
+  'unwatchFile',
+  'watch',
+  'watchFile',
+])
+
+const SOURCE_EXTENSIONS = ['.mjs', '.js', '.cjs', '.ts', '.mts', '.cts']
+
+function scriptKind(fileName) {
+  return fileName.endsWith('ts') ? ts.ScriptKind.TS : ts.ScriptKind.JS
+}
+
+function parse(source, fileName) {
+  return ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, scriptKind(fileName))
+}
+
+function moduleName(node) {
+  return node && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) ? node.text : null
+}
+
+/**
+ * Each place in `source` that can change the file system without safe-fs, by
+ * line, with what it is.
+ *
+ * @param {string} source - The file's text
+ * @param {string} fileName - Its name, for its language
+ * @returns {{ line: number, what: string }[]}
+ */
+export function directFsWrites(source, fileName) {
+  const file = parse(source, fileName)
+  const found = []
+  const add = (node, what) => {
+    found.push({ line: file.getLineAndCharacterOfPosition(node.getStart(file)).line + 1, what })
+  }
+
+  const visit = node => {
+    if (ts.isImportDeclaration(node) && FS_MODULES.has(moduleName(node.moduleSpecifier))) {
+      const clause = node.importClause
+      const from = moduleName(node.moduleSpecifier)
+      if (clause && !clause.isTypeOnly) {
+        if (clause.name) add(node, `imports ${from} whole, as ${clause.name.text}`)
+        const bindings = clause.namedBindings
+        if (bindings && ts.isNamespaceImport(bindings)) add(node, `imports ${from} whole, as ${bindings.name.text}`)
+        if (bindings && ts.isNamedImports(bindings)) {
+          for (const element of bindings.elements) {
+            const name = (element.propertyName ?? element.name).text
+            if (!element.isTypeOnly && !READ_ONLY.has(name)) add(element, `imports ${name} from ${from}`)
+          }
+        }
+      }
+    } else if (ts.isExportDeclaration(node) && FS_MODULES.has(moduleName(node.moduleSpecifier))) {
+      add(node, `re-exports ${moduleName(node.moduleSpecifier)}`)
+    } else if (
+      ts.isImportEqualsDeclaration(node) &&
+      ts.isExternalModuleReference(node.moduleReference) &&
+      FS_MODULES.has(moduleName(node.moduleReference.expression))
+    ) {
+      add(node, `imports ${moduleName(node.moduleReference.expression)} whole, as ${node.name.text}`)
+    } else if (ts.isCallExpression(node)) {
+      for (const argument of node.arguments) {
+        const name = moduleName(argument)
+        if (FS_MODULES.has(name)) add(node, `loads ${name} with a call`)
+      }
+    }
+    ts.forEachChild(node, visit)
+  }
+  visit(file)
+  return found
+}
+
+/** The relative module specifiers `source` imports, re-exports or loads with import(). */
+function localSpecifiers(source, fileName) {
+  const file = parse(source, fileName)
+  const specifiers = []
+  const visit = node => {
+    if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && moduleName(node.moduleSpecifier)?.startsWith('.')) {
+      specifiers.push(moduleName(node.moduleSpecifier))
+    } else if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      const name = moduleName(node.arguments[0])
+      if (name?.startsWith('.')) specifiers.push(name)
+    }
+    ts.forEachChild(node, visit)
+  }
+  visit(file)
+  return specifiers
+}
+
+/** The file a relative specifier names: as written, a TypeScript source for a .js name, or with an extension added. */
+function resolveSpecifier(fromFile, specifier) {
+  const base = resolve(dirname(fromFile), specifier)
+  const candidates = [
+    base,
+    base.replace(/\.js$/, '.ts'),
+    base.replace(/\.mjs$/, '.mts'),
+    ...SOURCE_EXTENSIONS.map(extension => `${base}${extension}`),
+    ...SOURCE_EXTENSIONS.map(extension => join(base, `index${extension}`)),
+  ]
+  return candidates.find(candidate => existsSync(candidate) && statSync(candidate).isFile()) ?? null
+}
+
+function isTest(path) {
+  return path.split(sep).includes('__tests__') || /\.test\.[cm]?[jt]s$/.test(path)
+}
+
+function sourcesUnder(directory) {
+  const files = []
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const path = join(directory, entry.name)
+    if (entry.isDirectory()) {
+      if (entry.name !== 'node_modules' && entry.name !== '__tests__') files.push(...sourcesUnder(path))
+    } else if (entry.isFile() && SOURCE_EXTENSIONS.some(extension => entry.name.endsWith(extension)) && !isTest(path)) {
+      files.push(path)
+    }
+  }
+  return files
+}
+
+/**
+ * The generator's files: every source under `directories` that is not a test,
+ * `entries`, and whatever those import from under `within`, followed to the end.
+ *
+ * @param {{ directories?: string[], entries?: string[], within: string }} options
+ * @returns {string[]} Absolute paths, sorted
+ */
+export function generatorFiles({ directories = [], entries = [], within }) {
+  const seen = new Set()
+  const pending = [...directories.flatMap(sourcesUnder), ...entries.map(entry => resolve(entry))]
+  while (pending.length > 0) {
+    const file = pending.pop()
+    if (seen.has(file)) continue
+    seen.add(file)
+    for (const specifier of localSpecifiers(readFileSync(file, 'utf8'), file)) {
+      const target = resolveSpecifier(file, specifier)
+      if (target && !relative(within, target).startsWith('..') && !isTest(target)) pending.push(target)
+    }
+  }
+  return [...seen].sort()
+}
+
+/**
+ * Each place, in each of `files` other than `allowed`, that can change the file
+ * system without safe-fs, as `path:line what` from `base`.
+ *
+ * @param {string[]} files - Absolute paths
+ * @param {{ base: string, allowed?: string[] }} options
+ * @returns {string[]}
+ */
+export function directFsWritesIn(files, { base, allowed = [] }) {
+  const exempt = new Set(allowed.map(path => resolve(path)))
+  return files
+    .filter(file => !exempt.has(file))
+    .flatMap(file =>
+      directFsWrites(readFileSync(file, 'utf8'), file).map(({ line, what }) => `${relative(base, file)}:${line} ${what}`)
+    )
+}

package/scripts/build/registry/__tests__/globals-css-tag.test.mjs

@@ -0,0 +1,66 @@
+/**
+ * Tests for how the registry build keeps app/globals.css's generated tag when it
+ * points the file's import at another theme: a file sync:app tagged and nobody
+ * changed since keeps an intact tag, and a file the project changed keeps the
+ * tag it had, which no longer matches.
+ *
+ * Run: node --test packages/core/scripts/build/registry/__tests__/globals-css-tag.test.mjs
+ */
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { createHash } from 'node:crypto'
+import { mkdtemp, mkdir, writeFile, readFile, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { syncAppGlobalsCss } from '../../theme.mjs'
+
+const hashOf = text => createHash('sha256').update(text.replace(/\r\n/g, '\n')).digest('hex')
+
+/** A globals.css as sync:app writes it: the tag line, then the file. */
+function taggedGlobals(body, hash = hashOf(body)) {
+  return `/* @nextspark-generated core@1.0.0 path=app/globals.css sha256=${hash} */\n${body}`
+}
+
+/** A project with two themes, whose app/globals.css is `content`. */
+async function projectWith(content) {
+  const root = await mkdtemp(join(tmpdir(), 'nextspark-globals-css-tag-'))
+  for (const theme of ['acme', 'other']) {
+    await mkdir(join(root, 'contents/themes', theme, 'styles'), { recursive: true })
+    await writeFile(join(root, 'contents/themes', theme, 'styles/globals.css'), 'body {}\n')
+  }
+  await mkdir(join(root, 'app'), { recursive: true })
+  await writeFile(join(root, 'app/globals.css'), content)
+  return { root, config: { projectRoot: root, themesDir: join(root, 'contents/themes') } }
+}
+
+test('pointing an intact tagged globals.css at another theme leaves its tag intact', async () => {
+  const body = '@import "../contents/themes/acme/styles/globals.css";\n\n.custom {}\n'
+  const { root, config } = await projectWith(taggedGlobals(body))
+  try {
+    assert.equal(syncAppGlobalsCss(config, 'other'), true)
+
+    const [tagLine, ...rest] = (await readFile(join(root, 'app/globals.css'), 'utf8')).split('\n')
+    const newBody = rest.join('\n')
+    assert.match(newBody, /@import "\.\.\/contents\/themes\/other\/styles\/globals\.css";/)
+    assert.equal(tagLine, `/* @nextspark-generated core@1.0.0 path=app/globals.css sha256=${hashOf(newBody)} */`)
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('pointing a customized globals.css at another theme leaves its tag as it was', async () => {
+  const body = '@import "../contents/themes/acme/styles/globals.css";\n\n.custom {}\n'
+  const staleTag = taggedGlobals(body, hashOf('what sync wrote before the project changed it\n'))
+  const { root, config } = await projectWith(staleTag)
+  try {
+    assert.equal(syncAppGlobalsCss(config, 'other'), true)
+
+    const content = await readFile(join(root, 'app/globals.css'), 'utf8')
+    assert.equal(content.split('\n')[0], staleTag.split('\n')[0])
+    assert.match(content, /@import "\.\.\/contents\/themes\/other\/styles\/globals\.css";/)
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})