@zerotal/validator 1.7.2 → 1.7.4

package/CHANGELOG.md

@@ -8,6 +8,24 @@ follows the Zerotal monorepo's unified versioning.
 
 ## [Unreleased]
 
+## [1.7.3] — 2026-08-20
+
+### Fixed
+
+- **An optional `number` or `date` reads `""` as absence.** An HTML `<select>` has one way to
+  say "none" — `<option value="">` — and it sends the empty string. `r.number().optional()`
+  refused it, so a form with an optional assignee could not be submitted _without_ one: the
+  single case the field was optional for. The message named a field the reader never touched,
+  which is the part that made it expensive to find.
+
+  It is now read as no value. The field is skipped, or set to `null` when the rule is also
+  `nullable()` — because clearing is what that option means, and skipping would leave the
+  previous value in place while reporting success. This mirrors how an explicit `null` on a
+  `nullable()` field already behaves.
+
+  Narrow on purpose: `string` still keeps `""`, where it may be a value someone meant, and the
+  remaining types wait for a case that needs them. Nothing that validated before stops doing so.
+
 ## [1.5.0] — 2026-08-15
 
 ### Fixed

package/api-surface.md

@@ -130,6 +130,7 @@ class FormRequest = {
   static macro: (name: string, fn: (this: FormRequest, ...args: unknown[]) => unknown) => void
   static validate: <T extends FormRequest>(this: new () => T) => Promise<Infer<ExtractDefs<ReturnType<T['rules']>>>>
   authorize: () => boolean | Promise<boolean>
+  prepareForValidation: (body: Record<string, unknown>) => Record<string, unknown>
   rules: (_r: RuleBuilder) => Record<string, FieldRule>
 }
 

package/package.json

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

package/src/Validator.ts

@@ -10,6 +10,12 @@ import type { UniqueOptions } from "./dbRules.ts";
 import { RULES } from "./stringRules.ts";
 
 /** Resolve whether a field is effectively required given its conditional modifiers. */
+/**
+ * Rule types for which the empty string cannot be a value, so an optional field
+ * handed `""` is a form saying "none" rather than data to check.
+ */
+const EMPTY_MEANS_ABSENT: ReadonlySet<FieldRuleDefinition["type"]> = new Set(["number", "date"]);
+
 function resolveRequired(def: FieldRuleDefinition, input: Record<string, unknown>): boolean {
   if (def.requiredIf !== undefined) {
     const cond = def.requiredIf;
@@ -124,12 +130,30 @@ export function runValidation<S extends Schema>(
       continue;
     }
 
+    const isRequired = resolveRequired(def, input);
+
+    // An HTML form has exactly one way to say "no value": the empty string. A
+    // `<select>`'s placeholder option sends it, and for a type that can never
+    // hold `""` — a number, a date — reading it as the literal text rather than
+    // as absence is what made an optional select unsubmittable in the one case
+    // it was optional for. The message named a field the reader never touched,
+    // which is the part that made it expensive to find.
+    //
+    // Narrow deliberately. `string` keeps `""`, where it may be a value someone
+    // meant; the remaining types wait for a case that needs them. Each is a
+    // widening when it comes — nothing that validated before stops doing so.
+    if (!isRequired && value === "" && EMPTY_MEANS_ABSENT.has(def.type)) {
+      // `nullable()` is the field saying it can be cleared, and clearing is what
+      // the placeholder option is for — so it reaches the output as null rather
+      // than being skipped, exactly as an explicit null does below. Skipping it
+      // would leave the previous value in place and report success.
+      value = def.nullable ? null : undefined;
+    }
+
     if ((value === undefined || value === null) && def.defaultVal !== undefined) {
       value = def.defaultVal;
     }
 
-    const isRequired = resolveRequired(def, input);
-
     if (isRequired && (value === undefined || value === null || value === "")) {
       errors[field] ??= def.requiredMessage ?? `The ${field} field is required.`;
       continue;