sonamu 0.10.12 → 0.10.13

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

@@ -1,6 +1,10 @@
 import { z } from "zod";
 import { type ExtendedApi } from "../../api/decorators";
 import { Template } from "../template";
+type RequestDefaultValue = null | undefined | bigint | boolean | number | string | RequestDefaultValue[] | RequestDefaultObject;
+interface RequestDefaultObject {
+    [key: string]: RequestDefaultValue;
+}
 export declare class Template__generated_http extends Template {
     constructor();
     getTargetAndPath(): {
@@ -14,11 +18,10 @@ export declare class Template__generated_http extends Template {
         target: string;
         path: string;
     }>;
-    zodTypeToReqDefault(zodType: z.ZodType, name: string): unknown;
+    zodTypeToReqDefault(zodType: z.ZodType, name: string): RequestDefaultValue;
     resolveApiParams(api: ExtendedApi, references: {
         [typeName: string]: z.ZodType;
-    }): {
-        [key: string]: unknown;
-    };
+    }): RequestDefaultObject;
 }
+export {};
 //# sourceMappingURL=generated_http.template.d.ts.map

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;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"}
+{"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,KAAK,mBAAmB,GACpB,IAAI,GACJ,SAAS,GACT,MAAM,GACN,OAAO,GACP,MAAM,GACN,MAAM,GACN,mBAAmB,EAAE,GACrB,oBAAoB,CAAC;AAEzB,UAAU,oBAAoB;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAAC;CACpC;AAED,qBAAa,wBAAyB,SAAQ,QAAQ;;IAKpD,gBAAgB;;;;IASV,MAAM;;;;;;;IA+CZ,mBAAmB,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,mBAAmB;IAkG1E,gBAAgB,CACd,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAA;KAAE,GAC5C,oBAAoB;CAaxB"}

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

@@ -1,7 +1,7 @@
-import { Sonamu, init_sonamu } from "../../api/sonamu.js";
 import { getZodObjectFromApi, init_code_converters } from "../../api/code-converters.js";
+import { Sonamu, init_sonamu } from "../../api/sonamu.js";
 import { Template, init_template } from "../template.js";
-import { z as z$1 } from "zod";
+import { z } from "zod";
 import qs from "qs";
 //#region src/template/implementations/generated_http.template.ts
 init_code_converters();
@@ -46,31 +46,31 @@ var Template__generated_http = class extends Template {
 		};
 	}
 	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";
+		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) if (name.endsWith("_at") || name.endsWith("_date") || name === "range") return "2000-01-01";
 		else return name.toUpperCase();
-		else if (zodType instanceof z$1.ZodNumber) {
+		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$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) {
+		} 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) 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) {
 			const kvDef = zodType.def;
-			const key = this.zodTypeToReqDefault(kvDef.keyType, name);
+			const key = String(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 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 return `unknown-${zodType.type}`;
 	}
 	resolveApiParams(api, references) {
@@ -86,4 +86,4 @@ var Template__generated_http = class extends Template {
 //#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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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"generated_http.template.js","names":[],"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\ntype RequestDefaultValue =\n  | null\n  | undefined\n  | bigint\n  | boolean\n  | number\n  | string\n  | RequestDefaultValue[]\n  | RequestDefaultObject;\n\ninterface RequestDefaultObject {\n  [key: string]: RequestDefaultValue;\n}\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): RequestDefaultValue {\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 [\n        this.zodTypeToReqDefault(\n          /* SAFETY: ZodArray 분기이므로 element가 배열 원소 스키마다. */ (\n            zodType as z.ZodArray<z.ZodType>\n          ).element,\n          name,\n        ),\n      ];\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(\n        /* SAFETY: ZodOptional 분기이므로 innerType이 선택 속성의 스키마다. */ (\n          zodType as z.ZodOptional<z.ZodType>\n        ).def.innerType,\n        name,\n      );\n    } else if (zodType instanceof z.ZodNullable) {\n      return null;\n    } else if (zodType instanceof z.ZodUnion) {\n      return this.zodTypeToReqDefault(\n        /* SAFETY: ZodUnion 분기이므로 options의 첫 항목이 유효한 대안 스키마다. */ (\n          zodType as z.ZodUnion<z.ZodType[]>\n        ).def.options[0],\n        name,\n      );\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 = /* SAFETY: ZodRecord/ZodMap 분기이므로 def가 키-값 스키마 정의다. */ (\n        zodType as z.ZodRecord<any, z.ZodType> | z.ZodMap<z.ZodType, z.ZodType>\n      ).def;\n      // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- ZodIntersection 타입 사용\n      const key = String(this.zodTypeToReqDefault(kvDef.keyType, name));\n      const value = this.zodTypeToReqDefault(kvDef.valueType, name);\n      return { [key]: value };\n    } else if (zodType instanceof z.ZodSet) {\n      return [\n        this.zodTypeToReqDefault(\n          /* SAFETY: ZodSet 분기이므로 valueType이 집합 원소 스키마다. */ (\n            zodType as z.ZodSet<z.ZodType>\n          ).def.valueType,\n          name,\n        ),\n      ];\n    } else if (zodType instanceof z.ZodIntersection) {\n      return this.zodTypeToReqDefault(\n        /* SAFETY: ZodIntersection 분기이므로 right가 교차 타입의 우측 스키마다. */ (\n          zodType as z.ZodIntersection<z.ZodType, z.ZodType>\n        ).def.right,\n        name,\n      );\n    } else if (zodType instanceof z.ZodDefault) {\n      return this.zodTypeToReqDefault(\n        /* SAFETY: ZodDefault 분기이므로 innerType이 기본값 적용 전 스키마다. */ (\n          zodType as z.ZodDefault<z.ZodType>\n        ).def.innerType,\n        name,\n      );\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  ): RequestDefaultObject {\n    const reqType = getZodObjectFromApi(api, references);\n    try {\n      // SAFETY: getZodObjectFromApi는 객체 스키마를 반환하므로 기본값도 객체이다.\n      const def = this.zodTypeToReqDefault(reqType, \"unknownName\") as RequestDefaultObject;\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":"AAaA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAyBvC,qBAAa,uBAAwB,SAAQ,QAAQ;;IAKnD,gBAAgB;;;;IAShB,MAAM;;;;;;;IAwHN,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;AAgCvC,qBAAa,uBAAwB,SAAQ,QAAQ;;IAKnD,gBAAgB;;;;IAShB,MAAM;;;;;;;IAyHN,OAAO,CAAC,2BAA2B;IAwEnC,OAAO,CAAC,oBAAoB;IAc5B,OAAO,CAAC,2BAA2B;IA4BnC;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IAgDjC;;OAEG;IACH,OAAO,CAAC,aAAa;CAGtB"}

package/dist/template/implementations/generated_sso.template.js

@@ -1,5 +1,5 @@
-import { Sonamu } from "../../api/sonamu.js";
 import { init_types, isBelongsToOneRelationProp, isManyToManyRelationProp, isOneToOneRelationProp } from "../../types/types.js";
+import { Sonamu } from "../../api/sonamu.js";
 import { EntityManager, init_entity_manager } from "../../entity/entity-manager.js";
 import { init_api } from "../../api/index.js";
 import { Template, init_template } from "../template.js";
@@ -25,6 +25,9 @@ function mapBetterAuthFieldType(type) {
 		default: return "unknown";
 	}
 }
+function addLoaderIdTypeSafetyComments(query) {
+	return query.replaceAll(/fromIds as (?:number|string)\[\]/g, "/* SAFETY: 로더가 전달하는 ID는 소스 엔티티의 기본 키 타입과 일치한다. */ $&");
+}
 var Template__generated_sso = class extends Template {
 	constructor() {
 		super("generated_sso");
@@ -58,7 +61,7 @@ var Template__generated_sso = class extends Template {
 				lines: [
 					`export const ${entityCamelName}LoaderQueries = {`,
 					...subsetKeys.map((subsetKey) => {
-						return `${subsetKey}: ${entity.getPuriLoaderQuery(subsetKey)},`;
+						return `${subsetKey}: ${addLoaderIdTypeSafetyComments(entity.getPuriLoaderQuery(subsetKey))},`;
 					}),
 					`} as const satisfies PuriLoaderQueries<${subsetKeyTypeName}>;`,
 					""
@@ -214,4 +217,4 @@ var Template__generated_sso = class extends Template {
 //#endregion
 export { Template__generated_sso };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"generated_sso.template.js","names":[],"sources":["../../../src/template/implementations/generated_sso.template.ts"],"sourcesContent":["import assert from \"assert\";\n\nimport inflection from \"inflection\";\nimport { unique } from \"radashi\";\n\nimport { Sonamu } from \"../../api\";\nimport { type Entity } from \"../../entity/entity\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport {\n  isBelongsToOneRelationProp,\n  isManyToManyRelationProp,\n  isOneToOneRelationProp,\n} from \"../../types/types\";\nimport { Template } from \"../template\";\nimport { type SourceCode } from \"./generated.template\";\n\n/**\n * better-auth additionalFields의 type 값을 TypeScript 타입 문자열로 변환합니다.\n */\nfunction mapBetterAuthFieldType(type: string): string {\n  switch (type) {\n    case \"string\":\n      return \"string\";\n    case \"number\":\n      return \"number\";\n    case \"boolean\":\n      return \"boolean\";\n    case \"date\":\n      return \"Date\";\n    case \"string[]\":\n      return \"string[]\";\n    case \"number[]\":\n      return \"number[]\";\n    default:\n      return \"unknown\";\n  }\n}\n\nexport class Template__generated_sso extends Template {\n  constructor() {\n    super(\"generated_sso\");\n  }\n\n  getTargetAndPath() {\n    const { dir } = Sonamu.config.api;\n\n    return {\n      target: `${dir}/src/application`,\n      path: `sonamu.generated.sso.ts`,\n    };\n  }\n\n  render() {\n    const entityIds = EntityManager.getAllIds();\n    const entities = entityIds.map((id) => EntityManager.get(id));\n\n    // SubsetQueries 생성 대상: 부모 엔티티가 없고 서브셋이 존재\n    const targetEntities = entities.filter(\n      (entity) => entity.parentId === undefined && Object.keys(entity.subsets).length > 0,\n    );\n\n    // SubsetQueries 생성\n    const sourceCodes: SourceCode[] = targetEntities.flatMap((entity) => {\n      const subsetKeys = Object.keys(entity.subsets);\n\n      const subsetKeyTypeName = `${entity.names.module}SubsetKey`;\n      const entityCamelName = inflection.camelize(entity.id, true);\n\n      // Puri 기반 SubsetQuery\n      const puriSubsetQuery: SourceCode = {\n        label: `SubsetQuery: ${entity.id}`,\n        lines: [\n          `export const ${entityCamelName}SubsetQueries = {`,\n          ...subsetKeys.map(\n            (subsetKey) => `${subsetKey}: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n            ${entity.getPuriSubsetQuery(subsetKey)};\n          },`,\n          ),\n          `};`,\n          \"\",\n        ],\n        importKeys: [],\n      };\n\n      // Puri 기반 SubsetLoadersQuery\n      const puriLoaderQuery: SourceCode = {\n        label: `LoaderQuery: ${entity.id}`,\n        lines: [\n          `export const ${entityCamelName}LoaderQueries = {`,\n          ...subsetKeys.map((subsetKey) => {\n            return `${subsetKey}: ${entity.getPuriLoaderQuery(subsetKey)},`;\n          }),\n          `} as const satisfies PuriLoaderQueries<${subsetKeyTypeName}>;`,\n          \"\",\n        ],\n        importKeys: [subsetKeyTypeName],\n      };\n\n      return [puriSubsetQuery, puriLoaderQuery];\n    });\n\n    // ForeignKey 타입 생성\n    const fkTypeSourceCode = this.getForeignKeyTypeSourceCode(entities);\n    if (fkTypeSourceCode) {\n      sourceCodes.push(fkTypeSourceCode);\n    }\n\n    // DatabaseSchema 생성\n    const dbSchemaSourceCode = this.getDatabaseSchemaSourceCode(entities);\n    if (dbSchemaSourceCode) {\n      sourceCodes.push(dbSchemaSourceCode);\n    }\n\n    // Auth User 타입 생성\n    const authUserTypeSourceCode = this.getAuthUserTypeSourceCode();\n    if (authUserTypeSourceCode) {\n      sourceCodes.push(authUserTypeSourceCode);\n    }\n\n    const sourceCode = sourceCodes.reduce(\n      (result, ts) => {\n        if (ts === null) {\n          return result;\n        }\n        assert(result);\n        return {\n          lines: [...result.lines, `// ${ts.label}`, ...ts.lines, \"\"],\n          importKeys: unique([...result.importKeys, ...ts.importKeys]),\n        };\n      },\n      {\n        lines: [],\n        importKeys: [],\n      } as Omit<SourceCode, \"label\">,\n    );\n\n    const body = sourceCode.lines.join(\"\\n\");\n    const isUsingManyToManyBaseSchema = body.includes(\"ManyToManyBaseSchema\");\n\n    const sonamuImports = [\n      \"PuriWrapper\",\n      \"DatabaseSchemaExtend\",\n      \"PuriLoaderQueries\",\n      isUsingManyToManyBaseSchema ? \"ManyToManyBaseSchema\" : \"\",\n    ]\n      .filter(Boolean)\n      .join(\", \");\n\n    // customHeaders 구성\n    const customHeaders = [\n      \"/**\",\n      \" * @generated\",\n      \" * 직접 수정하지 마세요.\",\n      \" */\",\n      \"\",\n      `import { ${sonamuImports} } from \"sonamu\";`,\n    ];\n    if (this.hasAuthConfig()) {\n      customHeaders.push(`import type { User } from \"better-auth\";`);\n    }\n\n    return {\n      ...this.getTargetAndPath(),\n      body: sourceCode.lines.join(\"\\n\"),\n      importKeys: sourceCode.importKeys,\n      customHeaders,\n    };\n  }\n\n  //===============================================\n  // private Helper Methods\n  //===============================================\n  private getDatabaseSchemaSourceCode(entities: Entity[]): SourceCode | null {\n    if (entities.length === 0) {\n      return null;\n    }\n\n    // DatabaseSchemaExtend - 테이블 스키마 타입 정의\n    const entitySchemaLines = entities.map((entity) => `${entity.table}: ${entity.id}BaseSchema;`);\n\n    const joinTables = unique(\n      entities.flatMap((entity) =>\n        entity.props.filter(isManyToManyRelationProp).map((prop) => {\n          const fromTableKey = inflection.singularize(entity.table);\n          const toEntity = EntityManager.get(prop.with);\n          const toTableKey = inflection.singularize(toEntity.table);\n          return {\n            table: prop.joinTable,\n            fromTableKey,\n            toTableKey,\n            fromEntityId: entity.id,\n            toEntityId: toEntity.id,\n          };\n        }),\n      ),\n      (joinTable) => joinTable.table,\n    );\n\n    // DatabaseForeignKeys - FK 컬럼을 가진 테이블만 정의\n    const entitiesWithFk = entities.filter(\n      (entity) => this.getForeignKeyColumns(entity).length > 0,\n    );\n    const fkMetadataLines = entitiesWithFk.map(\n      (entity) => `${entity.table}: ${entity.id}ForeignKeys;`,\n    );\n\n    // ContextExtend - auth 설정이 있을 때만 user 타입 추가\n    const contextExtendLines: string[] = [];\n    if (this.hasAuthConfig()) {\n      contextExtendLines.push(\n        ``,\n        `  export interface ContextExtend {`,\n        `    user: SonamuUser | null;`,\n        `  }`,\n      );\n    }\n\n    return {\n      label: `DatabaseSchema`,\n      lines: [\n        `declare module \"sonamu\" {`,\n        `  export interface DatabaseSchemaExtend {`,\n        ...entitySchemaLines,\n        ...joinTables.map((joinTable) => {\n          const fromEntity = EntityManager.get(joinTable.fromEntityId);\n          const toEntity = EntityManager.get(joinTable.toEntityId);\n          const fromPkType = fromEntity.getPkType() === \"integer\" ? \"number\" : \"string\";\n          const toPkType = toEntity.getPkType() === \"integer\" ? \"number\" : \"string\";\n\n          return `${joinTable.table}: ManyToManyBaseSchema<\"${joinTable.fromTableKey}\", \"${joinTable.toTableKey}\", ${fromPkType}, ${toPkType}>;`;\n        }),\n        `  }`,\n        ``,\n        `  export interface DatabaseForeignKeys {`,\n        ...fkMetadataLines,\n        `  }`,\n        ...contextExtendLines,\n        `}`,\n      ],\n      importKeys: entities.map((entity) => `${entity.id}BaseSchema`),\n    };\n  }\n\n  // FK 관계를 컬럼명으로 변환 (예: company → company_id)\n  private getForeignKeyColumns(entity: Entity): string[] {\n    return entity.props\n      .filter((prop) => {\n        if (isBelongsToOneRelationProp(prop)) {\n          return true;\n        }\n        if (isOneToOneRelationProp(prop) && prop.hasJoinColumn) {\n          return true;\n        }\n        return false;\n      })\n      .map((prop) => `${prop.name}_id`);\n  }\n\n  private getForeignKeyTypeSourceCode(entities: Entity[]): SourceCode | null {\n    if (entities.length === 0) {\n      return null;\n    }\n\n    // FK가 있는 엔티티만 타입 생성\n    const entitiesWithFk = entities.filter(\n      (entity) => this.getForeignKeyColumns(entity).length > 0,\n    );\n\n    if (entitiesWithFk.length === 0) {\n      return null;\n    }\n\n    const fkTypeLines = entitiesWithFk.map((entity) => {\n      const fkColumns = this.getForeignKeyColumns(entity);\n      const fkTypeValue = fkColumns.map((col) => `\"${col}\"`).join(\" | \");\n\n      return `export type ${entity.id}ForeignKeys = ${fkTypeValue};`;\n    });\n\n    return {\n      label: `ForeignKey Types`,\n      lines: fkTypeLines,\n      importKeys: [],\n    };\n  }\n\n  /**\n   * sonamu.config.ts의 auth.user.additionalFields에서 SonamuUser 타입을 생성합니다.\n   * @returns SourceCode | null - auth 설정이 없으면 null 반환\n   */\n  private getAuthUserTypeSourceCode(): SourceCode | null {\n    const authConfig = Sonamu.config.server?.auth;\n    if (!authConfig) {\n      return null;\n    }\n\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- additionalFields 타입이 동적임\n    const additionalFields = (authConfig as any)?.user?.additionalFields;\n    if (!additionalFields || Object.keys(additionalFields).length === 0) {\n      // additionalFields가 없으면 기본 User 타입만 사용\n      return {\n        label: \"Auth User Type\",\n        lines: [\"export type SonamuUser = User;\"],\n        importKeys: [],\n      };\n    }\n\n    const importKeys: string[] = [];\n\n    // additionalFields를 TypeScript 타입으로 변환\n    const fieldLines = Object.entries(additionalFields).map(([key, value]) => {\n      // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- better-auth additionalFields 구조\n      const fieldConfig = value as any;\n      const isRequired = fieldConfig.required !== false;\n\n      let fieldType: string;\n\n      // sonamuType이 있으면 description을 타입명으로 사용\n      if (fieldConfig.sonamuType) {\n        fieldType = fieldConfig.sonamuType;\n        importKeys.push(fieldType);\n      } else {\n        fieldType = mapBetterAuthFieldType(fieldConfig.type);\n      }\n\n      return `  ${key}${isRequired ? \"\" : \"?\"}: ${fieldType};`;\n    });\n\n    return {\n      label: \"Auth User Type\",\n      lines: [\"export type SonamuUser = User & {\", ...fieldLines, \"};\"],\n      importKeys,\n    };\n  }\n\n  /**\n   * auth 설정이 있는지 확인합니다.\n   */\n  private hasAuthConfig(): boolean {\n    return !!Sonamu.config.server?.auth;\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"generated_sso.template.js","names":[],"sources":["../../../src/template/implementations/generated_sso.template.ts"],"sourcesContent":["import assert from \"assert\";\n\nimport inflection from \"inflection\";\nimport { unique } from \"radashi\";\n\nimport { Sonamu } from \"../../api\";\nimport { type Entity } from \"../../entity/entity\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport {\n  isBelongsToOneRelationProp,\n  isManyToManyRelationProp,\n  isOneToOneRelationProp,\n} from \"../../types/types\";\nimport { Template } from \"../template\";\nimport { type SourceCode } from \"./generated.template\";\n\n/**\n * better-auth additionalFields의 type 값을 TypeScript 타입 문자열로 변환합니다.\n */\nfunction mapBetterAuthFieldType(type: string): string {\n  switch (type) {\n    case \"string\":\n      return \"string\";\n    case \"number\":\n      return \"number\";\n    case \"boolean\":\n      return \"boolean\";\n    case \"date\":\n      return \"Date\";\n    case \"string[]\":\n      return \"string[]\";\n    case \"number[]\":\n      return \"number[]\";\n    default:\n      return \"unknown\";\n  }\n}\n\nfunction addLoaderIdTypeSafetyComments(query: string): string {\n  return query.replaceAll(\n    /fromIds as (?:number|string)\\[\\]/g,\n    \"/* SAFETY: 로더가 전달하는 ID는 소스 엔티티의 기본 키 타입과 일치한다. */ $&\",\n  );\n}\n\nexport class Template__generated_sso extends Template {\n  constructor() {\n    super(\"generated_sso\");\n  }\n\n  getTargetAndPath() {\n    const { dir } = Sonamu.config.api;\n\n    return {\n      target: `${dir}/src/application`,\n      path: `sonamu.generated.sso.ts`,\n    };\n  }\n\n  render() {\n    const entityIds = EntityManager.getAllIds();\n    const entities = entityIds.map((id) => EntityManager.get(id));\n\n    // SubsetQueries 생성 대상: 부모 엔티티가 없고 서브셋이 존재\n    const targetEntities = entities.filter(\n      (entity) => entity.parentId === undefined && Object.keys(entity.subsets).length > 0,\n    );\n\n    // SubsetQueries 생성\n    const sourceCodes: SourceCode[] = targetEntities.flatMap((entity) => {\n      const subsetKeys = Object.keys(entity.subsets);\n\n      const subsetKeyTypeName = `${entity.names.module}SubsetKey`;\n      const entityCamelName = inflection.camelize(entity.id, true);\n\n      // Puri 기반 SubsetQuery\n      const puriSubsetQuery: SourceCode = {\n        label: `SubsetQuery: ${entity.id}`,\n        lines: [\n          `export const ${entityCamelName}SubsetQueries = {`,\n          ...subsetKeys.map(\n            (subsetKey) => `${subsetKey}: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n            ${entity.getPuriSubsetQuery(subsetKey)};\n          },`,\n          ),\n          `};`,\n          \"\",\n        ],\n        importKeys: [],\n      };\n\n      // Puri 기반 SubsetLoadersQuery\n      const puriLoaderQuery: SourceCode = {\n        label: `LoaderQuery: ${entity.id}`,\n        lines: [\n          `export const ${entityCamelName}LoaderQueries = {`,\n          ...subsetKeys.map((subsetKey) => {\n            const query = entity.getPuriLoaderQuery(subsetKey);\n            return `${subsetKey}: ${addLoaderIdTypeSafetyComments(query)},`;\n          }),\n          `} as const satisfies PuriLoaderQueries<${subsetKeyTypeName}>;`,\n          \"\",\n        ],\n        importKeys: [subsetKeyTypeName],\n      };\n\n      return [puriSubsetQuery, puriLoaderQuery];\n    });\n\n    // ForeignKey 타입 생성\n    const fkTypeSourceCode = this.getForeignKeyTypeSourceCode(entities);\n    if (fkTypeSourceCode) {\n      sourceCodes.push(fkTypeSourceCode);\n    }\n\n    // DatabaseSchema 생성\n    const dbSchemaSourceCode = this.getDatabaseSchemaSourceCode(entities);\n    if (dbSchemaSourceCode) {\n      sourceCodes.push(dbSchemaSourceCode);\n    }\n\n    // Auth User 타입 생성\n    const authUserTypeSourceCode = this.getAuthUserTypeSourceCode();\n    if (authUserTypeSourceCode) {\n      sourceCodes.push(authUserTypeSourceCode);\n    }\n\n    const sourceCode = sourceCodes.reduce(\n      (result, ts) => {\n        if (ts === null) {\n          return result;\n        }\n        assert(result);\n        return {\n          lines: [...result.lines, `// ${ts.label}`, ...ts.lines, \"\"],\n          importKeys: unique([...result.importKeys, ...ts.importKeys]),\n        };\n      },\n      /* SAFETY: reduce 누산기는 label을 제외한 SourceCode의 두 배열로 초기화된다. */ {\n        lines: [],\n        importKeys: [],\n      } as Omit<SourceCode, \"label\">,\n    );\n\n    const body = sourceCode.lines.join(\"\\n\");\n    const isUsingManyToManyBaseSchema = body.includes(\"ManyToManyBaseSchema\");\n\n    const sonamuImports = [\n      \"PuriWrapper\",\n      \"DatabaseSchemaExtend\",\n      \"PuriLoaderQueries\",\n      isUsingManyToManyBaseSchema ? \"ManyToManyBaseSchema\" : \"\",\n    ]\n      .filter(Boolean)\n      .join(\", \");\n\n    // customHeaders 구성\n    const customHeaders = [\n      \"/**\",\n      \" * @generated\",\n      \" * 직접 수정하지 마세요.\",\n      \" */\",\n      \"\",\n      `import { ${sonamuImports} } from \"sonamu\";`,\n    ];\n    if (this.hasAuthConfig()) {\n      customHeaders.push(`import type { User } from \"better-auth\";`);\n    }\n\n    return {\n      ...this.getTargetAndPath(),\n      body: sourceCode.lines.join(\"\\n\"),\n      importKeys: sourceCode.importKeys,\n      customHeaders,\n    };\n  }\n\n  //===============================================\n  // private Helper Methods\n  //===============================================\n  private getDatabaseSchemaSourceCode(entities: Entity[]): SourceCode | null {\n    if (entities.length === 0) {\n      return null;\n    }\n\n    // DatabaseSchemaExtend - 테이블 스키마 타입 정의\n    const entitySchemaLines = entities.map((entity) => `${entity.table}: ${entity.id}BaseSchema;`);\n\n    const joinTables = unique(\n      entities.flatMap((entity) =>\n        entity.props.filter(isManyToManyRelationProp).map((prop) => {\n          const fromTableKey = inflection.singularize(entity.table);\n          const toEntity = EntityManager.get(prop.with);\n          const toTableKey = inflection.singularize(toEntity.table);\n          return {\n            table: prop.joinTable,\n            fromTableKey,\n            toTableKey,\n            fromEntityId: entity.id,\n            toEntityId: toEntity.id,\n          };\n        }),\n      ),\n      (joinTable) => joinTable.table,\n    );\n\n    // DatabaseForeignKeys - FK 컬럼을 가진 테이블만 정의\n    const entitiesWithFk = entities.filter(\n      (entity) => this.getForeignKeyColumns(entity).length > 0,\n    );\n    const fkMetadataLines = entitiesWithFk.map(\n      (entity) => `${entity.table}: ${entity.id}ForeignKeys;`,\n    );\n\n    // ContextExtend - auth 설정이 있을 때만 user 타입 추가\n    const contextExtendLines: string[] = [];\n    if (this.hasAuthConfig()) {\n      contextExtendLines.push(\n        ``,\n        `  export interface ContextExtend {`,\n        `    user: SonamuUser | null;`,\n        `  }`,\n      );\n    }\n\n    return {\n      label: `DatabaseSchema`,\n      lines: [\n        `declare module \"sonamu\" {`,\n        `  export interface DatabaseSchemaExtend {`,\n        ...entitySchemaLines,\n        ...joinTables.map((joinTable) => {\n          const fromEntity = EntityManager.get(joinTable.fromEntityId);\n          const toEntity = EntityManager.get(joinTable.toEntityId);\n          const fromPkType = fromEntity.getPkType() === \"integer\" ? \"number\" : \"string\";\n          const toPkType = toEntity.getPkType() === \"integer\" ? \"number\" : \"string\";\n\n          return `${joinTable.table}: ManyToManyBaseSchema<\"${joinTable.fromTableKey}\", \"${joinTable.toTableKey}\", ${fromPkType}, ${toPkType}>;`;\n        }),\n        `  }`,\n        ``,\n        `  export interface DatabaseForeignKeys {`,\n        ...fkMetadataLines,\n        `  }`,\n        ...contextExtendLines,\n        `}`,\n      ],\n      importKeys: entities.map((entity) => `${entity.id}BaseSchema`),\n    };\n  }\n\n  // FK 관계를 컬럼명으로 변환 (예: company → company_id)\n  private getForeignKeyColumns(entity: Entity): string[] {\n    return entity.props\n      .filter((prop) => {\n        if (isBelongsToOneRelationProp(prop)) {\n          return true;\n        }\n        if (isOneToOneRelationProp(prop) && prop.hasJoinColumn) {\n          return true;\n        }\n        return false;\n      })\n      .map((prop) => `${prop.name}_id`);\n  }\n\n  private getForeignKeyTypeSourceCode(entities: Entity[]): SourceCode | null {\n    if (entities.length === 0) {\n      return null;\n    }\n\n    // FK가 있는 엔티티만 타입 생성\n    const entitiesWithFk = entities.filter(\n      (entity) => this.getForeignKeyColumns(entity).length > 0,\n    );\n\n    if (entitiesWithFk.length === 0) {\n      return null;\n    }\n\n    const fkTypeLines = entitiesWithFk.map((entity) => {\n      const fkColumns = this.getForeignKeyColumns(entity);\n      const fkTypeValue = fkColumns.map((col) => `\"${col}\"`).join(\" | \");\n\n      return `export type ${entity.id}ForeignKeys = ${fkTypeValue};`;\n    });\n\n    return {\n      label: `ForeignKey Types`,\n      lines: fkTypeLines,\n      importKeys: [],\n    };\n  }\n\n  /**\n   * sonamu.config.ts의 auth.user.additionalFields에서 SonamuUser 타입을 생성합니다.\n   * @returns SourceCode | null - auth 설정이 없으면 null 반환\n   */\n  private getAuthUserTypeSourceCode(): SourceCode | null {\n    const authConfig = Sonamu.config.server?.auth;\n    if (!authConfig) {\n      return null;\n    }\n\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- additionalFields 타입이 동적임\n    const additionalFields =\n      /* SAFETY: better-auth 설정의 user.additionalFields는 동적 필드 맵이다. */ (authConfig as any)\n        ?.user?.additionalFields;\n    if (!additionalFields || Object.keys(additionalFields).length === 0) {\n      // additionalFields가 없으면 기본 User 타입만 사용\n      return {\n        label: \"Auth User Type\",\n        lines: [\"export type SonamuUser = User;\"],\n        importKeys: [],\n      };\n    }\n\n    const importKeys: string[] = [];\n\n    // additionalFields를 TypeScript 타입으로 변환\n    const fieldLines = Object.entries(additionalFields).map(([key, value]) => {\n      // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- better-auth additionalFields 구조\n      const fieldConfig =\n        /* SAFETY: additionalFields의 각 값은 better-auth 필드 설정 객체이다. */ value as any;\n      const isRequired = fieldConfig.required !== false;\n\n      let fieldType: string;\n\n      // sonamuType이 있으면 description을 타입명으로 사용\n      if (fieldConfig.sonamuType) {\n        fieldType = fieldConfig.sonamuType;\n        importKeys.push(fieldType);\n      } else {\n        fieldType = mapBetterAuthFieldType(fieldConfig.type);\n      }\n\n      return `  ${key}${isRequired ? \"\" : \"?\"}: ${fieldType};`;\n    });\n\n    return {\n      label: \"Auth User Type\",\n      lines: [\"export type SonamuUser = User & {\", ...fieldLines, \"};\"],\n      importKeys,\n    };\n  }\n\n  /**\n   * auth 설정이 있는지 확인합니다.\n   */\n  private hasAuthConfig(): boolean {\n    return !!Sonamu.config.server?.auth;\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,18 @@
+import { Template } from "../template";
+export declare class Template__http_validators extends Template {
+    constructor();
+    getTargetAndPath(): {
+        target: string;
+        path: string;
+    };
+    render(): {
+        body: string;
+        importKeys: string[];
+        customHeaders: string[];
+        target: string;
+        path: string;
+    };
+    private renderAotRegistry;
+    private renderPlainStub;
+}
+//# sourceMappingURL=http_validators.template.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http_validators.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/http_validators.template.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAqDvC,qBAAa,yBAA0B,SAAQ,QAAQ;;IAKrD,gBAAgB;;;;IAOhB,MAAM;;;;;;;IAsDN,OAAO,CAAC,iBAAiB;IAoCzB,OAAO,CAAC,eAAe;CAUxB"}

package/dist/template/implementations/http_validators.template.js

@@ -0,0 +1,127 @@
+import { init_runtime_value, isObjectValue, isStringValue } from "../../utils/runtime-value.js";
+import { getHttpValidatorFingerprint, getHttpValidatorRouteIdentifier, getHttpValidatorRouteKey, init_http_validator } from "../../api/http-validator.js";
+import { Sonamu, init_sonamu } from "../../api/sonamu.js";
+import { Template, init_template } from "../template.js";
+//#region src/template/implementations/http_validators.template.ts
+init_http_validator();
+init_sonamu();
+init_runtime_value();
+init_template();
+function collectReferencedTypes(type, result) {
+	if (isStringValue(type)) return;
+	switch (type.t) {
+		case "ref":
+			result.add(type.id);
+			for (const argument of type.args ?? []) collectReferencedTypes(argument, result);
+			return;
+		case "array":
+			collectReferencedTypes(type.elementsType, result);
+			return;
+		case "object":
+			for (const prop of type.props) collectReferencedTypes(prop.type, result);
+			return;
+		case "union":
+		case "intersection":
+			for (const member of type.types) collectReferencedTypes(member, result);
+			return;
+		case "tuple-type":
+			for (const element of type.elements) collectReferencedTypes(element, result);
+			return;
+		case "indexed-access":
+			collectReferencedTypes(type.object, result);
+			collectReferencedTypes(type.index, result);
+			return;
+		case "type-param":
+			if (type.constraint !== void 0) collectReferencedTypes(type.constraint, result);
+			return;
+		case "function":
+			for (const parameter of type.parameters) collectReferencedTypes(parameter.type, result);
+			collectReferencedTypes(type.returnType, result);
+			return;
+		case "string-literal":
+		case "numeric-literal": return;
+	}
+}
+var Template__http_validators = class extends Template {
+	constructor() {
+		super("http_validators");
+	}
+	getTargetAndPath() {
+		return {
+			target: `${Sonamu.config.api.dir}/src/application`,
+			path: "sonamu.validators.generated.ts"
+		};
+	}
+	render() {
+		const apis = [...Sonamu.syncer.apis].filter((api) => api.websocketOptions === void 0).toSorted((left, right) => getHttpValidatorRouteKey(left).localeCompare(getHttpValidatorRouteKey(right)));
+		const routeKeys = apis.map(getHttpValidatorRouteKey);
+		const duplicateKey = routeKeys.find((key, index) => routeKeys.indexOf(key) !== index);
+		if (duplicateKey !== void 0) throw new Error(`중복된 HTTP validator route key: ${duplicateKey}`);
+		const fingerprint = getHttpValidatorFingerprint(apis);
+		const policy = Sonamu.config.validation?.zodCompiler;
+		const isAot = isObjectValue(policy) && policy !== null && policy.api === "aot";
+		const hasAotValidators = isAot && apis.length > 0;
+		const referencedTypes = /* @__PURE__ */ new Set();
+		for (const api of apis) {
+			for (const typeParameter of api.typeParameters) collectReferencedTypes(typeParameter, referencedTypes);
+			for (const parameter of api.parameters) collectReferencedTypes(parameter.type, referencedTypes);
+		}
+		const importKeys = [...referencedTypes].filter((typeName) => Sonamu.syncer.types[typeName] !== void 0).toSorted();
+		const body = isAot ? this.renderAotRegistry(apis, fingerprint, importKeys) : this.renderPlainStub(apis, fingerprint);
+		return {
+			...this.getTargetAndPath(),
+			body,
+			importKeys,
+			customHeaders: [
+				"/**",
+				" * @generated",
+				" * 직접 수정하지 마세요.",
+				" */",
+				"",
+				"/* oxlint-disable */",
+				"",
+				...hasAotValidators ? [`import { compile } from "zod-compiler";`, `import { fastifyCaster, getZodObjectFromApi } from "sonamu";`] : []
+			]
+		};
+	}
+	renderAotRegistry(apis, fingerprint, importKeys) {
+		const declarations = apis.map((api) => {
+			const identifier = `validator_${getHttpValidatorRouteIdentifier(api)}`;
+			const schemaApi = {
+				modelName: api.modelName,
+				methodName: api.methodName,
+				path: api.path,
+				options: { httpMethod: api.options.httpMethod ?? "GET" },
+				typeParameters: api.typeParameters,
+				parameters: api.parameters,
+				returnType: "unknown"
+			};
+			return `export const ${identifier} = compile(fastifyCaster(getZodObjectFromApi(${JSON.stringify(schemaApi)}, { ...types })));`;
+		});
+		const routeIds = Object.fromEntries(apis.map((api) => [getHttpValidatorRouteKey(api), getHttpValidatorRouteIdentifier(api)]));
+		return [
+			`export const fingerprint = ${JSON.stringify(fingerprint)};`,
+			`export const routeIds = ${JSON.stringify(routeIds)};`,
+			`const types = { ${importKeys.join(", ")} };`,
+			...declarations,
+			`export const validators = new Map([`,
+			...apis.map((api) => {
+				const routeKey = getHttpValidatorRouteKey(api);
+				return `  [${JSON.stringify(routeKey)}, validator_${getHttpValidatorRouteIdentifier(api)}],`;
+			}),
+			`]);`
+		].join("\n");
+	}
+	renderPlainStub(apis, fingerprint) {
+		const routeIds = Object.fromEntries(apis.map((api) => [getHttpValidatorRouteKey(api), getHttpValidatorRouteIdentifier(api)]));
+		return [
+			`export const fingerprint = ${JSON.stringify(fingerprint)};`,
+			`export const routeIds = ${JSON.stringify(routeIds)};`,
+			`export const validators = new Map();`
+		].join("\n");
+	}
+};
+//#endregion
+export { Template__http_validators };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"http_validators.template.js","names":[],"sources":["../../../src/template/implementations/http_validators.template.ts"],"sourcesContent":["import { type ExtendedApi } from \"../../api/decorators\";\nimport {\n  getHttpValidatorFingerprint,\n  getHttpValidatorRouteIdentifier,\n  getHttpValidatorRouteKey,\n} from \"../../api/http-validator\";\nimport { Sonamu } from \"../../api/sonamu\";\nimport { type ApiParamType } from \"../../types/types\";\nimport { isObjectValue, isStringValue } from \"../../utils/runtime-value\";\nimport { Template } from \"../template\";\n\nfunction collectReferencedTypes(type: ApiParamType, result: Set<string>): void {\n  if (isStringValue(type)) {\n    return;\n  }\n  switch (type.t) {\n    case \"ref\":\n      result.add(type.id);\n      for (const argument of type.args ?? []) {\n        collectReferencedTypes(argument, result);\n      }\n      return;\n    case \"array\":\n      collectReferencedTypes(type.elementsType, result);\n      return;\n    case \"object\":\n      for (const prop of type.props) {\n        collectReferencedTypes(prop.type, result);\n      }\n      return;\n    case \"union\":\n    case \"intersection\":\n      for (const member of type.types) {\n        collectReferencedTypes(member, result);\n      }\n      return;\n    case \"tuple-type\":\n      for (const element of type.elements) {\n        collectReferencedTypes(element, result);\n      }\n      return;\n    case \"indexed-access\":\n      collectReferencedTypes(type.object, result);\n      collectReferencedTypes(type.index, result);\n      return;\n    case \"type-param\":\n      if (type.constraint !== undefined) {\n        collectReferencedTypes(type.constraint, result);\n      }\n      return;\n    case \"function\":\n      for (const parameter of type.parameters) {\n        collectReferencedTypes(parameter.type, result);\n      }\n      collectReferencedTypes(type.returnType, result);\n      return;\n    case \"string-literal\":\n    case \"numeric-literal\":\n      return;\n  }\n}\n\nexport class Template__http_validators extends Template {\n  constructor() {\n    super(\"http_validators\");\n  }\n\n  getTargetAndPath() {\n    return {\n      target: `${Sonamu.config.api.dir}/src/application`,\n      path: \"sonamu.validators.generated.ts\",\n    };\n  }\n\n  render() {\n    const apis = [...Sonamu.syncer.apis]\n      .filter((api) => api.websocketOptions === undefined)\n      .toSorted((left, right) =>\n        getHttpValidatorRouteKey(left).localeCompare(getHttpValidatorRouteKey(right)),\n      );\n    const routeKeys = apis.map(getHttpValidatorRouteKey);\n    const duplicateKey = routeKeys.find((key, index) => routeKeys.indexOf(key) !== index);\n    if (duplicateKey !== undefined) {\n      throw new Error(`중복된 HTTP validator route key: ${duplicateKey}`);\n    }\n\n    const fingerprint = getHttpValidatorFingerprint(apis);\n    const policy = Sonamu.config.validation?.zodCompiler;\n    const isAot = isObjectValue(policy) && policy !== null && policy.api === \"aot\";\n    const hasAotValidators = isAot && apis.length > 0;\n    const referencedTypes = new Set<string>();\n    for (const api of apis) {\n      for (const typeParameter of api.typeParameters) {\n        collectReferencedTypes(typeParameter, referencedTypes);\n      }\n      for (const parameter of api.parameters) {\n        collectReferencedTypes(parameter.type, referencedTypes);\n      }\n    }\n    const importKeys = [...referencedTypes]\n      .filter((typeName) => Sonamu.syncer.types[typeName] !== undefined)\n      .toSorted();\n    const body = isAot\n      ? this.renderAotRegistry(apis, fingerprint, importKeys)\n      : this.renderPlainStub(apis, fingerprint);\n\n    return {\n      ...this.getTargetAndPath(),\n      body,\n      importKeys,\n      customHeaders: [\n        \"/**\",\n        \" * @generated\",\n        \" * 직접 수정하지 마세요.\",\n        \" */\",\n        \"\",\n        \"/* oxlint-disable */\",\n        \"\",\n        ...(hasAotValidators\n          ? [\n              `import { compile } from \"zod-compiler\";`,\n              `import { fastifyCaster, getZodObjectFromApi } from \"sonamu\";`,\n            ]\n          : []),\n      ],\n    };\n  }\n\n  private renderAotRegistry(\n    apis: ExtendedApi[],\n    fingerprint: string,\n    importKeys: string[],\n  ): string {\n    const declarations = apis.map((api) => {\n      const identifier = `validator_${getHttpValidatorRouteIdentifier(api)}`;\n      const schemaApi = {\n        modelName: api.modelName,\n        methodName: api.methodName,\n        path: api.path,\n        options: { httpMethod: api.options.httpMethod ?? \"GET\" },\n        typeParameters: api.typeParameters,\n        parameters: api.parameters,\n        returnType: \"unknown\",\n      } satisfies ExtendedApi;\n      return `export const ${identifier} = compile(fastifyCaster(getZodObjectFromApi(${JSON.stringify(schemaApi)}, { ...types })));`;\n    });\n    const routeIds = Object.fromEntries(\n      apis.map((api) => [getHttpValidatorRouteKey(api), getHttpValidatorRouteIdentifier(api)]),\n    );\n\n    return [\n      `export const fingerprint = ${JSON.stringify(fingerprint)};`,\n      `export const routeIds = ${JSON.stringify(routeIds)};`,\n      `const types = { ${importKeys.join(\", \")} };`,\n      ...declarations,\n      `export const validators = new Map([`,\n      ...apis.map((api) => {\n        const routeKey = getHttpValidatorRouteKey(api);\n        return `  [${JSON.stringify(routeKey)}, validator_${getHttpValidatorRouteIdentifier(api)}],`;\n      }),\n      `]);`,\n    ].join(\"\\n\");\n  }\n\n  private renderPlainStub(apis: ExtendedApi[], fingerprint: string): string {\n    const routeIds = Object.fromEntries(\n      apis.map((api) => [getHttpValidatorRouteKey(api), getHttpValidatorRouteIdentifier(api)]),\n    );\n    return [\n      `export const fingerprint = ${JSON.stringify(fingerprint)};`,\n      `export const routeIds = ${JSON.stringify(routeIds)};`,\n      `export const validators = new Map();`,\n    ].join(\"\\n\");\n  }\n}\n"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"model.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/model.template.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAErE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,qBAAa,eAAgB,SAAQ,QAAQ;;IAK3C,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;;;IAShC,mBAAmB,IAAI,MAAM,EAAE,GAAG,IAAI;IAIzC,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,CAAC,OAAO,CAAC;;;;;;CAwLpD"}
+{"version":3,"file":"model.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/model.template.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAErE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,qBAAa,eAAgB,SAAQ,QAAQ;;IAK3C,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;;;IAShC,mBAAmB,IAAI,MAAM,EAAE,GAAG,IAAI;IAIzC,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,CAAC,OAAO,CAAC;;;;;;CA0LpD"}

package/dist/template/implementations/model.template.js

@@ -196,4 +196,4 @@ export const ${entityId}Model = new ${entityId}ModelClass();
 //#endregion
 export { Template__model };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"model.template.js","names":[],"sources":["../../../src/template/implementations/model.template.ts"],"sourcesContent":["import type z from \"zod\";\n\nimport { Sonamu } from \"../../api\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport { type EntityNamesRecord } from \"../../entity/entity-manager\";\nimport { Naite } from \"../../naite/naite\";\nimport { type TemplateOptions } from \"../../types/types\";\nimport { Template } from \"../template\";\nimport { getZodTypeById, zodTypeToRenderingNode } from \"../zod-converter\";\nimport { Template__view_list } from \"./view_list.template\";\nexport class Template__model extends Template {\n  constructor() {\n    super(\"model\");\n  }\n\n  getTargetAndPath(names: EntityNamesRecord) {\n    const { dir } = Sonamu.config.api;\n\n    return {\n      target: `${dir}/src/application`,\n      path: `${names.fs}/${names.fs}.model.ts`,\n    };\n  }\n\n  override getRequiredDictKeys(): string[] | null {\n    return [\"error.entityNotFound\", \"error.unknownSearchField\"];\n  }\n\n  async render({ entityId }: TemplateOptions[\"model\"]) {\n    Naite.t(\"render\", { entityId });\n\n    const listParamsZodType = await getZodTypeById(`${entityId}ListParams`);\n    const listParamsNode = zodTypeToRenderingNode(listParamsZodType);\n\n    const subsetKeyZodType = await getZodTypeById(`${entityId}SubsetKey`);\n    const subsetKeys = (subsetKeyZodType as z.ZodEnum).enum;\n\n    const names = EntityManager.getNamesFromId(entityId);\n    const entity = EntityManager.get(entityId);\n\n    const vlTpl = new Template__view_list();\n    if (listParamsNode?.children === undefined) {\n      throw new Error(`listParamsNode가 없습니다. ${entityId}`);\n    }\n    const def = vlTpl.getDefault(listParamsNode.children);\n\n    // 에러 메시지 생성\n    const notFoundError = `SD(\"error.entityNotFound\")(\"${names.capital}\", id)`;\n    const unknownSearchFieldError = `SD(\"error.unknownSearchField\")(params.search)`;\n\n    // PK 타입에 따른 TypeScript 타입 결정\n    const pkType = entity.getPkType();\n    const idTsType = pkType === \"string\" || pkType === \"uuid\" ? \"string\" : \"number\";\n\n    return {\n      ...this.getTargetAndPath(names),\n      body: `\nimport { BaseModelClass, type ListResult, asArray, NotFoundException, BadRequestException, api, exhaustive } from 'sonamu';\nimport {\n  ${entityId}SubsetKey,\n  ${entityId}SubsetMapping,\n} from \"../sonamu.generated\";\nimport {\n  ${names.camel}SubsetQueries,\n  ${names.camel}LoaderQueries,\n} from \"../sonamu.generated.sso\";\nimport { ${entityId}ListParams, ${entityId}SaveParams } from \"./${names.fs}.types\";\nimport { SD } from \"../../i18n/sd.generated\";\n\n/*\n  ${entityId} Model\n*/\nclass ${entityId}ModelClass extends BaseModelClass<\n  ${entityId}SubsetKey,\n  ${entityId}SubsetMapping,\n  typeof ${names.camel}SubsetQueries,\n  typeof ${names.camel}LoaderQueries\n> {\n  constructor() {\n    super(\"${entityId}\", ${names.camel}SubsetQueries, ${names.camel}LoaderQueries);\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"${entityId}\" })\n  async findById<T extends ${entityId}SubsetKey>(\n    subset: T,\n    id: ${idTsType}\n  ): Promise<${entityId}SubsetMapping[T]> {\n    const { rows } = await this.findMany(subset, {\n      id,\n      num: 1,\n      page: 1,\n    });\n    if (!rows[0]) {\n      throw new NotFoundException(${notFoundError});\n    }\n\n    return rows[0];\n  }\n\n  async findOne<T extends ${entityId}SubsetKey>(\n    subset: T,\n    listParams: ${entityId}ListParams\n  ): Promise<${entityId}SubsetMapping[T] | null> {\n    const { rows } = await this.findMany(subset, {\n      ...listParams,\n      num: 1,\n      page: 1,\n    });\n\n    return rows[0] ?? null;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"${names.capitalPlural}\" })\n  async findMany<T extends ${entityId}SubsetKey, LP extends ${entityId}ListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): Promise<ListResult<LP, ${entityId}SubsetMapping[T]>> {\n    // params with defaults\n    const params = {\n      num: 24,\n      page: 1,\n      search: \"${def.search}\" as const,\n      orderBy: \"${def.orderBy}\" as const,\n      ...rawParams,\n    } satisfies ${entityId}ListParams;\n\n    // build queries\n    const { qb, onSubset: _ } = this.getSubsetQueries(subset);\n    \n    // id\n    if (params.id) {\n      qb.whereIn(\"${entity.table}.id\", asArray(params.id));\n    }\n\n    // search-keyword\n    if (params.search && params.keyword && params.keyword.length > 0) {\n      if (params.search === \"id\") {\n        qb.where(\"${entity.table}.id\", ${idTsType === \"string\" ? \"params.keyword\" : \"Number(params.keyword)\"});\n        // } else if (params.search === \"field\") {\n        //   qb.where(\"${entity.table}.field\", \"like\", \\`%\\${params.keyword}%\\`);\n      } else {\n        throw new BadRequestException(${unknownSearchFieldError});\n      }\n    }\n      \n    // orderBy\n    if (params.orderBy) {\n      // default orderBy\n      if (params.orderBy === \"id-desc\") {\n        qb.orderBy(\"${entity.table}.id\", \"desc\");\n      } else {\n        exhaustive(params.orderBy);\n      }\n    }\n\n    const enhancers = this.createEnhancers({\n      ${Object.keys(subsetKeys)\n        .map(\n          (key) => `${key}: (row) => ({\n          ...row,\n          // 서브셋별로 virtual 필드 계산로직 추가\n        }),`,\n        )\n        .join(\"\\n\")}\n    });\n\n    return this.executeSubsetQuery({\n      subset,\n      qb,\n      params,\n      enhancers,\n      debug: false,\n    });\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async save(\n    spa: ${entityId}SaveParams[]\n  ): Promise<${idTsType}[]> {\n    const wdb = this.getPuri(\"w\");\n\n    // register\n    spa.forEach((sp) => {\n      wdb.ubRegister(\"${entity.table}\", sp);\n    });\n\n    // transaction\n    return wdb.transaction(async (trx) => {\n      const ids = await trx.ubUpsert(\"${entity.table}\");\n\n      return ids;\n    });\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"], guards: [ \"admin\" ] })\n  async del(ids: ${idTsType}[]): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n\n    // transaction\n    await wdb.transaction(async (trx) => {\n      return trx.table(\"${entity.table}\").whereIn(\"${entity.table}.id\", ids).delete();\n    });\n\n    return ids.length;\n  }\n}\n\nexport const ${entityId}Model = new ${entityId}ModelClass();\n      `.trim(),\n      importKeys: [],\n    };\n  }\n}\n"],"mappings":";;;;;;;;SAEkC;oBACyB;WAElB;cAEH;mBACmC;AAEzE,IAAa,kBAAb,cAAqC,SAAS;CAC5C,cAAc;EACZ,MAAM,OAAO;CACf;CAEA,iBAAiB,OAA0B;EACzC,MAAM,EAAE,QAAQ,OAAO,OAAO;EAE9B,OAAO;GACL,QAAQ,GAAG,IAAI;GACf,MAAM,GAAG,MAAM,GAAG,GAAG,MAAM,GAAG;EAChC;CACF;CAEA,sBAAgD;EAC9C,OAAO,CAAC,wBAAwB,0BAA0B;CAC5D;CAEA,MAAM,OAAO,EAAE,YAAsC;EACnD,MAAM,EAAE,UAAU,EAAE,SAAS,CAAC;EAG9B,MAAM,iBAAiB,uBAAuB,MADd,eAAe,GAAG,SAAS,WAAW,CACP;EAG/D,MAAM,cAAc,MADW,eAAe,GAAG,SAAS,UAAU,EAChD,CAA+B;EAEnD,MAAM,QAAQ,cAAc,eAAe,QAAQ;EACnD,MAAM,SAAS,cAAc,IAAI,QAAQ;EAEzC,MAAM,QAAQ,IAAI,oBAAoB;EACtC,IAAI,gBAAgB,aAAa,QAC/B,MAAM,IAAI,MAAM,yBAAyB,UAAU;EAErD,MAAM,MAAM,MAAM,WAAW,eAAe,QAAQ;EAGpD,MAAM,gBAAgB,+BAA+B,MAAM,QAAQ;EACnE,MAAM,0BAA0B;EAGhC,MAAM,SAAS,OAAO,UAAU;EAChC,MAAM,WAAW,WAAW,YAAY,WAAW,SAAS,WAAW;EAEvE,OAAO;GACL,GAAG,KAAK,iBAAiB,KAAK;GAC9B,MAAM;;;IAGR,SAAS;IACT,SAAS;;;IAGT,MAAM,MAAM;IACZ,MAAM,MAAM;;WAEL,SAAS,cAAc,SAAS,uBAAuB,MAAM,GAAG;;;;IAIvE,SAAS;;QAEL,SAAS;IACb,SAAS;IACT,SAAS;WACF,MAAM,MAAM;WACZ,MAAM,MAAM;;;aAGV,SAAS,KAAK,MAAM,MAAM,iBAAiB,MAAM,MAAM;;;mFAGe,SAAS;6BAC/D,SAAS;;UAE5B,SAAS;eACJ,SAAS;;;;;;;oCAOY,cAAc;;;;;;4BAMtB,SAAS;;kBAEnB,SAAS;eACZ,SAAS;;;;;;;;;;mFAU2D,MAAM,cAAc;6BAC1E,SAAS,wBAAwB,SAAS;;;8BAGzC,SAAS;;;;;iBAKtB,IAAI,OAAO;kBACV,IAAI,QAAQ;;kBAEZ,SAAS;;;;;;;oBAOP,OAAO,MAAM;;;;;;oBAMb,OAAO,MAAM,QAAQ,aAAa,WAAW,mBAAmB,yBAAyB;;yBAEpF,OAAO,MAAM;;wCAEE,wBAAwB;;;;;;;;sBAQ1C,OAAO,MAAM;;;;;;;QAO3B,OAAO,KAAK,UAAU,CAAC,CACtB,KACE,QAAQ,GAAG,IAAI;;;YAIlB,CAAC,CACA,KAAK,IAAI,EAAE;;;;;;;;;;;;;;WAcT,SAAS;eACL,SAAS;;;;;wBAKA,OAAO,MAAM;;;;;wCAKG,OAAO,MAAM;;;;;;;mBAOlC,SAAS;;;;;0BAKF,OAAO,MAAM,cAAc,OAAO,MAAM;;;;;;;eAOnD,SAAS,cAAc,SAAS;QACvC,KAAK;GACP,YAAY,CAAC;EACf;CACF;AACF"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"model.template.js","names":[],"sources":["../../../src/template/implementations/model.template.ts"],"sourcesContent":["import type z from \"zod\";\n\nimport { Sonamu } from \"../../api\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport { type EntityNamesRecord } from \"../../entity/entity-manager\";\nimport { Naite } from \"../../naite/naite\";\nimport { type TemplateOptions } from \"../../types/types\";\nimport { Template } from \"../template\";\nimport { getZodTypeById, zodTypeToRenderingNode } from \"../zod-converter\";\nimport { Template__view_list } from \"./view_list.template\";\nexport class Template__model extends Template {\n  constructor() {\n    super(\"model\");\n  }\n\n  getTargetAndPath(names: EntityNamesRecord) {\n    const { dir } = Sonamu.config.api;\n\n    return {\n      target: `${dir}/src/application`,\n      path: `${names.fs}/${names.fs}.model.ts`,\n    };\n  }\n\n  override getRequiredDictKeys(): string[] | null {\n    return [\"error.entityNotFound\", \"error.unknownSearchField\"];\n  }\n\n  async render({ entityId }: TemplateOptions[\"model\"]) {\n    Naite.t(\"render\", { entityId });\n\n    const listParamsZodType = await getZodTypeById(`${entityId}ListParams`);\n    const listParamsNode = zodTypeToRenderingNode(listParamsZodType);\n\n    const subsetKeyZodType = await getZodTypeById(`${entityId}SubsetKey`);\n    const subsetKeys =\n      /* SAFETY: 생성된 *SubsetKey 타입은 enum 스키마로 등록된다. */ (subsetKeyZodType as z.ZodEnum)\n        .enum;\n\n    const names = EntityManager.getNamesFromId(entityId);\n    const entity = EntityManager.get(entityId);\n\n    const vlTpl = new Template__view_list();\n    if (listParamsNode?.children === undefined) {\n      throw new Error(`listParamsNode가 없습니다. ${entityId}`);\n    }\n    const def = vlTpl.getDefault(listParamsNode.children);\n\n    // 에러 메시지 생성\n    const notFoundError = `SD(\"error.entityNotFound\")(\"${names.capital}\", id)`;\n    const unknownSearchFieldError = `SD(\"error.unknownSearchField\")(params.search)`;\n\n    // PK 타입에 따른 TypeScript 타입 결정\n    const pkType = entity.getPkType();\n    const idTsType = pkType === \"string\" || pkType === \"uuid\" ? \"string\" : \"number\";\n\n    return {\n      ...this.getTargetAndPath(names),\n      body: `\nimport { BaseModelClass, type ListResult, asArray, NotFoundException, BadRequestException, api, exhaustive } from 'sonamu';\nimport {\n  ${entityId}SubsetKey,\n  ${entityId}SubsetMapping,\n} from \"../sonamu.generated\";\nimport {\n  ${names.camel}SubsetQueries,\n  ${names.camel}LoaderQueries,\n} from \"../sonamu.generated.sso\";\nimport { ${entityId}ListParams, ${entityId}SaveParams } from \"./${names.fs}.types\";\nimport { SD } from \"../../i18n/sd.generated\";\n\n/*\n  ${entityId} Model\n*/\nclass ${entityId}ModelClass extends BaseModelClass<\n  ${entityId}SubsetKey,\n  ${entityId}SubsetMapping,\n  typeof ${names.camel}SubsetQueries,\n  typeof ${names.camel}LoaderQueries\n> {\n  constructor() {\n    super(\"${entityId}\", ${names.camel}SubsetQueries, ${names.camel}LoaderQueries);\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"${entityId}\" })\n  async findById<T extends ${entityId}SubsetKey>(\n    subset: T,\n    id: ${idTsType}\n  ): Promise<${entityId}SubsetMapping[T]> {\n    const { rows } = await this.findMany(subset, {\n      id,\n      num: 1,\n      page: 1,\n    });\n    if (!rows[0]) {\n      throw new NotFoundException(${notFoundError});\n    }\n\n    return rows[0];\n  }\n\n  async findOne<T extends ${entityId}SubsetKey>(\n    subset: T,\n    listParams: ${entityId}ListParams\n  ): Promise<${entityId}SubsetMapping[T] | null> {\n    const { rows } = await this.findMany(subset, {\n      ...listParams,\n      num: 1,\n      page: 1,\n    });\n\n    return rows[0] ?? null;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"${names.capitalPlural}\" })\n  async findMany<T extends ${entityId}SubsetKey, LP extends ${entityId}ListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): Promise<ListResult<LP, ${entityId}SubsetMapping[T]>> {\n    // params with defaults\n    const params = {\n      num: 24,\n      page: 1,\n      search: \"${def.search}\" as const,\n      orderBy: \"${def.orderBy}\" as const,\n      ...rawParams,\n    } satisfies ${entityId}ListParams;\n\n    // build queries\n    const { qb, onSubset: _ } = this.getSubsetQueries(subset);\n    \n    // id\n    if (params.id) {\n      qb.whereIn(\"${entity.table}.id\", asArray(params.id));\n    }\n\n    // search-keyword\n    if (params.search && params.keyword && params.keyword.length > 0) {\n      if (params.search === \"id\") {\n        qb.where(\"${entity.table}.id\", ${idTsType === \"string\" ? \"params.keyword\" : \"Number(params.keyword)\"});\n        // } else if (params.search === \"field\") {\n        //   qb.where(\"${entity.table}.field\", \"like\", \\`%\\${params.keyword}%\\`);\n      } else {\n        throw new BadRequestException(${unknownSearchFieldError});\n      }\n    }\n      \n    // orderBy\n    if (params.orderBy) {\n      // default orderBy\n      if (params.orderBy === \"id-desc\") {\n        qb.orderBy(\"${entity.table}.id\", \"desc\");\n      } else {\n        exhaustive(params.orderBy);\n      }\n    }\n\n    const enhancers = this.createEnhancers({\n      ${Object.keys(subsetKeys)\n        .map(\n          (key) => `${key}: (row) => ({\n          ...row,\n          // 서브셋별로 virtual 필드 계산로직 추가\n        }),`,\n        )\n        .join(\"\\n\")}\n    });\n\n    return this.executeSubsetQuery({\n      subset,\n      qb,\n      params,\n      enhancers,\n      debug: false,\n    });\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async save(\n    spa: ${entityId}SaveParams[]\n  ): Promise<${idTsType}[]> {\n    const wdb = this.getPuri(\"w\");\n\n    // register\n    spa.forEach((sp) => {\n      wdb.ubRegister(\"${entity.table}\", sp);\n    });\n\n    // transaction\n    return wdb.transaction(async (trx) => {\n      const ids = await trx.ubUpsert(\"${entity.table}\");\n\n      return ids;\n    });\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"], guards: [ \"admin\" ] })\n  async del(ids: ${idTsType}[]): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n\n    // transaction\n    await wdb.transaction(async (trx) => {\n      return trx.table(\"${entity.table}\").whereIn(\"${entity.table}.id\", ids).delete();\n    });\n\n    return ids.length;\n  }\n}\n\nexport const ${entityId}Model = new ${entityId}ModelClass();\n      `.trim(),\n      importKeys: [],\n    };\n  }\n}\n"],"mappings":";;;;;;;;SAEkC;oBACyB;WAElB;cAEH;mBACmC;AAEzE,IAAa,kBAAb,cAAqC,SAAS;CAC5C,cAAc;EACZ,MAAM,OAAO;CACf;CAEA,iBAAiB,OAA0B;EACzC,MAAM,EAAE,QAAQ,OAAO,OAAO;EAE9B,OAAO;GACL,QAAQ,GAAG,IAAI;GACf,MAAM,GAAG,MAAM,GAAG,GAAG,MAAM,GAAG;EAChC;CACF;CAEA,sBAAgD;EAC9C,OAAO,CAAC,wBAAwB,0BAA0B;CAC5D;CAEA,MAAM,OAAO,EAAE,YAAsC;EACnD,MAAM,EAAE,UAAU,EAAE,SAAS,CAAC;EAG9B,MAAM,iBAAiB,uBAAuB,MADd,eAAe,GAAG,SAAS,WAAW,CACP;EAG/D,MAAM,cAC8C,MAFrB,eAAe,GAAG,SAAS,UAAU,EAEhB,CAC/C;EAEL,MAAM,QAAQ,cAAc,eAAe,QAAQ;EACnD,MAAM,SAAS,cAAc,IAAI,QAAQ;EAEzC,MAAM,QAAQ,IAAI,oBAAoB;EACtC,IAAI,gBAAgB,aAAa,QAC/B,MAAM,IAAI,MAAM,yBAAyB,UAAU;EAErD,MAAM,MAAM,MAAM,WAAW,eAAe,QAAQ;EAGpD,MAAM,gBAAgB,+BAA+B,MAAM,QAAQ;EACnE,MAAM,0BAA0B;EAGhC,MAAM,SAAS,OAAO,UAAU;EAChC,MAAM,WAAW,WAAW,YAAY,WAAW,SAAS,WAAW;EAEvE,OAAO;GACL,GAAG,KAAK,iBAAiB,KAAK;GAC9B,MAAM;;;IAGR,SAAS;IACT,SAAS;;;IAGT,MAAM,MAAM;IACZ,MAAM,MAAM;;WAEL,SAAS,cAAc,SAAS,uBAAuB,MAAM,GAAG;;;;IAIvE,SAAS;;QAEL,SAAS;IACb,SAAS;IACT,SAAS;WACF,MAAM,MAAM;WACZ,MAAM,MAAM;;;aAGV,SAAS,KAAK,MAAM,MAAM,iBAAiB,MAAM,MAAM;;;mFAGe,SAAS;6BAC/D,SAAS;;UAE5B,SAAS;eACJ,SAAS;;;;;;;oCAOY,cAAc;;;;;;4BAMtB,SAAS;;kBAEnB,SAAS;eACZ,SAAS;;;;;;;;;;mFAU2D,MAAM,cAAc;6BAC1E,SAAS,wBAAwB,SAAS;;;8BAGzC,SAAS;;;;;iBAKtB,IAAI,OAAO;kBACV,IAAI,QAAQ;;kBAEZ,SAAS;;;;;;;oBAOP,OAAO,MAAM;;;;;;oBAMb,OAAO,MAAM,QAAQ,aAAa,WAAW,mBAAmB,yBAAyB;;yBAEpF,OAAO,MAAM;;wCAEE,wBAAwB;;;;;;;;sBAQ1C,OAAO,MAAM;;;;;;;QAO3B,OAAO,KAAK,UAAU,CAAC,CACtB,KACE,QAAQ,GAAG,IAAI;;;YAIlB,CAAC,CACA,KAAK,IAAI,EAAE;;;;;;;;;;;;;;WAcT,SAAS;eACL,SAAS;;;;;wBAKA,OAAO,MAAM;;;;;wCAKG,OAAO,MAAM;;;;;;;mBAOlC,SAAS;;;;;0BAKF,OAAO,MAAM,cAAc,OAAO,MAAM;;;;;;;eAOnD,SAAS,cAAc,SAAS;QACvC,KAAK;GACP,YAAY,CAAC;EACf;CACF;AACF"}

package/dist/template/implementations/queries.template.js

@@ -1,6 +1,6 @@
-import { Sonamu, init_sonamu } from "../../api/sonamu.js";
 import { ApiParamType, init_types } from "../../types/types.js";
 import { apiParamToTsCode, apiParamTypeToTsType, init_code_converters } from "../../api/code-converters.js";
+import { Sonamu, init_sonamu } from "../../api/sonamu.js";
 import { Template, init_template } from "../template.js";
 import inflection from "inflection";
 import { diff, unique } from "radashi";

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

@@ -1 +1 @@
-{"version":3,"file":"sd.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/sd.template.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC;;;GAGG;AACH,qBAAa,YAAa,SAAQ,QAAQ;;IAKxC,gBAAgB,CAAC,MAAM,CAAC,EAAE,iBAAiB,EAAE,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK;;;;IAW7E,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC,IAAI,CAAC;;;;;;;IA6RrC;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAoC/B;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAiC3B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAYhC,OAAO,CAAC,YAAY;CAGrB"}
+{"version":3,"file":"sd.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/sd.template.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC;;;GAGG;AACH,qBAAa,YAAa,SAAQ,QAAQ;;IAKxC,gBAAgB,CAAC,MAAM,CAAC,EAAE,iBAAiB,EAAE,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK;;;;IAW7E,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC,IAAI,CAAC;;;;;;;IAqUrC;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAoC/B;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAiC3B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAYhC,OAAO,CAAC,YAAY;CAGrB"}