@esengine/server 4.2.0 → 4.4.0

package/dist/{chunk-BIAOJF7P.js → chunk-M7VONMZJ.js}

@@ -1,3 +1,4 @@
+import { createLogger } from './chunk-I4QQSQ72.js';
 import { __name, __publicField } from './chunk-T626JPC7.js';
 import * as path from 'path';
 import { createServer as createServer$1 } from 'http';
@@ -7,7 +8,66 @@ import * as fs from 'fs';
 import { pathToFileURL } from 'url';
 
 // src/http/router.ts
-async function createRequest(req) {
+var logger = createLogger("HTTP");
+function parseRoutePath(path3) {
+  const paramNames = [];
+  const isStatic = !path3.includes(":");
+  if (isStatic) {
+    return {
+      pattern: new RegExp(`^${escapeRegex(path3)}$`),
+      paramNames,
+      isStatic: true
+    };
+  }
+  const segments = path3.split("/").map((segment) => {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1);
+      paramNames.push(paramName);
+      return "([^/]+)";
+    }
+    return escapeRegex(segment);
+  });
+  return {
+    pattern: new RegExp(`^${segments.join("/")}$`),
+    paramNames,
+    isStatic: false
+  };
+}
+__name(parseRoutePath, "parseRoutePath");
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegex, "escapeRegex");
+function matchRoute(routes, path3, method) {
+  for (const route of routes) {
+    if (!route.isStatic) continue;
+    if (route.method !== "*" && route.method !== method) continue;
+    if (route.pattern.test(path3)) {
+      return {
+        route,
+        params: {}
+      };
+    }
+  }
+  for (const route of routes) {
+    if (route.isStatic) continue;
+    if (route.method !== "*" && route.method !== method) continue;
+    const match = path3.match(route.pattern);
+    if (match) {
+      const params = {};
+      route.paramNames.forEach((name, index) => {
+        params[name] = decodeURIComponent(match[index + 1]);
+      });
+      return {
+        route,
+        params
+      };
+    }
+  }
+  return null;
+}
+__name(matchRoute, "matchRoute");
+async function createRequest(req, params = {}) {
   const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
   const query = {};
   url.searchParams.forEach((value, key) => {
@@ -22,6 +82,7 @@ async function createRequest(req) {
     raw: req,
     method: req.method ?? "GET",
     path: url.pathname,
+    params,
     query,
     headers: req.headers,
     body,
@@ -67,6 +128,7 @@ function parseBody(req) {
 __name(parseBody, "parseBody");
 function createResponse(res) {
   let statusCode = 200;
+  let ended = false;
   const response = {
     raw: res,
     status(code) {
@@ -74,20 +136,28 @@ function createResponse(res) {
       return response;
     },
     header(name, value) {
-      res.setHeader(name, value);
+      if (!ended) {
+        res.setHeader(name, value);
+      }
       return response;
     },
     json(data) {
+      if (ended) return;
+      ended = true;
       res.setHeader("Content-Type", "application/json; charset=utf-8");
       res.statusCode = statusCode;
       res.end(JSON.stringify(data));
     },
     text(data) {
+      if (ended) return;
+      ended = true;
       res.setHeader("Content-Type", "text/plain; charset=utf-8");
       res.statusCode = statusCode;
       res.end(data);
     },
     error(code, message) {
+      if (ended) return;
+      ended = true;
       res.setHeader("Content-Type", "application/json; charset=utf-8");
       res.statusCode = code;
       res.end(JSON.stringify({
@@ -98,58 +168,170 @@ function createResponse(res) {
   return response;
 }
 __name(createResponse, "createResponse");
+function createOriginWhitelist(origins) {
+  const whitelist = {};
+  for (const origin of origins) {
+    whitelist[origin] = true;
+  }
+  return whitelist;
+}
+__name(createOriginWhitelist, "createOriginWhitelist");
 function applyCors(res, req, cors) {
-  const origin = req.headers.origin;
-  if (cors.origin === true || cors.origin === "*") {
-    res.setHeader("Access-Control-Allow-Origin", origin ?? "*");
-  } else if (typeof cors.origin === "string") {
+  const credentials = cors.credentials ?? false;
+  if (typeof cors.origin === "string" && cors.origin !== "*") {
     res.setHeader("Access-Control-Allow-Origin", cors.origin);
-  } else if (Array.isArray(cors.origin) && origin && cors.origin.includes(origin)) {
-    res.setHeader("Access-Control-Allow-Origin", origin);
-  }
-  if (cors.methods) {
-    res.setHeader("Access-Control-Allow-Methods", cors.methods.join(", "));
-  } else {
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
-  }
-  if (cors.allowedHeaders) {
-    res.setHeader("Access-Control-Allow-Headers", cors.allowedHeaders.join(", "));
-  } else {
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
-  }
-  if (cors.credentials) {
-    res.setHeader("Access-Control-Allow-Credentials", "true");
+    if (credentials) {
+      res.setHeader("Access-Control-Allow-Credentials", "true");
+    }
+  } else if (Array.isArray(cors.origin)) {
+    const requestOrigin = req.headers.origin;
+    if (typeof requestOrigin === "string") {
+      const whitelist = createOriginWhitelist(cors.origin);
+      if (requestOrigin in whitelist) {
+        res.setHeader("Access-Control-Allow-Origin", requestOrigin);
+        if (credentials) {
+          res.setHeader("Access-Control-Allow-Credentials", "true");
+        }
+      }
+    }
+  } else if (!credentials) {
+    if (cors.origin === "*" || cors.origin === true) {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+    }
   }
+  res.setHeader("Access-Control-Allow-Methods", cors.methods?.join(", ") ?? "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", cors.allowedHeaders?.join(", ") ?? "Content-Type, Authorization");
   if (cors.maxAge) {
     res.setHeader("Access-Control-Max-Age", String(cors.maxAge));
   }
 }
 __name(applyCors, "applyCors");
-function createHttpRouter(routes, cors) {
+async function executeMiddlewares(middlewares, req, res, finalHandler) {
+  let index = 0;
+  const next = /* @__PURE__ */ __name(async () => {
+    if (index < middlewares.length) {
+      const middleware = middlewares[index++];
+      await middleware(req, res, next);
+    } else {
+      await finalHandler();
+    }
+  }, "next");
+  await next();
+}
+__name(executeMiddlewares, "executeMiddlewares");
+async function executeWithTimeout(handler, timeoutMs, res) {
+  let resolved = false;
+  const timeoutPromise = new Promise((_, reject) => {
+    setTimeout(() => {
+      if (!resolved) {
+        reject(new Error("Request timeout"));
+      }
+    }, timeoutMs);
+  });
+  try {
+    await Promise.race([
+      handler().then(() => {
+        resolved = true;
+      }),
+      timeoutPromise
+    ]);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Request timeout") {
+      if (!res.writableEnded) {
+        res.statusCode = 408;
+        res.setHeader("Content-Type", "application/json; charset=utf-8");
+        res.end(JSON.stringify({
+          error: "Request Timeout"
+        }));
+      }
+    } else {
+      throw error;
+    }
+  }
+}
+__name(executeWithTimeout, "executeWithTimeout");
+function isHandlerDefinition(value) {
+  return typeof value === "object" && value !== null && "handler" in value && typeof value.handler === "function";
+}
+__name(isHandlerDefinition, "isHandlerDefinition");
+function isRouteMethods(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const methods = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS"
+  ];
+  return Object.keys(value).some((key) => methods.includes(key));
+}
+__name(isRouteMethods, "isRouteMethods");
+function extractHandler(methodHandler) {
+  if (isHandlerDefinition(methodHandler)) {
+    return {
+      handler: methodHandler.handler,
+      middlewares: methodHandler.middlewares ?? [],
+      timeout: methodHandler.timeout
+    };
+  }
+  return {
+    handler: methodHandler,
+    middlewares: [],
+    timeout: void 0
+  };
+}
+__name(extractHandler, "extractHandler");
+function createHttpRouter(routes, options = {}) {
+  const globalMiddlewares = options.middlewares ?? [];
+  const globalTimeout = options.timeout;
   const parsedRoutes = [];
   for (const [path3, handlerOrMethods] of Object.entries(routes)) {
+    const { pattern, paramNames, isStatic } = parseRoutePath(path3);
     if (typeof handlerOrMethods === "function") {
       parsedRoutes.push({
         method: "*",
         path: path3,
-        handler: handlerOrMethods
+        handler: handlerOrMethods,
+        pattern,
+        paramNames,
+        middlewares: [],
+        timeout: void 0,
+        isStatic
       });
-    } else {
-      for (const [method, handler] of Object.entries(handlerOrMethods)) {
-        if (handler !== void 0) {
+    } else if (isRouteMethods(handlerOrMethods)) {
+      for (const [method, methodHandler] of Object.entries(handlerOrMethods)) {
+        if (methodHandler !== void 0) {
+          const { handler, middlewares, timeout } = extractHandler(methodHandler);
           parsedRoutes.push({
             method,
             path: path3,
-            handler
+            handler,
+            pattern,
+            paramNames,
+            middlewares,
+            timeout,
+            isStatic
           });
         }
       }
+    } else if (isHandlerDefinition(handlerOrMethods)) {
+      const { handler, middlewares, timeout } = extractHandler(handlerOrMethods);
+      parsedRoutes.push({
+        method: "*",
+        path: path3,
+        handler,
+        pattern,
+        paramNames,
+        middlewares,
+        timeout,
+        isStatic
+      });
     }
   }
-  const corsOptions = cors === true ? {
-    origin: true,
-    credentials: true
-  } : cors === false ? null : cors ?? null;
+  const corsOptions = options.cors === true ? {
+    origin: "*"
+  } : options.cors === false ? null : options.cors ?? null;
   return /* @__PURE__ */ __name(async function handleRequest(req, res) {
     const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
     const path3 = url.pathname;
@@ -162,27 +344,50 @@ function createHttpRouter(routes, cors) {
         return true;
       }
     }
-    const route = parsedRoutes.find((r) => r.path === path3 && (r.method === "*" || r.method === method));
-    if (!route) {
+    const match = matchRoute(parsedRoutes, path3, method);
+    if (!match) {
       return false;
     }
+    const { route, params } = match;
     try {
-      const httpReq = await createRequest(req);
+      const httpReq = await createRequest(req, params);
       const httpRes = createResponse(res);
-      await route.handler(httpReq, httpRes);
+      const allMiddlewares = [
+        ...globalMiddlewares,
+        ...route.middlewares
+      ];
+      const timeout = route.timeout ?? globalTimeout;
+      const finalHandler = /* @__PURE__ */ __name(async () => {
+        await route.handler(httpReq, httpRes);
+      }, "finalHandler");
+      const executeHandler = /* @__PURE__ */ __name(async () => {
+        if (allMiddlewares.length > 0) {
+          await executeMiddlewares(allMiddlewares, httpReq, httpRes, finalHandler);
+        } else {
+          await finalHandler();
+        }
+      }, "executeHandler");
+      if (timeout && timeout > 0) {
+        await executeWithTimeout(executeHandler, timeout, res);
+      } else {
+        await executeHandler();
+      }
       return true;
     } catch (error) {
-      console.error("[HTTP] Route handler error:", error);
-      res.statusCode = 500;
-      res.setHeader("Content-Type", "application/json");
-      res.end(JSON.stringify({
-        error: "Internal Server Error"
-      }));
+      logger.error("Route handler error:", error);
+      if (!res.writableEnded) {
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({
+          error: "Internal Server Error"
+        }));
+      }
       return true;
     }
   }, "handleRequest");
 }
 __name(createHttpRouter, "createHttpRouter");
+var logger2 = createLogger("Server");
 function fileNameToHandlerName(fileName) {
   const baseName = fileName.replace(/\.(ts|js|mts|mjs)$/, "");
   return baseName.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
@@ -224,7 +429,7 @@ async function loadApiHandlers(apiDir) {
         });
       }
     } catch (err) {
-      console.warn(`[Server] Failed to load API handler: ${filePath}`, err);
+      logger2.warn(`Failed to load API handler: ${filePath}`, err);
     }
   }
   return handlers;
@@ -247,7 +452,7 @@ async function loadMsgHandlers(msgDir) {
         });
       }
     } catch (err) {
-      console.warn(`[Server] Failed to load msg handler: ${filePath}`, err);
+      logger2.warn(`Failed to load msg handler: ${filePath}`, err);
     }
   }
   return handlers;
@@ -280,7 +485,7 @@ function scanDirectoryRecursive(dir, baseDir = dir) {
 }
 __name(scanDirectoryRecursive, "scanDirectoryRecursive");
 function filePathToRoute(relativePath, prefix) {
-  let route = relativePath.replace(/\.(ts|js|mts|mjs)$/, "").replace(/\\/g, "/").replace(/\[([^\]]+)\]/g, ":$1");
+  let route = relativePath.replace(/\.(ts|js|mts|mjs)$/, "").replace(/\\/g, "/").replace(/\[(\w+)\]/g, ":$1");
   if (!route.startsWith("/")) {
     route = "/" + route;
   }
@@ -307,7 +512,7 @@ async function loadHttpHandlers(httpDir, prefix = "/api") {
         });
       }
     } catch (err) {
-      console.warn(`[Server] Failed to load HTTP handler: ${filePath}`, err);
+      logger2.warn(`Failed to load HTTP handler: ${filePath}`, err);
     }
   }
   return handlers;
@@ -315,6 +520,7 @@ async function loadHttpHandlers(httpDir, prefix = "/api") {
 __name(loadHttpHandlers, "loadHttpHandlers");
 
 // src/room/RoomManager.ts
+var logger3 = createLogger("Room");
 var _RoomManager = class _RoomManager {
   constructor(sendFn) {
     __publicField(this, "_definitions", /* @__PURE__ */ new Map());
@@ -340,7 +546,7 @@ var _RoomManager = class _RoomManager {
   async create(name, options) {
     const def = this._definitions.get(name);
     if (!def) {
-      console.warn(`[RoomManager] Room type not found: ${name}`);
+      logger3.warn(`Room type not found: ${name}`);
       return null;
     }
     const roomId = this._generateRoomId();
@@ -359,7 +565,7 @@ var _RoomManager = class _RoomManager {
     });
     this._rooms.set(roomId, room);
     await room._create(options);
-    console.log(`[Room] Created: ${name} (${roomId})`);
+    logger3.info(`Created: ${name} (${roomId})`);
     return room;
   }
   /**
@@ -375,7 +581,7 @@ var _RoomManager = class _RoomManager {
     const player = await room._addPlayer(playerId, conn);
     if (!player) return null;
     this._playerToRoom.set(playerId, room.id);
-    console.log(`[Room] Player ${playerId} joined ${room.id}`);
+    logger3.info(`Player ${playerId} joined ${room.id}`);
     return {
       room,
       player
@@ -391,7 +597,7 @@ var _RoomManager = class _RoomManager {
     const player = await room._addPlayer(playerId, conn);
     if (!player) return null;
     this._playerToRoom.set(playerId, room.id);
-    console.log(`[Room] Player ${playerId} joined ${room.id}`);
+    logger3.info(`Player ${playerId} joined ${room.id}`);
     return {
       room,
       player
@@ -409,7 +615,7 @@ var _RoomManager = class _RoomManager {
       await room._removePlayer(playerId, reason);
     }
     this._playerToRoom.delete(playerId);
-    console.log(`[Room] Player ${playerId} left ${roomId}`);
+    logger3.info(`Player ${playerId} left ${roomId}`);
   }
   /**
    * @zh 处理消息
@@ -486,19 +692,20 @@ async function createServer(config = {}) {
     ...config
   };
   const cwd = process.cwd();
+  const logger4 = createLogger("Server");
   const apiHandlers = await loadApiHandlers(path.resolve(cwd, opts.apiDir));
   const msgHandlers = await loadMsgHandlers(path.resolve(cwd, opts.msgDir));
   const httpDir = config.httpDir ?? opts.httpDir;
   const httpPrefix = config.httpPrefix ?? opts.httpPrefix;
   const httpHandlers = await loadHttpHandlers(path.resolve(cwd, httpDir), httpPrefix);
   if (apiHandlers.length > 0) {
-    console.log(`[Server] Loaded ${apiHandlers.length} API handlers`);
+    logger4.info(`Loaded ${apiHandlers.length} API handlers`);
   }
   if (msgHandlers.length > 0) {
-    console.log(`[Server] Loaded ${msgHandlers.length} message handlers`);
+    logger4.info(`Loaded ${msgHandlers.length} message handlers`);
   }
   if (httpHandlers.length > 0) {
-    console.log(`[Server] Loaded ${httpHandlers.length} HTTP handlers`);
+    logger4.info(`Loaded ${httpHandlers.length} HTTP handlers`);
   }
   const mergedHttpRoutes = {};
   for (const handler of httpHandlers) {
@@ -636,7 +843,9 @@ async function createServer(config = {}) {
         };
       }
       if (hasHttpRoutes) {
-        const httpRouter = createHttpRouter(mergedHttpRoutes, config.cors ?? true);
+        const httpRouter = createHttpRouter(mergedHttpRoutes, {
+          cors: config.cors ?? true
+        });
         httpServer = createServer$1(async (req, res) => {
           const handled = await httpRouter(req, res);
           if (!handled) {
@@ -651,7 +860,7 @@ async function createServer(config = {}) {
           server: httpServer,
           createConnData: /* @__PURE__ */ __name(() => ({}), "createConnData"),
           onStart: /* @__PURE__ */ __name(() => {
-            console.log(`[Server] Started on http://localhost:${opts.port}`);
+            logger4.info(`Started on http://localhost:${opts.port}`);
             opts.onStart?.(opts.port);
           }, "onStart"),
           onConnect: /* @__PURE__ */ __name(async (conn) => {
@@ -673,7 +882,7 @@ async function createServer(config = {}) {
           port: opts.port,
           createConnData: /* @__PURE__ */ __name(() => ({}), "createConnData"),
           onStart: /* @__PURE__ */ __name((p) => {
-            console.log(`[Server] Started on ws://localhost:${p}`);
+            logger4.info(`Started on ws://localhost:${p}`);
             opts.onStart?.(p);
           }, "onStart"),
           onConnect: /* @__PURE__ */ __name(async (conn) => {
@@ -725,5 +934,5 @@ async function createServer(config = {}) {
 __name(createServer, "createServer");
 
 export { createHttpRouter, createServer };
-//# sourceMappingURL=chunk-BIAOJF7P.js.map
-//# sourceMappingURL=chunk-BIAOJF7P.js.map
+//# sourceMappingURL=chunk-M7VONMZJ.js.map
+//# sourceMappingURL=chunk-M7VONMZJ.js.map