@zipbul/baker 0.0.1

package/dist/src/rules/index.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "94F6EB707B64F4EC64756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,5 @@
+import type { EmittableRule } from '../types';
+export declare function isMobilePhone(locale: string): EmittableRule;
+export declare function isPostalCode(locale: string): EmittableRule;
+export declare function isIdentityCard(locale: string): EmittableRule;
+export declare function isPassportNumber(locale: string): EmittableRule;

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

@@ -0,0 +1,6 @@
+import type { EmittableRule } from '../types';
+export declare function min(n: number): EmittableRule;
+export declare function max(n: number): EmittableRule;
+export declare const isPositive: EmittableRule;
+export declare const isNegative: EmittableRule;
+export declare function isDivisibleBy(n: number): EmittableRule;

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

@@ -0,0 +1,7 @@
+import type { EmittableRule } from '../types';
+export interface IsNotEmptyObjectOptions {
+    /** null/undefined 값을 가진 키를 무시할지 여부 (기본: false → 무시하지 않음) */
+    nullable?: boolean;
+}
+export declare function isNotEmptyObject(options?: IsNotEmptyObjectOptions): EmittableRule;
+export declare function isInstance(targetType: new (...args: any[]) => any): EmittableRule;

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

@@ -0,0 +1,145 @@
+import type { EmittableRule } from '../types';
+export declare function minLength(min: number): EmittableRule;
+export declare function maxLength(max: number): EmittableRule;
+export declare function length(minLen: number, maxLen: number): EmittableRule;
+export declare function contains(seed: string): EmittableRule;
+export declare function notContains(seed: string): EmittableRule;
+export declare function matches(pattern: string | RegExp, modifiers?: string): EmittableRule;
+export declare const isLowercase: EmittableRule;
+export declare const isUppercase: EmittableRule;
+export declare const isAscii: EmittableRule;
+export declare const isAlpha: EmittableRule;
+export declare const isAlphanumeric: EmittableRule;
+export declare const isBooleanString: EmittableRule;
+export interface IsNumberStringOptions {
+    no_symbols?: boolean;
+}
+export declare function isNumberString(options?: IsNumberStringOptions): EmittableRule;
+export interface IsDecimalOptions {
+    decimal_digits?: string;
+    force_decimal?: boolean;
+    locale?: string;
+}
+export declare function isDecimal(options?: IsDecimalOptions): EmittableRule;
+export declare const isFullWidth: EmittableRule;
+export declare const isHalfWidth: EmittableRule;
+export declare const isVariableWidth: EmittableRule;
+export declare const isMultibyte: EmittableRule;
+export declare const isSurrogatePair: EmittableRule;
+export declare const isHexadecimal: EmittableRule;
+export declare const isOctal: EmittableRule;
+export interface IsEmailOptions {
+    allow_display_name?: boolean;
+    allow_utf8_local_part?: boolean;
+    require_tld?: boolean;
+}
+export declare function isEmail(_options?: IsEmailOptions): EmittableRule;
+export interface IsURLOptions {
+    protocols?: string[];
+    require_tld?: boolean;
+    require_protocol?: boolean;
+    allow_underscores?: boolean;
+    allow_trailing_dot?: boolean;
+    allow_protocol_relative_urls?: boolean;
+}
+export declare function isURL(options?: IsURLOptions): EmittableRule;
+export declare function isUUID(version?: 1 | 2 | 3 | 4 | 5 | 'all'): EmittableRule;
+export declare function isIP(version?: 4 | 6): EmittableRule;
+export declare const isHexColor: EmittableRule;
+export declare function isRgbColor(includePercentValues?: boolean): EmittableRule;
+export declare const isHSL: EmittableRule;
+export interface IsMACAddressOptions {
+    no_separators?: boolean;
+}
+export declare function isMACAddress(options?: IsMACAddressOptions): EmittableRule;
+export declare function isISBN(version?: 10 | 13): EmittableRule;
+export declare const isISIN: EmittableRule;
+export interface IsISO8601Options {
+    strict?: boolean;
+}
+export declare function isISO8601(options?: IsISO8601Options): EmittableRule;
+export declare const isISRC: EmittableRule;
+export interface IsISSNOptions {
+    case_sensitive?: boolean;
+    requireHyphen?: boolean;
+}
+export declare function isISSN(options?: IsISSNOptions): EmittableRule;
+export declare const isJWT: EmittableRule;
+export interface IsLatLongOptions {
+    checkDMS?: boolean;
+}
+export declare function isLatLong(options?: IsLatLongOptions): EmittableRule;
+export declare const isLocale: EmittableRule;
+export declare const isDataURI: EmittableRule;
+export interface IsFQDNOptions {
+    require_tld?: boolean;
+    allow_underscores?: boolean;
+    allow_trailing_dot?: boolean;
+}
+export declare function isFQDN(options?: IsFQDNOptions): EmittableRule;
+export declare const isPort: EmittableRule;
+export declare const isEAN: EmittableRule;
+export declare const isISO31661Alpha2: EmittableRule;
+export declare const isISO31661Alpha3: EmittableRule;
+export declare const isBIC: EmittableRule;
+export declare const isFirebasePushId: EmittableRule;
+export declare const isSemVer: EmittableRule;
+export declare const isMongoId: EmittableRule;
+export declare const isJSON: EmittableRule;
+export interface IsBase32Options {
+    crockford?: boolean;
+}
+export declare function isBase32(options?: IsBase32Options): EmittableRule;
+export declare const isBase58: EmittableRule;
+export interface IsBase64Options {
+    urlSafe?: boolean;
+}
+export declare function isBase64(options?: IsBase64Options): EmittableRule;
+export interface IsDateStringOptions {
+    strictMode?: boolean;
+}
+export declare function isDateString(options?: IsDateStringOptions): EmittableRule;
+export declare const isMimeType: EmittableRule;
+export interface IsCurrencyOptions {
+    symbol?: string;
+    require_symbol?: boolean;
+    allow_space_after_symbol?: boolean;
+    symbol_after_digits?: boolean;
+    allow_negatives?: boolean;
+    parens_for_negatives?: boolean;
+    negative_sign_before_digits?: boolean;
+    negative_sign_after_digits?: boolean;
+    allow_negative_sign_placeholder?: boolean;
+    thousands_separator?: string;
+    decimal_separator?: string;
+    allow_decimal?: boolean;
+    require_decimal?: boolean;
+    digits_after_decimal?: number[];
+    allow_space_after_digits?: boolean;
+}
+export declare function isCurrency(options?: IsCurrencyOptions): EmittableRule;
+export declare const isMagnetURI: EmittableRule;
+export declare const isCreditCard: EmittableRule;
+export interface IsIBANOptions {
+    allowSpaces?: boolean;
+}
+export declare function isIBAN(options?: IsIBANOptions): EmittableRule;
+export declare function isByteLength(min: number, max?: number): EmittableRule;
+export declare function isHash(algorithm: string): EmittableRule;
+export declare const isRFC3339: EmittableRule;
+export declare const isMilitaryTime: EmittableRule;
+export declare const isLatitude: EmittableRule;
+export declare const isLongitude: EmittableRule;
+export declare const isEthereumAddress: EmittableRule;
+export declare const isBtcAddress: EmittableRule;
+export declare const isISO4217CurrencyCode: EmittableRule;
+export declare const isPhoneNumber: EmittableRule;
+export interface IsStrongPasswordOptions {
+    minLength?: number;
+    minLowercase?: number;
+    minUppercase?: number;
+    minNumbers?: number;
+    minSymbols?: number;
+}
+export declare function isStrongPassword(options?: IsStrongPasswordOptions): EmittableRule;
+export declare function isTaxId(locale: string): EmittableRule;

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

@@ -0,0 +1,14 @@
+import type { EmittableRule } from '../types';
+export declare const isString: EmittableRule;
+export interface IsNumberOptions {
+    allowNaN?: boolean;
+    allowInfinity?: boolean;
+    maxDecimalPlaces?: number;
+}
+export declare function isNumber(options?: IsNumberOptions): EmittableRule;
+export declare const isBoolean: EmittableRule;
+export declare const isDate: EmittableRule;
+export declare function isEnum(entity: object): EmittableRule;
+export declare const isInt: EmittableRule;
+export declare const isArray: EmittableRule;
+export declare const isObject: EmittableRule;

package/dist/src/seal/circular-analyzer.d.ts

@@ -0,0 +1,13 @@
+import type { RawClassMeta } from '../types';
+import type { SealOptions } from '../interfaces';
+/**
+ * 순환 참조 정적 분석 (§4.6)
+ *
+ * - enableCircularCheck: true → 항상 true
+ * - enableCircularCheck: false → 항상 false
+ * - 'auto' (기본) → @Type 참조 그래프를 DFS로 탐색해 순환 감지
+ *
+ * 순환 없는 flat DTO → false (WeakSet 오버헤드 0)
+ * 순환 있는 DTO → true (WeakSet 자동 삽입)
+ */
+export declare function analyzeCircular(Class: Function, _merged: RawClassMeta, options?: SealOptions): boolean;

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

@@ -0,0 +1,5 @@
+import { err as _resultErr } 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) => (T | ReturnType<typeof _resultErr<BakerError[]>>) | Promise<T | ReturnType<typeof _resultErr<BakerError[]>>>;

package/dist/src/seal/expose-validator.d.ts

@@ -0,0 +1,11 @@
+import type { RawClassMeta } from '../types';
+/**
+ * @Expose 스택 정적 검증 (§4.1, §3.3)
+ *
+ * 검사 ①: 동일 @Expose 항목에 deserializeOnly: true + serializeOnly: true → 양쪽 방향 모두 제외
+ * 검사 ②: 같은 방향에 2개 이상 @Expose가 있고 groups가 겹치면 SealError
+ *          - 둘 다 groups=[] (ungrouped) → 겹침
+ *          - 둘 다 non-empty groups이며 교집합 존재 → 겹침
+ *          - 하나는 ungrouped, 다른 하나는 grouped → 겹치지 않음 (다른 적용 범위)
+ */
+export declare function validateExposeStacks(merged: RawClassMeta, className?: string): void;

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

@@ -0,0 +1,5 @@
+export { seal, _resetForTesting, mergeInheritance } from './seal';
+export { buildDeserializeCode } from './deserialize-builder';
+export { buildSerializeCode } from './serialize-builder';
+export { analyzeCircular } from './circular-analyzer';
+export { validateExposeStacks } from './expose-validator';

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

@@ -0,0 +1,27 @@
+import type { RawClassMeta } from '../types';
+import type { SealOptions } from '../interfaces';
+/**
+ * 전역 레지스트리에 등록된 **모든** DTO를 봉인한다.
+ * - 2회 호출 시: SealError throw
+ * - 순환 참조 DTO는 placeholder 패턴으로 안전하게 처리
+ */
+export declare function seal(options?: SealOptions): void;
+/**
+ * @internal 테스트 전용 — testing.ts의 unseal()에서 호출
+ */
+export declare function _resetForTesting(): void;
+/**
+ * Class의 prototype chain을 따라 RAW 메타데이터를 child-first로 병합한다.
+ *
+ * 병합 규칙:
+ * - validation: union merge (부모+자식 모두 적용, 중복 rule 제거)
+ * - transform: 자식 우선, 자식에 없으면 부모 계승
+ * - expose: 자식 우선, 자식에 없으면 부모 계승
+ * - exclude: 자식 우선, 자식에 없으면 부모 계승
+ * - type: 자식 우선, 자식에 없으면 부모 계승
+ * - flags: 자식 우선, 자식에 없는 각 플래그만 부모에서 보충
+ */
+export declare function mergeInheritance(Class: Function): RawClassMeta;
+export declare const __testing__: {
+    mergeInheritance: typeof mergeInheritance;
+};

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

@@ -0,0 +1,7 @@
+import type { RawClassMeta } from '../types';
+import type { SealOptions, RuntimeOptions } from '../interfaces';
+/**
+ * serialize executor 코드 생성.
+ * 무검증 전제 — 항상 Record<string, unknown> 반환 (§4.3).
+ */
+export declare function buildSerializeCode<T>(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, isAsync: boolean): (instance: T, opts?: RuntimeOptions) => Record<string, unknown> | Promise<Record<string, unknown>>;

package/dist/src/symbols.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 2개의 Symbol — 외부 저장소 0, 글로벌 오염 0
+ * Symbol.for 사용: AOT 코드와 런타임 코드가 동일 Symbol을 공유할 수 있도록 global registry 사용
+ */
+/** Tier 1 수집 메타데이터 (데코레이터가 Class에 저장) */
+export declare const RAW: unique symbol;
+/** Tier 2 봉인 결과 (seal()이 Class에 저장하는 dual executor) */
+export declare const SEALED: unique symbol;

package/dist/src/symbols.js

@@ -0,0 +1,5 @@
+// @bun
+import{$c as b,_c as a}from"../index-w36xamck.js";export{b as SEALED,a as RAW};
+
+//# debugId=A547314686A0198964756E2164756E21
+//# sourceMappingURL=symbols.js.map

package/dist/src/symbols.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "A547314686A0198964756E2164756E21",
+  "names": []
+}

package/dist/src/types.d.ts

@@ -0,0 +1,119 @@
+export interface EmitContext {
+    /** RegExp 참조 배열에 등록, 인덱스 반환 */
+    addRegex(re: RegExp): number;
+    /** 참조 배열에 등록, 인덱스 반환 — 함수, 배열, Set, 원시값 등 */
+    addRef(value: unknown): number;
+    /** SealedExecutors 객체 참조 배열에 등록 — 중첩 @Type DTO용 */
+    addExecutor(executor: SealedExecutors<unknown>): number;
+    /** 에러 코드로 실패 처리 코드 문자열 생성 — path는 builder가 바인딩 */
+    fail(code: string): string;
+    /** 에러 수집 모드 여부 (= !stopAtFirstError) */
+    collectErrors: boolean;
+}
+export interface EmittableRule {
+    (value: unknown): boolean | Promise<boolean>;
+    emit(varName: string, ctx: EmitContext): string;
+    readonly ruleName: string;
+    /**
+     * builder가 typeof 가드 삽입 여부를 판단하는 메타.
+     * 해당 타입을 전제하는 rule만 설정 (예: isEmail → 'string').
+     * @IsString 자체는 undefined (자체 typeof 포함).
+     */
+    readonly requiresType?: 'string' | 'number';
+    /** async validate 함수 사용 시 true — deserialize-builder가 await 코드를 생성 */
+    readonly isAsync?: boolean;
+}
+/** 사용자 정의 메시지 콜백 인자 */
+export interface MessageArgs {
+    property: string;
+    value: unknown;
+    constraints: unknown[];
+}
+export interface RuleDef {
+    rule: EmittableRule;
+    each?: boolean;
+    groups?: string[];
+    /** 검증 실패 시 BakerError.message에 포함할 값 */
+    message?: string | ((args: MessageArgs) => string);
+    /** 검증 실패 시 BakerError.context에 포함할 임의 값 */
+    context?: unknown;
+}
+/** @Transform 콜백 시그니처 */
+export type TransformFunction = (params: TransformParams) => unknown;
+export interface TransformParams {
+    value: unknown;
+    key: string;
+    /** deserialize: input 원본 객체, serialize: class 인스턴스 */
+    obj: Record<string, unknown>;
+    type: 'deserialize' | 'serialize';
+}
+export interface TransformDef {
+    fn: TransformFunction;
+    options?: {
+        groups?: string[];
+        deserializeOnly?: boolean;
+        serializeOnly?: boolean;
+    };
+}
+export interface ExposeDef {
+    name?: string;
+    groups?: string[];
+    deserializeOnly?: boolean;
+    serializeOnly?: boolean;
+}
+export interface ExcludeDef {
+    deserializeOnly?: boolean;
+    serializeOnly?: boolean;
+}
+export interface TypeDef {
+    fn: () => new (...args: any[]) => any;
+    discriminator?: {
+        property: string;
+        subTypes: {
+            value: Function;
+            name: string;
+        }[];
+    };
+    keepDiscriminatorProperty?: boolean;
+}
+export interface PropertyFlags {
+    /** @IsOptional() — undefined/null 시 validation 전체 skip */
+    isOptional?: boolean;
+    /** @IsDefined() — null/undefined 불허. isOptional과 동시 시 IsDefined 우선 */
+    isDefined?: boolean;
+    /** @ValidateIf(cond) — false 시 필드 전체 검증 skip */
+    validateIf?: (obj: any) => boolean;
+    /** @ValidateNested() — 중첩 DTO 재귀 검증 트리거. @Type과 함께 사용 */
+    validateNested?: boolean;
+    /** @ValidateNested({ each: true }) — 배열 원소별 중첩 DTO 검증 */
+    validateNestedEach?: boolean;
+}
+export interface RawPropertyMeta {
+    validation: RuleDef[];
+    transform: TransformDef[];
+    expose: ExposeDef[];
+    exclude: ExcludeDef | null;
+    type: TypeDef | null;
+    flags: PropertyFlags;
+}
+export interface RawClassMeta {
+    [propertyKey: string]: RawPropertyMeta;
+}
+import type { RuntimeOptions } from './interfaces';
+import type { BakerError } from './errors';
+export interface SealedExecutors<T> {
+    /** 내부 executor — Result 패턴. deserialize()가 감싸서 throw로 변환 */
+    _deserialize(input: unknown, options?: RuntimeOptions): (T | import('@zipbul/result').Err<BakerError[]>) | Promise<T | import('@zipbul/result').Err<BakerError[]>>;
+    /** 내부 executor — 항상 성공. serialize는 무검증 전제 */
+    _serialize(instance: T, options?: RuntimeOptions): Record<string, unknown> | Promise<Record<string, unknown>>;
+    /** deserialize 방향에 async 규칙/transform/nested가 있으면 true */
+    _isAsync: boolean;
+    /** serialize 방향에 async transform/nested가 있으면 true */
+    _isSerializeAsync: boolean;
+    /** debug: true 시 생성된 executor 소스코드 저장 */
+    _source?: {
+        deserialize: string;
+        serialize: string;
+    };
+}
+export type { ValidationOptions } from './interfaces';

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@zipbul/baker",
+  "version": "0.0.1",
+  "description": "Decorator-based validate + transform with inline code generation. class-validator DX, AOT-level performance, zero reflect-metadata.",
+  "license": "MIT",
+  "author": "Junhyung Park (https://github.com/parkrevil)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zipbul/baker.git"
+  },
+  "bugs": "https://github.com/zipbul/baker/issues",
+  "homepage": "https://github.com/zipbul/baker#readme",
+  "keywords": [
+    "validation",
+    "transform",
+    "decorator",
+    "dto",
+    "class-validator",
+    "class-transformer",
+    "serialize",
+    "deserialize",
+    "code-generation",
+    "bun",
+    "zipbul"
+  ],
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./decorators": {
+      "import": "./dist/src/decorators/index.js",
+      "types": "./dist/src/decorators/index.d.ts"
+    },
+    "./aot": {
+      "import": "./dist/src/aot/index.js",
+      "types": "./dist/src/aot/index.d.ts"
+    },
+    "./rules": {
+      "import": "./dist/src/rules/index.js",
+      "types": "./dist/src/rules/index.d.ts"
+    },
+    "./symbols": {
+      "import": "./dist/src/symbols.js",
+      "types": "./dist/src/symbols.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@zipbul/result": "^0.0.3"
+  },
+  "scripts": {
+    "build": "bun build index.ts src/decorators/index.ts src/aot/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",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage",
+    "changeset": "changeset",
+    "version-packages": "changeset version",
+    "release": "changeset publish",
+    "prepare": "husky"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.8",
+    "@commitlint/cli": "^20.4.2",
+    "@commitlint/config-conventional": "^20.4.2",
+    "@types/bun": "^1.3.9",
+    "husky": "^9.1.7"
+  }
+}