@metaobjectsdev/codegen-ts 0.21.1 → 0.21.3

package/src/templates/filter-allowlist.ts

@@ -16,6 +16,7 @@ import {
   opsForSubType,
 } from "@metaobjectsdev/metadata";
 import { sortableFields } from "./filter-shared.js";
+import type { RenderContext } from "../render-context.js";
 
 const NUMBER_SUBTYPES = new Set<string>([
   FIELD_SUBTYPE_INT,
@@ -52,8 +53,15 @@ function filterableFields(entity: MetaObject, exclude?: string): MetaField[] {
  * `exclude` (FR-017): drop a field from the allowlist. Used by per-subtype TPH
  * allowlists to omit the discriminator — it's pinned by the per-subtype route
  * path, so a client must not filter on it.
+ *
+ * `ctx` supplies `timestampMode`: under `"date"` a `field.timestamp` column binds a JS
+ * `Date`, so its rule carries `dateValues: true` and runtime-ts's filter parser coerces
+ * the query-string value with `new Date(...)` rather than binding a string against a
+ * Date-typed column (which threw at request time). `ctx.timestampMode` is already
+ * normalized to `"string"` for sqlite/D1 at both config choke points, so no dialect
+ * branching is needed here. Absent `ctx`, or in the default mode, output is unchanged.
  */
-export function renderFilterAllowlist(entity: MetaObject, exclude?: string): Code {
+export function renderFilterAllowlist(entity: MetaObject, exclude?: string, ctx?: RenderContext): Code {
   const fields = filterableFields(entity, exclude);
   if (fields.length === 0) {
     return code`
@@ -66,7 +74,12 @@ export const ${entity.name}FilterAllowlist = {} as const satisfies FilterAllowli
     .map((f) => {
       const ops = opsForSubType(f.subType).map((o) => JSON.stringify(o)).join(", ");
       const sub = filterSubTypeFor(f.subType);
-      return `  ${f.name}: { ops: [${ops}] as const, subType: ${JSON.stringify(sub)} as const, leadingWildcard: false }`;
+      // Only field.timestamp is governed by timestampMode — Drizzle types
+      // field.date / field.time as strings under every dialect.
+      const dateValues = ctx?.timestampMode === "date" && f.subType === FIELD_SUBTYPE_TIMESTAMP
+        ? ", dateValues: true as const"
+        : "";
+      return `  ${f.name}: { ops: [${ops}] as const, subType: ${JSON.stringify(sub)} as const, leadingWildcard: false${dateValues} }`;
     })
     .join(",\n");
   return code`

package/src/templates/projection-decl.ts

@@ -176,7 +176,7 @@ ${constFieldLines.join("\n")}
 } as const;
 `,
     ...(allowlists
-      ? [renderFilterAllowlist(projection), renderSortAllowlist(projection)]
+      ? [renderFilterAllowlist(projection, undefined, ctx), renderSortAllowlist(projection)]
       : []),
     renderFilterType(projection),
   ];

package/src/templates/value-object-file.ts

@@ -40,7 +40,7 @@ export function renderValueObjectFile(obj: MetaObject, apiPrefix = "", ctx?: Ren
   // not filter on it). Included fields are the subtype's own + inherited base
   // filterable fields. Drives the per-subtype REST routes' filter layer.
   const discField = tphSubtype ? tphDiscriminatorPin(obj)?.fieldName : undefined;
-  const tphFilterAllowlist = tphSubtype ? renderFilterAllowlist(obj, discField) : null;
+  const tphFilterAllowlist = tphSubtype ? renderFilterAllowlist(obj, discField, ctx) : null;
   const tphSortAllowlist = tphSubtype ? renderSortAllowlist(obj, discField) : null;
   // FR-017 Tier 3: the per-subtype CLIENT filter type, discriminator-excluded —
   // kept in lockstep with the per-subtype allowlist above so a typed

package/src/templates/view-decl.ts

@@ -130,7 +130,9 @@ export function renderViewReadZodObject(fields: readonly MetaField[], opts: View
       return code`  ${f.name}: ${base}${nullable}`;
     }
     // #204 — an array passthrough reads as `T[]`; zodTypeFor returns the ELEMENT type.
-    const inner = code`${z}.${zodTypeFor(f).replace(/^z\./, "")}`;
+    // CRITICAL 3: thread timestampMode through so a FIELD_SUBTYPE_TIMESTAMP column
+    // agrees with the Drizzle view column's mode (both sourced from `opts` above).
+    const inner = code`${z}.${zodTypeFor(f, timestampMode).replace(/^z\./, "")}`;
     const zbase = f.resolvedIsArray() ? code`${z}.array(${inner})` : inner;
     return code`  ${f.name}: ${zbase}${nullable}`;
   });

package/src/templates/zod-validators.ts

@@ -28,6 +28,7 @@ import {
   VALIDATOR_ATTR_MAX, VALIDATOR_ATTR_MIN, VALIDATOR_ATTR_PATTERN,
   GENERATION_INCREMENT, GENERATION_UUID,
   OBJECT_ATTR_DISCRIMINATOR, OBJECT_ATTR_DISCRIMINATOR_VALUE,
+  OBJECT_SUBTYPE_VALUE,
 } from "@metaobjectsdev/metadata";
 import { enumValues, zodEnumExpr } from "../enum-meta.js";
 import { ZOD_INET_EXPR } from "./net-regex.js";
@@ -193,7 +194,13 @@ export function renderInsertSchemaOnly(obj: MetaObject, ctx?: RenderContext): Co
 
     if (autoSet === AUTO_SET_ON_CREATE || autoSet === AUTO_SET_ON_UPDATE) {
       insertFieldLines.push(
-        code`  ${child.name}: z.string().optional().transform(() => new Date().toISOString())`,
+        ctx?.timestampMode === "date"
+          // CRITICAL 1: these schemas validate raw JSON request bodies (wire
+          // timestamps are ISO strings), never a live `Date` — z.coerce.date()
+          // (not z.date()) so a string round-trips; z.date() rejects every JSON
+          // wire value outright (verified: z.date().safeParse(isoString) is false).
+          ? code`  ${child.name}: z.coerce.date().optional().transform(() => new Date())`
+          : code`  ${child.name}: z.string().optional().transform(() => new Date().toISOString())`,
       );
     } else {
       insertFieldLines.push(code`  ${child.name}: ${zodFieldExpr(child, obj, ctx)}`);
@@ -338,7 +345,13 @@ export function renderZodValidators(obj: MetaObject, ctx?: RenderContext): Code
     // Insert schema: @autoSet fields use transform (always override client input).
     if (autoSet === AUTO_SET_ON_CREATE || autoSet === AUTO_SET_ON_UPDATE) {
       insertFieldLines.push(
-        code`  ${child.name}: z.string().optional().transform(() => new Date().toISOString())`,
+        ctx?.timestampMode === "date"
+          // CRITICAL 1: these schemas validate raw JSON request bodies (wire
+          // timestamps are ISO strings), never a live `Date` — z.coerce.date()
+          // (not z.date()) so a string round-trips; z.date() rejects every JSON
+          // wire value outright (verified: z.date().safeParse(isoString) is false).
+          ? code`  ${child.name}: z.coerce.date().optional().transform(() => new Date())`
+          : code`  ${child.name}: z.string().optional().transform(() => new Date().toISOString())`,
       );
       // Preserving schema: the @autoSet column is validated verbatim (its natural
       // field expr) so an import/restore keeps the caller's original timestamp.
@@ -354,7 +367,13 @@ export function renderZodValidators(obj: MetaObject, ctx?: RenderContext): Code
       // Omit: creation timestamps cannot be changed after creation
     } else if (autoSet === AUTO_SET_ON_UPDATE) {
       updateFieldLines.push(
-        code`  ${child.name}: z.string().optional().transform(() => new Date().toISOString())`,
+        ctx?.timestampMode === "date"
+          // CRITICAL 1: these schemas validate raw JSON request bodies (wire
+          // timestamps are ISO strings), never a live `Date` — z.coerce.date()
+          // (not z.date()) so a string round-trips; z.date() rejects every JSON
+          // wire value outright (verified: z.date().safeParse(isoString) is false).
+          ? code`  ${child.name}: z.coerce.date().optional().transform(() => new Date())`
+          : code`  ${child.name}: z.string().optional().transform(() => new Date().toISOString())`,
       );
     } else {
       // All non-autoSet fields are optional in the update schema (PATCH semantics).
@@ -511,9 +530,29 @@ function zodFieldExpr(field: MetaField, owner?: MetaObject, ctx?: RenderContext)
       break;
     case FIELD_SUBTYPE_DATE:
     case FIELD_SUBTYPE_TIME:
-    case FIELD_SUBTYPE_TIMESTAMP:
-      baseStr = "z.string()";
+      baseStr = "z.string()"; // calendar date / time-of-day — always ISO-string-shaped, not governed by timestampMode
+      break;
+    case FIELD_SUBTYPE_TIMESTAMP: {
+      // Must agree with column-mapper.ts's mapColumnType, which already honors
+      // ctx.timestampMode for the Drizzle column itself — z.string() here regardless would
+      // disagree with a "date"-mode column (Date-typed) and fail to typecheck downstream
+      // (reported against an adopting project).
+      //
+      // IMPORTANT 5: a VO-hosted (object.value) timestamp is jsonb storage —
+      // inherently ISO-string JSON, never a live `Date` — so it stays z.string()
+      // regardless of ctx.timestampMode; that matches the VO structural interface
+      // (inferred-types.ts's SCALAR_TS_BY_SUBTYPE, deliberately NOT mode-aware —
+      // the two are documented as lock-step). An entity/TPH-subtype field (a real
+      // DB column) honors the mode.
+      const voHosted = owner?.subType === OBJECT_SUBTYPE_VALUE;
+      // CRITICAL 1: z.coerce.date() (not z.date()) — the ONE expression correct
+      // for both readers of zodFieldExpr's output: the TPH read schema parses DB
+      // rows (already a `Date` under pg date mode — z.coerce.date() passes a
+      // Date through unchanged) while insert/update/preserving parse wire JSON
+      // (an ISO string — z.coerce.date() parses it; z.date() would reject it).
+      baseStr = ctx?.timestampMode === "date" && !voHosted ? "z.coerce.date()" : "z.string()";
       break;
+    }
     case FIELD_SUBTYPE_ENUM: {
       const values = enumValues(field);
       if (values === undefined) {