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

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 })
+  }
+})