@metaobjectsdev/cli 1.0.9-rc.6 → 1.0.10

package/src/lib/gen-migrate-advice.ts

@@ -40,7 +40,7 @@ const VIEW_CHANGE_KINDS: ReadonlySet<Change["kind"]> = new Set(["create-view", "
 export interface GenMigrateAdviceInput {
   metadata: MetaRoot;
   /** `metaobjects.config.ts` `dialect` — undefined when no DB code is generated. */
-  dialect: "sqlite" | "postgres" | undefined;
+  dialect: "sqlite" | "postgres" | "mysql" | undefined;
   /** `.metaobjects/config.json` `migrate.dialect`, when set (may say `d1`). */
   migrateDialect: "sqlite" | "postgres" | "d1" | undefined;
   columnNamingStrategy: "snake_case" | "literal" | "kebab-case" | undefined;
@@ -55,6 +55,8 @@ export interface GenMigrateAdviceInput {
 export async function genMigrateAdvice(input: GenMigrateAdviceInput): Promise<string | undefined> {
   if (input.dialect === undefined || input.changedFiles.length === 0) return undefined;
 
+  if (input.dialect === "mysql") return mysqlAdvice(input);
+
   const d1 = d1BindingFor(input);
   const schemaDialect = d1 !== undefined ? "d1" : input.dialect;
   let built;
@@ -94,6 +96,27 @@ export async function genMigrateAdvice(input: GenMigrateAdviceInput): Promise<st
     : `migrate the schema change with \`meta migrate --db <url> --dialect ${input.dialect} --slug <name> --apply\``;
 }
 
+/**
+ * MySQL: `meta migrate` does not own the schema, so there is no migration to write. When the
+ * run touched a table-backed object, say that the adopter's DDL has to follow. The provenance
+ * (which generated file belongs to which table-backed object) does not depend on the dialect,
+ * so it is read through the Postgres expected-schema builder.
+ */
+function mysqlAdvice(input: GenMigrateAdviceInput): string | undefined {
+  let provenance: ReadonlyMap<string, string>;
+  try {
+    provenance = buildExpectedSchemaWithProvenance(input.metadata, {
+      dialect: "postgres",
+      ...(input.columnNamingStrategy !== undefined ? { columnNamingStrategy: input.columnNamingStrategy } : {}),
+    }).provenance;
+  } catch {
+    return undefined;
+  }
+  if (!touchesTableBackedObject(input.changedFiles, provenance)) return undefined;
+  return "MetaObjects does not manage a MySQL schema: apply the matching change to your MySQL DDL " +
+    "(the generated Drizzle tables describe the columns it must have)";
+}
+
 /** The project's D1 binding when it migrates through D1, else undefined. */
 function d1BindingFor(input: GenMigrateAdviceInput): D1Binding | undefined {
   if (input.dialect !== "sqlite" && input.migrateDialect !== "d1") return undefined;

package/src/lib/git-ignore.ts

@@ -17,6 +17,7 @@
 
 import { spawnSync } from "node:child_process";
 import { toPosix } from "./rel-posix.js";
+import { describeError } from "./error-text.js";
 
 /** Ignored paths, or the reason the question could not be asked. */
 export type GitIgnoreResult =
@@ -75,7 +76,7 @@ export function gitIgnored(
   try {
     res = spawnSync(gitBin, args, { encoding: "utf-8", input });
   } catch (err) {
-    return { unavailable: `git could not be run (${(err as Error).message})` };
+    return { unavailable: `git could not be run (${describeError(err)})` };
   }
   if (res.error !== undefined) {
     return { unavailable: "git is not on PATH" };

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