@pluv/platform-pluv 0.33.0 → 0.34.0

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;
+};

package/src/PluvIO.ts

@@ -1,221 +0,0 @@
-import type { GetInitialStorageFn, JWTEncodeParams } from "@pluv/io";
-import type { BaseUser, IOLike, InputZodLike } from "@pluv/types";
-import { Hono } from "hono";
-import { handle } from "hono/vercel";
-import { SIGNATURE_HEADER } from "./constants";
-import type { PluvPlatform } from "./PluvPlatform";
-import { ZodEvent } from "./schemas";
-import { verifyWebhook } from "./shared";
-
-interface PluvAuthorize<TUser extends BaseUser> {
-    required: true;
-    secret: string;
-    user: InputZodLike<TUser>;
-}
-
-interface PluvIOEndpoints {
-    createToken: string;
-}
-
-type RoomDeletedMessageEventData = {
-    encodedState: string | null;
-    room: string;
-};
-
-type UserConnectedEventData<TUser extends BaseUser> = {
-    encodedState: string | null;
-    room: string;
-    user: TUser;
-};
-
-type UserDisconnectedEventData<TUser extends BaseUser> = {
-    encodedState: string | null;
-    room: string;
-    user: TUser;
-};
-
-type PluvIOListeners<TUser extends BaseUser> = {
-    getInitialStorage?: GetInitialStorageFn<{}>;
-    onRoomDeleted: (event: RoomDeletedMessageEventData) => void;
-    onUserConnected: (event: UserConnectedEventData<TUser>) => void;
-    onUserDisconnected: (event: UserDisconnectedEventData<TUser>) => void;
-};
-
-type WebhooksConfig<TUser extends BaseUser> =
-    | ({ webhookSecret?: undefined } & { [P in keyof PluvIOListeners<TUser>]?: undefined })
-    | ({ webhookSecret: string } & Partial<PluvIOListeners<TUser>>);
-
-export type PluvIOConfig<TUser extends BaseUser> = WebhooksConfig<TUser> & {
-    /**
-     * @ignore
-     * @readonly
-     * @deprecated Internal use only. Changes to this will never be marked as breaking.
-     */
-    _defs?: {
-        endpoints?: PluvIOEndpoints;
-    };
-    authorize: {
-        user: InputZodLike<TUser>;
-    };
-    basePath: string;
-    publicKey: string;
-    secretKey: string;
-};
-
-export class PluvIO<TUser extends BaseUser> implements IOLike<PluvAuthorize<TUser>, {}> {
-    private readonly _authorize: PluvAuthorize<TUser>;
-    private readonly _basePath: string;
-    private readonly _endpoints: PluvIOEndpoints;
-    private readonly _getInitialStorage?: GetInitialStorageFn<{}>;
-    private readonly _listeners: PluvIOListeners<TUser>;
-    private readonly _publicKey: string;
-    private readonly _secretKey: string;
-    private readonly _webhookSecret?: string;
-
-    /**
-     * @ignore
-     * @readonly
-     * @deprecated Internal use only. Changes to this will never be marked as breaking.
-     */
-    public get _defs() {
-        return {
-            authorize: this._authorize,
-            context: {},
-            events: {},
-            get platform() {
-                throw new Error("Invalid platform reference");
-            },
-        };
-    }
-
-    public get fetch() {
-        const app = new Hono().basePath(this._basePath).route("/", this._webhooks);
-
-        return app.fetch;
-    }
-
-    public get handler() {
-        const app = new Hono().basePath(this._basePath).route("/", this._webhooks);
-
-        return handle(app);
-    }
-
-    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 TUser;
-
-                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 TUser;
-
-                await Promise.resolve(this._listeners.onUserDisconnected({ encodedState, room, user }));
-            }
-            default:
-                return c.json({ data: { ok: true } }, 200);
-        }
-    });
-
-    constructor(options: PluvIOConfig<TUser>) {
-        const {
-            _defs,
-            authorize,
-            basePath,
-            getInitialStorage,
-            onRoomDeleted,
-            onUserConnected,
-            onUserDisconnected,
-            publicKey,
-            secretKey,
-            webhookSecret,
-        } = options;
-
-        this._authorize = {
-            required: true,
-            secret: "",
-            user: authorize.user,
-        };
-        this._basePath = basePath;
-        this._endpoints = {
-            createToken: "https://pluv.io/api/room/token",
-            ..._defs?.endpoints,
-        };
-        this._getInitialStorage = getInitialStorage;
-        this._listeners = {
-            onRoomDeleted: (event) => onRoomDeleted?.(event),
-            onUserConnected: (event) => onUserConnected?.(event),
-            onUserDisconnected: (event) => onUserDisconnected?.(event),
-        };
-        this._publicKey = publicKey;
-        this._secretKey = secretKey;
-        this._webhookSecret = webhookSecret;
-    }
-
-    public async createToken(params: JWTEncodeParams<TUser, PluvPlatform>): 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;
-    }
-}

package/src/createIO.ts

@@ -1,7 +0,0 @@
-import type { BaseUser } from "@pluv/io";
-import type { PluvIOConfig } from "./PluvIO";
-import { PluvIO } from "./PluvIO";
-
-export const createIO = <TUser extends BaseUser>(config: PluvIOConfig<TUser>): PluvIO<TUser> => {
-    return new PluvIO(config);
-};