@signe/room 2.0.0 → 2.1.0

package/dist/index.js

@@ -326,6 +326,260 @@ function response(status, body) {
 }
 __name(response, "response");
 
+// src/request/response.ts
+var ServerResponse = class {
+  static {
+    __name(this, "ServerResponse");
+  }
+  interceptors;
+  statusCode = 200;
+  responseBody = {};
+  responseHeaders = {
+    "Content-Type": "application/json"
+  };
+  /**
+   * Creates a new ServerResponse instance
+   * @param interceptors Array of interceptor functions that can modify the response
+   */
+  constructor(interceptors = []) {
+    this.interceptors = interceptors;
+  }
+  /**
+   * Sets the status code for the response
+   * @param code HTTP status code
+   * @returns this instance for chaining
+   */
+  status(code) {
+    this.statusCode = code;
+    return this;
+  }
+  /**
+   * Sets the response body and returns this instance (chainable method)
+   * 
+   * @param body Response body
+   * @returns this instance for chaining
+   */
+  body(body) {
+    this.responseBody = body;
+    return this;
+  }
+  /**
+   * Adds a header to the response
+   * @param name Header name
+   * @param value Header value
+   * @returns this instance for chaining
+   */
+  header(name, value) {
+    this.responseHeaders[name] = value;
+    return this;
+  }
+  /**
+   * Adds multiple headers to the response
+   * @param headers Object containing headers
+   * @returns this instance for chaining
+   */
+  setHeaders(headers) {
+    this.responseHeaders = {
+      ...this.responseHeaders,
+      ...headers
+    };
+    return this;
+  }
+  /**
+   * Add an interceptor to the chain
+   * @param interceptor Function that takes a Response and returns a modified Response
+   * @returns this instance for chaining
+   */
+  use(interceptor) {
+    this.interceptors.push(interceptor);
+    return this;
+  }
+  /**
+   * Builds and returns the Response object after applying all interceptors
+   * @returns Promise<Response> The final Response object
+   * @private Internal method used by terminal methods
+   */
+  async buildResponse() {
+    let response2 = new Response(JSON.stringify(this.responseBody), {
+      status: this.statusCode,
+      headers: this.responseHeaders
+    });
+    for (const interceptor of this.interceptors) {
+      try {
+        const interceptedResponse = interceptor(response2);
+        if (interceptedResponse instanceof Promise) {
+          response2 = await interceptedResponse;
+        } else {
+          response2 = interceptedResponse;
+        }
+      } catch (error) {
+        console.error("Error in interceptor:", error);
+      }
+    }
+    return response2;
+  }
+  /**
+   * Sets the response body to the JSON-stringified version of the provided value
+   * and sends the response (terminal method)
+   * 
+   * @param body Response body to be JSON stringified
+   * @returns Promise<Response> The final Response object
+   */
+  async json(body) {
+    this.responseBody = body;
+    this.responseHeaders["Content-Type"] = "application/json";
+    return this.buildResponse();
+  }
+  /**
+   * Sends the response with the current configuration (terminal method)
+   * 
+   * @param body Optional body to set before sending
+   * @returns Promise<Response> The final Response object
+   */
+  async send(body) {
+    if (body !== void 0) {
+      this.responseBody = body;
+    }
+    return this.buildResponse();
+  }
+  /**
+   * Sends a plain text response (terminal method)
+   * 
+   * @param text Text to send
+   * @returns Promise<Response> The final Response object
+   */
+  async text(text) {
+    this.responseBody = text;
+    this.responseHeaders["Content-Type"] = "text/plain";
+    let response2 = new Response(text, {
+      status: this.statusCode,
+      headers: this.responseHeaders
+    });
+    for (const interceptor of this.interceptors) {
+      try {
+        const interceptedResponse = interceptor(response2);
+        if (interceptedResponse instanceof Promise) {
+          response2 = await interceptedResponse;
+        } else {
+          response2 = interceptedResponse;
+        }
+      } catch (error) {
+        console.error("Error in interceptor:", error);
+      }
+    }
+    return response2;
+  }
+  /**
+   * Redirects to the specified URL (terminal method)
+   * 
+   * @param url URL to redirect to
+   * @param statusCode HTTP status code (default: 302)
+   * @returns Promise<Response> The final Response object
+   */
+  async redirect(url, statusCode = 302) {
+    this.statusCode = statusCode;
+    this.responseHeaders["Location"] = url;
+    return this.buildResponse();
+  }
+  /**
+   * Creates a success response with status 200
+   * @param body Response body
+   * @returns Promise<Response> The final Response object
+   */
+  async success(body = {}) {
+    return this.status(200).json(body);
+  }
+  /**
+   * Creates an error response with status 400
+   * @param message Error message
+   * @param details Additional error details
+   * @returns Promise<Response> The final Response object
+   */
+  async badRequest(message, details = {}) {
+    return this.status(400).json({
+      error: message,
+      ...details
+    });
+  }
+  /**
+   * Creates an error response with status 403
+   * @param message Error message
+   * @returns Promise<Response> The final Response object
+   */
+  async notPermitted(message = "Not permitted") {
+    return this.status(403).json({
+      error: message
+    });
+  }
+  /**
+   * Creates an error response with status 401
+   * @param message Error message
+   * @returns Promise<Response> The final Response object
+   */
+  async unauthorized(message = "Unauthorized") {
+    return this.status(401).json({
+      error: message
+    });
+  }
+  /**
+   * Creates an error response with status 404
+   * @param message Error message
+   * @returns Promise<Response> The final Response object
+   */
+  async notFound(message = "Not found") {
+    return this.status(404).json({
+      error: message
+    });
+  }
+  /**
+   * Creates an error response with status 500
+   * @param message Error message
+   * @returns Promise<Response> The final Response object
+   */
+  async serverError(message = "Internal Server Error") {
+    return this.status(500).json({
+      error: message
+    });
+  }
+};
+
+// src/request/cors.ts
+function cors(res, options = {}) {
+  const newHeaders = new Headers(res.headers);
+  const requestOrigin = options.origin || "*";
+  newHeaders.set("Access-Control-Allow-Origin", requestOrigin);
+  if (options.credentials) {
+    newHeaders.set("Access-Control-Allow-Credentials", "true");
+  }
+  if (options.exposedHeaders && options.exposedHeaders.length) {
+    newHeaders.set("Access-Control-Expose-Headers", options.exposedHeaders.join(", "));
+  }
+  if (options.methods && options.methods.length) {
+    newHeaders.set("Access-Control-Allow-Methods", options.methods.join(", "));
+  } else {
+    newHeaders.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+  }
+  if (options.allowedHeaders && options.allowedHeaders.length) {
+    newHeaders.set("Access-Control-Allow-Headers", options.allowedHeaders.join(", "));
+  } else {
+    newHeaders.set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With");
+  }
+  if (options.maxAge) {
+    newHeaders.set("Access-Control-Max-Age", options.maxAge.toString());
+  } else {
+    newHeaders.set("Access-Control-Max-Age", "86400");
+  }
+  return new Response(res.body, {
+    status: res.status,
+    headers: newHeaders
+  });
+}
+__name(cors, "cors");
+function createCorsInterceptor(options = {}) {
+  return (res) => cors(res, options);
+}
+__name(createCorsInterceptor, "createCorsInterceptor");
+
 // src/server.ts
 var Message = z.object({
   action: z.string(),
@@ -727,6 +981,10 @@ var Server = class {
       return;
     }
     const subRoom = await this.getSubRoom();
+    if (!subRoom) {
+      console.warn("Room not found");
+      return;
+    }
     const roomGuards = subRoom.constructor["_roomGuards"] || [];
     for (const guard of roomGuards) {
       const isAuthorized = await guard(sender, result.data.value, this.room);
@@ -980,10 +1238,16 @@ var Server = class {
   async onRequest(req) {
     const isFromShard = req.headers.has("x-forwarded-by-shard");
     const shardId = req.headers.get("x-shard-id");
+    const res = new ServerResponse([
+      createCorsInterceptor()
+    ]);
+    if (req.method === "OPTIONS") {
+      return res.status(200).send({});
+    }
     if (isFromShard) {
-      return this.handleShardRequest(req, shardId);
+      return this.handleShardRequest(req, res, shardId);
     }
-    return this.handleDirectRequest(req);
+    return this.handleDirectRequest(req, res);
   }
   /**
   * @method handleDirectRequest
@@ -993,32 +1257,23 @@ var Server = class {
   * @description Processes requests received directly from clients
   * @returns {Promise<Response>} The response to return to the client
   */
-  async handleDirectRequest(req) {
+  async handleDirectRequest(req, res) {
     const subRoom = await this.getSubRoom();
-    const res = /* @__PURE__ */ __name((body, status) => {
-      return new Response(JSON.stringify(body), {
-        status
-      });
-    }, "res");
     if (!subRoom) {
-      return res({
-        error: "Not found"
-      }, 404);
+      return res.notFound();
     }
-    const response2 = await this.tryMatchRequestHandler(req, subRoom);
+    const response2 = await this.tryMatchRequestHandler(req, res, subRoom);
     if (response2) {
       return response2;
     }
-    const legacyResponse = await awaitReturn(subRoom["onRequest"]?.(req, this.room));
+    const legacyResponse = await awaitReturn(subRoom["onRequest"]?.(req, res));
     if (!legacyResponse) {
-      return res({
-        error: "Not found"
-      }, 404);
+      return res.notFound();
     }
     if (legacyResponse instanceof Response) {
       return legacyResponse;
     }
-    return res(legacyResponse, 200);
+    return res.success(legacyResponse);
   }
   /**
   * @method tryMatchRequestHandler
@@ -1029,7 +1284,7 @@ var Server = class {
   * @description Attempts to match the request to a registered @Request handler
   * @returns {Promise<Response | null>} The response or null if no handler matched
   */
-  async tryMatchRequestHandler(req, subRoom) {
+  async tryMatchRequestHandler(req, res, subRoom) {
     const requestHandlers = subRoom.constructor["_requestMetadata"];
     if (!requestHandlers) {
       return null;
@@ -1054,11 +1309,7 @@ var Server = class {
             return isAuthorized;
           }
           if (!isAuthorized) {
-            return new Response(JSON.stringify({
-              error: "Unauthorized"
-            }), {
-              status: 403
-            });
+            return res.notPermitted();
           }
         }
         let bodyData = null;
@@ -1073,41 +1324,27 @@ var Server = class {
               const body = await req.json();
               const validation = handler.bodyValidation.safeParse(body);
               if (!validation.success) {
-                return new Response(JSON.stringify({
-                  error: "Invalid request body",
+                return res.badRequest("Invalid request body", {
                   details: validation.error
-                }), {
-                  status: 400
                 });
               }
               bodyData = validation.data;
             }
           } catch (error) {
-            return new Response(JSON.stringify({
-              error: "Failed to parse request body"
-            }), {
-              status: 400
-            });
+            return res.badRequest("Failed to parse request body");
           }
         }
         try {
-          const result = await awaitReturn(subRoom[handler.key](req, bodyData, params, this.room));
+          req["data"] = bodyData;
+          req["params"] = params;
+          const result = await awaitReturn(subRoom[handler.key](req, res));
           if (result instanceof Response) {
             return result;
           }
-          return new Response(typeof result === "string" ? result : JSON.stringify(result), {
-            status: 200,
-            headers: {
-              "Content-Type": typeof result === "string" ? "text/plain" : "application/json"
-            }
-          });
+          return res.success(result);
         } catch (error) {
           console.error("Error executing request handler:", error);
-          return new Response(JSON.stringify({
-            error: "Internal server error"
-          }), {
-            status: 500
-          });
+          return res.serverError();
         }
       }
     }
@@ -1161,43 +1398,29 @@ var Server = class {
   * @description Processes requests forwarded by shards, preserving client context
   * @returns {Promise<Response>} The response to return to the shard (which will forward it to the client)
   */
-  async handleShardRequest(req, shardId) {
+  async handleShardRequest(req, res, shardId) {
     const subRoom = await this.getSubRoom();
     if (!subRoom) {
-      return new Response(JSON.stringify({
-        error: "Not found"
-      }), {
-        status: 404
-      });
+      return res.notFound();
     }
     const originalClientIp = req.headers.get("x-original-client-ip");
     const enhancedReq = this.createEnhancedRequest(req, originalClientIp);
     try {
-      const response2 = await this.tryMatchRequestHandler(enhancedReq, subRoom);
+      const response2 = await this.tryMatchRequestHandler(enhancedReq, res, subRoom);
       if (response2) {
         return response2;
       }
-      const legacyResponse = await awaitReturn(subRoom["onRequest"]?.(enhancedReq, this.room));
+      const legacyResponse = await awaitReturn(subRoom["onRequest"]?.(enhancedReq, res));
       if (!legacyResponse) {
-        return new Response(JSON.stringify({
-          error: "Not found"
-        }), {
-          status: 404
-        });
+        return res.notFound();
       }
       if (legacyResponse instanceof Response) {
         return legacyResponse;
       }
-      return new Response(JSON.stringify(legacyResponse), {
-        status: 200
-      });
+      return res.success(legacyResponse);
     } catch (error) {
       console.error(`Error processing request from shard ${shardId}:`, error);
-      return new Response(JSON.stringify({
-        error: "Internal server error"
-      }), {
-        status: 500
-      });
+      return res.serverError();
     }
   }
   /**
@@ -1858,14 +2081,12 @@ var WorldRoom = class {
       room.maxShards.set(roomConfig.maxShards);
     }
   }
-  async updateShardStats(req) {
+  async updateShardStats(req, res) {
     const body = await req.json();
     const { shardId, connections, status } = body;
     const shard = this.shards()[shardId];
     if (!shard) {
-      return {
-        error: `Shard ${shardId} not found`
-      };
+      return res.notFound(`Shard ${shardId} not found`);
     }
     shard.currentConnections.set(connections);
     if (status) {
@@ -1873,23 +2094,20 @@ var WorldRoom = class {
     }
     shard.lastHeartbeat.set(Date.now());
   }
-  async scaleRoom(req) {
+  async scaleRoom(req, res) {
     const data = await req.json();
     const { targetShardCount, shardTemplate, roomId } = data;
     const room = this.rooms()[roomId];
     if (!room) {
-      return {
-        error: `Room ${roomId} does not exist`
-      };
+      return res.notFound(`Room ${roomId} does not exist`);
     }
     const roomShards = Object.values(this.shards()).filter((shard) => shard.roomId() === roomId);
     const previousShardCount = roomShards.length;
     if (room.maxShards() !== void 0 && targetShardCount > room.maxShards()) {
-      return {
-        error: `Cannot scale beyond maximum allowed shards (${room.maxShards()})`,
+      return res.badRequest(`Cannot scale beyond maximum allowed shards (${room.maxShards()})`, {
         roomId,
         currentShardCount: previousShardCount
-      };
+      });
     }
     if (targetShardCount < previousShardCount) {
       const shardsToRemove = [
@@ -1915,45 +2133,34 @@ var WorldRoom = class {
       }
     }
   }
-  async connect(req) {
+  async connect(req, res) {
     try {
       let data;
       try {
         const body = await req.text();
         if (!body || body.trim() === "") {
-          return response(400, {
-            error: "Request body is empty"
-          });
+          return res.badRequest("Request body is empty");
         }
         data = JSON.parse(body);
       } catch (parseError) {
-        return response(400, {
-          error: "Invalid JSON in request body"
-        });
+        return res.badRequest("Invalid JSON in request body");
       }
       if (!data.roomId) {
-        return response(400, {
-          error: "roomId parameter is required"
-        });
+        return res.badRequest("roomId parameter is required");
       }
       const autoCreate = data.autoCreate !== void 0 ? data.autoCreate : true;
       const result = await this.findOptimalShard(data.roomId, autoCreate);
       if ("error" in result) {
-        return response(404, {
-          error: result.error
-        });
+        return res.notFound(result.error);
       }
-      return response(200, {
+      return res.success({
         success: true,
         shardId: result.shardId,
         url: result.url
       });
     } catch (error) {
       console.error("Error connecting to shard:", error);
-      return response(500, {
-        error: "Internal server error",
-        details: error instanceof Error ? error.message : String(error)
-      });
+      return res.serverError();
     }
   }
   async findOptimalShard(roomId, autoCreate = true) {
@@ -2087,7 +2294,8 @@ _ts_decorate([
   ]),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof party_exports === "undefined" || typeof void 0 === "undefined" ? Object : void 0
+    typeof party_exports === "undefined" || typeof void 0 === "undefined" ? Object : void 0,
+    typeof ServerResponse === "undefined" ? Object : ServerResponse
   ]),
   _ts_metadata("design:returntype", Promise)
 ], WorldRoom.prototype, "updateShardStats", null);
@@ -2101,7 +2309,8 @@ _ts_decorate([
   ]),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof party_exports === "undefined" || typeof void 0 === "undefined" ? Object : void 0
+    typeof party_exports === "undefined" || typeof void 0 === "undefined" ? Object : void 0,
+    typeof ServerResponse === "undefined" ? Object : ServerResponse
   ]),
   _ts_metadata("design:returntype", Promise)
 ], WorldRoom.prototype, "scaleRoom", null);
@@ -2112,7 +2321,8 @@ _ts_decorate([
   }),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof party_exports === "undefined" || typeof void 0 === "undefined" ? Object : void 0
+    typeof party_exports === "undefined" || typeof void 0 === "undefined" ? Object : void 0,
+    typeof ServerResponse === "undefined" ? Object : ServerResponse
   ]),
   _ts_metadata("design:returntype", Promise)
 ], WorldRoom.prototype, "connect", null);
@@ -2138,6 +2348,7 @@ export {
   RoomGuard,
   Server,
   ServerIo,
+  ServerResponse,
   Shard,
   WorldRoom,
   request,