@pluv/platform-pluv 0.32.9 → 0.34.0

package/dist/index.mjs

@@ -41,9 +41,9 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
-// src/PluvIO.ts
+// src/PluvPlatform.ts
+import { AbstractPlatform } from "@pluv/io";
 import { Hono } from "hono";
-import { handle } from "hono/vercel";
 
 // src/constants.ts
 var SIGNATURE_HEADER = "x-pluv-signature-256";
@@ -142,11 +142,50 @@ var verifyWebhook = (params) => __async(void 0, null, function* () {
   return timingSafeEqual(verificationBytes, signatureBytes);
 });
 
-// src/PluvIO.ts
-var PluvIO = class {
-  constructor(options) {
-    this._webhooks = new Hono().basePath("/").post("/event", (c) => __async(this, null, function* () {
-      var _a, _b;
+// src/PluvPlatform.ts
+var PluvPlatform = class extends AbstractPlatform {
+  constructor(params) {
+    super();
+    this._config = {
+      authorize: {
+        required: false,
+        secret: false
+      },
+      handleMode: "fetch",
+      registrationMode: "attached",
+      requireAuth: true,
+      listeners: {
+        onRoomDeleted: true,
+        onRoomMessage: false,
+        onStorageUpdated: false,
+        onUserConnected: true,
+        onUserDisconnected: true
+      }
+    };
+    this._name = "platformPluv";
+    this._createToken = (params) => __async(this, null, function* () {
+      var _a;
+      const parsed = this._authorize.user.parse(params.user);
+      const res = yield fetch(this._endpoints.createToken, {
+        headers: { "content-type": "application/json" },
+        method: "post",
+        body: JSON.stringify({
+          maxAge: (_a = params.maxAge) != null ? _a : null,
+          publicKey: this._publicKey,
+          room: params.room,
+          secretKey: this._secretKey,
+          user: parsed
+        })
+      }).catch(() => null);
+      if (!res || !res.ok || res.status !== 200) {
+        throw new Error("Authorization failed");
+      }
+      const token = yield res.text().catch(() => null);
+      if (typeof token !== "string") throw new Error("Authorization failed");
+      return token;
+    });
+    this._webhooks = new Hono().basePath("/").post("/", (c) => __async(this, null, function* () {
+      var _a, _b, _c, _d, _e;
       const signature = c.req.header(SIGNATURE_HEADER);
       if (!this._webhookSecret || !signature) return c.json({ error: "Unauthorized" }, 401);
       const payload = yield c.req.json();
@@ -168,109 +207,87 @@ var PluvIO = class {
         case "room-deleted": {
           const room = data.room;
           const encodedState = data.storage;
-          yield Promise.resolve(this._listeners.onRoomDeleted({ encodedState, room }));
+          yield Promise.resolve((_c = this._listeners) == null ? void 0 : _c.onRoomDeleted({ encodedState, room }));
           return c.json({ data: { room } }, 200);
         }
         case "user-connected": {
           const room = data.room;
           const encodedState = data.storage;
           const user = data.user;
-          yield Promise.resolve(this._listeners.onUserConnected({ encodedState, room, user }));
+          yield Promise.resolve((_d = this._listeners) == null ? void 0 : _d.onUserConnected({ encodedState, room, user }));
         }
         case "user-disconnected": {
           const room = data.room;
           const encodedState = data.storage;
           const user = data.user;
-          yield Promise.resolve(this._listeners.onUserDisconnected({ encodedState, room, user }));
+          yield Promise.resolve((_e = this._listeners) == null ? void 0 : _e.onUserDisconnected({ encodedState, room, user }));
         }
         default:
           return c.json({ data: { ok: true } }, 200);
       }
     }));
-    const {
-      _defs,
-      authorize,
-      basePath,
-      getInitialStorage,
-      onRoomDeleted,
-      onUserConnected,
-      onUserDisconnected,
-      publicKey,
-      secretKey,
-      webhookSecret
-    } = options;
-    this._authorize = {
-      required: true,
-      secret: "",
-      user: authorize.user
-    };
+    const { _defs, basePath, publicKey, secretKey, webhookSecret } = params;
     this._basePath = basePath;
     this._endpoints = __spreadValues({
       createToken: "https://pluv.io/api/room/token"
     }, _defs == null ? void 0 : _defs.endpoints);
-    this._getInitialStorage = getInitialStorage;
-    this._listeners = {
-      onRoomDeleted: (event) => onRoomDeleted == null ? void 0 : onRoomDeleted(event),
-      onUserConnected: (event) => onUserConnected == null ? void 0 : onUserConnected(event),
-      onUserDisconnected: (event) => onUserDisconnected == null ? void 0 : onUserDisconnected(event)
-    };
     this._publicKey = publicKey;
     this._secretKey = secretKey;
     this._webhookSecret = webhookSecret;
+    this._fetch = new Hono().basePath(this._basePath).route("/", this._webhooks).fetch;
   }
-  /**
-   * @ignore
-   * @readonly
-   * @deprecated Internal use only. Changes to this will never be marked as breaking.
-   */
-  get _defs() {
-    return {
-      authorize: this._authorize,
-      context: {},
-      events: {},
-      get platform() {
-        throw new Error("Invalid platform reference");
-      }
-    };
+  acceptWebSocket(webSocket) {
+    throw new Error("Not implemented");
   }
-  get fetch() {
-    const app = new Hono().basePath(this._basePath).route("/", this._webhooks);
-    return app.fetch;
+  convertWebSocket(webSocket, config) {
+    throw new Error("Not implemented");
   }
-  get handler() {
-    const app = new Hono().basePath(this._basePath).route("/", this._webhooks);
-    return handle(app);
+  getLastPing(webSocket) {
+    throw new Error("Not implemented");
   }
-  createToken(params) {
-    return __async(this, null, function* () {
-      var _a;
-      const parsed = this._authorize.user.parse(params.user);
-      const res = yield fetch(this._endpoints.createToken, {
-        headers: { "content-type": "application/json" },
-        method: "post",
-        body: JSON.stringify({
-          maxAge: (_a = params.maxAge) != null ? _a : null,
-          publicKey: this._publicKey,
-          room: params.room,
-          secretKey: this._secretKey,
-          user: parsed
-        })
-      }).catch(() => null);
-      if (!res || !res.ok || res.status !== 200) {
-        throw new Error("Authorization failed");
-      }
-      const token = yield res.text().catch(() => null);
-      if (typeof token !== "string") throw new Error("Authorization failed");
-      return token;
-    });
+  getSerializedState(webSocket) {
+    throw new Error("Not implemented");
+  }
+  getSessionId(webSocket) {
+    throw new Error("Not implemented");
+  }
+  getWebSockets() {
+    throw new Error("Not implemented");
+  }
+  initialize(config) {
+    throw new Error("Not implemented");
+  }
+  parseData(data) {
+    throw new Error("Not implemented");
+  }
+  randomUUID() {
+    throw new Error("Not implemented");
+  }
+  setSerializedState(webSocket, state) {
+    throw new Error("Not implemented");
+  }
+  validateConfig(config) {
+    if (!config.authorize) throw new Error("Config `authorize` must be provided to `platformPluv`");
+    if (!!config.onRoomMessage) throw new Error("Config `onRoomMessage` is not supported on `platformPluv`");
+    if (!!config.onStorageUpdated) throw new Error("Config `onStorageUpdated` is not supported on `platformPluv`");
+    if (!!config.authorize.required) {
+      throw new Error("Config `authorize.required` is not allowed to be false on `platformPluv`");
+    }
+    this._authorize = config.authorize;
+    this._getInitialStorage = config.getInitialStorage;
+    this._listeners = {
+      onRoomDeleted: config.onRoomDeleted,
+      onUserConnected: config.onUserConnected,
+      onUserDisconnected: config.onUserDisconnected
+    };
   }
 };
 
-// src/createIO.ts
-var createIO = (config) => {
-  return new PluvIO(config);
+// src/platformPluv.ts
+var platformPluv = (config) => {
+  return new PluvPlatform(config);
 };
 export {
-  ZodEvent,
-  createIO
+  PluvPlatform,
+  platformPluv
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/platform-pluv",
-  "version": "0.32.9",
+  "version": "0.34.0",
   "description": "@pluv/io adapter for pluv.io",
   "author": "leedavidcs",
   "license": "MIT",
@@ -17,19 +17,19 @@
     "access": "public"
   },
   "dependencies": {
-    "@types/node": "^22.8.4",
-    "hono": "^4.6.8",
-    "zod": "^3.23.8",
-    "@pluv/crdt": "^0.32.9",
-    "@pluv/io": "^0.32.9",
-    "@pluv/types": "^0.32.9"
+    "@types/node": "^22.10.2",
+    "hono": "^4.6.14",
+    "zod": "^3.24.1",
+    "@pluv/crdt": "^0.34.0",
+    "@pluv/io": "^0.34.0",
+    "@pluv/types": "^0.34.0"
   },
   "devDependencies": {
-    "eslint": "^8.57.0",
+    "eslint": "^8.57.1",
     "tsup": "^8.3.5",
-    "typescript": "^5.6.3",
-    "@pluv/tsconfig": "^0.32.9",
-    "eslint-config-pluv": "^0.32.9"
+    "typescript": "^5.7.2",
+    "@pluv/tsconfig": "^0.34.0",
+    "eslint-config-pluv": "^0.34.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/PluvPlatform.ts

@@ -1,14 +1,125 @@
-import {
-    AbstractPlatform,
+import type {
     AbstractPlatformConfig,
     AbstractWebSocket,
     ConvertWebSocketConfig,
-    WebSocketRegistrationMode,
+    GetInitialStorageFn,
+    JWTEncodeParams,
     WebSocketSerializedState,
 } from "@pluv/io";
+import { AbstractPlatform, authorize } from "@pluv/io";
+import { Hono } from "hono";
+import { SIGNATURE_HEADER } from "./constants";
+import { ZodEvent } from "./schemas";
+import { verifyWebhook } from "./shared";
+import type { PluvIOEndpoints, PluvIOListeners } from "./types";
 
-export class PluvPlatform extends AbstractPlatform {
-    _registrationMode: WebSocketRegistrationMode = "attached";
+export interface PluvPlatformConfig {
+    /**
+     * @ignore
+     * @readonly
+     * @deprecated Internal use only. Changes to this will never be marked as breaking.
+     */
+    _defs?: {
+        endpoints?: PluvIOEndpoints;
+    };
+    basePath: string;
+    publicKey: string;
+    secretKey: string;
+    webhookSecret?: string;
+}
+
+export class PluvPlatform extends AbstractPlatform<
+    any,
+    {},
+    {},
+    {
+        authorize: {
+            required: false;
+            secret: false;
+        };
+        handleMode: "fetch";
+        registrationMode: "attached";
+        requireAuth: true;
+        listeners: {
+            onRoomDeleted: true;
+            onRoomMessage: false;
+            onStorageUpdated: false;
+            onUserConnected: true;
+            onUserDisconnected: true;
+        };
+    }
+> {
+    public readonly _config = {
+        authorize: {
+            required: false as const,
+            secret: false as const,
+        },
+        handleMode: "fetch" as const,
+        registrationMode: "attached" as const,
+        requireAuth: true as const,
+        listeners: {
+            onRoomDeleted: true as const,
+            onRoomMessage: false as const,
+            onStorageUpdated: false as const,
+            onUserConnected: true as const,
+            onUserDisconnected: true as const,
+        },
+    };
+    public readonly _name = "platformPluv";
+
+    private _authorize: any;
+    private readonly _basePath: string;
+    private readonly _endpoints: PluvIOEndpoints;
+    private _getInitialStorage?: GetInitialStorageFn<{}>;
+    private _listeners?: PluvIOListeners;
+    private readonly _publicKey: string;
+    private readonly _secretKey: string;
+    private readonly _webhookSecret?: string;
+
+    public _createToken = async (params: JWTEncodeParams<any, any>): Promise<string> => {
+        const parsed = this._authorize.user.parse(params.user);
+
+        const res = await fetch(this._endpoints.createToken, {
+            headers: { "content-type": "application/json" },
+            method: "post",
+            body: JSON.stringify({
+                maxAge: params.maxAge ?? null,
+                publicKey: this._publicKey,
+                room: params.room,
+                secretKey: this._secretKey,
+                user: parsed,
+            }),
+        }).catch(() => null);
+
+        if (!res || !res.ok || res.status !== 200) {
+            throw new Error("Authorization failed");
+        }
+
+        const token = await res.text().catch(() => null);
+
+        if (typeof token !== "string") throw new Error("Authorization failed");
+
+        return token;
+    };
+
+    constructor(params: PluvPlatformConfig) {
+        super();
+
+        const { _defs, basePath, publicKey, secretKey, webhookSecret } = params;
+
+        this._basePath = basePath;
+        this._endpoints = {
+            createToken: "https://pluv.io/api/room/token",
+            ..._defs?.endpoints,
+        };
+        this._publicKey = publicKey;
+        this._secretKey = secretKey;
+        this._webhookSecret = webhookSecret;
+
+        this._fetch = new Hono().basePath(this._basePath).route("/", this._webhooks).fetch as (
+            req: any,
+        ) => Promise<any>;
+    }
 
     public acceptWebSocket(webSocket: AbstractWebSocket): Promise<void> {
         throw new Error("Not implemented");
@@ -49,4 +160,85 @@ export class PluvPlatform extends AbstractPlatform {
     public setSerializedState(webSocket: AbstractWebSocket, state: WebSocketSerializedState): void {
         throw new Error("Not implemented");
     }
+
+    public validateConfig(config: any): void {
+        if (!config.authorize) throw new Error("Config `authorize` must be provided to `platformPluv`");
+        if (!!config.onRoomMessage) throw new Error("Config `onRoomMessage` is not supported on `platformPluv`");
+        if (!!config.onStorageUpdated) throw new Error("Config `onStorageUpdated` is not supported on `platformPluv`");
+        if (!!config.authorize.required) {
+            throw new Error("Config `authorize.required` is not allowed to be false on `platformPluv`");
+        }
+
+        /**
+         * !HACK
+         * @description Assign these on the validation step, because we know this will happen on the
+         * server constructor internally.
+         * @date December 16, 2024
+         */
+        this._authorize = config.authorize;
+        this._getInitialStorage = config.getInitialStorage;
+        this._listeners = {
+            onRoomDeleted: config.onRoomDeleted,
+            onUserConnected: config.onUserConnected,
+            onUserDisconnected: config.onUserDisconnected,
+        };
+    }
+
+    private _webhooks = new Hono().basePath("/").post("/", async (c) => {
+        const signature = c.req.header(SIGNATURE_HEADER);
+
+        if (!this._webhookSecret || !signature) return c.json({ error: "Unauthorized" }, 401);
+
+        const payload = await c.req.json();
+
+        const verified = await verifyWebhook({
+            payload,
+            signature,
+            secret: this._webhookSecret,
+        });
+
+        if (!verified) return c.json({ error: "Unauthorized" }, 401);
+
+        const parsed = ZodEvent.safeParse(payload);
+
+        if (!parsed.success) return c.json({ data: { ok: true } }, 200);
+
+        const { event, data } = parsed.data;
+
+        switch (event) {
+            case "initial-storage": {
+                const room = data.room;
+                const storage =
+                    typeof room === "string"
+                        ? ((await this._getInitialStorage?.({ context: {}, room })) ?? null)
+                        : null;
+
+                return c.json({ data: { storage } }, 200);
+            }
+            case "room-deleted": {
+                const room = data.room;
+                const encodedState = data.storage;
+
+                await Promise.resolve(this._listeners?.onRoomDeleted({ encodedState, room }));
+
+                return c.json({ data: { room } }, 200);
+            }
+            case "user-connected": {
+                const room = data.room;
+                const encodedState = data.storage;
+                const user = data.user as any;
+
+                await Promise.resolve(this._listeners?.onUserConnected({ encodedState, room, user }));
+            }
+            case "user-disconnected": {
+                const room = data.room;
+                const encodedState = data.storage;
+                const user = data.user as any;
+
+                await Promise.resolve(this._listeners?.onUserDisconnected({ encodedState, room, user }));
+            }
+            default:
+                return c.json({ data: { ok: true } }, 200);
+        }
+    });
 }

package/src/index.ts

@@ -1,4 +1,8 @@
-export { createIO } from "./createIO";
-export type { PluvIO, PluvIOConfig } from "./PluvIO";
-export type { PluvPlatform } from "./PluvPlatform";
-export { ZodEvent } from "./schemas";
+export { platformPluv } from "./platformPluv";
+export { PluvPlatform } from "./PluvPlatform";
+export type {
+    PluvIOEndpoints,
+    RoomDeletedMessageEventData,
+    UserConnectedEventData,
+    UserDisconnectedEventData,
+} from "./types";

package/src/platformPluv.ts

@@ -0,0 +1,6 @@
+import type { PluvPlatformConfig } from "./PluvPlatform";
+import { PluvPlatform } from "./PluvPlatform";
+
+export const platformPluv = (config: PluvPlatformConfig) => {
+    return new PluvPlatform(config);
+};

package/src/types.ts

@@ -0,0 +1,29 @@
+import type { GetInitialStorageFn } from "@pluv/io";
+
+export interface PluvIOEndpoints {
+    createToken: string;
+}
+
+export type RoomDeletedMessageEventData = {
+    encodedState: string | null;
+    room: string;
+};
+
+export type UserConnectedEventData = {
+    encodedState: string | null;
+    room: string;
+    user: any;
+};
+
+export type UserDisconnectedEventData = {
+    encodedState: string | null;
+    room: string;
+    user: any;
+};
+
+export type PluvIOListeners = {
+    getInitialStorage?: GetInitialStorageFn<{}>;
+    onRoomDeleted: (event: RoomDeletedMessageEventData) => void;
+    onUserConnected: (event: UserConnectedEventData) => void;
+    onUserDisconnected: (event: UserDisconnectedEventData) => void;
+};