@warlock.js/seal 5.8.0 → 5.10.0

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to `@warlock.js/seal` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 5.10.0 - 2026-09-14
+
+### Added
+
+- `.coerce()` on `v.boolean()` — opt-in query-string coercion (`"true"`/`"1"` → `true`, `"false"`/`"0"` → `false`).
+
+## 5.9.0 - 2026-09-13
+
+### Added
+
+- `.coerce()` modifier on the number validators (`int` / `number` / `float` / `numeric`): opt into parsing a numeric-shaped string (e.g. a query-string param) into a number while the type rule stays strict. `v.int()` is unchanged by default; chain `.coerce()` to accept `"2"` as `2`. The inferred output type is unaffected.
+
 ## 5.7.0 - 2026-09-11
 
 ### Changed
@@ -11,6 +23,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 - Internal type-safety hardening; no behaviour change.
 
 ## 5.6.0 - 2026-09-08
+
 ### Fixed
 
 - **`warlock build` and `warlock start` died inside Seal before any application code ran**, with a `ReferenceError` from `array-validator.ts` extending `BaseValidator` before `base-validator.ts` had finished evaluating. The cause was one inline `type` import: under `verbatimModuleSyntax`, `import { type ValidateOptions } from "./validators"` is emitted as a real side-effect import, which closed an import cycle that a type-only import would never have created. Written as `import type { ... }`, the module is not pulled into evaluation at all. Nothing about the validators changed — only which modules load, and when.
@@ -86,7 +99,7 @@ changelogs.
 - `v.literal("")` could never pass. Every validator is required by default and `required` rejects anything the empty-value check calls empty — which includes `""` — so a schema demanding an exact empty string reported "is required" for a field that was present. A literal set containing an empty value now uses `present` (the key must exist) instead of `required`, leaving the literal set to judge the value. Only the empty string was affected; `v.literal(0)` and `v.literal(false)` always worked
 - `v.literal("").optional()` silently disabled the literal check rather than fixing it, accepting `""`, `null` **and** a missing key alike. The literal rule now runs on empty values (`requiresValue: false`) while treating absence as the required/present rule's question, so `.optional()` means optional again and a present value must still match
 - a **failed** validation no longer returns the input it rejected. `object` returned the raw input — including the unknown keys it had just complained about — while `discriminatedUnion` returned `undefined`; the same call shape had two contracts. Validating an outbound DTO to keep internal fields out of a response, then reading `data` without branching on `isValid`, shipped every field the schema existed to exclude. `data` is now `undefined` whenever `isValid` is `false`
-- `v.number().toFixed(n)` could never produce a valid result — the mutator returned `Number(value).toFixed(n)`, a *string*, which the validator's own `number` type rule then rejected. It now yields a number (`3.14159` → `3.14`), so the method works where it lives. No working code can have depended on the old output, since every such validation failed; for a fixed-point *string*, format at the presentation edge rather than asking a number schema to emit one
+- `v.number().toFixed(n)` could never produce a valid result — the mutator returned `Number(value).toFixed(n)`, a _string_, which the validator's own `number` type rule then rejected. It now yields a number (`3.14159` → `3.14`), so the method works where it lives. No working code can have depended on the old output, since every such validation failed; for a fixed-point _string_, format at the presentation edge rather than asking a number schema to emit one
 
 ## 4.2.11
 

package/cjs/index.cjs

@@ -1127,6 +1127,21 @@ const removeEmptyArrayElementsMutator = async (value) => {
 	return value.filter((item) => !isEmptyValue(item));
 };
 
+//#endregion
+//#region ../seal/src/mutators/boolean-mutators.ts
+/**
+* Coerce a query-string-shaped boolean into a real boolean.
+*
+* Converts exactly: `"true"` / `"1"` / `1` → `true`, `"false"` / `"0"` / `0` → `false`.
+* Case-sensitive, no trimming. Any other value (`"yes"`, `"on"`, `"TRUE"`, `""`,
+* `2`, `null`, etc.) passes through unchanged so the boolean type rule rejects it.
+*/
+const booleanCoerceMutator = async (value) => {
+	if (value === "true" || value === "1" || value === 1) return true;
+	if (value === "false" || value === "0" || value === 0) return false;
+	return value;
+};
+
 //#endregion
 //#region ../seal/src/mutators/date-mutators.ts
 /**
@@ -5783,6 +5798,27 @@ var BooleanValidator = class extends PrimitiveValidator {
 		return this.addRule(declinedWithoutRule, errorMessage, { field });
 	}
 	/**
+	* Opt in to coercion: an exact query-string-shaped boolean is converted to a
+	* real boolean **before** the type rules run; any other value passes through
+	* unchanged so bad input still fails the type rule.
+	*
+	* Converts exactly `"true"` / `"1"` / `1` → `true` and `"false"` / `"0"` / `0`
+	* → `false`. Case-sensitive, no trimming — `"TRUE"`, `"yes"`, `"on"`, `""`, and
+	* `2` all pass through unchanged and fail the type rule. `v.boolean()` does
+	* **not** coerce by default; this only takes effect when explicitly chained.
+	* For form-style truthy strings like `"yes"` / `"on"`, use `.accepted()` /
+	* `.declined()` instead — those are separate pass/fail rules, not coercion.
+	*
+	* The output type is unchanged (`Infer<>` keys off the validator class), so
+	* `v.boolean().coerce()` still infers `boolean`.
+	*
+	* @example
+	* v.boolean().coerce()   // "true" → true; "1" → true; "0" → false; "yes" → invalid
+	*/
+	coerce() {
+		return this.addMutator(booleanCoerceMutator);
+	}
+	/**
 	* Value must be strictly true (not "yes", "on", 1, etc.)
 	* @alias accepted - strict version
 	*/
@@ -6977,6 +7013,26 @@ var NumberValidator = class extends PrimitiveValidator {
 		return this.addMutator(toFixedMutator, { decimals });
 	}
 	/**
+	* Opt in to coercion: a numeric-shaped string is converted to a number
+	* **before** the type rules run; any other value passes through unchanged
+	* so bad input still fails the type rule.
+	*
+	* Strictness is preserved — coercion only fixes the string *representation*,
+	* not the value's shape. `v.int().coerce()` turns `"5"` into `5` (valid) but
+	* `"5.5"` into `5.5`, which still fails the integer rule. Number validators
+	* do **not** coerce by default; this only takes effect when explicitly chained.
+	*
+	* The output type is unchanged (`Infer<>` keys off the validator class), so
+	* `v.int().coerce()` still infers `number`.
+	*
+	* @example
+	* v.int().coerce()      // "5" → 5 (valid); "5.5" → 5.5 (invalid); "abc" → invalid
+	* v.number().coerce()   // "5.5" → 5.5 (valid)
+	*/
+	coerce() {
+		return this.addMutator(numericMutator);
+	}
+	/**
 	* @inheritdoc
 	*
 	* Returns `{ type: "number" }` with numeric constraint keywords.
@@ -8788,6 +8844,7 @@ exports.betweenNumbersRule = betweenNumbersRule;
 exports.betweenTimesRule = betweenTimesRule;
 exports.betweenYearsRule = betweenYearsRule;
 exports.birthdayRule = birthdayRule;
+exports.booleanCoerceMutator = booleanCoerceMutator;
 exports.booleanMutator = booleanMutator;
 exports.booleanRule = booleanRule;
 exports.businessDayRule = businessDayRule;