sonamu 0.9.4 → 0.9.6

package/src/syncer/api-parser.ts

@@ -6,10 +6,24 @@ import ts from "typescript";
 
 import { registeredApis } from "../api/decorators";
 import { type ExtendedApi } from "../api/decorators";
+import { type ResolvedWebSocketDecoratorOptions } from "../api/decorators";
 import { validateMethodName } from "../api/validator";
 import { type ApiParam, type ApiParamType } from "../types/types";
 import { type AbsolutePath } from "../utils/path-utils";
 
+type WebSocketTypeRefs = Pick<
+  ResolvedWebSocketDecoratorOptions,
+  "outEventsTypeRef" | "inEventsTypeRef"
+>;
+type ParsedMethod = {
+  modelName: string;
+  methodName: string;
+  typeParameters: ApiParamType.TypeParam[];
+  parameters: ApiParam[];
+  returnType: ApiParamType;
+  websocketTypeRefs: WebSocketTypeRefs;
+};
+
 /**
  * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.
  * @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.
@@ -29,7 +43,7 @@ export async function readApisFromFile(filePath: AbsolutePath): Promise<Extended
     ts.ScriptTarget.Latest,
   );
 
-  const methods: Omit<ExtendedApi, "path" | "options">[] = [];
+  const methods: ParsedMethod[] = [];
   let modelName: string = "UnknownModel";
   let methodName: string = "unknownMethod";
   const visitor = (node: ts.Node) => {
@@ -74,6 +88,7 @@ export async function readApisFromFile(filePath: AbsolutePath): Promise<Extended
         throw new Error(`리턴 타입이 기재되지 않은 메소드 ${modelName}.${methodName}`);
       }
       const returnType = resolveTypeNode(node.type);
+      const websocketTypeRefs = readWebSocketTypeRefs(node);
 
       methods.push({
         modelName,
@@ -81,6 +96,7 @@ export async function readApisFromFile(filePath: AbsolutePath): Promise<Extended
         typeParameters,
         parameters,
         returnType,
+        websocketTypeRefs,
       });
     }
     ts.forEachChild(node, visitor);
@@ -113,8 +129,16 @@ export async function readApisFromFile(filePath: AbsolutePath): Promise<Extended
     if (!foundMethod) {
       throw new Error(`API ${api.modelName}.${api.methodName} not found in ${filePath}`);
     }
+    const websocketOptions = api.websocketOptions
+      ? {
+          ...api.websocketOptions,
+          ...foundMethod.websocketTypeRefs,
+        }
+      : undefined;
+
     return {
       ...api,
+      websocketOptions,
       typeParameters: foundMethod?.typeParameters,
       parameters: foundMethod?.parameters,
       returnType: foundMethod?.returnType,
@@ -123,6 +147,93 @@ export async function readApisFromFile(filePath: AbsolutePath): Promise<Extended
   return extendedApis;
 }
 
+function readWebSocketTypeRefs(node: ts.MethodDeclaration): WebSocketTypeRefs {
+  const optionsLiteral = getDecoratorOptionsObjectLiteral(node, "websocket");
+  if (!optionsLiteral) {
+    return {};
+  }
+
+  const refs: WebSocketTypeRefs = {};
+  for (const property of optionsLiteral.properties) {
+    if (!ts.isPropertyAssignment(property)) {
+      continue;
+    }
+
+    const propertyName = getPropertyNameText(property.name);
+    if (propertyName !== "outEvents" && propertyName !== "inEvents") {
+      continue;
+    }
+
+    const typeRef = resolveDecoratorTypeRef(property.initializer);
+    if (!typeRef) {
+      continue;
+    }
+
+    if (propertyName === "outEvents") {
+      refs.outEventsTypeRef = typeRef;
+    } else {
+      refs.inEventsTypeRef = typeRef;
+    }
+  }
+
+  return refs;
+}
+
+function getDecoratorOptionsObjectLiteral(
+  node: ts.MethodDeclaration,
+  decoratorName: string,
+): ts.ObjectLiteralExpression | undefined {
+  for (const modifier of node.modifiers ?? []) {
+    if (!ts.isDecorator(modifier)) {
+      continue;
+    }
+
+    const expression = modifier.expression;
+    if (!ts.isCallExpression(expression)) {
+      continue;
+    }
+
+    if (!ts.isIdentifier(expression.expression) || expression.expression.text !== decoratorName) {
+      continue;
+    }
+
+    const [firstArg] = expression.arguments;
+    if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
+      return firstArg;
+    }
+  }
+
+  return undefined;
+}
+
+function getPropertyNameText(name: ts.PropertyName): string | undefined {
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+    return name.text;
+  }
+
+  return undefined;
+}
+
+function resolveDecoratorTypeRef(expression: ts.Expression): ApiParamType.Ref | undefined {
+  if (ts.isIdentifier(expression)) {
+    return {
+      t: "ref",
+      id: expression.text,
+    };
+  }
+
+  if (
+    ts.isAsExpression(expression) ||
+    ts.isParenthesizedExpression(expression) ||
+    ts.isNonNullExpression(expression) ||
+    ts.isTypeAssertionExpression(expression)
+  ) {
+    return resolveDecoratorTypeRef(expression.expression);
+  }
+
+  return undefined;
+}
+
 function resolveTypeNode(typeNode: ts.TypeNode): ApiParamType {
   switch (typeNode?.kind) {
     case ts.SyntaxKind.AnyKeyword:

package/src/syncer/checksum.ts

@@ -1,7 +1,5 @@
-import crypto from "crypto";
-import { type BinaryLike } from "crypto";
-import { createReadStream } from "fs";
-import { type PathLike } from "fs";
+import crypto, { type BinaryLike } from "crypto";
+import { createReadStream, type PathLike } from "fs";
 import { readFile, writeFile } from "fs/promises";
 import path from "path";
 
@@ -11,9 +9,9 @@ import { isEqual } from "radashi";
 import { Sonamu } from "../api/sonamu";
 import { globAsync } from "../utils/async-utils";
 import { exists } from "../utils/fs-utils";
-import { type AbsolutePath, type ApiRelativePath } from "../utils/path-utils";
+import { type AbsolutePath, type AppRelativePath } from "../utils/path-utils";
 import { differenceWith } from "../utils/utils";
-import { getChecksumPatternGroupInAbsolutePath } from "./file-patterns";
+import { getChecksumPatternGroupInAbsolutePath, GLOB_EXCLUDE } from "./file-patterns";
 
 type PathAndChecksum = {
   path: AbsolutePath;
@@ -53,17 +51,19 @@ export async function renewChecksums(): Promise<void> {
 }
 
 async function getCurrentChecksums(): Promise<PathAndChecksum[]> {
-  const filePaths = (
+  const allPaths = (
     await Promise.all(
-      Object.entries(getChecksumPatternGroupInAbsolutePath()).map(async ([_fileType, pattern]) => {
-        return globAsync(pattern) as Promise<AbsolutePath[]>;
+      Object.entries(getChecksumPatternGroupInAbsolutePath()).map(([_fileType, pattern]) => {
+        return globAsync(pattern, { exclude: GLOB_EXCLUDE });
       }),
     )
-  )
-    .flat()
-    .toSorted();
+  ).flat();
 
-  const fileChecksums = await Promise.all(
+  // 동일 파일이 여러 패턴에 매치될 수 있으므로(예: sd.generated.ts는 generated와 sdGenerated에 모두 매치)
+  // 중복 제거 후 안정 정렬.
+  const filePaths = Array.from(new Set(allPaths)).toSorted() as AbsolutePath[];
+
+  return await Promise.all(
     filePaths.map(async (filePath) => {
       return {
         path: filePath,
@@ -71,8 +71,6 @@ async function getCurrentChecksums(): Promise<PathAndChecksum[]> {
       };
     }),
   );
-
-  return fileChecksums;
 }
 
 async function getPreviousChecksums(): Promise<PathAndChecksum[]> {
@@ -83,8 +81,8 @@ async function getPreviousChecksums(): Promise<PathAndChecksum[]> {
 
   try {
     const previousChecksums = JSON.parse(await readFile(checksumFilePath, "utf-8")).map(
-      (r: { path: ApiRelativePath; checksum: string }) => ({
-        path: path.join(Sonamu.apiRootPath, r.path), // 체크섬 파일에서 읽을 때: API 상대 경로 → 절대 경로
+      (r: { path: AppRelativePath; checksum: string }) => ({
+        path: path.join(Sonamu.appRootPath, r.path), // 체크섬 파일에서 읽을 때: appRoot 상대 경로 → 절대 경로
         checksum: r.checksum,
       }),
     ) as PathAndChecksum[];
@@ -105,18 +103,14 @@ function getChecksumFilePath(): AbsolutePath {
 
 async function saveChecksums(checksums: PathAndChecksum[]): Promise<void> {
   const checksumFilePath = getChecksumFilePath();
-  await writeFile(
-    checksumFilePath,
-    JSON.stringify(
-      checksums.map((r) => ({
-        path: path.relative(Sonamu.apiRootPath, r.path), // 체크섬 파일에 저장할 때: 절대 경로 → API 상대 경로
-        checksum: r.checksum,
-      })),
-      null,
-      2,
-    ),
-    "utf-8",
-  );
+  // appRoot 상대 경로로 직렬화 + 알파벳 안정 정렬 (PR diff 깨끗하게 유지)
+  const serialized = checksums
+    .map((r) => ({
+      path: path.relative(Sonamu.appRootPath, r.path), // 체크섬 파일에 저장할 때: 절대 경로 → appRoot 상대 경로
+      checksum: r.checksum,
+    }))
+    .sort((a, b) => a.path.localeCompare(b.path));
+  await writeFile(checksumFilePath, JSON.stringify(serialized, null, 2), "utf-8");
 }
 
 async function getChecksumOfFile(filePath: PathLike): Promise<string> {

package/src/syncer/code-generator.ts

@@ -24,6 +24,7 @@ import { formatCode } from "../utils/formatter";
 import { exists } from "../utils/fs-utils";
 import { wrapIf } from "../utils/lodash-able";
 import { type AbsolutePath } from "../utils/path-utils";
+import { trackWritten } from "./file-tracking";
 
 /**
  * 템플릿을 렌더링하고 파일로 생성합니다.
@@ -179,7 +180,6 @@ async function resolveRenderedTemplate(
       Naite.t("resolveRenderedTemplate:beforeFormat", { key, header, body });
       const formatted = await formatCode(
         [header, body].join("\n\n"),
-        key === "entity" ? "json" : "typescript",
         `${Sonamu.appRootPath}/${filePath}`,
       );
       Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted);
@@ -208,6 +208,9 @@ async function writeCodeToPathEachTarget(pathAndCode: PathAndCode): Promise<Abso
         await mkdir(dir, { recursive: true });
       }
       await writeFile(dstFilePath, pathAndCode.code);
+      // 방금 우리가 쓴 path를 등록 → dev watcher의 후속 change 이벤트가
+      // 외부 변경으로 오인되지 않도록 거름 가드 자료 제공.
+      await trackWritten(dstFilePath);
       !isTest() &&
         console.log(
           chalk.bold("Generated: ") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, "")}`),

package/src/syncer/event-batcher.ts

@@ -0,0 +1,72 @@
+import { type AbsolutePath } from "../utils/path-utils";
+
+/**
+ * 파일 변경 이벤트를 batch로 모아 한 번에 처리하는 throttler를 만듭니다.
+ *
+ * 동작:
+ * - 같은 path가 여러 번 push되면 마지막 event로 dedupe됩니다.
+ * - 마지막 push 후 `delayMs` 동안 추가 push가 없으면 한 번에 flush됩니다 (trailing debounce).
+ * - flush 도중 들어오는 push는 다음 batch로 큐잉됩니다.
+ * - 한 시점에 onFlush는 단 하나만 진행됩니다 — 이로써 onFlush 내부에서 일어나는
+ *   작업이 다른 onFlush 호출과 인터리브되지 않음을 보장합니다.
+ *
+ * 호출자는 push만 하면 됩니다. 내부 큐/타이머 상태는 캡슐화되어 있고, onFlush가
+ * 받는 fileEvents는 dedupe된 Map입니다.
+ *
+ * @example
+ * const push = createFileEventBatcher({
+ *   delayMs: 100,
+ *   onFlush: (fileEvents) => handleBatch(fileEvents),
+ * });
+ * push("/path/a.ts" as AbsolutePath, "change");
+ * push("/path/b.ts" as AbsolutePath, "change"); // 100ms 후 둘 다 한 번에 onFlush로
+ */
+export function createFileEventBatcher<FileEventT extends string>(options: {
+  delayMs: number;
+  onFlush: (fileEvents: Map<AbsolutePath, FileEventT>) => Promise<void>;
+}): (path: AbsolutePath, event: FileEventT) => void {
+  const { delayMs, onFlush } = options;
+  const pending = new Map<AbsolutePath, FileEventT>();
+  let flushTimer: NodeJS.Timeout | null = null;
+  let isFlushing = false;
+
+  const scheduleFlush = (): void => {
+    if (flushTimer !== null) {
+      clearTimeout(flushTimer);
+    }
+    flushTimer = setTimeout(() => {
+      flushTimer = null;
+      void runFlush();
+    }, delayMs);
+  };
+
+  const runFlush = async (): Promise<void> => {
+    // flush 도중 추가 push로 또 다른 runFlush가 트리거된 경우, 한 번에 하나만 진행되게 합니다.
+    // 진행 중인 flush가 끝나면 finally에서 다음 batch를 자동으로 다시 스케줄합니다.
+    if (isFlushing || pending.size === 0) {
+      return;
+    }
+    isFlushing = true;
+    try {
+      // 현재까지 모인 변경을 snapshot으로 잡고 큐는 비웁니다.
+      // 이 batch가 처리되는 동안 들어오는 새 변경은 다음 batch로 모입니다.
+      const batch = new Map(pending);
+      pending.clear();
+      try {
+        await onFlush(batch);
+      } catch (e) {
+        console.error(e);
+      }
+    } finally {
+      isFlushing = false;
+      if (pending.size > 0) {
+        scheduleFlush();
+      }
+    }
+  };
+
+  return (path, event) => {
+    pending.set(path, event);
+    scheduleFlush();
+  };
+}

package/src/syncer/file-patterns.ts

@@ -1,51 +1,119 @@
 import path from "path";
 
 import { Sonamu } from "../api/sonamu";
-import { type AbsolutePath, type ApiRelativePath } from "../utils/path-utils";
+import { type AbsolutePath, type AppRelativePath } from "../utils/path-utils";
 
 /**
  * Syncer가 관심 가지고 지켜보는 파일들입니다.
  * 이 파일들에 변경이 생기면 추가적인 작업(이하 "싱크" 또는 "싱크 액션")을 수행합니다.
  * 이 작업이라 함은 파일 복사 또는 템플릿 렌더링을 통한 code generation을 의미합니다.
  *
- * **경로 형식**: API 상대 경로 (src/로 시작)
- * **사용**: getChecksumPatternGroupInAbsolutePath()로 절대 경로 변환 후 glob 사용
+ * 경로 형식: appRoot 기준 상대 경로 (target 디렉토리로 시작, 예: "api/src/...", "web/src/...")
+ * 사용: getChecksumPatternGroupInAbsolutePath()로 절대 경로 변환 후 glob 사용
+ *
+ * 두 가지 의미적 영역:
+ * - 입력 (사용자 작성): api 디렉토리에만 위치. 사용자가 직접 편집.
+ * - 출력 (sonamu 생성/복사): api 또는 target 디렉토리에 sonamu가 만들어내는 파일.
+ *
+ * 추적 밖 자산 (부트스트랩 phase에서 매번 보장):
+ * - sonamu.shared.ts: 사용자가 커스터마이즈하는 자산. IfNotExists로 1회 생성 후 손대지 않음.
+ * - entry-server.generated.tsx: 입력 의존 없는 정적 코드. 매번 overwrite generate.
+ *
+ * 위 둘은 sync()의 부트스트랩 phase에서 변경 검출 사이클과 무관하게 보장됩니다.
+ * 추적 사이클 안에서 할 액션이 없는 자산이라 패턴 그룹에 포함되지 않습니다.
+ *
+ * 위치 카테고리는 api/targets/anywhere 헬퍼로 명시적으로 표현합니다.
+ *
+ * FileType은 이 함수의 반환 타입에서 자동 추론됩니다. 키 추가 시 별도 enum/배열을
+ * 동기화할 필요 없이 여기 한 군데만 수정하면 됩니다.
  */
-const checksumPatternGroup = {
-  config: "src/sonamu.config.ts",
-  entity: "src/application/**/*.entity.json",
-  frame: "src/application/**/*.frame.ts",
-  functions: "src/application/**/*.functions.ts",
-  generated: "src/application/sonamu.generated.ts",
-  model: "src/application/**/*.model.ts",
-  types: "src/application/**/*.types.ts",
-  workflow: "src/application/**/*.workflow.ts",
-  i18n: "src/i18n/**/!(sd.generated).ts",
-  i18nGenerated: "src/i18n/**/sd.generated.ts",
-} as const satisfies Record<string, ApiRelativePath>;
-
-export { checksumPatternGroup };
-export type FileType = keyof typeof checksumPatternGroup;
-export type GlobPattern<T extends ApiRelativePath | AbsolutePath> = Record<FileType, T>;
+export function getChecksumPatternGroup() {
+  // 헬퍼 함수들 만들어서 가져옵니다.
+  const { api, targets, anywhere } = globBuilders();
+
+  return {
+    // Sonamu 입장에서 soruce가 되는 파일들입니다.
+    // 이 친구들이 변경되면 이들로부터 액션을 수행하고 파일을 생성합니다.
+    // 모노리포에서 이 source들은 api 프로젝트에 한정되므로, api에 있는 친구들만 리스팅합니다.
+    config: api("src/sonamu.config.ts"),
+    entity: api("src/application/**/*.entity.json"),
+    frame: api("src/application/**/*.frame.ts"),
+    functions: api("src/application/**/*.functions.ts"),
+    model: api("src/application/**/*.model.ts"),
+    types: api("src/application/**/*.types.ts"),
+    workflow: api("src/application/**/*.workflow.ts"),
+    i18n: api("src/i18n/**/!(sd.generated).ts"),
+
+    // Sonamu가 출력하는 생성 파일들입니다.
+    // 이 친구들도 정합성 검증 차원에서 sonamu.lock에 기록해야 하고,
+    // 또한 변경시 그 사실을 syncer가 알기는 해야 합니다(비록 별다른 처리가 없는 경우도 있지만).
+    //
+    // 자산 본성에 따라 위치 카테고리가 다르기 때문에, 본성별로 분리해서 표기합니다.
+    // - 양쪽-필요 자산: api에 정본이 만들어진 뒤 target에 복사됨 (sonamu.generated.*, queries.generated.ts).
+    // - api 전용 자산: api에만 만들어짐 (sonamu.generated.http).
+    // - target 전용 자산: target에만 만들어짐 (services.generated.ts는 services.template의 :target 분배).
+    //
+    // 여기에는 Sonamu의 모든 sync 산출물이 있는 것은 아닙니다.
+    // sonamu.shared.ts와 entry-server.generated.tsx와 같은
+    // sync 초반 1회성 부트스트랩 파일들은 관리 안 하기 때문에 여기에 리스팅도 안 합니다.
+    generated: api("src/application/**/*.generated.{ts,tsx,sso.ts}"),
+    generatedCopied: targets("src/services/**/{sonamu,queries}.generated.{ts,tsx,sso.ts}"),
+    httpGenerated: api("src/application/**/*.generated.http"),
+    servicesGenerated: targets("src/services/services.generated.ts"),
+    sdGenerated: anywhere("src/i18n/**/sd.generated.ts"),
+    typesCopied: targets("src/services/**/*.types.ts"),
+    functionsCopied: targets("src/services/**/*.functions.ts"),
+    i18nCopied: targets("src/i18n/**/!(sd.generated).ts"),
+  } satisfies Record<string, AppRelativePath>;
+}
 
 /**
- * API 상대 경로 패턴을 절대 경로 패턴으로 변환합니다.
- *
- * **목적**: Glob 패턴을 파일시스템에서 사용할 수 있는 절대 경로로 변환
- *
- * **사용처**: checksum.ts에서 실제 파일을 찾을 때
+ * 위치 카테고리별 글롭 빌더를 만들어 반환합니다.
+ * - api(rest): api 디렉토리에 한정
+ * - targets(rest): target 디렉토리들에 한정 (web, app 등)
+ * - anywhere(rest): api와 target 모두
+ */
+function globBuilders() {
+  const apiDir = Sonamu.config.api.dir;
+  const targetDirs = Sonamu.config.sync.targets;
+
+  // Node 내장 fs.glob의 brace expansion은 단일 멤버 {x}를 풀지 않으므로, 멤버가 1개일 때는 alternation 없이 직접 결합합니다.
+  const braceJoin = (dirs: readonly string[]) =>
+    dirs.length === 1 ? dirs[0] : `{${dirs.join(",")}}`;
+
+  return {
+    api: (pathFromApi: string) => `${apiDir}/${pathFromApi}` as AppRelativePath,
+    targets: (pathFromTarget: string) =>
+      `${braceJoin(targetDirs)}/${pathFromTarget}` as AppRelativePath,
+    anywhere: (pathFromAnywhere: string) =>
+      `${braceJoin([apiDir, ...targetDirs])}/${pathFromAnywhere}` as AppRelativePath,
+  };
+}
+
+/**
+ * FileType은 getChecksumPatternGroup의 반환 객체 키에서 자동 추론됩니다.
+ * 별도 배열/enum 동기화 불필요 — 패턴 그룹 함수가 진실의 단일 원천.
+ */
+export type FileType = keyof ReturnType<typeof getChecksumPatternGroup>;
+export type GlobPattern<T extends AppRelativePath | AbsolutePath> = Record<FileType, T>;
+
+/**
+ * 빌드 산출물 디렉토리는 alternation 글롭이 의도치 않게 휘말릴 수 있으므로 안전망으로 제외.
+ * Node 내장 fs.glob의 exclude 옵션과 함께 사용합니다.
+ */
+export const GLOB_EXCLUDE = ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.turbo/**"];
+
+/**
+ * appRoot 기준 상대 경로 패턴을 절대 경로 패턴으로 변환합니다.
  *
  * @returns 절대 경로 기반 Glob 패턴 맵
- *
- * @example
- * // 입력: { entity: "src/application/**\/*.entity.json" }
- * // 출력: { entity: "/Users/.../api/src/application/**\/*.entity.json" }
  */
 export function getChecksumPatternGroupInAbsolutePath(): GlobPattern<AbsolutePath> {
+  const group = getChecksumPatternGroup();
   return Object.fromEntries(
-    Object.entries(checksumPatternGroup).map(([key, value]) => [
+    Object.entries(group).map(([key, value]) => [
       key,
-      path.join(Sonamu.apiRootPath, value), // API 상대 경로 → 절대 경로
+      path.join(Sonamu.appRootPath, value), // appRoot 상대 경로 → 절대 경로
     ]),
   ) as GlobPattern<AbsolutePath>;
 }

package/src/syncer/file-tracking.ts

@@ -0,0 +1,27 @@
+import { stat } from "fs/promises";
+
+import { type AbsolutePath } from "../utils/path-utils";
+
+export const fileWrittenAt = new Map<AbsolutePath, number>();
+
+/**
+ * 우리가 디스크에 write한 path를 등록합니다. write 직후 호출하세요.
+ * 디스크에서 mtime을 직접 읽어 정확한 값으로 등록합니다.
+ */
+export async function trackWritten(filePath: AbsolutePath): Promise<void> {
+  const fileStat = await stat(filePath);
+  fileWrittenAt.set(filePath, fileStat.mtimeMs);
+}
+
+/**
+ * 주어진 path가 가장 최근 우리 write 이후로 외부에서 수정된 적 없는지 확인합니다.
+ * true면 "내가 쓴 그대로 남아있음", false면 "외부에서 수정됐거나 우리가 쓴 적 없음".
+ */
+export async function isLastChangedByMe(filePath: AbsolutePath): Promise<boolean> {
+  const registered = fileWrittenAt.get(filePath);
+  if (registered === undefined) {
+    return false;
+  }
+  const fileStat = await stat(filePath);
+  return fileStat.mtimeMs <= registered;
+}

package/src/syncer/module-loader.ts

@@ -3,26 +3,17 @@ import path from "path";
 import { z } from "zod";
 
 import { type BaseFrameClass } from "../api/base-frame";
-import { type ApiDecoratorOptions } from "../api/decorators";
+import { type ExtendedApi } from "../api/decorators";
 import { Sonamu } from "../api/sonamu";
 import { type BaseModelClass } from "../database/base-model";
 import { type WorkflowMetadata } from "../tasks/decorator";
-import { type ApiParam, type ApiParamType } from "../types/types";
 import { globAsync } from "../utils/async-utils";
 import { importMembers } from "../utils/esm-utils";
 import { runtimePath } from "../utils/path-utils";
 import { type AbsolutePath } from "../utils/path-utils";
 import { readApisFromFile } from "./api-parser";
 
-export type LoadedApis = {
-  typeParameters: ApiParamType.TypeParam[];
-  parameters: ApiParam[];
-  returnType: ApiParamType;
-  modelName: string;
-  methodName: string;
-  path: string;
-  options: ApiDecoratorOptions;
-}[];
+export type LoadedApis = ExtendedApi[];
 
 export type LoadedTypes = { [typeName: string]: z.ZodType };
 
@@ -100,7 +91,9 @@ export async function loadTypes(): Promise<LoadedTypes> {
     path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.types.ts")),
     path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.generated.ts")),
   ];
-  const typePaths = (await Promise.all(typePathsPatterns.map(globAsync))).flat();
+  const typePaths = (
+    await Promise.all(typePathsPatterns.map((pattern) => globAsync(pattern)))
+  ).flat();
 
   const types: LoadedTypes = {};
   for (const filePath of typePaths) {