@zipbul/baker 3.3.0 → 3.4.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @zipbul/baker
 
+## 3.4.0
+
+### Minor Changes
+
+- 92028cf: Add two binary-value validation rules to `@zipbul/baker/rules`:
+
+  - `isUint8Array` — a bare type guard (`value instanceof Uint8Array`), mirroring `isRegExp` /
+    `isArray`. Accepts `Uint8Array` and its subclasses (e.g. `Buffer`); rejects `Uint8ClampedArray`,
+    `DataView`, and plain arrays.
+  - `isByteSize(min, max?)` — the binary analogue of `isByteLength`. Validates the `.byteLength` of
+    any `ArrayBuffer.isView(v)` value (all typed arrays + `DataView`), measuring the view window
+    rather than the backing buffer. The generated code guards `ArrayBuffer.isView` before any
+    `.byteLength` read, so non-views fail cleanly instead of throwing.
+
+  Both are exported from `@zipbul/baker/rules` as imported identifiers (AOT-safe), are synchronous,
+  and compose inside a single `@Field(...)` — e.g. `@Field(isUint8Array, isByteSize(16), { optional: true })`
+  for raw key material such as an HKDF salt.
+
+## 3.3.1
+
+### Patch Changes
+
+- 8b15524: Fix `@Field({ context, message })` being dropped on non-rule-body failures. Field-level
+  context/message are now first-class and attached to EVERY field-own-path failure — the type
+  gate (e.g. `isInt` rejecting `NaN`/non-number), required-missing (`isDefined`), implicit
+  conversion (`conversionFailed`), and structural array/object gates — plus per-element
+  validation of `Set`/`Map` collections, matching the array-element behavior. Previously only
+  rule-body failures (e.g. `isInt` rejecting `Infinity`) carried them, so the same field could
+  emit an issue with or without `context` depending on which code path failed.
+
+  Descendant failures (nested child fields, array/collection elements with their own rules) keep
+  their own context, and `invalidDiscriminator` keeps its structural context — field context is
+  not leaked across paths.
+
 ## 3.3.0
 
 ### Minor Changes

package/dist/src/decorators/field.js

@@ -224,6 +224,15 @@ function Field(...args) {
             }
         }
         applyValidation(meta, rules, options);
+        // Field-level message/context — stored regardless of rules so non-rule failures
+        // (type gate, required-missing, conversion, structural gates) and type-only fields
+        // can carry them, not just rule-body failures.
+        if (options.context !== undefined) {
+            meta.context = options.context;
+        }
+        if (options.message !== undefined) {
+            meta.message = options.message;
+        }
         // ── flags ──
         if (options.optional) {
             meta.flags.isOptional = true;

package/dist/src/rules/binary.d.ts

@@ -0,0 +1,3 @@
+import type { EmittableRule } from '../types';
+export declare const isUint8Array: import("../types").InternalRule;
+export declare function isByteSize(min: number, max?: number): EmittableRule;

package/dist/src/rules/binary.js

@@ -0,0 +1,51 @@
+import { makeRule } from '../rule-plan.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// isUint8Array — instanceof guard (self-narrowing, no typeof gate; mirrors isRegExp)
+// ─────────────────────────────────────────────────────────────────────────────
+export const isUint8Array = makeRule({
+    name: 'isUint8Array',
+    constraints: {},
+    validate: value => value instanceof Uint8Array,
+    emit: (varName, ctx) => `if (!(${varName} instanceof Uint8Array)) ${ctx.fail('isUint8Array')};`,
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// isByteSize(min, max?) — byte length of any ArrayBufferView (binary analogue of isByteLength)
+//
+// The ArrayBuffer.isView guard MUST short-circuit before any .byteLength read: reading .byteLength
+// on a non-view yields undefined (and undefined < min is false → would wrongly pass), and on
+// null/undefined it throws. The guard-first else-if chain prevents both. .byteLength is inlined
+// (not aliased to a local like isByteLength) — it is a trivial getter, not an expensive call.
+//
+// min/max are dev-supplied constants; per "trust TS for dev inputs" they are not runtime-guarded,
+// consistent with isByteLength.
+// ─────────────────────────────────────────────────────────────────────────────
+export function isByteSize(min, max) {
+    return makeRule({
+        name: 'isByteSize',
+        constraints: { min, max },
+        // Fail-form mirrors emit exactly (same as isByteLength), so validate() and the generated code
+        // agree for ALL inputs — including degenerate NaN bounds, where pass-form (>= NaN) would reject
+        // but the emitted (< NaN) accepts, breaking validate/emit parity.
+        validate: value => {
+            if (!ArrayBuffer.isView(value)) {
+                return false;
+            }
+            const byteLen = value.byteLength;
+            if (byteLen < min) {
+                return false;
+            }
+            if (max !== undefined && byteLen > max) {
+                return false;
+            }
+            return true;
+        },
+        emit: (varName, ctx) => {
+            let code = `if (!ArrayBuffer.isView(${varName})) ${ctx.fail('isByteSize')};`;
+            code += `\nelse if (${varName}.byteLength < ${min}) ${ctx.fail('isByteSize')};`;
+            if (max !== undefined) {
+                code += `\nelse if (${varName}.byteLength > ${max}) ${ctx.fail('isByteSize')};`;
+            }
+            return code;
+        },
+    });
+}

package/dist/src/rules/index.d.ts

@@ -10,3 +10,4 @@ export { arrayContains, arrayNotContains, arrayMinSize, arrayMaxSize, arrayUniqu
 export { isNotEmptyObject, isInstance } from './object';
 export type { IsNotEmptyObjectOptions } from './object';
 export { isMobilePhone, isPostalCode, isIdentityCard, isPassportNumber } from './locales';
+export { isUint8Array, isByteSize } from './binary';

package/dist/src/rules/index.js

@@ -7,3 +7,4 @@ export { minLength, maxLength, length, contains, notContains, matches, isLowerca
 export { arrayContains, arrayNotContains, arrayMinSize, arrayMaxSize, arrayUnique, arrayNotEmpty } from './array.js';
 export { isNotEmptyObject, isInstance } from './object.js';
 export { isMobilePhone, isPostalCode, isIdentityCard, isPassportNumber } from './locales.js';
+export { isUint8Array, isByteSize } from './binary.js';

package/dist/src/seal/deserialize-builder.js

@@ -295,8 +295,10 @@ function generateFieldCode(fieldKey, meta, ctx) {
     const extractKey = getDeserializeExtractKey(fieldKey, meta.expose);
     const exposeGroups = getDeserializeExposeGroups(meta.expose);
     const inputObj = ctx.inputExpr || 'input';
-    // Create EmitContext
-    const emitCtx = makeEmitCtx(fieldKey, ctx);
+    // Create EmitContext — bake field-level message/context so EVERY field-own-path failure
+    // (gate, required-missing, conversion, structural gates) carries them, not just rule bodies.
+    const fieldExtras = computeFieldExtras(meta, fieldKey, varName, ctx);
+    const emitCtx = makeEmitCtx(fieldKey, ctx, fieldExtras);
     let fieldCode = '';
     // ① @ValidateIf guard
     let validateIfIdx = null;
@@ -413,28 +415,43 @@ function generateValidationCode(fieldKey, varName, meta, ctx, emitCtx, fieldGrou
     return code;
 }
 // ─────────────────────────────────────────────────────────────────────────────
-// Helper for computing per-rule extra fields (message/context) code strings
+// Helpers for computing message/context extra fields in generated issue objects
 // ─────────────────────────────────────────────────────────────────────────────
-/** Convert rule's message/context options into extra field strings within generated code */
-function computeRuleExtras(rd, fieldKey, varName, ctx) {
+/** Build the `,message:...,context:...` extras string for a generated issue object.
+ *  `getConstraintsArg` produces the JS expression for a message function's `constraints`
+ *  field; it runs AFTER the message ref is pushed, preserving ref-array order. */
+function buildIssueExtras(message, context, getConstraintsArg, fieldKey, varName, ctx) {
     let extra = '';
-    if (typeof rd.message === 'string') {
-        extra += `,message:${JSON.stringify(rd.message)}`;
+    if (typeof message === 'string') {
+        extra += `,message:${JSON.stringify(message)}`;
     }
-    else if (typeof rd.message === 'function') {
+    else if (typeof message === 'function') {
         const msgIdx = ctx.refs.length;
-        ctx.refs.push(rd.message);
-        const constraintsIdx = ctx.refs.length;
-        ctx.refs.push(rd.rule.constraints ?? {});
-        extra += `,message:refs[${msgIdx}]({property:${JSON.stringify(fieldKey)},value:${varName},constraints:refs[${constraintsIdx}]})`;
+        ctx.refs.push(message);
+        const constraintsArg = getConstraintsArg();
+        extra += `,message:refs[${msgIdx}]({property:${JSON.stringify(fieldKey)},value:${varName},constraints:${constraintsArg}})`;
     }
-    if (rd.context !== undefined) {
+    if (context !== undefined) {
         const ctxIdx = ctx.refs.length;
-        ctx.refs.push(rd.context);
+        ctx.refs.push(context);
         extra += `,context:refs[${ctxIdx}]`;
     }
     return extra;
 }
+/** Per-rule extras — a message function receives the failing rule's `constraints`. */
+function computeRuleExtras(rd, fieldKey, varName, ctx) {
+    return buildIssueExtras(rd.message, rd.context, () => {
+        const constraintsIdx = ctx.refs.length;
+        ctx.refs.push(rd.rule.constraints ?? {});
+        return `refs[${constraintsIdx}]`;
+    }, fieldKey, varName, ctx);
+}
+/** Field-level extras appended to EVERY failure of a field — including non-rule failures
+ *  (type gate, required-missing, conversion, structural gates) and type-only fields. No
+ *  specific rule applies, so a message function gets `constraints:{}`. */
+function computeFieldExtras(meta, fieldKey, varName, ctx) {
+    return buildIssueExtras(meta.message, meta.context, () => '{}', fieldKey, varName, ctx);
+}
 /** Create per-rule EmitContext (with message/context overrides) */
 function makeRuleEmitCtx(baseEmitCtx, fieldKey, varName, rd, ctx) {
     const extra = computeRuleExtras(rd, fieldKey, varName, ctx);
@@ -862,7 +879,7 @@ function emitEachRules(fieldKey, varName, eachRules, collectErrors, emitCtx, ctx
             code += emitCollectionBlock(collections[1]);
             code += `} else if (${kindVar} === 3) {\n`;
             code += emitCollectionBlock(collections[2]);
-            code += `} else { ${GEN.errList}.push({path:${pathKey},code:'isArray'}); }\n`;
+            code += `} else { ${emitCtx.fail('isArray')}; }\n`;
         }
         else {
             code += `if (${kindVar} === 0) ${emitCtx.fail('isArray')};\n`;
@@ -998,9 +1015,10 @@ function generateCollectionCode(fieldKey, varName, meta, ctx, emitCtx) {
             code += `  var ${siVar} = 0;\n`;
             code += `  for (var ${svVar} of ${GEN.out}[${JSON.stringify(fieldKey)}]) {\n`;
             for (const rd of eachRules) {
+                const extra = computeRuleExtras(rd, fieldKey, varName, ctx);
                 const failFn = (c) => collectErrors
-                    ? `${GEN.errList}.push({path:${JSON.stringify(fieldKey)}+'['+${siVar}+']',code:${JSON.stringify(c)}})`
-                    : `return err([{path:${JSON.stringify(fieldKey)}+'['+${siVar}+']',code:${JSON.stringify(c)}}])`;
+                    ? `${GEN.errList}.push({path:${JSON.stringify(fieldKey)}+'['+${siVar}+']',code:${JSON.stringify(c)}${extra}})`
+                    : `return err([{path:${JSON.stringify(fieldKey)}+'['+${siVar}+']',code:${JSON.stringify(c)}${extra}}])`;
                 const colEmitCtx = { ...emitCtx, fail: failFn };
                 code += `    ${rd.rule.emit(svVar, colEmitCtx)}\n`;
             }
@@ -1514,7 +1532,7 @@ function generateCollectionCodeValidateOnly(fieldKey, varName, meta, ctx, emitCt
 // ─────────────────────────────────────────────────────────────────────────────
 // makeEmitCtx — create per-field EmitContext
 // ─────────────────────────────────────────────────────────────────────────────
-function makeEmitCtx(fieldKey, ctx) {
+function makeEmitCtx(fieldKey, ctx, fieldExtras = '') {
     const { collectErrors, regexes, refs, execs, validateOnly, pathPrefix } = ctx;
     const pathExpr = pathPrefix ? `${pathPrefix}+${JSON.stringify(fieldKey)}` : JSON.stringify(fieldKey);
     return {
@@ -1532,12 +1550,12 @@ function makeEmitCtx(fieldKey, ctx) {
         },
         fail(code) {
             if (collectErrors) {
-                return `${GEN.errList}.push({path:${pathExpr},code:${JSON.stringify(code)}})`;
+                return `${GEN.errList}.push({path:${pathExpr},code:${JSON.stringify(code)}${fieldExtras}})`;
             }
             else if (validateOnly) {
-                return `return [{path:${pathExpr},code:${JSON.stringify(code)}}]`;
+                return `return [{path:${pathExpr},code:${JSON.stringify(code)}${fieldExtras}}]`;
             }
-            return `return err([{path:${pathExpr},code:${JSON.stringify(code)}}])`;
+            return `return err([{path:${pathExpr},code:${JSON.stringify(code)}${fieldExtras}}])`;
         },
         collectErrors,
         pathExpr: pathExpr,

package/dist/src/types.d.ts

@@ -152,6 +152,10 @@ export interface RawPropertyMeta {
     exclude: ExcludeDef | null;
     type: TypeDef | null;
     flags: PropertyFlags;
+    /** Field-level message applied to ALL failures of this field (gate/structural/required/conversion/rule) */
+    message?: string | ((args: MessageArgs) => string);
+    /** Field-level context attached to ALL failures of this field */
+    context?: unknown;
 }
 export interface RawClassMeta {
     [propertyKey: string]: RawPropertyMeta;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zipbul/baker",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "description": "Bun-only AOT decorator-based DTO validation & serialization. class-validator DX, sealed code generation, zero reflect-metadata.",
   "keywords": [
     "aot",