sonamu 0.10.12 → 0.10.13

package/dist/api/caster.js

@@ -1,12 +1,13 @@
 import { __esmMin } from "../_virtual/_rolldown/runtime.js";
-import { z as z$1 } from "zod";
+import { init_runtime_value, isObjectValue, isStringValue } from "../utils/runtime-value.js";
+import { z } from "zod";
 import assert from "assert";
 //#region src/api/caster.ts
 function isNumberType(zodType) {
-	return zodType instanceof z$1.ZodNumber;
+	return zodType instanceof z.ZodNumber;
 }
 function isNullOrOptional(zodType) {
-	return zodType instanceof z$1.ZodNullable || zodType instanceof z$1.ZodOptional;
+	return zodType instanceof z.ZodNullable || zodType instanceof z.ZodOptional;
 }
 function isZodNumberAnyway(zodType) {
 	if (isNumberType(zodType)) return true;
@@ -14,31 +15,30 @@ function isZodNumberAnyway(zodType) {
 	return false;
 }
 function caster(zodType, raw) {
-	if (isZodNumberAnyway(zodType) && typeof raw === "string") return Number(raw);
-	else if (zodType instanceof z$1.ZodUnion && zodType.options.some((opt) => isZodNumberAnyway(opt))) if (Array.isArray(raw)) {
+	if (isZodNumberAnyway(zodType) && isStringValue(raw)) return Number(raw);
+	else if (zodType instanceof z.ZodUnion && zodType.options.some((opt) => isZodNumberAnyway(opt))) if (Array.isArray(raw)) {
 		const numType = zodType.options.find((opt) => isNumberType(opt));
 		assert(numType !== void 0);
 		return raw.map((elem) => caster(numType, elem));
 	} else return Number(raw);
-	else if (zodType instanceof z$1.ZodBoolean && (raw === "true" || raw === "false")) return raw === "true";
-	else if (raw !== null && Array.isArray(raw) && zodType instanceof z$1.ZodArray) return raw.map((elem) => caster(zodType.element, elem));
-	else if (zodType instanceof z$1.ZodObject && typeof raw === "object" && raw !== null) return Object.keys(raw).reduce((r, rawKey) => {
-		r[rawKey] = caster(zodType.shape[rawKey], raw[rawKey]);
-		return r;
-	}, {});
-	else if (zodType instanceof z$1.ZodOptional) return caster(zodType.def.innerType, raw);
-	else if (zodType instanceof z$1.ZodNullable) return caster(zodType.def.innerType, raw);
-	else if (zodType instanceof z$1.ZodDate && raw !== null && raw !== void 0 && new Date(raw).toString() !== "Invalid Date") return new Date(raw);
+	else if (zodType instanceof z.ZodBoolean && (raw === "true" || raw === "false")) return raw === "true";
+	else if (raw !== null && Array.isArray(raw) && zodType instanceof z.ZodArray) return raw.map((elem) => caster(zodType.element, elem));
+	else if (zodType instanceof z.ZodObject && isObjectValue(raw) && raw !== null) return Object.fromEntries(Object.keys(raw).map((rawKey) => [rawKey, caster(zodType["shape"][rawKey], raw[rawKey])]));
+	else if (zodType instanceof z.ZodOptional) return caster(zodType.def.innerType, raw);
+	else if (zodType instanceof z.ZodNullable) return caster(zodType.def.innerType, raw);
+	else if (zodType instanceof z.ZodDate && raw !== null && raw !== void 0 && new Date(raw).toString() !== "Invalid Date") return new Date(raw);
 	else return raw;
 }
 function fastifyCaster(schema) {
-	return z$1.preprocess((raw) => {
+	return z.preprocess((raw) => {
 		return caster(schema, raw);
 	}, schema);
 }
-var init_caster = __esmMin((() => {}));
+var init_caster = __esmMin((() => {
+	init_runtime_value();
+}));
 //#endregion
 init_caster();
 export { caster, fastifyCaster, init_caster };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/api/code-converters.d.ts

@@ -21,6 +21,8 @@ import { z } from "zod";
 import { ApiParamType } from "../types/types";
 import { type ApiParam } from "../types/types";
 import { type ExtendedApi } from "./decorators";
+/** 신뢰할 수 없는 값을 ApiParamType 경계에서 검증합니다. */
+export declare function parseApiParamType<Input>(input: Input): ApiParamType;
 /**
  * Promise 타입을 한 번 언래핑하여 내부 타입을 반환합니다.
  * Promise가 아닌 경우 원본 타입을 그대로 반환합니다.
@@ -31,7 +33,7 @@ export declare function unwrapPromiseOnce(paramType: ApiParamType): ApiParamType
  * string, number, array, union 등 모든 ApiParamType을 처리하며,
  * 순환참조가 발생하는 경우 z.unknown()으로 fallback합니다.
  */
-export declare function getZodTypeFromApiParamType(paramType: ApiParamType, references: {
+export declare function getZodTypeFromApiParamType<Input>(input: Input, references: {
     [id: string]: z.ZodType;
 }): z.ZodType;
 /**
@@ -54,7 +56,7 @@ export declare function getZodObjectFromApi(api: ExtendedApi, references?: {
  * union, intersection, array, ref 등 모든 타입을 TS 문법으로 표현하며,
  * import가 필요한 타입 ID는 injectImportKeys에 수집합니다.
  */
-export declare function apiParamTypeToTsType(paramType: ApiParamType, injectImportKeys: string[]): string;
+export declare function apiParamTypeToTsType<Input>(input: Input, injectImportKeys: string[]): string;
 /**
  * ApiParam 배열을 TypeScript 함수 파라미터 코드로 변환합니다.
  * 예: "name: string, age?: number, active: boolean = true"

package/dist/api/code-converters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-converters.d.ts","sourceRoot":"","sources":["../../src/api/code-converters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAMhD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,YAAY,4BAMxD;AAMD;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,YAAY,EACvB,UAAU,EAAE;IACV,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC;CACzB,GACA,CAAC,CAAC,OAAO,CA4HX;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,QAAQ,EAAE,EACrB,UAAU,GAAE;IACV,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC;CACpB,GACL,CAAC,CAAC,SAAS,CAYb;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,WAAW,EAChB,UAAU,GAAE;IACV,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC;CACpB,qDAwBP;AAMD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,MAAM,CA6DhG;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,MAAM,CAUvF;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,MAAM,CAU/F"}
+{"version":3,"file":"code-converters.d.ts","sourceRoot":"","sources":["../../src/api/code-converters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAmEhD,2CAA2C;AAC3C,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,YAAY,CAMnE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,YAAY,4BAMxD;AAMD;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAC9C,KAAK,EAAE,KAAK,EACZ,UAAU,EAAE;IACV,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC;CACzB,GACA,CAAC,CAAC,OAAO,CAqJX;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,QAAQ,EAAE,EACrB,UAAU,GAAE;IACV,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC;CACpB,GACL,CAAC,CAAC,SAAS,CAYb;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,WAAW,EAChB,UAAU,GAAE;IACV,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC;CACpB,qDA0BP;AAMD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,MAAM,CAgE5F;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,MAAM,CAUvF;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,MAAM,CAU/F"}

package/dist/api/code-converters.js

@@ -1,6 +1,6 @@
 import { __esmMin } from "../_virtual/_rolldown/runtime.js";
 import { ApiParamType, init_types } from "../types/types.js";
-import { z as z$1 } from "zod";
+import { z } from "zod";
 //#region src/api/code-converters.ts
 /**
 * code-converters는 API 타입 정의들을 Zod 객체나 TypeScript 코드로 변환하는 함수들을 제공합니다.
@@ -21,6 +21,12 @@ import { z as z$1 } from "zod";
 * - ZodTypeDef 생성 (Zod 코드 문자열): zod-converter.ts의 zodTypeToZodCode 사용
 * - EntityProp 변환: zod-converter.ts 참조
 */
+/** 신뢰할 수 없는 값을 ApiParamType 경계에서 검증합니다. */
+function parseApiParamType(input) {
+	const result = ApiParamTypeSchema.safeParse(input);
+	if (!result.success) throw new Error(`resolve 불가 ApiParamType: ${z.prettifyError(result.error)}`);
+	return result.data;
+}
 /**
 * Promise 타입을 한 번 언래핑하여 내부 타입을 반환합니다.
 * Promise가 아닌 경우 원본 타입을 그대로 반환합니다.
@@ -34,29 +40,30 @@ function unwrapPromiseOnce(paramType) {
 * string, number, array, union 등 모든 ApiParamType을 처리하며,
 * 순환참조가 발생하는 경우 z.unknown()으로 fallback합니다.
 */
-function getZodTypeFromApiParamType(paramType, references) {
+function getZodTypeFromApiParamType(input, references) {
+	const paramType = parseApiParamType(input);
 	switch (paramType) {
-		case "string": return z$1.string();
-		case "number": return z$1.number();
-		case "boolean": return z$1.boolean();
+		case "string": return z.string();
+		case "number": return z.number();
+		case "boolean": return z.boolean();
 		default: {
 			const advType = paramType;
 			switch (advType.t) {
 				case "string-literal":
-				case "numeric-literal": return z$1.literal(advType.value);
+				case "numeric-literal": return z.literal(advType.value);
 				case "object": return getZodObjectFromApiParams(paramType.props);
 				case "array": {
 					const arrType = paramType;
-					return z$1.array(getZodTypeFromApiParamType(arrType.elementsType, references));
+					return z.array(getZodTypeFromApiParamType(arrType.elementsType, references));
 				}
 				case "ref": {
 					const refType = paramType;
-					if (refType.id === "Date") return z$1.date();
+					if (refType.id === "Date") return z.date();
 					if (["Pick", "Omit"].includes(refType.id)) {
 						if (refType.args?.length !== 2) throw new Error(`잘못된 ${refType.id}`);
 						const [obj, literalOrUnion] = refType.args.map((arg) => getZodTypeFromApiParamType(arg, references));
 						let keys = [];
-						if (literalOrUnion instanceof z$1.ZodUnion) keys = literalOrUnion.def.options.map((option) => option.def.values[0]);
+						if (literalOrUnion instanceof z.ZodUnion) keys = literalOrUnion.def.options.map((option) => option.def.values[0]);
 						else keys = literalOrUnion.def.values;
 						const keyRecord = Object.fromEntries(keys.map((key) => [key, true]));
 						if (refType.id === "Pick") {
@@ -68,26 +75,26 @@ function getZodTypeFromApiParamType(paramType, references) {
 						return getZodTypeFromApiParamType(refType.args[0], references).partial();
 					}
 					const reference = references[refType.id];
-					if (reference === void 0) return z$1.unknown();
+					if (reference === void 0) return z.unknown();
 					return reference;
 				}
 				case "union": {
 					const unionType = paramType;
 					if (unionType.types.length === 2 && unionType.types.some((type) => type === "null")) if (unionType.types[0] === "null") return getZodTypeFromApiParamType(unionType.types[1], references).nullable();
 					else return getZodTypeFromApiParamType(unionType.types[0], references).nullable();
-					return z$1.union(unionType.types.map((type) => getZodTypeFromApiParamType(type, references)));
+					return z.union(unionType.types.map((type) => getZodTypeFromApiParamType(type, references)));
 				}
 				case "intersection": return paramType.types.reduce((result, type, index) => {
 					const resolvedType = getZodTypeFromApiParamType(type, references);
 					if (index === 0) return resolvedType;
-					else return z$1.intersection(result, resolvedType);
-				}, z$1.unknown());
+					else return z.intersection(result, resolvedType);
+				}, z.unknown());
 				case "tuple-type": {
 					const tupleType = paramType;
-					return z$1.tuple(tupleType.elements.map((elem) => getZodTypeFromApiParamType(elem, references)));
+					return z.tuple(tupleType.elements.map((elem) => getZodTypeFromApiParamType(elem, references)));
 				}
 			}
-			return z$1.unknown();
+			return z.unknown();
 		}
 	}
 }
@@ -96,7 +103,7 @@ function getZodTypeFromApiParamType(paramType, references) {
 * 각 파라미터의 optional 여부를 반영하여 Zod 스키마를 생성합니다.
 */
 function getZodObjectFromApiParams(apiParams, references = {}) {
-	return z$1.object(Object.fromEntries(apiParams.map((param) => {
+	return z.object(Object.fromEntries(apiParams.map((param) => {
 		let zodType = getZodTypeFromApiParamType(param.type, references);
 		if (param.optional) zodType = zodType.optional();
 		return [param.name, zodType];
@@ -121,7 +128,8 @@ function getZodObjectFromApi(api, references = {}) {
 * union, intersection, array, ref 등 모든 타입을 TS 문법으로 표현하며,
 * import가 필요한 타입 ID는 injectImportKeys에 수집합니다.
 */
-function apiParamTypeToTsType(paramType, injectImportKeys) {
+function apiParamTypeToTsType(input, injectImportKeys) {
+	const paramType = parseApiParamType(input);
 	if ([
 		"string",
 		"number",
@@ -173,11 +181,84 @@ function apiParamToTsCode(params, injectImportKeys) {
 function apiParamToTsCodeAsObject(params, injectImportKeys) {
 	return `{ ${params.map((param) => `${param.name}${param.optional ? "?" : ""}: ${apiParamTypeToTsType(param.type, injectImportKeys)}${param.defaultDef ? `= ${param.defaultDef}` : ""}`).join(", ")} }`;
 }
+var ApiParamTypeSchema;
 var init_code_converters = __esmMin((() => {
 	init_types();
+	ApiParamTypeSchema = z.lazy(() => z.union([
+		z.enum([
+			"string",
+			"number",
+			"boolean",
+			"null",
+			"undefined",
+			"void",
+			"any",
+			"unknown",
+			"true",
+			"false"
+		]),
+		z.object({
+			t: z.literal("string-literal"),
+			value: z.string()
+		}),
+		z.object({
+			t: z.literal("numeric-literal"),
+			value: z.number()
+		}),
+		z.object({
+			t: z.literal("object"),
+			props: z.array(z.object({
+				name: z.string(),
+				type: ApiParamTypeSchema,
+				optional: z.boolean(),
+				defaultDef: z.string().optional()
+			}))
+		}),
+		z.object({
+			t: z.literal("union"),
+			types: z.array(ApiParamTypeSchema)
+		}),
+		z.object({
+			t: z.literal("intersection"),
+			types: z.array(ApiParamTypeSchema)
+		}),
+		z.object({
+			t: z.literal("array"),
+			elementsType: ApiParamTypeSchema
+		}),
+		z.object({
+			t: z.literal("ref"),
+			id: z.string(),
+			args: z.array(ApiParamTypeSchema).optional()
+		}),
+		z.object({
+			t: z.literal("indexed-access"),
+			object: ApiParamTypeSchema,
+			index: ApiParamTypeSchema
+		}),
+		z.object({
+			t: z.literal("type-param"),
+			id: z.string(),
+			constraint: ApiParamTypeSchema.optional()
+		}),
+		z.object({
+			t: z.literal("tuple-type"),
+			elements: z.array(ApiParamTypeSchema)
+		}),
+		z.object({
+			t: z.literal("function"),
+			parameters: z.array(z.object({
+				name: z.string(),
+				type: ApiParamTypeSchema,
+				optional: z.boolean(),
+				defaultDef: z.string().optional()
+			})),
+			returnType: ApiParamTypeSchema
+		})
+	]));
 }));
 //#endregion
 init_code_converters();
-export { apiParamToTsCode, apiParamToTsCodeAsObject, apiParamTypeToTsType, getZodObjectFromApi, getZodObjectFromApiParams, getZodTypeFromApiParamType, init_code_converters, unwrapPromiseOnce };
+export { apiParamToTsCode, apiParamToTsCodeAsObject, apiParamTypeToTsType, getZodObjectFromApi, getZodObjectFromApiParams, getZodTypeFromApiParamType, init_code_converters, parseApiParamType, unwrapPromiseOnce };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"code-converters.js","names":["z"],"sources":["../../src/api/code-converters.ts"],"sourcesContent":["/**\n * code-converters는 API 타입 정의들을 Zod 객체나 TypeScript 코드로 변환하는 함수들을 제공합니다.\n *\n * 1. API 시리즈들:\n * - ExtendedApi, ApiParam, ApiParamType\n * - API 메타데이터를 표현하는 타입 정의들\n *\n * 2. ZodObject 변환\n * - API 타입 정의 → Zod 타입 인스턴스 (런타임 밸리데이션용)\n * - getZodTypeFromApiParamType → getZodObjectFromApiParams → getZodObjectFromApi\n *\n * 3. TsTypeDef 변환\n * - API 타입 정의 → TypeScript 타입 코드 문자열 (코드 생성용)\n * - apiParamTypeToTsType → apiParamToTsCode, apiParamToTsCodeAsObject\n *\n * 참고:\n * - ZodTypeDef 생성 (Zod 코드 문자열): zod-converter.ts의 zodTypeToZodCode 사용\n * - EntityProp 변환: zod-converter.ts 참조\n */\n\nimport { z } from \"zod\";\n\nimport { ApiParamType } from \"../types/types\";\nimport { type ApiParam } from \"../types/types\";\nimport { type ExtendedApi } from \"./decorators\";\n\n// <any>를 자제하고, Zod에서 제약하는 기본적인 Generic Type Parameter를 사용함.\ntype AnyZodObject = z.ZodObject;\ntype AnyZodLiteral = z.ZodLiteral;\n\n/**\n * Promise 타입을 한 번 언래핑하여 내부 타입을 반환합니다.\n * Promise가 아닌 경우 원본 타입을 그대로 반환합니다.\n */\nexport function unwrapPromiseOnce(paramType: ApiParamType) {\n  if (ApiParamType.isPromise(paramType)) {\n    return paramType.args?.[0];\n  } else {\n    return paramType;\n  }\n}\n\n/*\n * API를 구성하는 요소들을 ZodObject로 변환하기 위한 함수들입니다.\n */\n\n/**\n * ApiParamType을 Zod 타입 인스턴스로 변환합니다.\n * string, number, array, union 등 모든 ApiParamType을 처리하며,\n * 순환참조가 발생하는 경우 z.unknown()으로 fallback합니다.\n */\nexport function getZodTypeFromApiParamType(\n  paramType: ApiParamType,\n  references: {\n    [id: string]: z.ZodType;\n  },\n): z.ZodType {\n  switch (paramType) {\n    case \"string\":\n      return z.string();\n    case \"number\":\n      return z.number();\n    case \"boolean\":\n      return z.boolean();\n    default: {\n      const advType = paramType as { t: string; value?: string | number };\n      switch (advType.t) {\n        case \"string-literal\":\n        case \"numeric-literal\":\n          return z.literal(advType.value);\n        case \"object\": {\n          const objType = paramType as { t: string; props: ApiParam[] };\n          return getZodObjectFromApiParams(objType.props);\n        }\n        case \"array\": {\n          const arrType = paramType as {\n            t: string;\n            elementsType: ApiParamType;\n          };\n          return z.array(getZodTypeFromApiParamType(arrType.elementsType, references));\n        }\n        case \"ref\": {\n          const refType = paramType as {\n            t: string;\n            id: string;\n            args?: ApiParamType[];\n          };\n          // Date 타입 처리\n          if (refType.id === \"Date\") {\n            return z.date();\n          }\n          // 객체 키 관리 유틸리티\n          if ([\"Pick\", \"Omit\"].includes(refType.id)) {\n            if (refType.args?.length !== 2) {\n              throw new Error(`잘못된 ${refType.id}`);\n            }\n            const [obj, literalOrUnion] = refType.args.map(\n              (arg) => getZodTypeFromApiParamType(arg, references),\n              // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- 생성되는 ZodUnion의 타입을 추적하기 어려움\n            ) as [AnyZodObject, z.ZodUnion<any> | AnyZodLiteral];\n\n            let keys: string[] = [];\n            if (literalOrUnion instanceof z.ZodUnion) {\n              keys = literalOrUnion.def.options.map(\n                (option: { def: { values: string[] } }) => option.def.values[0],\n              );\n            } else {\n              keys = (literalOrUnion as z.ZodLiteral<string>).def.values;\n            }\n            const keyRecord = Object.fromEntries(keys.map((key) => [key, true as const]));\n            if (refType.id === \"Pick\") {\n              if (obj.pick) {\n                // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- Zod 4.3.6 pick 타입 호환성\n                return obj.pick(keyRecord as any);\n              }\n            } else {\n              if (obj.omit) {\n                // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- Zod 4.3.6 omit 타입 호환성\n                return obj.omit(keyRecord as any);\n              }\n            }\n          }\n          if ([\"Partial\"].includes(refType.id)) {\n            if (refType.args?.length !== 1) {\n              throw new Error(`잘못된 ${refType.id}`);\n            }\n            const obj = getZodTypeFromApiParamType(refType.args[0], references);\n            // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- Partial 인수 타입 캐스팅\n            return (obj as z.ZodObject<any>).partial();\n          }\n          const reference = references[refType.id];\n          if (reference === undefined) {\n            return z.unknown();\n            // throw new Error(`ref 참조 불가 ${refType.id}`);\n          }\n          return reference;\n        }\n        case \"union\": {\n          const unionType = paramType as {\n            t: string;\n            types: ApiParamType[];\n          };\n          // nullable 유니온\n          if (unionType.types.length === 2 && unionType.types.some((type) => type === \"null\")) {\n            if (unionType.types[0] === \"null\") {\n              return getZodTypeFromApiParamType(unionType.types[1], references).nullable();\n            } else {\n              return getZodTypeFromApiParamType(unionType.types[0], references).nullable();\n            }\n          }\n          // 일반 유니온\n          return z.union(\n            unionType.types.map((type) => getZodTypeFromApiParamType(type, references)),\n          );\n        }\n        case \"intersection\": {\n          const intersectionType = paramType as {\n            t: string;\n            types: ApiParamType[];\n          };\n          return intersectionType.types.reduce((result, type, index) => {\n            const resolvedType = getZodTypeFromApiParamType(type, references);\n            if (index === 0) {\n              return resolvedType;\n            } else {\n              return z.intersection(result, resolvedType);\n            }\n          }, z.unknown() as z.ZodType);\n        }\n        case \"tuple-type\": {\n          const tupleType = paramType as ApiParamType.TupleType;\n          return z.tuple(\n            // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- 생성되는 ZodTuple의 타입을 추적하기 어려움\n            tupleType.elements.map((elem) => getZodTypeFromApiParamType(elem, references)) as any,\n          );\n        }\n      }\n      return z.unknown();\n    }\n  }\n}\n\n/**\n * ApiParam 배열을 ZodObject로 변환합니다.\n * 각 파라미터의 optional 여부를 반영하여 Zod 스키마를 생성합니다.\n */\nexport function getZodObjectFromApiParams(\n  apiParams: ApiParam[],\n  references: {\n    [id: string]: z.ZodType;\n  } = {},\n): z.ZodObject {\n  return z.object(\n    Object.fromEntries(\n      apiParams.map((param) => {\n        let zodType = getZodTypeFromApiParamType(param.type, references);\n        if (param.optional) {\n          zodType = zodType.optional();\n        }\n        return [param.name, zodType];\n      }),\n    ),\n  );\n}\n\n/**\n * ExtendedApi를 ZodObject로 변환합니다.\n * TypeParameter와 일반 파라미터를 처리하며,\n * Context, RefKnex, _로 시작하는 optional 파라미터는 제외합니다.\n */\nexport function getZodObjectFromApi(\n  api: ExtendedApi,\n  references: {\n    [id: string]: z.ZodType;\n  } = {},\n) {\n  if (api.typeParameters?.length > 0) {\n    for (const typeParam of api.typeParameters) {\n      if (typeParam.constraint) {\n        const zodType = getZodTypeFromApiParamType(typeParam.constraint, references);\n\n        // FIXME: references는 글로벌 오브젝트로, typeParam.id(\"T\" 등)를 key로 이렇게 덮어씌워버리면 loadedTypes가 오염됨.\n        // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- 레퍼런스 타입 캐스팅\n        (references[typeParam.id] as z.ZodType<any>) = zodType;\n      }\n    }\n  }\n  const ReqType = getZodObjectFromApiParams(\n    // api parsing한 결과가 api params\n    api.parameters.filter(\n      (param) =>\n        !ApiParamType.isContext(param.type) &&\n        !ApiParamType.isRefKnex(param.type) &&\n        !(param.optional && param.name.startsWith(\"_\")), // _로 시작하는 파라미터는 제외\n    ),\n    references,\n  );\n  return ReqType;\n}\n\n/*\n * API 타입 정의를 TypeScript 코드 문자열로 변환하기 위한 함수들입니다.\n */\n\n/**\n * ApiParamType을 TypeScript 타입 문자열로 변환합니다.\n * union, intersection, array, ref 등 모든 타입을 TS 문법으로 표현하며,\n * import가 필요한 타입 ID는 injectImportKeys에 수집합니다.\n */\nexport function apiParamTypeToTsType(paramType: ApiParamType, injectImportKeys: string[]): string {\n  if (\n    [\n      \"string\",\n      \"number\",\n      \"boolean\",\n      \"true\",\n      \"false\",\n      \"null\",\n      \"undefined\",\n      \"void\",\n      \"any\",\n      \"unknown\",\n    ].includes(paramType as string)\n  ) {\n    return paramType as string;\n  } else if (ApiParamType.isObject(paramType)) {\n    return `{ ${apiParamToTsCode(paramType.props, injectImportKeys)} }`;\n  } else if (ApiParamType.isStringLiteral(paramType)) {\n    return `\"${paramType.value}\"`;\n  } else if (ApiParamType.isNumericLiteral(paramType)) {\n    return String(paramType.value);\n  } else if (ApiParamType.isUnion(paramType)) {\n    return paramType.types.map((type) => apiParamTypeToTsType(type, injectImportKeys)).join(\" | \");\n  } else if (ApiParamType.isIntersection(paramType)) {\n    return paramType.types.map((type) => apiParamTypeToTsType(type, injectImportKeys)).join(\" & \");\n  } else if (ApiParamType.isArray(paramType)) {\n    // intersection이나 union인 경우 괄호로 감싸기\n    const elementsType = apiParamTypeToTsType(paramType.elementsType, injectImportKeys);\n    return ApiParamType.isIntersection(paramType.elementsType) ||\n      ApiParamType.isUnion(paramType.elementsType)\n      ? `(${elementsType})[]`\n      : `${elementsType}[]`;\n  } else if (ApiParamType.isRef(paramType)) {\n    if (![\"Pick\", \"Omit\", \"Promise\", \"Partial\", \"Date\"].includes(paramType.id)) {\n      // importKeys 인젝션\n      injectImportKeys.push(paramType.id);\n    }\n    if (paramType.args === undefined || paramType.args.length === 0) {\n      return paramType.id;\n    } else {\n      return `${paramType.id}<${paramType.args\n        .map((arg) => apiParamTypeToTsType(arg, injectImportKeys))\n        .join(\",\")}>`;\n    }\n  } else if (ApiParamType.isIndexedAccess(paramType)) {\n    return `${apiParamTypeToTsType(\n      paramType.object,\n      injectImportKeys,\n    )}[${apiParamTypeToTsType(paramType.index, injectImportKeys)}]`;\n  } else if (ApiParamType.isTupleType(paramType)) {\n    return `[ ${paramType.elements.map((elem) => apiParamTypeToTsType(elem, injectImportKeys))} ]`;\n  } else if (ApiParamType.isTypeParam(paramType)) {\n    return `${paramType.id}${\n      paramType.constraint\n        ? ` extends ${apiParamTypeToTsType(paramType.constraint, injectImportKeys)}`\n        : \"\"\n    }`;\n  } else {\n    throw new Error(`resolve 불가 ApiParamType ${paramType}`);\n  }\n}\n\n/**\n * ApiParam 배열을 TypeScript 함수 파라미터 코드로 변환합니다.\n * 예: \"name: string, age?: number, active: boolean = true\"\n */\nexport function apiParamToTsCode(params: ApiParam[], injectImportKeys: string[]): string {\n  return params\n    .map((param) => {\n      return `${param.name}${\n        param.optional && !param.defaultDef ? \"?\" : \"\"\n      }: ${apiParamTypeToTsType(param.type, injectImportKeys)}${\n        param.defaultDef ? `= ${param.defaultDef}` : \"\"\n      }`;\n    })\n    .join(\", \");\n}\n\n/**\n * ApiParam 배열을 TypeScript 객체 타입 코드로 변환합니다.\n * 예: \"{ name: string, age?: number, active: boolean = true }\"\n */\nexport function apiParamToTsCodeAsObject(params: ApiParam[], injectImportKeys: string[]): string {\n  return `{ ${params\n    .map(\n      (param) =>\n        `${param.name}${param.optional ? \"?\" : \"\"}: ${apiParamTypeToTsType(\n          param.type,\n          injectImportKeys,\n        )}${param.defaultDef ? `= ${param.defaultDef}` : \"\"}`,\n    )\n    .join(\", \")} }`;\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"code-converters.js","names":[],"sources":["../../src/api/code-converters.ts"],"sourcesContent":["/**\n * code-converters는 API 타입 정의들을 Zod 객체나 TypeScript 코드로 변환하는 함수들을 제공합니다.\n *\n * 1. API 시리즈들:\n * - ExtendedApi, ApiParam, ApiParamType\n * - API 메타데이터를 표현하는 타입 정의들\n *\n * 2. ZodObject 변환\n * - API 타입 정의 → Zod 타입 인스턴스 (런타임 밸리데이션용)\n * - getZodTypeFromApiParamType → getZodObjectFromApiParams → getZodObjectFromApi\n *\n * 3. TsTypeDef 변환\n * - API 타입 정의 → TypeScript 타입 코드 문자열 (코드 생성용)\n * - apiParamTypeToTsType → apiParamToTsCode, apiParamToTsCodeAsObject\n *\n * 참고:\n * - ZodTypeDef 생성 (Zod 코드 문자열): zod-converter.ts의 zodTypeToZodCode 사용\n * - EntityProp 변환: zod-converter.ts 참조\n */\n\nimport { z } from \"zod\";\n\nimport { ApiParamType } from \"../types/types\";\nimport { type ApiParam } from \"../types/types\";\nimport { type ExtendedApi } from \"./decorators\";\n\n// <any>를 자제하고, Zod에서 제약하는 기본적인 Generic Type Parameter를 사용함.\ntype AnyZodObject = z.ZodObject;\ntype AnyZodLiteral = z.ZodLiteral;\n\nconst ApiParamTypeSchema: z.ZodType<ApiParamType> = z.lazy(() =>\n  z.union([\n    z.enum([\n      \"string\",\n      \"number\",\n      \"boolean\",\n      \"null\",\n      \"undefined\",\n      \"void\",\n      \"any\",\n      \"unknown\",\n      \"true\",\n      \"false\",\n    ]),\n    z.object({ t: z.literal(\"string-literal\"), value: z.string() }),\n    z.object({ t: z.literal(\"numeric-literal\"), value: z.number() }),\n    z.object({\n      t: z.literal(\"object\"),\n      props: z.array(\n        z.object({\n          name: z.string(),\n          type: ApiParamTypeSchema,\n          optional: z.boolean(),\n          defaultDef: z.string().optional(),\n        }),\n      ),\n    }),\n    z.object({ t: z.literal(\"union\"), types: z.array(ApiParamTypeSchema) }),\n    z.object({ t: z.literal(\"intersection\"), types: z.array(ApiParamTypeSchema) }),\n    z.object({ t: z.literal(\"array\"), elementsType: ApiParamTypeSchema }),\n    z.object({\n      t: z.literal(\"ref\"),\n      id: z.string(),\n      args: z.array(ApiParamTypeSchema).optional(),\n    }),\n    z.object({\n      t: z.literal(\"indexed-access\"),\n      object: ApiParamTypeSchema,\n      index: ApiParamTypeSchema,\n    }),\n    z.object({\n      t: z.literal(\"type-param\"),\n      id: z.string(),\n      constraint: ApiParamTypeSchema.optional(),\n    }),\n    z.object({ t: z.literal(\"tuple-type\"), elements: z.array(ApiParamTypeSchema) }),\n    z.object({\n      t: z.literal(\"function\"),\n      parameters: z.array(\n        z.object({\n          name: z.string(),\n          type: ApiParamTypeSchema,\n          optional: z.boolean(),\n          defaultDef: z.string().optional(),\n        }),\n      ),\n      returnType: ApiParamTypeSchema,\n    }),\n  ]),\n);\n\n/** 신뢰할 수 없는 값을 ApiParamType 경계에서 검증합니다. */\nexport function parseApiParamType<Input>(input: Input): ApiParamType {\n  const result = ApiParamTypeSchema.safeParse(input);\n  if (!result.success) {\n    throw new Error(`resolve 불가 ApiParamType: ${z.prettifyError(result.error)}`);\n  }\n  return result.data;\n}\n\n/**\n * Promise 타입을 한 번 언래핑하여 내부 타입을 반환합니다.\n * Promise가 아닌 경우 원본 타입을 그대로 반환합니다.\n */\nexport function unwrapPromiseOnce(paramType: ApiParamType) {\n  if (ApiParamType.isPromise(paramType)) {\n    return paramType.args?.[0];\n  } else {\n    return paramType;\n  }\n}\n\n/*\n * API를 구성하는 요소들을 ZodObject로 변환하기 위한 함수들입니다.\n */\n\n/**\n * ApiParamType을 Zod 타입 인스턴스로 변환합니다.\n * string, number, array, union 등 모든 ApiParamType을 처리하며,\n * 순환참조가 발생하는 경우 z.unknown()으로 fallback합니다.\n */\nexport function getZodTypeFromApiParamType<Input>(\n  input: Input,\n  references: {\n    [id: string]: z.ZodType;\n  },\n): z.ZodType {\n  const paramType = parseApiParamType(input);\n  switch (paramType) {\n    case \"string\":\n      return z.string();\n    case \"number\":\n      return z.number();\n    case \"boolean\":\n      return z.boolean();\n    default: {\n      const advType =\n        /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ paramType as {\n          t: string;\n          value?: string | number;\n        };\n      switch (advType.t) {\n        case \"string-literal\":\n        case \"numeric-literal\":\n          return z.literal(advType.value);\n        case \"object\": {\n          const objType =\n            /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ paramType as {\n              t: string;\n              props: ApiParam[];\n            };\n          return getZodObjectFromApiParams(objType.props);\n        }\n        case \"array\": {\n          const arrType =\n            /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ paramType as {\n              t: string;\n              elementsType: ApiParamType;\n            };\n          return z.array(getZodTypeFromApiParamType(arrType.elementsType, references));\n        }\n        case \"ref\": {\n          const refType =\n            /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ paramType as {\n              t: string;\n              id: string;\n              args?: ApiParamType[];\n            };\n          // Date 타입 처리\n          if (refType.id === \"Date\") {\n            return z.date();\n          }\n          // 객체 키 관리 유틸리티\n          if ([\"Pick\", \"Omit\"].includes(refType.id)) {\n            if (refType.args?.length !== 2) {\n              throw new Error(`잘못된 ${refType.id}`);\n            }\n            const [obj, literalOrUnion] =\n              /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ refType.args.map(\n                (arg) => getZodTypeFromApiParamType(arg, references),\n              ) as [AnyZodObject, z.ZodUnion<any> | AnyZodLiteral];\n\n            let keys: string[] = [];\n            if (literalOrUnion instanceof z.ZodUnion) {\n              keys = literalOrUnion.def.options.map(\n                (option: { def: { values: string[] } }) => option.def.values[0],\n              );\n            } else {\n              keys =\n                /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ (\n                  literalOrUnion as z.ZodLiteral<string>\n                ).def.values;\n            }\n            const keyRecord = Object.fromEntries(keys.map((key) => [key, true as const]));\n            if (refType.id === \"Pick\") {\n              if (obj.pick) {\n                // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- Zod 4.3.6 pick 타입 호환성\n                return obj.pick(\n                  /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ keyRecord as any,\n                );\n              }\n            } else {\n              if (obj.omit) {\n                // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- Zod 4.3.6 omit 타입 호환성\n                return obj.omit(\n                  /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ keyRecord as any,\n                );\n              }\n            }\n          }\n          if ([\"Partial\"].includes(refType.id)) {\n            if (refType.args?.length !== 1) {\n              throw new Error(`잘못된 ${refType.id}`);\n            }\n            const obj = getZodTypeFromApiParamType(refType.args[0], references);\n            // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- Partial 인수 타입 캐스팅\n            return /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ (\n              obj as z.ZodObject<any>\n            ).partial();\n          }\n          const reference = references[refType.id];\n          if (reference === undefined) {\n            return z.unknown();\n            // throw new Error(`ref 참조 불가 ${refType.id}`);\n          }\n          return reference;\n        }\n        case \"union\": {\n          const unionType =\n            /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ paramType as {\n              t: string;\n              types: ApiParamType[];\n            };\n          // nullable 유니온\n          if (unionType.types.length === 2 && unionType.types.some((type) => type === \"null\")) {\n            if (unionType.types[0] === \"null\") {\n              return getZodTypeFromApiParamType(unionType.types[1], references).nullable();\n            } else {\n              return getZodTypeFromApiParamType(unionType.types[0], references).nullable();\n            }\n          }\n          // 일반 유니온\n          return z.union(\n            unionType.types.map((type) => getZodTypeFromApiParamType(type, references)),\n          );\n        }\n        case \"intersection\": {\n          const intersectionType =\n            /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ paramType as {\n              t: string;\n              types: ApiParamType[];\n            };\n          return intersectionType.types.reduce((result, type, index) => {\n            const resolvedType = getZodTypeFromApiParamType(type, references);\n            if (index === 0) {\n              return resolvedType;\n            } else {\n              return z.intersection(result, resolvedType);\n            }\n          }, /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ z.unknown() as z.ZodType);\n        }\n        case \"tuple-type\": {\n          const tupleType =\n            /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ paramType as ApiParamType.TupleType;\n          return z.tuple(\n            // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- 생성되는 ZodTuple의 타입을 추적하기 어려움\n            /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ tupleType.elements.map(\n              (elem) => getZodTypeFromApiParamType(elem, references),\n            ) as any,\n          );\n        }\n      }\n      return z.unknown();\n    }\n  }\n}\n\n/**\n * ApiParam 배열을 ZodObject로 변환합니다.\n * 각 파라미터의 optional 여부를 반영하여 Zod 스키마를 생성합니다.\n */\nexport function getZodObjectFromApiParams(\n  apiParams: ApiParam[],\n  references: {\n    [id: string]: z.ZodType;\n  } = {},\n): z.ZodObject {\n  return z.object(\n    Object.fromEntries(\n      apiParams.map((param) => {\n        let zodType = getZodTypeFromApiParamType(param.type, references);\n        if (param.optional) {\n          zodType = zodType.optional();\n        }\n        return [param.name, zodType];\n      }),\n    ),\n  );\n}\n\n/**\n * ExtendedApi를 ZodObject로 변환합니다.\n * TypeParameter와 일반 파라미터를 처리하며,\n * Context, RefKnex, _로 시작하는 optional 파라미터는 제외합니다.\n */\nexport function getZodObjectFromApi(\n  api: ExtendedApi,\n  references: {\n    [id: string]: z.ZodType;\n  } = {},\n) {\n  if (api.typeParameters?.length > 0) {\n    for (const typeParam of api.typeParameters) {\n      if (typeParam.constraint) {\n        const zodType = getZodTypeFromApiParamType(typeParam.constraint, references);\n\n        // FIXME: references는 글로벌 오브젝트로, typeParam.id(\"T\" 등)를 key로 이렇게 덮어씌워버리면 loadedTypes가 오염됨.\n        // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- 레퍼런스 타입 캐스팅\n        /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ (references[\n          typeParam.id\n        ] as z.ZodType<any>) = zodType;\n      }\n    }\n  }\n  const ReqType = getZodObjectFromApiParams(\n    // api parsing한 결과가 api params\n    api.parameters.filter(\n      (param) =>\n        !ApiParamType.isContext(param.type) &&\n        !ApiParamType.isRefKnex(param.type) &&\n        !(param.optional && param.name.startsWith(\"_\")), // _로 시작하는 파라미터는 제외\n    ),\n    references,\n  );\n  return ReqType;\n}\n\n/*\n * API 타입 정의를 TypeScript 코드 문자열로 변환하기 위한 함수들입니다.\n */\n\n/**\n * ApiParamType을 TypeScript 타입 문자열로 변환합니다.\n * union, intersection, array, ref 등 모든 타입을 TS 문법으로 표현하며,\n * import가 필요한 타입 ID는 injectImportKeys에 수집합니다.\n */\nexport function apiParamTypeToTsType<Input>(input: Input, injectImportKeys: string[]): string {\n  const paramType = parseApiParamType(input);\n  if (\n    [\n      \"string\",\n      \"number\",\n      \"boolean\",\n      \"true\",\n      \"false\",\n      \"null\",\n      \"undefined\",\n      \"void\",\n      \"any\",\n      \"unknown\",\n    ].includes(\n      /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ paramType as string,\n    )\n  ) {\n    return /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ paramType as string;\n  } else if (ApiParamType.isObject(paramType)) {\n    return `{ ${apiParamToTsCode(paramType.props, injectImportKeys)} }`;\n  } else if (ApiParamType.isStringLiteral(paramType)) {\n    return `\"${paramType.value}\"`;\n  } else if (ApiParamType.isNumericLiteral(paramType)) {\n    return String(paramType.value);\n  } else if (ApiParamType.isUnion(paramType)) {\n    return paramType.types.map((type) => apiParamTypeToTsType(type, injectImportKeys)).join(\" | \");\n  } else if (ApiParamType.isIntersection(paramType)) {\n    return paramType.types.map((type) => apiParamTypeToTsType(type, injectImportKeys)).join(\" & \");\n  } else if (ApiParamType.isArray(paramType)) {\n    // intersection이나 union인 경우 괄호로 감싸기\n    const elementsType = apiParamTypeToTsType(paramType.elementsType, injectImportKeys);\n    return ApiParamType.isIntersection(paramType.elementsType) ||\n      ApiParamType.isUnion(paramType.elementsType)\n      ? `(${elementsType})[]`\n      : `${elementsType}[]`;\n  } else if (ApiParamType.isRef(paramType)) {\n    if (![\"Pick\", \"Omit\", \"Promise\", \"Partial\", \"Date\"].includes(paramType.id)) {\n      // importKeys 인젝션\n      injectImportKeys.push(paramType.id);\n    }\n    if (paramType.args === undefined || paramType.args.length === 0) {\n      return paramType.id;\n    } else {\n      return `${paramType.id}<${paramType.args\n        .map((arg) => apiParamTypeToTsType(arg, injectImportKeys))\n        .join(\",\")}>`;\n    }\n  } else if (ApiParamType.isIndexedAccess(paramType)) {\n    return `${apiParamTypeToTsType(\n      paramType.object,\n      injectImportKeys,\n    )}[${apiParamTypeToTsType(paramType.index, injectImportKeys)}]`;\n  } else if (ApiParamType.isTupleType(paramType)) {\n    return `[ ${paramType.elements.map((elem) => apiParamTypeToTsType(elem, injectImportKeys))} ]`;\n  } else if (ApiParamType.isTypeParam(paramType)) {\n    return `${paramType.id}${\n      paramType.constraint\n        ? ` extends ${apiParamTypeToTsType(paramType.constraint, injectImportKeys)}`\n        : \"\"\n    }`;\n  } else {\n    throw new Error(`resolve 불가 ApiParamType ${paramType}`);\n  }\n}\n\n/**\n * ApiParam 배열을 TypeScript 함수 파라미터 코드로 변환합니다.\n * 예: \"name: string, age?: number, active: boolean = true\"\n */\nexport function apiParamToTsCode(params: ApiParam[], injectImportKeys: string[]): string {\n  return params\n    .map((param) => {\n      return `${param.name}${\n        param.optional && !param.defaultDef ? \"?\" : \"\"\n      }: ${apiParamTypeToTsType(param.type, injectImportKeys)}${\n        param.defaultDef ? `= ${param.defaultDef}` : \"\"\n      }`;\n    })\n    .join(\", \");\n}\n\n/**\n * ApiParam 배열을 TypeScript 객체 타입 코드로 변환합니다.\n * 예: \"{ name: string, age?: number, active: boolean = true }\"\n */\nexport function apiParamToTsCodeAsObject(params: ApiParam[], injectImportKeys: string[]): string {\n  return `{ ${params\n    .map(\n      (param) =>\n        `${param.name}${param.optional ? \"?\" : \"\"}: ${apiParamTypeToTsType(\n          param.type,\n          injectImportKeys,\n        )}${param.defaultDef ? `= ${param.defaultDef}` : \"\"}`,\n    )\n    .join(\", \")} }`;\n}\n"],"mappings":"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"}

package/dist/api/config.d.ts

@@ -52,6 +52,15 @@ export type SonamuTestConfig = {
     /** Dev 서버 내 Vitest 상주 인스턴스 설정 */
     devRunner?: SonamuDevRunnerConfig;
 };
+export type ZodCompilerApiMode = false | "jit" | "aot";
+export type ZodCompilerConfig = false | {
+    api?: ZodCompilerApiMode;
+};
+export type NormalizedZodCompilerPolicy = {
+    api: ZodCompilerApiMode;
+    targets: Record<string, never>;
+};
+export declare function normalizeZodCompilerPolicy<Value>(value: Value, _syncTargets?: readonly string[]): NormalizedZodCompilerPolicy;
 export type SonamuConfig<TSinkId extends string = string, TFilterId extends string = string> = {
     projectName?: string;
     api: {
@@ -76,6 +85,9 @@ export type SonamuConfig<TSinkId extends string = string, TFilterId extends stri
     sync: {
         targets: string[];
     };
+    validation?: {
+        zodCompiler?: ZodCompilerConfig;
+    };
     database: {
         database?: "pg" | "pgnative";
         defaultOptions?: DatabaseConfig;
@@ -240,5 +252,8 @@ export declare function defineConfig(config: Executable<SonamuConfig>): Promise<
  * @param rootPath
  * @returns
  */
-export declare function loadConfig(rootPath: string): Promise<SonamuConfig>;
+export interface ConfigLoaderDependencies {
+    ensureTsLoaderRegistered(rootPath: string): Promise<void>;
+}
+export declare function loadConfig(rootPath: string, dependencies?: ConfigLoaderDependencies): Promise<SonamuConfig>;
 //# sourceMappingURL=config.d.ts.map

package/dist/api/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/api/config.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/api/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EAC1B,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AAEjC,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE3E,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAQhE,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG;IAC7D,UAAU,CAAC,EAAE,IAAI,CAAC,kBAAkB,CAAC;CACtC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,oCAAoC;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,qBAAqB;IACrB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,mCAAmC;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,uCAAuC;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0CAA0C;IAC1C,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,6BAA6B;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,yBAAyB;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iCAAiC;IACjC,SAAS,CAAC,EAAE,qBAAqB,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AACvD,MAAM,MAAM,iBAAiB,GACzB,KAAK,GACL;IACE,GAAG,CAAC,EAAE,kBAAkB,CAAC;CAC1B,CAAC;AACN,MAAM,MAAM,2BAA2B,GAAG;IACxC,GAAG,EAAE,kBAAkB,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CAChC,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,KAAK,EAC9C,KAAK,EAAE,KAAK,EACZ,YAAY,GAAE,SAAS,MAAM,EAAO,GACnC,2BAA2B,CAkB7B;AAED,MAAM,MAAM,YAAY,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EAAE,SAAS,SAAS,MAAM,GAAG,MAAM,IAAI;IAC7F,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,GAAG,EAAE;QACH,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE;YACL,MAAM,EAAE,MAAM,CAAC;SAChB,CAAC;QACF,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;IAEF;;;;;;;;;;OAUG;IACH,IAAI,EAAE,iBAAiB,CAAC;IAExB,IAAI,EAAE;QACJ,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC;IAEF,UAAU,CAAC,EAAE;QACX,WAAW,CAAC,EAAE,iBAAiB,CAAC;KACjC,CAAC;IAEF,QAAQ,EAAE;QAER,QAAQ,CAAC,EAAE,IAAI,GAAG,UAAU,CAAC;QAE7B,cAAc,CAAC,EAAE,cAAc,CAAC;KACjC,CAAC;IAEF,OAAO,CAAC,EAAE,KAAK,GAAG,oBAAoB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAC3D,MAAM,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAE1B;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,gBAAgB,CAAC;IAExB;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,oBAAoB,GAAG,KAAK,GAAG,QAAQ,CAAC;IAEzD;;;;;;;;;;;;;;OAcG;IACH,YAAY,CAAC,EAAE;QACb,0CAA0C;QAC1C,OAAO,EAAE,CAAC,MAAM,cAAc,CAAC,EAAE,CAAC;QAClC,iCAAiC;QACjC,QAAQ,EAAE,MAAM,CAAC;QACjB,8BAA8B;QAC9B,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAEhC,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,OAAO,CAAC,EAAE,IAAI,CAAC,oBAAoB,EAAE,QAAQ,CAAC,CAAC;IAE/C,MAAM,CAAC,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IAEF,OAAO,CAAC,EAAE;QACR,qCAAqC;QACrC,QAAQ,CAAC,EAAE,OAAO,GAAG,sBAAsB,CAAC;QAC5C,IAAI,CAAC,EAAE,OAAO,GAAG,kBAAkB,CAAC;QACpC,QAAQ,CAAC,EAAE,OAAO,GAAG,sBAAsB,CAAC;QAC5C,SAAS,CAAC,EAAE,OAAO,GAAG,uBAAuB,CAAC;QAC9C,EAAE,CAAC,EAAE,OAAO,GAAG,eAAe,CAAC;QAC/B,GAAG,CAAC,EAAE,OAAO,GAAG,gBAAgB,CAAC;QACjC,MAAM,CAAC,EAAE,OAAO,GAAG,oBAAoB,CAAC;QACxC,EAAE,CAAC,EAAE,OAAO,GAAG,sBAAsB,CAAC;QAEtC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;KAC5C,CAAC;IAEF;;;;OAIG;IACH,IAAI,CAAC,EAAE,iBAAiB,GAAG;QACzB,IAAI,CAAC,EAAE;YACL,gBAAgB,CAAC,EAAE,MAAM,CACvB,MAAM,EACN,WAAW,CAAC,WAAW,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG;gBAChF,UAAU,CAAC,EAAE,MAAM,CAAC;aACrB,CACF,CAAC;SACH,CAAC;KACH,CAAC;IAEF;;;;;OAKG;IACH,SAAS,CAAC,EAAE,uBAAuB,CAAC;IAEpC,SAAS,EAAE,mBAAmB,CAAC;IAE/B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;IAExB;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CAAC,EAAE,WAAW,CAAC;IAEpB,SAAS,CAAC,EAAE;QACV,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QAC5D,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QAC/D,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;KAChG,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAE9B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,eAAe,CAAC;IAChC,eAAe,EAAE,CACf,cAAc,EAAE,IAAI,CAClB,OAAO,EACL,WAAW,GACX,OAAO,GACP,SAAS,GACT,SAAS,GACT,WAAW,GACX,YAAY,GACZ,QAAQ,GACR,MAAM,GACN,SAAS,CACZ,KACE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAChC,wBAAwB,CAAC,EAAE,CACzB,cAAc,EAAE,IAAI,CAClB,gBAAgB,EAChB,WAAW,GAAG,SAAS,GAAG,SAAS,GAAG,IAAI,GAAG,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAC1F,EACD,OAAO,EAAE,cAAc,KACpB,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACnD,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC7B,CAAC;AAGF,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAMpF;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,wBAAwB;IACvC,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3D;AASD,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,MAAM,EAChB,YAAY,GAAE,wBAA0D,GACvE,OAAO,CAAC,YAAY,CAAC,CAcvB"}