fix(codegen-ts): a dropdown descriptor that carries no options

0.25.0 moved a `field.enum`'s FORM view from "text" to "dropdown". The generated
`<Entity>` descriptor went on emitting no member list, so it told a consumer to render a
`<select>` and gave it nothing to put in one — while `@values` sat in the metadata the
whole time. The descriptor made a promise it withheld the means to keep, and every
consumer paid for it by restating the members by hand.

`UiFieldDescriptor` gains `options`, emitted for any `field.enum`. It reads through the
resolving accessor (ADR-0039), so a field inheriting `@values` from an abstract enum via
`extends` carries them too — an own-only read would hand back an empty dropdown for
exactly the fields a shared enum exists to serve.

Found by running the 1.0 candidate against the public reference app, where the same four
status symbols appear as literals in five hand-written files.

The whole codegen suite — 1529 tests — passed unchanged when `options` was added. Not one
fixture asserted an enum field's descriptor output, so the gate for this could not have
gone red no matter what the emitter did. A test that asserts it now exists, covering the
declared case, the inherited-through-extends case, that a non-enum field grows no options
key, and that the emitted const spells exactly two lists for two enums. Confirmed red on
three of its four cases before the fix.

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

Author: dmealing

CHANGELOG.md

@@ -7,6 +7,22 @@ this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+### Fixed — a `view: "dropdown"` descriptor carried no options
+
+`0.25.0` moved a `field.enum`'s FORM view from `text` to `dropdown`. The generated
+`<Entity>` descriptor kept emitting no member list, so it told a consumer to render a
+`<select>` and handed it nothing to fill one with — while `@values` sat in the metadata all
+along. Every consumer then restated the members by hand.
+
+`UiFieldDescriptor` gains `options`, emitted for any `field.enum`, read through the
+resolving accessor so members inherited from an abstract enum via `extends` are carried too.
+
+Found on the public reference app running the 1.0 candidate, where the same four symbols
+appeared as literals across five hand-written files. **Nothing caught it: the entire
+codegen suite passed unchanged when `options` was added, because not one fixture asserted
+an enum field's descriptor output at all.** That assertion now exists, and was confirmed to
+fail before the fix.
+
 ### Removed — the deprecated `codegen-ts/generators` export of the four ownable generators
 
 `entityFile`, `queriesFile`, `routesFile` and `barrel` are no longer exported from

server/typescript/packages/codegen-ts/src/templates/entity-constants.ts

@@ -76,6 +76,13 @@ function renderFieldEntry(f: UiFieldDescriptor): string {
   if (f.htmlType !== undefined) entries.push(`htmlType: ${JSON.stringify(f.htmlType)}`);
   if (f.rules.length > 0) entries.push(`rules: { ${f.rules.map(renderRule).join(", ")} }`);
 
+  // A `field.enum`'s member symbols. Emitted whenever the field has them, because the
+  // descriptor reports `view: "dropdown"` for an enum and a dropdown without options is
+  // a promise the descriptor cannot keep.
+  if (f.options !== undefined && f.options.length > 0) {
+    entries.push(`options: [${f.options.map((v) => JSON.stringify(v)).join(", ")}] as const`);
+  }
+
   // Currency-specific keys: only emitted for currency-subtype fields.
   if (f.currency !== undefined) {
     entries.push(`currency: ${JSON.stringify(f.currency.currency)}`);

server/typescript/packages/codegen-ts/src/templates/entity-ui-descriptor.ts

@@ -52,6 +52,7 @@ import {
 } from "@metaobjectsdev/metadata";
 import { inferViewKind, currencyMetaFor, labelFor, humanize, valueObjectFor } from "./field-meta.js";
 import { VIEW_CONTEXT_FORM } from "../view-context.js";
+import { enumValues } from "../enum-meta.js";
 import { isProjection } from "../projection/projection-detector.js";
 // `restPath` lives HERE rather than in api-surface.ts, which is where it used to sit and
 // which now re-exports it. The descriptor is what emits `$path`, so the composition has to
@@ -81,6 +82,17 @@ export interface UiFieldDescriptor {
   readonly rules: readonly UiRule[];
   /** Present only for a `field.currency`. */
   readonly currency?: { readonly currency: string; readonly locale: string } | undefined;
+  /**
+   * The member symbols, present exactly when the field is a `field.enum`.
+   *
+   * A descriptor that reports `view: "dropdown"` and carries no options tells a consumer
+   * to render a `<select>` and gives it nothing to put in one. That was the shape between
+   * 0.25.0 — which moved an enum field's form view from `text` to `dropdown` — and this,
+   * and it forced every consumer to restate the member list the metadata already declares.
+   * Found on the public reference app, where the same four symbols appeared as literals in
+   * five hand-written files.
+   */
+  readonly options?: readonly string[] | undefined;
   /**
    * Present when the generated FORM renders this field as a nested value-object
    * sub-form rather than an input — a `field.object` whose `@objectRef` resolves (see
@@ -284,6 +296,11 @@ export function buildUiFieldDescriptor(field: MetaField, root?: MetaRoot): UiFie
     currency: currencyMeta === null
       ? undefined
       : { currency: currencyMeta.currency, locale: currencyMeta.locale },
+    // Whatever the field's view resolves to, an enum's members belong on the descriptor:
+    // they are declared metadata, and withholding them is what makes a consumer hard-code
+    // them. Read through the RESOLVING accessor (ADR-0039) so a field that inherits
+    // `@values` from an abstract enum via `extends` carries them too.
+    options: enumValues(field),
     nested: vo === undefined
       ? undefined
       : { objectRef: vo.name, isArray: field.resolvedIsArray() },

server/typescript/packages/codegen-ts/test/enum-descriptor-options.test.ts

@@ -0,0 +1,77 @@
+// A descriptor that says `view: "dropdown"` must carry what a dropdown needs.
+//
+// 0.25.0 moved a `field.enum`'s FORM view from "text" to "dropdown". The descriptor kept
+// emitting no member list, so the generated `<Entity>` const told a consumer to render a
+// `<select>` and handed it nothing to fill one with — while the metadata had `@values` all
+// along. Every consumer then restated the members by hand; on the public reference app the
+// same four symbols appeared as literals across five hand-written files.
+//
+// Nothing caught it: the whole codegen suite passed unchanged when `options` was added,
+// because not one fixture asserted an enum field's descriptor output at all. This is that
+// assertion.
+import { describe, test, expect } from "bun:test";
+import type { MetaObject } from "@metaobjectsdev/metadata";
+import { MetaDataLoader, InMemoryStringSource } from "@metaobjectsdev/metadata";
+import { renderEntityConstants } from "../src/templates/entity-constants.js";
+import { buildUiFieldDescriptor } from "../src/templates/entity-ui-descriptor.js";
+
+const MODEL = {
+  "metadata.root": {
+    package: "acme",
+    children: [
+      // An abstract enum a concrete field inherits its members from, so the resolving
+      // read (ADR-0039) is exercised rather than an own-only one.
+      { "field.enum": { name: "orderState", abstract: true, "@values": ["open", "closed"] } },
+      {
+        "object.entity": {
+          name: "Order",
+          children: [
+            { "source.rdb": { "@kind": "table", "@table": "orders" } },
+            { "field.long": { name: "id", "@required": true } },
+            { "identity.primary": { name: "pk", "@fields": ["id"], "@generation": "increment" } },
+            { "field.enum": { name: "status", "@values": ["pending", "shipped", "cancelled"] } },
+            { "field.enum": { name: "state", extends: "orderState" } },
+            { "field.string": { name: "note" } },
+          ],
+        },
+      },
+    ],
+  },
+};
+
+async function loadOrder(): Promise<MetaObject> {
+  const result = await new MetaDataLoader().load([new InMemoryStringSource(JSON.stringify(MODEL))]);
+  if (result.errors.length > 0) throw new Error(result.errors.map((e) => e.message).join("\n"));
+  return result.root.objects().find((o) => o.name === "Order")!;
+}
+
+describe("an enum field's descriptor carries its members", () => {
+  test("a declared enum reports view dropdown AND its options", async () => {
+    const order = await loadOrder();
+    const status = order.fields().find((f) => f.name === "status")!;
+    const d = buildUiFieldDescriptor(status);
+    expect(d.view).toBe("dropdown");
+    expect(d.options).toEqual(["pending", "shipped", "cancelled"]);
+  });
+
+  test("members inherited through extends resolve too", async () => {
+    const order = await loadOrder();
+    const state = order.fields().find((f) => f.name === "state")!;
+    // An own-only read would return undefined here and the dropdown would be empty.
+    expect(buildUiFieldDescriptor(state).options).toEqual(["open", "closed"]);
+  });
+
+  test("a non-enum field carries no options key", async () => {
+    const order = await loadOrder();
+    const note = order.fields().find((f) => f.name === "note")!;
+    expect(buildUiFieldDescriptor(note).options).toBeUndefined();
+  });
+
+  test("the emitted const spells the members, and only for the enums", async () => {
+    const out = renderEntityConstants(await loadOrder()).toString();
+    expect(out).toContain(`options: ["pending", "shipped", "cancelled"] as const`);
+    expect(out).toContain(`options: ["open", "closed"] as const`);
+    // Exactly two option lists — the string field must not grow one.
+    expect(out.match(/options:/g)?.length).toBe(2);
+  });
+});