@xhulz/nina 0.30.0 → 0.31.0

package/src/commands/upgrade.mjs

@@ -15,7 +15,8 @@ import { spawnSync } from 'node:child_process';
 import { HARNESS, legacyHint } from '../paths.mjs';
 import { existsSync, lstatSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { composeProject, composedPaths, defaultedSlots, layerRootFor } from './compose.mjs';
+import { composeProject, composedPaths, defaultedSlots, layerRootFor, walk } from './compose.mjs';
+import { NEEDS, detected } from '../surfaces.mjs';
 import { filledSlots, projectSlots, referencedVocabulary } from './check.mjs';
 import { EXPECT_ENV } from '../expected.mjs';
 import { closeAnswered } from './learn.mjs';
@@ -213,6 +214,13 @@ export async function upgrade(argv, ctx) {
     .map((e) => e.name);
   const gone = surfaces.filter((s) => !available.includes(s));
   const kept = surfaces.filter((s) => available.includes(s));
+  // A surface the target release adds that this project's own files show it has. When a stack is split out
+  // of a concern — `prisma` out of `db` — its rules go with it, and a project that does not declare it loses
+  // them in silence: the rules that were in its specs yesterday are not there after the move.
+  const offeredBefore = (await readdir(join(from.dir, 'surfaces'), { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+  const offered = detected(await walk(target)).filter(
+    (d) => available.includes(d.surface) && !offeredBefore.includes(d.surface) && !surfaces.includes(d.surface) && (!NEEDS[d.surface] || kept.includes(NEEDS[d.surface])),
+  );
 
   const [vocabBefore, vocabAfter] = [
     await referencedVocabulary(from.dir, surfaces, target),
@@ -236,6 +244,11 @@ export async function upgrade(argv, ctx) {
 
   console.log(`  ${profile.core} → ${to}\n`);
 
+  if (offered.length > 0) {
+    console.log(`  ✗ ${offered.length} surface(s) ${to} adds that this project's files show it has — undeclared, their rules leave its specs:`);
+    for (const d of offered) console.log(`      ${d.surface} — ${d.why}`);
+    console.log(`      add each to "surfaces" in ${HARNESS}/profile.json, or pass --force to move without them.\n`);
+  }
   if (gone.length > 0) {
     console.log(`  ✗ ${gone.length} declared surface(s) do not exist in ${to}: ${gone.join(', ')}`);
     console.log(`      a rename cannot be guessed — pick the replacement yourself, and move the`);
@@ -309,7 +322,7 @@ export async function upgrade(argv, ctx) {
     console.log('');
   }
 
-  const blocking = gone.length + stranded.length + unwired.length + occupied.length + walledOff.length;
+  const blocking = gone.length + offered.length + stranded.length + unwired.length + occupied.length + walledOff.length;
   if (!apply) {
     console.log(
       blocking > 0

package/src/surfaces.mjs

@@ -0,0 +1,33 @@
+/**
+ * What the compiler knows about surfaces beyond their layers: which ones a repository's files reveal, and
+ * which ones only make sense on top of another.
+ *
+ * A surface is a question about what the project is — does it own persistent data, does it render a screen
+ * a person looks at — and its layer states what is true of every project that answers yes. A stack is a
+ * surface too, of another kind: `prisma` is how a project reaches the database it owns, and means nothing
+ * without one. The database surface used to be both at once, and a project that owned data but had not
+ * chosen its client was told its client was Prisma, its reads went through Accelerate and its tenant was
+ * `userId`.
+ *
+ * `init`, `check` and `upgrade` all read this, so a surface's evidence and its prerequisite are stated once.
+ */
+
+/** Surfaces a repository reveals by its files. The rest are claims about the domain. */
+export const DETECTABLE = [
+  { surface: 'db', why: 'a Prisma schema', test: (f) => f.some((p) => p.endsWith('schema.prisma')) },
+  { surface: 'prisma', why: 'a Prisma schema', test: (f) => f.some((p) => p.endsWith('schema.prisma')) },
+  { surface: 'edge-cf', why: 'a wrangler config', test: (f) => f.some((p) => /(^|\/)wrangler\.(toml|jsonc?)$/.test(p)) },
+  { surface: 'frontend', why: 'a Vite config', test: (f) => f.some((p) => /(^|\/)vite\.config\.[cm]?[jt]s$/.test(p)) },
+  { surface: 'blockchain', why: 'a Foundry or Hardhat config', test: (f) => f.some((p) => /(^|\/)(foundry\.toml|hardhat\.config\.[cm]?[jt]s)$/.test(p)) },
+];
+
+/** A stack surface, and the concern it is a stack of: declared without it, its rules have nowhere to land. */
+export const NEEDS = { prisma: 'db' };
+
+/**
+ * The surfaces a project's files reveal, with the evidence for each.
+ *
+ * @param {string[]} tree - The project's files, relative to it.
+ * @returns {{surface: string, why: string}[]}
+ */
+export const detected = (tree) => DETECTABLE.filter((d) => d.test(tree)).map(({ surface, why }) => ({ surface, why }));