@metaobjectsdev/cli 1.0.0-rc.6 → 1.0.0-rc.8

package/src/lib/load-metaobjects-config.ts

@@ -141,10 +141,14 @@ function resolveCliPkg(specifier: string): string {
  * the supported home of the generators with no ownable copy), so nothing upstream of here
  * can tell a correct import from a removed one.
  *
- * It reads the config SOURCE rather than catching the throw because the throw happens inside
- * a generator factory call with no reference back to the import that produced it, and only a
- * config declaring one of these in `generators: [...]` throws at all — a stale type-only
- * import would fail silently at typecheck-time instead.
+ * It reads the config SOURCE because that is the arm that can name the FILE and the exact
+ * import. `removedGeneratorRuntimeError` below is the second arm, and an adopter estate is
+ * why there are two: the import does not have to be in the config. This project's config
+ * imported an OWNED generator — `./codegen/generators/entityFileTyped`, the shape `meta
+ * eject` itself produces — and THAT file carried the stale
+ * `import { entityFile } from "@metaobjectsdev/codegen-ts/generators"`. The source scan saw
+ * a clean config and the adopter got exactly the bare TypeError this check exists to
+ * prevent: `(0 , _generators.entityFile) is not a function`, exit 2, no file, no remedy.
  */
 const REMOVED_GENERATOR_EXPORTS = ["entityFile", "queriesFile", "routesFile", "barrel"] as const;
 const GENERATORS_SUBPATH = "@metaobjectsdev/codegen-ts/generators";
@@ -180,6 +184,39 @@ export function removedGeneratorImportError(source: string): string | undefined
   );
 }
 
+/**
+ * The same diagnostic, recovered from the THROW instead of the source — for the case the
+ * source scan structurally cannot see: a removed export imported by a module the config
+ * imports, rather than by the config itself.
+ *
+ * It cannot name the file (the TypeError carries no reference back to the import that
+ * produced it — that limitation is real, it is just not a reason to say nothing), so it
+ * names what it does know: the symbol, the removal, and the one-command remedy. Matching is
+ * on the SYMBOL, not the message shape, because the shape is the transpiler's: Bun says
+ * `(0 , _generators.entityFile) is not a function` and Node ESM says
+ * `entityFile is not a function`.
+ */
+export function removedGeneratorRuntimeError(err: unknown): string | undefined {
+  const message = err instanceof Error ? err.message : String(err ?? "");
+  if (!/is not a function/.test(message)) return undefined;
+  const hit = REMOVED_GENERATOR_EXPORTS.find((n) => new RegExp(`\\b${n}\\b`).test(message));
+  if (hit === undefined) return undefined;
+  const template = hit.replace(/File$/, "");
+  return (
+    `${hit}() is not a function — 1.0 REMOVED it from "${GENERATORS_SUBPATH}" ` +
+    `(ADR-0034 scaffold-and-own): these generators are yours to own, so the package no ` +
+    `longer ships them as an import. Your metaobjects.config.ts does not import it, so ` +
+    `the import is in a module the config imports — most often an OWNED generator under ` +
+    `codegen/generators/, which is exactly what 'meta eject' writes.\n` +
+    `  Fix — copy it into your repo:\n    meta eject ${template}\n` +
+    `  then change that module's import to: ` +
+    `import { ${hit} } from "./codegen/generators/${template}";\n` +
+    `  The subpath itself is fine — promptRender, outputParser, routesFileHono and the ` +
+    `rest still live there.\n` +
+    `  Guide: docs/features/migrations/0.x-to-1.0.md §11`
+  );
+}
+
 function rewriteImportSpecifiers(source: string, aliasMap: Record<string, string>): string {
   let result = source;
   for (const [specifier, resolvedPath] of Object.entries(aliasMap)) {
@@ -461,7 +498,18 @@ export async function loadMetaobjectsConfig(projectRoot: string): Promise<Metaob
   const prepareStackTraceBefore = Error.prepareStackTrace;
   const stackTraceLimitBefore = Error.stackTraceLimit;
   try {
-    const raw = (await jiti.import(loadPath)) as MetaobjectsGenConfig | { default: MetaobjectsGenConfig };
+    let raw: MetaobjectsGenConfig | { default: MetaobjectsGenConfig };
+    try {
+      raw = (await jiti.import(loadPath)) as MetaobjectsGenConfig | { default: MetaobjectsGenConfig };
+    } catch (err) {
+      // The second arm of the ADR-0034 diagnostic: a removed export imported by a module the
+      // config imports rather than by the config itself. Rethrown as the migration message,
+      // because what reaches the adopter otherwise is `(0 , _generators.entityFile) is not a
+      // function` — the exact unactionable failure the source scan above exists to prevent.
+      const runtime = removedGeneratorRuntimeError(err);
+      if (runtime !== undefined) throw new Error(runtime);
+      throw err;
+    }
     // jiti's interopDefault doesn't always unwrap the default export when accessed
     // across module boundaries — explicitly unwrap if present.
     const cfg = (raw && typeof raw === "object" && "default" in raw && raw.default

package/src/lib/removed-prop-advisory.ts

@@ -0,0 +1,113 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { relPosix } from "./rel-posix.js";
+import { looksBundled } from "./authored-source.js";
+import { constructText, topLevelAttrs } from "./jsx-construct.js";
+
+/**
+ * F99 — a provider still mounted with a prop 1.0 renamed away.
+ *
+ * `<EntityFetcherProvider value={f}>` does not typecheck, and both the migration note and
+ * the base-URL advisory beside this one rest a safety argument on that fact. The argument
+ * holds only where `tsc` is in the gate chain, and in two of nine adopter estates it was
+ * not: `vite build` transpiles without typechecking, and a provider with the wrong prop
+ * still RENDERS — its children mount, and nothing fails until a component that actually
+ * calls a generated hook runs, in a browser, at which point the fetcher is undefined.
+ *
+ * One estate lost a round to it, misreading a red render smoke test as the release
+ * candidate breaking. The second shipped the identical construct and carried it through a
+ * whole pass. Two of nine, same component, same prop — that is a class, and the rename
+ * was ours.
+ *
+ * Unlike the base-URL advisory this fires at ANY `apiPrefix`, because there is no
+ * configuration under which the old prop reaches the provider. It is still a WARNING and
+ * never touches an exit code: the scan cannot see a re-export or an aliased local
+ * component, so it must not be the thing that fails a build.
+ */
+export interface RemovedPropFinding {
+  file: string;
+  line: number;
+  construct: string;
+  /** The prop that no longer exists. */
+  prop: string;
+  message: string;
+}
+
+const IGNORE_SEGMENTS = new Set([
+  "node_modules", ".git", "dist", "build", ".next", ".turbo", ".output",
+  "coverage", ".metaobjects", ".wrangler",
+]);
+const SCAN_EXT = /\.(?:ts|tsx|js|jsx|mjs)$/;
+const SKIP_FILE = /(?:\.d\.ts$|\.test\.|\.spec\.)/;
+
+/**
+ * What was renamed, and to what.
+ *
+ * Deliberately a table of ONE. A rename earns a row here only when an adopter has actually
+ * shipped the old spelling past their own gates — the value is in naming the specific
+ * construct two estates got wrong, not in mirroring the changelog. `open` also gates the
+ * cheap `includes()` prefilter in the walk, so a new row needs its marker adding there.
+ */
+const RENAMES: readonly {
+  construct: string;
+  open: RegExp;
+  from: string;
+  to: string;
+  since: string;
+}[] = [
+  {
+    construct: "<EntityFetcherProvider>",
+    open: /<EntityFetcherProvider\b/g,
+    from: "value",
+    to: "fetcher",
+    since: "1.0",
+  },
+];
+
+function scanFile(rel: string, src: string): RemovedPropFinding[] {
+  const out: RemovedPropFinding[] = [];
+  for (const { construct, open, from, to, since } of RENAMES) {
+    open.lastIndex = 0;
+    let m: RegExpExecArray | null;
+    while ((m = open.exec(src)) !== null) {
+      if (!topLevelAttrs(constructText(src, m.index, "jsx")).has(from)) continue;
+      const line = src.slice(0, m.index).split("\n").length;
+      out.push({
+        file: rel, line, construct, prop: from,
+        message:
+          `${rel}:${line} — ${construct} is mounted with \`${from}\`, which ${since} ` +
+          `renamed to \`${to}\`. The provider still renders, so nothing fails until a ` +
+          `component calls a generated hook and finds no fetcher. \`tsc --noEmit\` names ` +
+          `this exactly; a build that only transpiles does not. Rename ${from} → ${to} — ` +
+          `and check baseUrl while you are here, since it is optional and defaults to "".`,
+      });
+    }
+  }
+  return out;
+}
+
+function walk(dir: string, root: string, acc: RemovedPropFinding[]): void {
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    if (IGNORE_SEGMENTS.has(e.name)) continue;
+    const abs = join(dir, e.name);
+    // Symlinked directories are NOT followed — see base-url-advisory.ts for the 41-finding
+    // ELOOP this prevents.
+    if (e.isDirectory()) { walk(abs, root, acc); continue; }
+    if (!SCAN_EXT.test(e.name) || SKIP_FILE.test(e.name)) continue;
+    let src: string;
+    try { src = readFileSync(abs, "utf8"); } catch { continue; }
+    if (!src.includes("EntityFetcherProvider")) continue;
+    // A bundle is not authored source (F89) — the fix belongs in the file it was built from.
+    if (looksBundled(src)) continue;
+    acc.push(...scanFile(relPosix(root, abs), src));
+  }
+}
+
+/** Scan a project tree for providers still using a prop 1.0 renamed away. */
+export function scanForRemovedProps(root: string): RemovedPropFinding[] {
+  const acc: RemovedPropFinding[] = [];
+  walk(root, root, acc);
+  return acc;
+}

package/src/lib/wrangler.ts

@@ -24,8 +24,56 @@ export function buildWranglerExecuteArgs(opts: WranglerExecuteOptions): string[]
 }
 
 /**
- * Run wrangler with the given args; return stdout. Stderr is included in the
- * error message when wrangler exits non-zero. `cwd` is the directory wrangler
+ * The reason to report when wrangler exits non-zero.
+ *
+ * **`--json` puts wrangler's error on STDOUT, and warnings on stderr.** This function
+ * exists because the runner used to report stderr alone, so a live D1 gate failing for
+ * want of a `CLOUDFLARE_API_TOKEN` told the adopter its cause was
+ * `▲ [WARNING] … "unsafe" fields are experimental` — a warning, named as the reason a
+ * schema gate failed, with the real cause discarded. Found by running an estate's own
+ * `verify:prod-schema` against production for the first time.
+ *
+ * Order: the structured error wrangler wrote, then stderr, then raw stdout, then the
+ * process's own message. Stderr is still consulted — a genuine wrangler failure that
+ * never reaches stdout must not be swallowed to fix the opposite mistake.
+ */
+export function wranglerFailureReason(
+  stdout: string,
+  stderr: string,
+  fallback: string,
+): string {
+  const structured = structuredWranglerError(stdout);
+  if (structured !== undefined) return structured;
+  const err = stderr.trim();
+  if (err.length > 0) return err;
+  const out = stdout.trim();
+  if (out.length > 0) return out;
+  return fallback;
+}
+
+/** wrangler's two `--json` error shapes: `{error:{text}}` / `{error}` and the
+ *  `[{success:false,error}]` execute envelope. Anything else reads as absent. */
+function structuredWranglerError(stdout: string): string | undefined {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return undefined;
+  }
+  const node = Array.isArray(parsed) ? parsed[0] : parsed;
+  if (node === null || typeof node !== "object") return undefined;
+  const { error } = node as { error?: unknown };
+  if (typeof error === "string" && error.trim().length > 0) return error.trim();
+  if (error !== null && typeof error === "object") {
+    const { text } = error as { text?: unknown };
+    if (typeof text === "string" && text.trim().length > 0) return text.trim();
+  }
+  return undefined;
+}
+
+/**
+ * Run wrangler with the given args; return stdout. The failure REASON is chosen by
+ * `wranglerFailureReason` when wrangler exits non-zero. `cwd` is the directory wrangler
  * runs in (defaults to process.cwd() — caller should pass the project root).
  */
 export type WranglerRunner = (args: string[], cwd: string) => Promise<{ stdout: string; stderr: string }>;
@@ -39,8 +87,8 @@ export const defaultWranglerRunner: WranglerRunner = async (args, cwd) => {
     if (e.code === "ENOENT") {
       throw new Error(`wrangler not found on PATH; install it: 'npm i -D wrangler'`);
     }
-    const stderr = e.stderr ?? "";
-    throw new Error(`wrangler ${args.join(" ")} failed: ${stderr || e.message}`);
+    const reason = wranglerFailureReason(e.stdout ?? "", e.stderr ?? "", e.message);
+    throw new Error(`wrangler ${args.join(" ")} failed: ${reason}`);
   }
 };