sonamu 0.8.26 → 0.9.0

package/dist/template/zod-converter.js

@@ -1,679 +1,625 @@
-/**
- * zod-converter 구성
- * 1. 유틸리티
- *  - getZodTypeById
- *
- * 2. Zod 타입 변환 (EntityProp -> ZodType)
- *  - propToZodType
- *
- * 3. EntityProp/Node -> Zod 코드 문자열
- *  - propToZodTypeDef
- *  - propNodeToZodTypeDef
- *
- * 4. Zod 타입 인스턴스를 해당하는 Zod 코드 문자열로 변환 (ZodType -> ZodCode)
- *  - zodTypeToZodCode
- *
- * 5. Zod 타입을 UI 렌더링에 사용할 수 있는 RenderingNode로 변환 (ZodType -> RenderingNode)
- *  - zodTypeToRenderingNode
- *  - resolveRenderType
- */ import inflection from "inflection";
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
+import { BUILT_IN_TYPE_IDS, SonamuFileArraySchema, SonamuFileSchema, init_types, isBelongsToOneRelationProp, isBigIntegerArrayProp, isBigIntegerSingleProp, isBooleanArrayProp, isBooleanSingleProp, isDateArrayProp, isDateSingleProp, isEnumArrayProp, isEnumSingleProp, isIntegerArrayProp, isIntegerSingleProp, isJsonProp, isNumberArrayProp, isNumberSingleProp, isNumericArrayProp, isNumericSingleProp, isOneToOneRelationProp, isRelationProp, isSearchTextProp, isStringArrayProp, isStringSingleProp, isTsVectorProp, isUuidArrayProp, isUuidSingleProp, isVectorArrayProp, isVectorSingleProp, isVirtualProp } from "../types/types.js";
+import { createImportUrl, init_esm_utils } from "../utils/esm-utils.js";
+import { init_path_utils, runtimePath } from "../utils/path-utils.js";
+import { EntityManager, init_entity_manager } from "../entity/entity-manager.js";
+import inflection from "inflection";
+import { z as z$1 } from "zod";
 import path from "path";
-import { z } from "zod";
-import { Sonamu } from "../api/sonamu.js";
-import { EntityManager } from "../entity/entity-manager.js";
-import { BUILT_IN_TYPE_IDS, isBelongsToOneRelationProp, isBigIntegerArrayProp, isBigIntegerSingleProp, isBooleanArrayProp, isBooleanSingleProp, isDateArrayProp, isDateSingleProp, isEnumArrayProp, isEnumSingleProp, isIntegerArrayProp, isIntegerSingleProp, isJsonProp, isNumberArrayProp, isNumberSingleProp, isNumericArrayProp, isNumericSingleProp, isOneToOneRelationProp, isRelationProp, isSearchTextProp, isStringArrayProp, isStringSingleProp, isTsVectorProp, isUuidArrayProp, isUuidSingleProp, isVectorArrayProp, isVectorSingleProp, isVirtualProp, SonamuFileArraySchema, SonamuFileSchema } from "../types/types.js";
-import { createImportUrl } from "../utils/esm-utils.js";
-import { runtimePath } from "../utils/path-utils.js";
+
+//#region src/template/zod-converter.ts
 /**
- * 내장 타입 정의 (Zod 스키마 + UI 렌더링 타입)
- */ export const BUILT_IN_TYPES = {
-    SonamuFile: {
-        schema: SonamuFileSchema,
-        renderType: "json-sonamufile",
-        schemaName: "SonamuFileSchema"
-    },
-    "SonamuFile[]": {
-        schema: SonamuFileArraySchema,
-        renderType: "json-sonamufile-array",
-        schemaName: "SonamuFileArraySchema"
-    }
-};
+* zod-converter 구성
+* 1. 유틸리티
+*  - getZodTypeById
+*
+* 2. Zod 타입 변환 (EntityProp -> ZodType)
+*  - propToZodType
+*
+* 3. EntityProp/Node -> Zod 코드 문자열
+*  - propToZodTypeDef
+*  - propNodeToZodTypeDef
+*
+* 4. Zod 타입 인스턴스를 해당하는 Zod 코드 문자열로 변환 (ZodType -> ZodCode)
+*  - zodTypeToZodCode
+*
+* 5. Zod 타입을 UI 렌더링에 사용할 수 있는 RenderingNode로 변환 (ZodType -> RenderingNode)
+*  - zodTypeToRenderingNode
+*  - resolveRenderType
+*/
 /**
- * zodFormat을 Zod 4 코드 문자열로 변환합니다.
- * Zod 4에서는 z.email(), z.uuid() 등 독립적인 함수 형태를 사용합니다.
- */ function zodFormatToCode(format) {
-    // ISO 포맷은 z.iso.xxx() 형태
-    const isoFormats = {
-        isoDate: "z.iso.date()",
-        isoTime: "z.iso.time()",
-        isoDatetime: "z.iso.datetime()",
-        isoDuration: "z.iso.duration()"
-    };
-    // hash 포맷은 z.hash("algorithm") 형태
-    const hashFormats = {
-        hashMd5: 'z.hash("md5")',
-        hashSha1: 'z.hash("sha1")',
-        hashSha256: 'z.hash("sha256")',
-        hashSha384: 'z.hash("sha384")',
-        hashSha512: 'z.hash("sha512")'
-    };
-    if (format in isoFormats) {
-        return isoFormats[format];
-    }
-    if (format in hashFormats) {
-        return hashFormats[format];
-    }
-    // 기본 포맷은 z.xxx() 형태 (Zod 4)
-    return `z.${format}()`;
+* zodFormat을 Zod 4 코드 문자열로 변환합니다.
+* Zod 4에서는 z.email(), z.uuid() 등 독립적인 함수 형태를 사용합니다.
+*/
+function zodFormatToCode(format) {
+	const isoFormats = {
+		isoDate: "z.iso.date()",
+		isoTime: "z.iso.time()",
+		isoDatetime: "z.iso.datetime()",
+		isoDuration: "z.iso.duration()"
+	};
+	const hashFormats = {
+		hashMd5: "z.hash(\"md5\")",
+		hashSha1: "z.hash(\"sha1\")",
+		hashSha256: "z.hash(\"sha256\")",
+		hashSha384: "z.hash(\"sha384\")",
+		hashSha512: "z.hash(\"sha512\")"
+	};
+	if (format in isoFormats) {
+		return isoFormats[format];
+	}
+	if (format in hashFormats) {
+		return hashFormats[format];
+	}
+	return `z.${format}()`;
 }
 /**
- * zodFormat을 Zod 4 타입으로 변환합니다.
- * Zod 4에서는 z.email(), z.uuid() 등 독립적인 함수 형태를 사용합니다.
- */ function zodFormatToType(format) {
-    // ISO 포맷은 z.iso.xxx() 형태
-    switch(format){
-        case "isoDate":
-            return z.iso.date();
-        case "isoTime":
-            return z.iso.time();
-        case "isoDatetime":
-            return z.iso.datetime();
-        case "isoDuration":
-            return z.iso.duration();
-        // hash 포맷은 z.hash("algorithm") 형태
-        case "hashMd5":
-            return z.hash("md5");
-        case "hashSha1":
-            return z.hash("sha1");
-        case "hashSha256":
-            return z.hash("sha256");
-        case "hashSha384":
-            return z.hash("sha384");
-        case "hashSha512":
-            return z.hash("sha512");
-        // 기본 포맷은 z.xxx() 형태 (Zod 4)
-        default:
-            return z[format]();
-    }
+* zodFormat을 Zod 4 타입으로 변환합니다.
+* Zod 4에서는 z.email(), z.uuid() 등 독립적인 함수 형태를 사용합니다.
+*/
+function zodFormatToType(format) {
+	switch (format) {
+		case "isoDate": return z$1.iso.date();
+		case "isoTime": return z$1.iso.time();
+		case "isoDatetime": return z$1.iso.datetime();
+		case "isoDuration": return z$1.iso.duration();
+		case "hashMd5": return z$1.hash("md5");
+		case "hashSha1": return z$1.hash("sha1");
+		case "hashSha256": return z$1.hash("sha256");
+		case "hashSha384": return z$1.hash("sha384");
+		case "hashSha512": return z$1.hash("sha512");
+		default: return z$1[format]();
+	}
 }
 /**
- * Zod 타입 ID로부터 동적으로 Zod 스키마를 로드합니다.
- * 내장 타입(BUILT_IN_TYPE_IDS)은 바로 반환하고,
- * 그 외는 dist 디렉토리에서 ESM으로 import하여 가져옵니다.
- */ export async function getZodTypeById(zodTypeId) {
-    // 내장 타입 처리
-    if (BUILT_IN_TYPE_IDS.includes(zodTypeId)) {
-        const builtInType = BUILT_IN_TYPES[zodTypeId];
-        if (!builtInType) {
-            throw new Error(`내장 타입 ${zodTypeId}의 스키마가 정의되지 않았습니다`);
-        }
-        return builtInType.schema.describe(zodTypeId);
-    }
-    // 프로젝트에서 정의한 타입 동적 로드
-    const modulePath = EntityManager.getModulePath(zodTypeId);
-    const moduleAbsPath = path.join(Sonamu.apiRootPath, runtimePath(`dist/application/${modulePath}.js`));
-    const importUrl = createImportUrl(moduleAbsPath);
-    const imported = await import(importUrl);
-    if (!imported[zodTypeId]) {
-        throw new Error(`존재하지 않는 zodTypeId ${zodTypeId}`);
-    }
-    return imported[zodTypeId].describe(zodTypeId);
+* Zod 타입 ID로부터 동적으로 Zod 스키마를 로드합니다.
+* 내장 타입(BUILT_IN_TYPE_IDS)은 바로 반환하고,
+* 그 외는 dist 디렉토리에서 ESM으로 import하여 가져옵니다.
+*/
+async function getZodTypeById(zodTypeId) {
+	if (BUILT_IN_TYPE_IDS.includes(zodTypeId)) {
+		const builtInType = BUILT_IN_TYPES[zodTypeId];
+		if (!builtInType) {
+			throw new Error(`내장 타입 ${zodTypeId}의 스키마가 정의되지 않았습니다`);
+		}
+		return builtInType.schema.describe(zodTypeId);
+	}
+	const modulePath = EntityManager.getModulePath(zodTypeId);
+	const moduleAbsPath = path.join(Sonamu.apiRootPath, runtimePath(`dist/application/${modulePath}.js`));
+	const importUrl = createImportUrl(moduleAbsPath);
+	const imported = await import(importUrl);
+	if (!imported[zodTypeId]) {
+		throw new Error(`존재하지 않는 zodTypeId ${zodTypeId}`);
+	}
+	return imported[zodTypeId].describe(zodTypeId);
 }
 /**
- * EntityProp을 Zod 타입으로 변환합니다.
- * 각 prop의 타입에 따라 적절한 Zod validator를 생성합니다.
- */ export async function propToZodType(prop) {
-    let zodType = z.unknown();
-    if (isIntegerSingleProp(prop)) {
-        zodType = z.number().int();
-    } else if (isIntegerArrayProp(prop)) {
-        zodType = z.number().int().array();
-    } else if (isBigIntegerSingleProp(prop)) {
-        zodType = z.bigint();
-    } else if (isBigIntegerArrayProp(prop)) {
-        zodType = z.bigint().array();
-    } else if (isEnumSingleProp(prop)) {
-        zodType = await getZodTypeById(prop.id);
-    } else if (isEnumArrayProp(prop)) {
-        zodType = (await getZodTypeById(prop.id)).array();
-    } else if (isStringSingleProp(prop)) {
-        if (prop.zodFormat) {
-            zodType = zodFormatToType(prop.zodFormat);
-            if (prop.length && "max" in zodType) {
-                zodType = zodType.max(prop.length);
-            }
-        } else if (prop.length) {
-            zodType = z.string().max(prop.length);
-        } else {
-            zodType = z.string();
-        }
-    } else if (isStringArrayProp(prop)) {
-        let elementType;
-        if (prop.zodFormat) {
-            elementType = zodFormatToType(prop.zodFormat);
-            if (prop.length && "max" in elementType) {
-                elementType = elementType.max(prop.length);
-            }
-        } else if (prop.length) {
-            elementType = z.string().max(prop.length);
-        } else {
-            elementType = z.string();
-        }
-        zodType = elementType.array();
-    } else if (isNumberSingleProp(prop)) {
-        zodType = z.number();
-    } else if (isNumberArrayProp(prop)) {
-        zodType = z.number().array();
-    } else if (isNumericSingleProp(prop)) {
-        zodType = z.string();
-    } else if (isNumericArrayProp(prop)) {
-        zodType = z.string().array();
-    } else if (isBooleanSingleProp(prop)) {
-        zodType = z.boolean();
-    } else if (isBooleanArrayProp(prop)) {
-        zodType = z.boolean().array();
-    } else if (isDateSingleProp(prop)) {
-        zodType = z.date();
-    } else if (isDateArrayProp(prop)) {
-        zodType = z.date().array();
-    } else if (isUuidSingleProp(prop)) {
-        zodType = z.uuid();
-    } else if (isUuidArrayProp(prop)) {
-        zodType = z.uuid().array();
-    } else if (isJsonProp(prop)) {
-        zodType = await getZodTypeById(prop.id);
-    } else if (isSearchTextProp(prop)) {
-        zodType = z.string();
-    } else if (isVectorSingleProp(prop)) {
-        zodType = z.array(z.number());
-    } else if (isVectorArrayProp(prop)) {
-        zodType = z.array(z.array(z.number()));
-    } else if (isVirtualProp(prop)) {
-        zodType = await getZodTypeById(prop.id);
-    } else if (isRelationProp(prop)) {
-        if (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) && prop.hasJoinColumn) {
-            // FK 타입을 참조 엔티티 PK 타입에 따라 결정
-            const relEntity = EntityManager.get(prop.with);
-            const pkType = relEntity.getPkType();
-            if (pkType === "string" || pkType === "uuid") {
-                zodType = z.string();
-            } else {
-                zodType = z.number().int();
-            }
-        }
-    } else {
-        throw new Error(`prop을 zodType으로 변환하는데 실패 ${prop}}`);
-    }
-    if (prop.unsigned) {
-        zodType = zodType.nonnegative();
-    }
-    if (prop.nullable) {
-        zodType = zodType.nullable();
-    }
-    return zodType;
+* EntityProp을 Zod 타입으로 변환합니다.
+* 각 prop의 타입에 따라 적절한 Zod validator를 생성합니다.
+*/
+async function propToZodType(prop) {
+	let zodType = z$1.unknown();
+	if (isIntegerSingleProp(prop)) {
+		zodType = z$1.number().int();
+	} else if (isIntegerArrayProp(prop)) {
+		zodType = z$1.number().int().array();
+	} else if (isBigIntegerSingleProp(prop)) {
+		zodType = z$1.bigint();
+	} else if (isBigIntegerArrayProp(prop)) {
+		zodType = z$1.bigint().array();
+	} else if (isEnumSingleProp(prop)) {
+		zodType = await getZodTypeById(prop.id);
+	} else if (isEnumArrayProp(prop)) {
+		zodType = (await getZodTypeById(prop.id)).array();
+	} else if (isStringSingleProp(prop)) {
+		if (prop.zodFormat) {
+			zodType = zodFormatToType(prop.zodFormat);
+			if (prop.length && "max" in zodType) {
+				zodType = zodType.max(prop.length);
+			}
+		} else if (prop.length) {
+			zodType = z$1.string().max(prop.length);
+		} else {
+			zodType = z$1.string();
+		}
+	} else if (isStringArrayProp(prop)) {
+		let elementType;
+		if (prop.zodFormat) {
+			elementType = zodFormatToType(prop.zodFormat);
+			if (prop.length && "max" in elementType) {
+				elementType = elementType.max(prop.length);
+			}
+		} else if (prop.length) {
+			elementType = z$1.string().max(prop.length);
+		} else {
+			elementType = z$1.string();
+		}
+		zodType = elementType.array();
+	} else if (isNumberSingleProp(prop)) {
+		zodType = z$1.number();
+	} else if (isNumberArrayProp(prop)) {
+		zodType = z$1.number().array();
+	} else if (isNumericSingleProp(prop)) {
+		zodType = z$1.string();
+	} else if (isNumericArrayProp(prop)) {
+		zodType = z$1.string().array();
+	} else if (isBooleanSingleProp(prop)) {
+		zodType = z$1.boolean();
+	} else if (isBooleanArrayProp(prop)) {
+		zodType = z$1.boolean().array();
+	} else if (isDateSingleProp(prop)) {
+		zodType = z$1.date();
+	} else if (isDateArrayProp(prop)) {
+		zodType = z$1.date().array();
+	} else if (isUuidSingleProp(prop)) {
+		zodType = z$1.uuid();
+	} else if (isUuidArrayProp(prop)) {
+		zodType = z$1.uuid().array();
+	} else if (isJsonProp(prop)) {
+		zodType = await getZodTypeById(prop.id);
+	} else if (isSearchTextProp(prop)) {
+		zodType = z$1.string();
+	} else if (isVectorSingleProp(prop)) {
+		zodType = z$1.array(z$1.number());
+	} else if (isVectorArrayProp(prop)) {
+		zodType = z$1.array(z$1.array(z$1.number()));
+	} else if (isVirtualProp(prop)) {
+		zodType = await getZodTypeById(prop.id);
+	} else if (isRelationProp(prop)) {
+		if (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) && prop.hasJoinColumn) {
+			const relEntity = EntityManager.get(prop.with);
+			const pkType = relEntity.getPkType();
+			if (pkType === "string" || pkType === "uuid") {
+				zodType = z$1.string();
+			} else {
+				zodType = z$1.number().int();
+			}
+		}
+	} else {
+		throw new Error(`prop을 zodType으로 변환하는데 실패 ${prop}}`);
+	}
+	if (prop.unsigned) {
+		zodType = zodType.nonnegative();
+	}
+	if (prop.nullable) {
+		zodType = zodType.nullable();
+	}
+	return zodType;
 }
 /**
- * EntityProp을 Zod 타입 정의 코드 문자열로 변환합니다.
- */ export function propToZodTypeDef(prop, injectImportKeys) {
-    let stmt;
-    if (isIntegerSingleProp(prop)) {
-        stmt = `${prop.name}: z.int()`;
-    } else if (isIntegerArrayProp(prop)) {
-        stmt = `${prop.name}: z.int().array()`;
-    } else if (isBigIntegerSingleProp(prop)) {
-        stmt = `${prop.name}: z.bigint()`;
-    } else if (isBigIntegerArrayProp(prop)) {
-        stmt = `${prop.name}: z.bigint().array()`;
-    } else if (isEnumSingleProp(prop)) {
-        stmt = `${prop.name}: ${prop.id}`;
-        injectImportKeys.push(prop.id);
-    } else if (isEnumArrayProp(prop)) {
-        stmt = `${prop.name}: ${prop.id}.array()`;
-        injectImportKeys.push(prop.id);
-    } else if (isStringSingleProp(prop)) {
-        if (prop.zodFormat) {
-            const base = zodFormatToCode(prop.zodFormat);
-            if (prop.length) {
-                stmt = `${prop.name}: ${base}.max(${prop.length})`;
-            } else {
-                stmt = `${prop.name}: ${base}`;
-            }
-        } else if (prop.length) {
-            stmt = `${prop.name}: z.string().max(${prop.length})`;
-        } else {
-            stmt = `${prop.name}: z.string()`;
-        }
-    } else if (isStringArrayProp(prop)) {
-        if (prop.zodFormat) {
-            const base = zodFormatToCode(prop.zodFormat);
-            if (prop.length) {
-                stmt = `${prop.name}: ${base}.max(${prop.length}).array()`;
-            } else {
-                stmt = `${prop.name}: ${base}.array()`;
-            }
-        } else if (prop.length) {
-            stmt = `${prop.name}: z.string().max(${prop.length}).array()`;
-        } else {
-            stmt = `${prop.name}: z.string().array()`;
-        }
-    } else if (isNumberSingleProp(prop)) {
-        stmt = `${prop.name}: z.number()`;
-    } else if (isNumberArrayProp(prop)) {
-        stmt = `${prop.name}: z.number().array()`;
-    } else if (isNumericSingleProp(prop)) {
-        stmt = `${prop.name}: z.string()`;
-    } else if (isNumericArrayProp(prop)) {
-        stmt = `${prop.name}: z.string().array()`;
-    } else if (isDateSingleProp(prop)) {
-        stmt = `${prop.name}: z.date()`;
-    } else if (isDateArrayProp(prop)) {
-        stmt = `${prop.name}: z.date().array()`;
-    } else if (isBooleanSingleProp(prop)) {
-        stmt = `${prop.name}: z.boolean()`;
-    } else if (isBooleanArrayProp(prop)) {
-        stmt = `${prop.name}: z.boolean().array()`;
-    } else if (isUuidSingleProp(prop)) {
-        stmt = `${prop.name}: z.uuid()`;
-    } else if (isUuidArrayProp(prop)) {
-        stmt = `${prop.name}: z.uuid().array()`;
-    } else if (isJsonProp(prop)) {
-        // 내장 타입인 경우 스키마 이름으로 변환
-        if (BUILT_IN_TYPE_IDS.includes(prop.id)) {
-            const schemaName = prop.id === "SonamuFile" ? "SonamuFileSchema" : "SonamuFileArraySchema";
-            stmt = `${prop.name}: ${schemaName}`;
-            injectImportKeys.push(schemaName);
-        } else {
-            stmt = `${prop.name}: ${prop.id}`;
-            injectImportKeys.push(prop.id);
-        }
-    } else if (isSearchTextProp(prop)) {
-        stmt = `${prop.name}: z.string()`;
-    } else if (isVectorSingleProp(prop)) {
-        stmt = `${prop.name}: z.array(z.number())`;
-    } else if (isVectorArrayProp(prop)) {
-        stmt = `${prop.name}: z.array(z.array(z.number()))`;
-    } else if (isTsVectorProp(prop)) {
-        stmt = `${prop.name}: z.string()`;
-    } else if (isVirtualProp(prop)) {
-        stmt = `${prop.name}: ${prop.id}`;
-        injectImportKeys.push(prop.id);
-    } else if (isRelationProp(prop)) {
-        if (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) && prop.hasJoinColumn) {
-            // FK Zod 타입을 참조 엔티티 PK 타입에 따라 결정
-            const relEntity = EntityManager.get(prop.with);
-            const pkType = relEntity.getPkType();
-            if (pkType === "string" || pkType === "uuid") {
-                stmt = `${prop.name}_id: z.string()`;
-            } else {
-                stmt = `${prop.name}_id: z.int()`;
-            }
-        } else {
-            // 그외 relation 케이스 제외
-            return `// ${prop.name}: ${prop.relationType} ${prop.with}`;
-        }
-    } else {
-        return "// unable to resolve";
-    }
-    if (prop.unsigned) {
-        stmt += ".nonnegative()";
-    }
-    if (prop.nullable) {
-        stmt += ".nullable()";
-    }
-    // numeric 타입의 경우 nullable 이후에 meta 추가 (메타데이터가 최상위 레벨에 있어야 함)
-    if (isNumericSingleProp(prop) || isNumericArrayProp(prop)) {
-        stmt += '.meta({ SonamuPropType: "numeric" })';
-    }
-    return `${stmt},`;
+* EntityProp을 Zod 타입 정의 코드 문자열로 변환합니다.
+*/
+function propToZodTypeDef(prop, injectImportKeys) {
+	let stmt;
+	if (isIntegerSingleProp(prop)) {
+		stmt = `${prop.name}: z.int()`;
+	} else if (isIntegerArrayProp(prop)) {
+		stmt = `${prop.name}: z.int().array()`;
+	} else if (isBigIntegerSingleProp(prop)) {
+		stmt = `${prop.name}: z.bigint()`;
+	} else if (isBigIntegerArrayProp(prop)) {
+		stmt = `${prop.name}: z.bigint().array()`;
+	} else if (isEnumSingleProp(prop)) {
+		stmt = `${prop.name}: ${prop.id}`;
+		injectImportKeys.push(prop.id);
+	} else if (isEnumArrayProp(prop)) {
+		stmt = `${prop.name}: ${prop.id}.array()`;
+		injectImportKeys.push(prop.id);
+	} else if (isStringSingleProp(prop)) {
+		if (prop.zodFormat) {
+			const base = zodFormatToCode(prop.zodFormat);
+			if (prop.length) {
+				stmt = `${prop.name}: ${base}.max(${prop.length})`;
+			} else {
+				stmt = `${prop.name}: ${base}`;
+			}
+		} else if (prop.length) {
+			stmt = `${prop.name}: z.string().max(${prop.length})`;
+		} else {
+			stmt = `${prop.name}: z.string()`;
+		}
+	} else if (isStringArrayProp(prop)) {
+		if (prop.zodFormat) {
+			const base = zodFormatToCode(prop.zodFormat);
+			if (prop.length) {
+				stmt = `${prop.name}: ${base}.max(${prop.length}).array()`;
+			} else {
+				stmt = `${prop.name}: ${base}.array()`;
+			}
+		} else if (prop.length) {
+			stmt = `${prop.name}: z.string().max(${prop.length}).array()`;
+		} else {
+			stmt = `${prop.name}: z.string().array()`;
+		}
+	} else if (isNumberSingleProp(prop)) {
+		stmt = `${prop.name}: z.number()`;
+	} else if (isNumberArrayProp(prop)) {
+		stmt = `${prop.name}: z.number().array()`;
+	} else if (isNumericSingleProp(prop)) {
+		stmt = `${prop.name}: z.string()`;
+	} else if (isNumericArrayProp(prop)) {
+		stmt = `${prop.name}: z.string().array()`;
+	} else if (isDateSingleProp(prop)) {
+		stmt = `${prop.name}: z.date()`;
+	} else if (isDateArrayProp(prop)) {
+		stmt = `${prop.name}: z.date().array()`;
+	} else if (isBooleanSingleProp(prop)) {
+		stmt = `${prop.name}: z.boolean()`;
+	} else if (isBooleanArrayProp(prop)) {
+		stmt = `${prop.name}: z.boolean().array()`;
+	} else if (isUuidSingleProp(prop)) {
+		stmt = `${prop.name}: z.uuid()`;
+	} else if (isUuidArrayProp(prop)) {
+		stmt = `${prop.name}: z.uuid().array()`;
+	} else if (isJsonProp(prop)) {
+		if (BUILT_IN_TYPE_IDS.includes(prop.id)) {
+			const schemaName = prop.id === "SonamuFile" ? "SonamuFileSchema" : "SonamuFileArraySchema";
+			stmt = `${prop.name}: ${schemaName}`;
+			injectImportKeys.push(schemaName);
+		} else {
+			stmt = `${prop.name}: ${prop.id}`;
+			injectImportKeys.push(prop.id);
+		}
+	} else if (isSearchTextProp(prop)) {
+		stmt = `${prop.name}: z.string()`;
+	} else if (isVectorSingleProp(prop)) {
+		stmt = `${prop.name}: z.array(z.number())`;
+	} else if (isVectorArrayProp(prop)) {
+		stmt = `${prop.name}: z.array(z.array(z.number()))`;
+	} else if (isTsVectorProp(prop)) {
+		stmt = `${prop.name}: z.string()`;
+	} else if (isVirtualProp(prop)) {
+		stmt = `${prop.name}: ${prop.id}`;
+		injectImportKeys.push(prop.id);
+	} else if (isRelationProp(prop)) {
+		if (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) && prop.hasJoinColumn) {
+			const relEntity = EntityManager.get(prop.with);
+			const pkType = relEntity.getPkType();
+			if (pkType === "string" || pkType === "uuid") {
+				stmt = `${prop.name}_id: z.string()`;
+			} else {
+				stmt = `${prop.name}_id: z.int()`;
+			}
+		} else {
+			return `// ${prop.name}: ${prop.relationType} ${prop.with}`;
+		}
+	} else {
+		return "// unable to resolve";
+	}
+	if (prop.unsigned) {
+		stmt += ".nonnegative()";
+	}
+	if (prop.nullable) {
+		stmt += ".nullable()";
+	}
+	if (isNumericSingleProp(prop) || isNumericArrayProp(prop)) {
+		stmt += ".meta({ SonamuPropType: \"numeric\" })";
+	}
+	return `${stmt},`;
 }
 /**
- * EntityPropNode를 Zod 타입 정의 코드 문자열로 변환합니다.
- * plain, array, object 노드 타입을 재귀적으로 처리하여 중첩 구조를 지원합니다.
- */ export function propNodeToZodTypeDef(propNode, injectImportKeys) {
-    if (propNode.nodeType === "plain") {
-        return propToZodTypeDef(propNode.prop, injectImportKeys);
-    } else if (propNode.nodeType === "array") {
-        return [
-            propNode.prop ? `${propNode.prop.name}: ` : "",
-            "z.array(z.object({",
-            propNode.children.map((childPropNode)=>propNodeToZodTypeDef(childPropNode, injectImportKeys)).join("\n"),
-            "",
-            "})),"
-        ].join("\n");
-    } else if (propNode.nodeType === "object") {
-        return [
-            propNode.prop ? `${propNode.prop.name}: ` : "",
-            "z.object({",
-            propNode.children.map((childPropNode)=>propNodeToZodTypeDef(childPropNode, injectImportKeys)).join("\n"),
-            "",
-            `})${propNode.prop?.nullable ? ".nullable()" : ""},`
-        ].join("\n");
-    } else {
-        throw Error;
-    }
+* EntityPropNode를 Zod 타입 정의 코드 문자열로 변환합니다.
+* plain, array, object 노드 타입을 재귀적으로 처리하여 중첩 구조를 지원합니다.
+*/
+function propNodeToZodTypeDef(propNode, injectImportKeys) {
+	if (propNode.nodeType === "plain") {
+		return propToZodTypeDef(propNode.prop, injectImportKeys);
+	} else if (propNode.nodeType === "array") {
+		return [
+			propNode.prop ? `${propNode.prop.name}: ` : "",
+			"z.array(z.object({",
+			propNode.children.map((childPropNode) => propNodeToZodTypeDef(childPropNode, injectImportKeys)).join("\n"),
+			"",
+			"})),"
+		].join("\n");
+	} else if (propNode.nodeType === "object") {
+		return [
+			propNode.prop ? `${propNode.prop.name}: ` : "",
+			"z.object({",
+			propNode.children.map((childPropNode) => propNodeToZodTypeDef(childPropNode, injectImportKeys)).join("\n"),
+			"",
+			`})${propNode.prop?.nullable ? ".nullable()" : ""},`
+		].join("\n");
+	} else {
+		throw Error;
+	}
 }
-export function zodTypeToTsTypeDef(zt) {
-    switch(zt.def.type){
-        case "string":
-        case "number":
-        case "boolean":
-        case "bigint":
-        case "date":
-        case "null":
-        case "undefined":
-        case "any":
-        case "unknown":
-        case "never":
-            return zt.def.type;
-        case "nullable":
-            return `${zodTypeToTsTypeDef(zt.def.innerType)} | null`;
-        case "default":
-            return zodTypeToTsTypeDef(zt.def.innerType);
-        case "record":
-            {
-                const recordType = zt;
-                return `{ [ key: ${zodTypeToTsTypeDef(recordType.def.keyType)} ]: ${zodTypeToTsTypeDef(recordType.def.valueType)}}`;
-            }
-        case "literal":
-            return Array.from(zt.values).map((value)=>{
-                if (typeof value === "string") {
-                    return `"${value}"`;
-                }
-                if (value === null) {
-                    return `null`;
-                }
-                if (value === undefined) {
-                    return `undefined`;
-                }
-                return `${value}`;
-            }).join(" | ");
-        case "union":
-            return `${zt.options.map((option)=>zodTypeToTsTypeDef(option)).join(" | ")}`;
-        case "enum":
-            return `${zt.options.map((val)=>`"${val}"`).join(" | ")}`;
-        case "array":
-            return `${zodTypeToTsTypeDef(zt.element)}[]`;
-        case "object":
-            {
-                const shape = zt.shape;
-                return [
-                    "{",
-                    ...Object.keys(shape).map((key)=>{
-                        if (shape[key].def.type === "optional") {
-                            return `${key}?: ${zodTypeToTsTypeDef(shape[key].def.innerType)},`;
-                        } else {
-                            return `${key}: ${zodTypeToTsTypeDef(shape[key])},`;
-                        }
-                    }),
-                    "}"
-                ].join("\n");
-            }
-        case "optional":
-            return `${zodTypeToTsTypeDef(zt.def.innerType)} | undefined`;
-        case "template_literal":
-            {
-                const def = zt.def;
-                // 빈 template literal은 string으로 폴백
-                if (!def.parts || def.parts.length === 0) {
-                    return "string";
-                }
-                // 각 part를 TypeScript 타입 문자열로 변환
-                const parts = def.parts.map((part)=>{
-                    // 리터럴 값 (string, number, boolean, null, undefined)
-                    if (typeof part === "string") {
-                        return `${part}`;
-                    }
-                    // ZodType - 재귀적으로 변환
-                    if (part && typeof part === "object" && part._zod) {
-                        const innerType = zodTypeToTsTypeDef(part);
-                        return `$\{${innerType}}`;
-                    }
-                    // 폴백
-                    return `\${string}`;
-                });
-                return `\`${parts.join("")}\``;
-            }
-        case "file":
-            return "File";
-        default:
-            throw new Error(`처리되지 않은 ZodType ${zt.def.type}`);
-    }
+function zodTypeToTsTypeDef(zt) {
+	switch (zt.def.type) {
+		case "string":
+		case "number":
+		case "boolean":
+		case "bigint":
+		case "date":
+		case "null":
+		case "undefined":
+		case "any":
+		case "unknown":
+		case "never": return zt.def.type;
+		case "nullable": return `${zodTypeToTsTypeDef(zt.def.innerType)} | null`;
+		case "default": return zodTypeToTsTypeDef(zt.def.innerType);
+		case "record": {
+			const recordType = zt;
+			return `{ [ key: ${zodTypeToTsTypeDef(recordType.def.keyType)} ]: ${zodTypeToTsTypeDef(recordType.def.valueType)}}`;
+		}
+		case "literal": return Array.from(zt.values).map((value) => {
+			if (typeof value === "string") {
+				return `"${value}"`;
+			}
+			if (value === null) {
+				return `null`;
+			}
+			if (value === undefined) {
+				return `undefined`;
+			}
+			return `${value}`;
+		}).join(" | ");
+		case "union": return `${zt.options.map((option) => zodTypeToTsTypeDef(option)).join(" | ")}`;
+		case "enum": return `${zt.options.map((val) => `"${val}"`).join(" | ")}`;
+		case "array": return `${zodTypeToTsTypeDef(zt.element)}[]`;
+		case "object": {
+			const shape = zt.shape;
+			return [
+				"{",
+				...Object.keys(shape).map((key) => {
+					if (shape[key].def.type === "optional") {
+						return `${key}?: ${zodTypeToTsTypeDef(shape[key].def.innerType)},`;
+					} else {
+						return `${key}: ${zodTypeToTsTypeDef(shape[key])},`;
+					}
+				}),
+				"}"
+			].join("\n");
+		}
+		case "optional": return `${zodTypeToTsTypeDef(zt.def.innerType)} | undefined`;
+		case "template_literal": {
+			const def = zt.def;
+			if (!def.parts || def.parts.length === 0) {
+				return "string";
+			}
+			const parts = def.parts.map((part) => {
+				if (typeof part === "string") {
+					return `${part}`;
+				}
+				if (part && typeof part === "object" && part._zod) {
+					const innerType = zodTypeToTsTypeDef(part);
+					return `$\{${innerType}}`;
+				}
+				return `\${string}`;
+			});
+			return `\`${parts.join("")}\``;
+		}
+		case "file": return "File";
+		default: throw new Error(`처리되지 않은 ZodType ${zt.def.type}`);
+	}
 }
 /**
- * Zod 타입 인스턴스를 해당하는 Zod 코드 문자열로 변환합니다.
- */ export function zodTypeToZodCode(zt) {
-    switch(zt.def.type){
-        case "string":
-            return "z.string()";
-        case "number":
-            return "z.number()";
-        case "bigint":
-            return "z.bigint()";
-        case "boolean":
-            return "z.boolean()";
-        case "date":
-            return "z.date()";
-        case "null":
-            return "z.null()";
-        case "undefined":
-            return "z.undefined()";
-        case "any":
-            return "z.any()";
-        case "unknown":
-            return "z.unknown()";
-        case "never":
-            return "z.never()";
-        case "nullable":
-            return `${zodTypeToZodCode(zt.def.innerType)}.nullable()`;
-        case "default":
-            {
-                const zDefaultDef = zt.def;
-                return `${zodTypeToZodCode(zDefaultDef.innerType)}.default(${zDefaultDef.defaultValue})`;
-            }
-        case "record":
-            {
-                const zRecordDef = zt.def;
-                return `z.record(${zodTypeToZodCode(zRecordDef.keyType)}, ${zodTypeToZodCode(zRecordDef.valueType)})`;
-            }
-        case "literal":
-            {
-                const items = Array.from(zt.values).map((value)=>{
-                    if (typeof value === "string") {
-                        return `"${value}"`;
-                    }
-                    if (value === null) {
-                        return `null`;
-                    }
-                    if (value === undefined) {
-                        return `undefined`;
-                    }
-                    return `${value}`;
-                });
-                if (items.length === 1) {
-                    return `z.literal(${items[0]})`;
-                }
-                return `z.literal([${items.join(", ")}])`;
-            }
-        case "union":
-            return `z.union([${zt.def.options.map((option)=>zodTypeToZodCode(option)).join(",")}])`;
-        case "enum":
-            // NOTE: z.enum(["A", "B"])도 z.enum({ A: "A", B: "B" })로 처리됨.
-            return `z.enum({${Object.entries(zt.def.entries).map(([key, val])=>typeof val === "string" ? `${key}: "${val}"` : `${key}: ${val}`).join(", ")}})`;
-        case "array":
-            return `z.array(${zodTypeToZodCode(zt.def.element)})`;
-        case "object":
-            {
-                const shape = zt.shape;
-                return [
-                    "z.object({",
-                    ...Object.keys(shape).map((key)=>`${key}: ${zodTypeToZodCode(shape[key])},`),
-                    "})"
-                ].join("\n");
-            }
-        case "optional":
-            return `${zodTypeToZodCode(zt.def.innerType)}.optional()`;
-        case "file":
-            return `z.file()`;
-        case "template_literal":
-            {
-                const def = zt.def;
-                // 빈 template literal
-                if (!def.parts || def.parts.length === 0) {
-                    return "z.templateLiteral([])";
-                }
-                // 각 part를 Zod 코드 문자열로 변환
-                const parts = def.parts.map((part)=>{
-                    // 문자열 리터럴
-                    if (typeof part === "string") {
-                        return `"${part}"`;
-                    }
-                    // ZodType - 재귀적으로 변환
-                    if (part && typeof part === "object" && part._zod) {
-                        return zodTypeToZodCode(part);
-                    }
-                    // 폴백
-                    return "z.string()";
-                });
-                return `z.templateLiteral([${parts.join(", ")}])`;
-            }
-        case "intersection":
-            {
-                const zIntersectionDef = zt.def;
-                return `z.intersection(${zodTypeToZodCode(zIntersectionDef.left)}, ${zodTypeToZodCode(zIntersectionDef.right)})`;
-            }
-        default:
-            throw new Error(`처리되지 않은 ZodType ${zt.def.type}`);
-    }
+* Zod 타입 인스턴스를 해당하는 Zod 코드 문자열로 변환합니다.
+*/
+function zodTypeToZodCode(zt) {
+	switch (zt.def.type) {
+		case "string": return "z.string()";
+		case "number": return "z.number()";
+		case "bigint": return "z.bigint()";
+		case "boolean": return "z.boolean()";
+		case "date": return "z.date()";
+		case "null": return "z.null()";
+		case "undefined": return "z.undefined()";
+		case "any": return "z.any()";
+		case "unknown": return "z.unknown()";
+		case "never": return "z.never()";
+		case "nullable": return `${zodTypeToZodCode(zt.def.innerType)}.nullable()`;
+		case "default": {
+			const zDefaultDef = zt.def;
+			return `${zodTypeToZodCode(zDefaultDef.innerType)}.default(${zDefaultDef.defaultValue})`;
+		}
+		case "record": {
+			const zRecordDef = zt.def;
+			return `z.record(${zodTypeToZodCode(zRecordDef.keyType)}, ${zodTypeToZodCode(zRecordDef.valueType)})`;
+		}
+		case "literal": {
+			const items = Array.from(zt.values).map((value) => {
+				if (typeof value === "string") {
+					return `"${value}"`;
+				}
+				if (value === null) {
+					return `null`;
+				}
+				if (value === undefined) {
+					return `undefined`;
+				}
+				return `${value}`;
+			});
+			if (items.length === 1) {
+				return `z.literal(${items[0]})`;
+			}
+			return `z.literal([${items.join(", ")}])`;
+		}
+		case "union": return `z.union([${zt.def.options.map((option) => zodTypeToZodCode(option)).join(",")}])`;
+		case "enum": return `z.enum({${Object.entries(zt.def.entries).map(([key, val]) => typeof val === "string" ? `${key}: "${val}"` : `${key}: ${val}`).join(", ")}})`;
+		case "array": return `z.array(${zodTypeToZodCode(zt.def.element)})`;
+		case "object": {
+			const shape = zt.shape;
+			return [
+				"z.object({",
+				...Object.keys(shape).map((key) => `${key}: ${zodTypeToZodCode(shape[key])},`),
+				"})"
+			].join("\n");
+		}
+		case "optional": return `${zodTypeToZodCode(zt.def.innerType)}.optional()`;
+		case "file": return `z.file()`;
+		case "template_literal": {
+			const def = zt.def;
+			if (!def.parts || def.parts.length === 0) {
+				return "z.templateLiteral([])";
+			}
+			const parts = def.parts.map((part) => {
+				if (typeof part === "string") {
+					return `"${part}"`;
+				}
+				if (part && typeof part === "object" && part._zod) {
+					return zodTypeToZodCode(part);
+				}
+				return "z.string()";
+			});
+			return `z.templateLiteral([${parts.join(", ")}])`;
+		}
+		case "intersection": {
+			const zIntersectionDef = zt.def;
+			return `z.intersection(${zodTypeToZodCode(zIntersectionDef.left)}, ${zodTypeToZodCode(zIntersectionDef.right)})`;
+		}
+		default: throw new Error(`처리되지 않은 ZodType ${zt.def.type}`);
+	}
 }
 /**
- * Zod 타입을 UI 렌더링에 사용할 수 있는 RenderingNode로 변환합니다.
- * 재귀적으로 중첩된 타입들을 처리합니다.
- */ export function zodTypeToRenderingNode(zodType, baseKey = "root") {
-    const def = {
-        name: baseKey,
-        label: inflection.camelize(baseKey, false),
-        zodType
-    };
-    /**
-   * 케이스 처리 순서
-   *
-   * 1. 특수 케이스 (description 기반)
-   *    - SonamuFile/SonamuFile[] : z.object/z.array이지만 파일 업로드용 내장 타입
-   *
-   * 2. 일반 케이스 (instanceof 기반)
-   *    - z.ZodObject : 일반 객체
-   *    - z.ZodArray : 일반 배열
-   *      - vector : z.array(z.number)이지만 네이밍 기반으로 벡터 임베딩
-   *      - 일반 배열 : 그 외
-   *    - z.ZodUnion, z.ZodOptional, z.ZodNullable : 유틸리티 타입
-   *    - 기타 : resolveRenderType()으로 처리
-   */ // 특수 케이스: SonamuFile[] 타입 감지
-    if (zodType.description === "SonamuFile[]") {
-        return {
-            ...def,
-            renderType: "json-sonamufile-array"
-        };
-    }
-    // 특수 케이스: SonamuFile 단일 타입 감지
-    if (zodType.description === "SonamuFile") {
-        return {
-            ...def,
-            renderType: "json-sonamufile"
-        };
-    }
-    // 일반 케이스: ZodObject 체크
-    if (zodType instanceof z.ZodObject) {
-        const columnKeys = Object.keys(zodType.shape);
-        const children = columnKeys.map((key)=>{
-            const innerType = zodType.shape[key];
-            return zodTypeToRenderingNode(innerType, key);
-        });
-        return {
-            ...def,
-            renderType: "object",
-            children
-        };
-    } else if (zodType instanceof z.ZodArray) {
-        const innerType = zodType.def.element;
-        // vector 타입 판별: number 배열이면서 embedding, vector 등의 이름을 가진 경우
-        if (innerType instanceof z.ZodNumber && (baseKey.includes("embedding") || baseKey.includes("vector"))) {
-            return {
-                ...def,
-                renderType: "vector"
-            };
-        }
-        return {
-            ...def,
-            renderType: "array",
-            element: zodTypeToRenderingNode(innerType, baseKey)
-        };
-    } else if (zodType instanceof z.ZodUnion) {
-        const optionNodes = zodType.def.options.map((opt)=>zodTypeToRenderingNode(opt, baseKey));
-        // TODO: ZodUnion이 들어있는 경우 핸들링
-        return optionNodes[0];
-    } else if (zodType instanceof z.ZodOptional) {
-        return {
-            ...zodTypeToRenderingNode(zodType.def.innerType, baseKey),
-            optional: true
-        };
-    } else if (zodType instanceof z.ZodNullable) {
-        return {
-            ...zodTypeToRenderingNode(zodType.def.innerType, baseKey),
-            nullable: true
-        };
-    } else {
-        return {
-            ...def,
-            renderType: resolveRenderType(baseKey, zodType)
-        };
-    }
+* Zod 타입을 UI 렌더링에 사용할 수 있는 RenderingNode로 변환합니다.
+* 재귀적으로 중첩된 타입들을 처리합니다.
+*/
+function zodTypeToRenderingNode(zodType, baseKey = "root") {
+	const def = {
+		name: baseKey,
+		label: inflection.camelize(baseKey, false),
+		zodType
+	};
+	/**
+	* 케이스 처리 순서
+	*
+	* 1. 특수 케이스 (description 기반)
+	*    - SonamuFile/SonamuFile[] : z.object/z.array이지만 파일 업로드용 내장 타입
+	*
+	* 2. 일반 케이스 (instanceof 기반)
+	*    - z.ZodObject : 일반 객체
+	*    - z.ZodArray : 일반 배열
+	*      - vector : z.array(z.number)이지만 네이밍 기반으로 벡터 임베딩
+	*      - 일반 배열 : 그 외
+	*    - z.ZodUnion, z.ZodOptional, z.ZodNullable : 유틸리티 타입
+	*    - 기타 : resolveRenderType()으로 처리
+	*/
+	if (zodType.description === "SonamuFile[]") {
+		return {
+			...def,
+			renderType: "json-sonamufile-array"
+		};
+	}
+	if (zodType.description === "SonamuFile") {
+		return {
+			...def,
+			renderType: "json-sonamufile"
+		};
+	}
+	if (zodType instanceof z$1.ZodObject) {
+		const columnKeys = Object.keys(zodType.shape);
+		const children = columnKeys.map((key) => {
+			const innerType = zodType.shape[key];
+			return zodTypeToRenderingNode(innerType, key);
+		});
+		return {
+			...def,
+			renderType: "object",
+			children
+		};
+	} else if (zodType instanceof z$1.ZodArray) {
+		const innerType = zodType.def.element;
+		if (innerType instanceof z$1.ZodNumber && (baseKey.includes("embedding") || baseKey.includes("vector"))) {
+			return {
+				...def,
+				renderType: "vector"
+			};
+		}
+		return {
+			...def,
+			renderType: "array",
+			element: zodTypeToRenderingNode(innerType, baseKey)
+		};
+	} else if (zodType instanceof z$1.ZodUnion) {
+		const optionNodes = zodType.def.options.map((opt) => zodTypeToRenderingNode(opt, baseKey));
+		return optionNodes[0];
+	} else if (zodType instanceof z$1.ZodOptional) {
+		return {
+			...zodTypeToRenderingNode(zodType.def.innerType, baseKey),
+			optional: true
+		};
+	} else if (zodType instanceof z$1.ZodNullable) {
+		return {
+			...zodTypeToRenderingNode(zodType.def.innerType, baseKey),
+			nullable: true
+		};
+	} else {
+		return {
+			...def,
+			renderType: resolveRenderType(baseKey, zodType)
+		};
+	}
 }
 /**
- * Zod 타입과 키 이름으로부터 적절한 RenderType을 결정합니다.
- */ function resolveRenderType(key, zodType) {
-    if (zodType instanceof z.ZodDate) {
-        return "datetime";
-    } else if (zodType instanceof z.core.$ZodString) {
-        // NOTE: z.ZodString으로 비교하면 z.url(), z.email() 등의 타입에서 문제가 생기므로 z.core.$ZodString으로 비교함
-        // FIXME: email이나 url 타입 등에 대한 처리가 필요함
-        if (zodType.description === "SQLDateTimeString") {
-            return "string-datetime";
-        } else if (key.endsWith("date")) {
-            return "string-date";
-        } else if (key === "id") {
-            return "string-id";
-        } else if (key.endsWith("_id")) {
-            return "string-fk_id";
-        } else {
-            return "string-plain";
-        }
-    } else if (zodType instanceof z.ZodNumber) {
-        if (key === "id") {
-            return "number-id";
-        } else if (key.endsWith("_id")) {
-            return "number-fk_id";
-        } else {
-            return "number-plain";
-        }
-    } else if (zodType instanceof z.ZodBoolean) {
-        return "boolean";
-    } else if (zodType instanceof z.ZodEnum) {
-        return "enums";
-    } else if (zodType instanceof z.ZodRecord) {
-        return "record";
-    } else if (zodType instanceof z.ZodAny || zodType instanceof z.ZodUnknown) {
-        return "string-plain";
-    } else if (zodType instanceof z.ZodUnion) {
-        return "string-plain";
-    } else if (zodType instanceof z.ZodLiteral) {
-        return "string-plain";
-    } else if (zodType instanceof z.ZodTemplateLiteral) {
-        return "string-plain";
-    } else if (zodType.def.type === "custom") {
-        return "object";
-    } else {
-        throw new Error(`타입 파싱 불가 ${key} ${zodType.def.type}`);
-    }
+* Zod 타입과 키 이름으로부터 적절한 RenderType을 결정합니다.
+*/
+function resolveRenderType(key, zodType) {
+	if (zodType instanceof z$1.ZodDate) {
+		return "datetime";
+	} else if (zodType instanceof z$1.core.$ZodString) {
+		if (zodType.description === "SQLDateTimeString") {
+			return "string-datetime";
+		} else if (key.endsWith("date")) {
+			return "string-date";
+		} else if (key === "id") {
+			return "string-id";
+		} else if (key.endsWith("_id")) {
+			return "string-fk_id";
+		} else {
+			return "string-plain";
+		}
+	} else if (zodType instanceof z$1.ZodNumber) {
+		if (key === "id") {
+			return "number-id";
+		} else if (key.endsWith("_id")) {
+			return "number-fk_id";
+		} else {
+			return "number-plain";
+		}
+	} else if (zodType instanceof z$1.ZodBoolean) {
+		return "boolean";
+	} else if (zodType instanceof z$1.ZodEnum) {
+		return "enums";
+	} else if (zodType instanceof z$1.ZodRecord) {
+		return "record";
+	} else if (zodType instanceof z$1.ZodAny || zodType instanceof z$1.ZodUnknown) {
+		return "string-plain";
+	} else if (zodType instanceof z$1.ZodUnion) {
+		return "string-plain";
+	} else if (zodType instanceof z$1.ZodLiteral) {
+		return "string-plain";
+	} else if (zodType instanceof z$1.ZodTemplateLiteral) {
+		return "string-plain";
+	} else if (zodType.def.type === "custom") {
+		return "object";
+	} else {
+		throw new Error(`타입 파싱 불가 ${key} ${zodType.def.type}`);
+	}
 }
+var BUILT_IN_TYPES;
+var init_zod_converter = __esmMin((() => {
+	init_sonamu();
+	init_entity_manager();
+	init_types();
+	init_esm_utils();
+	init_path_utils();
+	BUILT_IN_TYPES = {
+		SonamuFile: {
+			schema: SonamuFileSchema,
+			renderType: "json-sonamufile",
+			schemaName: "SonamuFileSchema"
+		},
+		"SonamuFile[]": {
+			schema: SonamuFileArraySchema,
+			renderType: "json-sonamufile-array",
+			schemaName: "SonamuFileArraySchema"
+		}
+	};
+}));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/template/zod-converter.ts"],"sourcesContent":["/**\n * zod-converter 구성\n * 1. 유틸리티\n *  - getZodTypeById\n *\n * 2. Zod 타입 변환 (EntityProp -> ZodType)\n *  - propToZodType\n *\n * 3. EntityProp/Node -> Zod 코드 문자열\n *  - propToZodTypeDef\n *  - propNodeToZodTypeDef\n *\n * 4. Zod 타입 인스턴스를 해당하는 Zod 코드 문자열로 변환 (ZodType -> ZodCode)\n *  - zodTypeToZodCode\n *\n * 5. Zod 타입을 UI 렌더링에 사용할 수 있는 RenderingNode로 변환 (ZodType -> RenderingNode)\n *  - zodTypeToRenderingNode\n *  - resolveRenderType\n */\n\nimport inflection from \"inflection\";\nimport path from \"path\";\nimport { z } from \"zod\";\nimport type { $ZodLooseShape } from \"zod/v4/core\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport {\n  BUILT_IN_TYPE_IDS,\n  type EntityProp,\n  type EntityPropNode,\n  isBelongsToOneRelationProp,\n  isBigIntegerArrayProp,\n  isBigIntegerSingleProp,\n  isBooleanArrayProp,\n  isBooleanSingleProp,\n  isDateArrayProp,\n  isDateSingleProp,\n  isEnumArrayProp,\n  isEnumSingleProp,\n  isIntegerArrayProp,\n  isIntegerSingleProp,\n  isJsonProp,\n  isNumberArrayProp,\n  isNumberSingleProp,\n  isNumericArrayProp,\n  isNumericSingleProp,\n  isOneToOneRelationProp,\n  isRelationProp,\n  isSearchTextProp,\n  isStringArrayProp,\n  isStringSingleProp,\n  isTsVectorProp,\n  isUuidArrayProp,\n  isUuidSingleProp,\n  isVectorArrayProp,\n  isVectorSingleProp,\n  isVirtualProp,\n  type RenderingNode,\n  SonamuFileArraySchema,\n  SonamuFileSchema,\n  type ZodStringFormat,\n} from \"../types/types\";\nimport { createImportUrl } from \"../utils/esm-utils\";\nimport { runtimePath } from \"../utils/path-utils\";\n\n// <any>를 자제하고, Zod에서 제약하는 기본적인 Generic Type Parameter를 사용함.\ntype AnyZodRecord = z.ZodRecord<z.ZodString | z.ZodNumber | z.ZodSymbol, z.ZodType>;\ntype AnyZodObject = z.ZodObject<$ZodLooseShape>;\ntype AnyZodNullable = z.ZodNullable<z.ZodType>;\ntype AnyZodDefault = z.ZodDefault<z.ZodType>;\ntype AnyZodUnion = z.ZodUnion<z.ZodType[]>;\ntype AnyZodArray = z.ZodArray<z.ZodType>;\ntype AnyZodOptional = z.ZodOptional<z.ZodType>;\ntype AnyZodTemplateLiteral = z.ZodTemplateLiteral<string>;\n\n/**\n * 내장 타입 정의 (Zod 스키마 + UI 렌더링 타입)\n */\nexport const BUILT_IN_TYPES = {\n  SonamuFile: {\n    schema: SonamuFileSchema,\n    renderType: \"json-sonamufile\",\n    schemaName: \"SonamuFileSchema\",\n  },\n  \"SonamuFile[]\": {\n    schema: SonamuFileArraySchema,\n    renderType: \"json-sonamufile-array\",\n    schemaName: \"SonamuFileArraySchema\",\n  },\n} as const;\n\n/**\n * zodFormat을 Zod 4 코드 문자열로 변환합니다.\n * Zod 4에서는 z.email(), z.uuid() 등 독립적인 함수 형태를 사용합니다.\n */\nfunction zodFormatToCode(format: ZodStringFormat): string {\n  // ISO 포맷은 z.iso.xxx() 형태\n  const isoFormats: Record<string, string> = {\n    isoDate: \"z.iso.date()\",\n    isoTime: \"z.iso.time()\",\n    isoDatetime: \"z.iso.datetime()\",\n    isoDuration: \"z.iso.duration()\",\n  };\n\n  // hash 포맷은 z.hash(\"algorithm\") 형태\n  const hashFormats: Record<string, string> = {\n    hashMd5: 'z.hash(\"md5\")',\n    hashSha1: 'z.hash(\"sha1\")',\n    hashSha256: 'z.hash(\"sha256\")',\n    hashSha384: 'z.hash(\"sha384\")',\n    hashSha512: 'z.hash(\"sha512\")',\n  };\n\n  if (format in isoFormats) {\n    return isoFormats[format];\n  }\n\n  if (format in hashFormats) {\n    return hashFormats[format];\n  }\n\n  // 기본 포맷은 z.xxx() 형태 (Zod 4)\n  return `z.${format}()`;\n}\n\n/**\n * zodFormat을 Zod 4 타입으로 변환합니다.\n * Zod 4에서는 z.email(), z.uuid() 등 독립적인 함수 형태를 사용합니다.\n */\nfunction zodFormatToType(format: ZodStringFormat): z.ZodType {\n  // ISO 포맷은 z.iso.xxx() 형태\n  switch (format) {\n    case \"isoDate\":\n      return z.iso.date();\n    case \"isoTime\":\n      return z.iso.time();\n    case \"isoDatetime\":\n      return z.iso.datetime();\n    case \"isoDuration\":\n      return z.iso.duration();\n    // hash 포맷은 z.hash(\"algorithm\") 형태\n    case \"hashMd5\":\n      return z.hash(\"md5\");\n    case \"hashSha1\":\n      return z.hash(\"sha1\");\n    case \"hashSha256\":\n      return z.hash(\"sha256\");\n    case \"hashSha384\":\n      return z.hash(\"sha384\");\n    case \"hashSha512\":\n      return z.hash(\"sha512\");\n    // 기본 포맷은 z.xxx() 형태 (Zod 4)\n    default:\n      return (z as unknown as Record<string, () => z.ZodType>)[format]();\n  }\n}\n\n/**\n * Zod 타입 ID로부터 동적으로 Zod 스키마를 로드합니다.\n * 내장 타입(BUILT_IN_TYPE_IDS)은 바로 반환하고,\n * 그 외는 dist 디렉토리에서 ESM으로 import하여 가져옵니다.\n */\nexport async function getZodTypeById(zodTypeId: string): Promise<z.ZodTypeAny> {\n  // 내장 타입 처리\n  if ((BUILT_IN_TYPE_IDS as readonly string[]).includes(zodTypeId)) {\n    const builtInType = BUILT_IN_TYPES[zodTypeId as keyof typeof BUILT_IN_TYPES];\n    if (!builtInType) {\n      throw new Error(`내장 타입 ${zodTypeId}의 스키마가 정의되지 않았습니다`);\n    }\n    return builtInType.schema.describe(zodTypeId);\n  }\n\n  // 프로젝트에서 정의한 타입 동적 로드\n  const modulePath = EntityManager.getModulePath(zodTypeId);\n  const moduleAbsPath = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(`dist/application/${modulePath}.js`),\n  );\n  const importUrl = createImportUrl(moduleAbsPath);\n  const imported = await import(importUrl);\n\n  if (!imported[zodTypeId]) {\n    throw new Error(`존재하지 않는 zodTypeId ${zodTypeId}`);\n  }\n  return imported[zodTypeId].describe(zodTypeId);\n}\n\n/**\n * EntityProp을 Zod 타입으로 변환합니다.\n * 각 prop의 타입에 따라 적절한 Zod validator를 생성합니다.\n */\nexport async function propToZodType(prop: EntityProp): Promise<z.ZodTypeAny> {\n  let zodType: z.ZodTypeAny = z.unknown();\n  if (isIntegerSingleProp(prop)) {\n    zodType = z.number().int();\n  } else if (isIntegerArrayProp(prop)) {\n    zodType = z.number().int().array();\n  } else if (isBigIntegerSingleProp(prop)) {\n    zodType = z.bigint();\n  } else if (isBigIntegerArrayProp(prop)) {\n    zodType = z.bigint().array();\n  } else if (isEnumSingleProp(prop)) {\n    zodType = await getZodTypeById(prop.id);\n  } else if (isEnumArrayProp(prop)) {\n    zodType = (await getZodTypeById(prop.id)).array();\n  } else if (isStringSingleProp(prop)) {\n    if (prop.zodFormat) {\n      zodType = zodFormatToType(prop.zodFormat);\n      if (prop.length && \"max\" in zodType) {\n        zodType = (zodType as z.ZodString).max(prop.length);\n      }\n    } else if (prop.length) {\n      zodType = z.string().max(prop.length);\n    } else {\n      zodType = z.string();\n    }\n  } else if (isStringArrayProp(prop)) {\n    let elementType: z.ZodType;\n    if (prop.zodFormat) {\n      elementType = zodFormatToType(prop.zodFormat);\n      if (prop.length && \"max\" in elementType) {\n        elementType = (elementType as z.ZodString).max(prop.length);\n      }\n    } else if (prop.length) {\n      elementType = z.string().max(prop.length);\n    } else {\n      elementType = z.string();\n    }\n    zodType = elementType.array();\n  } else if (isNumberSingleProp(prop)) {\n    zodType = z.number();\n  } else if (isNumberArrayProp(prop)) {\n    zodType = z.number().array();\n  } else if (isNumericSingleProp(prop)) {\n    zodType = z.string();\n  } else if (isNumericArrayProp(prop)) {\n    zodType = z.string().array();\n  } else if (isBooleanSingleProp(prop)) {\n    zodType = z.boolean();\n  } else if (isBooleanArrayProp(prop)) {\n    zodType = z.boolean().array();\n  } else if (isDateSingleProp(prop)) {\n    zodType = z.date();\n  } else if (isDateArrayProp(prop)) {\n    zodType = z.date().array();\n  } else if (isUuidSingleProp(prop)) {\n    zodType = z.uuid();\n  } else if (isUuidArrayProp(prop)) {\n    zodType = z.uuid().array();\n  } else if (isJsonProp(prop)) {\n    zodType = await getZodTypeById(prop.id);\n  } else if (isSearchTextProp(prop)) {\n    zodType = z.string();\n  } else if (isVectorSingleProp(prop)) {\n    zodType = z.array(z.number());\n  } else if (isVectorArrayProp(prop)) {\n    zodType = z.array(z.array(z.number()));\n  } else if (isVirtualProp(prop)) {\n    zodType = await getZodTypeById(prop.id);\n  } else if (isRelationProp(prop)) {\n    if (isBelongsToOneRelationProp(prop) || (isOneToOneRelationProp(prop) && prop.hasJoinColumn)) {\n      // FK 타입을 참조 엔티티 PK 타입에 따라 결정\n      const relEntity = EntityManager.get(prop.with);\n      const pkType = relEntity.getPkType();\n      if (pkType === \"string\" || pkType === \"uuid\") {\n        zodType = z.string();\n      } else {\n        zodType = z.number().int();\n      }\n    }\n  } else {\n    throw new Error(`prop을 zodType으로 변환하는데 실패 ${prop}}`);\n  }\n\n  if ((prop as { unsigned?: boolean }).unsigned) {\n    zodType = (zodType as z.ZodNumber).nonnegative();\n  }\n  if (prop.nullable) {\n    zodType = zodType.nullable();\n  }\n\n  return zodType;\n}\n\n/**\n * EntityProp을 Zod 타입 정의 코드 문자열로 변환합니다.\n */\nexport function propToZodTypeDef(prop: EntityProp, injectImportKeys: string[]): string {\n  let stmt: string;\n  if (isIntegerSingleProp(prop)) {\n    stmt = `${prop.name}: z.int()`;\n  } else if (isIntegerArrayProp(prop)) {\n    stmt = `${prop.name}: z.int().array()`;\n  } else if (isBigIntegerSingleProp(prop)) {\n    stmt = `${prop.name}: z.bigint()`;\n  } else if (isBigIntegerArrayProp(prop)) {\n    stmt = `${prop.name}: z.bigint().array()`;\n  } else if (isEnumSingleProp(prop)) {\n    stmt = `${prop.name}: ${prop.id}`;\n    injectImportKeys.push(prop.id);\n  } else if (isEnumArrayProp(prop)) {\n    stmt = `${prop.name}: ${prop.id}.array()`;\n    injectImportKeys.push(prop.id);\n  } else if (isStringSingleProp(prop)) {\n    if (prop.zodFormat) {\n      const base = zodFormatToCode(prop.zodFormat);\n      if (prop.length) {\n        stmt = `${prop.name}: ${base}.max(${prop.length})`;\n      } else {\n        stmt = `${prop.name}: ${base}`;\n      }\n    } else if (prop.length) {\n      stmt = `${prop.name}: z.string().max(${prop.length})`;\n    } else {\n      stmt = `${prop.name}: z.string()`;\n    }\n  } else if (isStringArrayProp(prop)) {\n    if (prop.zodFormat) {\n      const base = zodFormatToCode(prop.zodFormat);\n      if (prop.length) {\n        stmt = `${prop.name}: ${base}.max(${prop.length}).array()`;\n      } else {\n        stmt = `${prop.name}: ${base}.array()`;\n      }\n    } else if (prop.length) {\n      stmt = `${prop.name}: z.string().max(${prop.length}).array()`;\n    } else {\n      stmt = `${prop.name}: z.string().array()`;\n    }\n  } else if (isNumberSingleProp(prop)) {\n    stmt = `${prop.name}: z.number()`;\n  } else if (isNumberArrayProp(prop)) {\n    stmt = `${prop.name}: z.number().array()`;\n  } else if (isNumericSingleProp(prop)) {\n    stmt = `${prop.name}: z.string()`;\n  } else if (isNumericArrayProp(prop)) {\n    stmt = `${prop.name}: z.string().array()`;\n  } else if (isDateSingleProp(prop)) {\n    stmt = `${prop.name}: z.date()`;\n  } else if (isDateArrayProp(prop)) {\n    stmt = `${prop.name}: z.date().array()`;\n  } else if (isBooleanSingleProp(prop)) {\n    stmt = `${prop.name}: z.boolean()`;\n  } else if (isBooleanArrayProp(prop)) {\n    stmt = `${prop.name}: z.boolean().array()`;\n  } else if (isUuidSingleProp(prop)) {\n    stmt = `${prop.name}: z.uuid()`;\n  } else if (isUuidArrayProp(prop)) {\n    stmt = `${prop.name}: z.uuid().array()`;\n  } else if (isJsonProp(prop)) {\n    // 내장 타입인 경우 스키마 이름으로 변환\n    if ((BUILT_IN_TYPE_IDS as readonly string[]).includes(prop.id)) {\n      const schemaName = prop.id === \"SonamuFile\" ? \"SonamuFileSchema\" : \"SonamuFileArraySchema\";\n      stmt = `${prop.name}: ${schemaName}`;\n      injectImportKeys.push(schemaName);\n    } else {\n      stmt = `${prop.name}: ${prop.id}`;\n      injectImportKeys.push(prop.id);\n    }\n  } else if (isSearchTextProp(prop)) {\n    stmt = `${prop.name}: z.string()`;\n  } else if (isVectorSingleProp(prop)) {\n    stmt = `${prop.name}: z.array(z.number())`;\n  } else if (isVectorArrayProp(prop)) {\n    stmt = `${prop.name}: z.array(z.array(z.number()))`;\n  } else if (isTsVectorProp(prop)) {\n    stmt = `${prop.name}: z.string()`;\n  } else if (isVirtualProp(prop)) {\n    stmt = `${prop.name}: ${prop.id}`;\n    injectImportKeys.push(prop.id);\n  } else if (isRelationProp(prop)) {\n    if (isBelongsToOneRelationProp(prop) || (isOneToOneRelationProp(prop) && prop.hasJoinColumn)) {\n      // FK Zod 타입을 참조 엔티티 PK 타입에 따라 결정\n      const relEntity = EntityManager.get(prop.with);\n      const pkType = relEntity.getPkType();\n      if (pkType === \"string\" || pkType === \"uuid\") {\n        stmt = `${prop.name}_id: z.string()`;\n      } else {\n        stmt = `${prop.name}_id: z.int()`;\n      }\n    } else {\n      // 그외 relation 케이스 제외\n      return `// ${prop.name}: ${prop.relationType} ${prop.with}`;\n    }\n  } else {\n    return \"// unable to resolve\";\n  }\n\n  if ((prop as { unsigned?: boolean }).unsigned) {\n    stmt += \".nonnegative()\";\n  }\n  if (prop.nullable) {\n    stmt += \".nullable()\";\n  }\n\n  // numeric 타입의 경우 nullable 이후에 meta 추가 (메타데이터가 최상위 레벨에 있어야 함)\n  if (isNumericSingleProp(prop) || isNumericArrayProp(prop)) {\n    stmt += '.meta({ SonamuPropType: \"numeric\" })';\n  }\n\n  return `${stmt},`;\n}\n\n/**\n * EntityPropNode를 Zod 타입 정의 코드 문자열로 변환합니다.\n * plain, array, object 노드 타입을 재귀적으로 처리하여 중첩 구조를 지원합니다.\n */\nexport function propNodeToZodTypeDef(propNode: EntityPropNode, injectImportKeys: string[]): string {\n  if (propNode.nodeType === \"plain\") {\n    return propToZodTypeDef(propNode.prop, injectImportKeys);\n  } else if (propNode.nodeType === \"array\") {\n    return [\n      propNode.prop ? `${propNode.prop.name}: ` : \"\",\n      \"z.array(z.object({\",\n      propNode.children\n        .map((childPropNode) => propNodeToZodTypeDef(childPropNode, injectImportKeys))\n        .join(\"\\n\"),\n      \"\",\n      \"})),\",\n    ].join(\"\\n\");\n  } else if (propNode.nodeType === \"object\") {\n    return [\n      propNode.prop ? `${propNode.prop.name}: ` : \"\",\n      \"z.object({\",\n      propNode.children\n        .map((childPropNode) => propNodeToZodTypeDef(childPropNode, injectImportKeys))\n        .join(\"\\n\"),\n      \"\",\n      `})${propNode.prop?.nullable ? \".nullable()\" : \"\"},`,\n    ].join(\"\\n\");\n  } else {\n    throw Error;\n  }\n}\n\nexport function zodTypeToTsTypeDef(zt: z.ZodType): string {\n  switch (zt.def.type) {\n    case \"string\":\n    case \"number\":\n    case \"boolean\":\n    case \"bigint\":\n    case \"date\":\n    case \"null\":\n    case \"undefined\":\n    case \"any\":\n    case \"unknown\":\n    case \"never\":\n      return zt.def.type;\n    case \"nullable\":\n      return `${zodTypeToTsTypeDef((zt as AnyZodNullable).def.innerType)} | null`;\n    case \"default\":\n      return zodTypeToTsTypeDef((zt as AnyZodDefault).def.innerType);\n    case \"record\": {\n      const recordType = zt as AnyZodRecord;\n      return `{ [ key: ${zodTypeToTsTypeDef(recordType.def.keyType)} ]: ${zodTypeToTsTypeDef(recordType.def.valueType)}}`;\n    }\n    case \"literal\":\n      return Array.from((zt as z.ZodLiteral).values)\n        .map((value) => {\n          if (typeof value === \"string\") {\n            return `\"${value}\"`;\n          }\n\n          if (value === null) {\n            return `null`;\n          }\n\n          if (value === undefined) {\n            return `undefined`;\n          }\n\n          return `${value}`;\n        })\n        .join(\" | \");\n    case \"union\":\n      return `${(zt as AnyZodUnion).options\n        .map((option) => zodTypeToTsTypeDef(option))\n        .join(\" | \")}`;\n    case \"enum\":\n      return `${(zt as z.ZodEnum).options.map((val) => `\"${val}\"`).join(\" | \")}`;\n    case \"array\":\n      return `${zodTypeToTsTypeDef((zt as AnyZodArray).element)}[]`;\n    case \"object\": {\n      const shape = (zt as AnyZodObject).shape;\n      return [\n        \"{\",\n        ...Object.keys(shape).map((key) => {\n          if (shape[key].def.type === \"optional\") {\n            return `${key}?: ${zodTypeToTsTypeDef(shape[key].def.innerType)},`;\n          } else {\n            return `${key}: ${zodTypeToTsTypeDef(shape[key])},`;\n          }\n        }),\n        \"}\",\n      ].join(\"\\n\");\n    }\n    case \"optional\":\n      return `${zodTypeToTsTypeDef((zt as AnyZodOptional).def.innerType)} | undefined`;\n    case \"template_literal\": {\n      const def = (zt as AnyZodTemplateLiteral).def;\n\n      // 빈 template literal은 string으로 폴백\n      if (!def.parts || def.parts.length === 0) {\n        return \"string\";\n      }\n\n      // 각 part를 TypeScript 타입 문자열로 변환\n      const parts = def.parts.map((part: unknown) => {\n        // 리터럴 값 (string, number, boolean, null, undefined)\n        if (typeof part === \"string\") {\n          return `${part}`;\n        }\n\n        // ZodType - 재귀적으로 변환\n        if (part && typeof part === \"object\" && (part as z.ZodType)._zod) {\n          const innerType = zodTypeToTsTypeDef(part as z.ZodType);\n          return `$\\{${innerType}}`;\n        }\n\n        // 폴백\n        return `\\${string}`;\n      });\n\n      return `\\`${parts.join(\"\")}\\``;\n    }\n    case \"file\":\n      return \"File\";\n    default:\n      throw new Error(`처리되지 않은 ZodType ${zt.def.type}`);\n  }\n}\n\n/**\n * Zod 타입 인스턴스를 해당하는 Zod 코드 문자열로 변환합니다.\n */\nexport function zodTypeToZodCode(zt: z.ZodType): string {\n  switch (zt.def.type) {\n    case \"string\":\n      return \"z.string()\";\n    case \"number\":\n      return \"z.number()\";\n    case \"bigint\":\n      return \"z.bigint()\";\n    case \"boolean\":\n      return \"z.boolean()\";\n    case \"date\":\n      return \"z.date()\";\n    case \"null\":\n      return \"z.null()\";\n    case \"undefined\":\n      return \"z.undefined()\";\n    case \"any\":\n      return \"z.any()\";\n    case \"unknown\":\n      return \"z.unknown()\";\n    case \"never\":\n      return \"z.never()\";\n    case \"nullable\":\n      return `${zodTypeToZodCode((zt as AnyZodNullable).def.innerType)}.nullable()`;\n    case \"default\": {\n      const zDefaultDef = (zt as AnyZodDefault).def;\n      return `${zodTypeToZodCode(zDefaultDef.innerType)}.default(${zDefaultDef.defaultValue})`;\n    }\n    case \"record\": {\n      const zRecordDef = (zt as AnyZodRecord).def;\n      return `z.record(${zodTypeToZodCode(zRecordDef.keyType)}, ${zodTypeToZodCode(\n        zRecordDef.valueType,\n      )})`;\n    }\n    case \"literal\": {\n      const items = Array.from((zt as z.ZodLiteral<string | number>).values).map((value) => {\n        if (typeof value === \"string\") {\n          return `\"${value}\"`;\n        }\n\n        if (value === null) {\n          return `null`;\n        }\n\n        if (value === undefined) {\n          return `undefined`;\n        }\n\n        return `${value}`;\n      });\n\n      if (items.length === 1) {\n        return `z.literal(${items[0]})`;\n      }\n      return `z.literal([${items.join(\", \")}])`;\n    }\n    case \"union\":\n      return `z.union([${(zt as AnyZodUnion).def.options\n        .map((option: z.ZodType) => zodTypeToZodCode(option))\n        .join(\",\")}])`;\n    case \"enum\":\n      // NOTE: z.enum([\"A\", \"B\"])도 z.enum({ A: \"A\", B: \"B\" })로 처리됨.\n      return `z.enum({${Object.entries((zt as z.ZodEnum).def.entries)\n        .map(([key, val]) => (typeof val === \"string\" ? `${key}: \"${val}\"` : `${key}: ${val}`))\n        .join(\", \")}})`;\n    case \"array\":\n      return `z.array(${zodTypeToZodCode((zt as z.ZodArray<z.ZodType>).def.element)})`;\n    case \"object\": {\n      const shape = (zt as AnyZodObject).shape;\n      return [\n        \"z.object({\",\n        ...Object.keys(shape).map((key) => `${key}: ${zodTypeToZodCode(shape[key])},`),\n        \"})\",\n      ].join(\"\\n\");\n    }\n    case \"optional\":\n      return `${zodTypeToZodCode((zt as z.ZodOptional<z.ZodType>).def.innerType)}.optional()`;\n    case \"file\":\n      return `z.file()`;\n    case \"template_literal\": {\n      const def = (zt as AnyZodTemplateLiteral).def;\n\n      // 빈 template literal\n      if (!def.parts || def.parts.length === 0) {\n        return \"z.templateLiteral([])\";\n      }\n\n      // 각 part를 Zod 코드 문자열로 변환\n      const parts = def.parts.map((part: unknown) => {\n        // 문자열 리터럴\n        if (typeof part === \"string\") {\n          return `\"${part}\"`;\n        }\n        // ZodType - 재귀적으로 변환\n        if (part && typeof part === \"object\" && (part as z.ZodType)._zod) {\n          return zodTypeToZodCode(part as z.ZodType);\n        }\n\n        // 폴백\n        return \"z.string()\";\n      });\n\n      return `z.templateLiteral([${parts.join(\", \")}])`;\n    }\n    case \"intersection\": {\n      const zIntersectionDef = (zt as z.ZodIntersection<z.ZodType, z.ZodType>).def;\n      return `z.intersection(${zodTypeToZodCode(zIntersectionDef.left)}, ${zodTypeToZodCode(zIntersectionDef.right)})`;\n    }\n    default:\n      throw new Error(`처리되지 않은 ZodType ${zt.def.type}`);\n  }\n}\n\n/**\n * Zod 타입을 UI 렌더링에 사용할 수 있는 RenderingNode로 변환합니다.\n * 재귀적으로 중첩된 타입들을 처리합니다.\n */\nexport function zodTypeToRenderingNode(\n  zodType: z.ZodTypeAny,\n  baseKey: string = \"root\",\n): RenderingNode {\n  const def = {\n    name: baseKey,\n    label: inflection.camelize(baseKey, false),\n    zodType,\n  };\n\n  /**\n   * 케이스 처리 순서\n   *\n   * 1. 특수 케이스 (description 기반)\n   *    - SonamuFile/SonamuFile[] : z.object/z.array이지만 파일 업로드용 내장 타입\n   *\n   * 2. 일반 케이스 (instanceof 기반)\n   *    - z.ZodObject : 일반 객체\n   *    - z.ZodArray : 일반 배열\n   *      - vector : z.array(z.number)이지만 네이밍 기반으로 벡터 임베딩\n   *      - 일반 배열 : 그 외\n   *    - z.ZodUnion, z.ZodOptional, z.ZodNullable : 유틸리티 타입\n   *    - 기타 : resolveRenderType()으로 처리\n   */\n\n  // 특수 케이스: SonamuFile[] 타입 감지\n  if (zodType.description === \"SonamuFile[]\") {\n    return { ...def, renderType: \"json-sonamufile-array\" };\n  }\n\n  // 특수 케이스: SonamuFile 단일 타입 감지\n  if (zodType.description === \"SonamuFile\") {\n    return { ...def, renderType: \"json-sonamufile\" };\n  }\n\n  // 일반 케이스: ZodObject 체크\n  if (zodType instanceof z.ZodObject) {\n    const columnKeys = Object.keys(zodType.shape);\n    const children = columnKeys.map((key) => {\n      const innerType = zodType.shape[key];\n      return zodTypeToRenderingNode(innerType, key);\n    });\n    return {\n      ...def,\n      renderType: \"object\",\n      children,\n    };\n  } else if (zodType instanceof z.ZodArray) {\n    const innerType = (zodType as z.ZodArray<z.ZodTypeAny>).def.element;\n    // vector 타입 판별: number 배열이면서 embedding, vector 등의 이름을 가진 경우\n    if (\n      innerType instanceof z.ZodNumber &&\n      (baseKey.includes(\"embedding\") || baseKey.includes(\"vector\"))\n    ) {\n      return {\n        ...def,\n        renderType: \"vector\",\n      };\n    }\n    return {\n      ...def,\n      renderType: \"array\",\n      element: zodTypeToRenderingNode(innerType, baseKey),\n    };\n  } else if (zodType instanceof z.ZodUnion) {\n    const optionNodes = (zodType as z.ZodUnion<z.ZodType[]>).def.options.map((opt) =>\n      zodTypeToRenderingNode(opt, baseKey),\n    );\n    // TODO: ZodUnion이 들어있는 경우 핸들링\n    return optionNodes[0];\n  } else if (zodType instanceof z.ZodOptional) {\n    return {\n      ...zodTypeToRenderingNode((zodType as z.ZodOptional<z.ZodType>).def.innerType, baseKey),\n      optional: true,\n    };\n  } else if (zodType instanceof z.ZodNullable) {\n    return {\n      ...zodTypeToRenderingNode((zodType as z.ZodNullable<z.ZodType>).def.innerType, baseKey),\n      nullable: true,\n    };\n  } else {\n    return {\n      ...def,\n      renderType: resolveRenderType(baseKey, zodType),\n    };\n  }\n}\n\n/**\n * Zod 타입과 키 이름으로부터 적절한 RenderType을 결정합니다.\n */\nfunction resolveRenderType(key: string, zodType: z.ZodTypeAny): RenderingNode[\"renderType\"] {\n  if (zodType instanceof z.ZodDate) {\n    return \"datetime\";\n  } else if (zodType instanceof z.core.$ZodString) {\n    // NOTE: z.ZodString으로 비교하면 z.url(), z.email() 등의 타입에서 문제가 생기므로 z.core.$ZodString으로 비교함\n    // FIXME: email이나 url 타입 등에 대한 처리가 필요함\n    if (zodType.description === \"SQLDateTimeString\") {\n      return \"string-datetime\";\n    } else if (key.endsWith(\"date\")) {\n      return \"string-date\";\n    } else if (key === \"id\") {\n      return \"string-id\";\n    } else if (key.endsWith(\"_id\")) {\n      return \"string-fk_id\";\n    } else {\n      return \"string-plain\";\n    }\n  } else if (zodType instanceof z.ZodNumber) {\n    if (key === \"id\") {\n      return \"number-id\";\n    } else if (key.endsWith(\"_id\")) {\n      return \"number-fk_id\";\n    } else {\n      return \"number-plain\";\n    }\n  } else if (zodType instanceof z.ZodBoolean) {\n    return \"boolean\";\n  } else if (zodType instanceof z.ZodEnum) {\n    return \"enums\";\n  } else if (zodType instanceof z.ZodRecord) {\n    return \"record\";\n  } else if (zodType instanceof z.ZodAny || zodType instanceof z.ZodUnknown) {\n    return \"string-plain\";\n  } else if (zodType instanceof z.ZodUnion) {\n    return \"string-plain\";\n  } else if (zodType instanceof z.ZodLiteral) {\n    return \"string-plain\";\n  } else if (zodType instanceof z.ZodTemplateLiteral) {\n    return \"string-plain\";\n  } else if (zodType.def.type === \"custom\") {\n    return \"object\";\n  } else {\n    throw new Error(`타입 파싱 불가 ${key} ${zodType.def.type}`);\n  }\n}\n"],"names":["inflection","path","z","Sonamu","EntityManager","BUILT_IN_TYPE_IDS","isBelongsToOneRelationProp","isBigIntegerArrayProp","isBigIntegerSingleProp","isBooleanArrayProp","isBooleanSingleProp","isDateArrayProp","isDateSingleProp","isEnumArrayProp","isEnumSingleProp","isIntegerArrayProp","isIntegerSingleProp","isJsonProp","isNumberArrayProp","isNumberSingleProp","isNumericArrayProp","isNumericSingleProp","isOneToOneRelationProp","isRelationProp","isSearchTextProp","isStringArrayProp","isStringSingleProp","isTsVectorProp","isUuidArrayProp","isUuidSingleProp","isVectorArrayProp","isVectorSingleProp","isVirtualProp","SonamuFileArraySchema","SonamuFileSchema","createImportUrl","runtimePath","BUILT_IN_TYPES","SonamuFile","schema","renderType","schemaName","zodFormatToCode","format","isoFormats","isoDate","isoTime","isoDatetime","isoDuration","hashFormats","hashMd5","hashSha1","hashSha256","hashSha384","hashSha512","zodFormatToType","iso","date","time","datetime","duration","hash","getZodTypeById","zodTypeId","includes","builtInType","Error","describe","modulePath","getModulePath","moduleAbsPath","join","apiRootPath","importUrl","imported","propToZodType","prop","zodType","unknown","number","int","array","bigint","id","zodFormat","length","max","string","elementType","boolean","uuid","hasJoinColumn","relEntity","get","with","pkType","getPkType","unsigned","nonnegative","nullable","propToZodTypeDef","injectImportKeys","stmt","name","push","base","relationType","propNodeToZodTypeDef","propNode","nodeType","children","map","childPropNode","zodTypeToTsTypeDef","zt","def","type","innerType","recordType","keyType","valueType","Array","from","values","value","undefined","options","option","val","element","shape","Object","keys","key","parts","part","_zod","zodTypeToZodCode","zDefaultDef","defaultValue","zRecordDef","items","entries","zIntersectionDef","left","right","zodTypeToRenderingNode","baseKey","label","camelize","description","ZodObject","columnKeys","ZodArray","ZodNumber","ZodUnion","optionNodes","opt","ZodOptional","optional","ZodNullable","resolveRenderType","ZodDate","core","$ZodString","endsWith","ZodBoolean","ZodEnum","ZodRecord","ZodAny","ZodUnknown","ZodLiteral","ZodTemplateLiteral"],"mappings":"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"}
+//#endregion
+init_zod_converter();
+export { BUILT_IN_TYPES, getZodTypeById, init_zod_converter, propNodeToZodTypeDef, propToZodType, propToZodTypeDef, zodTypeToRenderingNode, zodTypeToTsTypeDef, zodTypeToZodCode };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"zod-converter.js","names":["isoFormats: Record<string, string>","hashFormats: Record<string, string>","z","zodType: z.ZodTypeAny","elementType: z.ZodType","stmt: string"],"sources":["../../src/template/zod-converter.ts"],"sourcesContent":["/**\n * zod-converter 구성\n * 1. 유틸리티\n *  - getZodTypeById\n *\n * 2. Zod 타입 변환 (EntityProp -> ZodType)\n *  - propToZodType\n *\n * 3. EntityProp/Node -> Zod 코드 문자열\n *  - propToZodTypeDef\n *  - propNodeToZodTypeDef\n *\n * 4. Zod 타입 인스턴스를 해당하는 Zod 코드 문자열로 변환 (ZodType -> ZodCode)\n *  - zodTypeToZodCode\n *\n * 5. Zod 타입을 UI 렌더링에 사용할 수 있는 RenderingNode로 변환 (ZodType -> RenderingNode)\n *  - zodTypeToRenderingNode\n *  - resolveRenderType\n */\n\nimport path from \"path\";\n\nimport inflection from \"inflection\";\nimport { z } from \"zod\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport {\n  BUILT_IN_TYPE_IDS,\n  isBelongsToOneRelationProp,\n  isBigIntegerArrayProp,\n  isBigIntegerSingleProp,\n  isBooleanArrayProp,\n  isBooleanSingleProp,\n  isDateArrayProp,\n  isDateSingleProp,\n  isEnumArrayProp,\n  isEnumSingleProp,\n  isIntegerArrayProp,\n  isIntegerSingleProp,\n  isJsonProp,\n  isNumberArrayProp,\n  isNumberSingleProp,\n  isNumericArrayProp,\n  isNumericSingleProp,\n  isOneToOneRelationProp,\n  isRelationProp,\n  isSearchTextProp,\n  isStringArrayProp,\n  isStringSingleProp,\n  isTsVectorProp,\n  isUuidArrayProp,\n  isUuidSingleProp,\n  isVectorArrayProp,\n  isVectorSingleProp,\n  isVirtualProp,\n  SonamuFileArraySchema,\n  SonamuFileSchema,\n} from \"../types/types\";\nimport {\n  type EntityProp,\n  type EntityPropNode,\n  type RenderingNode,\n  type ZodStringFormat,\n} from \"../types/types\";\nimport { createImportUrl } from \"../utils/esm-utils\";\nimport { runtimePath } from \"../utils/path-utils\";\n\n// <any>를 자제하고, Zod에서 제약하는 기본적인 Generic Type Parameter를 사용함.\ntype AnyZodRecord = z.ZodRecord<z.ZodString | z.ZodNumber | z.ZodSymbol, z.ZodType>;\ntype AnyZodObject = z.ZodObject;\ntype AnyZodNullable = z.ZodNullable<z.ZodType>;\ntype AnyZodDefault = z.ZodDefault<z.ZodType>;\ntype AnyZodUnion = z.ZodUnion<z.ZodType[]>;\ntype AnyZodArray = z.ZodArray<z.ZodType>;\ntype AnyZodOptional = z.ZodOptional<z.ZodType>;\ntype AnyZodTemplateLiteral = z.ZodTemplateLiteral;\n\n/**\n * 내장 타입 정의 (Zod 스키마 + UI 렌더링 타입)\n */\nexport const BUILT_IN_TYPES = {\n  SonamuFile: {\n    schema: SonamuFileSchema,\n    renderType: \"json-sonamufile\",\n    schemaName: \"SonamuFileSchema\",\n  },\n  \"SonamuFile[]\": {\n    schema: SonamuFileArraySchema,\n    renderType: \"json-sonamufile-array\",\n    schemaName: \"SonamuFileArraySchema\",\n  },\n} as const;\n\n/**\n * zodFormat을 Zod 4 코드 문자열로 변환합니다.\n * Zod 4에서는 z.email(), z.uuid() 등 독립적인 함수 형태를 사용합니다.\n */\nfunction zodFormatToCode(format: ZodStringFormat): string {\n  // ISO 포맷은 z.iso.xxx() 형태\n  const isoFormats: Record<string, string> = {\n    isoDate: \"z.iso.date()\",\n    isoTime: \"z.iso.time()\",\n    isoDatetime: \"z.iso.datetime()\",\n    isoDuration: \"z.iso.duration()\",\n  };\n\n  // hash 포맷은 z.hash(\"algorithm\") 형태\n  const hashFormats: Record<string, string> = {\n    hashMd5: 'z.hash(\"md5\")',\n    hashSha1: 'z.hash(\"sha1\")',\n    hashSha256: 'z.hash(\"sha256\")',\n    hashSha384: 'z.hash(\"sha384\")',\n    hashSha512: 'z.hash(\"sha512\")',\n  };\n\n  if (format in isoFormats) {\n    return isoFormats[format];\n  }\n\n  if (format in hashFormats) {\n    return hashFormats[format];\n  }\n\n  // 기본 포맷은 z.xxx() 형태 (Zod 4)\n  return `z.${format}()`;\n}\n\n/**\n * zodFormat을 Zod 4 타입으로 변환합니다.\n * Zod 4에서는 z.email(), z.uuid() 등 독립적인 함수 형태를 사용합니다.\n */\nfunction zodFormatToType(format: ZodStringFormat): z.ZodType {\n  // ISO 포맷은 z.iso.xxx() 형태\n  switch (format) {\n    case \"isoDate\":\n      return z.iso.date();\n    case \"isoTime\":\n      return z.iso.time();\n    case \"isoDatetime\":\n      return z.iso.datetime();\n    case \"isoDuration\":\n      return z.iso.duration();\n    // hash 포맷은 z.hash(\"algorithm\") 형태\n    case \"hashMd5\":\n      return z.hash(\"md5\");\n    case \"hashSha1\":\n      return z.hash(\"sha1\");\n    case \"hashSha256\":\n      return z.hash(\"sha256\");\n    case \"hashSha384\":\n      return z.hash(\"sha384\");\n    case \"hashSha512\":\n      return z.hash(\"sha512\");\n    // 기본 포맷은 z.xxx() 형태 (Zod 4)\n    default:\n      return (z as unknown as Record<string, () => z.ZodType>)[format]();\n  }\n}\n\n/**\n * Zod 타입 ID로부터 동적으로 Zod 스키마를 로드합니다.\n * 내장 타입(BUILT_IN_TYPE_IDS)은 바로 반환하고,\n * 그 외는 dist 디렉토리에서 ESM으로 import하여 가져옵니다.\n */\nexport async function getZodTypeById(zodTypeId: string): Promise<z.ZodTypeAny> {\n  // 내장 타입 처리\n  if ((BUILT_IN_TYPE_IDS as readonly string[]).includes(zodTypeId)) {\n    const builtInType = BUILT_IN_TYPES[zodTypeId as keyof typeof BUILT_IN_TYPES];\n    if (!builtInType) {\n      throw new Error(`내장 타입 ${zodTypeId}의 스키마가 정의되지 않았습니다`);\n    }\n    return builtInType.schema.describe(zodTypeId);\n  }\n\n  // 프로젝트에서 정의한 타입 동적 로드\n  const modulePath = EntityManager.getModulePath(zodTypeId);\n  const moduleAbsPath = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(`dist/application/${modulePath}.js`),\n  );\n  const importUrl = createImportUrl(moduleAbsPath);\n  const imported = await import(importUrl);\n\n  if (!imported[zodTypeId]) {\n    throw new Error(`존재하지 않는 zodTypeId ${zodTypeId}`);\n  }\n  return imported[zodTypeId].describe(zodTypeId);\n}\n\n/**\n * EntityProp을 Zod 타입으로 변환합니다.\n * 각 prop의 타입에 따라 적절한 Zod validator를 생성합니다.\n */\nexport async function propToZodType(prop: EntityProp): Promise<z.ZodTypeAny> {\n  let zodType: z.ZodTypeAny = z.unknown();\n  if (isIntegerSingleProp(prop)) {\n    zodType = z.number().int();\n  } else if (isIntegerArrayProp(prop)) {\n    zodType = z.number().int().array();\n  } else if (isBigIntegerSingleProp(prop)) {\n    zodType = z.bigint();\n  } else if (isBigIntegerArrayProp(prop)) {\n    zodType = z.bigint().array();\n  } else if (isEnumSingleProp(prop)) {\n    zodType = await getZodTypeById(prop.id);\n  } else if (isEnumArrayProp(prop)) {\n    zodType = (await getZodTypeById(prop.id)).array();\n  } else if (isStringSingleProp(prop)) {\n    if (prop.zodFormat) {\n      zodType = zodFormatToType(prop.zodFormat);\n      if (prop.length && \"max\" in zodType) {\n        zodType = (zodType as z.ZodString).max(prop.length);\n      }\n    } else if (prop.length) {\n      zodType = z.string().max(prop.length);\n    } else {\n      zodType = z.string();\n    }\n  } else if (isStringArrayProp(prop)) {\n    let elementType: z.ZodType;\n    if (prop.zodFormat) {\n      elementType = zodFormatToType(prop.zodFormat);\n      if (prop.length && \"max\" in elementType) {\n        elementType = (elementType as z.ZodString).max(prop.length);\n      }\n    } else if (prop.length) {\n      elementType = z.string().max(prop.length);\n    } else {\n      elementType = z.string();\n    }\n    zodType = elementType.array();\n  } else if (isNumberSingleProp(prop)) {\n    zodType = z.number();\n  } else if (isNumberArrayProp(prop)) {\n    zodType = z.number().array();\n  } else if (isNumericSingleProp(prop)) {\n    zodType = z.string();\n  } else if (isNumericArrayProp(prop)) {\n    zodType = z.string().array();\n  } else if (isBooleanSingleProp(prop)) {\n    zodType = z.boolean();\n  } else if (isBooleanArrayProp(prop)) {\n    zodType = z.boolean().array();\n  } else if (isDateSingleProp(prop)) {\n    zodType = z.date();\n  } else if (isDateArrayProp(prop)) {\n    zodType = z.date().array();\n  } else if (isUuidSingleProp(prop)) {\n    zodType = z.uuid();\n  } else if (isUuidArrayProp(prop)) {\n    zodType = z.uuid().array();\n  } else if (isJsonProp(prop)) {\n    zodType = await getZodTypeById(prop.id);\n  } else if (isSearchTextProp(prop)) {\n    zodType = z.string();\n  } else if (isVectorSingleProp(prop)) {\n    zodType = z.array(z.number());\n  } else if (isVectorArrayProp(prop)) {\n    zodType = z.array(z.array(z.number()));\n  } else if (isVirtualProp(prop)) {\n    zodType = await getZodTypeById(prop.id);\n  } else if (isRelationProp(prop)) {\n    if (isBelongsToOneRelationProp(prop) || (isOneToOneRelationProp(prop) && prop.hasJoinColumn)) {\n      // FK 타입을 참조 엔티티 PK 타입에 따라 결정\n      const relEntity = EntityManager.get(prop.with);\n      const pkType = relEntity.getPkType();\n      if (pkType === \"string\" || pkType === \"uuid\") {\n        zodType = z.string();\n      } else {\n        zodType = z.number().int();\n      }\n    }\n  } else {\n    throw new Error(`prop을 zodType으로 변환하는데 실패 ${prop}}`);\n  }\n\n  if ((prop as { unsigned?: boolean }).unsigned) {\n    zodType = (zodType as z.ZodNumber).nonnegative();\n  }\n  if (prop.nullable) {\n    zodType = zodType.nullable();\n  }\n\n  return zodType;\n}\n\n/**\n * EntityProp을 Zod 타입 정의 코드 문자열로 변환합니다.\n */\nexport function propToZodTypeDef(prop: EntityProp, injectImportKeys: string[]): string {\n  let stmt: string;\n  if (isIntegerSingleProp(prop)) {\n    stmt = `${prop.name}: z.int()`;\n  } else if (isIntegerArrayProp(prop)) {\n    stmt = `${prop.name}: z.int().array()`;\n  } else if (isBigIntegerSingleProp(prop)) {\n    stmt = `${prop.name}: z.bigint()`;\n  } else if (isBigIntegerArrayProp(prop)) {\n    stmt = `${prop.name}: z.bigint().array()`;\n  } else if (isEnumSingleProp(prop)) {\n    stmt = `${prop.name}: ${prop.id}`;\n    injectImportKeys.push(prop.id);\n  } else if (isEnumArrayProp(prop)) {\n    stmt = `${prop.name}: ${prop.id}.array()`;\n    injectImportKeys.push(prop.id);\n  } else if (isStringSingleProp(prop)) {\n    if (prop.zodFormat) {\n      const base = zodFormatToCode(prop.zodFormat);\n      if (prop.length) {\n        stmt = `${prop.name}: ${base}.max(${prop.length})`;\n      } else {\n        stmt = `${prop.name}: ${base}`;\n      }\n    } else if (prop.length) {\n      stmt = `${prop.name}: z.string().max(${prop.length})`;\n    } else {\n      stmt = `${prop.name}: z.string()`;\n    }\n  } else if (isStringArrayProp(prop)) {\n    if (prop.zodFormat) {\n      const base = zodFormatToCode(prop.zodFormat);\n      if (prop.length) {\n        stmt = `${prop.name}: ${base}.max(${prop.length}).array()`;\n      } else {\n        stmt = `${prop.name}: ${base}.array()`;\n      }\n    } else if (prop.length) {\n      stmt = `${prop.name}: z.string().max(${prop.length}).array()`;\n    } else {\n      stmt = `${prop.name}: z.string().array()`;\n    }\n  } else if (isNumberSingleProp(prop)) {\n    stmt = `${prop.name}: z.number()`;\n  } else if (isNumberArrayProp(prop)) {\n    stmt = `${prop.name}: z.number().array()`;\n  } else if (isNumericSingleProp(prop)) {\n    stmt = `${prop.name}: z.string()`;\n  } else if (isNumericArrayProp(prop)) {\n    stmt = `${prop.name}: z.string().array()`;\n  } else if (isDateSingleProp(prop)) {\n    stmt = `${prop.name}: z.date()`;\n  } else if (isDateArrayProp(prop)) {\n    stmt = `${prop.name}: z.date().array()`;\n  } else if (isBooleanSingleProp(prop)) {\n    stmt = `${prop.name}: z.boolean()`;\n  } else if (isBooleanArrayProp(prop)) {\n    stmt = `${prop.name}: z.boolean().array()`;\n  } else if (isUuidSingleProp(prop)) {\n    stmt = `${prop.name}: z.uuid()`;\n  } else if (isUuidArrayProp(prop)) {\n    stmt = `${prop.name}: z.uuid().array()`;\n  } else if (isJsonProp(prop)) {\n    // 내장 타입인 경우 스키마 이름으로 변환\n    if ((BUILT_IN_TYPE_IDS as readonly string[]).includes(prop.id)) {\n      const schemaName = prop.id === \"SonamuFile\" ? \"SonamuFileSchema\" : \"SonamuFileArraySchema\";\n      stmt = `${prop.name}: ${schemaName}`;\n      injectImportKeys.push(schemaName);\n    } else {\n      stmt = `${prop.name}: ${prop.id}`;\n      injectImportKeys.push(prop.id);\n    }\n  } else if (isSearchTextProp(prop)) {\n    stmt = `${prop.name}: z.string()`;\n  } else if (isVectorSingleProp(prop)) {\n    stmt = `${prop.name}: z.array(z.number())`;\n  } else if (isVectorArrayProp(prop)) {\n    stmt = `${prop.name}: z.array(z.array(z.number()))`;\n  } else if (isTsVectorProp(prop)) {\n    stmt = `${prop.name}: z.string()`;\n  } else if (isVirtualProp(prop)) {\n    stmt = `${prop.name}: ${prop.id}`;\n    injectImportKeys.push(prop.id);\n  } else if (isRelationProp(prop)) {\n    if (isBelongsToOneRelationProp(prop) || (isOneToOneRelationProp(prop) && prop.hasJoinColumn)) {\n      // FK Zod 타입을 참조 엔티티 PK 타입에 따라 결정\n      const relEntity = EntityManager.get(prop.with);\n      const pkType = relEntity.getPkType();\n      if (pkType === \"string\" || pkType === \"uuid\") {\n        stmt = `${prop.name}_id: z.string()`;\n      } else {\n        stmt = `${prop.name}_id: z.int()`;\n      }\n    } else {\n      // 그외 relation 케이스 제외\n      return `// ${prop.name}: ${prop.relationType} ${prop.with}`;\n    }\n  } else {\n    return \"// unable to resolve\";\n  }\n\n  if ((prop as { unsigned?: boolean }).unsigned) {\n    stmt += \".nonnegative()\";\n  }\n  if (prop.nullable) {\n    stmt += \".nullable()\";\n  }\n\n  // numeric 타입의 경우 nullable 이후에 meta 추가 (메타데이터가 최상위 레벨에 있어야 함)\n  if (isNumericSingleProp(prop) || isNumericArrayProp(prop)) {\n    stmt += '.meta({ SonamuPropType: \"numeric\" })';\n  }\n\n  return `${stmt},`;\n}\n\n/**\n * EntityPropNode를 Zod 타입 정의 코드 문자열로 변환합니다.\n * plain, array, object 노드 타입을 재귀적으로 처리하여 중첩 구조를 지원합니다.\n */\nexport function propNodeToZodTypeDef(propNode: EntityPropNode, injectImportKeys: string[]): string {\n  if (propNode.nodeType === \"plain\") {\n    return propToZodTypeDef(propNode.prop, injectImportKeys);\n  } else if (propNode.nodeType === \"array\") {\n    return [\n      propNode.prop ? `${propNode.prop.name}: ` : \"\",\n      \"z.array(z.object({\",\n      propNode.children\n        .map((childPropNode) => propNodeToZodTypeDef(childPropNode, injectImportKeys))\n        .join(\"\\n\"),\n      \"\",\n      \"})),\",\n    ].join(\"\\n\");\n  } else if (propNode.nodeType === \"object\") {\n    return [\n      propNode.prop ? `${propNode.prop.name}: ` : \"\",\n      \"z.object({\",\n      propNode.children\n        .map((childPropNode) => propNodeToZodTypeDef(childPropNode, injectImportKeys))\n        .join(\"\\n\"),\n      \"\",\n      `})${propNode.prop?.nullable ? \".nullable()\" : \"\"},`,\n    ].join(\"\\n\");\n  } else {\n    throw Error;\n  }\n}\n\nexport function zodTypeToTsTypeDef(zt: z.ZodType): string {\n  switch (zt.def.type) {\n    case \"string\":\n    case \"number\":\n    case \"boolean\":\n    case \"bigint\":\n    case \"date\":\n    case \"null\":\n    case \"undefined\":\n    case \"any\":\n    case \"unknown\":\n    case \"never\":\n      return zt.def.type;\n    case \"nullable\":\n      return `${zodTypeToTsTypeDef((zt as AnyZodNullable).def.innerType)} | null`;\n    case \"default\":\n      return zodTypeToTsTypeDef((zt as AnyZodDefault).def.innerType);\n    case \"record\": {\n      const recordType = zt as AnyZodRecord;\n      return `{ [ key: ${zodTypeToTsTypeDef(recordType.def.keyType)} ]: ${zodTypeToTsTypeDef(recordType.def.valueType)}}`;\n    }\n    case \"literal\":\n      return Array.from((zt as z.ZodLiteral).values)\n        .map((value) => {\n          if (typeof value === \"string\") {\n            return `\"${value}\"`;\n          }\n\n          if (value === null) {\n            return `null`;\n          }\n\n          if (value === undefined) {\n            return `undefined`;\n          }\n\n          return `${value}`;\n        })\n        .join(\" | \");\n    case \"union\":\n      return `${(zt as AnyZodUnion).options\n        .map((option) => zodTypeToTsTypeDef(option))\n        .join(\" | \")}`;\n    case \"enum\":\n      return `${(zt as z.ZodEnum).options.map((val) => `\"${val}\"`).join(\" | \")}`;\n    case \"array\":\n      return `${zodTypeToTsTypeDef((zt as AnyZodArray).element)}[]`;\n    case \"object\": {\n      const shape = (zt as AnyZodObject).shape;\n      return [\n        \"{\",\n        ...Object.keys(shape).map((key) => {\n          if (shape[key].def.type === \"optional\") {\n            return `${key}?: ${zodTypeToTsTypeDef(shape[key].def.innerType)},`;\n          } else {\n            return `${key}: ${zodTypeToTsTypeDef(shape[key])},`;\n          }\n        }),\n        \"}\",\n      ].join(\"\\n\");\n    }\n    case \"optional\":\n      return `${zodTypeToTsTypeDef((zt as AnyZodOptional).def.innerType)} | undefined`;\n    case \"template_literal\": {\n      const def = (zt as AnyZodTemplateLiteral).def;\n\n      // 빈 template literal은 string으로 폴백\n      if (!def.parts || def.parts.length === 0) {\n        return \"string\";\n      }\n\n      // 각 part를 TypeScript 타입 문자열로 변환\n      const parts = def.parts.map((part: unknown) => {\n        // 리터럴 값 (string, number, boolean, null, undefined)\n        if (typeof part === \"string\") {\n          return `${part}`;\n        }\n\n        // ZodType - 재귀적으로 변환\n        if (part && typeof part === \"object\" && (part as z.ZodType)._zod) {\n          const innerType = zodTypeToTsTypeDef(part as z.ZodType);\n          return `$\\{${innerType}}`;\n        }\n\n        // 폴백\n        return `\\${string}`;\n      });\n\n      return `\\`${parts.join(\"\")}\\``;\n    }\n    case \"file\":\n      return \"File\";\n    default:\n      throw new Error(`처리되지 않은 ZodType ${zt.def.type}`);\n  }\n}\n\n/**\n * Zod 타입 인스턴스를 해당하는 Zod 코드 문자열로 변환합니다.\n */\nexport function zodTypeToZodCode(zt: z.ZodType): string {\n  switch (zt.def.type) {\n    case \"string\":\n      return \"z.string()\";\n    case \"number\":\n      return \"z.number()\";\n    case \"bigint\":\n      return \"z.bigint()\";\n    case \"boolean\":\n      return \"z.boolean()\";\n    case \"date\":\n      return \"z.date()\";\n    case \"null\":\n      return \"z.null()\";\n    case \"undefined\":\n      return \"z.undefined()\";\n    case \"any\":\n      return \"z.any()\";\n    case \"unknown\":\n      return \"z.unknown()\";\n    case \"never\":\n      return \"z.never()\";\n    case \"nullable\":\n      return `${zodTypeToZodCode((zt as AnyZodNullable).def.innerType)}.nullable()`;\n    case \"default\": {\n      const zDefaultDef = (zt as AnyZodDefault).def;\n      return `${zodTypeToZodCode(zDefaultDef.innerType)}.default(${zDefaultDef.defaultValue})`;\n    }\n    case \"record\": {\n      const zRecordDef = (zt as AnyZodRecord).def;\n      return `z.record(${zodTypeToZodCode(zRecordDef.keyType)}, ${zodTypeToZodCode(\n        zRecordDef.valueType,\n      )})`;\n    }\n    case \"literal\": {\n      const items = Array.from((zt as z.ZodLiteral<string | number>).values).map((value) => {\n        if (typeof value === \"string\") {\n          return `\"${value}\"`;\n        }\n\n        if (value === null) {\n          return `null`;\n        }\n\n        if (value === undefined) {\n          return `undefined`;\n        }\n\n        return `${value}`;\n      });\n\n      if (items.length === 1) {\n        return `z.literal(${items[0]})`;\n      }\n      return `z.literal([${items.join(\", \")}])`;\n    }\n    case \"union\":\n      return `z.union([${(zt as AnyZodUnion).def.options\n        .map((option: z.ZodType) => zodTypeToZodCode(option))\n        .join(\",\")}])`;\n    case \"enum\":\n      // NOTE: z.enum([\"A\", \"B\"])도 z.enum({ A: \"A\", B: \"B\" })로 처리됨.\n      return `z.enum({${Object.entries((zt as z.ZodEnum).def.entries)\n        .map(([key, val]) => (typeof val === \"string\" ? `${key}: \"${val}\"` : `${key}: ${val}`))\n        .join(\", \")}})`;\n    case \"array\":\n      return `z.array(${zodTypeToZodCode((zt as z.ZodArray<z.ZodType>).def.element)})`;\n    case \"object\": {\n      const shape = (zt as AnyZodObject).shape;\n      return [\n        \"z.object({\",\n        ...Object.keys(shape).map((key) => `${key}: ${zodTypeToZodCode(shape[key])},`),\n        \"})\",\n      ].join(\"\\n\");\n    }\n    case \"optional\":\n      return `${zodTypeToZodCode((zt as z.ZodOptional<z.ZodType>).def.innerType)}.optional()`;\n    case \"file\":\n      return `z.file()`;\n    case \"template_literal\": {\n      const def = (zt as AnyZodTemplateLiteral).def;\n\n      // 빈 template literal\n      if (!def.parts || def.parts.length === 0) {\n        return \"z.templateLiteral([])\";\n      }\n\n      // 각 part를 Zod 코드 문자열로 변환\n      const parts = def.parts.map((part: unknown) => {\n        // 문자열 리터럴\n        if (typeof part === \"string\") {\n          return `\"${part}\"`;\n        }\n        // ZodType - 재귀적으로 변환\n        if (part && typeof part === \"object\" && (part as z.ZodType)._zod) {\n          return zodTypeToZodCode(part as z.ZodType);\n        }\n\n        // 폴백\n        return \"z.string()\";\n      });\n\n      return `z.templateLiteral([${parts.join(\", \")}])`;\n    }\n    case \"intersection\": {\n      const zIntersectionDef = (zt as z.ZodIntersection<z.ZodType, z.ZodType>).def;\n      return `z.intersection(${zodTypeToZodCode(zIntersectionDef.left)}, ${zodTypeToZodCode(zIntersectionDef.right)})`;\n    }\n    default:\n      throw new Error(`처리되지 않은 ZodType ${zt.def.type}`);\n  }\n}\n\n/**\n * Zod 타입을 UI 렌더링에 사용할 수 있는 RenderingNode로 변환합니다.\n * 재귀적으로 중첩된 타입들을 처리합니다.\n */\nexport function zodTypeToRenderingNode(\n  zodType: z.ZodTypeAny,\n  baseKey: string = \"root\",\n): RenderingNode {\n  const def = {\n    name: baseKey,\n    label: inflection.camelize(baseKey, false),\n    zodType,\n  };\n\n  /**\n   * 케이스 처리 순서\n   *\n   * 1. 특수 케이스 (description 기반)\n   *    - SonamuFile/SonamuFile[] : z.object/z.array이지만 파일 업로드용 내장 타입\n   *\n   * 2. 일반 케이스 (instanceof 기반)\n   *    - z.ZodObject : 일반 객체\n   *    - z.ZodArray : 일반 배열\n   *      - vector : z.array(z.number)이지만 네이밍 기반으로 벡터 임베딩\n   *      - 일반 배열 : 그 외\n   *    - z.ZodUnion, z.ZodOptional, z.ZodNullable : 유틸리티 타입\n   *    - 기타 : resolveRenderType()으로 처리\n   */\n\n  // 특수 케이스: SonamuFile[] 타입 감지\n  if (zodType.description === \"SonamuFile[]\") {\n    return { ...def, renderType: \"json-sonamufile-array\" };\n  }\n\n  // 특수 케이스: SonamuFile 단일 타입 감지\n  if (zodType.description === \"SonamuFile\") {\n    return { ...def, renderType: \"json-sonamufile\" };\n  }\n\n  // 일반 케이스: ZodObject 체크\n  if (zodType instanceof z.ZodObject) {\n    const columnKeys = Object.keys(zodType.shape);\n    const children = columnKeys.map((key) => {\n      const innerType = zodType.shape[key];\n      return zodTypeToRenderingNode(innerType, key);\n    });\n    return {\n      ...def,\n      renderType: \"object\",\n      children,\n    };\n  } else if (zodType instanceof z.ZodArray) {\n    const innerType = (zodType as z.ZodArray<z.ZodTypeAny>).def.element;\n    // vector 타입 판별: number 배열이면서 embedding, vector 등의 이름을 가진 경우\n    if (\n      innerType instanceof z.ZodNumber &&\n      (baseKey.includes(\"embedding\") || baseKey.includes(\"vector\"))\n    ) {\n      return {\n        ...def,\n        renderType: \"vector\",\n      };\n    }\n    return {\n      ...def,\n      renderType: \"array\",\n      element: zodTypeToRenderingNode(innerType, baseKey),\n    };\n  } else if (zodType instanceof z.ZodUnion) {\n    const optionNodes = (zodType as z.ZodUnion<z.ZodType[]>).def.options.map((opt) =>\n      zodTypeToRenderingNode(opt, baseKey),\n    );\n    // TODO: ZodUnion이 들어있는 경우 핸들링\n    return optionNodes[0];\n  } else if (zodType instanceof z.ZodOptional) {\n    return {\n      ...zodTypeToRenderingNode((zodType as z.ZodOptional<z.ZodType>).def.innerType, baseKey),\n      optional: true,\n    };\n  } else if (zodType instanceof z.ZodNullable) {\n    return {\n      ...zodTypeToRenderingNode((zodType as z.ZodNullable<z.ZodType>).def.innerType, baseKey),\n      nullable: true,\n    };\n  } else {\n    return {\n      ...def,\n      renderType: resolveRenderType(baseKey, zodType),\n    };\n  }\n}\n\n/**\n * Zod 타입과 키 이름으로부터 적절한 RenderType을 결정합니다.\n */\nfunction resolveRenderType(key: string, zodType: z.ZodTypeAny): RenderingNode[\"renderType\"] {\n  if (zodType instanceof z.ZodDate) {\n    return \"datetime\";\n  } else if (zodType instanceof z.core.$ZodString) {\n    // NOTE: z.ZodString으로 비교하면 z.url(), z.email() 등의 타입에서 문제가 생기므로 z.core.$ZodString으로 비교함\n    // FIXME: email이나 url 타입 등에 대한 처리가 필요함\n    if (zodType.description === \"SQLDateTimeString\") {\n      return \"string-datetime\";\n    } else if (key.endsWith(\"date\")) {\n      return \"string-date\";\n    } else if (key === \"id\") {\n      return \"string-id\";\n    } else if (key.endsWith(\"_id\")) {\n      return \"string-fk_id\";\n    } else {\n      return \"string-plain\";\n    }\n  } else if (zodType instanceof z.ZodNumber) {\n    if (key === \"id\") {\n      return \"number-id\";\n    } else if (key.endsWith(\"_id\")) {\n      return \"number-fk_id\";\n    } else {\n      return \"number-plain\";\n    }\n  } else if (zodType instanceof z.ZodBoolean) {\n    return \"boolean\";\n  } else if (zodType instanceof z.ZodEnum) {\n    return \"enums\";\n  } else if (zodType instanceof z.ZodRecord) {\n    return \"record\";\n  } else if (zodType instanceof z.ZodAny || zodType instanceof z.ZodUnknown) {\n    return \"string-plain\";\n  } else if (zodType instanceof z.ZodUnion) {\n    return \"string-plain\";\n  } else if (zodType instanceof z.ZodLiteral) {\n    return \"string-plain\";\n  } else if (zodType instanceof z.ZodTemplateLiteral) {\n    return \"string-plain\";\n  } else if (zodType.def.type === \"custom\") {\n    return \"object\";\n  } else {\n    throw new Error(`타입 파싱 불가 ${key} ${zodType.def.type}`);\n  }\n}\n"],"mappings":"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"}