Merge abstract-codegen-followups: TS emitAbstractShapes knob + Java registry bootstrap fix

- feat(codegen-ts): emitAbstractShapes config knob (default true) — completes
  the optional TS parity (Unit 5) for the cross-port abstract-codegen knob.
- fix(java-metadata): break a class-init cycle in the registry bootstrap by
  removing redundant self-registering static{} blocks from MetaData/MetaRoot
  (registration flows solely through CoreTypeMetaDataProvider). Fixes a latent
  provider-load failure that left the registry with only field.base.

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

Author: dmealing

server/java/codegen-base/src/test/java/com/metaobjects/generator/util/GeneratorUtilAbstractTest.java

@@ -21,16 +21,23 @@
  */
 public class GeneratorUtilAbstractTest extends GeneratorTestBase {
 
-    // Deliberately field-free: the accessor reads the object's own `abstract`
-    // flag, so the model only needs `object.entity` (a registered type). Avoiding
-    // field subtypes keeps this unit test independent of the metadata-module
-    // provider-bootstrap path (which other codegen-base tests don't exercise).
+    // Field-bearing on purpose: loading field.long/field.string forces the
+    // metadata provider-bootstrap path. This is also a regression guard for the
+    // class-init cycle where MetaData's static{} block bootstrapped the registry
+    // during its own <clinit>, leaving subclass loggers null and the field
+    // subtypes unregistered (only field.base). See the removal of the redundant
+    // self-registration static{} blocks in MetaData/MetaRoot.
     private static final String MODEL = "{\n" +
         "  \"metadata.root\": {\n" +
         "    \"package\": \"acme\",\n" +
         "    \"children\": [\n" +
-        "      { \"object.entity\": { \"name\": \"Base\", \"abstract\": true } },\n" +
-        "      { \"object.entity\": { \"name\": \"Concrete\", \"extends\": \"Base\" } }\n" +
+        "      { \"object.entity\": { \"name\": \"Base\", \"abstract\": true, \"children\": [\n" +
+        "        { \"field.long\": { \"name\": \"id\" } }\n" +
+        "      ] } },\n" +
+        "      { \"object.entity\": { \"name\": \"Concrete\", \"extends\": \"Base\", \"children\": [\n" +
+        "        { \"field.string\": { \"name\": \"label\" } },\n" +
+        "        { \"identity.primary\": { \"name\": \"pk\", \"@fields\": [\"id\"] } }\n" +
+        "      ] } }\n" +
         "    ]\n" +
         "  }\n" +
         "}";

server/java/metadata/src/main/java/com/metaobjects/MetaData.java

@@ -128,7 +128,7 @@ public class MetaData implements Cloneable, Serializable {
     /** Root metadata subtype for the tree-root node (MetaRoot) */
     public static final String SUBTYPE_ROOT = "root";
 
-    // Unified registry self-registration for root metadata type
+    // Registered via CoreTypeMetaDataProvider on the ServiceLoader bootstrap.
     /**
      * Register MetaData as metadata.base with abstract requirements constraints.
      * This creates metadata.base which defines metadata file structure and enforces
@@ -245,14 +245,15 @@ public static void registerTypes() {
         registerTypes(MetaDataRegistry.getInstance());
     }
 
-    // Static registration block - automatically registers the root metadata type when class is loaded
-    static {
-        try {
-            registerTypes(MetaDataRegistry.getInstance());
-        } catch (Exception e) {
-            log.error("Failed to register root MetaData type during class loading", e);
-        }
-    }
+    // NOTE: metadata.base registration is performed by CoreTypeMetaDataProvider
+    // (the ServiceLoader bootstrap), invoked on first MetaDataRegistry.getInstance().
+    // A static{} block here that called getInstance() during MetaData.<clinit> is
+    // intentionally absent: because the field/object/etc. providers call
+    // registerTypes() on MetaData subclasses, bootstrapping the registry from this
+    // base class's initializer created a class-init cycle (a subclass's static
+    // logger could be observed null, aborting provider load and leaving only
+    // field.base registered). Registration via the provider is the single source.
+
     // Unified caching strategy
     private final CacheStrategy cache = new HybridCache();
 
@@ -371,7 +372,7 @@ public MetaData(String type, String subType, String name ) {
 
     // ========== ENHANCED TYPE SYSTEM METHODS ==========
 
-    // Type definition methods removed - using unified registry with static self-registration
+    // Type definition methods removed - using unified registry via ServiceLoader providers
 
     /**
      * Validate MetaData name during construction

server/java/metadata/src/main/java/com/metaobjects/MetaRoot.java

@@ -59,30 +59,24 @@ public class MetaRoot extends MetaData {
      */
     private transient boolean synthesizedName = false;
 
-    // Self-registration of the metadata.root type with the unified registry.
     // metadata.root accepts the same top-level children as metadata.base; it is
-    // the concrete tree-root produced by MetaDataLoader.
-    // metadata.root self-registers against the singleton on class-load. The same
-    // registration is also wired into the ServiceLoader bootstrap
-    // (CoreTypeMetaDataProvider) so isolated registries created via
-    // MetaDataRegistry.createWithCoreProviders() get it too; the idempotency guard
-    // in registerTypes() makes the two paths safe.
-    static {
-        registerTypes(MetaDataRegistry.getInstance());
-    }
+    // the concrete tree-root produced by MetaDataLoader. Its registration is wired
+    // into the ServiceLoader bootstrap (CoreTypeMetaDataProvider), invoked on first
+    // MetaDataRegistry.getInstance() — including isolated registries created via
+    // MetaDataRegistry.createWithCoreProviders(). A self-registering static{} block
+    // here is intentionally absent: bootstrapping the registry from this class's
+    // <clinit> created a class-init cycle (see the matching note in MetaData).
 
     /**
      * Registers the metadata.root type with the supplied registry.
-     * Provided for parity with {@link MetaData#registerTypes(MetaDataRegistry)};
-     * the static initializer already self-registers against the singleton.
+     * Invoked via CoreTypeMetaDataProvider on the ServiceLoader bootstrap.
      *
      * @param registry the registry to register with
      */
     public static void registerTypes(MetaDataRegistry registry) {
         try {
-            // Idempotent: the static block (singleton) and the ServiceLoader
-            // bootstrap (CoreTypeMetaDataProvider, for isolated registries) both
-            // call this; skip if metadata.root is already registered.
+            // Idempotent: skip if metadata.root is already registered (the
+            // provider may run against a registry that already has it).
             if (registry.isRegistered(TYPE_METADATA, SUBTYPE_ROOT)) {
                 return;
             }

server/typescript/packages/codegen-ts/src/generators/entity-file.ts

@@ -3,6 +3,7 @@ import { perEntity, type Generator, type GeneratorFactory } from "../generator.j
 import { renderEntityFile } from "../templates/entity-file.js";
 import { formatTs } from "../format.js";
 import { entityOutputPath } from "../import-path.js";
+import { isAbstract } from "../instance-artifacts.js";
 
 export interface EntityFileOpts {
   filter?: (entity: MetaObject) => boolean;
@@ -33,6 +34,12 @@ export const entityFile = function entityFile(opts?: EntityFileOpts): Generator
       if (!ctx.renderContext) {
         throw new Error("entity-file: renderContext is required (provided by runGen)");
       }
+      // Abstract entities contribute shape only. When emitAbstractShapes is off
+      // (cross-port knob; default on) the entity-file generator emits nothing for
+      // them. Instance/write generators skip abstract unconditionally elsewhere.
+      if (isAbstract(entity) && !ctx.renderContext.emitAbstractShapes) {
+        return [];
+      }
       return {
         path: entityOutputPath(ctx.config.outputLayout ?? "flat", entity.package, `${entity.name}.ts`),
         content: await formatTs(renderEntityFile(entity, ctx.renderContext, { allowlists })),

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

@@ -37,6 +37,15 @@ export interface MetaobjectsGenConfig extends ResolvedGenConfig {
   columnNamingStrategy?: ColumnNamingStrategy;
   /** Path prefix applied to generated route registrations + hook fetch URLs. Defaults to "". */
   apiPrefix?: string;
+  /**
+   * Whether abstract entities (`@isAbstract: true`) emit their shape artifact
+   * (the type-only interface / value-object file from the entity-file
+   * generator). Defaults to `true`. Instance/write artifacts (forms, CRUD/read
+   * hooks, grids) are NEVER emitted for abstract entities regardless of this
+   * flag — that invariant lives in `instance-artifacts.ts`. This knob only
+   * governs the shape, mirroring the cross-port `emitAbstractShapes` option.
+   */
+  emitAbstractShapes?: boolean;
   /** Named output destinations. Generators reference one via `target`. */
   targets?: Record<string, TargetConfig>;
   /** importBase for the default target (top-level outDir). */
@@ -57,6 +66,7 @@ export interface MetaobjectsGenConfig extends ResolvedGenConfig {
 export interface NormalizedMetaobjectsGenConfig extends Omit<MetaobjectsGenConfig, "targets"> {
   columnNamingStrategy: ColumnNamingStrategy;
   apiPrefix: string;
+  emitAbstractShapes: boolean;
   outputLayout: OutputLayout;
   targets: Record<string, ResolvedTarget>;
 }
@@ -98,6 +108,7 @@ export function normalizeConfig(config: MetaobjectsGenConfig): NormalizedMetaobj
     ...config,
     columnNamingStrategy: config.columnNamingStrategy ?? DEFAULT_COLUMN_NAMING_STRATEGY,
     apiPrefix: config.apiPrefix ?? "",
+    emitAbstractShapes: config.emitAbstractShapes ?? true,
     outputLayout: config.outputLayout ?? "flat",
     targets: resolveTargets(config),
   };

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

@@ -39,6 +39,8 @@ export interface RenderContext {
   columnNamingStrategy: ColumnNamingStrategy;
   /** Path prefix applied to generated route registrations + hook fetch URLs. Defaults to "". */
   apiPrefix: string;
+  /** Whether abstract entities emit their shape artifact (type-only interface / value-object file). Defaults to true. Instance/write artifacts are never emitted for abstract entities regardless. */
+  emitAbstractShapes: boolean;
   /** Output layout mode: "flat" (default) — all files in outDir; "package" — sub-paths from entity metadata package. */
   outputLayout: OutputLayout;
   /** The target THIS generator emits to (drives path layout + same-target imports). */
@@ -53,11 +55,12 @@ export interface RenderContext {
 }
 
 /** Optional shape — `extStyle`, `omImport`, `columnNamingStrategy`, `apiPrefix`, `outputLayout`, and `packageOf` default if omitted. `packageOf` defaults to an empty Map (correct for flat layout; `runGen` always provides the real map). */
-export type RenderContextInput = Omit<RenderContext, "extStyle" | "omImport" | "columnNamingStrategy" | "apiPrefix" | "outputLayout" | "packageOf" | "selfTarget" | "entityModuleTarget"> & {
+export type RenderContextInput = Omit<RenderContext, "extStyle" | "omImport" | "columnNamingStrategy" | "apiPrefix" | "emitAbstractShapes" | "outputLayout" | "packageOf" | "selfTarget" | "entityModuleTarget"> & {
   extStyle?: ExtStyle;
   omImport?: string;
   columnNamingStrategy?: ColumnNamingStrategy;
   apiPrefix?: string;
+  emitAbstractShapes?: boolean;
   outputLayout?: OutputLayout;
   packageOf?: Map<string, string | undefined>;
   selfTarget?: ResolvedTarget;
@@ -85,6 +88,7 @@ export function makeRenderContext(opts: RenderContextInput): RenderContext {
     omImport: opts.omImport ?? "../index",
     columnNamingStrategy: opts.columnNamingStrategy ?? "snake_case",
     apiPrefix: opts.apiPrefix ?? "",
+    emitAbstractShapes: opts.emitAbstractShapes ?? true,
     outputLayout,
     packageOf: opts.packageOf ?? new Map(),
     selfTarget: defaultTarget,

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

@@ -155,6 +155,7 @@ export async function runGen(opts: RunGenOpts): Promise<RunGenResult> {
       extStyle: config.extStyle,
       columnNamingStrategy: config.columnNamingStrategy,
       apiPrefix: config.apiPrefix,
+      emitAbstractShapes: config.emitAbstractShapes,
       outputLayout: selfTarget.outputLayout,
       pkMap,
       relationMap,

server/typescript/packages/codegen-ts/test/generators/entity-file.test.ts

@@ -6,7 +6,7 @@ import { buildPkMap } from "../../src/pk-resolver.js";
 import { buildRelationMap } from "../../src/relation-resolver.js";
 import { makeRenderContext } from "../../src/render-context.js";
 import type { GenContext } from "../../src/generator.js";
-import { MetaDataLoader } from "@metaobjectsdev/metadata";
+import { MetaDataLoader, InMemoryStringSource } from "@metaobjectsdev/metadata";
 import { FileSource } from "@metaobjectsdev/metadata/core";
 
 const FIXTURE = resolve(import.meta.dir, "..", "fixtures", "single-entity.json");
@@ -101,3 +101,66 @@ describe("entityFile() factory", () => {
     expect(files).toEqual([]);
   });
 });
+
+describe("entityFile() — emitAbstractShapes knob", () => {
+  // Abstract base (sourceless → shape is a value-object interface) + concrete subclass.
+  const MODEL = JSON.stringify({
+    "metadata.root": {
+      package: "acme",
+      children: [
+        {
+          "object.entity": {
+            name: "Base",
+            abstract: true,
+            children: [
+              { "field.int": { name: "id" } },
+              { "field.string": { name: "name" } },
+              { "identity.primary": { "@fields": "id" } },
+            ],
+          },
+        },
+        {
+          "object.entity": {
+            name: "Widget",
+            extends: "Base",
+            children: [
+              { "source.rdb": { "@table": "widgets" } },
+              { "field.string": { name: "sku" } },
+            ],
+          },
+        },
+      ],
+    },
+  });
+
+  async function runWith(emitAbstractShapes: boolean) {
+    const { root, errors } = await new MetaDataLoader().load([new InMemoryStringSource(MODEL)]);
+    if (errors.length > 0) throw new Error(errors.map((e: { message: string }) => e.message).join("\n"));
+    const entities = root.objects();
+    const renderContext = makeRenderContext({
+      dialect: "sqlite", loadedRoot: root, outDir: "/tmp",
+      dbImport: "../db", extStyle: "none", emitAbstractShapes,
+      pkMap: buildPkMap(root), relationMap: buildRelationMap(root),
+    });
+    const ctx: GenContext = {
+      entities, loadedRoot: root,
+      matches: () => true,
+      config: { outDir: "/tmp", extStyle: "none", dbImport: "../db", dialect: "sqlite" },
+      renderContext,
+      warn: () => {},
+    };
+    return (await entityFile().generate(ctx)).map((f) => f.path);
+  }
+
+  test("default (on): abstract entity emits its shape file", async () => {
+    const paths = await runWith(true);
+    expect(paths).toContain("Base.ts");
+    expect(paths).toContain("Widget.ts");
+  });
+
+  test("off: abstract entity emits no file; concrete still emits", async () => {
+    const paths = await runWith(false);
+    expect(paths).not.toContain("Base.ts");
+    expect(paths).toContain("Widget.ts");
+  });
+});