@zipbul/baker 1.0.0 → 2.0.0

package/dist/src/create-rule.d.ts

@@ -1,22 +1,22 @@
 import type { EmittableRule } from './types';
 export interface CreateRuleOptions {
-    /** 규칙 이름. 에러 코드로 사용됨. */
+    /** Rule name. Used as the error code. */
     name: string;
-    /** 검증 함수 — true: 통과, false: 실패. async 함수 허용 (Promise<boolean> 반환 시 자동으로 async 룰로 등록). */
+    /** Validation function — true: pass, false: fail. Async functions allowed (automatically registered as async rule when returning Promise<boolean>). */
     validate: (value: unknown) => boolean | Promise<boolean>;
-    /** 룰 파라미터 — toJsonSchema 매핑에 사용 */
+    /** Rule parameters */
     constraints?: Record<string, unknown>;
-    /** 이 룰이 전제하는 타입 — 타입 게이트 최적화에 사용 */
+    /** Type assumed by this rule — used for type gate optimization */
     requiresType?: 'string' | 'number' | 'boolean' | 'date';
 }
 /**
- * 사용자 정의 검증 규칙을 생성한다.
+ * Creates a user-defined validation rule.
  *
  * @example
- * // 간단 형태
+ * // Simple form
  * const koreanPhone = createRule('koreanPhone', (v) => /^01[016789]/.test(v as string));
  *
- * // 옵션 형태
+ * // Options form
  * const isEven = createRule({
  *   name: 'isEven',
  *   validate: (v) => typeof v === 'number' && v % 2 === 0,

package/dist/src/decorators/field.d.ts

@@ -4,7 +4,7 @@ export interface ArrayOfMarker {
     readonly rules: EmittableRule[];
 }
 /**
- * 배열의 각 원소에 규칙 적용.
+ * Apply rules to each element of an array.
  *
  * @example
  * @Field(arrayOf(isString(), minLength(1)))
@@ -17,17 +17,10 @@ export interface FieldTransformParams {
     obj: Record<string, unknown>;
     direction: 'deserialize' | 'serialize';
 }
-export interface JsonSchemaOverride {
-    title?: string;
-    description?: string;
-    default?: unknown;
-    examples?: unknown[];
-    [key: string]: unknown;
-}
 export interface FieldOptions {
-    /** 중첩 DTO 타입. thunk — 순환 참조 지원. [Dto]면 배열. */
+    /** Nested DTO type. Thunk — supports circular references. [Dto] for arrays. */
     type?: () => (new (...args: any[]) => any) | (new (...args: any[]) => any)[];
-    /** 다형성 discriminator 설정 — type과 함께 사용 */
+    /** Polymorphic discriminator configuration — used with type */
     discriminator?: {
         property: string;
         subTypes: {
@@ -35,40 +28,50 @@ export interface FieldOptions {
             name: string;
         }[];
     };
-    /** discriminator 프로퍼티를 결과 객체에 유지할지 여부 */
+    /** Whether to keep the discriminator property in the result object */
     keepDiscriminatorProperty?: boolean;
-    /** 검증 규칙 배열 */
+    /** Validation rules array */
     rules?: (EmittableRule | ArrayOfMarker)[];
-    /** undefined 허용 */
+    /** Allow undefined */
     optional?: boolean;
-    /** null 허용 */
+    /** Allow null */
     nullable?: boolean;
-    /** JSON 키 매핑 (양방향) */
+    /** JSON key mapping (bidirectional) */
     name?: string;
-    /** deserialize 방향 키 매핑 (name과 동시 사용 불가) */
+    /** Deserialize direction key mapping (cannot be used with name) */
     deserializeName?: string;
-    /** serialize 방향 키 매핑 (name과 동시 사용 불가) */
+    /** Serialize direction key mapping (cannot be used with name) */
     serializeName?: string;
-    /** 필드 제외 — true: 양방향, 'deserializeOnly': 역직렬화만, 'serializeOnly': 직렬화만 */
+    /** Field exclusion — true: bidirectional, 'deserializeOnly': deserialization only, 'serializeOnly': serialization only */
     exclude?: boolean | 'deserializeOnly' | 'serializeOnly';
-    /** 그룹 — 필드 가시성 제어 + validation rule 조건부 적용 */
+    /** Groups — field visibility control + conditional validation rule application */
     groups?: string[];
-    /** 조건부 검증 — false 시 필드 전체 검증 skip */
+    /** Conditional validation — skip all field validation when false */
     when?: (obj: any) => boolean;
-    /** JSON Schema 커스텀 (프로퍼티 레벨) */
-    schema?: JsonSchemaOverride;
-    /** 값 변환 함수 */
+    /** Value transform function */
     transform?: (params: FieldTransformParams) => unknown;
-    /** transform 방향 제한 */
+    /** Transform direction restriction */
     transformDirection?: 'deserializeOnly' | 'serializeOnly';
+    /** Error message on validation failure — applied to all rules of the field (rule's own message takes precedence) */
+    message?: string | ((args: {
+        property: string;
+        value: unknown;
+        constraints: Record<string, unknown>;
+    }) => string);
+    /** Error context on validation failure — applied to all rules of the field (rule's own context takes precedence) */
+    context?: unknown;
+    /** Nested DTO class thunk for Map values — used with type: () => Map */
+    mapValue?: () => new (...args: any[]) => any;
+    /** Nested DTO class thunk for Set elements — used with type: () => Set */
+    setValue?: () => new (...args: any[]) => any;
 }
 type RuleArg = EmittableRule | ArrayOfMarker;
-/** @Field() — 빈 필드 등록 */
+/** @Field() — empty field registration */
 export declare function Field(): PropertyDecorator;
-/** @Field(isString(), email()) — 가변 인자 규칙 */
+/** @Field(isString(), email()) — variadic rules */
 export declare function Field(...rules: RuleArg[]): PropertyDecorator;
-/** @Field({ type: () => Dto }) — 옵션 객체 */
+/** @Field({ type: () => Dto }) — options object */
 export declare function Field(options: FieldOptions): PropertyDecorator;
-/** @Field(isString(), { optional: true }) — 규칙 + 옵션 혼합 */
+/** @Field(isString(), { optional: true }) — rules + options mixed */
 export declare function Field(...rulesAndOptions: [...RuleArg[], FieldOptions]): PropertyDecorator;
 export {};

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

@@ -1,2 +1,2 @@
 export { Field, arrayOf } from './field';
-export type { FieldOptions, FieldTransformParams, JsonSchemaOverride, ArrayOfMarker } from './field';
+export type { FieldOptions, FieldTransformParams, ArrayOfMarker } from './field';

package/dist/src/decorators/index.js

@@ -1,5 +1,5 @@
 // @bun
-import"../../index-xdn55cz3.js";import{c as a,d as b}from"../../index-57gr0v18.js";import"../../index-aegrb1kn.js";export{a as arrayOf,b as Field};
+import"../../index-xdn55cz3.js";import{c as a,d as b}from"../../index-btgens0c.js";import"../../index-k369bbht.js";export{a as arrayOf,b as Field};
 
 //# debugId=9E4BFE621FA3997464756E2164756E21
 //# sourceMappingURL=index.js.map

package/dist/src/errors.d.ts

@@ -1,38 +1,49 @@
 /**
- * 개별 필드 에러 — 최소 계약(minimum contract).
+ * Individual field error — minimum contract.
  *
- * 예약 에러 코드:
- * - 'invalidInput': input이 null, 비객체, 배열일 때 (path='')
- * - 'isObject': 중첩 @Type 필드의 값이 객체가 아닐 때
- * - 'isArray': 배열 중첩 (each:true) 필드의 값이 배열이 아닐 때
- * - 'invalidDiscriminator': discriminator 값이 subTypes에 없을 때
- * - 'conversionFailed': enableImplicitConversion에서 타입 변환 실패 시
- * - 'whitelistViolation': whitelist: true에서 미선언 필드가 input에 존재할 때
+ * Reserved error codes:
+ * - 'invalidInput': when input is null, non-object, or array (path='')
+ * - 'isObject': when a nested @Type field's value is not an object
+ * - 'isArray': when an array-nested (each:true) field's value is not an array
+ * - 'invalidDiscriminator': when the discriminator value is not in subTypes
+ * - 'conversionFailed': when type conversion fails in enableImplicitConversion
+ * - 'whitelistViolation': when undeclared fields exist in input with whitelist: true
  *
- * 향후 확장 필드(message, expected, actual 등)는 반드시 Optional로 추가.
+ * Future extension fields (message, expected, actual, etc.) must be added as Optional.
  */
 export interface BakerError {
     readonly path: string;
     readonly code: string;
-    /** 사용자 정의 에러 메시지 — 데코레이터 message 옵션이 설정된 경우에만 포함 */
+    /** User-defined error message — included only when the decorator message option is set */
     readonly message?: string;
-    /** 사용자 정의 컨텍스트 — 데코레이터 context 옵션이 설정된 경우에만 포함 */
+    /** User-defined context — included only when the decorator context option is set */
     readonly context?: unknown;
 }
+/** Symbol tag for isBakerError() type guard — collision-proof discriminator */
+export declare const BAKER_ERROR: unique symbol;
+/** Validation failure — returned by deserialize() on invalid input */
+export interface BakerErrors {
+    readonly [BAKER_ERROR]: true;
+    readonly errors: readonly BakerError[];
+}
 /**
- * deserialize() 검증 실패 시 throw되는 에러.
- * errors 배열에 모든 필드 에러가 담겨 있다.
+ * Type guard — narrows deserialize() result to BakerErrors.
+ *
+ * @example
+ * const result = await deserialize(UserDto, input);
+ * if (isBakerError(result)) {
+ *   result.errors // readonly BakerError[]
+ * } else {
+ *   result // UserDto
+ * }
  */
-export declare class BakerValidationError extends Error {
-    readonly errors: BakerError[];
-    /** 검증 대상 DTO 클래스명 (DX-2) */
-    readonly className?: string;
-    constructor(errors: BakerError[], className?: string);
-}
+export declare function isBakerError(value: unknown): value is BakerErrors;
+/** @internal — create BakerErrors object */
+export declare function _toBakerErrors(errors: BakerError[]): BakerErrors;
 /**
- * 봉인 관련 에러:
- * - seal() 2회 이상 호출 시
- * - 미봉인 클래스에 deserialize()/serialize() 호출 시
+ * Seal-related error:
+ * - When seal() is called more than once
+ * - When deserialize()/serialize() is called on an unsealed class
  */
 export declare class SealError extends Error {
     constructor(message: string);

package/dist/src/functions/_run-sealed.d.ts

@@ -0,0 +1,7 @@
+import type { BakerErrors } from '../errors';
+import type { RuntimeOptions } from '../interfaces';
+/**
+ * @internal — shared seal+dispatch+unwrap for deserialize and validate.
+ * Calls sealed._deserialize, converts Result to BakerErrors, maps success via onSuccess.
+ */
+export declare function _runSealed<S>(Class: Function, input: unknown, options: RuntimeOptions | undefined, onSuccess: (result: any) => S): S | BakerErrors | Promise<S | BakerErrors>;

package/dist/src/functions/deserialize.d.ts

@@ -1,9 +1,11 @@
+import type { BakerErrors } from '../errors';
 import type { RuntimeOptions } from '../interfaces';
 /**
- * input → Class 인스턴스 변환 + 검증.
- * - 첫 호출 시 auto-seal (globalRegistry 전체 배치)
- * - 성공: Promise<T> 반환
- * - 검증 실패: BakerValidationError throw
- * - 데코레이터 없는 클래스: SealError throw
+ * Converts input to a Class instance + validates.
+ * - Auto-seals on first call (batches entire globalRegistry)
+ * - Sync DTOs return directly, async DTOs return Promise
+ * - Success: T
+ * - Validation failure: BakerErrors (use isBakerError() to narrow)
+ * - Class without decorators: throws SealError
  */
-export declare function deserialize<T>(Class: new (...args: any[]) => T, input: unknown, options?: RuntimeOptions): Promise<T>;
+export declare function deserialize<T>(Class: new (...args: any[]) => T, input: unknown, options?: RuntimeOptions): T | BakerErrors | Promise<T | BakerErrors>;

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

@@ -1,4 +1,3 @@
 export { deserialize } from './deserialize';
 export { serialize } from './serialize';
-export { toJsonSchema } from './to-json-schema';
-export type { ToJsonSchemaOptions } from './to-json-schema';
+export { validate } from './validate';

package/dist/src/functions/serialize.d.ts

@@ -1,8 +1,9 @@
 import type { RuntimeOptions } from '../interfaces';
 /**
- * Class 인스턴스 → plain 객체 변환.
- * - 첫 호출 시 auto-seal (globalRegistry 전체 배치)
- * - 무검증 전제 — 항상 Record<string, unknown> 반환 (또는 Promise)
- * - 데코레이터 없는 클래스: SealError throw
+ * Converts a Class instance to a plain object.
+ * - Auto-seals on first call (batches entire globalRegistry)
+ * - Sync DTOs return directly, async DTOs return Promise
+ * - No validation — always returns Record<string, unknown>
+ * - Class without decorators: throws SealError
  */
-export declare function serialize<T>(instance: T, options?: RuntimeOptions): Promise<Record<string, unknown>>;
+export declare function serialize<T>(instance: T, options?: RuntimeOptions): Record<string, unknown> | Promise<Record<string, unknown>>;

package/dist/src/functions/validate.d.ts

@@ -0,0 +1,13 @@
+import type { BakerErrors } from '../errors';
+import type { EmittableRule } from '../types';
+import type { RuntimeOptions } from '../interfaces';
+/**
+ * DTO-level validation — validates input against a decorated class.
+ * Sync DTOs return directly, async DTOs return Promise.
+ */
+export declare function validate<T>(Class: new (...args: any[]) => T, input: unknown, options?: RuntimeOptions): true | BakerErrors | Promise<true | BakerErrors>;
+/**
+ * Ad-hoc validation — validates a single value against one or more rules.
+ * Sync rules return directly, async rules return Promise.
+ */
+export declare function validate(input: unknown, ...rules: EmittableRule[]): true | BakerErrors | Promise<true | BakerErrors>;

package/dist/src/interfaces.d.ts

@@ -1,32 +1,32 @@
 export interface SealOptions {
     /**
-     * validation 데코레이터를 타입 힌트로 활용한 자동 변환.
+     * Automatic conversion using validation decorators as type hints.
      * @default false
      */
     enableImplicitConversion?: boolean;
     /**
-     * input에 해당 키가 없을 때 클래스 기본값을 사용.
+     * Use class default values when the key is missing from input.
      * @default false
      */
     exposeDefaultValues?: boolean;
     /**
-     * true: 첫 에러 즉시 반환. false(기본): 전체 에러 수집.
+     * true: return immediately on first error. false (default): collect all errors.
      * @default false
      */
     stopAtFirstError?: boolean;
     /**
-     * true: 미선언 필드 거부. mergeInheritance(Class)의 key 집합을 허용 목록으로 사용.
-     * @Exclude 필드도 whitelist에 포함 — 존재는 허용하되 결과에서 제외.
+     * true: reject undeclared fields. Uses the key set from mergeInheritance(Class) as the allowlist.
+     * @Exclude fields are also included in the whitelist — their presence is allowed but they are excluded from the result.
      * @default false
      */
     whitelist?: boolean;
     /**
-     * true: 생성 코드에 필드 제외 사유를 주석으로 포함.
+     * true: include field exclusion reasons as comments in generated code.
      * @default false
      */
     debug?: boolean;
 }
 export interface RuntimeOptions {
-    /** 요청별 groups — 요청마다 다를 수 있으므로 런타임에 전달 */
+    /** Per-request groups — passed at runtime since they may vary per request */
     groups?: string[];
 }

package/dist/src/registry.d.ts

@@ -1,8 +1,8 @@
 /**
- * 전역 레지스트리 — 데코레이터가 1개라도 부착된 클래스를 자동 등록
+ * Global registry — automatically registers classes with at least one decorator attached
  *
- * - ensureMeta()에서 자동 호출
- * - seal()이 이 Set을 순회하여 모든 DTO를 봉인
- * - 메타데이터는 여기에 저장되지 않음 — 인덱스(어떤 클래스가 등록되었는지)로만 사용
+ * - Automatically called from ensureMeta()
+ * - seal() iterates this Set to seal all DTOs
+ * - Metadata is not stored here — used only as an index (which classes are registered)
  */
 export declare const globalRegistry: Set<Function>;

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

@@ -4,7 +4,7 @@ export { min, max, isPositive, isNegative, isDivisibleBy } from './number';
 export { minDate, maxDate } from './date';
 export { equals, notEquals, isEmpty, isNotEmpty, isIn, isNotIn } from './common';
 export { minLength, maxLength, length, contains, notContains, matches, isLowercase, isUppercase, isAscii, isAlpha, isAlphanumeric, isBooleanString, isNumberString, isDecimal, isFullWidth, isHalfWidth, isVariableWidth, isMultibyte, isSurrogatePair, isHexadecimal, isOctal, isEmail, isURL, isUUID, isIP, isHexColor, isRgbColor, isHSL, isMACAddress, isISBN, isISIN, isISO8601, isISRC, isISSN, isJWT, isLatLong, isLocale, isDataURI, isFQDN, isPort, isEAN, isISO31661Alpha2, isISO31661Alpha3, isBIC, isFirebasePushId, isSemVer, isMongoId, isJSON, isBase32, isBase58, isBase64, isDateString, isMimeType, isCurrency, isMagnetURI, isCreditCard, isIBAN, isByteLength, isHash, isRFC3339, isMilitaryTime, isLatitude, isLongitude, isEthereumAddress, isBtcAddress, isISO4217CurrencyCode, isPhoneNumber, isStrongPassword, isTaxId, } from './string';
-export type { IsEmailOptions, IsURLOptions, IsBase32Options, IsBase64Options, IsDateStringOptions, IsCurrencyOptions, IsMACAddressOptions, IsIBANOptions, IsISSNOptions, IsFQDNOptions, IsLatLongOptions, IsISO8601Options, IsNumberStringOptions, IsDecimalOptions, IsStrongPasswordOptions, } from './string';
+export type { IsURLOptions, IsBase64Options, IsMACAddressOptions, IsIBANOptions, IsISSNOptions, IsFQDNOptions, IsISO8601Options, IsNumberStringOptions, IsStrongPasswordOptions, } from './string';
 export { arrayContains, arrayNotContains, arrayMinSize, arrayMaxSize, arrayUnique, arrayNotEmpty, } from './array';
 export { isNotEmptyObject, isInstance } from './object';
 export type { IsNotEmptyObjectOptions } from './object';