@metaobjectsdev/cli 1.0.9 → 1.0.11

package/src/lib/name-lint.ts

@@ -0,0 +1,106 @@
+// `meta verify` — the node-name AUTHORING lint.
+//
+// The loader accepts any string as a node `name`, on every port. An adopter's metadata
+// carried a field named `"defaultCurrencyId "` (a trailing space, copied from legacy XML)
+// and an identity named `"account_defaultCurrencyId _fk"`; both loaded with no error.
+//
+// WHY THIS IS A WARNING AND NOT A LOAD ERROR. It was weighed against the correction bar
+// in docs/compatibility-policy.md and does not pass it: whitespace names WORK today on
+// the core path — `meta migrate` emits a quoted column (`"default_currency_id "`) and the
+// ObjectManager round-trips the key — and multi-word requirement names are documented to
+// load. Refusing them at load would break metadata that does what its author asked, so
+// the honest instrument is an advisory that names the edit.
+//
+// EVERY FINDING IS A WARNING, BY CONSTRUCTION — the same rule, and the same reasoning,
+// as requirement-lint.ts's header. Nothing here reaches the exit code.
+//
+// REQUIREMENTS ARE NOT LINTED HERE. A requirement's name is its dotted ADDRESS and the
+// requirement lint already owns it (WARN_REQUIREMENT_NAME_NOT_ADDRESSABLE reports
+// leading/trailing whitespace; a short multi-word label such as "Order Recording" is
+// deliberately NOT reported, because renaming one moves its address and its emitted
+// stub file for no gain). Reporting the same name twice under two codes would make
+// one edit look like two problems.
+//
+// IT READS THE LOADED MODEL, NEVER THE FILES — and walks DECLARATIONS (see `walk`).
+
+import { PACKAGE_SEPARATOR, TYPE_FIELD, TYPE_REQUIREMENT, type MetaData } from "@metaobjectsdev/metadata";
+import type { Diagnostic } from "./requirement-check.js";
+
+/** Leading or trailing whitespace — the strong finding. */
+export const WARN_NAME_SURROUNDING_WHITESPACE = "WARN_NAME_SURROUNDING_WHITESPACE";
+/** Whitespace inside an otherwise trimmed name — the plain advisory. */
+export const WARN_NAME_INTERNAL_WHITESPACE = "WARN_NAME_INTERNAL_WHITESPACE";
+
+/**
+ * What counts as whitespace: the ECMAScript `\s` class. That is ASCII space, tab, LF,
+ * CR, VT and FF, plus U+00A0 (no-break space), U+FEFF, U+1680, U+2000–U+200A, U+2028,
+ * U+2029, U+202F, U+205F and U+3000. The non-ASCII members matter for this lint's
+ * actual source of input: a no-break space survives a copy out of a document or a
+ * legacy export and is invisible in every editor.
+ */
+const WHITESPACE = /\s/u;
+
+function warn(path: string, code: string, message: string): Diagnostic {
+  return { severity: "warn", code, path, message };
+}
+
+/** One segment of a node's address. A name with whitespace is quoted so the
+ *  whitespace is visible in the printed path rather than vanishing into it. */
+function segment(name: string): string {
+  return WHITESPACE.test(name) ? JSON.stringify(name) : name;
+}
+
+function check(node: MetaData, path: string, out: Diagnostic[]): void {
+  const name = node.name;
+  if (name === "" || !WHITESPACE.test(name)) return;
+
+  const kind = `${node.type}.${node.subType}`;
+  const quoted = JSON.stringify(name);
+  // @column is a FIELD attribute. Advising an object or identity author to pin it
+  // would send them looking for a slot that does not exist on the node.
+  const pin = node.type === TYPE_FIELD ? ", and pin @column if the physical column must keep its name" : "";
+  const trimmed = name.trim();
+
+  if (trimmed !== name) {
+    const inner = WHITESPACE.test(trimmed) ? " It also contains whitespace inside it." : "";
+    const target = trimmed === "" ? "" : ` (to ${JSON.stringify(trimmed)}, presumably)`;
+    out.push(warn(path, WARN_NAME_SURROUNDING_WHITESPACE,
+      `${kind} name ${quoted} has leading or trailing whitespace, which is almost certainly ` +
+      `unintended — rename it${target}${pin}. The whitespace is carried into every identifier, ` +
+      `column and wire key derived from the name.${inner}`));
+    return;
+  }
+
+  out.push(warn(path, WARN_NAME_INTERNAL_WHITESPACE,
+    `${kind} name ${quoted} contains whitespace. A name is an identifier: derived column names ` +
+    `and wire keys carry the space, and generated code cannot use it as one. Consider ` +
+    `renaming it${pin}.`));
+}
+
+/** A root-level node's address: package-qualified the way `resolutionKey()` is, so the
+ *  path reads like every other reference to the node. */
+function topLevelAddress(node: MetaData): string {
+  const pkg = node.package ?? node.fileDefaultPackage;
+  return pkg !== undefined && pkg !== "" ? `${pkg}${PACKAGE_SEPARATOR}${segment(node.name)}` : segment(node.name);
+}
+
+/**
+ * Lint the name of every named node in the loaded model, requirements excepted.
+ * Returns `[]` for a model with no whitespace in any name.
+ */
+export function lintNodeNames(root: MetaData): Diagnostic[] {
+  const out: Diagnostic[] = [];
+  const walk = (n: MetaData, prefix: string): void => {
+    // OWN-ONLY (ADR-0039 sanctioned case): this reports each DECLARATION once, at the
+    // node that declares it. A field inherited through `extends` is one declaration and
+    // one rename; the resolving `children()` would repeat it on every subtype.
+    for (const c of n.ownChildren()) {
+      if (c.type === TYPE_REQUIREMENT) continue; // owned by requirement-lint.ts — see header
+      const path = prefix === "" ? topLevelAddress(c) : `${prefix}.${segment(c.name)}`;
+      check(c, path, out);
+      walk(c, path);
+    }
+  };
+  walk(root, "");
+  return out;
+}

package/src/lib/output.ts

@@ -47,8 +47,9 @@ export interface GenFileEntry {
 export interface GenResultShape {
   files: GenFileEntry[];
   outDir: string;
-  /** Absent for a value-object-only project (no DB code generated → no dialect used). */
-  dialect: Dialect | undefined;
+  /** Absent for a value-object-only project (no DB code generated → no dialect used). The
+   *  CODEGEN dialect, which may be `mysql` (a dialect `meta migrate` does not speak). */
+  dialect: Dialect | "mysql" | undefined;
   dryRun: boolean;
   warnings: string[];
   /**

package/src/lib/requirement-check.ts

@@ -675,14 +675,58 @@ export function summariseRequirements(
     // `exactOptionalPropertyTypes`, so the keys are absent rather than undefined.
   };
 
-  for (const req of reqs) {
+  // `undecided` counts only the requirements a `@disposition` could actually
+  // SETTLE. A parent is `partial` because a descendant is, so a disposition on it
+  // would have to mean "we accept that memory is incomplete" — which settles
+  // nothing, names no work, and cannot be acted on.
+  //
+  // Measured on a real ledger before this was written: one adopter's tree printed
+  // "19 recorded gap(s) with no @disposition", and SIXTEEN of the nineteen were
+  // roll-up parents (`assistant`, `memory`, `security`, `understanding`,
+  // `conversation`, `growth`, `action`). Three were leaves anyone could rule on.
+  // Overstating by 6x is not cosmetic: a count nobody can action is a count
+  // everybody learns to skip, and the real gaps then ride along inside it
+  // invisibly — the opposite of what the line exists to do.
+  //
+  // Ancestry comes from the scan's own dotted PATHS rather than a second
+  // traversal, so this cannot disagree with how every other check addresses a
+  // node. `::` carries no dot, so splitting on "." keeps a package-qualified root
+  // segment intact. EVERY ancestor is excluded, not only the immediate parent:
+  // real ledgers are five deep, and an L1 node three levels above the work is no
+  // more actionable than the L2 one.
+  //
+  // A descendant marks its ancestors whether or not it is itself DISPOSED, and
+  // that asymmetry is the point. Once the only outstanding leaf under a parent has
+  // been ruled on, nothing beneath that parent is owed — so the parent must not be
+  // resurrected as a fresh decision by the roll-up status the ruled-on child gave
+  // it. Skipping disposed descendants here would do exactly that: it was the first
+  // implementation, and the test for the disposed-child tree caught it.
+  const rollUpAncestors = new Set<string>();
+  for (const { node, path } of scan.addressed) {
+    if (!node.hasOutstandingWork()) continue;
+    const segments = path.split(".");
+    for (let i = 1; i < segments.length; i++) {
+      rollUpAncestors.add(segments.slice(0, i).join("."));
+    }
+  }
+
+  for (const { node: req, path } of scan.addressed) {
     if (req.subType === REQUIREMENT_SUBTYPE_ARCHITECTURAL) summary.architectural++;
     else summary.functional++;
 
     const status = req.status();
+    // byStatus is UNCHANGED on purpose: a roll-up parent is still genuinely
+    // `partial`, and the status breakdown is where that belongs. Only the
+    // "decisions owed" line narrows.
     if (status !== undefined) summary.byStatus[status] = (summary.byStatus[status] ?? 0) + 1;
 
-    if (req.hasOutstandingWork() && req.disposition() === undefined) summary.undecided++;
+    if (
+      req.hasOutstandingWork() &&
+      req.disposition() === undefined &&
+      !rollUpAncestors.has(path)
+    ) {
+      summary.undecided++;
+    }
     if (req.disposition() === REQUIREMENT_DISPOSITION_DEFERRED && req.trackedBy().length === 0) {
       summary.deferredUntracked++;
     }

package/src/lib/runtime-boundary-advisory.ts

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { OWNED_RUNTIME_DIR, HTTP_RUNTIME_PACKAGE } from "@metaobjectsdev/codegen-ts";
+
+/**
+ * Generated code that imports the owned HTTP-adapter copy from OUTSIDE its own
+ * workspace package.
+ *
+ * Since 1.0.9 an ejected `entity` / `routes` / `routes-hono` generator points its output
+ * at `codegen/runtime/` (the adapter source `meta eject` copied) by a path relative to
+ * the output directory. In a single-package project that is exactly right. In a monorepo
+ * whose output sits inside a workspace package (`apps/api/src/generated`), the path climbs
+ * out of that package: `tsc` rejects the file (`TS6059 … is not under 'rootDir'`), and the
+ * copy's own bare imports (`qs`, `fastify`) do not resolve from the repository root. The
+ * `meta gen` run itself is green; the adopter's build is the first thing that disagrees.
+ *
+ * Found upgrading a pnpm monorepo. This names the package and the two ways out. It is a
+ * warning and never changes an exit code.
+ */
+export interface RuntimeBoundaryFinding {
+  /** Project-relative directory of the workspace package the generated file sits in. */
+  packageDir: string;
+  /** One generated file (project-relative) that crosses the boundary. */
+  example: string;
+}
+
+const IMPORT_SPEC = /\bfrom\s+["'](\.{1,2}\/[^"']+)["']/g;
+
+function nearestPackageDir(fileDir: string, projectRoot: string): string | undefined {
+  for (let d = fileDir; ; d = dirname(d)) {
+    if (d === projectRoot || !d.startsWith(projectRoot + sep)) return undefined;
+    if (existsSync(join(d, "package.json"))) return d;
+  }
+}
+
+function isInside(child: string, parent: string): boolean {
+  return child === parent || child.startsWith(parent + sep);
+}
+
+export function findRuntimeBoundaryCrossings(
+  projectRoot: string,
+  generatedFiles: readonly string[],
+): RuntimeBoundaryFinding[] {
+  const root = resolve(projectRoot);
+  const runtimeRoot = join(root, OWNED_RUNTIME_DIR);
+  const byPackage = new Map<string, RuntimeBoundaryFinding>();
+  for (const file of generatedFiles) {
+    if (!/\.(ts|tsx|mts)$/.test(file) || !existsSync(file)) continue;
+    const abs = resolve(file);
+    const pkgDir = nearestPackageDir(dirname(abs), root);
+    if (pkgDir === undefined || isInside(runtimeRoot, pkgDir) || byPackage.has(pkgDir)) continue;
+    const text = readFileSync(abs, "utf8");
+    for (const m of text.matchAll(IMPORT_SPEC)) {
+      if (isInside(resolve(dirname(abs), m[1]!), runtimeRoot)) {
+        byPackage.set(pkgDir, {
+          packageDir: relative(root, pkgDir).split(sep).join("/"),
+          example: relative(root, abs).split(sep).join("/"),
+        });
+        break;
+      }
+    }
+  }
+  return [...byPackage.values()];
+}
+
+export function runtimeBoundaryWarnings(findings: readonly RuntimeBoundaryFinding[]): string[] {
+  return findings.map((f) =>
+    `generated code in ${f.packageDir}/ imports the owned HTTP adapter from ${OWNED_RUNTIME_DIR}/, ` +
+    `outside that workspace package (e.g. ${f.example}); its build will not resolve it. ` +
+    `Either keep importing the published adapter — pass \`runtimeImport: "${HTTP_RUNTIME_PACKAGE}"\` ` +
+    `to the ejected entity/routes generators — or move ${OWNED_RUNTIME_DIR}/ inside ${f.packageDir}/ ` +
+    `and point \`runtimeImport\` at it.`,
+  );
+}