sonamu 0.6.0 → 0.7.0

package/src/shared/web.shared.ts.txt

@@ -1,23 +1,27 @@
+/** biome-ignore-all lint/correctness/useExhaustiveDependencies: shared */
+/** biome-ignore-all lint/suspicious/noExplicitAny: shared */
+
 /*
   fetch
 */
 import type { AxiosRequestConfig } from "axios";
 import axios from "axios";
-import { z, ZodIssue } from "zod";
 import qs from "qs";
+import { type ZodIssue, z } from "zod";
 
 // ISO 8601 및 타임존 포맷의 날짜 문자열을 Date 객체로 변환하는 reviver
-function dateReviver(key: string, value: any): any {
+function dateReviver(_key: string, value: any): any {
   if (typeof value === "string") {
     // ISO 8601 형식: 2024-01-15T09:30:00.000Z 또는 2024-01-15T09:30:00+09:00
-    const isoRegex =
-      /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d{1,3})?)?(Z|[+-]\d{2}:\d{2})?$/;
+    const isoRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d{1,3})?)?(Z|[+-]\d{2}:\d{2})?$/;
 
     // Timezone 포맷: 2024-01-15 09:30:00+09:00
     const timezoneRegex = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}$/;
 
-    if ((isoRegex.test(value) || timezoneRegex.test(value)) &&
-        new Date(value).toString() !== "Invalid Date") {
+    if (
+      (isoRegex.test(value) || timezoneRegex.test(value)) &&
+      new Date(value).toString() !== "Invalid Date"
+    ) {
       return new Date(value);
     }
   }
@@ -29,7 +33,7 @@ axios.defaults.transformResponse = [
     if (typeof data === "string") {
       try {
         return JSON.parse(data, dateReviver);
-      } catch (e) {
+      } catch {
         return data;
       }
     }
@@ -61,7 +65,7 @@ export class SonamuError extends Error {
   constructor(
     public code: number,
     public message: string,
-    public issues: z.ZodIssue[]
+    public issues: z.ZodIssue[],
   ) {
     super(message);
     this.isSonamuError = true;
@@ -106,9 +110,7 @@ export async function swrFetcher(args: [string, object]): Promise<any> {
     const res = await axios.get(`${url}?${qs.stringify(params)}`);
     return res.data;
   } catch (e: any) {
-    const error: any = new Error(
-      e.response.data.message ?? e.response.message ?? "Unknown"
-    );
+    const error: any = new Error(e.response.data.message ?? e.response.message ?? "Unknown");
     error.statusCode = e.response?.data.statusCode ?? e.response.status;
     throw error;
   }
@@ -119,16 +121,14 @@ export async function swrPostFetcher(args: [string, object]): Promise<any> {
     const res = await axios.post(url, params);
     return res.data;
   } catch (e: any) {
-    const error: any = new Error(
-      e.response.data.message ?? e.response.message ?? "Unknown"
-    );
+    const error: any = new Error(e.response.data.message ?? e.response.message ?? "Unknown");
     error.statusCode = e.response?.data.statusCode ?? e.response.status;
     throw error;
   }
 }
 export function handleConditional(
   args: [string, object],
-  conditional?: () => boolean
+  conditional?: () => boolean,
 ): [string, object] | null {
   if (conditional) {
     return conditional() ? args : null;
@@ -139,9 +139,7 @@ export function handleConditional(
 /*
   Utils
 */
-export function zArrayable<T extends z.ZodTypeAny>(
-  shape: T
-): z.ZodUnion<[T, z.ZodArray<T>]> {
+export function zArrayable<T extends z.ZodTypeAny>(shape: T): z.ZodUnion<[T, z.ZodArray<T>]> {
   return z.union([shape, shape.array()]);
 }
 
@@ -175,6 +173,7 @@ export type SSEStreamState = {
 export type EventHandlers<T> = {
   [K in keyof T]: (data: T[K]) => void;
 };
+
 import { useEffect, useRef, useState } from "react";
 
 export function useSSEStream<T extends Record<string, any>>(
@@ -183,7 +182,7 @@ export function useSSEStream<T extends Record<string, any>>(
   handlers: {
     [K in keyof T]?: (data: T[K]) => void;
   },
-  options: SSEStreamOptions = {}
+  options: SSEStreamOptions = {},
 ): SSEStreamState {
   const { enabled = true, retry = 3, retryInterval = 3000 } = options;
 
@@ -245,7 +244,7 @@ export function useSSEStream<T extends Record<string, any>>(
         }));
       };
 
-      eventSource.onerror = (event) => {
+      eventSource.onerror = (_event) => {
         // 이미 다른 연결로 교체되었는지 확인
         if (eventSourceRef.current !== eventSource) {
           return; // 이미 새로운 연결이 있으면 무시
@@ -313,10 +312,7 @@ export function useSSEStream<T extends Record<string, any>>(
               const data = JSON.parse(event.data);
               handler(data);
             } catch (error) {
-              console.error(
-                `Failed to parse SSE data for event ${eventType}:`,
-                error
-              );
+              console.error(`Failed to parse SSE data for event ${eventType}:`, error);
             }
             setState((prev) => ({
               ...prev,

package/src/stream/sse.ts

@@ -1,11 +1,11 @@
-import { z } from "zod";
-import type { FastifyRequest, FastifyReply } from "fastify";
+import type { FastifyReply, FastifyRequest } from "fastify";
+import type { z } from "zod";
 
 // NOTE(Haze, 251106): context provider에서 인자를 채워주면 createSSE(events)만으로 사용 가능
 export function createSSEFactory<T extends z.ZodObject>(
   socket: FastifyRequest["socket"],
   reply: FastifyReply,
-  _events: T
+  _events: T,
 ) {
   return new SSEConnection<T>(socket, reply);
 }
@@ -15,7 +15,7 @@ class SSEConnection<T extends z.ZodObject> {
 
   constructor(
     private readonly socket: FastifyRequest["socket"],
-    private readonly reply: FastifyReply
+    private readonly reply: FastifyReply,
   ) {
     this.socket.on("close", () => {
       this._closed = true;
@@ -42,7 +42,7 @@ class SSEConnection<T extends z.ZodObject> {
       event: "end",
       data: "END",
     });
-    
+
     await new Promise((resolve) => setTimeout(resolve, 200));
     this.reply.raw.end();
   }

package/src/syncer/api-parser.ts

@@ -1,11 +1,11 @@
-import { ApiParam, ApiParamType } from "../types/types";
+import assert from "assert";
 import { readFile } from "fs/promises";
-import * as _ from "lodash-es";
-import ts from "typescript";
-import { ExtendedApi, registeredApis } from "../api/decorators";
 import inflection from "inflection";
-import assert from "assert";
-import { AbsolutePath } from "../utils/path-utils";
+import ts from "typescript";
+import { type ExtendedApi, registeredApis } from "../api/decorators";
+import { validateMethodName } from "../api/validator";
+import type { ApiParam, ApiParamType } from "../types/types";
+import type { AbsolutePath } from "../utils/path-utils";
 
 /**
  * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.
@@ -13,15 +13,17 @@ import { AbsolutePath } from "../utils/path-utils";
  * @param filePath - 파싱할 TypeScript 파일의 절대 경로
  * @returns API 메소드 정보 배열 (타입 파라미터, 파라미터, 리턴 타입 등)
  */
-export async function readApisFromFile(filePath: AbsolutePath) {
-  if (!filePath.endsWith(".ts")) { 
-    throw new Error(`${filePath} does not seem to be a TypeScript file. Please check the file path. We only support parsing TypeScript files.`);
+export async function readApisFromFile(filePath: AbsolutePath): Promise<ExtendedApi[]> {
+  if (!filePath.endsWith(".ts")) {
+    throw new Error(
+      `${filePath} does not seem to be a TypeScript file. Please check the file path. We only support parsing TypeScript files.`,
+    );
   }
-  
+
   const sourceFile = ts.createSourceFile(
     filePath,
     (await readFile(filePath)).toString(),
-    ts.ScriptTarget.Latest
+    ts.ScriptTarget.Latest,
   );
 
   const methods: Omit<ExtendedApi, "path" | "options">[] = [];
@@ -36,21 +38,20 @@ export async function readApisFromFile(filePath: AbsolutePath) {
     if (ts.isMethodDeclaration(node)) {
       if (ts.isIdentifier(node.name)) {
         methodName = node.name.escapedText.toString();
+        validateMethodName(methodName);
       }
 
-      const typeParameters: ApiParamType.TypeParam[] = (
-        node.typeParameters ?? []
-      ).map((typeParam) => {
-        const tp = typeParam as ts.TypeParameterDeclaration;
+      const typeParameters: ApiParamType.TypeParam[] = (node.typeParameters ?? []).map(
+        (typeParam) => {
+          const tp = typeParam as ts.TypeParameterDeclaration;
 
-        return {
-          t: "type-param",
-          id: tp.name.escapedText.toString(),
-          constraint: tp.constraint
-            ? resolveTypeNode(tp.constraint)
-            : undefined,
-        };
-      });
+          return {
+            t: "type-param",
+            id: tp.name.escapedText.toString(),
+            constraint: tp.constraint ? resolveTypeNode(tp.constraint) : undefined,
+          };
+        },
+      );
       const parameters: ApiParam[] = node.parameters.map((paramDec, index) => {
         const defaultDef = printNode(paramDec.initializer, sourceFile);
 
@@ -60,20 +61,16 @@ export async function readApisFromFile(filePath: AbsolutePath) {
           {
             name: paramDec.name,
             type: paramDec.type as ts.TypeNode,
-            optional:
-              paramDec.questionToken !== undefined ||
-              paramDec.initializer !== undefined,
+            optional: paramDec.questionToken !== undefined || paramDec.initializer !== undefined,
             defaultDef,
           },
-          index
+          index,
         );
       });
       if (node.type === undefined) {
-        throw new Error(
-          `리턴 타입이 기재되지 않은 메소드 ${modelName}.${methodName}`
-        );
+        throw new Error(`리턴 타입이 기재되지 않은 메소드 ${modelName}.${methodName}`);
       }
-      const returnType = resolveTypeNode(node.type!);
+      const returnType = resolveTypeNode(node.type);
 
       methods.push({
         modelName,
@@ -94,9 +91,7 @@ export async function readApisFromFile(filePath: AbsolutePath) {
   // 현재 파일의 등록된 API 필터
   const currentModelApis = registeredApis.filter((api) => {
     return methods.find(
-      (method) =>
-        method.modelName === api.modelName &&
-        method.methodName === api.methodName
+      (method) => method.modelName === api.modelName && method.methodName === api.methodName,
     );
   });
   if (currentModelApis.length === 0) {
@@ -109,15 +104,16 @@ export async function readApisFromFile(filePath: AbsolutePath) {
   // 등록된 API에 현재 메소드 타입 정보 확장
   const extendedApis = currentModelApis.map((api) => {
     const foundMethod = methods.find(
-      (method) =>
-        method.modelName === api.modelName &&
-        method.methodName === api.methodName
+      (method) => method.modelName === api.modelName && method.methodName === api.methodName,
     );
+    if (!foundMethod) {
+      throw new Error(`API ${api.modelName}.${api.methodName} not found in ${filePath}`);
+    }
     return {
       ...api,
-      typeParameters: foundMethod!.typeParameters,
-      parameters: foundMethod!.parameters,
-      returnType: foundMethod!.returnType,
+      typeParameters: foundMethod?.typeParameters,
+      parameters: foundMethod?.parameters,
+      returnType: foundMethod?.returnType,
     };
   });
   return extendedApis;
@@ -141,7 +137,7 @@ function resolveTypeNode(typeNode: ts.TypeNode): ApiParamType {
       return "null";
     case ts.SyntaxKind.VoidKeyword:
       return "void";
-    case ts.SyntaxKind.LiteralType:
+    case ts.SyntaxKind.LiteralType: {
       const literal = (typeNode as ts.LiteralTypeNode).literal;
       if (ts.isStringLiteral(literal)) {
         return {
@@ -165,13 +161,15 @@ function resolveTypeNode(typeNode: ts.TypeNode): ApiParamType {
         }
         throw new Error("알 수 없는 리터럴");
       }
-    case ts.SyntaxKind.ArrayType:
+    }
+    case ts.SyntaxKind.ArrayType: {
       const arrNode = typeNode as ts.ArrayTypeNode;
       return {
         t: "array",
         elementsType: resolveTypeNode(arrNode.elementType),
       };
-    case ts.SyntaxKind.TypeLiteral:
+    }
+    case ts.SyntaxKind.TypeLiteral: {
       const literalNode = typeNode as ts.TypeLiteralNode;
       return {
         t: "object",
@@ -185,9 +183,7 @@ function resolveTypeNode(typeNode: ts.TypeNode): ApiParamType {
 
             return resolveParamDec({
               name: {
-                escapedText: `[${res.name}${res.optional ? "?" : ""}: ${
-                  res.type
-                }]`,
+                escapedText: `[${res.name}${res.optional ? "?" : ""}: ${res.type}]`,
               } as ts.Identifier,
               type: member.type as ts.TypeNode,
             });
@@ -195,45 +191,35 @@ function resolveTypeNode(typeNode: ts.TypeNode): ApiParamType {
             return resolveParamDec({
               name: (member as ts.PropertySignature).name as ts.Identifier,
               type: (member as ts.PropertySignature).type as ts.TypeNode,
-              optional:
-                (member as ts.PropertySignature).questionToken !== undefined,
+              optional: (member as ts.PropertySignature).questionToken !== undefined,
             });
           }
         }),
       };
+    }
     case ts.SyntaxKind.TypeReference:
       return {
         t: "ref",
-        id: (
-          (typeNode as ts.TypeReferenceNode).typeName as ts.Identifier
-        ).escapedText.toString(),
+        id: ((typeNode as ts.TypeReferenceNode).typeName as ts.Identifier).escapedText.toString(),
         args: (typeNode as ts.TypeReferenceNode).typeArguments?.map((typeArg) =>
-          resolveTypeNode(typeArg)
+          resolveTypeNode(typeArg),
         ),
       };
     case ts.SyntaxKind.UnionType:
       return {
         t: "union",
-        types: (typeNode as ts.UnionTypeNode).types.map((type) =>
-          resolveTypeNode(type)
-        ),
+        types: (typeNode as ts.UnionTypeNode).types.map((type) => resolveTypeNode(type)),
       };
     case ts.SyntaxKind.IntersectionType:
       return {
         t: "intersection",
-        types: (typeNode as ts.IntersectionTypeNode).types.map((type) =>
-          resolveTypeNode(type)
-        ),
+        types: (typeNode as ts.IntersectionTypeNode).types.map((type) => resolveTypeNode(type)),
       };
     case ts.SyntaxKind.IndexedAccessType:
       return {
         t: "indexed-access",
-        object: resolveTypeNode(
-          (typeNode as ts.IndexedAccessTypeNode).objectType
-        ),
-        index: resolveTypeNode(
-          (typeNode as ts.IndexedAccessTypeNode).indexType
-        ),
+        object: resolveTypeNode((typeNode as ts.IndexedAccessTypeNode).objectType),
+        index: resolveTypeNode((typeNode as ts.IndexedAccessTypeNode).indexType),
       };
     case ts.SyntaxKind.TupleType:
       if (ts.isTupleTypeNode(typeNode)) {
@@ -258,7 +244,7 @@ function resolveParamDec(
     optional?: boolean;
     defaultDef?: string;
   },
-  index: number = 0
+  index: number = 0,
 ): ApiParam {
   const name = paramDec.name as ts.Identifier;
   const type = resolveTypeNode(paramDec.type);
@@ -286,10 +272,7 @@ function resolveParamDec(
   return result;
 }
 
-function printNode(
-  node: ts.Node | undefined,
-  sourceFile: ts.SourceFile
-): string | undefined {
+function printNode(node: ts.Node | undefined, sourceFile: ts.SourceFile): string | undefined {
   if (node === undefined) {
     return undefined;
   }

package/src/syncer/checksum.ts

@@ -1,17 +1,14 @@
+import crypto, { type BinaryLike } from "crypto";
+import equal from "fast-deep-equal";
+import { createReadStream, type PathLike } from "fs";
+import { readFile, writeFile } from "fs/promises";
 import path from "path";
+import { isEqual } from "radashi";
+import { Sonamu } from "../api/sonamu";
 import { globAsync } from "../utils/async-utils";
-import { createReadStream, PathLike } from "fs";
-import { readFile, writeFile } from "fs/promises";
 import { exists } from "../utils/fs-utils";
-
-import crypto from "crypto";
-import equal from "fast-deep-equal";
-import * as _ from "lodash-es";
-import { Sonamu } from "../api/sonamu";
-import {
-  AbsolutePath,
-  ApiRelativePath,
-} from "../utils/path-utils";
+import type { AbsolutePath, ApiRelativePath } from "../utils/path-utils";
+import { differenceWith } from "../utils/utils";
 import { getChecksumPatternGroupInAbsolutePath } from "./file-patterns";
 
 type PathAndChecksum = {
@@ -23,9 +20,7 @@ type PathAndChecksum = {
  * 체크섬 파일에 저장된 내용과 현재 실제 파일의 체크섬을 비교하여 변경된 파일을 찾습니다.
  * @returns 변경된 파일 경로 배열. 프로젝트 루트부터 슬래시로 시작합니다. 예시: "/src/application/user/user.model.ts"
  */
-export async function findChangedFilesUsingChecksums(): Promise<
-  AbsolutePath[]
-> {
+export async function findChangedFilesUsingChecksums(): Promise<AbsolutePath[]> {
   const calculatedChecksums = await getCurrentChecksums();
   const savedChecksums = await getPreviousChecksums();
 
@@ -34,9 +29,7 @@ export async function findChangedFilesUsingChecksums(): Promise<
     return [];
   }
 
-  const diff = _.differenceWith(calculatedChecksums, savedChecksums, _.isEqual);
-
-  return diff.map((r) => r.path);
+  return differenceWith(calculatedChecksums, savedChecksums, isEqual).map((r) => r.path);
 }
 
 /**
@@ -62,10 +55,7 @@ export async function renewChecksums(): Promise<void> {
  * @param two 파일 경로
  * @returns boolean
  */
-export async function areFilesSame(
-  one: PathLike,
-  two: PathLike
-): Promise<boolean> {
+export async function areFilesSame(one: PathLike, two: PathLike): Promise<boolean> {
   if (!(await exists(one)) || !(await exists(two))) {
     return false;
   }
@@ -79,11 +69,9 @@ export async function areFilesSame(
 async function getCurrentChecksums(): Promise<PathAndChecksum[]> {
   const filePaths = (
     await Promise.all(
-      Object.entries(getChecksumPatternGroupInAbsolutePath()).map(
-        async ([_fileType, pattern]) => {
-          return globAsync(pattern) as Promise<AbsolutePath[]>;
-        }
-      )
+      Object.entries(getChecksumPatternGroupInAbsolutePath()).map(async ([_fileType, pattern]) => {
+        return globAsync(pattern) as Promise<AbsolutePath[]>;
+      }),
     )
   )
     .flat()
@@ -95,7 +83,7 @@ async function getCurrentChecksums(): Promise<PathAndChecksum[]> {
         path: filePath,
         checksum: await getChecksumOfFile(filePath),
       };
-    })
+    }),
   );
 
   return fileChecksums;
@@ -107,12 +95,12 @@ async function getPreviousChecksums(): Promise<PathAndChecksum[]> {
     return [];
   }
 
-  const previousChecksums = JSON.parse(
-    await readFile(checksumFilePath, "utf-8")
-  ).map((r: { path: ApiRelativePath; checksum: string }) => ({
-    path: path.join(Sonamu.apiRootPath, r.path), // 체크섬 파일에서 읽을 때: API 상대 경로 → 절대 경로
-    checksum: r.checksum,
-  })) as PathAndChecksum[];
+  const previousChecksums = JSON.parse(await readFile(checksumFilePath, "utf-8")).map(
+    (r: { path: ApiRelativePath; checksum: string }) => ({
+      path: path.join(Sonamu.apiRootPath, r.path), // 체크섬 파일에서 읽을 때: API 상대 경로 → 절대 경로
+      checksum: r.checksum,
+    }),
+  ) as PathAndChecksum[];
   return previousChecksums;
 }
 
@@ -130,9 +118,9 @@ async function saveChecksums(checksums: PathAndChecksum[]): Promise<void> {
         checksum: r.checksum,
       })),
       null,
-      2
+      2,
     ),
-    "utf-8"
+    "utf-8",
   );
   console.log("checksum saved", checksumFilePath);
 }
@@ -142,10 +130,10 @@ async function getChecksumOfFile(filePath: PathLike): Promise<string> {
     const hash = crypto.createHash("sha1");
     const input = createReadStream(filePath);
     input.on("error", reject);
-    input.on("data", function (chunk: any) {
+    input.on("data", (chunk: BinaryLike) => {
       hash.update(chunk);
     });
-    input.on("close", function () {
+    input.on("close", () => {
       resolve(hash.digest("hex"));
     });
   });