sonamu 0.8.26 → 0.9.0

package/dist/api/decorators.js

@@ -1,283 +1,260 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { convertDomainToCategory, init_category } from "../logger/category.js";
+import { DB, init_db } from "../database/db.js";
+import { UpsertBuilder, init_upsert_builder } from "../database/upsert-builder.js";
+import { BaseFrameClass, init_base_frame } from "./base-frame.js";
+import { PuriTransactionWrapper, init_puri_wrapper } from "../database/puri-wrapper.js";
+import { BaseModelClass, init_base_model } from "../database/base-model.js";
 import { getLogger } from "@logtape/logtape";
-import assert from "assert";
 import inflection from "inflection";
 import { isEqual } from "radashi";
-import { BaseModelClass } from "../database/base-model.js";
-import { DB } from "../database/db.js";
-import { PuriTransactionWrapper } from "../database/puri-wrapper.js";
-import { UpsertBuilder } from "../database/upsert-builder.js";
-import { convertDomainToCategory } from "../logger/category.js";
-import { BaseFrameClass } from "./base-frame.js";
-export const registeredApis = [];
-const DECORATOR_TYPES = {
-    API: Symbol("api"),
-    STREAM: Symbol("stream"),
-    UPLOAD: Symbol("upload")
-};
+import assert from "assert";
+
+//#region src/api/decorators.ts
 function checkSingleDecorator(target, propertyKey, decoratorType) {
-    const method = target[propertyKey];
-    if (method?.__decoratorType && method?.__decoratorType !== decoratorType) {
-        throw new Error(`@${decoratorType.description ?? String(decoratorType)} decorator can only be used once on ${target.constructor.name}.${propertyKey}. You can use only one of @api or @stream decorator on the same method.`);
-    } else {
-        method.__decoratorType = decoratorType;
-    }
+	const method = target[propertyKey];
+	if (method?.__decoratorType && method?.__decoratorType !== decoratorType) {
+		throw new Error(`@${decoratorType.description ?? String(decoratorType)} decorator can only be used once on ${target.constructor.name}.${propertyKey}. You can use only one of @api or @stream decorator on the same method.`);
+	} else {
+		method.__decoratorType = decoratorType;
+	}
 }
-export function api(options = {}) {
-    options = {
-        httpMethod: "GET",
-        contentType: "application/json",
-        clients: [
-            "axios"
-        ],
-        ...options
-    };
-    return (target, propertyKey, descriptor)=>{
-        const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];
-        assert(modelName, `modelName is required on @api decorator on ${target.constructor.name}.${propertyKey}`);
-        const methodName = propertyKey;
-        // 메서드에 걸린 데코레이터 중복 체크
-        checkSingleDecorator(target, propertyKey, DECORATOR_TYPES.API);
-        const defaultPath = `/${inflection.camelize(modelName.replace(/Model$/, "").replace(/Frame$/, ""), true)}/${inflection.camelize(propertyKey, true)}`;
-        const path = options.path ?? defaultPath;
-        // 기존 동일한 메서드가 있는지 확인 후 있는 경우 override
-        const existingApi = registeredApis.find((api)=>api.modelName === modelName && api.methodName === methodName);
-        if (existingApi) {
-            // 기존의 path와 새로운 path가 다르다면(=빈 스트링이 아니었는데 다른 스트링으로 바뀌게 된다면) 에러를 터뜨려줍니다.
-            assertNoConflictingPath("api", modelName, methodName, existingApi.path, path);
-            existingApi.path = path;
-            // 기존의 옵션과 새로운 옵션이 겹치는 부분이 있다면 에러를 터뜨려줍니다.
-            assertNoConflictingOptions("api", modelName, methodName, existingApi.options, options);
-            existingApi.options = {
-                ...existingApi.options,
-                ...options
-            };
-        } else {
-            registeredApis.push({
-                modelName,
-                methodName,
-                path,
-                options
-            });
-        }
-        const originalMethod = descriptor.value;
-        descriptor.value = async function(...args) {
-            if (this instanceof BaseModelClass) {
-                getLogger(convertDomainToCategory(this.modelName, "model")).debug("api: {httpMethod} {model}.{method}", {
-                    httpMethod: options.httpMethod,
-                    model: modelName,
-                    method: methodName
-                });
-            }
-            if (this instanceof BaseFrameClass) {
-                getLogger(convertDomainToCategory(this.frameName, "frame")).debug("api: {httpMethod} {model}.{method}", {
-                    httpMethod: options.httpMethod,
-                    model: modelName,
-                    method: methodName
-                });
-            }
-            return originalMethod.apply(this, args);
-        };
-    };
+function api(options = {}) {
+	options = {
+		httpMethod: "GET",
+		contentType: "application/json",
+		clients: ["axios"],
+		...options
+	};
+	return (target, propertyKey, descriptor) => {
+		const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];
+		assert(modelName, `modelName is required on @api decorator on ${target.constructor.name}.${propertyKey}`);
+		const methodName = propertyKey;
+		checkSingleDecorator(target, propertyKey, DECORATOR_TYPES.API);
+		const defaultPath = `/${inflection.camelize(modelName.replace(/Model$/, "").replace(/Frame$/, ""), true)}/${inflection.camelize(propertyKey, true)}`;
+		const path = options.path ?? defaultPath;
+		const existingApi = registeredApis.find((api$1) => api$1.modelName === modelName && api$1.methodName === methodName);
+		if (existingApi) {
+			assertNoConflictingPath("api", modelName, methodName, existingApi.path, path);
+			existingApi.path = path;
+			assertNoConflictingOptions("api", modelName, methodName, existingApi.options, options);
+			existingApi.options = {
+				...existingApi.options,
+				...options
+			};
+		} else {
+			registeredApis.push({
+				modelName,
+				methodName,
+				path,
+				options
+			});
+		}
+		const originalMethod = descriptor.value;
+		descriptor.value = async function(...args) {
+			if (this instanceof BaseModelClass) {
+				getLogger(convertDomainToCategory(this.modelName, "model")).debug("api: {httpMethod} {model}.{method}", {
+					httpMethod: options.httpMethod,
+					model: modelName,
+					method: methodName
+				});
+			}
+			if (this instanceof BaseFrameClass) {
+				getLogger(convertDomainToCategory(this.frameName, "frame")).debug("api: {httpMethod} {model}.{method}", {
+					httpMethod: options.httpMethod,
+					model: modelName,
+					method: methodName
+				});
+			}
+			return originalMethod.apply(this, args);
+		};
+	};
 }
-export function stream(options) {
-    return (target, propertyKey, descriptor)=>{
-        const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];
-        assert(modelName, `modelName is required on @stream decorator on ${target.constructor.name}.${propertyKey}`);
-        const methodName = propertyKey;
-        // 메서드에 걸린 데코레이터 중복 체크
-        checkSingleDecorator(target, propertyKey, DECORATOR_TYPES.STREAM);
-        const defaultPath = `/${inflection.camelize(modelName.replace(/Model$/, "").replace(/Frame$/, ""), true)}/${inflection.camelize(propertyKey, true)}`;
-        const path = options.path ?? defaultPath;
-        // stream 전용 필드(events, type)는 ApiDecoratorOptions에 속하지 않으므로 제외
-        const { events: _, type: _type, ...apiOptions } = options;
-        const optionsWithDefaults = {
-            ...apiOptions,
-            httpMethod: "GET"
-        };
-        const existingApi = registeredApis.find((api)=>api.modelName === modelName && api.methodName === methodName);
-        if (existingApi) {
-            // 기존의 path와 새로운 path가 다르다면(=빈 스트링이 아니었는데 다른 스트링으로 바뀌게 된다면) 에러를 터뜨려줍니다.
-            assertNoConflictingPath("stream", modelName, methodName, existingApi.path, path);
-            existingApi.path = path;
-            // 기존의 옵션과 새로운 옵션이 겹치는 부분이 있다면 에러를 터뜨려줍니다.
-            assertNoConflictingOptions("stream", modelName, methodName, existingApi.options, optionsWithDefaults);
-            existingApi.options = {
-                ...existingApi.options,
-                ...optionsWithDefaults
-            };
-            existingApi.streamOptions = options;
-        } else {
-            registeredApis.push({
-                modelName,
-                methodName,
-                path,
-                options: optionsWithDefaults,
-                streamOptions: options
-            });
-        }
-        const originalMethod = descriptor.value;
-        descriptor.value = async function(...args) {
-            if (this instanceof BaseModelClass) {
-                getLogger(convertDomainToCategory(this.modelName, "model")).debug("stream: {model}.{method}", {
-                    model: modelName,
-                    method: methodName
-                });
-            }
-            if (this instanceof BaseFrameClass) {
-                getLogger(convertDomainToCategory(this.frameName, "frame")).debug("stream: {model}.{method}", {
-                    model: modelName,
-                    method: methodName
-                });
-            }
-            return originalMethod.apply(this, args);
-        };
-    };
+function stream(options) {
+	return (target, propertyKey, descriptor) => {
+		const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];
+		assert(modelName, `modelName is required on @stream decorator on ${target.constructor.name}.${propertyKey}`);
+		const methodName = propertyKey;
+		checkSingleDecorator(target, propertyKey, DECORATOR_TYPES.STREAM);
+		const defaultPath = `/${inflection.camelize(modelName.replace(/Model$/, "").replace(/Frame$/, ""), true)}/${inflection.camelize(propertyKey, true)}`;
+		const path = options.path ?? defaultPath;
+		const { events: _, type: _type, ...apiOptions } = options;
+		const optionsWithDefaults = {
+			...apiOptions,
+			httpMethod: "GET"
+		};
+		const existingApi = registeredApis.find((api$1) => api$1.modelName === modelName && api$1.methodName === methodName);
+		if (existingApi) {
+			assertNoConflictingPath("stream", modelName, methodName, existingApi.path, path);
+			existingApi.path = path;
+			assertNoConflictingOptions("stream", modelName, methodName, existingApi.options, optionsWithDefaults);
+			existingApi.options = {
+				...existingApi.options,
+				...optionsWithDefaults
+			};
+			existingApi.streamOptions = options;
+		} else {
+			registeredApis.push({
+				modelName,
+				methodName,
+				path,
+				options: optionsWithDefaults,
+				streamOptions: options
+			});
+		}
+		const originalMethod = descriptor.value;
+		descriptor.value = async function(...args) {
+			if (this instanceof BaseModelClass) {
+				getLogger(convertDomainToCategory(this.modelName, "model")).debug("stream: {model}.{method}", {
+					model: modelName,
+					method: methodName
+				});
+			}
+			if (this instanceof BaseFrameClass) {
+				getLogger(convertDomainToCategory(this.frameName, "frame")).debug("stream: {model}.{method}", {
+					model: modelName,
+					method: methodName
+				});
+			}
+			return originalMethod.apply(this, args);
+		};
+	};
 }
-export function transactional(options = {}) {
-    const { isolation, readOnly, dbPreset = "w" } = options;
-    return (target, propertyKey, descriptor)=>{
-        const originalMethod = descriptor.value;
-        const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];
-        assert(modelName, `modelName is required on @stream decorator on ${target.constructor.name}.${propertyKey}`);
-        const methodName = propertyKey;
-        descriptor.value = async function(...args) {
-            this.logger.debug("transactional: {model}.{method}", {
-                model: modelName,
-                method: methodName
-            });
-            const existingContext = DB.transactionStorage.getStore();
-            // AsyncLocalStorage 컨텍스트 없거나 해당 preset의 트랜잭션이 없으면 새로 시작
-            const startTransaction = async ()=>{
-                const puri = this.getPuri(dbPreset);
-                return puri.knex.transaction(async (trx)=>{
-                    this.logger.debug("new transaction context: {dbPreset}", {
-                        dbPreset
-                    });
-                    const trxWrapper = new PuriTransactionWrapper(trx, new UpsertBuilder());
-                    // TransactionContext에 트랜잭션 저장
-                    DB.getTransactionContext().setTransaction(dbPreset, trxWrapper);
-                    try {
-                        return await originalMethod.apply(this, args);
-                    } finally{
-                        // 트랜잭션 제거
-                        this.logger.debug("delete transaction context: {dbPreset}", {
-                            dbPreset
-                        });
-                        DB.getTransactionContext().deleteTransaction(dbPreset);
-                    }
-                }, {
-                    isolationLevel: isolation,
-                    readOnly
-                });
-            };
-            // AsyncLocalStorage 컨텍스트가 없으면 새로 생성
-            if (!existingContext) {
-                return DB.runWithTransaction(startTransaction);
-            }
-            // 이미 AsyncLocalStorage 컨텍스트 안에 있는지 확인 후 해당 preset의 트랜잭션이 이미 있으면 재사용
-            if (existingContext?.getTransaction(dbPreset)) {
-                this.logger.debug("reuse transaction context: {dbPreset}", {
-                    dbPreset
-                });
-                return originalMethod.apply(this, args);
-            }
-            // 컨텍스트는 있지만 이 preset의 트랜잭션은 없는 경우 (같은 컨텍스트 내에서 실행)
-            return startTransaction();
-        };
-        return descriptor;
-    };
+function transactional(options = {}) {
+	const { isolation, readOnly, dbPreset = "w" } = options;
+	return (target, propertyKey, descriptor) => {
+		const originalMethod = descriptor.value;
+		const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];
+		assert(modelName, `modelName is required on @stream decorator on ${target.constructor.name}.${propertyKey}`);
+		const methodName = propertyKey;
+		descriptor.value = async function(...args) {
+			this.logger.debug("transactional: {model}.{method}", {
+				model: modelName,
+				method: methodName
+			});
+			const existingContext = DB.transactionStorage.getStore();
+			const startTransaction = async () => {
+				const puri = this.getPuri(dbPreset);
+				return puri.knex.transaction(async (trx) => {
+					this.logger.debug("new transaction context: {dbPreset}", { dbPreset });
+					const trxWrapper = new PuriTransactionWrapper(trx, new UpsertBuilder());
+					DB.getTransactionContext().setTransaction(dbPreset, trxWrapper);
+					try {
+						return await originalMethod.apply(this, args);
+					} finally {
+						this.logger.debug("delete transaction context: {dbPreset}", { dbPreset });
+						DB.getTransactionContext().deleteTransaction(dbPreset);
+					}
+				}, {
+					isolationLevel: isolation,
+					readOnly
+				});
+			};
+			if (!existingContext) {
+				return DB.runWithTransaction(startTransaction);
+			}
+			if (existingContext?.getTransaction(dbPreset)) {
+				this.logger.debug("reuse transaction context: {dbPreset}", { dbPreset });
+				return originalMethod.apply(this, args);
+			}
+			return startTransaction();
+		};
+		return descriptor;
+	};
 }
 /**
- * 파일 업로드 API를 생성해줍니다. (@api 데코레이터 없이 독립적으로 사용)
- * @param options
- * @returns
- */ export function upload(options = {
-    consume: "buffer"
-}) {
-    return (target, propertyKey, descriptor)=>{
-        const originalMethod = descriptor.value;
-        const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];
-        assert(modelName, `modelName is required on @upload decorator on ${target.constructor.name}.${propertyKey}`);
-        const methodName = propertyKey;
-        // 메서드에 걸린 데코레이터 중복 체크
-        checkSingleDecorator(target, propertyKey, DECORATOR_TYPES.UPLOAD);
-        const defaultPath = `/${inflection.camelize(modelName.replace(/Model$/, "").replace(/Frame$/, ""), true)}/${inflection.camelize(methodName, true)}`;
-        // registeredApis에서 해당 API 찾아서 uploadOptions 추가
-        const existingApi = registeredApis.find((api)=>api.modelName === modelName && api.methodName === methodName);
-        if (existingApi) {
-            // 재등록 시 업로드 옵션만 갱신
-            existingApi.uploadOptions = options;
-        } else {
-            // 새로 등록
-            registeredApis.push({
-                modelName,
-                methodName,
-                path: defaultPath,
-                options: {
-                    httpMethod: "POST",
-                    clients: [
-                        "axios-multipart",
-                        "tanstack-mutation-multipart"
-                    ],
-                    guards: options.guards,
-                    description: options.description
-                },
-                uploadOptions: options
-            });
-        }
-        descriptor.value = async function(...args) {
-            if (this instanceof BaseModelClass) {
-                getLogger(convertDomainToCategory(this.modelName, "model")).debug("upload: {model}.{method}", {
-                    model: modelName,
-                    method: methodName
-                });
-            }
-            if (this instanceof BaseFrameClass) {
-                getLogger(convertDomainToCategory(this.frameName, "frame")).debug("upload: {model}.{method}", {
-                    model: modelName,
-                    method: methodName
-                });
-            }
-            return originalMethod.apply(this, args);
-        };
-        return descriptor;
-    };
+* 파일 업로드 API를 생성해줍니다. (@api 데코레이터 없이 독립적으로 사용)
+* @param options
+* @returns
+*/
+function upload(options = { consume: "buffer" }) {
+	return (target, propertyKey, descriptor) => {
+		const originalMethod = descriptor.value;
+		const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];
+		assert(modelName, `modelName is required on @upload decorator on ${target.constructor.name}.${propertyKey}`);
+		const methodName = propertyKey;
+		checkSingleDecorator(target, propertyKey, DECORATOR_TYPES.UPLOAD);
+		const defaultPath = `/${inflection.camelize(modelName.replace(/Model$/, "").replace(/Frame$/, ""), true)}/${inflection.camelize(methodName, true)}`;
+		const existingApi = registeredApis.find((api$1) => api$1.modelName === modelName && api$1.methodName === methodName);
+		if (existingApi) {
+			existingApi.uploadOptions = options;
+		} else {
+			registeredApis.push({
+				modelName,
+				methodName,
+				path: defaultPath,
+				options: {
+					httpMethod: "POST",
+					clients: ["axios-multipart", "tanstack-mutation-multipart"],
+					guards: options.guards,
+					description: options.description
+				},
+				uploadOptions: options
+			});
+		}
+		descriptor.value = async function(...args) {
+			if (this instanceof BaseModelClass) {
+				getLogger(convertDomainToCategory(this.modelName, "model")).debug("upload: {model}.{method}", {
+					model: modelName,
+					method: methodName
+				});
+			}
+			if (this instanceof BaseFrameClass) {
+				getLogger(convertDomainToCategory(this.frameName, "frame")).debug("upload: {model}.{method}", {
+					model: modelName,
+					method: methodName
+				});
+			}
+			return originalMethod.apply(this, args);
+		};
+		return descriptor;
+	};
 }
 /**
- * 기존의 path와 새로운 path가 다르다면(=값이 있던 스트링이 다른 값이 있는 스트링으로 바뀌게 된다면) 에러를 터뜨려줍니다.
- * @param decoratorName 데코레이터 이름
- * @param modelName 모델 이름
- * @param methodName 메서드 이름
- * @param existingPath 기존의 path
- * @param newPath 새로운 path
- */ function assertNoConflictingPath(decoratorName, modelName, methodName, existingPath, newPath) {
-    if (existingPath !== "" && newPath !== "" && existingPath !== newPath) {
-        // 이것이 무슨 상황이냐면요, api.path가 덮어씌워지는 상황입니다.
-        // 가령 @api({ path: "/api/v1/users" }) 데코레이터가 붙어있는 메서드에
-        // @stream({ path: "/api/v1/users/stream" }) 같은 것이 붙어 있는 상황입니다.
-        // 이렇게 되면 두 데코레이터가 같은 api의 path 필드를 건드리게 되므로, 에러를 터뜨려줍니다.
-        throw new Error(`@${decoratorName} decorator on ${modelName}.${methodName} has conflicting path: ${newPath}. The decorator is trying to override the existing path(${existingPath}) with the new path(${newPath}).`);
-    }
+* 기존의 path와 새로운 path가 다르다면(=값이 있던 스트링이 다른 값이 있는 스트링으로 바뀌게 된다면) 에러를 터뜨려줍니다.
+* @param decoratorName 데코레이터 이름
+* @param modelName 모델 이름
+* @param methodName 메서드 이름
+* @param existingPath 기존의 path
+* @param newPath 새로운 path
+*/
+function assertNoConflictingPath(decoratorName, modelName, methodName, existingPath, newPath) {
+	if (existingPath !== "" && newPath !== "" && existingPath !== newPath) {
+		throw new Error(`@${decoratorName} decorator on ${modelName}.${methodName} has conflicting path: ${newPath}. The decorator is trying to override the existing path(${existingPath}) with the new path(${newPath}).`);
+	}
 }
 /**
- * 기존의 옵션과 새로운 옵션이 겹치는 부분이 있다면 에러를 터뜨려줍니다.
- * @param decoratorName 데코레이터 이름
- * @param modelName 모델 이름
- * @param methodName 메서드 이름
- * @param existingOptions 기존의 옵션
- * @param newOptions 새로운 옵션
- */ function assertNoConflictingOptions(decoratorName, modelName, methodName, // biome-ignore lint/suspicious/noExplicitAny: <아 쉽게쉽게 좀 갑시다>
-existingOptions, // biome-ignore lint/suspicious/noExplicitAny: <이럴 때 아니면 any 언제 씁니까>
-newOptions) {
-    Object.keys(newOptions).forEach((key)=>{
-        if (existingOptions[key] && !isEqual(existingOptions[key], newOptions[key])) {
-            // 이것이 무슨 상황이냐면요, api.options가 덮어씌워지는 상황입니다.
-            // 가령 @api({ resourceName: "Users" }) 데코레이터가 붙어있는 메서드에
-            // @stream({ resourceName: "Posts" }) 같은 것이 붙어 있는 상황입니다.
-            // 이렇게 되면 두 데코레이터가 같은 api의 options 속 같은 필드를 건드리게 되므로, 에러를 터뜨려줍니다.
-            throw new Error(`@${decoratorName} decorator on ${modelName}.${methodName} has conflicting options: ${key}. The decorator is trying to override the existing option(${JSON.stringify(existingOptions[key])}) with the new option(${JSON.stringify(newOptions[key])}).`);
-        }
-    });
+* 기존의 옵션과 새로운 옵션이 겹치는 부분이 있다면 에러를 터뜨려줍니다.
+* @param decoratorName 데코레이터 이름
+* @param modelName 모델 이름
+* @param methodName 메서드 이름
+* @param existingOptions 기존의 옵션
+* @param newOptions 새로운 옵션
+*/
+function assertNoConflictingOptions(decoratorName, modelName, methodName, existingOptions, newOptions) {
+	Object.keys(newOptions).forEach((key) => {
+		if (existingOptions[key] && !isEqual(existingOptions[key], newOptions[key])) {
+			throw new Error(`@${decoratorName} decorator on ${modelName}.${methodName} has conflicting options: ${key}. The decorator is trying to override the existing option(${JSON.stringify(existingOptions[key])}) with the new option(${JSON.stringify(newOptions[key])}).`);
+		}
+	});
 }
+var registeredApis, DECORATOR_TYPES;
+var init_decorators = __esmMin((() => {
+	init_base_model();
+	init_db();
+	init_puri_wrapper();
+	init_upsert_builder();
+	init_category();
+	init_base_frame();
+	registeredApis = [];
+	DECORATOR_TYPES = {
+		API: Symbol("api"),
+		STREAM: Symbol("stream"),
+		UPLOAD: Symbol("upload")
+	};
+}));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/api/decorators.ts"],"sourcesContent":["import type { FastifyMultipartBaseOptions } from \"@fastify/multipart\";\nimport { getLogger } from \"@logtape/logtape\";\nimport assert from \"assert\";\nimport type { HTTPMethods } from \"fastify\";\nimport inflection from \"inflection\";\nimport { isEqual } from \"radashi\";\nimport type { z } from \"zod\";\nimport type { CacheControlConfig } from \"../cache-control/types\";\nimport type { CompressConfig } from \"../compress/types\";\nimport { BaseModelClass } from \"../database/base-model\";\nimport { DB } from \"../database/db\";\nimport {\n  PuriTransactionWrapper,\n  type PuriWrapper,\n  type TransactionalOptions,\n} from \"../database/puri-wrapper\";\nimport { UpsertBuilder } from \"../database/upsert-builder\";\nimport { convertDomainToCategory } from \"../logger/category\";\nimport type { DriverKey } from \"../storage/drivers\";\nimport type { KeyGenerator } from \"../storage/types\";\nimport type { ApiParam, ApiParamType } from \"../types/types\";\nimport { BaseFrameClass } from \"./base-frame\";\n\nexport interface GuardKeys {\n  query: true;\n  admin: true;\n  user: true;\n}\nexport type GuardKey = keyof GuardKeys;\nexport type ServiceClient =\n  | \"axios\"\n  | \"axios-multipart\"\n  | \"tanstack-query\"\n  | \"tanstack-mutation\"\n  | \"tanstack-mutation-multipart\"\n  | \"window-fetch\";\nexport type ApiDecoratorOptions = {\n  httpMethod?: HTTPMethods;\n  contentType?:\n    | \"text/plain\"\n    | \"text/html\"\n    | \"text/xml\"\n    | \"application/json\"\n    | \"application/octet-stream\";\n  clients?: ServiceClient[];\n  path?: string;\n  resourceName?: string;\n  guards?: GuardKey[];\n  description?: string;\n  timeout?: number;\n  /** API 응답의 Cache-Control 헤더 설정. 설정하지 않으면 cacheControlHandler 또는 기본값이 적용됩니다. */\n  cacheControl?: CacheControlConfig;\n  /** API 응답의 압축 설정. false로 설정하면 압축을 비활성화합니다. */\n  compress?: CompressConfig;\n};\nexport type StreamDecoratorOptions = {\n  type: \"sse\"; // | 'ws\n  // biome-ignore lint/suspicious/noExplicitAny: 이벤트 키별로 넘겨주는 값이므로 어떤 타입이든 상관없음\n  events: z.ZodObject<any>;\n  path?: string;\n  resourceName?: string;\n  guards?: GuardKey[];\n  description?: string;\n};\n\ntype BufferUploadOptions = {\n  consume?: \"buffer\";\n};\ntype StreamUploadOptions = {\n  consume: \"stream\";\n  destination: DriverKey;\n  keyGenerator?: KeyGenerator;\n};\nexport type UploadDecoratorOptions = {\n  guards?: GuardKey[];\n  description?: string;\n  limits?: FastifyMultipartBaseOptions[\"limits\"];\n} & (BufferUploadOptions | StreamUploadOptions);\n\nexport const registeredApis: {\n  /**\n   * modelName은 모델 클래스 이름입니다. (ex. \"UserModel\")\n   */\n  modelName: string;\n  methodName: string;\n  path: string;\n  options: ApiDecoratorOptions;\n  streamOptions?: StreamDecoratorOptions;\n  uploadOptions?: UploadDecoratorOptions;\n}[] = [];\nexport type ExtendedApi = {\n  modelName: string;\n  methodName: string;\n  path: string;\n  options: ApiDecoratorOptions;\n  streamOptions?: StreamDecoratorOptions;\n  uploadOptions?: UploadDecoratorOptions;\n  typeParameters: ApiParamType.TypeParam[];\n  parameters: ApiParam[];\n  returnType: ApiParamType;\n};\ntype DecoratorTarget = { constructor: { name: string } };\n\nconst DECORATOR_TYPES = {\n  API: Symbol(\"api\"),\n  STREAM: Symbol(\"stream\"),\n  UPLOAD: Symbol(\"upload\"),\n} as const;\n\nfunction checkSingleDecorator(target: DecoratorTarget, propertyKey: string, decoratorType: symbol) {\n  const method = target[propertyKey as keyof typeof target] as { __decoratorType?: symbol };\n  if (method?.__decoratorType && method?.__decoratorType !== decoratorType) {\n    throw new Error(\n      `@${decoratorType.description ?? String(decoratorType)} decorator can only be used once on ${target.constructor.name}.${propertyKey}. You can use only one of @api or @stream decorator on the same method.`,\n    );\n  } else {\n    method.__decoratorType = decoratorType;\n  }\n}\n\nexport function api(options: ApiDecoratorOptions = {}) {\n  options = {\n    httpMethod: \"GET\",\n    contentType: \"application/json\",\n    clients: [\"axios\"],\n    ...options,\n  };\n\n  return (target: DecoratorTarget, propertyKey: string, descriptor: PropertyDescriptor) => {\n    const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];\n    assert(\n      modelName,\n      `modelName is required on @api decorator on ${target.constructor.name}.${propertyKey}`,\n    );\n    const methodName = propertyKey;\n\n    // 메서드에 걸린 데코레이터 중복 체크\n    checkSingleDecorator(target, propertyKey, DECORATOR_TYPES.API);\n\n    const defaultPath = `/${inflection.camelize(\n      modelName.replace(/Model$/, \"\").replace(/Frame$/, \"\"),\n      true,\n    )}/${inflection.camelize(propertyKey, true)}`;\n    const path = options.path ?? defaultPath;\n\n    // 기존 동일한 메서드가 있는지 확인 후 있는 경우 override\n    const existingApi = registeredApis.find(\n      (api) => api.modelName === modelName && api.methodName === methodName,\n    );\n    if (existingApi) {\n      // 기존의 path와 새로운 path가 다르다면(=빈 스트링이 아니었는데 다른 스트링으로 바뀌게 된다면) 에러를 터뜨려줍니다.\n      assertNoConflictingPath(\"api\", modelName, methodName, existingApi.path, path);\n      existingApi.path = path;\n\n      // 기존의 옵션과 새로운 옵션이 겹치는 부분이 있다면 에러를 터뜨려줍니다.\n      assertNoConflictingOptions(\"api\", modelName, methodName, existingApi.options, options);\n      existingApi.options = {\n        ...existingApi.options, // 기존의 옵션을 존중하되\n        ...options, // @api 데코레이터의 옵션을 추가합니다.\n      };\n    } else {\n      registeredApis.push({\n        modelName,\n        methodName,\n        path,\n        options,\n      });\n    }\n\n    const originalMethod = descriptor.value;\n    descriptor.value = async function (this: BaseModelClass | BaseFrameClass, ...args: unknown[]) {\n      if (this instanceof BaseModelClass) {\n        getLogger(convertDomainToCategory(this.modelName, \"model\")).debug(\n          \"api: {httpMethod} {model}.{method}\",\n          {\n            httpMethod: options.httpMethod,\n            model: modelName,\n            method: methodName,\n          },\n        );\n      }\n\n      if (this instanceof BaseFrameClass) {\n        getLogger(convertDomainToCategory(this.frameName, \"frame\")).debug(\n          \"api: {httpMethod} {model}.{method}\",\n          {\n            httpMethod: options.httpMethod,\n            model: modelName,\n            method: methodName,\n          },\n        );\n      }\n\n      return originalMethod.apply(this, args);\n    };\n  };\n}\n\nexport function stream(options: StreamDecoratorOptions) {\n  return (target: DecoratorTarget, propertyKey: string, descriptor: PropertyDescriptor) => {\n    const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];\n    assert(\n      modelName,\n      `modelName is required on @stream decorator on ${target.constructor.name}.${propertyKey}`,\n    );\n    const methodName = propertyKey;\n\n    // 메서드에 걸린 데코레이터 중복 체크\n    checkSingleDecorator(target, propertyKey, DECORATOR_TYPES.STREAM);\n\n    const defaultPath = `/${inflection.camelize(\n      modelName.replace(/Model$/, \"\").replace(/Frame$/, \"\"),\n      true,\n    )}/${inflection.camelize(propertyKey, true)}`;\n    const path = options.path ?? defaultPath;\n    // stream 전용 필드(events, type)는 ApiDecoratorOptions에 속하지 않으므로 제외\n    const { events: _, type: _type, ...apiOptions } = options;\n    const optionsWithDefaults = {\n      ...apiOptions,\n      httpMethod: \"GET\" as HTTPMethods,\n    };\n\n    const existingApi = registeredApis.find(\n      (api) => api.modelName === modelName && api.methodName === methodName,\n    );\n    if (existingApi) {\n      // 기존의 path와 새로운 path가 다르다면(=빈 스트링이 아니었는데 다른 스트링으로 바뀌게 된다면) 에러를 터뜨려줍니다.\n      assertNoConflictingPath(\"stream\", modelName, methodName, existingApi.path, path);\n      existingApi.path = path;\n\n      // 기존의 옵션과 새로운 옵션이 겹치는 부분이 있다면 에러를 터뜨려줍니다.\n      assertNoConflictingOptions(\n        \"stream\",\n        modelName,\n        methodName,\n        existingApi.options,\n        optionsWithDefaults,\n      );\n      existingApi.options = {\n        ...existingApi.options, // 기존의 옵션을 존중하되\n        ...optionsWithDefaults, // @stream 데코레이터의 옵션을 추가합니다.\n      };\n\n      existingApi.streamOptions = options;\n    } else {\n      registeredApis.push({\n        modelName,\n        methodName,\n        path,\n        options: optionsWithDefaults,\n        streamOptions: options,\n      });\n    }\n\n    const originalMethod = descriptor.value;\n    descriptor.value = async function (this: BaseModelClass | BaseFrameClass, ...args: unknown[]) {\n      if (this instanceof BaseModelClass) {\n        getLogger(convertDomainToCategory(this.modelName, \"model\")).debug(\n          \"stream: {model}.{method}\",\n          {\n            model: modelName,\n            method: methodName,\n          },\n        );\n      }\n\n      if (this instanceof BaseFrameClass) {\n        getLogger(convertDomainToCategory(this.frameName, \"frame\")).debug(\n          \"stream: {model}.{method}\",\n          {\n            model: modelName,\n            method: methodName,\n          },\n        );\n      }\n\n      return originalMethod.apply(this, args);\n    };\n  };\n}\n\nexport function transactional(options: TransactionalOptions = {}) {\n  const { isolation, readOnly, dbPreset = \"w\" } = options;\n\n  return (target: DecoratorTarget, propertyKey: string, descriptor: PropertyDescriptor) => {\n    const originalMethod = descriptor.value;\n    const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];\n    assert(\n      modelName,\n      `modelName is required on @stream decorator on ${target.constructor.name}.${propertyKey}`,\n    );\n    const methodName = propertyKey;\n\n    descriptor.value = async function (this: BaseModelClass, ...args: unknown[]) {\n      this.logger.debug(\"transactional: {model}.{method}\", {\n        model: modelName,\n        method: methodName,\n      });\n\n      const existingContext = DB.transactionStorage.getStore();\n\n      // AsyncLocalStorage 컨텍스트 없거나 해당 preset의 트랜잭션이 없으면 새로 시작\n      const startTransaction = async () => {\n        const puri = this.getPuri(dbPreset) as PuriWrapper;\n\n        return puri.knex.transaction(\n          async (trx) => {\n            this.logger.debug(\"new transaction context: {dbPreset}\", { dbPreset });\n            const trxWrapper = new PuriTransactionWrapper(trx, new UpsertBuilder());\n            // TransactionContext에 트랜잭션 저장\n            DB.getTransactionContext().setTransaction(dbPreset, trxWrapper);\n\n            try {\n              return await originalMethod.apply(this, args);\n            } finally {\n              // 트랜잭션 제거\n              this.logger.debug(\"delete transaction context: {dbPreset}\", { dbPreset });\n              DB.getTransactionContext().deleteTransaction(dbPreset);\n            }\n          },\n          { isolationLevel: isolation, readOnly },\n        );\n      };\n\n      // AsyncLocalStorage 컨텍스트가 없으면 새로 생성\n      if (!existingContext) {\n        return DB.runWithTransaction(startTransaction);\n      }\n\n      // 이미 AsyncLocalStorage 컨텍스트 안에 있는지 확인 후 해당 preset의 트랜잭션이 이미 있으면 재사용\n      if (existingContext?.getTransaction(dbPreset)) {\n        this.logger.debug(\"reuse transaction context: {dbPreset}\", { dbPreset });\n        return originalMethod.apply(this, args);\n      }\n\n      // 컨텍스트는 있지만 이 preset의 트랜잭션은 없는 경우 (같은 컨텍스트 내에서 실행)\n      return startTransaction();\n    };\n\n    return descriptor;\n  };\n}\n\n/**\n * 파일 업로드 API를 생성해줍니다. (@api 데코레이터 없이 독립적으로 사용)\n * @param options\n * @returns\n */\nexport function upload(options: UploadDecoratorOptions = { consume: \"buffer\" }) {\n  return (target: DecoratorTarget, propertyKey: string, descriptor: PropertyDescriptor) => {\n    const originalMethod = descriptor.value;\n    const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];\n    assert(\n      modelName,\n      `modelName is required on @upload decorator on ${target.constructor.name}.${propertyKey}`,\n    );\n    const methodName = propertyKey;\n\n    // 메서드에 걸린 데코레이터 중복 체크\n    checkSingleDecorator(target, propertyKey, DECORATOR_TYPES.UPLOAD);\n\n    const defaultPath = `/${inflection.camelize(\n      modelName.replace(/Model$/, \"\").replace(/Frame$/, \"\"),\n      true,\n    )}/${inflection.camelize(methodName, true)}`;\n\n    // registeredApis에서 해당 API 찾아서 uploadOptions 추가\n    const existingApi = registeredApis.find(\n      (api) => api.modelName === modelName && api.methodName === methodName,\n    );\n\n    if (existingApi) {\n      // 재등록 시 업로드 옵션만 갱신\n      existingApi.uploadOptions = options;\n    } else {\n      // 새로 등록\n      registeredApis.push({\n        modelName,\n        methodName,\n        path: defaultPath,\n        options: {\n          httpMethod: \"POST\",\n          clients: [\"axios-multipart\", \"tanstack-mutation-multipart\"],\n          guards: options.guards,\n          description: options.description,\n        },\n        uploadOptions: options,\n      });\n    }\n\n    descriptor.value = async function (this: BaseModelClass | BaseFrameClass, ...args: unknown[]) {\n      if (this instanceof BaseModelClass) {\n        getLogger(convertDomainToCategory(this.modelName, \"model\")).debug(\n          \"upload: {model}.{method}\",\n          {\n            model: modelName,\n            method: methodName,\n          },\n        );\n      }\n\n      if (this instanceof BaseFrameClass) {\n        getLogger(convertDomainToCategory(this.frameName, \"frame\")).debug(\n          \"upload: {model}.{method}\",\n          {\n            model: modelName,\n            method: methodName,\n          },\n        );\n      }\n\n      return originalMethod.apply(this, args);\n    };\n\n    return descriptor;\n  };\n}\n\n/**\n * 기존의 path와 새로운 path가 다르다면(=값이 있던 스트링이 다른 값이 있는 스트링으로 바뀌게 된다면) 에러를 터뜨려줍니다.\n * @param decoratorName 데코레이터 이름\n * @param modelName 모델 이름\n * @param methodName 메서드 이름\n * @param existingPath 기존의 path\n * @param newPath 새로운 path\n */\nfunction assertNoConflictingPath(\n  decoratorName: string,\n  modelName: string,\n  methodName: string,\n  existingPath: string,\n  newPath: string,\n) {\n  if (existingPath !== \"\" && newPath !== \"\" && existingPath !== newPath) {\n    // 이것이 무슨 상황이냐면요, api.path가 덮어씌워지는 상황입니다.\n    // 가령 @api({ path: \"/api/v1/users\" }) 데코레이터가 붙어있는 메서드에\n    // @stream({ path: \"/api/v1/users/stream\" }) 같은 것이 붙어 있는 상황입니다.\n    // 이렇게 되면 두 데코레이터가 같은 api의 path 필드를 건드리게 되므로, 에러를 터뜨려줍니다.\n    throw new Error(\n      `@${decoratorName} decorator on ${modelName}.${methodName} has conflicting path: ${newPath}. The decorator is trying to override the existing path(${existingPath}) with the new path(${newPath}).`,\n    );\n  }\n}\n\n/**\n * 기존의 옵션과 새로운 옵션이 겹치는 부분이 있다면 에러를 터뜨려줍니다.\n * @param decoratorName 데코레이터 이름\n * @param modelName 모델 이름\n * @param methodName 메서드 이름\n * @param existingOptions 기존의 옵션\n * @param newOptions 새로운 옵션\n */\nfunction assertNoConflictingOptions(\n  decoratorName: string,\n  modelName: string,\n  methodName: string,\n  // biome-ignore lint/suspicious/noExplicitAny: <아 쉽게쉽게 좀 갑시다>\n  existingOptions: Record<string, any>,\n  // biome-ignore lint/suspicious/noExplicitAny: <이럴 때 아니면 any 언제 씁니까>\n  newOptions: Record<string, any>,\n) {\n  Object.keys(newOptions).forEach((key) => {\n    if (existingOptions[key] && !isEqual(existingOptions[key], newOptions[key])) {\n      // 이것이 무슨 상황이냐면요, api.options가 덮어씌워지는 상황입니다.\n      // 가령 @api({ resourceName: \"Users\" }) 데코레이터가 붙어있는 메서드에\n      // @stream({ resourceName: \"Posts\" }) 같은 것이 붙어 있는 상황입니다.\n      // 이렇게 되면 두 데코레이터가 같은 api의 options 속 같은 필드를 건드리게 되므로, 에러를 터뜨려줍니다.\n      throw new Error(\n        `@${decoratorName} decorator on ${modelName}.${methodName} has conflicting options: ${key}. The decorator is trying to override the existing option(${JSON.stringify(existingOptions[key])}) with the new option(${JSON.stringify(newOptions[key])}).`,\n      );\n    }\n  });\n}\n"],"names":["getLogger","assert","inflection","isEqual","BaseModelClass","DB","PuriTransactionWrapper","UpsertBuilder","convertDomainToCategory","BaseFrameClass","registeredApis","DECORATOR_TYPES","API","Symbol","STREAM","UPLOAD","checkSingleDecorator","target","propertyKey","decoratorType","method","__decoratorType","Error","description","String","name","api","options","httpMethod","contentType","clients","descriptor","modelName","match","methodName","defaultPath","camelize","replace","path","existingApi","find","assertNoConflictingPath","assertNoConflictingOptions","push","originalMethod","value","args","debug","model","frameName","apply","stream","events","_","type","_type","apiOptions","optionsWithDefaults","streamOptions","transactional","isolation","readOnly","dbPreset","logger","existingContext","transactionStorage","getStore","startTransaction","puri","getPuri","knex","transaction","trx","trxWrapper","getTransactionContext","setTransaction","deleteTransaction","isolationLevel","runWithTransaction","getTransaction","upload","consume","uploadOptions","guards","decoratorName","existingPath","newPath","existingOptions","newOptions","Object","keys","forEach","key","JSON","stringify"],"mappings":"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"}
+//#endregion
+init_decorators();
+export { api, init_decorators, registeredApis, stream, transactional, upload };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"decorators.js","names":["api","registeredApis: {\n  /**\n   * modelName은 모델 클래스 이름입니다. (ex. \"UserModel\")\n   */\n  modelName: string;\n  methodName: string;\n  path: string;\n  options: ApiDecoratorOptions;\n  streamOptions?: StreamDecoratorOptions;\n  uploadOptions?: UploadDecoratorOptions;\n}[]"],"sources":["../../src/api/decorators.ts"],"sourcesContent":["import assert from \"assert\";\n\nimport { type FastifyMultipartBaseOptions } from \"@fastify/multipart\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { type HTTPMethods } from \"fastify\";\nimport inflection from \"inflection\";\nimport { isEqual } from \"radashi\";\nimport { type z } from \"zod\";\n\nimport { type CacheControlConfig } from \"../cache-control/types\";\nimport { type CompressConfig } from \"../compress/types\";\nimport { BaseModelClass } from \"../database/base-model\";\nimport { DB } from \"../database/db\";\nimport { PuriTransactionWrapper } from \"../database/puri-wrapper\";\nimport { type TransactionalOptions } from \"../database/puri-wrapper\";\nimport { UpsertBuilder } from \"../database/upsert-builder\";\nimport { convertDomainToCategory } from \"../logger/category\";\nimport { type DriverKey } from \"../storage/drivers\";\nimport { type KeyGenerator } from \"../storage/types\";\nimport { type ApiParam, type ApiParamType } from \"../types/types\";\nimport { BaseFrameClass } from \"./base-frame\";\n\nexport interface GuardKeys {\n  query: true;\n  admin: true;\n  user: true;\n}\nexport type GuardKey = keyof GuardKeys;\nexport type ServiceClient =\n  | \"axios\"\n  | \"axios-multipart\"\n  | \"tanstack-query\"\n  | \"tanstack-mutation\"\n  | \"tanstack-mutation-multipart\"\n  | \"window-fetch\";\nexport type ApiDecoratorOptions = {\n  httpMethod?: HTTPMethods;\n  contentType?:\n    | \"text/plain\"\n    | \"text/html\"\n    | \"text/xml\"\n    | \"application/json\"\n    | \"application/octet-stream\";\n  clients?: ServiceClient[];\n  path?: string;\n  resourceName?: string;\n  guards?: GuardKey[];\n  description?: string;\n  timeout?: number;\n  /** API 응답의 Cache-Control 헤더 설정. 설정하지 않으면 cacheControlHandler 또는 기본값이 적용됩니다. */\n  cacheControl?: CacheControlConfig;\n  /** API 응답의 압축 설정. false로 설정하면 압축을 비활성화합니다. */\n  compress?: CompressConfig;\n};\nexport type StreamDecoratorOptions = {\n  type: \"sse\"; // | 'ws\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- 이벤트 키별로 넘겨주는 값이므로 어떤 타입이든 상관없음\n  events: z.ZodObject<any>;\n  path?: string;\n  resourceName?: string;\n  guards?: GuardKey[];\n  description?: string;\n};\n\ntype BufferUploadOptions = {\n  consume?: \"buffer\";\n};\ntype StreamUploadOptions = {\n  consume: \"stream\";\n  destination: DriverKey;\n  keyGenerator?: KeyGenerator;\n};\nexport type UploadDecoratorOptions = {\n  guards?: GuardKey[];\n  description?: string;\n  limits?: FastifyMultipartBaseOptions[\"limits\"];\n} & (BufferUploadOptions | StreamUploadOptions);\n\nexport const registeredApis: {\n  /**\n   * modelName은 모델 클래스 이름입니다. (ex. \"UserModel\")\n   */\n  modelName: string;\n  methodName: string;\n  path: string;\n  options: ApiDecoratorOptions;\n  streamOptions?: StreamDecoratorOptions;\n  uploadOptions?: UploadDecoratorOptions;\n}[] = [];\nexport type ExtendedApi = {\n  modelName: string;\n  methodName: string;\n  path: string;\n  options: ApiDecoratorOptions;\n  streamOptions?: StreamDecoratorOptions;\n  uploadOptions?: UploadDecoratorOptions;\n  typeParameters: ApiParamType.TypeParam[];\n  parameters: ApiParam[];\n  returnType: ApiParamType;\n};\ntype DecoratorTarget = { constructor: { name: string } };\n\nconst DECORATOR_TYPES = {\n  API: Symbol(\"api\"),\n  STREAM: Symbol(\"stream\"),\n  UPLOAD: Symbol(\"upload\"),\n} as const;\n\nfunction checkSingleDecorator(target: DecoratorTarget, propertyKey: string, decoratorType: symbol) {\n  const method = target[propertyKey as keyof typeof target] as { __decoratorType?: symbol };\n  if (method?.__decoratorType && method?.__decoratorType !== decoratorType) {\n    throw new Error(\n      `@${decoratorType.description ?? String(decoratorType)} decorator can only be used once on ${target.constructor.name}.${propertyKey}. You can use only one of @api or @stream decorator on the same method.`,\n    );\n  } else {\n    method.__decoratorType = decoratorType;\n  }\n}\n\nexport function api(options: ApiDecoratorOptions = {}) {\n  options = {\n    httpMethod: \"GET\",\n    contentType: \"application/json\",\n    clients: [\"axios\"],\n    ...options,\n  };\n\n  return (target: DecoratorTarget, propertyKey: string, descriptor: PropertyDescriptor) => {\n    const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];\n    assert(\n      modelName,\n      `modelName is required on @api decorator on ${target.constructor.name}.${propertyKey}`,\n    );\n    const methodName = propertyKey;\n\n    // 메서드에 걸린 데코레이터 중복 체크\n    checkSingleDecorator(target, propertyKey, DECORATOR_TYPES.API);\n\n    const defaultPath = `/${inflection.camelize(\n      modelName.replace(/Model$/, \"\").replace(/Frame$/, \"\"),\n      true,\n    )}/${inflection.camelize(propertyKey, true)}`;\n    const path = options.path ?? defaultPath;\n\n    // 기존 동일한 메서드가 있는지 확인 후 있는 경우 override\n    const existingApi = registeredApis.find(\n      (api) => api.modelName === modelName && api.methodName === methodName,\n    );\n    if (existingApi) {\n      // 기존의 path와 새로운 path가 다르다면(=빈 스트링이 아니었는데 다른 스트링으로 바뀌게 된다면) 에러를 터뜨려줍니다.\n      assertNoConflictingPath(\"api\", modelName, methodName, existingApi.path, path);\n      existingApi.path = path;\n\n      // 기존의 옵션과 새로운 옵션이 겹치는 부분이 있다면 에러를 터뜨려줍니다.\n      assertNoConflictingOptions(\"api\", modelName, methodName, existingApi.options, options);\n      existingApi.options = {\n        ...existingApi.options, // 기존의 옵션을 존중하되\n        ...options, // @api 데코레이터의 옵션을 추가합니다.\n      };\n    } else {\n      registeredApis.push({\n        modelName,\n        methodName,\n        path,\n        options,\n      });\n    }\n\n    const originalMethod = descriptor.value;\n    descriptor.value = async function (this: BaseModelClass | BaseFrameClass, ...args: unknown[]) {\n      if (this instanceof BaseModelClass) {\n        getLogger(convertDomainToCategory(this.modelName, \"model\")).debug(\n          \"api: {httpMethod} {model}.{method}\",\n          {\n            httpMethod: options.httpMethod,\n            model: modelName,\n            method: methodName,\n          },\n        );\n      }\n\n      if (this instanceof BaseFrameClass) {\n        getLogger(convertDomainToCategory(this.frameName, \"frame\")).debug(\n          \"api: {httpMethod} {model}.{method}\",\n          {\n            httpMethod: options.httpMethod,\n            model: modelName,\n            method: methodName,\n          },\n        );\n      }\n\n      return originalMethod.apply(this, args);\n    };\n  };\n}\n\nexport function stream(options: StreamDecoratorOptions) {\n  return (target: DecoratorTarget, propertyKey: string, descriptor: PropertyDescriptor) => {\n    const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];\n    assert(\n      modelName,\n      `modelName is required on @stream decorator on ${target.constructor.name}.${propertyKey}`,\n    );\n    const methodName = propertyKey;\n\n    // 메서드에 걸린 데코레이터 중복 체크\n    checkSingleDecorator(target, propertyKey, DECORATOR_TYPES.STREAM);\n\n    const defaultPath = `/${inflection.camelize(\n      modelName.replace(/Model$/, \"\").replace(/Frame$/, \"\"),\n      true,\n    )}/${inflection.camelize(propertyKey, true)}`;\n    const path = options.path ?? defaultPath;\n    // stream 전용 필드(events, type)는 ApiDecoratorOptions에 속하지 않으므로 제외\n    const { events: _, type: _type, ...apiOptions } = options;\n    const optionsWithDefaults = {\n      ...apiOptions,\n      httpMethod: \"GET\" as HTTPMethods,\n    };\n\n    const existingApi = registeredApis.find(\n      (api) => api.modelName === modelName && api.methodName === methodName,\n    );\n    if (existingApi) {\n      // 기존의 path와 새로운 path가 다르다면(=빈 스트링이 아니었는데 다른 스트링으로 바뀌게 된다면) 에러를 터뜨려줍니다.\n      assertNoConflictingPath(\"stream\", modelName, methodName, existingApi.path, path);\n      existingApi.path = path;\n\n      // 기존의 옵션과 새로운 옵션이 겹치는 부분이 있다면 에러를 터뜨려줍니다.\n      assertNoConflictingOptions(\n        \"stream\",\n        modelName,\n        methodName,\n        existingApi.options,\n        optionsWithDefaults,\n      );\n      existingApi.options = {\n        ...existingApi.options, // 기존의 옵션을 존중하되\n        ...optionsWithDefaults, // @stream 데코레이터의 옵션을 추가합니다.\n      };\n\n      existingApi.streamOptions = options;\n    } else {\n      registeredApis.push({\n        modelName,\n        methodName,\n        path,\n        options: optionsWithDefaults,\n        streamOptions: options,\n      });\n    }\n\n    const originalMethod = descriptor.value;\n    descriptor.value = async function (this: BaseModelClass | BaseFrameClass, ...args: unknown[]) {\n      if (this instanceof BaseModelClass) {\n        getLogger(convertDomainToCategory(this.modelName, \"model\")).debug(\n          \"stream: {model}.{method}\",\n          {\n            model: modelName,\n            method: methodName,\n          },\n        );\n      }\n\n      if (this instanceof BaseFrameClass) {\n        getLogger(convertDomainToCategory(this.frameName, \"frame\")).debug(\n          \"stream: {model}.{method}\",\n          {\n            model: modelName,\n            method: methodName,\n          },\n        );\n      }\n\n      return originalMethod.apply(this, args);\n    };\n  };\n}\n\nexport function transactional(options: TransactionalOptions = {}) {\n  const { isolation, readOnly, dbPreset = \"w\" } = options;\n\n  return (target: DecoratorTarget, propertyKey: string, descriptor: PropertyDescriptor) => {\n    const originalMethod = descriptor.value;\n    const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];\n    assert(\n      modelName,\n      `modelName is required on @stream decorator on ${target.constructor.name}.${propertyKey}`,\n    );\n    const methodName = propertyKey;\n\n    descriptor.value = async function (this: BaseModelClass, ...args: unknown[]) {\n      this.logger.debug(\"transactional: {model}.{method}\", {\n        model: modelName,\n        method: methodName,\n      });\n\n      const existingContext = DB.transactionStorage.getStore();\n\n      // AsyncLocalStorage 컨텍스트 없거나 해당 preset의 트랜잭션이 없으면 새로 시작\n      const startTransaction = async () => {\n        const puri = this.getPuri(dbPreset);\n\n        return puri.knex.transaction(\n          async (trx) => {\n            this.logger.debug(\"new transaction context: {dbPreset}\", { dbPreset });\n            const trxWrapper = new PuriTransactionWrapper(trx, new UpsertBuilder());\n            // TransactionContext에 트랜잭션 저장\n            DB.getTransactionContext().setTransaction(dbPreset, trxWrapper);\n\n            try {\n              return await originalMethod.apply(this, args);\n            } finally {\n              // 트랜잭션 제거\n              this.logger.debug(\"delete transaction context: {dbPreset}\", { dbPreset });\n              DB.getTransactionContext().deleteTransaction(dbPreset);\n            }\n          },\n          { isolationLevel: isolation, readOnly },\n        );\n      };\n\n      // AsyncLocalStorage 컨텍스트가 없으면 새로 생성\n      if (!existingContext) {\n        return DB.runWithTransaction(startTransaction);\n      }\n\n      // 이미 AsyncLocalStorage 컨텍스트 안에 있는지 확인 후 해당 preset의 트랜잭션이 이미 있으면 재사용\n      if (existingContext?.getTransaction(dbPreset)) {\n        this.logger.debug(\"reuse transaction context: {dbPreset}\", { dbPreset });\n        return originalMethod.apply(this, args);\n      }\n\n      // 컨텍스트는 있지만 이 preset의 트랜잭션은 없는 경우 (같은 컨텍스트 내에서 실행)\n      return startTransaction();\n    };\n\n    return descriptor;\n  };\n}\n\n/**\n * 파일 업로드 API를 생성해줍니다. (@api 데코레이터 없이 독립적으로 사용)\n * @param options\n * @returns\n */\nexport function upload(options: UploadDecoratorOptions = { consume: \"buffer\" }) {\n  return (target: DecoratorTarget, propertyKey: string, descriptor: PropertyDescriptor) => {\n    const originalMethod = descriptor.value;\n    const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];\n    assert(\n      modelName,\n      `modelName is required on @upload decorator on ${target.constructor.name}.${propertyKey}`,\n    );\n    const methodName = propertyKey;\n\n    // 메서드에 걸린 데코레이터 중복 체크\n    checkSingleDecorator(target, propertyKey, DECORATOR_TYPES.UPLOAD);\n\n    const defaultPath = `/${inflection.camelize(\n      modelName.replace(/Model$/, \"\").replace(/Frame$/, \"\"),\n      true,\n    )}/${inflection.camelize(methodName, true)}`;\n\n    // registeredApis에서 해당 API 찾아서 uploadOptions 추가\n    const existingApi = registeredApis.find(\n      (api) => api.modelName === modelName && api.methodName === methodName,\n    );\n\n    if (existingApi) {\n      // 재등록 시 업로드 옵션만 갱신\n      existingApi.uploadOptions = options;\n    } else {\n      // 새로 등록\n      registeredApis.push({\n        modelName,\n        methodName,\n        path: defaultPath,\n        options: {\n          httpMethod: \"POST\",\n          clients: [\"axios-multipart\", \"tanstack-mutation-multipart\"],\n          guards: options.guards,\n          description: options.description,\n        },\n        uploadOptions: options,\n      });\n    }\n\n    descriptor.value = async function (this: BaseModelClass | BaseFrameClass, ...args: unknown[]) {\n      if (this instanceof BaseModelClass) {\n        getLogger(convertDomainToCategory(this.modelName, \"model\")).debug(\n          \"upload: {model}.{method}\",\n          {\n            model: modelName,\n            method: methodName,\n          },\n        );\n      }\n\n      if (this instanceof BaseFrameClass) {\n        getLogger(convertDomainToCategory(this.frameName, \"frame\")).debug(\n          \"upload: {model}.{method}\",\n          {\n            model: modelName,\n            method: methodName,\n          },\n        );\n      }\n\n      return originalMethod.apply(this, args);\n    };\n\n    return descriptor;\n  };\n}\n\n/**\n * 기존의 path와 새로운 path가 다르다면(=값이 있던 스트링이 다른 값이 있는 스트링으로 바뀌게 된다면) 에러를 터뜨려줍니다.\n * @param decoratorName 데코레이터 이름\n * @param modelName 모델 이름\n * @param methodName 메서드 이름\n * @param existingPath 기존의 path\n * @param newPath 새로운 path\n */\nfunction assertNoConflictingPath(\n  decoratorName: string,\n  modelName: string,\n  methodName: string,\n  existingPath: string,\n  newPath: string,\n) {\n  if (existingPath !== \"\" && newPath !== \"\" && existingPath !== newPath) {\n    // 이것이 무슨 상황이냐면요, api.path가 덮어씌워지는 상황입니다.\n    // 가령 @api({ path: \"/api/v1/users\" }) 데코레이터가 붙어있는 메서드에\n    // @stream({ path: \"/api/v1/users/stream\" }) 같은 것이 붙어 있는 상황입니다.\n    // 이렇게 되면 두 데코레이터가 같은 api의 path 필드를 건드리게 되므로, 에러를 터뜨려줍니다.\n    throw new Error(\n      `@${decoratorName} decorator on ${modelName}.${methodName} has conflicting path: ${newPath}. The decorator is trying to override the existing path(${existingPath}) with the new path(${newPath}).`,\n    );\n  }\n}\n\n/**\n * 기존의 옵션과 새로운 옵션이 겹치는 부분이 있다면 에러를 터뜨려줍니다.\n * @param decoratorName 데코레이터 이름\n * @param modelName 모델 이름\n * @param methodName 메서드 이름\n * @param existingOptions 기존의 옵션\n * @param newOptions 새로운 옵션\n */\nfunction assertNoConflictingOptions(\n  decoratorName: string,\n  modelName: string,\n  methodName: string,\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- <아 쉽게쉽게 좀 갑시다>\n  existingOptions: Record<string, any>,\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- <이럴 때 아니면 any 언제 씁니까>\n  newOptions: Record<string, any>,\n) {\n  Object.keys(newOptions).forEach((key) => {\n    if (existingOptions[key] && !isEqual(existingOptions[key], newOptions[key])) {\n      // 이것이 무슨 상황이냐면요, api.options가 덮어씌워지는 상황입니다.\n      // 가령 @api({ resourceName: \"Users\" }) 데코레이터가 붙어있는 메서드에\n      // @stream({ resourceName: \"Posts\" }) 같은 것이 붙어 있는 상황입니다.\n      // 이렇게 되면 두 데코레이터가 같은 api의 options 속 같은 필드를 건드리게 되므로, 에러를 터뜨려줍니다.\n      throw new Error(\n        `@${decoratorName} decorator on ${modelName}.${methodName} has conflicting options: ${key}. The decorator is trying to override the existing option(${JSON.stringify(existingOptions[key])}) with the new option(${JSON.stringify(newOptions[key])}).`,\n      );\n    }\n  });\n}\n"],"mappings":"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"}