@metaobjectsdev/codegen-ts 0.14.1 → 0.15.0-rc.1

package/src/templates/zod-validators.ts

@@ -16,9 +16,11 @@ import {
   FIELD_SUBTYPE_BOOLEAN, FIELD_SUBTYPE_DOUBLE, FIELD_SUBTYPE_FLOAT,
   FIELD_SUBTYPE_DATE, FIELD_SUBTYPE_TIME, FIELD_SUBTYPE_TIMESTAMP,
   FIELD_SUBTYPE_ENUM, FIELD_SUBTYPE_OBJECT, FIELD_SUBTYPE_MAP, FIELD_SUBTYPE_UUID,
+  FIELD_SUBTYPE_URI, FIELD_SUBTYPE_INET,
   VALIDATOR_SUBTYPE_REQUIRED, VALIDATOR_SUBTYPE_LENGTH, VALIDATOR_SUBTYPE_REGEX,
   VALIDATOR_SUBTYPE_NUMERIC, VALIDATOR_SUBTYPE_ARRAY,
   IDENTITY_ATTR_FIELDS, IDENTITY_ATTR_GENERATION,
+  FIELD_ATTR_STRING_FORMAT, STRING_FORMAT_EMAIL, STRING_FORMAT_HOSTNAME,
   FIELD_ATTR_REQUIRED, FIELD_ATTR_MAX_LENGTH, FIELD_ATTR_DEFAULT,
   FIELD_ATTR_AUTO_SET, FIELD_ATTR_OBJECT_REF, FIELD_ATTR_VALUE_TYPE, FIELD_ATTR_READ_ONLY,
   FIELD_ATTR_DB_COLUMN_TYPE, DB_COLUMN_TYPE_JSONB,
@@ -43,12 +45,16 @@ import { valueObjectModuleSpecifier } from "../import-path.js";
  * when the object is not a TPH subtype.
  */
 export function tphDiscriminatorPin(obj: MetaObject): { fieldName: string; value: string } | undefined {
+  // ADR-0039: own — super-resolution walk. A subtype declares its OWN
+  // @discriminatorValue (must not inherit one), and the base level is found by
+  // walking superResolved reading each level's OWN @discriminator.
   const value = obj.ownAttr(OBJECT_ATTR_DISCRIMINATOR_VALUE);
   if (typeof value !== "string" || value === "") return undefined;
 
   // Walk the extends chain to find the root carrying @discriminator.
   let cursor = obj.superResolved;
   while (cursor !== undefined) {
+    // ADR-0039: own — super-resolution walk; read each level's OWN @discriminator.
     const fieldName = cursor.ownAttr(OBJECT_ATTR_DISCRIMINATOR);
     if (typeof fieldName === "string" && fieldName !== "") {
       return { fieldName, value };
@@ -322,6 +328,17 @@ ${joinCode(updateFieldLines, { on: ",\n" })}
 `;
 }
 
+/**
+ * ADR-0036/0037 Wave 3 — the CANONICAL hostname matcher for @stringFormat:
+ * hostname, emitted as a Zod `.regex(...)` literal. The matcher lives in codegen
+ * (NOT author validator.regex) so every port can replicate the SAME canonical
+ * form — cross-language regex engines diverge, so the byte-identical source of
+ * truth is this one expression. RFC 1123 labels: 1–63 chars each, alphanumeric
+ * + internal hyphens, dot-separated; total form anchored.
+ */
+const HOSTNAME_REGEX_LITERAL =
+  "/^(?=.{1,253}$)([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/";
+
 /** Zod expression for a scalar value subtype (used for a field.map's @valueType). */
 function zodScalarFor(subType: string): string {
   if (subType === FIELD_SUBTYPE_INT || subType === FIELD_SUBTYPE_LONG || subType === FIELD_SUBTYPE_CURRENCY) return "z.number().int()";
@@ -342,7 +359,7 @@ function zodFieldExpr(field: MetaField, owner?: MetaObject, ctx?: RenderContext)
   // field.object below).
   if (field.attr(FIELD_ATTR_DB_COLUMN_TYPE) === DB_COLUMN_TYPE_JSONB) {
     let base: Code = code`z.unknown()`;
-    if (field.isArray) base = code`z.array(${base})`;
+    if (field.resolvedIsArray()) base = code`z.array(${base})`;
     return appendValidatorChain(base, field);
   }
 
@@ -364,13 +381,13 @@ function zodFieldExpr(field: MetaField, owner?: MetaObject, ctx?: RenderContext)
         : `./${refBase}.js`;
       const refImp = imp(`${refBase}InsertSchema@${moduleSpec}`);
       let base: Code = code`${refImp}`;
-      if (field.isArray) base = code`z.array(${base})`;
+      if (field.resolvedIsArray()) base = code`z.array(${base})`;
       return appendValidatorChain(base, field);
     }
     // No resolvable @objectRef — fall through to z.unknown(); downstream code
     // can still pass a value through but loses validation.
     let base: Code = code`z.unknown()`;
-    if (field.isArray) base = code`z.array(${base})`;
+    if (field.resolvedIsArray()) base = code`z.array(${base})`;
     return appendValidatorChain(base, field);
   }
 
@@ -427,21 +444,44 @@ function zodFieldExpr(field: MetaField, owner?: MetaObject, ctx?: RenderContext)
           const spec = sharedEnumImportSpecifier(ctx, owner?.package);
           const sharedConst = imp(`${constName}@${spec}`);
           let base: Code = code`${sharedConst}`;
-          if (field.isArray) base = code`z.array(${base})`;
+          if (field.resolvedIsArray()) base = code`z.array(${base})`;
           return appendValidatorChain(base, field);
         }
       }
       baseStr = zodEnumExpr(values);
       break;
     }
-    case FIELD_SUBTYPE_STRING:
+    case FIELD_SUBTYPE_URI:
+      // ADR-0036/0037 Wave 3: a URI/URL string — codegen owns the canonical
+      // URL matcher (Zod .url()), never author regex.
+      baseStr = "z.string().url()";
+      break;
+    case FIELD_SUBTYPE_INET:
+      // ADR-0036/0037 Wave 3: an IP-address string (v4 or v6) — codegen owns
+      // the canonical IP matcher (Zod .ip() accepts both versions).
+      baseStr = "z.string().ip()";
+      break;
+    case FIELD_SUBTYPE_STRING: {
+      // ADR-0036/0037 Wave 3: @stringFormat narrows a plain string to a closed
+      // validated format. The canonical matcher per format lives HERE (codegen),
+      // not author validator.regex. The field stays a plain string.
+      const fmt = field.attr(FIELD_ATTR_STRING_FORMAT);
+      if (fmt === STRING_FORMAT_EMAIL) {
+        baseStr = "z.string().email()";
+      } else if (fmt === STRING_FORMAT_HOSTNAME) {
+        baseStr = `z.string().regex(${HOSTNAME_REGEX_LITERAL})`;
+      } else {
+        baseStr = "z.string()";
+      }
+      break;
+    }
     case FIELD_SUBTYPE_UUID:
     default:
       baseStr = "z.string()";
       break;
   }
 
-  if (field.isArray) baseStr = `z.array(${baseStr})`;
+  if (field.resolvedIsArray()) baseStr = `z.array(${baseStr})`;
   return appendValidatorChain(code`${baseStr}`, field);
 }
 
@@ -480,36 +520,45 @@ function appendValidatorChain(base: Code, field: MetaField): Code {
   let arrMax: number | undefined;
   for (const child of field.validators()) {
     if (child.subType === VALIDATOR_SUBTYPE_REQUIRED) isRequired = true;
+    // ADR-0039: resolving — a validator may inherit @min/@max/@pattern via extends
+    // (matches Java attrInt's resolving getMetaAttr(attr)).
     if (child.subType === VALIDATOR_SUBTYPE_LENGTH) {
-      const max = child.ownAttr(VALIDATOR_ATTR_MAX);
-      const min = child.ownAttr(VALIDATOR_ATTR_MIN);
+      const max = child.attr(VALIDATOR_ATTR_MAX);
+      const min = child.attr(VALIDATOR_ATTR_MIN);
       if (typeof max === "number") maxLen = max;
       if (typeof min === "number") minLen = min;
     }
     if (child.subType === VALIDATOR_SUBTYPE_REGEX) {
-      const p = child.ownAttr(VALIDATOR_ATTR_PATTERN);
+      const p = child.attr(VALIDATOR_ATTR_PATTERN);
       if (typeof p === "string") pattern = p;
     }
     if (child.subType === VALIDATOR_SUBTYPE_NUMERIC) {
-      const max = child.ownAttr(VALIDATOR_ATTR_MAX);
-      const min = child.ownAttr(VALIDATOR_ATTR_MIN);
+      const max = child.attr(VALIDATOR_ATTR_MAX);
+      const min = child.attr(VALIDATOR_ATTR_MIN);
       if (typeof max === "number") numMax = max;
       if (typeof min === "number") numMin = min;
     }
     if (child.subType === VALIDATOR_SUBTYPE_ARRAY) {
-      const max = child.ownAttr(VALIDATOR_ATTR_MAX);
-      const min = child.ownAttr(VALIDATOR_ATTR_MIN);
+      const max = child.attr(VALIDATOR_ATTR_MAX);
+      const min = child.attr(VALIDATOR_ATTR_MIN);
       if (typeof max === "number") arrMax = max;
       if (typeof min === "number") arrMin = min;
     }
   }
 
+  // A `field.string` + `@dbColumnType: jsonb` open bag has a `z.unknown()` base, so
+  // the string character-count validators (.min/.max/.regex) do NOT apply — chaining
+  // `.min(1)` for a required bag yields `z.unknown().min(1)`, a TS compile error.
+  // "Required" for an open bag means non-optional only (handled by the optional()
+  // logic below). A jsonb ARRAY still gets element-count bounds via the array branch.
+  const isJsonbBag = field.attr(FIELD_ATTR_DB_COLUMN_TYPE) === DB_COLUMN_TYPE_JSONB;
+
   let chain: Code = base;
   // Array element-count bounds apply to the z.array(...) wrapper regardless of element type.
-  if (field.isArray) {
+  if (field.resolvedIsArray()) {
     if (arrMin !== undefined) chain = code`${chain}.min(${arrMin})`;
     if (arrMax !== undefined) chain = code`${chain}.max(${arrMax})`;
-  } else if (field.subType === FIELD_SUBTYPE_STRING) {
+  } else if (field.subType === FIELD_SUBTYPE_STRING && !isJsonbBag) {
     if (minLen !== undefined) chain = code`${chain}.min(${minLen})`;
     else if (isRequired) chain = code`${chain}.min(1)`;
     if (maxLen !== undefined) chain = code`${chain}.max(${maxLen})`;