@signe/room 2.0.1 → 2.2.0

package/dist/index.d.ts

@@ -324,10 +324,55 @@ declare class Server implements Server$1 {
      */
     private getUsersProperty;
     private getUsersPropName;
-    private getSession;
+    /**
+     * Retrieves the connection status property from a user object.
+     *
+     * @param {any} user - The user object to get the connection property from.
+     * @returns {Function|null} - The connection property signal function or null if not found.
+     * @private
+     */
+    private getUserConnectionProperty;
+    /**
+     * Updates a user's connection status in the signal.
+     *
+     * @param {any} user - The user object to update.
+     * @param {boolean} isConnected - The new connection status.
+     * @returns {boolean} - Whether the update was successful.
+     * @private
+     */
+    private updateUserConnectionStatus;
+    /**
+     * @method getSession
+     * @private
+     * @param {string} privateId - The private ID of the session.
+     * @returns {Promise<Object|null>} The session object, or null if not found.
+     *
+     * @example
+     * ```typescript
+     * const session = await server.getSession("privateId");
+     * console.log(session);
+     * ```
+     */
+    getSession(privateId: string): Promise<{
+        publicId: string;
+        state?: any;
+        created?: number;
+        connected?: boolean;
+    } | null>;
     private saveSession;
     private updateSessionConnection;
-    private deleteSession;
+    /**
+     * @method deleteSession
+     * @private
+     * @param {string} privateId - The private ID of the session to delete.
+     * @returns {Promise<void>}
+     *
+     * @example
+     * ```typescript
+     * await server.deleteSession("privateId");
+     * ```
+     */
+    deleteSession(privateId: string): Promise<void>;
     onConnectClient(conn: Connection, ctx: ConnectionContext): Promise<void>;
     /**
      * @method onConnect
@@ -501,7 +546,7 @@ declare class MockPartyClient {
     private events;
     id: string;
     conn: MockConnection;
-    constructor(server: Server);
+    constructor(server: Server, id?: string);
     addEventListener(event: any, cb: any): void;
     removeEventListener(event: any, cb: any): void;
     _trigger(event: any, data: any): void;
@@ -521,7 +566,7 @@ declare class MockPartyRoom {
     context: MockContext;
     env: {};
     constructor(id?: string, options?: any);
-    connection(server: Server): Promise<MockPartyClient>;
+    connection(server: Server, id?: string): Promise<MockPartyClient>;
     broadcast(data: any): void;
     getConnection(id: string): MockPartyClient;
     getConnections(): MockConnection[];
@@ -616,9 +661,9 @@ declare function testRoom(Room: any, options?: {
 }): Promise<{
     server: Server | Shard;
     room: any;
-    createClient: () => Promise<MockPartyClient>;
+    createClient: (id?: string) => Promise<MockPartyClient>;
 }>;
-declare function request(room: Server, path: string, options?: {
+declare function request(room: Server | Shard, path: string, options?: {
     method: 'GET' | 'POST' | 'PUT' | 'DELETE';
     body?: any;
     headers?: Record<string, string>;

package/dist/index.js

@@ -97,140 +97,6 @@ var Storage = class {
   }
 };
 
-// src/mock.ts
-var MockPartyClient = class {
-  static {
-    __name(this, "MockPartyClient");
-  }
-  server;
-  events;
-  id;
-  conn;
-  constructor(server) {
-    this.server = server;
-    this.events = /* @__PURE__ */ new Map();
-    this.id = generateShortUUID();
-    this.conn = new MockConnection(this);
-  }
-  addEventListener(event, cb) {
-    this.events.set(event, cb);
-  }
-  removeEventListener(event, cb) {
-    this.events.delete(event);
-  }
-  _trigger(event, data) {
-    this.events.get(event)?.(data);
-  }
-  send(data) {
-    return this.server.onMessage(JSON.stringify(data), this.conn);
-  }
-};
-var MockLobby = class MockLobby2 {
-  static {
-    __name(this, "MockLobby");
-  }
-  server;
-  constructor(server) {
-    this.server = server;
-  }
-  socket() {
-    return new MockPartyClient(this.server);
-  }
-};
-var MockContext = class MockContext2 {
-  static {
-    __name(this, "MockContext");
-  }
-  room;
-  parties;
-  constructor(room, options = {}) {
-    this.room = room;
-    this.parties = {
-      main: /* @__PURE__ */ new Map()
-    };
-    const parties = options.parties || {};
-    for (let lobbyId in parties) {
-      this.parties.main.set(lobbyId, new MockLobby(parties[lobbyId](room)));
-    }
-  }
-};
-var MockPartyRoom = class MockPartyRoom2 {
-  static {
-    __name(this, "MockPartyRoom");
-  }
-  id;
-  clients;
-  storage;
-  context;
-  env;
-  constructor(id2, options = {}) {
-    this.id = id2;
-    this.clients = /* @__PURE__ */ new Map();
-    this.storage = new Storage();
-    this.env = {};
-    this.id = id2 || generateShortUUID();
-    this.context = new MockContext(this, {
-      parties: options.parties || {}
-    });
-    this.env = options.env || {};
-  }
-  async connection(server) {
-    const socket = new MockPartyClient(server);
-    const url = new URL("http://localhost");
-    const request2 = new Request(url.toString(), {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-    await server.onConnect(socket.conn, {
-      request: request2
-    });
-    this.clients.set(socket.id, socket);
-    return socket;
-  }
-  broadcast(data) {
-    this.clients.forEach((client) => {
-      client._trigger("message", data);
-    });
-  }
-  getConnection(id2) {
-    return this.clients.get(id2);
-  }
-  getConnections() {
-    return Array.from(this.clients.values()).map((client) => client.conn);
-  }
-  clear() {
-    this.clients.clear();
-  }
-};
-var MockConnection = class {
-  static {
-    __name(this, "MockConnection");
-  }
-  client;
-  server;
-  id;
-  constructor(client) {
-    this.client = client;
-    this.state = {};
-    this.server = client.server;
-    this.id = client.id;
-  }
-  state;
-  setState(value) {
-    this.state = value;
-  }
-  send(data) {
-    this.client._trigger("message", data);
-  }
-  close() {
-    this.server.onClose(this);
-  }
-};
-var ServerIo = MockPartyRoom;
-var ClientIo = MockPartyClient;
-
 // src/server.ts
 import { dset as dset2 } from "dset";
 import z from "zod";
@@ -546,7 +412,8 @@ var ServerResponse = class {
 // src/request/cors.ts
 function cors(res, options = {}) {
   const newHeaders = new Headers(res.headers);
-  newHeaders.set("Access-Control-Allow-Origin", options.origin || "*");
+  const requestOrigin = options.origin || "*";
+  newHeaders.set("Access-Control-Allow-Origin", requestOrigin);
   if (options.credentials) {
     newHeaders.set("Access-Control-Allow-Credentials", "true");
   }
@@ -565,6 +432,8 @@ function cors(res, options = {}) {
   }
   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,
@@ -828,9 +697,54 @@ var Server = class {
     return null;
   }
   getUsersPropName(subRoom) {
-    const meta = subRoom.constructor["_propertyMetadata"];
-    return meta?.get("users");
+    if (!subRoom) return null;
+    const metadata = subRoom.constructor._propertyMetadata;
+    if (!metadata) return null;
+    return metadata.get("users");
+  }
+  /**
+  * Retrieves the connection status property from a user object.
+  * 
+  * @param {any} user - The user object to get the connection property from.
+  * @returns {Function|null} - The connection property signal function or null if not found.
+  * @private
+  */
+  getUserConnectionProperty(user) {
+    if (!user) return null;
+    const metadata = user.constructor._propertyMetadata;
+    if (!metadata) return null;
+    const connectedPropName = metadata.get("connected");
+    if (!connectedPropName) return null;
+    return user[connectedPropName];
   }
+  /**
+  * Updates a user's connection status in the signal.
+  * 
+  * @param {any} user - The user object to update.
+  * @param {boolean} isConnected - The new connection status.
+  * @returns {boolean} - Whether the update was successful.
+  * @private
+  */
+  updateUserConnectionStatus(user, isConnected) {
+    const connectionSignal = this.getUserConnectionProperty(user);
+    if (connectionSignal) {
+      connectionSignal.set(isConnected);
+      return true;
+    }
+    return false;
+  }
+  /**
+  * @method getSession
+  * @private
+  * @param {string} privateId - The private ID of the session.
+  * @returns {Promise<Object|null>} The session object, or null if not found.
+  * 
+  * @example
+  * ```typescript
+  * const session = await server.getSession("privateId");
+  * console.log(session);
+  * ```
+  */
   async getSession(privateId) {
     if (!privateId) return null;
     try {
@@ -857,6 +771,17 @@ var Server = class {
       });
     }
   }
+  /**
+  * @method deleteSession
+  * @private
+  * @param {string} privateId - The private ID of the session to delete.
+  * @returns {Promise<void>}
+  * 
+  * @example
+  * ```typescript
+  * await server.deleteSession("privateId");
+  * ```
+  */
   async deleteSession(privateId) {
     await this.room.storage.delete(`session:${privateId}`);
   }
@@ -892,6 +817,8 @@ var Server = class {
         signal2()[publicId] = user;
         const snapshot = createStatesSnapshot(user);
         this.room.storage.put(`${usersPropName}.${publicId}`, snapshot);
+      } else {
+        user = signal2()[existingSession.publicId];
       }
       if (!existingSession) {
         await this.saveSession(conn.id, {
@@ -901,6 +828,7 @@ var Server = class {
         await this.updateSessionConnection(conn.id, true);
       }
     }
+    this.updateUserConnectionStatus(user, true);
     await awaitReturn(subRoom["onJoin"]?.(user, conn, ctx));
     conn.setState({
       ...conn.state,
@@ -978,6 +906,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);
@@ -1052,17 +984,14 @@ var Server = class {
   * @returns {Promise<void>}
   */
   async handleShardClientConnect(message, shardConnection) {
-    const { privateId, connectionInfo } = message;
+    const { privateId, requestInfo } = message;
     const shardState = shardConnection.state;
     const virtualContext = {
-      request: {
-        headers: new Headers({
-          "x-forwarded-for": connectionInfo.ip,
-          "user-agent": connectionInfo.userAgent
-        }),
-        method: "GET",
-        url: ""
-      }
+      request: requestInfo ? {
+        headers: new Headers(requestInfo.headers),
+        method: requestInfo.method,
+        url: requestInfo.url
+      } : void 0
     };
     const virtualConnection = {
       id: privateId,
@@ -1204,14 +1133,17 @@ var Server = class {
     const { publicId } = conn.state;
     const user = signal2?.()[publicId];
     if (!user) return;
-    await awaitReturn(subRoom["onLeave"]?.(user, conn));
     await this.updateSessionConnection(privateId, false);
-    this.broadcast({
-      type: "user_disconnected",
-      value: {
-        publicId
-      }
-    }, subRoom);
+    const connectionUpdated = this.updateUserConnectionStatus(user, false);
+    await awaitReturn(subRoom["onLeave"]?.(user, conn));
+    if (!connectionUpdated) {
+      this.broadcast({
+        type: "user_disconnected",
+        value: {
+          publicId
+        }
+      }, subRoom);
+    }
   }
   async onAlarm() {
     const subRoom = await this.getSubRoom();
@@ -1234,6 +1166,9 @@ var Server = class {
     const res = new ServerResponse([
       createCorsInterceptor()
     ]);
+    if (req.method === "OPTIONS") {
+      return res.status(200).send({});
+    }
     if (isFromShard) {
       return this.handleShardRequest(req, res, shardId);
     }
@@ -1507,13 +1442,21 @@ var Shard = class {
   }
   onConnect(conn, ctx) {
     this.connectionMap.set(conn.id, conn);
+    const headers = {};
+    if (ctx.request?.headers) {
+      ctx.request.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+    }
+    const requestInfo = ctx.request ? {
+      headers,
+      url: ctx.request.url,
+      method: ctx.request.method
+    } : null;
     this.ws.send(JSON.stringify({
       type: "shard.clientConnected",
       privateId: conn.id,
-      connectionInfo: {
-        ip: ctx.request?.headers.get("x-forwarded-for") || "unknown",
-        userAgent: ctx.request?.headers.get("user-agent") || "unknown"
-      }
+      requestInfo
     }));
     this.updateWorldStats();
   }
@@ -1652,6 +1595,9 @@ async function testRoom(Room3, options = {}) {
     const shardServer = new Shard(io);
     shardServer.subRoom = null;
     server = shardServer;
+    for (const lobby of io.context.parties.main.values()) {
+      await lobby.server.onStart();
+    }
   } else {
     server = await createServer(io);
   }
@@ -1659,8 +1605,8 @@ async function testRoom(Room3, options = {}) {
   return {
     server,
     room: server.subRoom,
-    createClient: /* @__PURE__ */ __name(async () => {
-      const client = await io.connection(server);
+    createClient: /* @__PURE__ */ __name(async (id2) => {
+      const client = await io.connection(server, id2);
       return client;
     }, "createClient")
   };
@@ -1676,6 +1622,143 @@ async function request(room, path, options = {
 }
 __name(request, "request");
 
+// src/mock.ts
+var MockPartyClient = class {
+  static {
+    __name(this, "MockPartyClient");
+  }
+  server;
+  events;
+  id;
+  conn;
+  constructor(server, id2) {
+    this.server = server;
+    this.events = /* @__PURE__ */ new Map();
+    this.id = id2 || generateShortUUID();
+    this.conn = new MockConnection(this);
+  }
+  addEventListener(event, cb) {
+    this.events.set(event, cb);
+  }
+  removeEventListener(event, cb) {
+    this.events.delete(event);
+  }
+  _trigger(event, data) {
+    this.events.get(event)?.(data);
+  }
+  send(data) {
+    return this.server.onMessage(JSON.stringify(data), this.conn);
+  }
+};
+var MockLobby = class MockLobby2 {
+  static {
+    __name(this, "MockLobby");
+  }
+  server;
+  constructor(server) {
+    this.server = server;
+  }
+  socket() {
+    return new MockPartyClient(this.server);
+  }
+  fetch(url, options) {
+    return request(this.server, url, options);
+  }
+};
+var MockContext = class MockContext2 {
+  static {
+    __name(this, "MockContext");
+  }
+  room;
+  parties;
+  constructor(room, options = {}) {
+    this.room = room;
+    this.parties = {
+      main: /* @__PURE__ */ new Map()
+    };
+    const parties = options.parties || {};
+    for (let lobbyId in parties) {
+      this.parties.main.set(lobbyId, new MockLobby(parties[lobbyId](room)));
+    }
+  }
+};
+var MockPartyRoom = class MockPartyRoom2 {
+  static {
+    __name(this, "MockPartyRoom");
+  }
+  id;
+  clients;
+  storage;
+  context;
+  env;
+  constructor(id2, options = {}) {
+    this.id = id2;
+    this.clients = /* @__PURE__ */ new Map();
+    this.storage = new Storage();
+    this.env = {};
+    this.id = id2 || generateShortUUID();
+    this.context = new MockContext(this, {
+      parties: options.parties || {}
+    });
+    this.env = options.env || {};
+  }
+  async connection(server, id2) {
+    const socket = new MockPartyClient(server, id2);
+    const url = new URL("http://localhost");
+    const request2 = new Request(url.toString(), {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    await server.onConnect(socket.conn, {
+      request: request2
+    });
+    this.clients.set(socket.id, socket);
+    return socket;
+  }
+  broadcast(data) {
+    this.clients.forEach((client) => {
+      client._trigger("message", data);
+    });
+  }
+  getConnection(id2) {
+    return this.clients.get(id2);
+  }
+  getConnections() {
+    return Array.from(this.clients.values()).map((client) => client.conn);
+  }
+  clear() {
+    this.clients.clear();
+  }
+};
+var MockConnection = class {
+  static {
+    __name(this, "MockConnection");
+  }
+  client;
+  server;
+  id;
+  constructor(client) {
+    this.client = client;
+    this.state = {};
+    this.server = client.server;
+    this.id = client.id;
+  }
+  state;
+  setState(value) {
+    this.state = value;
+  }
+  send(data) {
+    this.client._trigger("message", data);
+  }
+  close() {
+    this.server.onClose(this);
+  }
+};
+var ServerIo = MockPartyRoom;
+var ClientIo = MockPartyClient;
+
 // src/world.ts
 import { signal } from "@signe/reactive";
 import { sync, id, persist } from "@signe/sync";