@pluv/platform-node 0.20.0 → 0.21.1

package/.turbo/turbo-build.log

@@ -1,18 +1,18 @@
 
-> @pluv/platform-node@0.20.0 build /home/runner/work/pluv/pluv/packages/platform-node
+> @pluv/platform-node@0.21.1 build /home/runner/work/pluv/pluv/packages/platform-node
 > tsup src/index.ts --format esm,cjs --dts
 
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.1.0
-CLI Target: es6
-ESM Build start
-CJS Build start
-ESM dist/index.mjs 6.12 KB
-ESM ⚡️ Build success in 127ms
-CJS dist/index.js 7.93 KB
-CJS ⚡️ Build success in 128ms
-DTS Build start
-DTS ⚡️ Build success in 4198ms
-DTS dist/index.d.mts 2.92 KB
-DTS dist/index.d.ts  2.92 KB
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.2.4
+CLI Target: es6
+ESM Build start
+CJS Build start
+ESM dist/index.mjs 7.58 KB
+ESM ⚡️ Build success in 91ms
+CJS dist/index.js 9.35 KB
+CJS ⚡️ Build success in 92ms
+DTS Build start
+DTS ⚡️ Build success in 3454ms
+DTS dist/index.d.mts 3.56 KB
+DTS dist/index.d.ts  3.56 KB

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # @pluv/platform-node
 
+## 0.21.1
+
+### Patch Changes
+
+- @pluv/io@0.21.1
+- @pluv/types@0.21.1
+
+## 0.21.0
+
+### Minor Changes
+
+- 41b15e4: **BREAKING** - Updated `sessions` type in the procedure context from `Map<string, WebSocketSession>` to `readonly WebSocketSession[]`.
+- f570c8a: **BREAKING**: The original request object is no longer available in the context of any event resolvers.
+
+  Previously, the request object that was passed into `PluvServer.getRoom` would be made available on the context object of each of the resolvers. This is no-longer a part of the event context, and therefore needs to be omitted from calls to `PluvServer.getRoom`.
+
+  ```ts
+  // Before
+
+  // With platform-node
+  ioServer.getRoom(websocket, { req, token });
+
+  // With platform-cloudflare
+  ioServer.getRoom(websocket, { env, req, token });
+  ```
+
+  ```ts
+  // Now
+
+  // With platform-node
+  ioServer.getRoom(websocket, { req });
+
+  // With platform-cloudflare
+  ioServer.getRoom(websocket, { env, req });
+  ```
+
+- b98ab6b: Internal updates to platforms (i.e. `@pluv/platform-cloudflare` and `@pluv/platform-node`) to be able to support Cloudflare Worker Websocket Hibernation APIs.
+
+### Patch Changes
+
+- cc2613e: Moved `sessionId` from being derived in `IORoom` to being derived as a getter in `AbstractWebsocket`.
+- Updated dependencies [307bd44]
+- Updated dependencies [41b15e4]
+- Updated dependencies [f570c8a]
+- Updated dependencies [b98ab6b]
+- Updated dependencies [4c2228d]
+- Updated dependencies [cc2613e]
+  - @pluv/io@0.21.0
+  - @pluv/types@0.21.0
+
 ## 0.20.0
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,40 +1,50 @@
-import { AbstractWebSocket, AbstractEventMap, AbstractListener, AbstractWebSocketConfig, AbstractPersistance, AbstractPubSub, AbstractPlatform, ConvertWebSocketConfig, PluvServer } from '@pluv/io';
-import { MaybePromise, Maybe, InferIOAuthorizeUser, InferIOAuthorize, InferIOAuthorizeRequired } from '@pluv/types';
-import { IncomingMessage as IncomingMessage$1, ServerResponse, Server } from 'node:http';
+import { AbstractWebSocket, WebSocketSerializedState, AbstractEventMap, AbstractListener, AbstractWebSocketConfig, WebSocketRegistrationMode, AbstractPersistance, AbstractPubSub, AbstractPlatform, ConvertWebSocketConfig, AbstractPlatformConfig, PluvServer } from '@pluv/io';
+import { JsonObject, MaybePromise, Maybe, InferIOAuthorizeUser, InferIOAuthorize, InferIOAuthorizeRequired } from '@pluv/types';
+import { IncomingMessage, ServerResponse, Server } from 'node:http';
 import { WebSocket, Server as Server$1 } from 'ws';
 export { WebSocket } from 'ws';
-import { IncomingMessage } from 'http';
 
 type NodeWebSocketConfig = AbstractWebSocketConfig;
-declare class NodeWebSocket extends AbstractWebSocket {
-    webSocket: WebSocket;
+declare class NodeWebSocket extends AbstractWebSocket<WebSocket> {
+    private _sessionId;
+    private _state;
+    set presence(presence: JsonObject | null);
     get readyState(): 0 | 1 | 2 | 3;
+    get sessionId(): string;
+    get state(): WebSocketSerializedState;
     constructor(webSocket: WebSocket, config: NodeWebSocketConfig);
     addEventListener<TType extends keyof AbstractEventMap>(type: TType, handler: AbstractListener<TType>): void;
     close(code?: number | undefined, reason?: string | undefined): void;
-    initialize(): Promise<() => void>;
     send(message: string | ArrayBuffer | ArrayBufferView): void;
     terminate(): void;
 }
 
-type NodePlatformOptions = {
+type NodePlatformConfig = {
+    mode?: WebSocketRegistrationMode;
+} & ({
     persistance?: undefined;
     pubSub?: undefined;
 } | {
     persistance: AbstractPersistance;
     pubSub: AbstractPubSub;
-};
-declare class NodePlatform extends AbstractPlatform<WebSocket, {
-    req: IncomingMessage;
-}> {
-    constructor(options?: NodePlatformOptions);
+});
+declare class NodePlatform extends AbstractPlatform<NodeWebSocket> {
+    readonly _registrationMode: WebSocketRegistrationMode;
+    constructor(config?: NodePlatformConfig);
+    acceptWebSocket(webSocket: NodeWebSocket): Promise<void>;
     convertWebSocket(webSocket: WebSocket, config: ConvertWebSocketConfig): NodeWebSocket;
+    getLastPing(webSocket: NodeWebSocket): number | null;
+    getSerializedState(webSocket: NodeWebSocket): WebSocketSerializedState | null;
+    getSessionId(webSocket: WebSocket): string | null;
+    getWebSockets(): readonly WebSocket[];
+    initialize(config: AbstractPlatformConfig<{}, {}>): this;
     parseData(data: string | ArrayBuffer): Record<string, any>;
     randomUUID(): string;
+    setSerializedState(webSocket: NodeWebSocket, state: WebSocketSerializedState): void;
 }
 
 interface AuthorizeFunctionContext {
-    req: IncomingMessage$1;
+    req: IncomingMessage;
     res: ServerResponse;
     roomId: string;
 }
@@ -48,11 +58,11 @@ type CreatePluvHandlerConfig<TPluvServer extends PluvServer<NodePlatform, any, a
 } : {
     authorize?: undefined;
 });
-type RequestHandler = (req: IncomingMessage$1, res: ServerResponse, next?: () => void) => void;
+type RequestHandler = (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
 interface WebSocketHandlerResult {
     matched: boolean;
 }
-type WebSocketHandler = (ws: WebSocket, req: IncomingMessage$1) => Promise<WebSocketHandlerResult>;
+type WebSocketHandler = (ws: WebSocket, req: IncomingMessage) => Promise<WebSocketHandlerResult>;
 interface CreatePluvHandlerResult {
     createWsServer: () => Server$1;
     handler: RequestHandler;
@@ -60,6 +70,6 @@ interface CreatePluvHandlerResult {
 }
 declare const createPluvHandler: <TPluvServer extends PluvServer<NodePlatform, any, any, any>>(config: CreatePluvHandlerConfig<TPluvServer>) => CreatePluvHandlerResult;
 
-declare const platformNode: (options?: NodePlatformOptions) => NodePlatform;
+declare const platformNode: (config?: NodePlatformConfig) => NodePlatform;
 
-export { type AuthorizeFunction, type AuthorizeFunctionContext, type CreatePluvHandlerConfig, type NodePlatformOptions, createPluvHandler, platformNode };
+export { type AuthorizeFunction, type AuthorizeFunctionContext, type CreatePluvHandlerConfig, type NodePlatformConfig, createPluvHandler, platformNode };

package/dist/index.d.ts

@@ -1,40 +1,50 @@
-import { AbstractWebSocket, AbstractEventMap, AbstractListener, AbstractWebSocketConfig, AbstractPersistance, AbstractPubSub, AbstractPlatform, ConvertWebSocketConfig, PluvServer } from '@pluv/io';
-import { MaybePromise, Maybe, InferIOAuthorizeUser, InferIOAuthorize, InferIOAuthorizeRequired } from '@pluv/types';
-import { IncomingMessage as IncomingMessage$1, ServerResponse, Server } from 'node:http';
+import { AbstractWebSocket, WebSocketSerializedState, AbstractEventMap, AbstractListener, AbstractWebSocketConfig, WebSocketRegistrationMode, AbstractPersistance, AbstractPubSub, AbstractPlatform, ConvertWebSocketConfig, AbstractPlatformConfig, PluvServer } from '@pluv/io';
+import { JsonObject, MaybePromise, Maybe, InferIOAuthorizeUser, InferIOAuthorize, InferIOAuthorizeRequired } from '@pluv/types';
+import { IncomingMessage, ServerResponse, Server } from 'node:http';
 import { WebSocket, Server as Server$1 } from 'ws';
 export { WebSocket } from 'ws';
-import { IncomingMessage } from 'http';
 
 type NodeWebSocketConfig = AbstractWebSocketConfig;
-declare class NodeWebSocket extends AbstractWebSocket {
-    webSocket: WebSocket;
+declare class NodeWebSocket extends AbstractWebSocket<WebSocket> {
+    private _sessionId;
+    private _state;
+    set presence(presence: JsonObject | null);
     get readyState(): 0 | 1 | 2 | 3;
+    get sessionId(): string;
+    get state(): WebSocketSerializedState;
     constructor(webSocket: WebSocket, config: NodeWebSocketConfig);
     addEventListener<TType extends keyof AbstractEventMap>(type: TType, handler: AbstractListener<TType>): void;
     close(code?: number | undefined, reason?: string | undefined): void;
-    initialize(): Promise<() => void>;
     send(message: string | ArrayBuffer | ArrayBufferView): void;
     terminate(): void;
 }
 
-type NodePlatformOptions = {
+type NodePlatformConfig = {
+    mode?: WebSocketRegistrationMode;
+} & ({
     persistance?: undefined;
     pubSub?: undefined;
 } | {
     persistance: AbstractPersistance;
     pubSub: AbstractPubSub;
-};
-declare class NodePlatform extends AbstractPlatform<WebSocket, {
-    req: IncomingMessage;
-}> {
-    constructor(options?: NodePlatformOptions);
+});
+declare class NodePlatform extends AbstractPlatform<NodeWebSocket> {
+    readonly _registrationMode: WebSocketRegistrationMode;
+    constructor(config?: NodePlatformConfig);
+    acceptWebSocket(webSocket: NodeWebSocket): Promise<void>;
     convertWebSocket(webSocket: WebSocket, config: ConvertWebSocketConfig): NodeWebSocket;
+    getLastPing(webSocket: NodeWebSocket): number | null;
+    getSerializedState(webSocket: NodeWebSocket): WebSocketSerializedState | null;
+    getSessionId(webSocket: WebSocket): string | null;
+    getWebSockets(): readonly WebSocket[];
+    initialize(config: AbstractPlatformConfig<{}, {}>): this;
     parseData(data: string | ArrayBuffer): Record<string, any>;
     randomUUID(): string;
+    setSerializedState(webSocket: NodeWebSocket, state: WebSocketSerializedState): void;
 }
 
 interface AuthorizeFunctionContext {
-    req: IncomingMessage$1;
+    req: IncomingMessage;
     res: ServerResponse;
     roomId: string;
 }
@@ -48,11 +58,11 @@ type CreatePluvHandlerConfig<TPluvServer extends PluvServer<NodePlatform, any, a
 } : {
     authorize?: undefined;
 });
-type RequestHandler = (req: IncomingMessage$1, res: ServerResponse, next?: () => void) => void;
+type RequestHandler = (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
 interface WebSocketHandlerResult {
     matched: boolean;
 }
-type WebSocketHandler = (ws: WebSocket, req: IncomingMessage$1) => Promise<WebSocketHandlerResult>;
+type WebSocketHandler = (ws: WebSocket, req: IncomingMessage) => Promise<WebSocketHandlerResult>;
 interface CreatePluvHandlerResult {
     createWsServer: () => Server$1;
     handler: RequestHandler;
@@ -60,6 +70,6 @@ interface CreatePluvHandlerResult {
 }
 declare const createPluvHandler: <TPluvServer extends PluvServer<NodePlatform, any, any, any>>(config: CreatePluvHandlerConfig<TPluvServer>) => CreatePluvHandlerResult;
 
-declare const platformNode: (options?: NodePlatformOptions) => NodePlatform;
+declare const platformNode: (config?: NodePlatformConfig) => NodePlatform;
 
-export { type AuthorizeFunction, type AuthorizeFunctionContext, type CreatePluvHandlerConfig, type NodePlatformOptions, createPluvHandler, platformNode };
+export { type AuthorizeFunction, type AuthorizeFunctionContext, type CreatePluvHandlerConfig, type NodePlatformConfig, createPluvHandler, platformNode };

package/dist/index.js

@@ -3,8 +3,22 @@ var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -75,6 +89,9 @@ var handle = (ws) => ({
 });
 var createPluvHandler = (config) => {
   const { authorize, endpoint = "/api/pluv", io, server } = config;
+  if (io._registrationMode === "detached") {
+    throw new Error("Cannot use createPluvHandler in detached mode for Node.js");
+  }
   const wsServer = new import_ws.Server({ server });
   const wsHandler = (ws, req) => __async(void 0, null, function* () {
     var _a;
@@ -94,8 +111,8 @@ var createPluvHandler = (config) => {
     if (!roomId) return onError.invalidRoom();
     const token = ((_a = parsed.query) == null ? void 0 : _a.token) || void 0;
     if (Array.isArray(token)) return onError.invalidToken();
-    const room = io.getRoom(roomId, { req });
-    yield room.register(ws, { req, token });
+    const room = io.getRoom(roomId);
+    yield room.register(ws, { token });
     return { matched: true };
   });
   const createWsServer = () => {
@@ -123,11 +140,7 @@ var createPluvHandler = (config) => {
     try {
       const user = yield authorize({ res, req, roomId });
       if (!user) throw new Error();
-      const token = yield io.createToken({
-        req,
-        room: roomId,
-        user
-      });
+      const token = yield io.createToken({ room: roomId, user });
       res.writeHead(200, { "Content-Type": "text/plain" });
       return res.end(token);
     } catch (err) {
@@ -144,49 +157,53 @@ var createPluvHandler = (config) => {
 
 // src/NodePlatform.ts
 var import_io2 = require("@pluv/io");
-var import_crypto = __toESM(require("crypto"));
-var import_util = require("util");
+var import_node_crypto2 = __toESM(require("crypto"));
+var import_node_util = require("util");
 
 // src/NodeWebSocket.ts
 var import_io = require("@pluv/io");
+var import_node_crypto = __toESM(require("crypto"));
 var NodeWebSocket = class extends import_io.AbstractWebSocket {
+  set presence(presence) {
+    this._state.presence = presence;
+  }
   get readyState() {
     return this.webSocket.readyState;
   }
+  get sessionId() {
+    return this._sessionId;
+  }
+  get state() {
+    return this._state;
+  }
   constructor(webSocket, config) {
-    const { room, sessionId, userId } = config;
-    super({ room, sessionId, userId });
-    this.webSocket = webSocket;
+    const { room } = config;
+    super(webSocket, config);
+    this._sessionId = import_node_crypto.default.randomUUID();
+    this._state = {
+      presence: null,
+      quit: false,
+      room,
+      timers: { ping: (/* @__PURE__ */ new Date()).getTime() }
+    };
   }
   addEventListener(type, handler) {
     switch (type) {
       case "close":
-        this.webSocket.on("close", (code, reason) => __async(this, null, function* () {
-          yield Promise.resolve(
-            handler({
-              code,
-              reason: reason.toString("utf-8")
-            })
-          );
+        this.webSocket.on("close", (code, buffer) => __async(this, null, function* () {
+          const reason = buffer.toString("utf-8");
+          yield Promise.resolve(handler({ code, reason }));
         }));
         return;
       case "error":
         this.webSocket.on("error", (error) => __async(this, null, function* () {
-          yield Promise.resolve(
-            handler({
-              error,
-              message: error.message
-            })
-          );
+          const message = error.message;
+          yield Promise.resolve(handler({ error, message }));
         }));
         return;
       case "message":
         this.webSocket.on("message", (data) => __async(this, null, function* () {
-          yield Promise.resolve(
-            handler({
-              data
-            })
-          );
+          yield Promise.resolve(handler({ data }));
         }));
         return;
       default:
@@ -197,11 +214,6 @@ var NodeWebSocket = class extends import_io.AbstractWebSocket {
     if (!canClose) return;
     this.webSocket.close(code, reason);
   }
-  initialize() {
-    return __async(this, null, function* () {
-      return Promise.resolve(() => void 0);
-    });
-  }
   send(message) {
     if (this.readyState !== this.OPEN) return;
     this.webSocket.send(message, (error) => {
@@ -214,27 +226,54 @@ var NodeWebSocket = class extends import_io.AbstractWebSocket {
 };
 
 // src/NodePlatform.ts
-var NodePlatform = class extends import_io2.AbstractPlatform {
-  constructor(options = {}) {
-    const { persistance, pubSub } = options;
+var NodePlatform = class _NodePlatform extends import_io2.AbstractPlatform {
+  constructor(config = {}) {
+    const { mode = "attached", persistance, pubSub } = config;
     super(persistance && pubSub ? { persistance, pubSub } : {});
+    this._registrationMode = mode;
+  }
+  acceptWebSocket(webSocket) {
+    return Promise.resolve(void 0);
   }
   convertWebSocket(webSocket, config) {
-    return new NodeWebSocket(webSocket, config);
+    const { room } = config;
+    return new NodeWebSocket(webSocket, { persistance: this.persistance, room });
+  }
+  getLastPing(webSocket) {
+    return null;
+  }
+  getSerializedState(webSocket) {
+    return null;
+  }
+  getSessionId(webSocket) {
+    return null;
+  }
+  getWebSockets() {
+    return [];
+  }
+  initialize(config) {
+    return new _NodePlatform(__spreadValues({
+      mode: this._registrationMode,
+      persistance: this.persistance,
+      pubSub: this.pubSub
+    }, config))._initialize();
   }
   parseData(data) {
     if (typeof data === "string") return JSON.parse(data);
-    const decoder = new import_util.TextDecoder("utf8");
+    const decoder = new import_node_util.TextDecoder("utf8");
     return JSON.parse(decoder.decode(data));
   }
   randomUUID() {
-    return import_crypto.default.randomUUID();
+    return import_node_crypto2.default.randomUUID();
+  }
+  setSerializedState(webSocket, state) {
+    return;
   }
 };
 
 // src/platformNode.ts
-var platformNode = (options = {}) => {
-  return new NodePlatform(options);
+var platformNode = (config = {}) => {
+  return new NodePlatform(config);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.mjs

@@ -1,3 +1,19 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -39,6 +55,9 @@ var handle = (ws) => ({
 });
 var createPluvHandler = (config) => {
   const { authorize, endpoint = "/api/pluv", io, server } = config;
+  if (io._registrationMode === "detached") {
+    throw new Error("Cannot use createPluvHandler in detached mode for Node.js");
+  }
   const wsServer = new WsServer({ server });
   const wsHandler = (ws, req) => __async(void 0, null, function* () {
     var _a;
@@ -58,8 +77,8 @@ var createPluvHandler = (config) => {
     if (!roomId) return onError.invalidRoom();
     const token = ((_a = parsed.query) == null ? void 0 : _a.token) || void 0;
     if (Array.isArray(token)) return onError.invalidToken();
-    const room = io.getRoom(roomId, { req });
-    yield room.register(ws, { req, token });
+    const room = io.getRoom(roomId);
+    yield room.register(ws, { token });
     return { matched: true };
   });
   const createWsServer = () => {
@@ -87,11 +106,7 @@ var createPluvHandler = (config) => {
     try {
       const user = yield authorize({ res, req, roomId });
       if (!user) throw new Error();
-      const token = yield io.createToken({
-        req,
-        room: roomId,
-        user
-      });
+      const token = yield io.createToken({ room: roomId, user });
       res.writeHead(200, { "Content-Type": "text/plain" });
       return res.end(token);
     } catch (err) {
@@ -108,49 +123,53 @@ var createPluvHandler = (config) => {
 
 // src/NodePlatform.ts
 import { AbstractPlatform } from "@pluv/io";
-import crypto from "crypto";
+import crypto2 from "crypto";
 import { TextDecoder } from "util";
 
 // src/NodeWebSocket.ts
 import { AbstractWebSocket } from "@pluv/io";
+import crypto from "crypto";
 var NodeWebSocket = class extends AbstractWebSocket {
+  set presence(presence) {
+    this._state.presence = presence;
+  }
   get readyState() {
     return this.webSocket.readyState;
   }
+  get sessionId() {
+    return this._sessionId;
+  }
+  get state() {
+    return this._state;
+  }
   constructor(webSocket, config) {
-    const { room, sessionId, userId } = config;
-    super({ room, sessionId, userId });
-    this.webSocket = webSocket;
+    const { room } = config;
+    super(webSocket, config);
+    this._sessionId = crypto.randomUUID();
+    this._state = {
+      presence: null,
+      quit: false,
+      room,
+      timers: { ping: (/* @__PURE__ */ new Date()).getTime() }
+    };
   }
   addEventListener(type, handler) {
     switch (type) {
       case "close":
-        this.webSocket.on("close", (code, reason) => __async(this, null, function* () {
-          yield Promise.resolve(
-            handler({
-              code,
-              reason: reason.toString("utf-8")
-            })
-          );
+        this.webSocket.on("close", (code, buffer) => __async(this, null, function* () {
+          const reason = buffer.toString("utf-8");
+          yield Promise.resolve(handler({ code, reason }));
         }));
         return;
       case "error":
         this.webSocket.on("error", (error) => __async(this, null, function* () {
-          yield Promise.resolve(
-            handler({
-              error,
-              message: error.message
-            })
-          );
+          const message = error.message;
+          yield Promise.resolve(handler({ error, message }));
         }));
         return;
       case "message":
         this.webSocket.on("message", (data) => __async(this, null, function* () {
-          yield Promise.resolve(
-            handler({
-              data
-            })
-          );
+          yield Promise.resolve(handler({ data }));
         }));
         return;
       default:
@@ -161,11 +180,6 @@ var NodeWebSocket = class extends AbstractWebSocket {
     if (!canClose) return;
     this.webSocket.close(code, reason);
   }
-  initialize() {
-    return __async(this, null, function* () {
-      return Promise.resolve(() => void 0);
-    });
-  }
   send(message) {
     if (this.readyState !== this.OPEN) return;
     this.webSocket.send(message, (error) => {
@@ -178,13 +192,37 @@ var NodeWebSocket = class extends AbstractWebSocket {
 };
 
 // src/NodePlatform.ts
-var NodePlatform = class extends AbstractPlatform {
-  constructor(options = {}) {
-    const { persistance, pubSub } = options;
+var NodePlatform = class _NodePlatform extends AbstractPlatform {
+  constructor(config = {}) {
+    const { mode = "attached", persistance, pubSub } = config;
     super(persistance && pubSub ? { persistance, pubSub } : {});
+    this._registrationMode = mode;
+  }
+  acceptWebSocket(webSocket) {
+    return Promise.resolve(void 0);
   }
   convertWebSocket(webSocket, config) {
-    return new NodeWebSocket(webSocket, config);
+    const { room } = config;
+    return new NodeWebSocket(webSocket, { persistance: this.persistance, room });
+  }
+  getLastPing(webSocket) {
+    return null;
+  }
+  getSerializedState(webSocket) {
+    return null;
+  }
+  getSessionId(webSocket) {
+    return null;
+  }
+  getWebSockets() {
+    return [];
+  }
+  initialize(config) {
+    return new _NodePlatform(__spreadValues({
+      mode: this._registrationMode,
+      persistance: this.persistance,
+      pubSub: this.pubSub
+    }, config))._initialize();
   }
   parseData(data) {
     if (typeof data === "string") return JSON.parse(data);
@@ -192,13 +230,16 @@ var NodePlatform = class extends AbstractPlatform {
     return JSON.parse(decoder.decode(data));
   }
   randomUUID() {
-    return crypto.randomUUID();
+    return crypto2.randomUUID();
+  }
+  setSerializedState(webSocket, state) {
+    return;
   }
 };
 
 // src/platformNode.ts
-var platformNode = (options = {}) => {
-  return new NodePlatform(options);
+var platformNode = (config = {}) => {
+  return new NodePlatform(config);
 };
 export {
   createPluvHandler,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/platform-node",
-  "version": "0.20.0",
+  "version": "0.21.1",
   "description": "@pluv/io adapter for node.js",
   "author": "leedavidcs",
   "license": "MIT",
@@ -17,19 +17,19 @@
     "access": "public"
   },
   "dependencies": {
-    "@types/node": "^20.14.9",
-    "@types/ws": "^8.5.10",
-    "path-to-regexp": "^7.0.0",
-    "@pluv/io": "^0.20.0",
-    "@pluv/types": "^0.20.0"
+    "@types/node": "^22.2.0",
+    "@types/ws": "^8.5.12",
+    "path-to-regexp": "^7.1.0",
+    "@pluv/io": "^0.21.1",
+    "@pluv/types": "^0.21.1"
   },
   "devDependencies": {
     "eslint": "^8.57.0",
-    "tsup": "^8.1.0",
-    "typescript": "^5.4.5",
+    "tsup": "^8.2.4",
+    "typescript": "^5.5.4",
     "ws": "^8.18.0",
-    "@pluv/tsconfig": "^0.20.0",
-    "eslint-config-pluv": "^0.20.0"
+    "@pluv/tsconfig": "^0.21.1",
+    "eslint-config-pluv": "^0.21.1"
   },
   "peerDependencies": {
     "ws": "^8.0.0"

package/src/NodePlatform.ts

@@ -1,27 +1,66 @@
-import type { AbstractPersistance, ConvertWebSocketConfig } from "@pluv/io";
-import { AbstractPlatform, AbstractPubSub } from "@pluv/io";
-import crypto from "crypto";
-import { IncomingMessage } from "http";
-import { TextDecoder } from "util";
+import type {
+    AbstractPersistance,
+    AbstractPlatformConfig,
+    AbstractPubSub,
+    ConvertWebSocketConfig,
+    WebSocketRegistrationMode,
+    WebSocketSerializedState,
+} from "@pluv/io";
+import { AbstractPlatform } from "@pluv/io";
+import crypto from "node:crypto";
+import { TextDecoder } from "node:util";
 import type { WebSocket } from "ws";
 import { NodeWebSocket } from "./NodeWebSocket";
 
-export type NodePlatformOptions =
+export type NodePlatformConfig = { mode?: WebSocketRegistrationMode } & (
     | { persistance?: undefined; pubSub?: undefined }
-    | {
-          persistance: AbstractPersistance;
-          pubSub: AbstractPubSub;
-      };
+    | { persistance: AbstractPersistance; pubSub: AbstractPubSub }
+);
 
-export class NodePlatform extends AbstractPlatform<WebSocket, { req: IncomingMessage }> {
-    constructor(options: NodePlatformOptions = {}) {
-        const { persistance, pubSub } = options;
+export class NodePlatform extends AbstractPlatform<NodeWebSocket> {
+    readonly _registrationMode: WebSocketRegistrationMode;
+
+    constructor(config: NodePlatformConfig = {}) {
+        const { mode = "attached", persistance, pubSub } = config;
 
         super(persistance && pubSub ? { persistance, pubSub } : {});
+
+        this._registrationMode = mode;
+    }
+
+    public acceptWebSocket(webSocket: NodeWebSocket): Promise<void> {
+        return Promise.resolve(undefined);
     }
 
     public convertWebSocket(webSocket: WebSocket, config: ConvertWebSocketConfig): NodeWebSocket {
-        return new NodeWebSocket(webSocket, config);
+        const { room } = config;
+
+        return new NodeWebSocket(webSocket, { persistance: this.persistance, room });
+    }
+
+    public getLastPing(webSocket: NodeWebSocket): number | null {
+        return null;
+    }
+
+    public getSerializedState(webSocket: NodeWebSocket): WebSocketSerializedState | null {
+        return null;
+    }
+
+    public getSessionId(webSocket: WebSocket): string | null {
+        return null;
+    }
+
+    public getWebSockets(): readonly WebSocket[] {
+        return [];
+    }
+
+    public initialize(config: AbstractPlatformConfig<{}, {}>): this {
+        return new NodePlatform({
+            mode: this._registrationMode,
+            persistance: this.persistance,
+            pubSub: this.pubSub,
+            ...config,
+        } as NodePlatformConfig)._initialize() as this;
     }
 
     public parseData(data: string | ArrayBuffer): Record<string, any> {
@@ -35,4 +74,8 @@ export class NodePlatform extends AbstractPlatform<WebSocket, { req: IncomingMes
     public randomUUID(): string {
         return crypto.randomUUID();
     }
+
+    public setSerializedState(webSocket: NodeWebSocket, state: WebSocketSerializedState): void {
+        return;
+    }
 }

package/src/NodeWebSocket.ts

@@ -5,8 +5,11 @@ import type {
     AbstractListener,
     AbstractMessageEvent,
     AbstractWebSocketConfig,
+    WebSocketSerializedState,
 } from "@pluv/io";
 import { AbstractWebSocket } from "@pluv/io";
+import type { JsonObject } from "@pluv/types";
+import crypto from "node:crypto";
 import type { WebSocket } from "ws";
 
 export interface NodeWebSocketEventMap {
@@ -17,52 +20,61 @@ export interface NodeWebSocketEventMap {
 
 export type NodeWebSocketConfig = AbstractWebSocketConfig;
 
-export class NodeWebSocket extends AbstractWebSocket {
-    public webSocket: WebSocket;
+export class NodeWebSocket extends AbstractWebSocket<WebSocket> {
+    private _sessionId: string;
+    private _state: WebSocketSerializedState;
+
+    public set presence(presence: JsonObject | null) {
+        this._state.presence = presence;
+    }
 
     public get readyState(): 0 | 1 | 2 | 3 {
         return this.webSocket.readyState;
     }
 
+    public get sessionId(): string {
+        return this._sessionId;
+    }
+
+    public get state(): WebSocketSerializedState {
+        return this._state;
+    }
+
     constructor(webSocket: WebSocket, config: NodeWebSocketConfig) {
-        const { room, sessionId, userId } = config;
+        const { room } = config;
 
-        super({ room, sessionId, userId });
+        super(webSocket, config);
 
-        this.webSocket = webSocket;
+        this._sessionId = crypto.randomUUID();
+        this._state = {
+            presence: null,
+            quit: false,
+            room,
+            timers: { ping: new Date().getTime() },
+        };
     }
 
     public addEventListener<TType extends keyof AbstractEventMap>(type: TType, handler: AbstractListener<TType>): void {
         switch (type) {
             case "close":
-                this.webSocket.on("close", async (code, reason) => {
-                    await Promise.resolve(
-                        (handler as AbstractListener<"close">)({
-                            code,
-                            reason: reason.toString("utf-8"),
-                        }),
-                    );
+                this.webSocket.on("close", async (code, buffer) => {
+                    const reason = buffer.toString("utf-8");
+
+                    await Promise.resolve((handler as AbstractListener<"close">)({ code, reason }));
                 });
 
                 return;
             case "error":
                 this.webSocket.on("error", async (error) => {
-                    await Promise.resolve(
-                        (handler as AbstractListener<"error">)({
-                            error,
-                            message: error.message,
-                        }),
-                    );
+                    const message = error.message;
+
+                    await Promise.resolve((handler as AbstractListener<"error">)({ error, message }));
                 });
 
                 return;
             case "message":
                 this.webSocket.on("message", async (data) => {
-                    await Promise.resolve(
-                        (handler as AbstractListener<"message">)({
-                            data,
-                        }),
-                    );
+                    await Promise.resolve((handler as AbstractListener<"message">)({ data }));
                 });
 
                 return;
@@ -78,10 +90,6 @@ export class NodeWebSocket extends AbstractWebSocket {
         this.webSocket.close(code, reason);
     }
 
-    public async initialize(): Promise<() => void> {
-        return Promise.resolve(() => undefined);
-    }
-
     public send(message: string | ArrayBuffer | ArrayBufferView): void {
         if (this.readyState !== this.OPEN) return;
 

package/src/createPluvHandler.ts

@@ -67,6 +67,10 @@ export const createPluvHandler = <TPluvServer extends PluvServer<NodePlatform, a
 ): CreatePluvHandlerResult => {
     const { authorize, endpoint = "/api/pluv", io, server } = config;
 
+    if (io._registrationMode === "detached") {
+        throw new Error("Cannot use createPluvHandler in detached mode for Node.js");
+    }
+
     const wsServer = new WsServer({ server });
 
     const wsHandler = async (ws: WebSocket, req: IncomingMessage): Promise<WebSocketHandlerResult> => {
@@ -97,9 +101,9 @@ export const createPluvHandler = <TPluvServer extends PluvServer<NodePlatform, a
 
         if (Array.isArray(token)) return onError.invalidToken();
 
-        const room = io.getRoom(roomId, { req });
+        const room = io.getRoom(roomId);
 
-        await room.register(ws, { req, token });
+        await room.register(ws, { token });
 
         return { matched: true };
     };
@@ -144,11 +148,7 @@ export const createPluvHandler = <TPluvServer extends PluvServer<NodePlatform, a
 
             if (!user) throw new Error();
 
-            const token = await io.createToken({
-                req,
-                room: roomId,
-                user,
-            });
+            const token = await io.createToken({ room: roomId, user });
 
             res.writeHead(200, { "Content-Type": "text/plain" });
             return res.end(token);

package/src/index.ts

@@ -1,5 +1,5 @@
 export type { AuthorizeFunction, AuthorizeFunctionContext, CreatePluvHandlerConfig } from "./createPluvHandler";
 export { createPluvHandler } from "./createPluvHandler";
 export type { WebSocket } from "ws";
-export type { NodePlatformOptions } from "./NodePlatform";
+export type { NodePlatformConfig } from "./NodePlatform";
 export { platformNode } from "./platformNode";

package/src/platformNode.ts

@@ -1,6 +1,6 @@
-import type { NodePlatformOptions } from "./NodePlatform";
+import type { NodePlatformConfig } from "./NodePlatform";
 import { NodePlatform } from "./NodePlatform";
 
-export const platformNode = (options: NodePlatformOptions = {}): NodePlatform => {
-    return new NodePlatform(options);
+export const platformNode = (config: NodePlatformConfig = {}): NodePlatform => {
+    return new NodePlatform(config);
 };