sonamu 0.7.21 → 0.7.23

package/dist/api/decorators.js

@@ -1,9 +1,13 @@
+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";
 import { Sonamu } from "./sonamu.js";
 export const registeredApis = [];
 const DECORATOR_TYPES = {
@@ -27,7 +31,7 @@ export function api(options = {}) {
         ],
         ...options
     };
-    return (target, propertyKey)=>{
+    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;
@@ -55,10 +59,28 @@ export function api(options = {}) {
                 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)=>{
+    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;
@@ -91,25 +113,44 @@ export function stream(options) {
                 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)=>{
+    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 컨텍스트 안에 있는지 확인
-            if (existingContext) {
-                // 해당 preset의 트랜잭션이 이미 있으면 재사용
-                if (existingContext.getTransaction(dbPreset)) {
-                    return originalMethod.apply(this, args);
-                }
-            }
             // 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);
@@ -117,6 +158,9 @@ export function transactional(options = {}) {
                         return await originalMethod.apply(this, args);
                     } finally{
                         // 트랜잭션 제거
+                        this.logger.debug("delete transaction context: {dbPreset}", {
+                            dbPreset
+                        });
                         DB.getTransactionContext().deleteTransaction(dbPreset);
                     }
                 }, {
@@ -127,10 +171,16 @@ export function transactional(options = {}) {
             // AsyncLocalStorage 컨텍스트가 없으면 새로 생성
             if (!existingContext) {
                 return DB.runWithTransaction(startTransaction);
-            } else {
-                // 컨텍스트는 있지만 이 preset의 트랜잭션은 없는 경우 (같은 컨텍스트 내에서 실행)
-                return 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;
     };
@@ -140,11 +190,11 @@ export function transactional(options = {}) {
  * @param options
  * @returns
  */ export function upload(options = {}) {
-    return (_target, _propertyKey, descriptor)=>{
+    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;
+        const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];
+        assert(modelName, `modelName is required on @upload decorator on ${target.constructor.name}.${propertyKey}`);
+        const methodName = propertyKey;
         // registeredApis에서 해당 API 찾아서 uploadOptions 추가
         const existingApi = registeredApis.find((api)=>api.modelName === modelName && api.methodName === methodName);
         if (existingApi) {
@@ -163,6 +213,18 @@ export function transactional(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
+                });
+            }
             const { request } = Sonamu.getContext();
             const uploadContext = {
                 file: undefined,
@@ -229,4 +291,4 @@ newOptions) {
     });
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/api/decorators.ts"],"sourcesContent":["import assert from \"assert\";\nimport type { HTTPMethods } from \"fastify\";\nimport inflection from \"inflection\";\nimport { isEqual } from \"radashi\";\nimport type { z } from \"zod\";\nimport type { 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 type { ApiParam, ApiParamType } from \"../types/types\";\nimport type { UploadContext } from \"./context\";\nimport { Sonamu } from \"./sonamu\";\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  | \"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};\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};\nexport type UploadDecoratorOptions = {\n  mode?: \"single\" | \"multiple\";\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} 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      `@${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) => {\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}\n\nexport function stream(options: StreamDecoratorOptions) {\n  return (target: DecoratorTarget, propertyKey: string) => {\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    const optionsWithDefaults = {\n      ...options,\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}\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\n    descriptor.value = async function (this: BaseModelClass, ...args: unknown[]) {\n      const existingContext = DB.transactionStorage.getStore();\n\n      // 이미 AsyncLocalStorage 컨텍스트 안에 있는지 확인\n      if (existingContext) {\n        // 해당 preset의 트랜잭션이 이미 있으면 재사용\n        if (existingContext.getTransaction(dbPreset)) {\n          return originalMethod.apply(this, args);\n        }\n      }\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            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              DB.getTransactionContext().deleteTransaction(dbPreset);\n            }\n          },\n          { isolationLevel: isolation, readOnly },\n        );\n      };\n\n      // AsyncLocalStorage 컨텍스트가 없으면 새로 생성\n      if (!existingContext) {\n        return DB.runWithTransaction(startTransaction);\n      } else {\n        // 컨텍스트는 있지만 이 preset의 트랜잭션은 없는 경우 (같은 컨텍스트 내에서 실행)\n        return startTransaction();\n      }\n    };\n\n    return descriptor;\n  };\n}\n\n/**\n * api 데코레이터와 함께 사용할 수 있습니다.\n * @param options\n * @returns\n */\nexport function upload(options: UploadDecoratorOptions = {}) {\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    // registeredApis에서 해당 API 찾아서 uploadOptions 추가\n    const existingApi = registeredApis.find(\n      (api) => api.modelName === modelName && api.methodName === methodName,\n    );\n    if (existingApi) {\n      existingApi.uploadOptions = options;\n    } else {\n      // 이 메소드에 붙은 @api 데코레이터가 아직 eval되지 않은 상황입니다. (만약 @api가 안 붙어 있었다면 심각한 상황입니다..!)\n      // 여기에서 최초로 modelName과 methodName에 대해 registeredApis에 하나를 추가해주어야 합니다.\n      // uploadOptions는 그대로 추가하고, path는 빈 스트링으로 추가해줍니다.\n      // 이후 @api 데코레이터가 eval되면 실제 path로 덮어씌워지고, options가 추가됩니다.\n      registeredApis.push({\n        modelName,\n        methodName,\n        path: \"\",\n        options: {},\n        uploadOptions: options,\n      });\n    }\n\n    descriptor.value = async function (this: BaseModelClass, ...args: unknown[]) {\n      const { request } = Sonamu.getContext();\n      const uploadContext: UploadContext = {\n        file: undefined,\n        files: [],\n      };\n\n      const { UploadedFile } = await import(\"../storage/uploaded-file\");\n      if (options.mode === \"multiple\") {\n        const rawFilesIterator = request.files();\n        for await (const rawFile of rawFilesIterator) {\n          if (rawFile) {\n            await rawFile.toBuffer();\n            uploadContext.files.push(new UploadedFile(rawFile));\n          }\n        }\n      } else {\n        const rawFile = await request.file();\n        if (rawFile) {\n          uploadContext.file = new UploadedFile(rawFile);\n        }\n      }\n\n      return Sonamu.uploadStorage.run({ uploadContext }, () => {\n        return originalMethod.apply(this, args);\n      });\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":["assert","inflection","isEqual","DB","PuriTransactionWrapper","UpsertBuilder","Sonamu","registeredApis","DECORATOR_TYPES","API","Symbol","STREAM","checkSingleDecorator","target","propertyKey","decoratorType","method","__decoratorType","Error","String","name","api","options","httpMethod","contentType","clients","modelName","match","methodName","defaultPath","camelize","replace","path","existingApi","find","assertNoConflictingPath","assertNoConflictingOptions","push","stream","optionsWithDefaults","streamOptions","transactional","isolation","readOnly","dbPreset","_target","_propertyKey","descriptor","originalMethod","value","args","existingContext","transactionStorage","getStore","getTransaction","apply","startTransaction","puri","getPuri","knex","transaction","trx","trxWrapper","getTransactionContext","setTransaction","deleteTransaction","isolationLevel","runWithTransaction","upload","uploadOptions","request","getContext","uploadContext","file","undefined","files","UploadedFile","mode","rawFilesIterator","rawFile","toBuffer","uploadStorage","run","decoratorName","existingPath","newPath","existingOptions","newOptions","Object","keys","forEach","key","JSON","stringify"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/api/decorators.ts"],"sourcesContent":["import { 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 { 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 { ApiParam, ApiParamType } from \"../types/types\";\nimport { BaseFrameClass } from \"./base-frame\";\nimport type { UploadContext } from \"./context\";\nimport { Sonamu } from \"./sonamu\";\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  | \"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};\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};\nexport type UploadDecoratorOptions = {\n  mode?: \"single\" | \"multiple\";\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} 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      `@${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    const optionsWithDefaults = {\n      ...options,\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 데코레이터와 함께 사용할 수 있습니다.\n * @param options\n * @returns\n */\nexport function upload(options: UploadDecoratorOptions = {}) {\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    // registeredApis에서 해당 API 찾아서 uploadOptions 추가\n    const existingApi = registeredApis.find(\n      (api) => api.modelName === modelName && api.methodName === methodName,\n    );\n    if (existingApi) {\n      existingApi.uploadOptions = options;\n    } else {\n      // 이 메소드에 붙은 @api 데코레이터가 아직 eval되지 않은 상황입니다. (만약 @api가 안 붙어 있었다면 심각한 상황입니다..!)\n      // 여기에서 최초로 modelName과 methodName에 대해 registeredApis에 하나를 추가해주어야 합니다.\n      // uploadOptions는 그대로 추가하고, path는 빈 스트링으로 추가해줍니다.\n      // 이후 @api 데코레이터가 eval되면 실제 path로 덮어씌워지고, options가 추가됩니다.\n      registeredApis.push({\n        modelName,\n        methodName,\n        path: \"\",\n        options: {},\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      const { request } = Sonamu.getContext();\n      const uploadContext: UploadContext = {\n        file: undefined,\n        files: [],\n      };\n\n      const { UploadedFile } = await import(\"../storage/uploaded-file\");\n      if (options.mode === \"multiple\") {\n        const rawFilesIterator = request.files();\n        for await (const rawFile of rawFilesIterator) {\n          if (rawFile) {\n            await rawFile.toBuffer();\n            uploadContext.files.push(new UploadedFile(rawFile));\n          }\n        }\n      } else {\n        const rawFile = await request.file();\n        if (rawFile) {\n          uploadContext.file = new UploadedFile(rawFile);\n        }\n      }\n\n      return Sonamu.uploadStorage.run({ uploadContext }, () => {\n        return originalMethod.apply(this, args);\n      });\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","Sonamu","registeredApis","DECORATOR_TYPES","API","Symbol","STREAM","checkSingleDecorator","target","propertyKey","decoratorType","method","__decoratorType","Error","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","optionsWithDefaults","streamOptions","transactional","isolation","readOnly","dbPreset","logger","existingContext","transactionStorage","getStore","startTransaction","puri","getPuri","knex","transaction","trx","trxWrapper","getTransactionContext","setTransaction","deleteTransaction","isolationLevel","runWithTransaction","getTransaction","upload","uploadOptions","request","getContext","uploadContext","file","undefined","files","UploadedFile","mode","rawFilesIterator","rawFile","toBuffer","uploadStorage","run","decoratorName","existingPath","newPath","existingOptions","newOptions","Object","keys","forEach","key","JSON","stringify"],"mappings":"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"}

package/dist/api/index.d.ts

@@ -2,5 +2,6 @@ export * from "./caster";
 export * from "./code-converters";
 export * from "./context";
 export * from "./decorators";
+export * from "./secret";
 export * from "./sonamu";
 //# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/dist/api/index.js

@@ -2,6 +2,7 @@ export * from "./caster.js";
 export * from "./code-converters.js";
 export * from "./context.js";
 export * from "./decorators.js";
+export * from "./secret.js";
 export * from "./sonamu.js";
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hcGkvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vY2FzdGVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb2RlLWNvbnZlcnRlcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnRleHRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NvbmFtdVwiO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBVztBQUN6QixjQUFjLHVCQUFvQjtBQUNsQyxjQUFjLGVBQVk7QUFDMUIsY0FBYyxrQkFBZTtBQUM3QixjQUFjLGNBQVcifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hcGkvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vY2FzdGVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb2RlLWNvbnZlcnRlcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnRleHRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NlY3JldFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc29uYW11XCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFXO0FBQ3pCLGNBQWMsdUJBQW9CO0FBQ2xDLGNBQWMsZUFBWTtBQUMxQixjQUFjLGtCQUFlO0FBQzdCLGNBQWMsY0FBVztBQUN6QixjQUFjLGNBQVcifQ==

package/dist/api/secret.d.ts

@@ -0,0 +1,7 @@
+export type SonamuSecrets = {
+    anthropic_api_key?: string;
+    voyage_api_key?: string;
+    openai_api_key?: string;
+};
+export declare function getSecrets(): SonamuSecrets;
+//# sourceMappingURL=secret.d.ts.map

package/dist/api/secret.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret.d.ts","sourceRoot":"","sources":["../../src/api/secret.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,wBAAgB,UAAU,IAAI,aAAa,CAgB1C"}

package/dist/api/secret.js

@@ -0,0 +1,17 @@
+export function getSecrets() {
+    const secrets = {};
+    const secretKeys = [
+        "anthropic_api_key",
+        "voyage_api_key",
+        "openai_api_key"
+    ];
+    for (const key of secretKeys){
+        const envKey = key.toUpperCase();
+        if (envKey in process.env) {
+            secrets[key] = process.env[envKey];
+        }
+    }
+    return secrets;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hcGkvc2VjcmV0LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIFNvbmFtdVNlY3JldHMgPSB7XG4gIGFudGhyb3BpY19hcGlfa2V5Pzogc3RyaW5nO1xuICB2b3lhZ2VfYXBpX2tleT86IHN0cmluZztcbiAgb3BlbmFpX2FwaV9rZXk/OiBzdHJpbmc7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0U2VjcmV0cygpOiBTb25hbXVTZWNyZXRzIHtcbiAgY29uc3Qgc2VjcmV0czogU29uYW11U2VjcmV0cyA9IHt9O1xuICBjb25zdCBzZWNyZXRLZXlzOiAoa2V5b2YgU29uYW11U2VjcmV0cylbXSA9IFtcbiAgICBcImFudGhyb3BpY19hcGlfa2V5XCIsXG4gICAgXCJ2b3lhZ2VfYXBpX2tleVwiLFxuICAgIFwib3BlbmFpX2FwaV9rZXlcIixcbiAgXSBhcyBjb25zdDtcblxuICBmb3IgKGNvbnN0IGtleSBvZiBzZWNyZXRLZXlzKSB7XG4gICAgY29uc3QgZW52S2V5ID0ga2V5LnRvVXBwZXJDYXNlKCk7XG4gICAgaWYgKGVudktleSBpbiBwcm9jZXNzLmVudikge1xuICAgICAgc2VjcmV0c1trZXldID0gcHJvY2Vzcy5lbnZbZW52S2V5XTtcbiAgICB9XG4gIH1cblxuICByZXR1cm4gc2VjcmV0cztcbn1cbiJdLCJuYW1lcyI6WyJnZXRTZWNyZXRzIiwic2VjcmV0cyIsInNlY3JldEtleXMiLCJrZXkiLCJlbnZLZXkiLCJ0b1VwcGVyQ2FzZSIsInByb2Nlc3MiLCJlbnYiXSwibWFwcGluZ3MiOiJBQU1BLE9BQU8sU0FBU0E7SUFDZCxNQUFNQyxVQUF5QixDQUFDO0lBQ2hDLE1BQU1DLGFBQXNDO1FBQzFDO1FBQ0E7UUFDQTtLQUNEO0lBRUQsS0FBSyxNQUFNQyxPQUFPRCxXQUFZO1FBQzVCLE1BQU1FLFNBQVNELElBQUlFLFdBQVc7UUFDOUIsSUFBSUQsVUFBVUUsUUFBUUMsR0FBRyxFQUFFO1lBQ3pCTixPQUFPLENBQUNFLElBQUksR0FBR0csUUFBUUMsR0FBRyxDQUFDSCxPQUFPO1FBQ3BDO0lBQ0Y7SUFFQSxPQUFPSDtBQUNUIn0=

package/dist/api/sonamu.d.ts

@@ -2,6 +2,7 @@ import { AsyncLocalStorage } from "async_hooks";
 import type { FSWatcher } from "chokidar";
 import type { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
 import type { IncomingMessage, Server, ServerResponse } from "http";
+import type { CacheManager } from "../cache/types";
 import type { SonamuDBConfig } from "../database/db";
 import type { StorageManager } from "../storage/storage-manager";
 import type { Syncer } from "../syncer/syncer";
@@ -11,11 +12,7 @@ import type { AbsolutePath } from "../utils/path-utils";
 import type { SonamuConfig } from "./config";
 import type { Context, UploadContext } from "./context";
 import type { ExtendedApi } from "./decorators";
-export type SonamuSecrets = {
-    anthropic_api_key?: string;
-    voyage_api_key?: string;
-    openai_api_key?: string;
-};
+import { type SonamuSecrets } from "./secret";
 declare class SonamuClass {
     isInitialized: boolean;
     asyncLocalStorage: AsyncLocalStorage<{
@@ -39,14 +36,17 @@ declare class SonamuClass {
     private _config;
     set config(config: SonamuConfig);
     get config(): SonamuConfig;
-    private _secrets;
-    set secrets(secrets: SonamuSecrets);
-    get secrets(): SonamuSecrets | null;
+    readonly secrets: SonamuSecrets;
     private _storage;
     /**
      * StorageManager 인스턴스
      */
     get storage(): StorageManager;
+    private _cache;
+    /**
+     * CacheManager 인스턴스 (BentoCache)
+     */
+    get cache(): CacheManager;
     private _workflows;
     get workflows(): WorkflowManager;
     watcher: FSWatcher | null;
@@ -63,13 +63,22 @@ declare class SonamuClass {
         enableSync?: boolean;
         doSilent?: boolean;
     }): Promise<void>;
+    private viteServer;
+    private setupViteDevServer;
+    private setupStaticWebServer;
     createApiHandler(api: ExtendedApi, config: SonamuFastifyConfig): (request: FastifyRequest, reply: FastifyReply) => Promise<unknown>;
+    /**
+     * SSR용 API 호출 (HTTP 오버헤드 없이 직접 호출)
+     * createApiHandler의 로직을 재사용하되, request 파싱 대신 params 직접 사용
+     */
+    invokeApiForSSR(api: ExtendedApi, params: any[], config: SonamuFastifyConfig, request: FastifyRequest, reply: FastifyReply): Promise<unknown>;
     invokeModelMethod(api: ExtendedApi, args: unknown[], context: Context, reply: FastifyReply): Promise<unknown>;
     createContext(config: SonamuFastifyConfig, request: FastifyRequest, reply: FastifyReply): Promise<Context>;
     startWatcher(): Promise<void>;
     runScript(fn: () => Promise<void>): Promise<void>;
     private registerPlugins;
     private registerAuth;
+    private initializeCache;
     private initializeWorkflows;
     private boot;
     private handleFileChange;

package/dist/api/sonamu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sonamu.d.ts","sourceRoot":"","sources":["../../src/api/sonamu.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"sonamu.d.ts","sourceRoot":"","sources":["../../src/api/sonamu.ts"],"names":[],"mappings":"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"}