sonamu 0.8.26 → 0.9.0

package/dist/template/implementations/generated_http.template.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import type { ExtendedApi } from "../../api/decorators";
+import { type ExtendedApi } from "../../api/decorators";
 import { Template } from "../template";
 export declare class Template__generated_http extends Template {
     constructor();
@@ -14,7 +14,7 @@ export declare class Template__generated_http extends Template {
         target: string;
         path: string;
     }>;
-    zodTypeToReqDefault(zodType: z.ZodType<unknown>, name: string): unknown;
+    zodTypeToReqDefault(zodType: z.ZodType, name: string): unknown;
     resolveApiParams(api: ExtendedApi, references: {
         [typeName: string]: z.ZodType;
     }): {

package/dist/template/implementations/generated_http.template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generated_http.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/generated_http.template.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,wBAAyB,SAAQ,QAAQ;;IAKpD,gBAAgB;;;;IASV,MAAM;;;;;;;IA+CZ,mBAAmB,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;IAiEvE,gBAAgB,CACd,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAA;KAAE,GAC5C;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE;CAY9B"}
+{"version":3,"file":"generated_http.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/generated_http.template.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,wBAAyB,SAAQ,QAAQ;;IAKpD,gBAAgB;;;;IASV,MAAM;;;;;;;IA+CZ,mBAAmB,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;IAiE9D,gBAAgB,CACd,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAA;KAAE,GAC5C;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE;CAc9B"}

package/dist/template/implementations/generated_http.template.js

@@ -1,135 +1,116 @@
+import { Sonamu, init_sonamu } from "../../api/sonamu.js";
+import { getZodObjectFromApi, init_code_converters } from "../../api/code-converters.js";
+import { Template, init_template } from "../template.js";
+import { z as z$1 } from "zod";
 import qs from "qs";
-import { z } from "zod";
-import { getZodObjectFromApi } from "../../api/code-converters.js";
-import { Sonamu } from "../../api/sonamu.js";
-import { Template } from "../template.js";
-export class Template__generated_http extends Template {
-    constructor(){
-        super("generated_http");
-    }
-    getTargetAndPath() {
-        const { dir } = Sonamu.config.api;
-        return {
-            target: `${dir}/src/application`,
-            path: `sonamu.generated.http`
-        };
-    }
-    async render() {
-        const { syncer: { types, apis }, config: { api: { route: { prefix } } } } = Sonamu;
-        const lines = await Promise.all(apis.map(async (api)=>{
-            const reqObject = this.resolveApiParams(api, types);
-            const dataLines = await (async ()=>{
-                if ((api.options.httpMethod ?? "GET") === "GET") {
-                    return {
-                        querystring: [
-                            qs.stringify(reqObject, {
-                                encode: false
-                            }).split("&").join("\n\t&")
-                        ],
-                        body: []
-                    };
-                } else {
-                    return {
-                        querystring: [],
-                        body: [
-                            "",
-                            JSON.stringify(reqObject, null, 2)
-                        ]
-                    };
-                }
-            })();
-            return [
-                [
-                    `${api.options.httpMethod ?? "GET"} {{baseUrl}}${prefix}${api.path}`,
-                    ...dataLines.querystring
-                ].join("\n\t?"),
-                `Content-Type: ${api.options.contentType ?? "application/json"}`,
-                ...dataLines.body
-            ].join("\n");
-        }));
-        return {
-            ...this.getTargetAndPath(),
-            body: lines.join("\n\n###\n\n"),
-            importKeys: [],
-            customHeaders: [
-                "# @generated",
-                "# 직접 수정하지 마세요."
-            ]
-        };
-    }
-    zodTypeToReqDefault(zodType, name) {
-        if (zodType instanceof z.ZodObject) {
-            return Object.fromEntries(Object.keys(zodType.shape).map((key)=>[
-                    key,
-                    this.zodTypeToReqDefault(zodType.shape[key], key)
-                ]));
-        } else if (zodType instanceof z.ZodArray) {
-            return [
-                this.zodTypeToReqDefault(zodType.element, name)
-            ];
-        } else if (zodType instanceof z.core.$ZodString) {
-            // NOTE: z.ZodString으로 비교하면 z.url(), z.email() 등의 타입에서 문제가 생기므로 z.core.$ZodString으로 비교함
-            if (name.endsWith("_at") || name.endsWith("_date") || name === "range") {
-                return "2000-01-01";
-            } else {
-                return name.toUpperCase();
-            }
-        } else if (zodType instanceof z.ZodNumber) {
-            if (name === "num") {
-                return 24;
-            }
-            const minValue = zodType.minValue ?? 0;
-            return minValue > Number.MIN_SAFE_INTEGER ? minValue : 0;
-        } else if (zodType instanceof z.ZodBoolean) {
-            return false;
-        } else if (zodType instanceof z.ZodEnum) {
-            return zodType.options[0];
-        } else if (zodType instanceof z.ZodOptional) {
-            return this.zodTypeToReqDefault(zodType.def.innerType, name);
-        } else if (zodType instanceof z.ZodNullable) {
-            return null;
-        } else if (zodType instanceof z.ZodUnion) {
-            return this.zodTypeToReqDefault(zodType.def.options[0], name);
-        } else if (zodType instanceof z.ZodUnknown) {
-            return "unknown";
-        } else if (zodType instanceof z.ZodTuple) {
-            /** biome-ignore lint/suspicious/noExplicitAny: ZodTuple 타입 사용 */ return zodType.def.items.map((item)=>this.zodTypeToReqDefault(item, name));
-        } else if (zodType instanceof z.ZodDate) {
-            return "2000-01-01";
-        } else if (zodType instanceof z.ZodLiteral) {
-            return zodType.value;
-        } else if (zodType instanceof z.ZodRecord || zodType instanceof z.ZodMap) {
-            // biome-ignore lint/suspicious/noExplicitAny: ZodRecord 타입 사용
-            const kvDef = zodType.def;
-            // biome-ignore lint/suspicious/noExplicitAny: ZodIntersection 타입 사용
-            const key = this.zodTypeToReqDefault(kvDef.keyType, name);
-            const value = this.zodTypeToReqDefault(kvDef.valueType, name);
-            return {
-                [key]: value
-            };
-        } else if (zodType instanceof z.ZodSet) {
-            return [
-                this.zodTypeToReqDefault(zodType.def.valueType, name)
-            ];
-        } else if (zodType instanceof z.ZodIntersection) {
-            return this.zodTypeToReqDefault(zodType.def.right, name);
-        } else if (zodType instanceof z.ZodDefault) {
-            return this.zodTypeToReqDefault(zodType.def.innerType, name);
-        } else {
-            // console.log(zodType);
-            return `unknown-${zodType.type}`;
-        }
-    }
-    resolveApiParams(api, references) {
-        const reqType = getZodObjectFromApi(api, references);
-        try {
-            const def = this.zodTypeToReqDefault(reqType, "unknownName");
-            return def;
-        } catch (error) {
-            console.error(error);
-            throw new Error(`Invalid zod type detected on ${api.modelName}:${api.methodName}`);
-        }
-    }
-}
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/generated_http.template.ts"],"sourcesContent":["import qs from \"qs\";\nimport { z } from \"zod\";\nimport { getZodObjectFromApi } from \"../../api/code-converters\";\nimport type { ExtendedApi } from \"../../api/decorators\";\nimport { Sonamu } from \"../../api/sonamu\";\nimport { Template } from \"../template\";\n\nexport class Template__generated_http extends Template {\n  constructor() {\n    super(\"generated_http\");\n  }\n\n  getTargetAndPath() {\n    const { dir } = Sonamu.config.api;\n\n    return {\n      target: `${dir}/src/application`,\n      path: `sonamu.generated.http`,\n    };\n  }\n\n  async render() {\n    const {\n      syncer: { types, apis },\n      config: {\n        api: {\n          route: { prefix },\n        },\n      },\n    } = Sonamu;\n\n    const lines = await Promise.all(\n      apis.map(async (api) => {\n        const reqObject = this.resolveApiParams(api, types);\n\n        const dataLines = await (async () => {\n          if ((api.options.httpMethod ?? \"GET\") === \"GET\") {\n            return {\n              querystring: [qs.stringify(reqObject, { encode: false }).split(\"&\").join(\"\\n\\t&\")],\n              body: [],\n            };\n          } else {\n            return {\n              querystring: [],\n              body: [\"\", JSON.stringify(reqObject, null, 2)],\n            };\n          }\n        })();\n\n        return [\n          [\n            `${api.options.httpMethod ?? \"GET\"} {{baseUrl}}${prefix}${api.path}`,\n            ...dataLines.querystring,\n          ].join(\"\\n\\t?\"),\n          `Content-Type: ${api.options.contentType ?? \"application/json\"}`,\n          ...dataLines.body,\n        ].join(\"\\n\");\n      }),\n    );\n\n    return {\n      ...this.getTargetAndPath(),\n      body: lines.join(\"\\n\\n###\\n\\n\"),\n      importKeys: [],\n      customHeaders: [\"# @generated\", \"# 직접 수정하지 마세요.\"],\n    };\n  }\n\n  zodTypeToReqDefault(zodType: z.ZodType<unknown>, name: string): unknown {\n    if (zodType instanceof z.ZodObject) {\n      return Object.fromEntries(\n        Object.keys(zodType.shape).map((key) => [\n          key,\n          this.zodTypeToReqDefault(zodType.shape[key], key),\n        ]),\n      );\n    } else if (zodType instanceof z.ZodArray) {\n      return [this.zodTypeToReqDefault((zodType as z.ZodArray<z.ZodType>).element, name)];\n    } else if (zodType instanceof z.core.$ZodString) {\n      // NOTE: z.ZodString으로 비교하면 z.url(), z.email() 등의 타입에서 문제가 생기므로 z.core.$ZodString으로 비교함\n      if (name.endsWith(\"_at\") || name.endsWith(\"_date\") || name === \"range\") {\n        return \"2000-01-01\";\n      } else {\n        return name.toUpperCase();\n      }\n    } else if (zodType instanceof z.ZodNumber) {\n      if (name === \"num\") {\n        return 24;\n      }\n\n      const minValue = zodType.minValue ?? 0;\n      return minValue > Number.MIN_SAFE_INTEGER ? minValue : 0;\n    } else if (zodType instanceof z.ZodBoolean) {\n      return false;\n    } else if (zodType instanceof z.ZodEnum) {\n      return zodType.options[0];\n    } else if (zodType instanceof z.ZodOptional) {\n      return this.zodTypeToReqDefault((zodType as z.ZodOptional<z.ZodType>).def.innerType, name);\n    } else if (zodType instanceof z.ZodNullable) {\n      return null;\n    } else if (zodType instanceof z.ZodUnion) {\n      return this.zodTypeToReqDefault((zodType as z.ZodUnion<z.ZodType[]>).def.options[0], name);\n    } else if (zodType instanceof z.ZodUnknown) {\n      return \"unknown\";\n    } else if (zodType instanceof z.ZodTuple) {\n      /** biome-ignore lint/suspicious/noExplicitAny: ZodTuple 타입 사용 */\n      return zodType.def.items.map((item: any) => this.zodTypeToReqDefault(item, name));\n    } else if (zodType instanceof z.ZodDate) {\n      return \"2000-01-01\";\n    } else if (zodType instanceof z.ZodLiteral) {\n      return zodType.value;\n    } else if (zodType instanceof z.ZodRecord || zodType instanceof z.ZodMap) {\n      // biome-ignore lint/suspicious/noExplicitAny: ZodRecord 타입 사용\n      const kvDef = (zodType as z.ZodRecord<any, z.ZodType> | z.ZodMap<z.ZodType, z.ZodType>).def;\n      // biome-ignore lint/suspicious/noExplicitAny: ZodIntersection 타입 사용\n      const key = this.zodTypeToReqDefault(kvDef.keyType, name) as any;\n      const value = this.zodTypeToReqDefault(kvDef.valueType, name);\n      return { [key]: value };\n    } else if (zodType instanceof z.ZodSet) {\n      return [this.zodTypeToReqDefault((zodType as z.ZodSet<z.ZodType>).def.valueType, name)];\n    } else if (zodType instanceof z.ZodIntersection) {\n      return this.zodTypeToReqDefault(\n        (zodType as z.ZodIntersection<z.ZodType, z.ZodType>).def.right,\n        name,\n      );\n    } else if (zodType instanceof z.ZodDefault) {\n      return this.zodTypeToReqDefault((zodType as z.ZodDefault<z.ZodType>).def.innerType, name);\n    } else {\n      // console.log(zodType);\n      return `unknown-${zodType.type}`;\n    }\n  }\n\n  resolveApiParams(\n    api: ExtendedApi,\n    references: { [typeName: string]: z.ZodType },\n  ): { [key: string]: unknown } {\n    const reqType = getZodObjectFromApi(api, references);\n    try {\n      const def = this.zodTypeToReqDefault(reqType, \"unknownName\") as {\n        [key: string]: unknown;\n      };\n      return def;\n    } catch (error) {\n      console.error(error);\n      throw new Error(`Invalid zod type detected on ${api.modelName}:${api.methodName}`);\n    }\n  }\n}\n"],"names":["qs","z","getZodObjectFromApi","Sonamu","Template","Template__generated_http","getTargetAndPath","dir","config","api","target","path","render","syncer","types","apis","route","prefix","lines","Promise","all","map","reqObject","resolveApiParams","dataLines","options","httpMethod","querystring","stringify","encode","split","join","body","JSON","contentType","importKeys","customHeaders","zodTypeToReqDefault","zodType","name","ZodObject","Object","fromEntries","keys","shape","key","ZodArray","element","core","$ZodString","endsWith","toUpperCase","ZodNumber","minValue","Number","MIN_SAFE_INTEGER","ZodBoolean","ZodEnum","ZodOptional","def","innerType","ZodNullable","ZodUnion","ZodUnknown","ZodTuple","items","item","ZodDate","ZodLiteral","value","ZodRecord","ZodMap","kvDef","keyType","valueType","ZodSet","ZodIntersection","right","ZodDefault","type","references","reqType","error","console","Error","modelName","methodName"],"mappings":"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"}
+//#region src/template/implementations/generated_http.template.ts
+init_code_converters();
+init_sonamu();
+init_template();
+var Template__generated_http = class extends Template {
+	constructor() {
+		super("generated_http");
+	}
+	getTargetAndPath() {
+		const { dir } = Sonamu.config.api;
+		return {
+			target: `${dir}/src/application`,
+			path: `sonamu.generated.http`
+		};
+	}
+	async render() {
+		const { syncer: { types, apis }, config: { api: { route: { prefix } } } } = Sonamu;
+		const lines = await Promise.all(apis.map(async (api) => {
+			const reqObject = this.resolveApiParams(api, types);
+			const dataLines = await (async () => {
+				if ((api.options.httpMethod ?? "GET") === "GET") {
+					return {
+						querystring: [qs.stringify(reqObject, { encode: false }).split("&").join("\n	&")],
+						body: []
+					};
+				} else {
+					return {
+						querystring: [],
+						body: ["", JSON.stringify(reqObject, null, 2)]
+					};
+				}
+			})();
+			return [
+				[`${api.options.httpMethod ?? "GET"} {{baseUrl}}${prefix}${api.path}`, ...dataLines.querystring].join("\n	?"),
+				`Content-Type: ${api.options.contentType ?? "application/json"}`,
+				...dataLines.body
+			].join("\n");
+		}));
+		return {
+			...this.getTargetAndPath(),
+			body: lines.join("\n\n###\n\n"),
+			importKeys: [],
+			customHeaders: ["# @generated", "# 직접 수정하지 마세요."]
+		};
+	}
+	zodTypeToReqDefault(zodType, name) {
+		if (zodType instanceof z$1.ZodObject) {
+			return Object.fromEntries(Object.keys(zodType.shape).map((key) => [key, this.zodTypeToReqDefault(zodType.shape[key], key)]));
+		} else if (zodType instanceof z$1.ZodArray) {
+			return [this.zodTypeToReqDefault(zodType.element, name)];
+		} else if (zodType instanceof z$1.core.$ZodString) {
+			if (name.endsWith("_at") || name.endsWith("_date") || name === "range") {
+				return "2000-01-01";
+			} else {
+				return name.toUpperCase();
+			}
+		} else if (zodType instanceof z$1.ZodNumber) {
+			if (name === "num") {
+				return 24;
+			}
+			const minValue = zodType.minValue ?? 0;
+			return minValue > Number.MIN_SAFE_INTEGER ? minValue : 0;
+		} else if (zodType instanceof z$1.ZodBoolean) {
+			return false;
+		} else if (zodType instanceof z$1.ZodEnum) {
+			return zodType.options[0];
+		} else if (zodType instanceof z$1.ZodOptional) {
+			return this.zodTypeToReqDefault(zodType.def.innerType, name);
+		} else if (zodType instanceof z$1.ZodNullable) {
+			return null;
+		} else if (zodType instanceof z$1.ZodUnion) {
+			return this.zodTypeToReqDefault(zodType.def.options[0], name);
+		} else if (zodType instanceof z$1.ZodUnknown) {
+			return "unknown";
+		} else if (zodType instanceof z$1.ZodTuple) {
+			return zodType.def.items.map((item) => this.zodTypeToReqDefault(item, name));
+		} else if (zodType instanceof z$1.ZodDate) {
+			return "2000-01-01";
+		} else if (zodType instanceof z$1.ZodLiteral) {
+			return zodType.value;
+		} else if (zodType instanceof z$1.ZodRecord || zodType instanceof z$1.ZodMap) {
+			const kvDef = zodType.def;
+			const key = this.zodTypeToReqDefault(kvDef.keyType, name);
+			const value = this.zodTypeToReqDefault(kvDef.valueType, name);
+			return { [key]: value };
+		} else if (zodType instanceof z$1.ZodSet) {
+			return [this.zodTypeToReqDefault(zodType.def.valueType, name)];
+		} else if (zodType instanceof z$1.ZodIntersection) {
+			return this.zodTypeToReqDefault(zodType.def.right, name);
+		} else if (zodType instanceof z$1.ZodDefault) {
+			return this.zodTypeToReqDefault(zodType.def.innerType, name);
+		} else {
+			return `unknown-${zodType.type}`;
+		}
+	}
+	resolveApiParams(api, references) {
+		const reqType = getZodObjectFromApi(api, references);
+		try {
+			const def = this.zodTypeToReqDefault(reqType, "unknownName");
+			return def;
+		} catch (error) {
+			console.error(error);
+			throw new Error(`Invalid zod type detected on ${api.modelName}:${api.methodName}`, { cause: error });
+		}
+	}
+};
+
+//#endregion
+export { Template__generated_http };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"generated_http.template.js","names":["z"],"sources":["../../../src/template/implementations/generated_http.template.ts"],"sourcesContent":["import qs from \"qs\";\nimport { z } from \"zod\";\n\nimport { getZodObjectFromApi } from \"../../api/code-converters\";\nimport { type ExtendedApi } from \"../../api/decorators\";\nimport { Sonamu } from \"../../api/sonamu\";\nimport { Template } from \"../template\";\n\nexport class Template__generated_http extends Template {\n  constructor() {\n    super(\"generated_http\");\n  }\n\n  getTargetAndPath() {\n    const { dir } = Sonamu.config.api;\n\n    return {\n      target: `${dir}/src/application`,\n      path: `sonamu.generated.http`,\n    };\n  }\n\n  async render() {\n    const {\n      syncer: { types, apis },\n      config: {\n        api: {\n          route: { prefix },\n        },\n      },\n    } = Sonamu;\n\n    const lines = await Promise.all(\n      apis.map(async (api) => {\n        const reqObject = this.resolveApiParams(api, types);\n\n        const dataLines = await (async () => {\n          if ((api.options.httpMethod ?? \"GET\") === \"GET\") {\n            return {\n              querystring: [qs.stringify(reqObject, { encode: false }).split(\"&\").join(\"\\n\\t&\")],\n              body: [],\n            };\n          } else {\n            return {\n              querystring: [],\n              body: [\"\", JSON.stringify(reqObject, null, 2)],\n            };\n          }\n        })();\n\n        return [\n          [\n            `${api.options.httpMethod ?? \"GET\"} {{baseUrl}}${prefix}${api.path}`,\n            ...dataLines.querystring,\n          ].join(\"\\n\\t?\"),\n          `Content-Type: ${api.options.contentType ?? \"application/json\"}`,\n          ...dataLines.body,\n        ].join(\"\\n\");\n      }),\n    );\n\n    return {\n      ...this.getTargetAndPath(),\n      body: lines.join(\"\\n\\n###\\n\\n\"),\n      importKeys: [],\n      customHeaders: [\"# @generated\", \"# 직접 수정하지 마세요.\"],\n    };\n  }\n\n  zodTypeToReqDefault(zodType: z.ZodType, name: string): unknown {\n    if (zodType instanceof z.ZodObject) {\n      return Object.fromEntries(\n        Object.keys(zodType.shape).map((key) => [\n          key,\n          this.zodTypeToReqDefault(zodType.shape[key], key),\n        ]),\n      );\n    } else if (zodType instanceof z.ZodArray) {\n      return [this.zodTypeToReqDefault((zodType as z.ZodArray<z.ZodType>).element, name)];\n    } else if (zodType instanceof z.core.$ZodString) {\n      // NOTE: z.ZodString으로 비교하면 z.url(), z.email() 등의 타입에서 문제가 생기므로 z.core.$ZodString으로 비교함\n      if (name.endsWith(\"_at\") || name.endsWith(\"_date\") || name === \"range\") {\n        return \"2000-01-01\";\n      } else {\n        return name.toUpperCase();\n      }\n    } else if (zodType instanceof z.ZodNumber) {\n      if (name === \"num\") {\n        return 24;\n      }\n\n      const minValue = zodType.minValue ?? 0;\n      return minValue > Number.MIN_SAFE_INTEGER ? minValue : 0;\n    } else if (zodType instanceof z.ZodBoolean) {\n      return false;\n    } else if (zodType instanceof z.ZodEnum) {\n      return zodType.options[0];\n    } else if (zodType instanceof z.ZodOptional) {\n      return this.zodTypeToReqDefault((zodType as z.ZodOptional<z.ZodType>).def.innerType, name);\n    } else if (zodType instanceof z.ZodNullable) {\n      return null;\n    } else if (zodType instanceof z.ZodUnion) {\n      return this.zodTypeToReqDefault((zodType as z.ZodUnion<z.ZodType[]>).def.options[0], name);\n    } else if (zodType instanceof z.ZodUnknown) {\n      return \"unknown\";\n    } else if (zodType instanceof z.ZodTuple) {\n      // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- ZodTuple 타입 사용\n      return zodType.def.items.map((item: any) => this.zodTypeToReqDefault(item, name));\n    } else if (zodType instanceof z.ZodDate) {\n      return \"2000-01-01\";\n    } else if (zodType instanceof z.ZodLiteral) {\n      return zodType.value;\n    } else if (zodType instanceof z.ZodRecord || zodType instanceof z.ZodMap) {\n      // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- ZodRecord 타입 사용\n      const kvDef = (zodType as z.ZodRecord<any, z.ZodType> | z.ZodMap<z.ZodType, z.ZodType>).def;\n      // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- ZodIntersection 타입 사용\n      const key = this.zodTypeToReqDefault(kvDef.keyType, name) as any;\n      const value = this.zodTypeToReqDefault(kvDef.valueType, name);\n      return { [key]: value };\n    } else if (zodType instanceof z.ZodSet) {\n      return [this.zodTypeToReqDefault((zodType as z.ZodSet<z.ZodType>).def.valueType, name)];\n    } else if (zodType instanceof z.ZodIntersection) {\n      return this.zodTypeToReqDefault(\n        (zodType as z.ZodIntersection<z.ZodType, z.ZodType>).def.right,\n        name,\n      );\n    } else if (zodType instanceof z.ZodDefault) {\n      return this.zodTypeToReqDefault((zodType as z.ZodDefault<z.ZodType>).def.innerType, name);\n    } else {\n      // console.log(zodType);\n      return `unknown-${zodType.type}`;\n    }\n  }\n\n  resolveApiParams(\n    api: ExtendedApi,\n    references: { [typeName: string]: z.ZodType },\n  ): { [key: string]: unknown } {\n    const reqType = getZodObjectFromApi(api, references);\n    try {\n      const def = this.zodTypeToReqDefault(reqType, \"unknownName\") as {\n        [key: string]: unknown;\n      };\n      return def;\n    } catch (error) {\n      console.error(error);\n      throw new Error(`Invalid zod type detected on ${api.modelName}:${api.methodName}`, {\n        cause: error,\n      });\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/template/implementations/generated_sso.template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generated_sso.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/generated_sso.template.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAyBvC,qBAAa,uBAAwB,SAAQ,QAAQ;;IAKnD,gBAAgB;;;;IAShB,MAAM;;;;;;;IAuHN,OAAO,CAAC,2BAA2B;IAwEnC,OAAO,CAAC,oBAAoB;IAc5B,OAAO,CAAC,2BAA2B;IA4BnC;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IA6CjC;;OAEG;IACH,OAAO,CAAC,aAAa;CAGtB"}
+{"version":3,"file":"generated_sso.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/generated_sso.template.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAyBvC,qBAAa,uBAAwB,SAAQ,QAAQ;;IAKnD,gBAAgB;;;;IAShB,MAAM;;;;;;;IAuHN,OAAO,CAAC,2BAA2B;IAwEnC,OAAO,CAAC,oBAAoB;IAc5B,OAAO,CAAC,2BAA2B;IA4BnC;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IA6CjC;;OAEG;IACH,OAAO,CAAC,aAAa;CAGtB"}