@metaobjectsdev/cli 0.24.3 → 0.24.5

package/dist/src/lib/package-manifest.js

@@ -0,0 +1,52 @@
+// One answer to "what does this project declare as a dependency".
+//
+// Three commands ask it — `meta init` (is this package already declared, or must the
+// scaffold add it?), `meta eject` (will the ejected file's imports resolve, or does the
+// adopter's tsc report TS2307?), and stack detection (which frameworks is this project
+// on?). They had three hand-rolled JSON-parse-and-union blocks covering DIFFERENT field
+// sets, and the asymmetry was the cost: `eject` reported a peer-declared package as
+// missing and told the adopter to install what they already had — advice that, followed,
+// adds a second physical copy of a package whose class identity is load-bearing (the
+// ts-poet split in 0.21.6 and the metadata node-guard split are both that bug).
+//
+// A fix to one had no way to find the other two: nothing referenced anything, and no
+// shared name connected them to a grep.
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Every package name the manifest declares, across ALL FOUR dependency fields.
+ *
+ * All four, because the question every caller is really asking is "will this resolve,
+ * and will their typecheck be happy" — not "is it in one particular field". A library
+ * consuming MetaObjects through `peerDependencies` (the correct declaration for a
+ * package whose consumer supplies the version) has it declared, and so does one using
+ * `optionalDependencies`.
+ */
+export function declaredDependencyNames(pkg) {
+    const out = new Set();
+    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+        for (const name of Object.keys(pkg[field] ?? {}))
+            out.add(name);
+    }
+    return out;
+}
+/**
+ * Read and parse `<cwd>/package.json`.
+ *
+ * `undefined` distinguishes "no readable manifest" from "a manifest declaring nothing",
+ * which callers report differently: with no manifest there is nothing to compare
+ * against, so the honest message names what a file needs rather than claiming it is
+ * missing from a list that was never read.
+ */
+export function readPackageManifest(cwd) {
+    const path = join(cwd, "package.json");
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=package-manifest.js.map

package/dist/src/lib/package-manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-manifest.js","sourceRoot":"","sources":["../../../src/lib/package-manifest.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,EAAE;AACF,qFAAqF;AACrF,wFAAwF;AACxF,uFAAuF;AACvF,wFAAwF;AACxF,oFAAoF;AACpF,yFAAyF;AACzF,qFAAqF;AACrF,gFAAgF;AAChF,EAAE;AACF,qFAAqF;AACrF,wCAAwC;AACxC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAUjC;;;;;;;;GAQG;AACH,MAAM,UAAU,uBAAuB,CAAC,GAAoB;IAC1D,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;IAC9B,KAAK,MAAM,KAAK,IAAI,CAAC,cAAc,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,sBAAsB,CAAU,EAAE,CAAC;QAC7G,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;YAAE,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAW;IAC7C,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;IACvC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;QAAE,OAAO,SAAS,CAAC;IACxC,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAoB,CAAC;IACnE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metaobjectsdev/cli",
-  "version": "0.24.3",
+  "version": "0.24.5",
   "description": "CLI for MetaObjects: scaffold, codegen, migrate, and drift-detection commands.",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -49,15 +49,15 @@
   ],
   "dependencies": {
     "@libsql/kysely-libsql": "^0.4.0",
-    "@metaobjectsdev/codegen-ts": "0.24.3",
-    "@metaobjectsdev/codegen-ts-react": "0.24.3",
-    "@metaobjectsdev/codegen-ts-tanstack": "0.24.3",
-    "@metaobjectsdev/docs-site": "0.24.3",
-    "@metaobjectsdev/metadata": "0.24.3",
-    "@metaobjectsdev/migrate-ts": "0.24.3",
-    "@metaobjectsdev/render": "0.24.3",
-    "@metaobjectsdev/runtime-ts": "0.24.3",
-    "@metaobjectsdev/sdk": "0.24.3",
+    "@metaobjectsdev/codegen-ts": "0.24.5",
+    "@metaobjectsdev/codegen-ts-react": "0.24.5",
+    "@metaobjectsdev/codegen-ts-tanstack": "0.24.5",
+    "@metaobjectsdev/docs-site": "0.24.5",
+    "@metaobjectsdev/metadata": "0.24.5",
+    "@metaobjectsdev/migrate-ts": "0.24.5",
+    "@metaobjectsdev/render": "0.24.5",
+    "@metaobjectsdev/runtime-ts": "0.24.5",
+    "@metaobjectsdev/sdk": "0.24.5",
     "@toon-format/toon": "^2.3.0",
     "jiti": "^2.4.0"
   },
@@ -76,7 +76,7 @@
     "@types/pg": "^8.0.0",
     "bun-types": "latest",
     "drizzle-orm": "^0.45.1",
-    "fastify": "^4.28.1",
+    "fastify": "^5.6.2",
     "kysely": "^0.27.0",
     "pg": "^8.0.0",
     "pg-mem": "^3.0.4",

package/src/commands/eject.ts

@@ -0,0 +1,282 @@
+// FR-040 §4.2(a) — `meta eject <generator>` takes ownership of any reference-template
+// generator, in any package, at any time after `meta init`. ADR-0034 scaffold-and-own
+// has `init` copy four of them eagerly (entity, queries, routes, barrel); this is the
+// SAME copy operation, generalised to every ejectable name and callable on demand — for
+// a generator you skipped at init time, or one a package gained since.
+import { mkdir, writeFile, stat, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { cliVersion } from "../lib/version.js";
+import * as coreTpl from "@metaobjectsdev/codegen-ts";
+import * as reactTpl from "@metaobjectsdev/codegen-ts-react";
+import * as tanstackTpl from "@metaobjectsdev/codegen-ts-tanstack";
+import { parseEjectArgs } from "../lib/args.js";
+import { log } from "../lib/log.js";
+import { declaredDependencyNames, readPackageManifest } from "../lib/package-manifest.js";
+
+// Mirrors `OWNED_GENERATORS_DIR` in init.ts's `writeOwnedGenerators` — same directory,
+// same never-clobber-without-consent contract. Kept as its own local constant rather
+// than shared: eject is a standalone operation on ANY name, not a byproduct of init,
+// and the two call sites have no other state in common worth coupling over one string.
+const OWNED_GENERATORS_DIR = "codegen/generators";
+
+interface TemplateSource {
+  packageName: string;
+  names: readonly string[];
+  /** That package's own `src/reference/` directory. */
+  root: () => string;
+}
+
+// One registry, three packages — a package that gains templates later registers itself
+// here and `meta eject` picks it up with no other change.
+//
+// Each entry exposes its reference ROOT rather than a read function. The packages' own
+// `readReferenceTemplate` narrows its parameter to a literal union, so calling it with
+// a CLI-supplied `string` used to need a generic `asserts name is N` helper — ~20 lines
+// to re-establish, for the compiler, a fact `resolveSource` has ALREADY established at
+// runtime by selecting this entry via `names.includes(name)`. Reading from the root
+// deletes that machinery without weakening anything: membership is still checked, once,
+// where the untrusted value enters.
+const SOURCES: TemplateSource[] = [
+  {
+    packageName: "@metaobjectsdev/codegen-ts",
+    names: coreTpl.REFERENCE_GENERATOR_NAMES,
+    root: coreTpl.resolveReferenceRoot,
+  },
+  {
+    packageName: "@metaobjectsdev/codegen-ts-react",
+    names: reactTpl.REFERENCE_GENERATOR_NAMES,
+    root: reactTpl.resolveReferenceRoot,
+  },
+  {
+    packageName: "@metaobjectsdev/codegen-ts-tanstack",
+    names: tanstackTpl.REFERENCE_GENERATOR_NAMES,
+    root: tanstackTpl.resolveReferenceRoot,
+  },
+];
+
+function resolveSource(name: string): TemplateSource | undefined {
+  return SOURCES.find((s) => s.names.includes(name));
+}
+
+/** Every ejectable name, in registry order (stable — matches `meta eject --list`). */
+export function ejectableNames(): string[] {
+  return SOURCES.flatMap((s) => s.names);
+}
+
+// Every reference template's header documents its own paste-ready import line, e.g.
+// codegen-ts/src/reference/entity.ts:
+//   // Then import it LOCALLY in metaobjects.config.ts:
+//   //   import { entityFile } from "./codegen/generators/entity.js";
+// Extracting it here — rather than re-deriving an export symbol from the file name —
+// means eject can never drift from what the template itself already tells a human to
+// paste, and needs no per-name export-symbol map: a generator's exported symbol does
+// NOT follow its file name (`hooks.ts` exports `tanstackQuery`, `routes-hono.ts`
+// exports `routesFileHono`, `grid.ts` exports `tanstackGrid`).
+const HEADER_IMPORT_RE = /^\/\/\s+(import \{ \w+ \} from "\.\/codegen\/generators\/[\w.-]+\.js";)\s*$/m;
+
+/** The bound symbol out of the already-validated import line — same single source of
+ *  truth as the line itself, so the "replace this binding" message can never name a
+ *  symbol the template does not actually export. */
+function extractExportName(importLine: string, name: string): string {
+  const match = /^import \{ (\w+) \}/.exec(importLine);
+  if (!match?.[1]) {
+    throw new Error(`reference template "${name}" has an unparseable import line: ${importLine}`);
+  }
+  return match[1];
+}
+
+function extractImportLine(templateSource: string, name: string): string {
+  const match = HEADER_IMPORT_RE.exec(templateSource);
+  if (!match?.[1]) {
+    throw new Error(
+      `reference template "${name}" has no documented "// import { ... }" header line — ` +
+        "cannot report the import line to paste.",
+    );
+  }
+  return match[1];
+}
+
+async function fileExists(p: string): Promise<boolean> {
+  try {
+    return (await stat(p)).isFile();
+  } catch {
+    return false;
+  }
+}
+
+export interface EjectOptions {
+  cwd: string;
+  name: string;
+  /** Overwrite an already-ejected file. Without it, eject NEVER clobbers — matching
+   *  `writeOwnedGenerators`'s unconditional preserve-if-present rule in init.ts. */
+  force?: boolean;
+}
+
+export interface EjectResult {
+  path: string;
+  importLine: string;
+  /** The symbol the template exports — the binding to REPLACE in the config. */
+  exportName: string;
+  /** The package the generator currently comes from, i.e. the import to remove. */
+  packageName: string;
+  /** Advisory lines about packages the ejected file imports but the project lacks. */
+  dependencyNotes: string[];
+  status: "created" | "preserved";
+}
+
+/** The `@metaobjectsdev/*` packages an ejected template imports, read from the file
+ *  itself rather than from a per-name table — the template is the only thing that
+ *  knows, and a table would drift from it the moment a template gains an import. */
+function requiredPackages(templateSource: string): string[] {
+  const found = new Set<string>();
+  // The optional trailing group matches a SUBPATH and is deliberately not captured: what
+  // has to be installed is the package, and `@metaobjectsdev/metadata/constants` is a
+  // real, documented subpath this codebase already uses (the browser-safe pure-constants
+  // entry). Requiring the closing quote straight after the package name — as this did —
+  // made any such import match nothing at all, so a template gaining one would get no
+  // note. That is the drift this function exists to prevent, reappearing inside the
+  // function itself.
+  for (const m of templateSource.matchAll(/from\s+"(@metaobjectsdev\/[\w-]+)(?:\/[\w./-]+)?"/g)) {
+    if (m[1] !== undefined) found.add(m[1]);
+  }
+  return [...found].sort();
+}
+
+/**
+ * An ejected file is ordinary source in the adopter's repo, so its imports must be
+ * declared dependencies or their `tsc` reports TS2307 on the file we just told them
+ * they own — and under a strict (pnpm/npm) node_modules layout `meta gen` cannot
+ * resolve it either. `meta init` already calls this out by ADDING the two packages its
+ * four scaffolded generators need; the on-demand templates import two more
+ * (codegen-ts-react, codegen-ts-tanstack) that nothing declares.
+ *
+ * This REPORTS rather than edits: init is a scaffolder writing a whole project and has
+ * a manifest in hand, while eject copies one file into a repo whose dependency policy
+ * (workspace protocol, catalog, pinned ranges) is the adopter's. Naming the exact
+ * missing package and the version to match is the useful half; silently rewriting
+ * someone's manifest is not.
+ */
+export async function dependencyNotesForTemplate(cwd: string, templateSource: string): Promise<string[]> {
+  const required = requiredPackages(templateSource);
+  if (required.length === 0) return [];
+
+  const pkg = readPackageManifest(cwd);
+  if (pkg === undefined) {
+    // No readable manifest — say what the file needs and let the adopter place it.
+    return [`This file imports: ${required.join(", ")}. Make sure each is installed.`];
+  }
+  const declared = declaredDependencyNames(pkg);
+
+  const missing = required.filter((p) => !declared.has(p));
+  if (missing.length === 0) return [];
+  return [
+    `The ejected file imports ${missing.join(", ")}, which your package.json does not ` +
+    "declare — your typecheck will report TS2307 until it does. Install with:",
+    `  npm i -D ${missing.map((p) => `${p}@^${cliVersion()}`).join(" ")}`,
+  ];
+}
+
+export async function ejectGenerator(opts: EjectOptions): Promise<EjectResult> {
+  const source = resolveSource(opts.name);
+  if (source === undefined) {
+    throw new Error(
+      `unknown generator "${opts.name}". Ejectable generators: ${ejectableNames().join(", ")}. ` +
+        "Run `meta eject --list` to see them grouped by package.",
+    );
+  }
+
+  const templateSource = await readFile(join(source.root(), `${opts.name}.ts`), "utf8");
+  const importLine = extractImportLine(templateSource, opts.name);
+  const exportName = extractExportName(importLine, opts.name);
+  const rel = `${OWNED_GENERATORS_DIR}/${opts.name}.ts`;
+  const abs = join(opts.cwd, rel);
+  const notes = await dependencyNotesForTemplate(opts.cwd, templateSource);
+  const common = {
+    path: rel,
+    importLine,
+    exportName,
+    packageName: source.packageName,
+    dependencyNotes: notes,
+  };
+
+  if (!opts.force && (await fileExists(abs))) {
+    return { ...common, status: "preserved" };
+  }
+
+  await mkdir(join(opts.cwd, OWNED_GENERATORS_DIR), { recursive: true });
+  await writeFile(abs, templateSource, "utf8");
+  return { ...common, status: "created" };
+}
+
+function listOutput(): string {
+  const lines: string[] = [];
+  lines.push("Ejectable generators (copy any of these into codegen/generators/ and own it):");
+  lines.push("");
+  for (const source of SOURCES) {
+    lines.push(`${source.packageName}:`);
+    lines.push(`  ${source.names.join(", ")}`);
+    lines.push("");
+  }
+  lines.push("Run: meta eject <name>");
+  return lines.join("\n");
+}
+
+export async function ejectCommand(args: string[], cwd: string): Promise<number> {
+  let flags;
+  try {
+    flags = parseEjectArgs(args);
+  } catch (err) {
+    log.error((err as Error).message);
+    return 2;
+  }
+
+  if (flags.list) {
+    log.info(listOutput());
+    return 0;
+  }
+
+  if (flags.name === undefined) {
+    log.error("meta eject requires a generator name, or --list to see what's ejectable.");
+    return 2;
+  }
+
+  try {
+    const result = await ejectGenerator({ cwd, name: flags.name, force: flags.force });
+    if (result.status === "preserved") {
+      log.info(`${result.path} already exists — left untouched (pass --force to overwrite).`);
+    } else {
+      log.info(`Ejected "${flags.name}" -> ${result.path}. You own it now (ADR-0034 scaffold-and-own).`);
+    }
+    // REPLACE, never "paste". A generator reaches `generators: [...]` under ONE binding,
+    // so a reader told to "paste" gets a duplicate identifier at best — and at worst
+    // deletes nothing, keeps `formFile()` in the array bound to the PACKAGE import, and
+    // silently runs the packaged generator while editing the ejected file. That failure
+    // is invisible and is the exact one ejecting exists to prevent.
+    //
+    // But eject reads no config, so it cannot know WHICH of the three states this project
+    // is in, and stating one of them as fact is wrong in the other two — including for the
+    // four `meta init` scaffolds, whose config already imports from ./codegen/generators/,
+    // which is precisely the `meta eject <name> --force` re-sync case. Name the goal, then
+    // the three branches; the reader knows which one they are looking at.
+    log.info(`In metaobjects.config.ts, "${result.exportName}" must resolve to this file:`);
+    log.info(`  ${result.importLine}`);
+    log.info(
+      `  - If it is imported from "${result.packageName}", REPLACE that import with the ` +
+      "line above. Adding a second one leaves `generators` bound to the PACKAGED " +
+      "generator, and your edits to this file do nothing.",
+    );
+    log.info(
+      "  - If it is already imported from ./codegen/generators/ (what `meta init` " +
+      "scaffolds), it points here already — nothing to change.",
+    );
+    log.info(
+      `  - If ${result.exportName}() is not in \`generators\` yet, add the import above ` +
+      "AND the entry.",
+    );
+    for (const line of result.dependencyNotes) log.info(line);
+    return 0;
+  } catch (err) {
+    log.error((err as Error).message);
+    return 1;
+  }
+}