@signe/room 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/decorators.ts
-function action(name, bodyValidation) {
+function Action(name, bodyValidation) {
   return function(target, propertyKey) {
     if (!target.constructor._actionMetadata) {
       target.constructor._actionMetadata = /* @__PURE__ */ new Map();
@@ -15,23 +15,261 @@ function Room(options) {
     target.path = options.path;
     target.maxUsers = options.maxUsers;
     target.throttleStorage = options.throttleStorage;
+    target.throttleSync = options.throttleSync;
   };
 }
 
+// ../sync/src/utils.ts
+function isClass(obj) {
+  return typeof obj === "function" && obj.prototype && obj.prototype.constructor === obj;
+}
+var isObject = (item) => item && typeof item === "object" && !Array.isArray(item) && item !== null;
+function generateShortUUID() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let uuid = "";
+  for (let i = 0; i < 8; i++) {
+    const randomIndex = Math.floor(Math.random() * chars.length);
+    uuid += chars[randomIndex];
+  }
+  return uuid;
+}
+
+// src/mock.ts
+var MockPartySocket = class {
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+    this.id = generateShortUUID();
+  }
+  addEventListener(event, cb) {
+    this.events.set(event, cb);
+  }
+  removeEventListener(event, cb) {
+    this.events.delete(event);
+  }
+  _trigger(event, data) {
+    this.events.get(event)?.(data);
+  }
+};
+var MockStorage = class {
+  constructor() {
+    this.storage = /* @__PURE__ */ new Map();
+  }
+  async get(key) {
+    return this.storage.get(key);
+  }
+  async put(key, value) {
+    this.storage.set(key, value);
+  }
+  async list() {
+    return this.storage;
+  }
+};
+var MockPartyRoom = class {
+  constructor(id) {
+    this.id = id;
+    this.clients = /* @__PURE__ */ new Map();
+    this.storage = new MockStorage();
+    this.id = id || generateShortUUID();
+  }
+  connection(client) {
+    const socket = new MockPartySocket();
+    this.clients.set(socket.id, client);
+    client.id = socket.id;
+  }
+  broadcast(data) {
+    this.clients.forEach((client) => {
+      client._trigger("message", data);
+    });
+  }
+  clear() {
+    this.clients.clear();
+  }
+};
+var MockConnection = class {
+  constructor() {
+    this.state = {};
+  }
+  setState(value) {
+    this.state = value;
+  }
+};
+var ServerIo = MockPartyRoom;
+var ClientIo = MockPartySocket;
+
 // src/server.ts
-import { createStatesSnapshot, getByPath, load, syncClass } from "@signe/sync";
 import { dset as dset2 } from "dset";
 import z from "zod";
 
+// ../sync/src/core.ts
+import {
+  ArraySubject,
+  ObjectSubject,
+  isSignal
+} from "@signe/reactive";
+var syncClass = (instance, options = {}) => {
+  const cacheSync = /* @__PURE__ */ new Map();
+  const cachePersist = /* @__PURE__ */ new Set();
+  instance.$valuesChanges = {
+    set: (path, value) => {
+      cacheSync.set(path, value);
+      options.onSync?.(cacheSync);
+    },
+    setPersist: (path) => {
+      if (path == "") path = ".";
+      cachePersist.add(path);
+      options.onPersist?.(cachePersist);
+    },
+    has: (path) => {
+      return cacheSync.has(path);
+    },
+    get: (path) => {
+      return cacheSync.get(path);
+    }
+  };
+  createSyncClass(instance);
+};
+function createStatesSnapshot(instance) {
+  let persistObject = {};
+  if (instance.$snapshot) {
+    for (const key of instance.$snapshot.keys()) {
+      const signal = instance.$snapshot.get(key);
+      const persist = signal.options.persist ?? true;
+      let value = signal();
+      if (isObject(value) || Array.isArray(value)) {
+        break;
+      }
+      if (persist) {
+        persistObject[key] = value;
+      }
+    }
+  }
+  return persistObject;
+}
+function setMetadata(target, key, value) {
+  const meta = target.constructor._propertyMetadata;
+  const propId = meta?.get(key);
+  if (propId) {
+    if (isSignal(target[propId])) {
+      target[propId].set(value);
+    } else {
+      target[propId] = value;
+    }
+  }
+}
+var createSyncClass = (currentClass, parentKey = null, parentClass = null, path = "") => {
+  currentClass.$path = path;
+  if (parentClass) {
+    currentClass.$valuesChanges = parentClass.$valuesChanges;
+  }
+  if (parentKey) {
+    setMetadata(currentClass, "id", parentKey);
+  }
+  if (currentClass.$snapshot) {
+    for (const key of currentClass.$snapshot.keys()) {
+      const signal = currentClass.$snapshot.get(key);
+      const syncToClient = signal.options.syncToClient ?? true;
+      const persist = signal.options.persist ?? true;
+      let value = signal();
+      if (isObject(value) || Array.isArray(value)) {
+        value = { ...value };
+      }
+      const newPath = (path ? path + "." : "") + key;
+      if (syncToClient) {
+        currentClass.$valuesChanges.set(newPath, value);
+      }
+      if (persist) {
+        if (parentClass) currentClass.$valuesChanges.setPersist(path);
+      }
+    }
+  }
+};
+
+// ../sync/src/load.ts
+import { isSignal as isSignal2 } from "@signe/reactive";
+function load(rootInstance, values, valueIsObject) {
+  if (valueIsObject) {
+    loadFromObject(rootInstance, values);
+  } else {
+    loadFromPaths(rootInstance, values);
+  }
+}
+function loadFromPaths(rootInstance, values) {
+  for (const [path, value] of Object.entries(values)) {
+    const parts = path.split(".");
+    loadValue(rootInstance, parts, value);
+  }
+}
+function loadFromObject(rootInstance, values, currentPath = "") {
+  for (const [key, value] of Object.entries(values)) {
+    const newPath = currentPath ? `${currentPath}.${key}` : key;
+    if (typeof value === "object" && !Array.isArray(value)) {
+      loadFromObject(rootInstance, value, newPath);
+    } else {
+      const parts = newPath.split(".");
+      loadValue(rootInstance, parts, value);
+    }
+  }
+}
+function loadValue(rootInstance, parts, value) {
+  let current = rootInstance;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (i === parts.length - 1) {
+      if (value == "$delete") {
+        if (isSignal2(current)) {
+          current = current();
+        }
+        Reflect.deleteProperty(current, part);
+      } else if (current[part]?._subject) {
+        current[part].set(value);
+      }
+    } else {
+      if (isSignal2(current)) {
+        current = current();
+      }
+      const currentValue = current[part];
+      if (currentValue === void 0) {
+        const parentInstance = getByPath(
+          rootInstance,
+          parts.slice(0, i).join(".")
+        );
+        const classType = parentInstance?.options?.classType;
+        if (classType) {
+          current[part] = !isClass(classType) ? classType(part) : new classType();
+          setMetadata(current[part], "id", part);
+        } else {
+          current[part] = {};
+        }
+      }
+      current = current[part];
+    }
+  }
+}
+function getByPath(root, path) {
+  const parts = path.split(".");
+  let current = root;
+  for (const part of parts) {
+    if (isSignal2(current)) {
+      current = current();
+    }
+    if (current[part]) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+
 // src/utils.ts
 import { dset } from "dset";
 function isPromise(value) {
-  return value && value instanceof Promise;
+  return value instanceof Promise;
 }
 async function awaitReturn(val) {
   return isPromise(val) ? await val : val;
 }
-function isClass(obj) {
+function isClass2(obj) {
   return typeof obj === "function" && obj.prototype && obj.prototype.constructor === obj;
 }
 function throttle(func, wait) {
@@ -58,18 +296,25 @@ function extractParams(pattern, str) {
   const match = regex.exec(str);
   if (match && match.groups) {
     return match.groups;
+  } else if (pattern === str) {
+    return {};
   } else {
     return null;
   }
 }
 function dremove(obj, keys) {
-  keys.split && (keys = keys.split("."));
-  var i = 0, l = keys.length, t = { ...obj }, k;
+  if (typeof keys === "string") {
+    keys = keys.split(".");
+  }
+  let i = 0;
+  const l = keys.length;
+  let t = obj;
+  let k;
   while (i < l - 1) {
     k = keys[i++];
     if (k === "__proto__" || k === "constructor" || k === "prototype") return;
+    if (typeof t[k] !== "object" || t[k] === null) return;
     t = t[k];
-    if (typeof t !== "object" || t === null) return;
   }
   k = keys[i];
   if (t && typeof t === "object" && !(k === "__proto__" || k === "constructor" || k === "prototype")) {
@@ -81,8 +326,8 @@ function buildObject(valuesMap, allMemory) {
   for (let path of valuesMap.keys()) {
     const value = valuesMap.get(path);
     dset(memoryObj, path, value);
-    if (path == "$delete") {
-      dremove(allMemory, value);
+    if (value === "$delete") {
+      dremove(allMemory, path);
     } else {
       dset(allMemory, path, value);
     }
@@ -96,19 +341,81 @@ var Message = z.object({
   value: z.any()
 });
 var Server = class {
+  /**
+   * @constructor
+   * @param {Party.Room} room - The room object representing the current game or application instance.
+   * 
+   * @example
+   * ```typescript
+   * const server = new MyServer(new ServerIo("game"));
+   * ```
+   */
   constructor(room) {
     this.room = room;
-    this.memoryAll = {};
-    this.subRoom = {};
+    this.subRoom = null;
     this.rooms = [];
-    for (let room2 of this.rooms) {
-      const params = extractParams(room2.path, this.room.id);
+  }
+  /**
+    * @readonly
+    * @property {boolean} isHibernate - Indicates whether the server is in hibernate mode.
+    * 
+    * @example
+    * ```typescript
+    * if (!server.isHibernate) {
+    *   console.log("Server is active");
+    * }
+    * ```
+    */
+  get isHibernate() {
+    return !!this["options"]?.hibernate;
+  }
+  /**
+   * @method onStart
+   * @async
+   * @description Initializes the server and creates the initial room if not in hibernate mode.
+   * @returns {Promise<void>}
+   * 
+   * @example
+   * ```typescript
+   * async function initServer() {
+   *   await server.onStart();
+   *   console.log("Server started");
+   * }
+   * ```
+   */
+  async onStart() {
+    if (!this.isHibernate) {
+      this.subRoom = await this.createRoom();
+    }
+  }
+  /**
+   * @method createRoom
+   * @private
+   * @async
+   * @param {CreateRoomOptions} [options={}] - Options for creating the room.
+   * @returns {Promise<Object>} The created room instance.
+   * @throws {Error} If no matching room is found.
+   * 
+   * @example
+   * ```typescript
+   * // This method is private and called internally
+   * async function internalCreateRoom() {
+   *   const room = await this.createRoom({ getMemoryAll: true });
+   *   console.log("Room created:", room);
+   * }
+   * ```
+   */
+  async createRoom(options = {}) {
+    let instance;
+    let init = true;
+    for (let room of this.rooms) {
+      const params = extractParams(room.path, this.room.id);
       if (params) {
-        this.subRoom = new room2(this.room, params);
+        instance = new room(this.room, params);
         break;
       }
     }
-    if (!this.subRoom) {
+    if (!instance) {
       throw new Error("Room not found");
     }
     const loadMemory = async () => {
@@ -121,75 +428,160 @@ var Server = class {
         }
         dset2(tmpObject, key, value);
       }
-      load(this, tmpObject);
+      load(instance, tmpObject);
     };
-    loadMemory();
-    syncClass(this.subRoom, {
-      onSync: throttle((values) => {
-        const packet = buildObject(values, this.memoryAll);
-        this.room.broadcast(
-          JSON.stringify({
-            type: "sync",
-            value: packet
-          })
-        );
-        values.clear();
-      }, 500),
-      onPersist: throttle(async (values) => {
-        for (let path of values) {
-          const instance = path == "." ? this.subRoom : getByPath(this.subRoom, path);
-          const itemValue = createStatesSnapshot(instance);
-          await this.room.storage.put(path, itemValue);
-        }
-        values.clear();
-      }, this.subRoom["throttleStorage"] ?? 2e3)
+    await loadMemory();
+    instance.$memoryAll = {};
+    const syncCb = (values) => {
+      if (options.getMemoryAll) {
+        buildObject(values, instance.$memoryAll);
+      }
+      if (init && this.isHibernate) {
+        init = false;
+        return;
+      }
+      const packet = buildObject(values, instance.$memoryAll);
+      this.room.broadcast(
+        JSON.stringify({
+          type: "sync",
+          value: packet
+        })
+      );
+      values.clear();
+    };
+    const persistCb = async (values) => {
+      for (let path of values) {
+        const _instance = path == "." ? instance : getByPath(instance, path);
+        const itemValue = createStatesSnapshot(_instance);
+        await this.room.storage.put(path, itemValue);
+      }
+      values.clear();
+    };
+    syncClass(instance, {
+      onSync: throttle(syncCb, instance["throttleSync"] ?? 500),
+      onPersist: throttle(persistCb, instance["throttleStorage"] ?? 2e3)
     });
+    return instance;
   }
-  static async onBeforeConnect(request) {
-    try {
-      request.headers.set("X-User-ID", "" + Math.random());
-      return request;
-    } catch (e) {
-      return new Response("Unauthorized", { status: 401 });
+  /**
+   * @method getSubRoom
+   * @private
+   * @async
+   * @param {Object} [options={}] - Options for getting the sub-room.
+   * @returns {Promise<Object>} The sub-room instance.
+   * 
+   * @example
+   * ```typescript
+   * // This method is private and called internally
+   * async function internalGetSubRoom() {
+   *   const subRoom = await this.getSubRoom();
+   *   console.log("Sub-room retrieved:", subRoom);
+   * }
+   * ```
+   */
+  async getSubRoom(options = {}) {
+    let subRoom;
+    if (this.isHibernate) {
+      subRoom = await this.createRoom(options);
+    } else {
+      subRoom = this.subRoom;
     }
+    return subRoom;
   }
-  getUsersProperty() {
-    const meta = this.subRoom.constructor["_propertyMetadata"];
+  /**
+   * @method getUsersProperty
+   * @private
+   * @param {Object} subRoom - The sub-room instance.
+   * @returns {Object|null} The users property of the sub-room, or null if not found.
+   * 
+   * @example
+   * ```typescript
+   * // This method is private and called internally
+   * function internalGetUsers(subRoom) {
+   *   const users = this.getUsersProperty(subRoom);
+   *   console.log("Users:", users);
+   * }
+   * ```
+   */
+  getUsersProperty(subRoom) {
+    const meta = subRoom.constructor["_propertyMetadata"];
     const propId = meta?.get("users");
     if (propId) {
-      return this.subRoom[propId];
+      return subRoom[propId];
     }
     return null;
   }
+  /**
+   * @method onConnect
+   * @async
+   * @param {Party.Connection} conn - The connection object for the new user.
+   * @param {Party.ConnectionContext} ctx - The context of the connection.
+   * @description Handles a new user connection, creates a user object, and sends initial sync data.
+   * @returns {Promise<void>}
+   * 
+   * @example
+   * ```typescript
+   * server.onConnect = async (conn, ctx) => {
+   *   await server.onConnect(conn, ctx);
+   *   console.log("New user connected:", conn.id);
+   * };
+   * ```
+   */
   async onConnect(conn, ctx) {
-    const publicId = "a" + ("" + Math.random()).split(".")[1];
+    const subRoom = await this.getSubRoom({
+      getMemoryAll: true
+    });
+    const publicId = generateShortUUID();
     let user = null;
-    const signal = this.getUsersProperty();
+    const signal = this.getUsersProperty(subRoom);
     if (signal) {
       const { classType } = signal.options;
-      user = isClass(classType) ? new classType() : classType(conn, ctx);
+      user = isClass2(classType) ? new classType() : classType(conn, ctx);
       signal()[publicId] = user;
     }
-    await awaitReturn(this.subRoom["onJoin"]?.(user, conn, ctx));
+    await awaitReturn(subRoom["onJoin"]?.(user, conn, ctx));
     conn.setState({ publicId });
     conn.send(
       JSON.stringify({
         type: "sync",
         value: {
           pId: publicId,
-          ...this.memoryAll
+          ...subRoom.$memoryAll
         }
       })
     );
   }
+  /**
+   * @method onMessage
+   * @async
+   * @param {string} message - The message received from a user.
+   * @param {Party.Connection} sender - The connection object of the sender.
+   * @description Processes incoming messages and triggers corresponding actions in the sub-room.
+   * @returns {Promise<void>}
+   * 
+   * @example
+   * ```typescript
+   * server.onMessage = async (message, sender) => {
+   *   await server.onMessage(message, sender);
+   *   console.log("Message processed from:", sender.id);
+   * };
+   * ```
+   */
   async onMessage(message, sender) {
-    const actions = this.subRoom.constructor["_actionMetadata"];
-    const result = Message.safeParse(JSON.parse(message));
+    let json;
+    try {
+      json = JSON.parse(message);
+    } catch (e) {
+      return;
+    }
+    const result = Message.safeParse(json);
     if (!result.success) {
       return;
     }
+    const subRoom = await this.getSubRoom();
+    const actions = subRoom.constructor["_actionMetadata"];
     if (actions) {
-      const signal = this.getUsersProperty();
+      const signal = this.getUsersProperty(subRoom);
       const { publicId } = sender.state;
       const user = signal?.()[publicId];
       const actionName = actions.get(result.data.action);
@@ -203,24 +595,43 @@ var Server = class {
           }
         }
         await awaitReturn(
-          this.subRoom[actionName.key](user, result.data.value, sender)
+          subRoom[actionName.key](user, result.data.value, sender)
         );
       }
     }
   }
+  /**
+   * @method onClose
+   * @async
+   * @param {Party.Connection} conn - The connection object of the disconnecting user.
+   * @description Handles user disconnection, removing them from the room and triggering the onLeave event.
+   * @returns {Promise<void>}
+   * 
+   * @example
+   * ```typescript
+   * server.onClose = async (conn) => {
+   *   await server.onClose(conn);
+   *   console.log("User disconnected:", conn.id);
+   * };
+   * ```
+   */
   async onClose(conn) {
-    const signal = this.getUsersProperty();
+    const subRoom = await this.getSubRoom();
+    const signal = this.getUsersProperty(subRoom);
     const { publicId } = conn.state;
     const user = signal?.()[publicId];
-    await awaitReturn(this.subRoom["onLeave"]?.(user, conn));
+    await awaitReturn(subRoom["onLeave"]?.(user, conn));
     if (signal) {
       delete signal()[publicId];
     }
   }
 };
 export {
+  Action,
+  ClientIo,
+  MockConnection,
   Room,
   Server,
-  action
+  ServerIo
 };
 //# sourceMappingURL=index.js.map