chore: genericize sibling-project naming in codegen test fixtures

Nine TypeScript test files used a sibling project's name as a metadata package
and an abbreviated private scope as a fake npm scope. Both are placeholder
fixture values with no behavioural meaning; they are now `shop` and `@acme/`.

codegen-ts 1300 pass / 0 fail, codegen-ts-react 26/26, codegen-ts-tanstack 79/79.
(Two codegen-ts failures seen first time round were a fresh-worktree precondition
— runtime-ts had no dist — and reproduce with these edits stashed.)

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: dmealing

server/typescript/packages/cli/test/integration/gen-multi-target.test.ts

@@ -18,7 +18,7 @@ function setupRepo(): string {
       children: [
         { "object.entity": {
           name: "Program",
-          package: "mikes::commerce",
+          package: "shop::commerce",
           children: [
             { "source.rdb": {} },
             { "field.long": { name: "id", children: [
@@ -38,10 +38,10 @@ import { entityFile, queriesFile, routesFile } from "@metaobjectsdev/codegen-ts/
 import { tanstackQuery } from "@metaobjectsdev/codegen-ts-tanstack";
 export default defineConfig({
   outDir: ${JSON.stringify(join(root, "packages/database/src/generated"))},
-  importBase: "@mf/database/generated",
+  importBase: "@acme/database/generated",
   extStyle: "none", dbImport: "../index", dialect: "sqlite", outputLayout: "package", apiPrefix: "/api",
   targets: {
-    api: { outDir: ${JSON.stringify(join(root, "apps/api/src/generated"))}, dbImport: "@mf/database" },
+    api: { outDir: ${JSON.stringify(join(root, "apps/api/src/generated"))}, dbImport: "@acme/database" },
     web: { outDir: ${JSON.stringify(join(root, "apps/web/src/generated"))} },
   },
   generators: [ entityFile(), queriesFile(), routesFile({ target: "api" }), tanstackQuery({ target: "web" }) ],
@@ -57,20 +57,20 @@ describe("meta gen — multi-target end-to-end", () => {
       const exit = await run(["gen", "--cwd", root]);
       expect(exit).toBe(0);
 
-      const entityPath = join(root, "packages/database/src/generated/mikes/commerce/Program.ts");
-      const routesPath = join(root, "apps/api/src/generated/mikes/commerce/Program.routes.ts");
-      const hooksPath  = join(root, "apps/web/src/generated/mikes/commerce/Program.hooks.ts");
+      const entityPath = join(root, "packages/database/src/generated/shop/commerce/Program.ts");
+      const routesPath = join(root, "apps/api/src/generated/shop/commerce/Program.routes.ts");
+      const hooksPath  = join(root, "apps/web/src/generated/shop/commerce/Program.hooks.ts");
       expect(existsSync(entityPath)).toBe(true);
       expect(existsSync(routesPath)).toBe(true);
       expect(existsSync(hooksPath)).toBe(true);
 
       const routes = readFileSync(routesPath, "utf-8");
-      expect(routes).toContain("@mf/database/generated/mikes/commerce/Program");
-      expect(routes).toContain('from "@mf/database"');     // per-target db import
+      expect(routes).toContain("@acme/database/generated/shop/commerce/Program");
+      expect(routes).toContain('from "@acme/database"');     // per-target db import
       expect(routes).not.toContain('"./Program"');
 
       const hooks = readFileSync(hooksPath, "utf-8");
-      expect(hooks).toContain("@mf/database/generated/mikes/commerce/Program");
+      expect(hooks).toContain("@acme/database/generated/shop/commerce/Program");
       expect(hooks).not.toContain('"./Program"');
     } finally {
       rmSync(root, { recursive: true, force: true });

server/typescript/packages/codegen-ts-react/test/cross-target.test.ts

@@ -8,7 +8,7 @@ import { FileSource } from "@metaobjectsdev/metadata/core";
 // Product lives in package "shop::commerce" → package-layout path "shop/commerce/Product".
 const FIXTURE = resolve(import.meta.dir, "fixtures", "packaged-entity.json");
 
-const model: ResolvedTarget = { name: "default", outDir: "db/gen", importBase: "@mf/db/generated", outputLayout: "package", dbImport: "../index", runtime: true };
+const model: ResolvedTarget = { name: "default", outDir: "db/gen", importBase: "@acme/db/generated", outputLayout: "package", dbImport: "../index", runtime: true };
 const web:   ResolvedTarget = { name: "web", outDir: "web/gen", importBase: undefined, outputLayout: "package", dbImport: "../index", runtime: true };
 
 async function ctxFor(self: ResolvedTarget, em: ResolvedTarget) {
@@ -28,7 +28,7 @@ describe("form-file — cross target", () => {
   it("imports entity via importBase package path, not relative", async () => {
     const { entity, ctx } = await ctxFor(web, model);
     const out = renderFormFile(entity, ctx);
-    expect(out).toContain(`from "@mf/db/generated/shop/commerce/Product"`);
+    expect(out).toContain(`from "@acme/db/generated/shop/commerce/Product"`);
     expect(out).not.toContain(`from "./Product"`);
   });
   it("same target stays relative", async () => {

server/typescript/packages/codegen-ts-tanstack/test/cross-target.test.ts

@@ -9,7 +9,7 @@ import { FileSource } from "@metaobjectsdev/metadata/core";
 // Product lives in package "shop::commerce" → package-layout path "shop/commerce/Product".
 const FIXTURE = resolve(import.meta.dir, "fixtures", "packaged-grid-entity.json");
 
-const model: ResolvedTarget = { name: "default", outDir: "db/gen", importBase: "@mf/db/generated", outputLayout: "package", dbImport: "../index", runtime: true };
+const model: ResolvedTarget = { name: "default", outDir: "db/gen", importBase: "@acme/db/generated", outputLayout: "package", dbImport: "../index", runtime: true };
 const web:   ResolvedTarget = { name: "web", outDir: "web/gen", importBase: undefined, outputLayout: "package", dbImport: "../index", runtime: true };
 
 async function ctxFor(self: ResolvedTarget, em: ResolvedTarget) {
@@ -29,7 +29,7 @@ describe("hooks-file — cross target", () => {
   it("imports entity via importBase package path, not relative", async () => {
     const { entity, ctx } = await ctxFor(web, model);
     const out = renderHooksFile(entity, ctx);
-    expect(out).toContain(`from "@mf/db/generated/shop/commerce/Product"`);
+    expect(out).toContain(`from "@acme/db/generated/shop/commerce/Product"`);
     expect(out).not.toContain(`from "./Product"`);
   });
   it("same target stays relative", async () => {
@@ -42,7 +42,7 @@ describe("columns-file — cross target", () => {
   it("imports entity types via importBase package path, not relative", async () => {
     const { entity, ctx } = await ctxFor(web, model);
     const out = renderColumnsFile(entity, ctx);
-    expect(out).toContain(`from "@mf/db/generated/shop/commerce/Product"`);
+    expect(out).toContain(`from "@acme/db/generated/shop/commerce/Product"`);
     expect(out).not.toContain(`from "./Product"`);
   });
 });

server/typescript/packages/codegen-ts/test/import-path.test.ts

@@ -13,7 +13,7 @@ import {
 } from "../src/import-path.js";
 
 const model = (over: Partial<ResolvedTarget> = {}): ResolvedTarget => ({
-  name: "default", outDir: "db/gen", importBase: "@mf/db/generated",
+  name: "default", outDir: "db/gen", importBase: "@acme/db/generated",
   outputLayout: "package", dbImport: "../index", runtime: true, ...over,
 });
 const web = (over: Partial<ResolvedTarget> = {}): ResolvedTarget => ({
@@ -23,50 +23,50 @@ const web = (over: Partial<ResolvedTarget> = {}): ResolvedTarget => ({
 
 describe("entityModuleSpecifier", () => {
   it("same target → relative (honors extStyle), package layout", () => {
-    expect(entityModuleSpecifier(model(), model(), "mikes::commerce", "Program", "none"))
+    expect(entityModuleSpecifier(model(), model(), "shop::commerce", "Program", "none"))
       .toBe("./Program");
-    expect(entityModuleSpecifier(model(), model(), "mikes::commerce", "Program", "js"))
+    expect(entityModuleSpecifier(model(), model(), "shop::commerce", "Program", "js"))
       .toBe("./Program.js");
   });
   it("same target → relative, flat layout", () => {
-    expect(entityModuleSpecifier(model({ outputLayout: "flat" }), model({ outputLayout: "flat" }), "mikes::commerce", "Program", "none"))
+    expect(entityModuleSpecifier(model({ outputLayout: "flat" }), model({ outputLayout: "flat" }), "shop::commerce", "Program", "none"))
       .toBe("./Program");
   });
   it("cross target, package layout → extension-less importBase path (extStyle ignored)", () => {
-    expect(entityModuleSpecifier(web(), model(), "mikes::commerce", "Program", "js"))
-      .toBe("@mf/db/generated/mikes/commerce/Program");
+    expect(entityModuleSpecifier(web(), model(), "shop::commerce", "Program", "js"))
+      .toBe("@acme/db/generated/shop/commerce/Program");
   });
   it("cross target, flat layout → importBase + entity, no package path", () => {
-    expect(entityModuleSpecifier(web({ outputLayout: "flat" }), model({ outputLayout: "flat" }), "mikes::commerce", "Program", "none"))
-      .toBe("@mf/db/generated/Program");
+    expect(entityModuleSpecifier(web({ outputLayout: "flat" }), model({ outputLayout: "flat" }), "shop::commerce", "Program", "none"))
+      .toBe("@acme/db/generated/Program");
   });
   it("cross target, entity at root package → importBase + entity", () => {
     expect(entityModuleSpecifier(web(), model(), undefined, "Tag", "none"))
-      .toBe("@mf/db/generated/Tag");
+      .toBe("@acme/db/generated/Tag");
   });
   it("cross target without importBase → throws", () => {
-    expect(() => entityModuleSpecifier(web(), model({ importBase: undefined }), "mikes::commerce", "Program", "none"))
+    expect(() => entityModuleSpecifier(web(), model({ importBase: undefined }), "shop::commerce", "Program", "none"))
       .toThrow(/importBase/);
   });
 });
 
 describe("siblingSpecifier", () => {
   it("always same-target relative, package layout", () => {
-    expect(siblingSpecifier(web(), "mikes::commerce", "Program.columns", "none")).toBe("./Program.columns");
+    expect(siblingSpecifier(web(), "shop::commerce", "Program.columns", "none")).toBe("./Program.columns");
   });
   it("honors extStyle", () => {
-    expect(siblingSpecifier(web(), "mikes::commerce", "Program.columns", "js")).toBe("./Program.columns.js");
+    expect(siblingSpecifier(web(), "shop::commerce", "Program.columns", "js")).toBe("./Program.columns.js");
   });
 });
 
 describe("barrelModuleSpecifier", () => {
   it("same target (package) → './<pkg-path>/<entity>'", () => {
-    expect(barrelModuleSpecifier(model(), model(), "mikes::commerce", "Program", "none"))
-      .toBe("./mikes/commerce/Program");
+    expect(barrelModuleSpecifier(model(), model(), "shop::commerce", "Program", "none"))
+      .toBe("./shop/commerce/Program");
   });
   it("cross target → extension-less importBase path", () => {
-    expect(barrelModuleSpecifier(web(), model(), "mikes::commerce", "Program", "none"))
-      .toBe("@mf/db/generated/mikes/commerce/Program");
+    expect(barrelModuleSpecifier(web(), model(), "shop::commerce", "Program", "none"))
+      .toBe("@acme/db/generated/shop/commerce/Program");
   });
 });
 

server/typescript/packages/codegen-ts/test/metaobjects-config.test.ts

@@ -6,9 +6,9 @@ describe("resolveTargets", () => {
   const base = { outDir: "db/gen", extStyle: "none" as const, dbImport: "../index", dialect: "sqlite" as const, generators: [] };
 
   test("synthesizes a 'default' target from top-level fields", () => {
-    const t = resolveTargets({ ...base, importBase: "@mf/db/generated", outputLayout: "package" });
+    const t = resolveTargets({ ...base, importBase: "@acme/db/generated", outputLayout: "package" });
     expect(t[DEFAULT_TARGET_NAME]).toEqual({
-      name: "default", outDir: "db/gen", importBase: "@mf/db/generated",
+      name: "default", outDir: "db/gen", importBase: "@acme/db/generated",
       outputLayout: "package", dbImport: "../index", runtime: true,
     });
   });
@@ -21,13 +21,13 @@ describe("resolveTargets", () => {
 
   test("named targets resolve; outputLayout + dbImport fall back to top-level, importBase does NOT inherit", () => {
     const t = resolveTargets({
-      ...base, outputLayout: "package", importBase: "@mf/db/generated",
+      ...base, outputLayout: "package", importBase: "@acme/db/generated",
       targets: {
-        api: { outDir: "api/gen", dbImport: "@mf/database" },
+        api: { outDir: "api/gen", dbImport: "@acme/database" },
         web: { outDir: "web/gen" },
       },
     });
-    expect(t.api).toEqual({ name: "api", outDir: "api/gen", importBase: undefined, outputLayout: "package", dbImport: "@mf/database", runtime: true });
+    expect(t.api).toEqual({ name: "api", outDir: "api/gen", importBase: undefined, outputLayout: "package", dbImport: "@acme/database", runtime: true });
     expect(t.web).toEqual({ name: "web", outDir: "web/gen", importBase: undefined, outputLayout: "package", dbImport: "../index", runtime: true });
   });
 

server/typescript/packages/codegen-ts/test/render-context.test.ts

@@ -20,11 +20,11 @@ describe("makeRenderContext — targets", () => {
   });
 
   it("passes through explicit selfTarget + entityModuleTarget", () => {
-    const em: ResolvedTarget = { name: "default", outDir: "db/gen", importBase: "@mf/db/generated", outputLayout: "package", dbImport: "../index", runtime: true };
+    const em: ResolvedTarget = { name: "default", outDir: "db/gen", importBase: "@acme/db/generated", outputLayout: "package", dbImport: "../index", runtime: true };
     const web: ResolvedTarget = { name: "web", outDir: "web/gen", importBase: undefined, outputLayout: "package", dbImport: "../index", runtime: true };
     const ctx = makeRenderContext({ ...baseInput, outputLayout: "package", selfTarget: web, entityModuleTarget: em });
     expect(ctx.selfTarget.name).toBe("web");
-    expect(ctx.entityModuleTarget.importBase).toBe("@mf/db/generated");
+    expect(ctx.entityModuleTarget.importBase).toBe("@acme/db/generated");
   });
 });
 

server/typescript/packages/codegen-ts/test/runner.test.ts

@@ -153,7 +153,7 @@ describe("runGen — multi-target", () => {
     const result = await runGen({
       config: defineConfig({
         outDir: tmp, extStyle: "none", dbImport: "../index", dialect: "sqlite",
-        importBase: "@mf/db/generated",
+        importBase: "@acme/db/generated",
         targets: { api: { outDir: apiDir } },
         generators: [entity, routes],
       }),

server/typescript/packages/codegen-ts/test/templates/barrel.test.ts

@@ -4,7 +4,7 @@ import { GENERATED_HEADER } from "../../src/constants.js";
 import type { ResolvedTarget } from "../../src/import-path.js";
 
 const tgt = (outputLayout: "flat" | "package"): ResolvedTarget =>
-  ({ name: "default", outDir: "x", importBase: "@mf/db/generated", outputLayout, dbImport: "../index", runtime: true });
+  ({ name: "default", outDir: "x", importBase: "@acme/db/generated", outputLayout, dbImport: "../index", runtime: true });
 
 describe("renderBarrel", () => {
   test("emits alphabetical exports + @generated header", () => {

server/typescript/packages/codegen-ts/test/templates/cross-target.test.ts

@@ -25,8 +25,8 @@ async function ctxFor(self: ResolvedTarget, em: ResolvedTarget) {
   return { entity, ctx };
 }
 
-const model: ResolvedTarget = { name: "default", outDir: "db/gen", importBase: "@mf/db/generated", outputLayout: "package", dbImport: "../index", runtime: true };
-const api:   ResolvedTarget = { name: "api", outDir: "api/gen", importBase: undefined, outputLayout: "package", dbImport: "@mf/database", runtime: true };
+const model: ResolvedTarget = { name: "default", outDir: "db/gen", importBase: "@acme/db/generated", outputLayout: "package", dbImport: "../index", runtime: true };
+const api:   ResolvedTarget = { name: "api", outDir: "api/gen", importBase: undefined, outputLayout: "package", dbImport: "@acme/database", runtime: true };
 
 describe("queries-file — same target stays relative", () => {
   it("imports entity via './<Entity>'", async () => {
@@ -39,8 +39,8 @@ describe("routes-file — cross target", () => {
   it("imports entity via importBase package path, db via per-target dbImport", async () => {
     const { entity, ctx } = await ctxFor(api, model);
     const out = renderRoutesFile(entity, ctx);
-    expect(out).toContain(`from "@mf/db/generated/shop/commerce/${entity.name}"`);
-    expect(out).toContain(`from "@mf/database"`);          // per-target db import
+    expect(out).toContain(`from "@acme/db/generated/shop/commerce/${entity.name}"`);
+    expect(out).toContain(`from "@acme/database"`);          // per-target db import
     expect(out).not.toContain(`from "./${entity.name}"`);
   });
 });