@zipbul/baker 2.0.0 → 2.2.0

package/dist/src/seal/codegen-utils.d.ts

@@ -0,0 +1,7 @@
+/** Convert key to a valid JS identifier suffix (encode non-alphanumeric chars via charCode to prevent collisions) */
+export declare function sanitizeKey(key: string): string;
+/**
+ * Generate a groups-has expression for the fast-path single-group / Set pattern.
+ * Checks if any of the given groups match the runtime groups.
+ */
+export declare function buildGroupsHasExpr(singleGroupVar: string, groupsVar: string, groups: string[]): string;

package/dist/src/seal/deserialize-builder.d.ts

@@ -2,4 +2,5 @@ import type { Result, ResultAsync } from '@zipbul/result';
 import type { RawClassMeta } from '../types';
 import type { SealOptions, RuntimeOptions } from '../interfaces';
 import { type BakerError } from '../errors';
-export declare function buildDeserializeCode<T>(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean): (input: unknown, opts?: RuntimeOptions) => Result<T, BakerError[]> | ResultAsync<T, BakerError[]>;
+export declare function buildDeserializeCode<T>(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean, validateOnly?: boolean): (input: unknown, opts?: RuntimeOptions) => Result<T, BakerError[]> | ResultAsync<T, BakerError[]>;
+export declare function buildValidateCode(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean): (input: unknown, opts?: RuntimeOptions) => BakerError[] | null | Promise<BakerError[] | null>;

package/dist/src/seal/seal.d.ts

@@ -1,7 +1,7 @@
 import type { RawClassMeta, SealedExecutors } from '../types';
 /** @internal Placeholder executor for circular dependency detection during seal */
 declare function _circularPlaceholder(className: string): SealedExecutors<unknown>;
-/** @internal — used by configure() to warn about post-seal calls */
+/** @internal — used by configure() to reject post-seal calls */
 export declare function _isSealed(): boolean;
 /** List of sealed classes — used by unseal to remove SEALED */
 export declare const _sealedClasses: Set<Function>;

package/dist/src/symbols.js

@@ -1,5 +1,2 @@
 // @bun
-import{e as a,f as b}from"../index-k369bbht.js";export{b as SEALED,a as RAW};
-
-//# debugId=90C1D92A7675C52B64756E2164756E21
-//# sourceMappingURL=symbols.js.map
+import{o as a,p as b}from"../index-jp2yjd6g.js";import"../index-mw7met6r.js";export{b as SEALED,a as RAW};

package/dist/src/transformers/collection.transformer.d.ts

@@ -0,0 +1,3 @@
+import type { Transformer } from '../types';
+export declare function csvTransformer(separator?: string): Transformer;
+export declare const jsonTransformer: Transformer;

package/dist/src/transformers/date.transformer.d.ts

@@ -0,0 +1,4 @@
+import type { Transformer } from '../types';
+export declare const unixSecondsTransformer: Transformer;
+export declare const unixMillisTransformer: Transformer;
+export declare const isoStringTransformer: Transformer;

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

@@ -0,0 +1,8 @@
+export { trimTransformer, toLowerCaseTransformer, toUpperCaseTransformer } from './string.transformer';
+export { roundTransformer } from './number.transformer';
+export { unixSecondsTransformer, unixMillisTransformer, isoStringTransformer } from './date.transformer';
+export { csvTransformer, jsonTransformer } from './collection.transformer';
+export { luxonTransformer } from './luxon.transformer';
+export type { LuxonTransformerOptions } from './luxon.transformer';
+export { momentTransformer } from './moment.transformer';
+export type { MomentTransformerOptions } from './moment.transformer';

package/dist/src/transformers/index.js

@@ -0,0 +1,2 @@
+// @bun
+import{q as n}from"../../index-mw7met6r.js";var s={deserialize:({value:r})=>typeof r==="string"?r.trim():r,serialize:({value:r})=>typeof r==="string"?r.trim():r},i={deserialize:({value:r})=>typeof r==="string"?r.toLowerCase():r,serialize:({value:r})=>typeof r==="string"?r.toLowerCase():r},f={deserialize:({value:r})=>typeof r==="string"?r.toUpperCase():r,serialize:({value:r})=>typeof r==="string"?r.toUpperCase():r};function m(r=0){let t=Math.pow(10,r),e=(o)=>typeof o==="number"&&Number.isFinite(o)?Math.round(o*t)/t:o;return{deserialize:({value:o})=>e(o),serialize:({value:o})=>e(o)}}var a={deserialize:({value:r})=>typeof r==="number"?new Date(r*1000):r,serialize:({value:r})=>r instanceof Date?Math.floor(r.getTime()/1000):r},p={deserialize:({value:r})=>typeof r==="number"?new Date(r):r,serialize:({value:r})=>r instanceof Date?r.getTime():r},T={deserialize:({value:r})=>{if(typeof r!=="string")return r;let t=new Date(r);return Number.isNaN(t.getTime())?r:t},serialize:({value:r})=>r instanceof Date?r.toISOString():r};function y(r=","){return{deserialize:({value:t})=>typeof t==="string"?t.split(r):t,serialize:({value:t})=>Array.isArray(t)?t.join(r):t}}var c={deserialize:({value:r})=>{if(typeof r!=="string")return r;try{return JSON.parse(r)}catch{return r}},serialize:({value:r})=>{if(r!=null&&typeof r==="object")return JSON.stringify(r);return r}};async function x(r){let{DateTime:t}=await import("luxon"),e=r?.zone??"utc";return{deserialize:({value:o})=>{if(typeof o==="string")return t.fromISO(o,{zone:e});if(o instanceof Date)return t.fromJSDate(o,{zone:e});return o},serialize:({value:o})=>{if(o&&typeof o==="object"&&typeof o.toISO==="function")return r?.format?o.toFormat(r.format):o.toISO();return o}}}async function z(r){let t=(await import("moment")).default;return{deserialize:({value:e})=>{if(typeof e==="string"||e instanceof Date)return t(e);return e},serialize:({value:e})=>{if(e&&typeof e==="object"&&typeof e.toISOString==="function"&&typeof e.format==="function")return r?.format?e.format(r.format):e.toISOString();return e}}}export{a as unixSecondsTransformer,p as unixMillisTransformer,s as trimTransformer,f as toUpperCaseTransformer,i as toLowerCaseTransformer,m as roundTransformer,z as momentTransformer,x as luxonTransformer,c as jsonTransformer,T as isoStringTransformer,y as csvTransformer};

package/dist/src/transformers/luxon.transformer.d.ts

@@ -0,0 +1,6 @@
+import type { Transformer } from '../types';
+export interface LuxonTransformerOptions {
+    format?: string;
+    zone?: string;
+}
+export declare function luxonTransformer(opts?: LuxonTransformerOptions): Promise<Transformer>;

package/dist/src/transformers/moment.transformer.d.ts

@@ -0,0 +1,5 @@
+import type { Transformer } from '../types';
+export interface MomentTransformerOptions {
+    format?: string;
+}
+export declare function momentTransformer(opts?: MomentTransformerOptions): Promise<Transformer>;

package/dist/src/transformers/number.transformer.d.ts

@@ -0,0 +1,2 @@
+import type { Transformer } from '../types';
+export declare function roundTransformer(precision?: number): Transformer;

package/dist/src/transformers/string.transformer.d.ts

@@ -0,0 +1,4 @@
+import type { Transformer } from '../types';
+export declare const trimTransformer: Transformer;
+export declare const toLowerCaseTransformer: Transformer;
+export declare const toUpperCaseTransformer: Transformer;

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 */
@@ -40,17 +75,20 @@ export interface RuleDef {
     /** Arbitrary value to include in BakerError.context on validation failure */
     context?: unknown;
 }
-/** @Transform callback signature */
-export type TransformFunction = (params: TransformParams) => unknown;
 export interface TransformParams {
     value: unknown;
     key: string;
-    /** deserialize: original input object, serialize: class instance */
     obj: Record<string, unknown>;
-    type: 'deserialize' | 'serialize';
 }
+export interface Transformer {
+    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 | Promise<unknown>;
 export interface TransformDef {
     fn: TransformFunction;
+    isAsync?: boolean;
     options?: {
         groups?: string[];
         deserializeOnly?: boolean;
@@ -96,7 +134,7 @@ export interface PropertyFlags {
     /** @IsNullable() — allow and assign null, reject undefined */
     isNullable?: boolean;
     /** @ValidateIf(cond) — skip all field validation when false */
-    validateIf?: (obj: any) => boolean;
+    validateIf?: (obj: Record<string, any>) => boolean;
     /** @ValidateNested() — trigger recursive validation for nested DTOs. Used with @Type */
     validateNested?: boolean;
     /** @ValidateNested({ each: true }) — validate nested DTOs per array element */
@@ -121,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,7 +1,7 @@
 {
   "name": "@zipbul/baker",
-  "version": "2.0.0",
-  "description": "Decorator-based validate + transform with inline code generation. class-validator DX, AOT-level performance, zero reflect-metadata.",
+  "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)",
   "repository": {
@@ -12,7 +12,9 @@
   "homepage": "https://github.com/zipbul/baker#readme",
   "keywords": [
     "validation",
+    "validator",
     "transform",
+    "transformer",
     "decorator",
     "dto",
     "typescript",
@@ -20,11 +22,15 @@
     "type-safe",
     "class-validator",
     "class-transformer",
+    "class-validator-alternative",
+    "zod-alternative",
     "serialize",
     "deserialize",
     "code-generation",
+    "aot",
     "bun",
-    "zipbul"
+    "fast-validation",
+    "schema-validation"
   ],
   "engines": {
     "bun": ">=1.0.0"
@@ -50,6 +56,10 @@
     "./symbols": {
       "import": "./dist/src/symbols.js",
       "types": "./dist/src/symbols.d.ts"
+    },
+    "./transformers": {
+      "import": "./dist/src/transformers/index.js",
+      "types": "./dist/src/transformers/index.d.ts"
     }
   },
   "files": [
@@ -62,11 +72,23 @@
     "access": "public",
     "provenance": true
   },
+  "peerDependencies": {
+    "luxon": ">=3.0.0",
+    "moment": ">=2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "luxon": {
+      "optional": true
+    },
+    "moment": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "@zipbul/result": "1.0.0"
   },
   "scripts": {
-    "build": "bun build index.ts src/decorators/index.ts src/rules/index.ts src/symbols.ts --outdir dist --target bun --format esm --splitting --packages external --sourcemap=linked --root . --production && tsc -p tsconfig.build.json",
+    "build": "bun build index.ts src/decorators/index.ts src/rules/index.ts src/symbols.ts src/transformers/index.ts --outdir dist --target bun --format esm --splitting --packages external --root . --production && tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "test": "bun test",
     "test:coverage": "bun test --coverage",
@@ -82,6 +104,8 @@
     "@commitlint/config-conventional": "^20.4.2",
     "@sinclair/typebox": "^0.34.48",
     "@types/bun": "^1.3.9",
+    "@types/luxon": "^3.7.1",
+    "@types/moment": "^2.13.0",
     "ajv": "^8.18.0",
     "arktype": "^2.2.0",
     "class-transformer": "^0.5.1",

package/dist/index-btgens0c.js

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

package/dist/index-k369bbht.js

@@ -1,6 +0,0 @@
-// @bun
-var f=Symbol.for("baker:raw"),g=Symbol.for("baker:sealed");
-export{f as e,g as f};
-
-//# debugId=CE8212BEB6474C6064756E2164756E21
-//# sourceMappingURL=index-k369bbht.js.map