fix(cli): thread config providers into offline migrate paths (#157)

runBaseline + runOfflineGenerate called loadMemory() without the consumer
providers from metaobjects.config.ts, so a project registering a custom subtype
via a config provider hit 'Unknown type' on offline meta migrate — even though
meta gen and the DB migrate paths load the same metadata fine. Load the config
once up front in both functions and pass providers to loadMemory (folding the
later columnNamingStrategy read into that same load), mirroring the DB path.

Closes #157

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SKaSE8U5cwN4ZGFwhJwxSY

Author: dmealing

server/typescript/packages/cli/src/commands/migrate.ts

@@ -509,18 +509,27 @@ export async function runBaseline(
     }
   } else {
     let metadata;
-    try {
-      metadata = await loadMemory(metaRoot);
-    } catch (err) {
-      log.error(`migrate baseline: failed to load metadata: ${(err as Error).message}`);
-      return 2;
-    }
+    // Load metaobjects.config.ts ONCE, up front, for BOTH the consumer providers
+    // and the columnNamingStrategy — mirroring the DB path (and `meta gen`) so
+    // offline baseline resolves config-registered custom subtypes too (#157).
+    let baselineConfigProviders:
+      | readonly import("@metaobjectsdev/codegen-ts").MetaDataTypeProvider[]
+      | undefined;
     let baselineStrategy: "snake_case" | "literal" | "kebab-case" = "snake_case";
     try {
       const cfg = await loadMetaobjectsConfig(metaRoot);
+      baselineConfigProviders = cfg.providers;
       if (cfg.columnNamingStrategy) baselineStrategy = cfg.columnNamingStrategy;
     } catch {
-      // config absent — default snake_case
+      // config absent — no custom providers, default snake_case
+    }
+    try {
+      metadata = await loadMemory(metaRoot, {
+        ...(baselineConfigProviders !== undefined ? { providers: baselineConfigProviders } : {}),
+      });
+    } catch (err) {
+      log.error(`migrate baseline: failed to load metadata: ${(err as Error).message}`);
+      return 2;
     }
     const baselineViews = buildProjectionViews(metadata, { dialect: config.dialect, columnNamingStrategy: baselineStrategy });
     snapshot = baselineFromMetadata(metadata, config.dialect, baselineStrategy, baselineViews);
@@ -553,9 +562,26 @@ export async function runOfflineGenerate(
     log.error(`migrate: --dialect required for offline generation (or use --from-db)`);
     return 2;
   }
+  // Load metaobjects.config.ts ONCE, up front, for BOTH the consumer providers
+  // and the columnNamingStrategy — mirroring the DB path (and `meta gen`) so
+  // offline generate resolves config-registered custom subtypes too (#157).
+  let offlineConfigProviders:
+    | readonly import("@metaobjectsdev/codegen-ts").MetaDataTypeProvider[]
+    | undefined;
+  let offlineStrategy: "snake_case" | "literal" | "kebab-case" = "snake_case";
+  try {
+    const cfg = await loadMetaobjectsConfig(metaRoot);
+    offlineConfigProviders = cfg.providers;
+    if (cfg.columnNamingStrategy) offlineStrategy = cfg.columnNamingStrategy;
+  } catch {
+    // config absent — no custom providers, default snake_case
+  }
+
   let metadata;
   try {
-    metadata = await loadMemory(metaRoot);
+    metadata = await loadMemory(metaRoot, {
+      ...(offlineConfigProviders !== undefined ? { providers: offlineConfigProviders } : {}),
+    });
   } catch (err) {
     log.error(`migrate: failed to load metadata: ${(err as Error).message}`);
     return 2;
@@ -584,13 +610,6 @@ export async function runOfflineGenerate(
   const collectedAmbiguous: AmbiguousChange[] = [];
   const onAmbiguousResolution = mapOnAmbiguous(config.onAmbiguous);
 
-  let offlineStrategy: "snake_case" | "literal" | "kebab-case" = "snake_case";
-  try {
-    const cfg = await loadMetaobjectsConfig(metaRoot);
-    if (cfg.columnNamingStrategy) offlineStrategy = cfg.columnNamingStrategy;
-  } catch {
-    // config absent — default snake_case
-  }
   const offlineViews = buildProjectionViews(metadata, { dialect: config.dialect, columnNamingStrategy: offlineStrategy });
 
   let plan;

server/typescript/packages/cli/test/migrate-providers.test.ts

@@ -0,0 +1,121 @@
+import { describe, test, expect, afterAll } from "bun:test";
+import { mkdtemp, rm, mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runBaseline, runOfflineGenerate } from "../src/commands/migrate.js";
+
+// #157 — the offline migrate paths (baseline + offline generate) must thread the
+// consumer `providers` from metaobjects.config.ts into loadMemory, exactly like
+// `meta gen` and the DB migrate paths do. Otherwise a project that registers a
+// custom subtype via a config provider hits `Unknown type <subtype>` on offline
+// `meta migrate`, forcing a "strip the custom nodes" workaround.
+
+const dirs: string[] = [];
+afterAll(async () => {
+  for (const d of dirs) await rm(d, { recursive: true, force: true });
+});
+
+// A config that registers a custom `validator.geocheck` subtype via a provider —
+// mirrors how an adopter ships a custom subtype to gen/migrate. A validator is
+// used (not a field) so it exercises provider-threading without also depending on
+// how the migrate column-mapper handles a novel physical type.
+const CUSTOM_CONFIG = [
+  `import { defineConfig } from "@metaobjectsdev/codegen-ts";`,
+  `import { entityFile } from "@metaobjectsdev/codegen-ts/generators";`,
+  `import { TypeId, TYPE_VALIDATOR, MetaValidator } from "@metaobjectsdev/metadata";`,
+  `const geoProvider = {`,
+  `  id: "test-geocheck",`,
+  `  dependencies: ["metaobjects-core-types"],`,
+  `  registerTypes(registry) {`,
+  `    registry.register({`,
+  `      typeId: new TypeId(TYPE_VALIDATOR, "geocheck"),`,
+  `      description: "A custom validator",`,
+  `      factory: (typeId, name) => new MetaValidator(typeId, name),`,
+  `      childRules: [],`,
+  `      attributes: [],`,
+  `    });`,
+  `  },`,
+  `};`,
+  `export default defineConfig({`,
+  `  outDir: "out",`,
+  `  dialect: "postgres",`,
+  `  generators: [entityFile()],`,
+  `  providers: [geoProvider],`,
+  `});`,
+].join("\n");
+
+// An entity (writable table) whose `name` field carries the custom validator.
+// The `validator.geocheck` child resolves ONLY when the config provider loads —
+// so an offline migrate that doesn't thread providers fails at metadata load.
+const CUSTOM_META = {
+  "metadata.root": {
+    package: "acme::geo",
+    children: [
+      {
+        "object.entity": {
+          name: "Place",
+          children: [
+            { "field.long": { name: "id" } },
+            {
+              "field.string": {
+                name: "name",
+                children: [{ "validator.geocheck": { name: "chk" } }],
+              },
+            },
+            { "source.rdb": { name: "src", "@table": "places" } },
+            {
+              "identity.primary": {
+                name: "pk",
+                "@fields": ["id"],
+                "@generation": "increment",
+              },
+            },
+          ],
+        },
+      },
+    ],
+  },
+};
+
+async function customProject(): Promise<string> {
+  const root = await mkdtemp(join(tmpdir(), "mts-migprov-"));
+  dirs.push(root);
+  await mkdir(join(root, "metaobjects"), { recursive: true });
+  await writeFile(
+    join(root, "metaobjects", "meta.json"),
+    JSON.stringify(CUSTOM_META),
+    "utf8",
+  );
+  await writeFile(join(root, "metaobjects.config.ts"), CUSTOM_CONFIG, "utf8");
+  return root;
+}
+
+describe("offline migrate threads config providers (#157)", () => {
+  test("runBaseline loads a config-registered custom subtype (no strip workaround)", async () => {
+    const root = await customProject();
+    const code = await runBaseline(
+      { dialect: "postgres", outDir: "./.metaobjects/migrations", fromDb: false } as any,
+      root,
+    );
+    expect(code).toBe(0);
+  });
+
+  test("runOfflineGenerate loads a config-registered custom subtype", async () => {
+    const root = await customProject();
+    // baseline first (also needs the provider) so there is a snapshot to diff.
+    await runBaseline(
+      { dialect: "postgres", outDir: "./.metaobjects/migrations", fromDb: false } as any,
+      root,
+    );
+    const code = await runOfflineGenerate(
+      {
+        dialect: "postgres",
+        outDir: "./.metaobjects/migrations",
+        allow: [],
+        onAmbiguous: "error",
+      } as any,
+      root,
+    );
+    expect(code).toBe(0);
+  });
+});