@simplysm/service-server 13.0.99 → 14.0.1

package/src/services/orm-service.ts

@@ -15,7 +15,7 @@ import consola from "consola";
 
 const logger = consola.withTag("service-server:OrmService");
 
-// Static state needs to live outside the factory (shared across calls)
+// 정적 상태는 팩토리 외부에 존재해야 함 (호출 간 공유)
 const socketConns = new WeakMap<ServiceSocket, Map<number, DbConn>>();
 
 export const OrmService = defineService(
@@ -24,7 +24,7 @@ export const OrmService = defineService(
     const sock = (): ServiceSocket => {
       const socket = ctx.socket;
       if (socket == null) {
-        throw new Error("WebSocket connection is required. ORM service cannot be used over HTTP.");
+        throw new Error("WebSocket 연결이 필요합니다. ORM 서비스는 HTTP로 사용할 수 없습니다.");
       }
       return socket;
     };
@@ -34,7 +34,7 @@ export const OrmService = defineService(
         opt.configName
       ];
       if (config == null) {
-        throw new Error(`ORM configuration not found: ${opt.configName}`);
+        throw new Error(`ORM 설정을 찾을 수 없습니다: ${opt.configName}`);
       }
       return { ...config, ...opt.config } as DbConnConfig;
     };
@@ -43,7 +43,7 @@ export const OrmService = defineService(
       const myConns = socketConns.get(sock());
       const conn = myConns?.get(connId);
       if (conn == null) {
-        throw new Error("Not connected to database. (Invalid Connection ID)");
+        throw new Error("데이터베이스에 연결되지 않았습니다. (유효하지 않은 연결 ID)");
       }
       return conn;
     };
@@ -71,7 +71,7 @@ export const OrmService = defineService(
           sock().on("close", async () => {
             if (myConns == null) return;
 
-            logger.debug("Socket close detected: cleaning up all open DB connections.");
+            logger.debug("소켓 종료 감지: 열린 모든 DB 연결을 정리합니다.");
             const conns = Array.from(myConns.values());
 
             await Promise.all(
@@ -81,7 +81,7 @@ export const OrmService = defineService(
                     await conn.close();
                   }
                 } catch (err) {
-                  logger.warn("Error ignored during forced DB connection close", err);
+                  logger.warn("강제 DB 연결 종료 중 에러 무시됨", err);
                 }
               }),
             );
@@ -110,7 +110,7 @@ export const OrmService = defineService(
           const conn = getConn(connId);
           await conn.close();
         } catch (err) {
-          logger.warn("Error ignored during DB connection close", err);
+          logger.warn("DB 연결 종료 중 에러 무시됨", err);
         }
       },
 

package/src/transport/http/http-request-handler.ts

@@ -16,49 +16,55 @@ export async function handleHttpRequest<TAuthInfo = unknown>(
 ): Promise<void> {
   const { service, method } = req.params as { service: string; method: string };
 
-  // ClientName header
+  // ClientName 헤더
   const clientName = req.headers["x-sd-client-name"] as string | undefined;
-  if (clientName == null) throw new Error("ClientName header is required");
+  if (clientName == null) throw new Error("ClientName 헤더가 필요합니다");
 
-  // Parse and verify Authorization header
+  // Authorization 헤더 파싱 및 검증
   let authTokenPayload: AuthTokenPayload<TAuthInfo> | undefined;
   try {
     const authHeader = req.headers.authorization;
     if (authHeader != null) {
-      if (jwtSecret == null) throw new Error("JWT Secret is not defined.");
+      if (jwtSecret == null) throw new Error("JWT Secret이 정의되지 않았습니다.");
 
       const token = authHeader.split(" ")[1]; // "Bearer <token>"
       authTokenPayload = await verifyJwt<TAuthInfo>(jwtSecret, token);
     }
   } catch (err) {
     reply.status(401).send({
-      error: "Unauthorized",
+      error: "인증 실패",
       message: err instanceof Error ? err.message : String(err),
     });
     return;
   }
 
-  // Parse parameters
+  // 매개변수 파싱
   let params: unknown[] | undefined;
   if (req.method === "GET") {
     const query = req.query as { json?: string };
     if (typeof query.json !== "string") {
-      throw new Error("JSON query parameter required");
+      throw new Error("JSON 쿼리 파라미터가 필요합니다");
     }
     params = json.parse(query.json);
   } else if (req.method === "POST") {
     if (!Array.isArray(req.body)) {
       reply.status(400).send({
-        error: "Bad Request",
-        message: "Request body must be an array.",
+        error: "잘못된 요청",
+        message: "요청 본문은 배열이어야 합니다.",
       });
       return;
     }
 
     params = req.body as unknown[];
+  } else {
+    reply.status(405).send({
+      error: "Method Not Allowed",
+      message: `${req.method} 메서드는 지원하지 않습니다.`,
+    });
+    return;
   }
 
-  // Execute service and send response
+  // 서비스 실행 및 응답 전송
   if (params != null) {
     const serviceResult = await runMethod({
       serviceName: service,

package/src/transport/http/static-file-handler.ts

@@ -14,12 +14,12 @@ export async function handleStaticFile(
   let targetFilePath = path.resolve(rootPath, "www", urlPath);
   const allowedRootPath = path.resolve(rootPath, "www");
 
-  // Security guard for targetPath (prevent path traversal)
+  // targetPath 보안 가드 (경로 탐색 공격 방지)
   if (targetFilePath !== allowedRootPath && !pathx.isChildPath(targetFilePath, allowedRootPath)) {
-    throw new Error("Access denied");
+    throw new Error("접근이 거부되었습니다");
   }
 
-  // Redirect with trailing slash for directories (standard web server behavior)
+  // 디렉토리에 대해 슬래시를 추가하여 리다이렉트 (표준 웹 서버 동작)
   if ((await fsx.exists(targetFilePath)) && (await fsx.stat(targetFilePath)).isDirectory()) {
     if (!urlPath.endsWith("/")) {
       const urlObj = new URL(req.raw.url!, "http://localhost");
@@ -29,15 +29,15 @@ export async function handleStaticFile(
     targetFilePath = path.resolve(targetFilePath, "index.html");
   }
 
-  // Permission check (hidden files, etc.)
+  // 권한 확인 (숨김 파일 등)
   if (path.basename(targetFilePath).startsWith(".")) {
-    const errorMessage = "You do not have permission to access this file.";
+    const errorMessage = "이 파일에 접근할 권한이 없습니다.";
     responseErrorHtml(reply, 403, errorMessage);
     logger.warn(`[403] ${errorMessage} (${targetFilePath})`);
     return;
   }
 
-  // Send file
+  // 파일 전송
   const filename = path.basename(targetFilePath);
   const directory = path.dirname(targetFilePath);
 
@@ -46,11 +46,11 @@ export async function handleStaticFile(
   } catch (err: unknown) {
     const error = err as { code?: string };
     if (error.code === "ENOENT") {
-      const errorMessage = "File not found.";
+      const errorMessage = "파일을 찾을 수 없습니다.";
       responseErrorHtml(reply, 404, errorMessage);
       logger.warn(`[404] ${errorMessage} (${targetFilePath})`);
     } else {
-      const errorMessage = "An error occurred while sending the file.";
+      const errorMessage = "파일 전송 중 에러가 발생했습니다.";
       responseErrorHtml(reply, 500, errorMessage);
       logger.error(`[500] ${errorMessage}`, err);
     }

package/src/transport/http/upload-handler.ts

@@ -17,24 +17,24 @@ export async function handleUpload(
   jwtSecret: string | undefined,
 ): Promise<void> {
   if (!req.isMultipart()) {
-    reply.status(400).send("Multipart request expected");
+    reply.status(400).send("Multipart 요청이 필요합니다");
     return;
   }
 
-  // Auth check
+  // 인증 확인
   try {
     const authHeader = req.headers.authorization;
     if (authHeader == null) {
-      throw new Error("Authentication token is missing.");
+      throw new Error("인증 토큰이 누락되었습니다.");
     }
     if (jwtSecret == null) {
-      throw new Error("JWT Secret is not defined.");
+      throw new Error("JWT Secret이 정의되지 않았습니다.");
     }
     const token = authHeader.split(" ")[1];
     await verifyJwt(jwtSecret, token);
   } catch (err) {
     reply.status(401).send({
-      error: "Unauthorized",
+      error: "인증 실패",
       message: err instanceof Error ? err.message : String(err),
     });
     return;
@@ -58,7 +58,7 @@ export async function handleUpload(
         await pipeline(part.file, createWriteStream(currentSavePath));
 
         if (part.file.truncated) {
-          throw new Error(`File limit exceeded: ${originalFilename}`);
+          throw new Error(`파일 크기 제한 초과: ${originalFilename}`);
         }
 
         const stats = await fsx.stat(currentSavePath);
@@ -75,13 +75,20 @@ export async function handleUpload(
 
     reply.send(result);
   } catch (err) {
-    logger.error("Upload Error", err);
+    logger.error("업로드 에러", err);
 
     if (currentSavePath != null) {
       await fsx.rm(currentSavePath).catch(() => {});
-      logger.warn(`Incomplete file deleted: ${currentSavePath}`);
+      logger.warn(`불완전한 파일 삭제됨: ${currentSavePath}`);
     }
 
-    reply.code(500).send("Upload Failed");
+    // 이미 저장된 파일 정리
+    for (const savedFile of result) {
+      const savedPath = path.resolve(rootPath, "www", savedFile.path);
+      await fsx.rm(savedPath).catch(() => {});
+      logger.warn(`이미 저장된 파일 삭제됨: ${savedPath}`);
+    }
+
+    reply.code(500).send("업로드 실패");
   }
 }

package/src/transport/socket/service-socket.ts

@@ -15,10 +15,10 @@ import type {
 const logger = consola.withTag("service-server:ServiceSocket");
 
 /**
- * Service socket interface
+ * 서비스 소켓 인터페이스
  *
- * Manages a single WebSocket connection with protocol encoding/decoding,
- * ping/pong keep-alive, and event listener tracking.
+ * 프로토콜 인코딩/디코딩, ping/pong 연결 유지,
+ * 이벤트 리스너 추적이 포함된 단일 WebSocket 연결을 관리한다.
  */
 export interface ServiceSocket {
   readonly connectedAtDateTime: DateTime;
@@ -27,37 +27,37 @@ export interface ServiceSocket {
   authTokenPayload?: AuthTokenPayload;
 
   /**
-   * Close the WebSocket connection
+   * WebSocket 연결을 닫는다
    */
   close(): void;
 
   /**
-   * Send a message to the client
+   * 클라이언트에 메시지를 전송한다
    */
   send(uuid: string, msg: ServiceServerMessage): Promise<number>;
 
   /**
-   * Register an event listener with key/name/info
+   * key/name/info로 이벤트 리스너를 등록한다
    */
   addListener(key: string, eventName: string, info: unknown): void;
 
   /**
-   * Remove an event listener by key
+   * key로 이벤트 리스너를 제거한다
    */
   removeListener(key: string): void;
 
   /**
-   * Get all event listeners for a specific event name
+   * 특정 이벤트 이름에 해당하는 모든 이벤트 리스너를 조회한다
    */
   getEventListeners(eventName: string): Array<{ key: string; info: unknown }>;
 
   /**
-   * Filter target keys that exist in this socket's listeners
+   * 이 소켓의 리스너에 존재하는 대상 키를 필터링한다
    */
   filterEventTargetKeys(targetKeys: string[]): string[];
 
   /**
-   * Register event handlers
+   * 이벤트 핸들러를 등록한다
    */
   on(event: "error", handler: (err: Error) => void): void;
   on(event: "close", handler: (code: number) => void): void;
@@ -65,10 +65,10 @@ export interface ServiceSocket {
 }
 
 /**
- * Create a service socket instance
+ * 서비스 소켓 인스턴스를 생성한다
  *
- * Manages a single WebSocket connection with protocol encoding/decoding,
- * ping/pong keep-alive, and event listener tracking.
+ * 프로토콜 인코딩/디코딩, ping/pong 연결 유지,
+ * 이벤트 리스너 추적이 포함된 단일 WebSocket 연결을 관리한다.
  */
 export function createServiceSocket(
   socket: WebSocket,
@@ -77,10 +77,10 @@ export function createServiceSocket(
   connReq: FastifyRequest,
 ): ServiceSocket {
   // -------------------------------------------------------------------
-  // State
+  // 상태
   // -------------------------------------------------------------------
 
-  const PING_INTERVAL = 5000; // Send ping every 5s
+  const PING_INTERVAL = 5000; // 5초마다 ping 전송
   const PONG_PACKET = new Uint8Array([0x02]);
 
   const protocol = createServerProtocolWrapper();
@@ -97,7 +97,7 @@ export function createServiceSocket(
   const connectedAtDateTime = new DateTime();
 
   // -------------------------------------------------------------------
-  // Helpers
+  // 헬퍼
   // -------------------------------------------------------------------
 
   async function sendInternal(uuid: string, msg: ServiceServerRawMessage): Promise<number> {
@@ -121,11 +121,11 @@ export function createServiceSocket(
   }
 
   // -------------------------------------------------------------------
-  // Event Handlers
+  // 이벤트 핸들러
   // -------------------------------------------------------------------
 
   function onError(err: Error): void {
-    logger.error("WebSocket client error", err);
+    logger.error("WebSocket 클라이언트 에러", err);
     emitEvent("error", err);
   }
 
@@ -137,7 +137,7 @@ export function createServiceSocket(
 
   async function onMessage(msgBuffer: Bytes): Promise<void> {
     try {
-      // Handle pong response to ping
+      // ping에 대한 pong 응답 처리
       if (msgBuffer.length === 1 && msgBuffer[0] === 0x01) {
         if (socket.readyState === WebSocket.OPEN) {
           socket.send(PONG_PACKET);
@@ -159,12 +159,12 @@ export function createServiceSocket(
         emitEvent("message", { uuid: decodeResult.uuid, msg });
       }
     } catch (err) {
-      logger.error("Error processing WebSocket message", err);
+      logger.error("WebSocket 메시지 처리 중 에러 발생", err);
     }
   }
 
   // -------------------------------------------------------------------
-  // Setup
+  // 설정
   // -------------------------------------------------------------------
 
   socket.on("close", onClose);
@@ -186,7 +186,7 @@ export function createServiceSocket(
   }, PING_INTERVAL);
 
   // -------------------------------------------------------------------
-  // Public API
+  // 공개 API
   // -------------------------------------------------------------------
 
   return {

package/src/transport/socket/websocket-handler.ts

@@ -1,5 +1,5 @@
 import type { WebSocket } from "ws";
-import { Uuid } from "@simplysm/core-common";
+import { Uuid, env } from "@simplysm/core-common";
 import type { ServiceEventDef, ServiceClientMessage } from "@simplysm/service-common";
 import { createServiceSocket, type ServiceSocket } from "./service-socket";
 import { verifyJwt } from "../../auth/jwt-manager";
@@ -9,29 +9,29 @@ import consola from "consola";
 const logger = consola.withTag("service-server:WebSocketHandler");
 
 /**
- * WebSocket handler interface
+ * WebSocket 핸들러 인터페이스
  *
- * Manages multiple WebSocket connections, routes messages to services,
- * and handles event broadcasting.
+ * 여러 WebSocket 연결을 관리하고, 메시지를 서비스로 라우팅하며,
+ * 이벤트 브로드캐스팅을 처리한다.
  */
 export interface WebSocketHandler {
   /**
-   * Add a new WebSocket connection
+   * 새 WebSocket 연결을 추가한다
    */
   addSocket(socket: WebSocket, clientId: string, clientName: string, connReq: FastifyRequest): void;
 
   /**
-   * Close all active connections
+   * 모든 활성 연결을 닫는다
    */
   closeAll(): void;
 
   /**
-   * Broadcast reload message to all clients
+   * 모든 클라이언트에 리로드 메시지를 브로드캐스트한다
    */
   broadcastReload(clientName: string | undefined, changedFileSet: Set<string>): Promise<void>;
 
   /**
-   * Emit event to matching clients
+   * 매칭되는 클라이언트에 이벤트를 발생시킨다
    */
   emit<TInfo, TData>(
     eventDef: ServiceEventDef<TInfo, TData>,
@@ -41,10 +41,10 @@ export interface WebSocketHandler {
 }
 
 /**
- * Create a WebSocket handler instance
+ * WebSocket 핸들러 인스턴스를 생성한다
  *
- * Manages multiple WebSocket connections, routes messages to services,
- * and handles event broadcasting.
+ * 여러 WebSocket 연결을 관리하고, 메시지를 서비스로 라우팅하며,
+ * 이벤트 브로드캐스팅을 처리한다.
  */
 export function createWebSocketHandler(
   runMethod: (def: {
@@ -56,13 +56,13 @@ export function createWebSocketHandler(
   jwtSecret: string | undefined,
 ): WebSocketHandler {
   // -------------------------------------------------------------------
-  // State
+  // 상태
   // -------------------------------------------------------------------
 
   const socketMap = new Map<string, ServiceSocket>();
 
   // -------------------------------------------------------------------
-  // Helpers
+  // 헬퍼
   // -------------------------------------------------------------------
 
   async function processRequest(
@@ -72,7 +72,9 @@ export function createWebSocketHandler(
   ): Promise<number> {
     try {
       if (message.name.includes(".") && Array.isArray(message.body)) {
-        const [serviceName, methodName] = message.name.split(".");
+        const dotIndex = message.name.indexOf(".");
+        const serviceName = message.name.substring(0, dotIndex);
+        const methodName = message.name.substring(dotIndex + 1);
 
         const result = await runMethod({
           serviceName,
@@ -99,35 +101,34 @@ export function createWebSocketHandler(
       } else if (message.name === "evt:emit") {
         const { keys, data } = message.body as { keys: string[]; data: unknown };
 
-        for (const subSock of socketMap.values()) {
-          const targetKeys = subSock.filterEventTargetKeys(keys);
-          if (targetKeys.length > 0) {
-            await subSock.send(uuid, {
-              name: "evt:on",
-              body: {
-                keys: targetKeys,
-                data,
-              },
-            });
-          }
-        }
+        await Promise.allSettled(
+          Array.from(socketMap.values()).map(async (subSock) => {
+            const targetKeys = subSock.filterEventTargetKeys(keys);
+            if (targetKeys.length > 0) {
+              await subSock.send(uuid, {
+                name: "evt:on",
+                body: { keys: targetKeys, data },
+              });
+            }
+          }),
+        );
 
         return await serviceSocket.send(uuid, { name: "response" });
       } else if (message.name === "auth") {
-        if (jwtSecret == null) throw new Error("JWT Secret is not defined.");
+        if (jwtSecret == null) throw new Error("JWT Secret이 정의되지 않았습니다.");
 
         const token = message.body;
         serviceSocket.authTokenPayload = await verifyJwt(jwtSecret, token);
         return await serviceSocket.send(uuid, { name: "response" });
       } else {
-        const err = new Error("Invalid request.");
+        const err = new Error("유효하지 않은 요청입니다.");
 
         return await serviceSocket.send(uuid, {
           name: "error",
           body: {
             name: err.name,
             message: err.message,
-            stack: err.stack,
+            ...(env.DEV ? { stack: err.stack } : {}),
             code: "BAD_MESSAGE",
           },
         });
@@ -136,7 +137,7 @@ export function createWebSocketHandler(
       const error =
         err instanceof Error
           ? err
-          : new Error(typeof err === "string" ? err : "An unknown error has occurred.");
+          : new Error(typeof err === "string" ? err : "알 수 없는 에러가 발생했습니다.");
 
       return serviceSocket.send(uuid, {
         name: "error",
@@ -144,14 +145,14 @@ export function createWebSocketHandler(
           name: error.name,
           message: error.message,
           code: "INTERNAL_ERROR",
-          stack: error.stack,
+          ...(env.DEV ? { stack: error.stack } : {}),
         },
       });
     }
   }
 
   // -------------------------------------------------------------------
-  // Public API
+  // 공개 API
   // -------------------------------------------------------------------
 
   return {
@@ -164,7 +165,7 @@ export function createWebSocketHandler(
       try {
         const serviceSocket = createServiceSocket(socket, clientId, clientName, connReq);
 
-        // Disconnect existing connection
+        // 기존 연결 해제
         const prevServiceSocket = socketMap.get(clientId);
         if (prevServiceSocket != null) {
           prevServiceSocket.close();
@@ -172,32 +173,32 @@ export function createWebSocketHandler(
           const connectionDateTimeText =
             prevServiceSocket.connectedAtDateTime.toFormatString("yyyy:MM:dd HH:mm:ss.fff");
           logger.debug(
-            `Disconnected previous client connection: ${clientId}: ${connectionDateTimeText}`,
+            `이전 클라이언트 연결 해제됨: ${clientId}: ${connectionDateTimeText}`,
           );
         }
 
         socketMap.set(clientId, serviceSocket);
 
         serviceSocket.on("close", (code) => {
-          logger.debug(`Client disconnected: (code: ${code})`);
+          logger.debug(`클라이언트 연결 해제됨: (code: ${code})`);
 
           if (socketMap.get(clientId) !== serviceSocket) return;
           socketMap.delete(clientId);
         });
 
         serviceSocket.on("message", async ({ uuid, msg }) => {
-          logger.debug("Request received", msg);
+          logger.debug("요청 수신됨", msg);
           const sentSize = await processRequest(serviceSocket, uuid, msg);
-          logger.debug(`Response sent (size: ${sentSize})`);
+          logger.debug(`응답 전송됨 (크기: ${sentSize})`);
         });
 
-        logger.debug("Client connected", {
+        logger.debug("클라이언트 연결됨", {
           clientId,
           remoteAddress: connReq.socket.remoteAddress,
           socketSize: socketMap.size,
         });
       } catch (err) {
-        logger.error("Error handling connection", err);
+        logger.error("연결 처리 중 에러 발생", err);
         socket.terminate();
       }
     },
@@ -212,15 +213,14 @@ export function createWebSocketHandler(
       clientName: string | undefined,
       changedFileSet: Set<string>,
     ): Promise<void> {
-      for (const serviceSocket of socketMap.values()) {
-        await serviceSocket.send(Uuid.generate().toString(), {
-          name: "reload",
-          body: {
-            clientName,
-            changedFileSet,
-          },
-        });
-      }
+      await Promise.allSettled(
+        Array.from(socketMap.values()).map((serviceSocket) =>
+          serviceSocket.send(Uuid.generate().toString(), {
+            name: "reload",
+            body: { clientName, changedFileSet },
+          }),
+        ),
+      );
     },
 
     async emit<TInfo, TData>(
@@ -234,18 +234,17 @@ export function createWebSocketHandler(
         .filter((item) => infoSelector(item.info as TInfo))
         .map((item) => item.key);
 
-      for (const subSock of socketMap.values()) {
-        const subTargetKeys = subSock.filterEventTargetKeys(targetKeys);
-        if (subTargetKeys.length > 0) {
-          await subSock.send(Uuid.generate().toString(), {
-            name: "evt:on",
-            body: {
-              keys: subTargetKeys,
-              data,
-            },
-          });
-        }
-      }
+      await Promise.allSettled(
+        Array.from(socketMap.values()).map(async (subSock) => {
+          const subTargetKeys = subSock.filterEventTargetKeys(targetKeys);
+          if (subTargetKeys.length > 0) {
+            await subSock.send(Uuid.generate().toString(), {
+              name: "evt:on",
+              body: { keys: subTargetKeys, data },
+            });
+          }
+        }),
+      );
     },
   };
 }

package/src/types/server-options.ts

@@ -9,6 +9,6 @@ export interface ServiceServerOptions {
   };
   auth?: {
     jwtSecret: string;
-  };
+  } | false;
   services: ServiceDefinition[];
 }