@zipbul/baker 2.1.0 → 2.2.0

package/dist/src/types.d.ts

@@ -9,6 +9,10 @@ export interface EmitContext {
     fail(code: string): string;
     /** Whether error collection mode is enabled (= !stopAtFirstError) */
     collectErrors: boolean;
+    /** Whether this emit runs inside a type gate (typeof/instanceof already verified) */
+    insideTypeGate?: boolean;
+    /** @internal Path expression for inline nested — used by makeRuleEmitCtx */
+    _pathExpr?: string;
 }
 export interface EmittableRule {
     (value: unknown): boolean | Promise<boolean>;
@@ -19,12 +23,43 @@ export interface EmittableRule {
      * Only set for rules that assume a specific type (e.g., isEmail → 'string').
      * @IsString itself is undefined (it includes its own typeof check).
      */
-    readonly requiresType?: 'string' | 'number' | 'boolean' | 'date';
+    readonly requiresType?: 'string' | 'number' | 'boolean' | 'date' | 'array' | 'object';
     /** Expose rule parameters for external reading */
     readonly constraints?: Record<string, unknown>;
-    /** true when using an async validate function — deserialize-builder generates await code */
+    /** true when the rule is explicitly async and must be awaited */
     readonly isAsync?: boolean;
 }
+/** @internal internal rule shape used by builders for optimization metadata */
+export interface InternalRule extends EmittableRule {
+    readonly plan?: RulePlan;
+}
+export type RulePlanExpr = {
+    kind: 'value';
+} | {
+    kind: 'member';
+    object: RulePlanExpr;
+    property: 'length';
+} | {
+    kind: 'call0';
+    object: RulePlanExpr;
+    method: 'getTime';
+} | {
+    kind: 'literal';
+    value: number;
+};
+export type RulePlanCheck = {
+    kind: 'compare';
+    left: RulePlanExpr;
+    op: '<' | '<=' | '>' | '>=' | '===' | '!==';
+    right: RulePlanExpr;
+} | {
+    kind: 'and' | 'or';
+    checks: RulePlanCheck[];
+};
+export interface RulePlan {
+    cacheKey?: 'length' | 'time';
+    failure: RulePlanCheck;
+}
 /** Arguments for user-defined message callback */
 export interface MessageArgs {
     property: string;
@@ -32,7 +67,7 @@ export interface MessageArgs {
     constraints: Record<string, unknown>;
 }
 export interface RuleDef {
-    rule: EmittableRule;
+    rule: InternalRule;
     each?: boolean;
     groups?: string[];
     /** Value to include in BakerError.message on validation failure */
@@ -46,13 +81,14 @@ export interface TransformParams {
     obj: Record<string, unknown>;
 }
 export interface Transformer {
-    deserialize(params: TransformParams): unknown;
-    serialize(params: TransformParams): unknown;
+    deserialize(params: TransformParams): unknown | Promise<unknown>;
+    serialize(params: TransformParams): unknown | Promise<unknown>;
 }
 /** Internal — direction-specific transform function stored after @Field processing */
-export type TransformFunction = (params: TransformParams) => unknown;
+export type TransformFunction = (params: TransformParams) => unknown | Promise<unknown>;
 export interface TransformDef {
     fn: TransformFunction;
+    isAsync?: boolean;
     options?: {
         groups?: string[];
         deserializeOnly?: boolean;
@@ -123,6 +159,8 @@ export interface SealedExecutors<T> {
     _deserialize(input: unknown, options?: RuntimeOptions): Result<T, BakerError[]> | ResultAsync<T, BakerError[]>;
     /** Internal executor — always succeeds. serialize assumes no validation */
     _serialize(instance: T, options?: RuntimeOptions): Record<string, unknown> | Promise<Record<string, unknown>>;
+    /** Internal executor — validate-only (no object creation). Returns null on success, BakerError[] on failure */
+    _validate(input: unknown, options?: RuntimeOptions): BakerError[] | null | Promise<BakerError[] | null>;
     /** true if the deserialize direction has async rules/transforms/nested */
     _isAsync: boolean;
     /** true if the serialize direction has async transforms/nested */

package/dist/src/utils.d.ts

@@ -1,2 +1,4 @@
 /** minification-safe async function detection (uses Symbol.toStringTag, not constructor.name) */
 export declare function isAsyncFunction(fn: Function): boolean;
+/** Promise-like detection used to enforce sync/async contract at runtime */
+export declare function isPromiseLike(value: unknown): value is PromiseLike<unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zipbul/baker",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Fastest decorator-based DTO validation for TypeScript. AOT code generation, 42ns per validation, 163x faster than class-validator. Zero reflect-metadata.",
   "license": "MIT",
   "author": "Junhyung Park (https://github.com/parkrevil)",

package/dist/index-k3d659ad.js

@@ -1,3 +0,0 @@
-// @bun
-import{d as v}from"./index-fnv35wrf.js";var z=new Set;function B(h,w){if(!Object.prototype.hasOwnProperty.call(h,v))h[v]=Object.create(null),z.add(h);let G=h[v];return G[w]??={validation:[],transform:[],expose:[],exclude:null,type:null,flags:{}}}var H=Symbol.for("baker:arrayOf");function T(...h){let w={rules:h};return w[H]=!0,w}function J(h){return typeof h==="object"&&h!==null&&h[H]===!0}var U=new Set(["type","discriminator","keepDiscriminatorProperty","rules","optional","nullable","name","deserializeName","serializeName","exclude","groups","when","transform","message","context","mapValue","setValue"]);function C(h){if(typeof h==="function")return!1;if(typeof h!=="object"||h===null)return!1;if(J(h))return!1;let w=Object.keys(h);if(w.length===0)return!0;return w.some((G)=>U.has(G))}function X(h){if(h.length===0)return{rules:[],options:{}};if(h.length===1&&C(h[0])){let G=h[0];return{rules:G.rules??[],options:G}}let w=h[h.length-1];if(C(w)){let G=w,j=h.slice(0,-1);if(G.rules)j=[...j,...G.rules];return{rules:j,options:G}}return{rules:h,options:{}}}function Z(h,w,G){for(let j of w)if(J(j))for(let q of j.rules){let b={rule:q,each:!0,groups:G.groups};if(G.message!==void 0)b.message=G.message;if(G.context!==void 0)b.context=G.context;h.validation.push(b)}else{let q={rule:j,groups:G.groups};if(G.message!==void 0)q.message=G.message;if(G.context!==void 0)q.context=G.context;h.validation.push(q)}}function $(h,w){if(w.name)h.expose.push({name:w.name,groups:w.groups});else if(w.deserializeName||w.serializeName){if(w.deserializeName)h.expose.push({name:w.deserializeName,deserializeOnly:!0,groups:w.groups});if(w.serializeName)h.expose.push({name:w.serializeName,serializeOnly:!0,groups:w.groups})}else if(w.groups)h.expose.push({groups:w.groups});else h.expose.push({})}function K(h,w){if(!w.transform)return;let G=Array.isArray(w.transform)?w.transform:[w.transform];for(let j of G)h.transform.push({fn:j.deserialize,options:{deserializeOnly:!0}},{fn:j.serialize,options:{serializeOnly:!0}})}function E(...h){return(w,G)=>{let j=w.constructor,b=B(j,G),{rules:Q,options:S}=X(h);if(Z(b,Q,S),S.optional)b.flags.isOptional=!0;if(S.nullable)b.flags.isNullable=!0;if(S.when)b.flags.validateIf=S.when;if(S.type)b.type={fn:S.type,discriminator:S.discriminator,keepDiscriminatorProperty:S.keepDiscriminatorProperty,collectionValue:S.mapValue??S.setValue};if($(b,S),S.exclude){if(S.exclude===!0)b.exclude={};else if(S.exclude==="deserializeOnly")b.exclude={deserializeOnly:!0};else if(S.exclude==="serializeOnly")b.exclude={serializeOnly:!0}}K(b,S)}}
-export{z as a,T as b,E as c};