sonamu 0.8.26 → 0.9.0

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

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