@zerotal/validator 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -8,6 +8,22 @@ follows the Zerotal monorepo's unified versioning.
 
 ## [Unreleased]
 
+## [1.5.0] — 2026-08-15
+
+### Fixed
+
+- **`Infer<>` resolves `array` and `object` to their contents.** Both inferred
+  `unknown`, which is worse than it sounds: the idiomatic `data.ids ?? []` turns
+  `unknown` into `{}`, so the error the user sees is
+  `Property 'map' does not exist on type '{}'` — pointing at the array they just
+  validated, with nothing to suggest the validator is where the type was lost.
+  `r.array(r.number())` is now `number[]`, `r.object({ … })` is the shape it was
+  given, and both nest to any depth. `nullable()` widens at every level rather
+  than only the top one.
+
+  `r.object()`'s shape parameter is inferred directly instead of through a
+  `Schema` constraint, which is what makes the field types reachable at all.
+
 ## [1.0.3] — 2026-08-07
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zerotal/validator",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "license": "MIT",
   "maturity": "stable",
   "private": false,
@@ -29,7 +29,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@zerotal/core": "1.4.0"
+    "@zerotal/core": "1.5.0"
   },
   "devDependencies": {
     "typescript": "^5.8.0"

package/src/FieldRule.ts

@@ -1,4 +1,4 @@
-import type { FieldRuleDefinition, Schema, CustomFn } from "./types.ts";
+import type { FieldRuleDefinition, CustomFn } from "./types.ts";
 import type { UniqueOptions } from "./dbRules.ts";
 
 // Narrow definition types — each class's _def has a literal 'type' field so
@@ -6,8 +6,17 @@ import type { UniqueOptions } from "./dbRules.ts";
 type StringDef = Omit<FieldRuleDefinition, "type"> & { type: "string" };
 type NumberDef = Omit<FieldRuleDefinition, "type"> & { type: "number" };
 type BooleanDef = Omit<FieldRuleDefinition, "type"> & { type: "boolean" };
-type ArrayDef = Omit<FieldRuleDefinition, "type"> & { type: "array" };
-type ObjectDef = Omit<FieldRuleDefinition, "type"> & { type: "object" };
+// array/object are the two whose inferred type depends on more than `type`, so their
+// defs keep the item/shape definitions in the type rather than widening them to the
+// optional `children`/`shape` on FieldRuleDefinition. Without this the item type is
+// erased and `Infer<>` can only say `unknown` for the whole array.
+type ArrayDef<C extends FieldRuleDefinition = FieldRuleDefinition> = Omit<
+  FieldRuleDefinition,
+  "type" | "children"
+> & { type: "array"; children: C };
+type ObjectDef<
+  Sh extends Record<string, FieldRuleDefinition> = Record<string, FieldRuleDefinition>,
+> = Omit<FieldRuleDefinition, "type" | "shape"> & { type: "object"; shape: Sh };
 
 type RuleEntry = { name: string; args: unknown[]; message?: string; fn?: CustomFn };
 
@@ -513,7 +522,7 @@ export class BooleanRule extends FieldRule {
 }
 
 export class ArrayRule<T extends FieldRule> extends FieldRule {
-  readonly _def: ArrayDef;
+  readonly _def: ArrayDef<T["_def"]>;
 
   constructor(item: T) {
     super();
@@ -544,10 +553,13 @@ export class ArrayRule<T extends FieldRule> extends FieldRule {
   }
 }
 
-export class ObjectRule<S extends Schema> extends FieldRule {
-  readonly _def: ObjectDef;
+// Generic over the *rules* passed in, not over the definitions they produce. The old
+// `S extends Schema` had no inference site — `{ [K in keyof S]: FieldRule }` mentions
+// S only in its keys — so S collapsed to its constraint and the shape was lost.
+export class ObjectRule<S extends Record<string, FieldRule>> extends FieldRule {
+  readonly _def: ObjectDef<{ [K in keyof S]: S[K]["_def"] }>;
 
-  constructor(shape: { [K in keyof S]: FieldRule }) {
+  constructor(shape: S) {
     super();
     const shapeRecord: Record<string, FieldRuleDefinition> = {};
     for (const [k, v] of Object.entries(shape)) {
@@ -559,7 +571,7 @@ export class ObjectRule<S extends Schema> extends FieldRule {
       nullable: false,
       defaultVal: undefined,
       rules: [],
-      shape: shapeRecord,
+      shape: shapeRecord as { [K in keyof S]: S[K]["_def"] },
     };
   }
 }

package/src/FormRequest.ts

@@ -62,6 +62,8 @@ type SessionLike = {
  * const data = await StorePostRequest.validate();
  * // data.title → string  (fully typed — no casts needed)
  */
+// Merged with the empty interface below — the app-augmentable seam for typed fields.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 export abstract class FormRequest {
   /**
    * Access the current request's HttpContext from within instance methods.
@@ -251,5 +253,5 @@ export abstract class FormRequest {
  *   }
  * }
  */
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 export interface FormRequest {}

package/src/RuleBuilder.ts

@@ -9,7 +9,6 @@ import {
   PasswordRule,
 } from "./FieldRule.ts";
 import type { FieldRule } from "./FieldRule.ts";
-import type { Schema } from "./types.ts";
 
 export class RuleBuilder {
   /**
@@ -59,7 +58,7 @@ export class RuleBuilder {
     return new ArrayRule(item);
   }
 
-  object<S extends Schema>(shape: { [K in keyof S]: FieldRule }): ObjectRule<S> {
+  object<S extends Record<string, FieldRule>>(shape: S): ObjectRule<S> {
     return new ObjectRule<S>(shape);
   }
 }

package/src/types.ts

@@ -47,7 +47,38 @@ export type InferFieldType<F extends FieldRuleDefinition> = F["type"] extends "s
       ? boolean
       : F["type"] extends "date"
         ? Date
-        : unknown;
+        : F["type"] extends "array"
+          ? InferArrayType<F>
+          : F["type"] extends "object"
+            ? InferObjectType<F>
+            : unknown;
+
+/**
+ * `array` and `object` carry their contents on `children` / `shape`, so unlike the
+ * scalar rules their inferred type is not decided by `type` alone. `ArrayRule` and
+ * `ObjectRule` thread the item/shape definitions through those two fields (see
+ * `ArrayDef` / `ObjectDef`), which is what these two read back out.
+ *
+ * Both degrade rather than fail: a definition widened to bare `FieldRuleDefinition`
+ * has an optional `children`/`shape` that infers nothing, and falls back to the
+ * loosest honest type instead of `never`.
+ */
+type InferArrayType<F extends FieldRuleDefinition> = F extends {
+  children: infer C extends FieldRuleDefinition;
+}
+  ? InferField<C>[]
+  : unknown[];
+
+type InferObjectType<F extends FieldRuleDefinition> = F extends {
+  shape: infer Sh extends Record<string, FieldRuleDefinition>;
+}
+  ? { [K in keyof Sh]: InferField<Sh[K]> }
+  : Record<string, unknown>;
+
+/** One field's type, including its `nullable` widening. Shared by `Infer` and the nested inferers. */
+type InferField<F extends FieldRuleDefinition> = F["nullable"] extends true
+  ? InferFieldType<F> | null
+  : InferFieldType<F>;
 
 /**
  * Infer the validated TypeScript type from a Schema.
@@ -55,9 +86,7 @@ export type InferFieldType<F extends FieldRuleDefinition> = F["type"] extends "s
  * distinction is enforced at runtime only. Trade-off acknowledged in the plan.
  */
 export type Infer<S extends Schema> = {
-  [K in keyof S]: S[K]["nullable"] extends true
-    ? InferFieldType<S[K]> | null
-    : InferFieldType<S[K]>;
+  [K in keyof S]: InferField<S[K]>;
 };
 
 export type ValidationErrors = Record<string, string>;