@metaobjectsdev/codegen-ts 0.23.1 → 0.23.2

package/src/column-mapper.ts

@@ -46,7 +46,7 @@ import {
   AGG_COLLECT,
 } from "@metaobjectsdev/metadata";
 import { columnNameFromField } from "./naming.js";
-import { enumValues } from "./enum-meta.js";
+import { enumValues, intValueMapOf, intValueForMember } from "./enum-meta.js";
 import { DEFAULT_COLUMN_NAMING_STRATEGY, stripPackage } from "@metaobjectsdev/metadata";
 import type { Dialect, ColumnNamingStrategy } from "./metaobjects-config.js";
 
@@ -212,9 +212,42 @@ function canonicalizeSqlExpr(value: string): string {
   return value; // unrecognized — pass through (function calls etc.)
 }
 
+/**
+ * An int-backed `field.enum` column: a generated Drizzle `customType` whose
+ * `toDriver`/`fromDriver` translate member symbol <-> stored integer, so the
+ * codec lives in the COLUMN definition rather than in the query layer.
+ *
+ * This is the TS analogue of what every other port already does at its own
+ * `MetaField` codec seam (EF Core `HasConversion`, OMDB `JdbcFieldCodec`, Exposed
+ * `customEnumeration`, Python `ObjectManager` coercion) — which is why it was
+ * chosen over a Zod write-transform plus a bespoke read-decode: TS's generated
+ * queries hand back raw Drizzle rows and have no decode seam at all, so a
+ * query-layer codec would have meant inventing one and wrapping every generated
+ * read. Binding through the column type also makes filter values encode for free.
+ */
+export interface EnumIntCustomType {
+  /** Local const name for the customType column helper, e.g. `orderStatusEnumCol`. */
+  fnConstName: string;
+  /** Local const name for the symbol->int map, e.g. `ORDER_STATUS_TO_INT`. */
+  toIntConstName: string;
+  /** Local const name for the int->symbol map, e.g. `ORDER_STATUS_FROM_INT`. */
+  fromIntConstName: string;
+  /** Physical column type for `dataType()` — always integer for an int-backed enum. */
+  dataType: string;
+  /** Member symbols, in `@values` order (the TS union and the map key order). */
+  members: string[];
+  /** Member symbol -> stored integer. */
+  intByMember: Record<string, number>;
+}
+
 export interface ColumnSpec {
   /** Drizzle function name, e.g., "text", "integer", "varchar". */
   fnName: string;
+  /**
+   * When set, `fnName` names a LOCAL generated const (this spec's customType
+   * helper) rather than a Drizzle export — the renderer must NOT `imp()` it.
+   */
+  enumIntCustomType?: EnumIntCustomType;
   /** DB column name (snake_case from field name, or @column override). */
   dbName: string;
   /** Positional args after dbName (currently always empty; reserved). */
@@ -342,6 +375,48 @@ function objectRefBaseName(field: MetaField): string | undefined {
   return undefined;
 }
 
+/** SCREAMING_SNAKE_CASE for a generated map const name. */
+function screamingSnake(s: string): string {
+  return s
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/[^A-Za-z0-9]+/g, "_")
+    .toUpperCase();
+}
+
+/**
+ * Build the customType descriptor for an int-backed `field.enum`, or undefined
+ * when `@values` is missing (the field then degrades to a plain integer column
+ * rather than emitting a codec over an unknown member set).
+ *
+ * Names are derived from the FIELD name, so the consts are per-entity-file and
+ * self-contained. A shared enum consumed by N entities therefore emits N small
+ * identical helpers rather than requiring a cross-module import — the same
+ * self-contained tradeoff the per-entity enum union already makes.
+ */
+function buildEnumIntCustomType(
+  field: MetaField,
+  intByMember: Record<string, number>,
+): EnumIntCustomType | undefined {
+  const members = enumValues(field);
+  if (members === undefined || members.length === 0) return undefined;
+  // Every member must map — the loader pins key-set-equals-@values (Check 5b), so a
+  // miss is unreachable; throwing beats emitting a codec with a hole in it.
+  for (const m of members) {
+    intValueForMember(intByMember, m, `customType codec for field '${field.name}'`);
+  }
+  const base = field.name.replace(/[^A-Za-z0-9]/g, "");
+  const camel = base.charAt(0).toLowerCase() + base.slice(1);
+  const screaming = screamingSnake(base);
+  return {
+    fnConstName: `${camel}IntEnum`,
+    toIntConstName: `${screaming}_TO_INT`,
+    fromIntConstName: `${screaming}_FROM_INT`,
+    dataType: "integer",
+    members,
+    intByMember,
+  };
+}
+
 export function mapColumnType(
   field: MetaField,
   dialect: Dialect,
@@ -355,6 +430,8 @@ export function mapColumnType(
 
   let fnName: string;
   let fnOptions: Record<string, unknown> | undefined;
+  // Set only for an int-backed field.enum — see EnumIntCustomType.
+  let enumIntCustomType: EnumIntCustomType | undefined;
 
   let leadingComment: string | undefined;
   if (dialect === "sqlite") {
@@ -405,8 +482,20 @@ export function mapColumnType(
           // "string" by the time it reaches here for this dialect.
           fnName = "text";
           break;
-        case FIELD_SUBTYPE_STRING:
         case FIELD_SUBTYPE_ENUM:
+          // An INT-BACKED enum stores the mapped integer on SQLite too — SQLite has
+          // one integer storage class, so this matches migrate-ts's integer{32}.
+          {
+            const im = intValueMapOf(field);
+            if (im !== undefined) {
+              enumIntCustomType = buildEnumIntCustomType(field, im);
+              fnName = enumIntCustomType?.fnConstName ?? "integer";
+            } else {
+              fnName = "text";
+            }
+          }
+          break;
+        case FIELD_SUBTYPE_STRING:
         case FIELD_SUBTYPE_UUID:
         case FIELD_SUBTYPE_URI:
         case FIELD_SUBTYPE_INET:
@@ -524,6 +613,22 @@ export function mapColumnType(
           fnName = "jsonb";
           break;
         case FIELD_SUBTYPE_ENUM:
+          // An INT-BACKED enum (@intValueMap, design D5) stores the mapped integer,
+          // so the Drizzle column is integer — matching migrate-ts's expected-schema.
+          // The TS-facing type stays the member-string union; the symbol<->int
+          // translation happens at the write/read boundary. Scalar only: D7 makes
+          // @intValueMap + isArray ERR_ENUM_INT_VALUE_MAP_ARRAY at load, so an array
+          // enum reaching here is always string-backed.
+          {
+            const im = intValueMapOf(field);
+            if (im !== undefined) {
+              enumIntCustomType = buildEnumIntCustomType(field, im);
+              fnName = enumIntCustomType?.fnConstName ?? "integer";
+            } else {
+              fnName = "text";
+            }
+          }
+          break;
         default:
           fnName = "text";
           break;
@@ -669,6 +774,7 @@ export function mapColumnType(
   };
   if (fnOptions !== undefined) result.fnOptions = fnOptions;
   if (defaultExpr !== undefined) result.defaultExpr = defaultExpr;
+  if (enumIntCustomType !== undefined) result.enumIntCustomType = enumIntCustomType;
   if (dollarTypeRef !== undefined) result.dollarTypeRef = dollarTypeRef;
   if (leadingComment !== undefined) result.leadingComment = leadingComment;
 
@@ -676,12 +782,22 @@ export function mapColumnType(
   if (subType === FIELD_SUBTYPE_ENUM && !isArray) {
     const values = enumValues(field);
     if (values !== undefined && values.length > 0) {
-      // Single-quote escaping is belt-and-suspenders: the loader's
-      // ENUM_MEMBER_PATTERN already rejects quote-bearing members (members are
-      // validated to be identifier-safe), so this never fires in practice.
-      const list = values
-        .map((v) => `'${v.replace(/'/g, "''")}'`)
-        .join(", ");
+      const intMap = intValueMapOf(field);
+      let list: string;
+      if (intMap !== undefined) {
+        // Int-backed: the column holds integers, so the CHECK lists them unquoted.
+        // Keyed BY MEMBER through the map (not Object.values) so the constraint can
+        // never disagree with @values, which stays the SSOT. Must match
+        // migrate-ts's buildChecks exactly or `meta verify` reports permanent drift.
+        list = values
+          .map((v) => String(intValueForMember(intMap, v, `CHECK for column '${dbName}'`)))
+          .join(", ");
+      } else {
+        // Single-quote escaping is belt-and-suspenders: the loader's
+        // ENUM_MEMBER_PATTERN already rejects quote-bearing members (members are
+        // validated to be identifier-safe), so this never fires in practice.
+        list = values.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
+      }
       result.checkConstraint = `${dbName} IN (${list})`;
     }
   }

package/src/enum-meta.ts

@@ -3,7 +3,7 @@
 // extraction and the z.enum([...]) expression are derived in exactly one place.
 
 import type { MetaField } from "@metaobjectsdev/metadata";
-import { FIELD_ATTR_VALUES } from "@metaobjectsdev/metadata";
+import { FIELD_ATTR_VALUES, FIELD_ATTR_INT_VALUE_MAP } from "@metaobjectsdev/metadata";
 
 /**
  * Effective enum member values (`@values`) for a field, as strings.
@@ -20,6 +20,42 @@ export function enumValues(field: MetaField): string[] | undefined {
   return values.map((v) => String(v));
 }
 
+/**
+ * The effective `@intValueMap` (member symbol → integer) for an int-backed enum,
+ * or undefined when the enum is string-backed. Its PRESENCE is the whole trigger
+ * for integer persistence (design D5) — there is no separate flag or config.
+ *
+ * ADR-0039: RESOLVING (`attr`, not `ownAttr`), and this is load-bearing rather
+ * than incidental. Post-#246 an own `@intValueMap` declared against a shared
+ * (root-level abstract) enum is `ERR_ENUM_EXTENDS_VALUES_CONFLICT`, so the map
+ * lives on the SHARED DECLARATION and every consuming field INHERITS it. An
+ * own-only read would therefore see undefined on exactly the shape adopters are
+ * steered toward, and silently emit a string codec into an integer column.
+ */
+export function intValueMapOf(field: MetaField): Record<string, number> | undefined {
+  const raw = field.attr(FIELD_ATTR_INT_VALUE_MAP);
+  if (raw === undefined || raw === null || typeof raw !== "object") return undefined;
+  return raw as Record<string, number>;
+}
+
+/**
+ * The integer a member symbol persists as, for an int-backed enum. Throws when the
+ * member has no mapping — the loader pins key-set-equals-`@values` (Check 5b) in
+ * every port, so a miss is unreachable and must not be papered over: emitting the
+ * symbol instead would fail only at INSERT time, against a live database.
+ */
+export function intValueForMember(
+  intMap: Record<string, number>,
+  member: string,
+  context: string,
+): number {
+  const n = intMap[member];
+  if (typeof n !== "number") {
+    throw new Error(`@intValueMap has no integer for member '${member}' (${context}).`);
+  }
+  return n;
+}
+
 /** Build the Zod expression for a set of enum members, e.g. `z.enum(["A", "B"])`. */
 export function zodEnumExpr(values: string[]): string {
   return `z.enum([${values.map((v) => JSON.stringify(v)).join(", ")}])`;

package/src/projection/extract-view-spec.ts

@@ -32,6 +32,8 @@ import {
   FILTER_OP_LT,
   FILTER_OP_LTE,
   FILTER_OP_IS_NULL,
+  FILTER_OP_LIKE,
+  FIELD_SUBTYPE_ENUM,
   FILTER_COMPOSE_AND,
   FILTER_COMPOSE_OR,
   SORT_ORDER_DESC,
@@ -47,6 +49,7 @@ import {
   type AggregateFunction,
 } from "@metaobjectsdev/metadata";
 import { type MetaData, type MetaField, type MetaRoot, MetaObject } from "@metaobjectsdev/metadata";
+import { intValueMapOf } from "../enum-meta.js";
 import {
   columnNameFromField,
   viewNameFromProjection,
@@ -126,13 +129,84 @@ function resolveAggregateFilter(
       kind: "cmp",
       ref: `${alias}.${sourceColumnNameFor(field, ctx)}`,
       op,
-      value: opObj[op],
+      // Same int-backed-enum encoding as the row-scope @filter below: this scoping
+      // filter renders as a SQL literal too (FILTER (WHERE …) / CASE WHEN), so a
+      // member symbol would land unencoded in an integer comparison.
+      value: encodeIntEnumFilterValue(
+        opObj[op],
+        op,
+        field.subType === FIELD_SUBTYPE_ENUM ? intValueMapOf(field) : undefined,
+        key,
+        entity.name,
+      ),
     });
   }
   if (clauses.length === 0) return undefined;
   return clauses.length === 1 ? clauses[0]! : { kind: "and", clauses };
 }
 
+/**
+ * The `@intValueMap` of every int-backed `field.enum` the projection declares, keyed
+ * by field name. Only int-backed enums appear, so a lookup miss means "no encoding".
+ *
+ * `fields()` (effective) and `intValueMapOf` (which reads `attr`, RESOLVING) — a
+ * projection's fields are bound through `extends` to the base entity's, and post-#246
+ * the map itself commonly lives one hop further up on a shared abstract declaration.
+ * Own-only at either hop would silently emit the member symbol into an integer column
+ * (ADR-0039).
+ */
+function intEnumMapsOf(projection: MetaObject): ReadonlyMap<string, Record<string, number>> {
+  const out = new Map<string, Record<string, number>>();
+  for (const f of projection.fields()) {
+    if (f.subType !== FIELD_SUBTYPE_ENUM) continue;
+    const map = intValueMapOf(f);
+    if (map !== undefined) out.set(f.name, map);
+  }
+  return out;
+}
+
+/**
+ * Lower a filter value for an int-backed `field.enum` from its member SYMBOL to the
+ * INTEGER it persists as. A no-op for every other field (`intMap` undefined), so a
+ * string-backed enum's SQL is byte-identical.
+ *
+ * `isNull` is skipped — its value is a boolean, not a member. `like` is unreachable:
+ * `opsForField` removes it from an int-backed enum's band, so the loader rejects it
+ * before codegen; the explicit throw makes that a loud failure rather than a
+ * `LIKE NaN`. An unmapped member is likewise loader-unreachable (the key set is
+ * pinned equal to `@values`) and throws for the same reason — silently emitting the
+ * symbol would produce DDL that fails only at apply time, against a live database.
+ */
+function encodeIntEnumFilterValue(
+  value: unknown,
+  op: string,
+  intMap: Record<string, number> | undefined,
+  fieldName: string,
+  projectionName: string,
+): unknown {
+  if (intMap === undefined) return value;
+  if (op === FILTER_OP_IS_NULL) return value;
+  if (op === FILTER_OP_LIKE) {
+    throw new Error(
+      `Projection ${projectionName}: view @filter uses "like" on "${fieldName}", an ` +
+        `int-backed field.enum (@intValueMap) — it stores as an integer column, so a ` +
+        `substring match is not expressible. Use eq/ne/in.`,
+    );
+  }
+  const encode = (v: unknown): unknown => {
+    if (typeof v !== "string") return v;
+    const n = intMap[v];
+    if (typeof n !== "number") {
+      throw new Error(
+        `Projection ${projectionName}: view @filter value "${v}" for "${fieldName}" has no ` +
+          `entry in @intValueMap.`,
+      );
+    }
+    return n;
+  };
+  return Array.isArray(value) ? value.map(encode) : encode(value);
+}
+
 /**
  * #207 — resolve a projection's row-scope `@filter` (the desugared canonical
  * `{ field: { op: value }, and?, or? }`) into a {@link ViewFilterClause} whose
@@ -152,13 +226,14 @@ function resolveViewFilter(
   filter: unknown,
   columnsByField: ReadonlyMap<string, SelectColumn>,
   projectionName: string,
+  intMapsByField: ReadonlyMap<string, Record<string, number>>,
 ): ViewFilterClause | undefined {
   if (typeof filter !== "object" || filter === null || Array.isArray(filter)) return undefined;
   const clauses: ViewFilterClause[] = [];
   for (const [key, val] of Object.entries(filter as Record<string, unknown>)) {
     if (key === FILTER_AND || key === FILTER_OR) {
       const subs = (Array.isArray(val) ? val : [])
-        .map((s) => resolveViewFilter(s, columnsByField, projectionName))
+        .map((s) => resolveViewFilter(s, columnsByField, projectionName, intMapsByField))
         .filter((c): c is ViewFilterClause => c !== undefined);
       if (subs.length > 0) clauses.push({ kind: key === FILTER_AND ? "and" : "or", clauses: subs });
       continue;
@@ -177,7 +252,14 @@ function resolveViewFilter(
     // becomes its own comparison, AND-composed (dropping all-but-the-first would silently
     // widen the exposed row set). The loader has already validated every op for this
     // field's subtype.
-    for (const [op, value] of Object.entries(desugarClause(val))) {
+    for (const [op, rawValue] of Object.entries(desugarClause(val))) {
+      // An INT-BACKED field.enum (@intValueMap, design D5) stores as an INTEGER
+      // column, so the authored member SYMBOL must become its integer before it is
+      // rendered as a SQL literal. The Drizzle customType handles the runtime query
+      // path, but view DDL is emitted as literal SQL text and never touches Drizzle.
+      const value = encodeIntEnumFilterValue(
+        rawValue, op, intMapsByField.get(key), key, projectionName,
+      );
       if (col.kind === "passthrough") {
         clauses.push({ kind: "cmp", ref: `${col.sourceAlias}.${col.sourceColumn}`, op, value });
       } else if (col.kind === "computed") {
@@ -990,7 +1072,9 @@ export function extractViewSpec(
       const columnsByField = new Map<string, SelectColumn>(
         selectSpec.columns.map((c) => [c.fieldName, c] as const),
       );
-      where = resolveViewFilter(rawFilter, columnsByField, projection.name);
+      where = resolveViewFilter(
+        rawFilter, columnsByField, projection.name, intEnumMapsOf(projection),
+      );
     }
   }
 

package/src/templates/drizzle-schema.ts

@@ -13,7 +13,7 @@ import {
 } from "@metaobjectsdev/metadata";
 import { fieldDeclaringPackage, type RenderContext } from "../render-context.js";
 import { crossEntitySpecifier, valueObjectModuleSpecifier } from "../import-path.js";
-import { mapColumnType, type ColumnSpec } from "../column-mapper.js";
+import { mapColumnType, type ColumnSpec, type EnumIntCustomType } from "../column-mapper.js";
 import { tableNameFromEntity, columnNameFromField } from "../naming.js";
 import { renderRelationsBlock } from "./relations-block.js";
 import { renderDocsFor } from "./jsdoc.js";
@@ -66,6 +66,9 @@ export function renderDrizzleSchema(obj: MetaObject, ctx: RenderContext): Code {
   const columnLines: Code[] = [];
   // Collect CHECK constraints for enum columns; emitted as table-level check() callbacks.
   const checkConstraints: Array<{ name: string; expr: string }> = [];
+  // Int-backed field.enum customType helpers, emitted ahead of the table. Keyed by
+  // const name so a shared enum used by two fields of the SAME entity emits once.
+  const enumIntTypes = new Map<string, EnumIntCustomType>();
   for (const child of obj.fields()) {
     // #213 — a derived (origin-bearing) field is read-only, materialized on the
     // read (view) side, NOT a column on the entity's write table (FR-024 §7).
@@ -78,6 +81,9 @@ export function renderDrizzleSchema(obj: MetaObject, ctx: RenderContext): Code {
     // Compute the column spec once per field and reuse it for both the column
     // line and the CHECK collection.
     const spec = mapColumnType(child, ctx.dialect, ctx.columnNamingStrategy, ctx.timestampMode);
+    if (spec.enumIntCustomType !== undefined) {
+      enumIntTypes.set(spec.enumIntCustomType.fnConstName, spec.enumIntCustomType);
+    }
     const fieldDocs = renderDocsFor(child);
     const columnLine = renderColumn(spec, child, ctx, isPk, pkGeneration, fkInfo, isComposite, isUnique, obj.package, obj.name);
     columnLines.push(fieldDocs ? code`  ${fieldDocs}\n${columnLine}` : columnLine);
@@ -103,6 +109,9 @@ export function renderDrizzleSchema(obj: MetaObject, ctx: RenderContext): Code {
     // #213 — a TPH subtype's derived field is read-only too; never a table column.
     if (child.isDerived()) continue;
     const spec = mapColumnType(child, ctx.dialect, ctx.columnNamingStrategy, ctx.timestampMode);
+    if (spec.enumIntCustomType !== undefined) {
+      enumIntTypes.set(spec.enumIntCustomType.fnConstName, spec.enumIntCustomType);
+    }
     const fieldDocs = renderDocsFor(child);
     const columnLine = renderColumn(
       spec, child, ctx, false, undefined, fkMap.get(child.name), isComposite, false, obj.package, obj.name, true,
@@ -177,11 +186,60 @@ ${joinCode(columnLines, { on: ",\n", trim: false })}
   // Emit the relations() block (returns null if no relations).
   const relationsBlock = renderRelationsBlock(obj, ctx);
 
-  if (relationsBlock === null) {
-    return tableBlock;
-  }
+  // Int-backed enum codecs are declared BEFORE the table that references them.
+  // Sorted by const name so output is deterministic regardless of field order.
+  const enumIntBlocks = [...enumIntTypes.values()]
+    .sort((a, b) => a.fnConstName.localeCompare(b.fnConstName))
+    .map((t) => renderEnumIntCustomType(t, importModule));
 
-  return joinCode([tableBlock, relationsBlock], { on: "\n" });
+  const blocks: Code[] = [...enumIntBlocks, tableBlock];
+  if (relationsBlock !== null) blocks.push(relationsBlock);
+  return blocks.length === 1 ? blocks[0]! : joinCode(blocks, { on: "\n" });
+}
+
+/**
+ * Render an int-backed `field.enum`'s Drizzle `customType` helper plus its two
+ * lookup maps.
+ *
+ * The codec lives HERE, in the column definition, so nothing downstream needs to
+ * know about it: `db.insert().values()` encodes on bind, a selected row decodes on
+ * read, and a filter comparison encodes because Drizzle binds through the column
+ * type. That is why this shape was chosen over a Zod write-transform plus a
+ * generated read-decode — TS's generated queries return raw Drizzle rows and have
+ * no decode seam, so the query-layer approach meant inventing one and wrapping
+ * every generated read. It is also the direct analogue of what the other four
+ * ports already do (EF Core `HasConversion`, OMDB `JdbcFieldCodec`, Exposed
+ * `customEnumeration`, Python `ObjectManager` coercion).
+ *
+ * `fromDriver` throws on an unmapped integer rather than returning undefined: a
+ * value outside the map means the DB holds data the model says is impossible
+ * (a hand-written INSERT, or a member removed without a migration), and silently
+ * yielding `undefined` for a non-nullable field would surface far from the cause.
+ */
+function renderEnumIntCustomType(t: EnumIntCustomType, importModule: string): Code {
+  const customTypeSym = imp(`customType@${importModule}`);
+  const union = t.members.map((m) => JSON.stringify(m)).join(" | ");
+  const toEntries = t.members
+    .map((m) => `${JSON.stringify(m)}: ${t.intByMember[m]}`)
+    .join(", ");
+  const fromEntries = t.members
+    .map((m) => `${t.intByMember[m]}: ${JSON.stringify(m)}`)
+    .join(", ");
+  return code`
+const ${t.toIntConstName} = { ${toEntries} } as const satisfies Record<${union}, number>;
+const ${t.fromIntConstName}: Record<number, ${union}> = { ${fromEntries} };
+const ${t.fnConstName} = ${customTypeSym}<{ data: ${union}; driverData: number }>({
+  dataType: () => ${JSON.stringify(t.dataType)},
+  toDriver: (value) => ${t.toIntConstName}[value],
+  fromDriver: (value) => {
+    const member = ${t.fromIntConstName}[value];
+    if (member === undefined) {
+      throw new Error(\`unmapped ${t.fnConstName} value: \${value}\`);
+    }
+    return member;
+  },
+});
+`;
 }
 
 interface FkInfo {
@@ -266,7 +324,13 @@ function renderColumn(
   // and suppress any DB default (other-subtype rows must stay NULL here).
   forceNullable: boolean = false,
 ): Code {
-  const fnSym = imp(`${spec.fnName}@${spec.importModule}`);
+  // An int-backed field.enum's column function is a LOCAL generated const (the
+  // customType helper emitted into this same file), so it must not be imported
+  // from drizzle-orm/*-core like a built-in column type would be.
+  const fnSym =
+    spec.enumIntCustomType !== undefined
+      ? spec.enumIntCustomType.fnConstName
+      : imp(`${spec.fnName}@${spec.importModule}`);
 
   const dbNameLit = JSON.stringify(spec.dbName);
   let baseCall: Code;

package/src/templates/filter-allowlist.ts

@@ -13,7 +13,7 @@ import {
   FIELD_SUBTYPE_TIME,
   FIELD_SUBTYPE_TIMESTAMP,
   FIELD_SUBTYPE_CURRENCY,
-  opsForSubType,
+  opsForField,
 } from "@metaobjectsdev/metadata";
 import { sortableFields } from "./filter-shared.js";
 import type { RenderContext } from "../render-context.js";
@@ -72,7 +72,9 @@ export const ${entity.name}FilterAllowlist = {} as const satisfies FilterAllowli
   }
   const rows = fields
     .map((f) => {
-      const ops = opsForSubType(f.subType).map((o) => JSON.stringify(o)).join(", ");
+      // opsForField, not opsForSubType — an int-backed field.enum (@intValueMap)
+      // stores as an integer, so `like` (a substring match) is not in its band.
+      const ops = opsForField(f).map((o) => JSON.stringify(o)).join(", ");
       const sub = filterSubTypeFor(f.subType);
       // Only field.timestamp is governed by timestampMode — Drizzle types
       // field.date / field.time as strings under every dialect.

package/src/templates/filter-type.ts

@@ -11,7 +11,7 @@ import {
   FIELD_SUBTYPE_LONG,
   FIELD_SUBTYPE_DOUBLE,
   FIELD_SUBTYPE_FLOAT,
-  opsForSubType,
+  opsForField,
 } from "@metaobjectsdev/metadata";
 import { isSortableField } from "./filter-shared.js";
 
@@ -34,7 +34,11 @@ function tsNameFor(fieldSubType: string): string {
 }
 
 function renderFieldUnion(field: MetaField): string {
-  const ops = opsForSubType(field.subType);
+  // opsForField, not opsForSubType — an int-backed field.enum (@intValueMap) stores
+  // as an integer, so `like` is not in its band. The client type and the server
+  // allowlist MUST agree: offering `like` here that the allowlist 400s is a
+  // client/server mismatch of exactly the kind filter-shared.ts exists to prevent.
+  const ops = opsForField(field);
   const tsName = tsNameFor(field.subType);
   const opEntries = ops.map((op) => {
     if (op === "in") return `in?: ${tsName}[]`;