@pluv/platform-pluv 1.0.0 → 1.0.1

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @pluv/platform-pluv@1.0.0 build /home/runner/work/pluv/pluv/packages/platform-pluv
+> @pluv/platform-pluv@1.0.1 build /home/runner/work/pluv/pluv/packages/platform-pluv
 > tsup src/index.ts --format esm,cjs --dts
 
 CLI Building entry: src/index.ts
@@ -8,11 +8,11 @@
 CLI Target: es6
 ESM Build start
 CJS Build start
-ESM dist/index.mjs 12.12 KB
-ESM ⚡️ Build success in 90ms
-CJS dist/index.js 13.95 KB
-CJS ⚡️ Build success in 91ms
+ESM dist/index.mjs 12.32 KB
+ESM ⚡️ Build success in 78ms
+CJS dist/index.js 14.15 KB
+CJS ⚡️ Build success in 81ms
 DTS Build start
-DTS ⚡️ Build success in 7029ms
+DTS ⚡️ Build success in 6574ms
 DTS dist/index.d.mts 3.67 KB
 DTS dist/index.d.ts  3.67 KB

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @pluv/platform-pluv
 
+## 1.0.1
+
+### Patch Changes
+
+- Updated dependencies [c583be9]
+  - @pluv/io@1.0.1
+  - @pluv/crdt@1.0.1
+  - @pluv/types@1.0.1
+
 ## 1.0.0
 
 ### Major Changes

package/dist/index.js

@@ -160,7 +160,10 @@ var createHmac = (params) => __async(void 0, null, function* () {
   const crypto2 = getCrypto();
   const algorithm = { name: "HMAC", hash: { name: "SHA-256" } };
   const extractable = false;
-  const key = yield crypto2.subtle.importKey("raw", keyBytes, algorithm, extractable, ["sign", "verify"]);
+  const key = yield crypto2.subtle.importKey("raw", keyBytes, algorithm, extractable, [
+    "sign",
+    "verify"
+  ]);
   const payloadBytes = encoder.encode(payload);
   const signature = yield crypto2.subtle.sign("HMAC", key, payloadBytes);
   const hmac = Array.from(new Uint8Array(signature)).map((b) => ("0" + b.toString(16)).slice(-2)).join("");
@@ -289,21 +292,32 @@ var PluvPlatform = class extends import_io.AbstractPlatform {
           case "room-deleted": {
             const room = data.room;
             const encodedState = data.storage;
-            yield Promise.resolve((_e = this._listeners) == null ? void 0 : _e.onRoomDeleted({ context, encodedState, room }));
+            yield Promise.resolve(
+              (_e = this._listeners) == null ? void 0 : _e.onRoomDeleted({ context, encodedState, room })
+            );
             return createSuccessResponse(c, { event, room });
           }
           case "user-connected": {
             const room = data.room;
             const encodedState = data.storage;
             const user = data.user;
-            yield Promise.resolve((_f = this._listeners) == null ? void 0 : _f.onUserConnected({ context, encodedState, room, user }));
+            yield Promise.resolve(
+              (_f = this._listeners) == null ? void 0 : _f.onUserConnected({ context, encodedState, room, user })
+            );
             return createSuccessResponse(c, { event, room });
           }
           case "user-disconnected": {
             const room = data.room;
             const encodedState = data.storage;
             const user = data.user;
-            yield Promise.resolve((_g = this._listeners) == null ? void 0 : _g.onUserDisconnected({ context, encodedState, room, user }));
+            yield Promise.resolve(
+              (_g = this._listeners) == null ? void 0 : _g.onUserDisconnected({
+                context,
+                encodedState,
+                room,
+                user
+              })
+            );
             return createSuccessResponse(c, { event, room });
           }
           default: {
@@ -319,7 +333,9 @@ var PluvPlatform = class extends import_io.AbstractPlatform {
     const { _defs, context, basePath, publicKey, secretKey, webhookSecret } = params;
     this._basePath = basePath;
     this._context = typeof context === "function" ? context(this._roomContext) : context;
-    this._endpoints = (_a = _defs == null ? void 0 : _defs.endpoints) != null ? _a : { createToken: "https://rooms.pluv.io/api/room/token" };
+    this._endpoints = (_a = _defs == null ? void 0 : _defs.endpoints) != null ? _a : {
+      createToken: "https://rooms.pluv.io/api/room/token"
+    };
     this._publicKey = publicKey;
     this._secretKey = secretKey;
     this._webhookSecret = webhookSecret;
@@ -357,9 +373,12 @@ var PluvPlatform = class extends import_io.AbstractPlatform {
     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)
+      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`");
     this._authorize = config.authorize;
     this._getInitialStorage = config.getInitialStorage;
     this._listeners = {

package/dist/index.mjs

@@ -130,7 +130,10 @@ var createHmac = (params) => __async(void 0, null, function* () {
   const crypto2 = getCrypto();
   const algorithm = { name: "HMAC", hash: { name: "SHA-256" } };
   const extractable = false;
-  const key = yield crypto2.subtle.importKey("raw", keyBytes, algorithm, extractable, ["sign", "verify"]);
+  const key = yield crypto2.subtle.importKey("raw", keyBytes, algorithm, extractable, [
+    "sign",
+    "verify"
+  ]);
   const payloadBytes = encoder.encode(payload);
   const signature = yield crypto2.subtle.sign("HMAC", key, payloadBytes);
   const hmac = Array.from(new Uint8Array(signature)).map((b) => ("0" + b.toString(16)).slice(-2)).join("");
@@ -259,21 +262,32 @@ var PluvPlatform = class extends AbstractPlatform {
           case "room-deleted": {
             const room = data.room;
             const encodedState = data.storage;
-            yield Promise.resolve((_e = this._listeners) == null ? void 0 : _e.onRoomDeleted({ context, encodedState, room }));
+            yield Promise.resolve(
+              (_e = this._listeners) == null ? void 0 : _e.onRoomDeleted({ context, encodedState, room })
+            );
             return createSuccessResponse(c, { event, room });
           }
           case "user-connected": {
             const room = data.room;
             const encodedState = data.storage;
             const user = data.user;
-            yield Promise.resolve((_f = this._listeners) == null ? void 0 : _f.onUserConnected({ context, encodedState, room, user }));
+            yield Promise.resolve(
+              (_f = this._listeners) == null ? void 0 : _f.onUserConnected({ context, encodedState, room, user })
+            );
             return createSuccessResponse(c, { event, room });
           }
           case "user-disconnected": {
             const room = data.room;
             const encodedState = data.storage;
             const user = data.user;
-            yield Promise.resolve((_g = this._listeners) == null ? void 0 : _g.onUserDisconnected({ context, encodedState, room, user }));
+            yield Promise.resolve(
+              (_g = this._listeners) == null ? void 0 : _g.onUserDisconnected({
+                context,
+                encodedState,
+                room,
+                user
+              })
+            );
             return createSuccessResponse(c, { event, room });
           }
           default: {
@@ -289,7 +303,9 @@ var PluvPlatform = class extends AbstractPlatform {
     const { _defs, context, basePath, publicKey, secretKey, webhookSecret } = params;
     this._basePath = basePath;
     this._context = typeof context === "function" ? context(this._roomContext) : context;
-    this._endpoints = (_a = _defs == null ? void 0 : _defs.endpoints) != null ? _a : { createToken: "https://rooms.pluv.io/api/room/token" };
+    this._endpoints = (_a = _defs == null ? void 0 : _defs.endpoints) != null ? _a : {
+      createToken: "https://rooms.pluv.io/api/room/token"
+    };
     this._publicKey = publicKey;
     this._secretKey = secretKey;
     this._webhookSecret = webhookSecret;
@@ -327,9 +343,12 @@ var PluvPlatform = class extends AbstractPlatform {
     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)
+      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`");
     this._authorize = config.authorize;
     this._getInitialStorage = config.getInitialStorage;
     this._listeners = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/platform-pluv",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "@pluv/io adapter for pluv.io",
   "author": "leedavidcs",
   "license": "MIT",
@@ -21,16 +21,16 @@
     "fast-json-stable-stringify": "^2.1.0",
     "hono": "^4.7.8",
     "zod": "^3.24.3",
-    "@pluv/crdt": "^1.0.0",
-    "@pluv/io": "^1.0.0",
-    "@pluv/types": "^1.0.0"
+    "@pluv/crdt": "^1.0.1",
+    "@pluv/io": "^1.0.1",
+    "@pluv/types": "^1.0.1"
   },
   "devDependencies": {
     "eslint": "^9.25.1",
     "tsup": "^8.4.0",
     "typescript": "^5.8.3",
-    "@pluv/tsconfig": "^1.0.0",
-    "eslint-config-pluv": "^1.0.0"
+    "@pluv/tsconfig": "^1.0.1",
+    "eslint-config-pluv": "^1.0.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/PluvPlatform.ts

@@ -130,7 +130,9 @@ export class PluvPlatform<
 
         this._basePath = basePath;
         this._context = typeof context === "function" ? context(this._roomContext) : context;
-        this._endpoints = _defs?.endpoints ?? { createToken: "https://rooms.pluv.io/api/room/token" };
+        this._endpoints = _defs?.endpoints ?? {
+            createToken: "https://rooms.pluv.io/api/room/token",
+        };
         this._publicKey = publicKey;
         this._secretKey = secretKey;
         this._webhookSecret = webhookSecret;
@@ -175,14 +177,20 @@ export class PluvPlatform<
         throw new Error("Not implemented");
     }
 
-    public setSerializedState(webSocket: AbstractWebSocket, state: WebSocketSerializedState): WebSocketSerializedState {
+    public setSerializedState(
+        webSocket: AbstractWebSocket,
+        state: WebSocketSerializedState,
+    ): WebSocketSerializedState {
         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)
+            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`");
 
         /**
          * !HACK
@@ -199,79 +207,94 @@ export class PluvPlatform<
         };
     }
 
-    private _webhooksRouter = new Hono().basePath("/").post("/", async (c: Context<BlankEnv, "/", BlankInput>) => {
-        const [algorithm, signature] = c.req.header(SIGNATURE_HEADER)?.split("=") ?? [];
-
-        try {
-            if (!this._webhookSecret) throw new HttpError("Unauthorized", 401);
-            if (algorithm !== SIGNATURE_ALGORITHM) throw new HttpError("Unauthorized", 401);
-            if (!signature) throw new HttpError("Unauthorized", 401);
-
-            const [payload, webhookSecret] = await Promise.all([
-                c.req.json(),
-                typeof this._webhookSecret === "string" ? this._webhookSecret : await this._webhookSecret(),
-            ]);
-
-            const verified = await verifyWebhook({
-                payload: stringify(payload),
-                signature,
-                secret: webhookSecret,
-            });
-
-            if (!verified) throw new HttpError("Unauthorized", 401);
-
-            const parsed = ZodEvent.safeParse(payload);
-
-            if (!parsed.success) throw new HttpError("Invalid request", 400);
-
-            const { event, data } = parsed.data;
-            const context = this._context;
-
-            switch (event) {
-                case "initial-storage": {
-                    const room = data.room;
-                    const storage =
-                        typeof room === "string"
-                            ? ((await this._getInitialStorage?.({ context, room })) ?? null)
-                            : null;
-
-                    return createSuccessResponse(c, { event, room, storage });
+    private _webhooksRouter = new Hono()
+        .basePath("/")
+        .post("/", async (c: Context<BlankEnv, "/", BlankInput>) => {
+            const [algorithm, signature] = c.req.header(SIGNATURE_HEADER)?.split("=") ?? [];
+
+            try {
+                if (!this._webhookSecret) throw new HttpError("Unauthorized", 401);
+                if (algorithm !== SIGNATURE_ALGORITHM) throw new HttpError("Unauthorized", 401);
+                if (!signature) throw new HttpError("Unauthorized", 401);
+
+                const [payload, webhookSecret] = await Promise.all([
+                    c.req.json(),
+                    typeof this._webhookSecret === "string"
+                        ? this._webhookSecret
+                        : await this._webhookSecret(),
+                ]);
+
+                const verified = await verifyWebhook({
+                    payload: stringify(payload),
+                    signature,
+                    secret: webhookSecret,
+                });
+
+                if (!verified) throw new HttpError("Unauthorized", 401);
+
+                const parsed = ZodEvent.safeParse(payload);
+
+                if (!parsed.success) throw new HttpError("Invalid request", 400);
+
+                const { event, data } = parsed.data;
+                const context = this._context;
+
+                switch (event) {
+                    case "initial-storage": {
+                        const room = data.room;
+                        const storage =
+                            typeof room === "string"
+                                ? ((await this._getInitialStorage?.({ context, room })) ?? null)
+                                : null;
+
+                        return createSuccessResponse(c, { event, room, storage });
+                    }
+                    case "room-deleted": {
+                        const room = data.room;
+                        const encodedState = data.storage;
+
+                        await Promise.resolve(
+                            this._listeners?.onRoomDeleted({ context, encodedState, room }),
+                        );
+
+                        return createSuccessResponse(c, { event, room });
+                    }
+                    case "user-connected": {
+                        const room = data.room;
+                        const encodedState = data.storage;
+                        const user = data.user as any;
+
+                        await Promise.resolve(
+                            this._listeners?.onUserConnected({ context, encodedState, room, user }),
+                        );
+
+                        return createSuccessResponse(c, { event, room });
+                    }
+                    case "user-disconnected": {
+                        const room = data.room;
+                        const encodedState = data.storage;
+                        const user = data.user as any;
+
+                        await Promise.resolve(
+                            this._listeners?.onUserDisconnected({
+                                context,
+                                encodedState,
+                                room,
+                                user,
+                            }),
+                        );
+
+                        return createSuccessResponse(c, { event, room });
+                    }
+                    default: {
+                        throw new HttpError("Unknown event", 400);
+                    }
                 }
-                case "room-deleted": {
-                    const room = data.room;
-                    const encodedState = data.storage;
-
-                    await Promise.resolve(this._listeners?.onRoomDeleted({ context, encodedState, room }));
+            } catch (error) {
+                const message = error instanceof Error ? error.message : "Unexpected error";
+                const status = error instanceof HttpError ? error.status : 500;
 
-                    return createSuccessResponse(c, { event, room });
-                }
-                case "user-connected": {
-                    const room = data.room;
-                    const encodedState = data.storage;
-                    const user = data.user as any;
-
-                    await Promise.resolve(this._listeners?.onUserConnected({ context, encodedState, room, user }));
-
-                    return createSuccessResponse(c, { event, room });
-                }
-                case "user-disconnected": {
-                    const room = data.room;
-                    const encodedState = data.storage;
-                    const user = data.user as any;
-
-                    await Promise.resolve(this._listeners?.onUserDisconnected({ context, encodedState, room, user }));
-
-                    return createSuccessResponse(c, { event, room });
-                }
-                default: {
-                    throw new HttpError("Unknown event", 400);
-                }
+                return createErrorResponse(c, { message }, status);
             }
-        } catch (error) {
-            const message = error instanceof Error ? error.message : "Unexpected error";
-            const status = error instanceof HttpError ? error.status : 500;
-
-            return createErrorResponse(c, { message }, status);
-        }
-    });
+        });
 }

package/src/platformPluv.ts

@@ -8,13 +8,19 @@ export type PlatformPluvCreateIOParams<
     TUser extends BaseUser = BaseUser,
 > = Id<
     PluvPlatformConfig &
-        Omit<CreateIOParams<PluvPlatform, TContext, TUser>, "authorize" | "context" | "limits" | "platform"> & {
+        Omit<
+            CreateIOParams<PluvPlatform, TContext, TUser>,
+            "authorize" | "context" | "limits" | "platform"
+        > & {
             authorize: PluvIOAuthorize<PluvPlatform, TUser, InferInitContextType<PluvPlatform>>;
             context?: PluvContext<PluvPlatform, TContext>;
         }
 >;
 
-export const platformPluv = <TContext extends Record<string, any> = {}, TUser extends BaseUser = BaseUser>(
+export const platformPluv = <
+    TContext extends Record<string, any> = {},
+    TUser extends BaseUser = BaseUser,
+>(
     config: PlatformPluvCreateIOParams<TContext, TUser>,
 ): CreateIOParams<PluvPlatform<TContext, TUser>, TContext, TUser> => {
     const { authorize, context, crdt, debug } = config;

package/src/shared/createHmac.ts

@@ -24,7 +24,10 @@ export const createHmac = async (params: CreateHmacParams): Promise<CreateHmacRe
     const algorithm: webcrypto.HmacImportParams = { name: "HMAC", hash: { name: "SHA-256" } };
     const extractable = false;
 
-    const key = await crypto.subtle.importKey("raw", keyBytes, algorithm, extractable, ["sign", "verify"]);
+    const key = await crypto.subtle.importKey("raw", keyBytes, algorithm, extractable, [
+        "sign",
+        "verify",
+    ]);
     const payloadBytes = encoder.encode(payload);
 
     const signature = await crypto.subtle.sign("HMAC", key, payloadBytes);

package/src/types.ts

@@ -21,14 +21,25 @@ export interface PluvIOEndpoints {
     createToken: string;
 }
 
-export type PluvIOListeners<TContext extends Record<string, any> = {}, TUser extends BaseUser = BaseUser> = {
+export type PluvIOListeners<
+    TContext extends Record<string, any> = {},
+    TUser extends BaseUser = BaseUser,
+> = {
     getInitialStorage?: GetInitialStorageFn<TContext>;
     onRoomDeleted: (event: IORoomListenerEvent<TContext>) => void;
     onUserConnected: (
-        event: IOUserConnectedEvent<PluvPlatform<TContext>, { user: InputZodLike<TUser> }, TContext>,
+        event: IOUserConnectedEvent<
+            PluvPlatform<TContext>,
+            { user: InputZodLike<TUser> },
+            TContext
+        >,
     ) => void;
     onUserDisconnected: (
-        event: IOUserDisconnectedEvent<PluvPlatform<TContext>, { user: InputZodLike<TUser> }, TContext>,
+        event: IOUserDisconnectedEvent<
+            PluvPlatform<TContext>,
+            { user: InputZodLike<TUser> },
+            TContext
+        >,
     ) => void;
 };