@pluv/platform-cloudflare 0.1.18 → 0.2.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @pluv/platform-cloudflare@0.1.18 build /home/runner/work/pluv/pluv/packages/platform-cloudflare
+> @pluv/platform-cloudflare@0.2.0 build /home/runner/work/pluv/pluv/packages/platform-cloudflare
 > tsup src/index.ts --format esm,cjs --dts
 
 CLI Building entry: src/index.ts
@@ -8,10 +8,10 @@
 CLI Target: es6
 ESM Build start
 CJS Build start
-ESM dist/index.mjs 1.50 KB
-ESM ⚡️ Build success in 118ms
-CJS dist/index.js 2.52 KB
-CJS ⚡️ Build success in 119ms
+CJS dist/index.js 6.66 KB
+CJS ⚡️ Build success in 72ms
+ESM dist/index.mjs 5.53 KB
+ESM ⚡️ Build success in 81ms
 DTS Build start
-DTS ⚡️ Build success in 4258ms
-DTS dist/index.d.ts 1.03 KB
+DTS ⚡️ Build success in 5105ms
+DTS dist/index.d.ts 2.57 KB

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @pluv/platform-cloudflare
 
+## 0.2.0
+
+### Minor Changes
+
+- 643d5b5: added createPluvHandler to automatically set-up a pluv server with reasonable defaults
+
+### Patch Changes
+
+- b85a232: bumped dependencies
+- fde89cf: added defaults to the client to align it with createPluvClient by default
+- Updated dependencies [b85a232]
+  - @pluv/io@0.4.1
+  - @pluv/types@0.2.0
+
 ## 0.1.18
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { AbstractWebSocket, AbstractEventMap, AbstractListener, AbstractWebSocketConfig, AbstractPlatform } from '@pluv/io';
+import { AbstractWebSocket, AbstractEventMap, AbstractListener, AbstractWebSocketConfig, AbstractPlatform, PluvIO } from '@pluv/io';
+import { MaybePromise, Maybe, InferIOAuthorizeUser, InferIOAuthorize, InferIOAuthorizeRequired } from '@pluv/types';
 
 type CloudflareWebSocketConfig = AbstractWebSocketConfig;
 declare class CloudflareWebSocket extends AbstractWebSocket {
@@ -18,6 +19,31 @@ declare class CloudflarePlatform extends AbstractPlatform<WebSocket> {
     randomUUID(): string;
 }
 
+interface AuthorizeFunctionContext {
+    request: Request<any, CfProperties<any>>;
+    roomId: string;
+}
+type AuthorizeFunction<TPluv extends PluvIO<CloudflarePlatform>> = (ctx: AuthorizeFunctionContext) => MaybePromise<Maybe<InferIOAuthorizeUser<InferIOAuthorize<TPluv>>>>;
+type CreatePluvHandlerConfig<TPluv extends PluvIO<CloudflarePlatform>, TBinding extends string, TEnv extends Record<string, any>> = {
+    binding: TBinding;
+    endpoint?: string;
+    modify?: (request: Request, response: Response, env: TEnv) => MaybePromise<Response>;
+    io: TPluv;
+} & (InferIOAuthorizeRequired<InferIOAuthorize<TPluv>> extends true ? {
+    authorize: AuthorizeFunction<TPluv>;
+} : {
+    authorize?: undefined;
+});
+type PluvHandlerFetch<TEnv extends Record<string, any> = {}> = (request: Request, env: TEnv) => Promise<Response | null>;
+interface CreatePluvHandlerResult<TEnv extends Record<string, any> = {}> {
+    DurableObject: {
+        new (state: DurableObjectState): DurableObject;
+    };
+    fetch: PluvHandlerFetch<TEnv>;
+    handler: ExportedHandler<TEnv>;
+}
+declare const createPluvHandler: <TPluv extends PluvIO<CloudflarePlatform, any, any, any, any, any, any>, TBinding extends string, TEnv extends Record<string, any>>(config: CreatePluvHandlerConfig<TPluv, TBinding, TEnv>) => CreatePluvHandlerResult<TEnv>;
+
 declare const platformCloudflare: () => CloudflarePlatform;
 
-export { platformCloudflare };
+export { AuthorizeFunction, AuthorizeFunctionContext, CreatePluvHandlerConfig, CreatePluvHandlerResult, PluvHandlerFetch, createPluvHandler, platformCloudflare };

package/dist/index.js

@@ -16,14 +16,138 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  createPluvHandler: () => createPluvHandler,
   platformCloudflare: () => platformCloudflare
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/createPluvHandler.ts
+var import_path_to_regexp = require("path-to-regexp");
+var createPluvHandler = (config) => {
+  const { authorize, binding, endpoint = "/api/pluv", modify, io } = config;
+  const DurableObject = class {
+    constructor(state) {
+      this._io = io.getRoom(state.id.toString());
+    }
+    fetch(request) {
+      return __async(this, null, function* () {
+        const isWSRequest = request.headers.get("Upgrade") === "websocket";
+        if (!isWSRequest) {
+          return new Response("Expected websocket", { status: 400 });
+        }
+        const { 0: client, 1: server } = new WebSocketPair();
+        const token = new URL(request.url).searchParams.get("token");
+        yield this._io.register(server, { token });
+        return new Response(null, { status: 101, webSocket: client });
+      });
+    }
+  };
+  const getDurableObjectNamespace = (env) => {
+    const namespace = env[binding];
+    if (!namespace) {
+      throw new Error(`Could not find DurableObject binding: ${binding}`);
+    }
+    return namespace;
+  };
+  const authHandler = (request, env) => __async(void 0, null, function* () {
+    if (!authorize)
+      return null;
+    const { pathname, searchParams } = new URL(request.url);
+    const matcher = (0, import_path_to_regexp.match)(`${endpoint}/authorize`);
+    const matched = matcher(pathname);
+    if (!matched)
+      return null;
+    const roomId = searchParams.get("room");
+    if (!roomId) {
+      return new Response("Not found", {
+        headers: { "Content-Type": "text/plain" },
+        status: 404
+      });
+    }
+    try {
+      const user = yield authorize({ request, roomId });
+      if (!user)
+        throw new Error();
+      const namespace = getDurableObjectNamespace(env);
+      const durableObjectId = namespace.idFromName(roomId);
+      const token = yield io.createToken({
+        room: durableObjectId.toString(),
+        user
+      });
+      return new Response(token, {
+        headers: { "Content-Type": "text/plain" },
+        status: 200
+      });
+    } catch (err) {
+      return new Response(
+        err instanceof Error ? err.message : "Unauthorized",
+        {
+          headers: { "Content-Type": "text/plain" },
+          status: 403
+        }
+      );
+    }
+  });
+  const roomHandler = (request, env) => __async(void 0, null, function* () {
+    const { pathname } = new URL(request.url);
+    const matcher = (0, import_path_to_regexp.match)(`${endpoint}/room/:roomId`);
+    const matched = matcher(pathname);
+    if (!matched)
+      return null;
+    const { roomId } = matched.params;
+    if (!roomId) {
+      return new Response("Not found", {
+        headers: { "Content-Type": "text/plain" },
+        status: 404
+      });
+    }
+    const namespace = getDurableObjectNamespace(env);
+    const durableObjectId = namespace.idFromName(roomId);
+    const room = namespace.get(durableObjectId);
+    return room.fetch(request);
+  });
+  const fetch = (request, env) => __async(void 0, null, function* () {
+    return [authHandler, roomHandler].reduce((promise, current) => {
+      return promise.then((value) => value != null ? value : current(request, env));
+    }, Promise.resolve(null));
+  });
+  const handler = {
+    fetch: (request, env) => __async(void 0, null, function* () {
+      var _a, _b;
+      const response = (_a = yield fetch(request, env)) != null ? _a : new Response("Not Found", {
+        headers: { "Content-Type": "text/plain" },
+        status: 404
+      });
+      return (_b = modify == null ? void 0 : modify(request, response, env)) != null ? _b : response;
+    })
+  };
+  return { fetch, DurableObject, handler };
+};
+
 // src/CloudflarePlatform.ts
 var import_io2 = require("@pluv/io");
 
@@ -85,5 +209,6 @@ var platformCloudflare = () => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  createPluvHandler,
   platformCloudflare
 });

package/dist/index.mjs

@@ -1,3 +1,127 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/createPluvHandler.ts
+import { match } from "path-to-regexp";
+var createPluvHandler = (config) => {
+  const { authorize, binding, endpoint = "/api/pluv", modify, io } = config;
+  const DurableObject = class {
+    constructor(state) {
+      this._io = io.getRoom(state.id.toString());
+    }
+    fetch(request) {
+      return __async(this, null, function* () {
+        const isWSRequest = request.headers.get("Upgrade") === "websocket";
+        if (!isWSRequest) {
+          return new Response("Expected websocket", { status: 400 });
+        }
+        const { 0: client, 1: server } = new WebSocketPair();
+        const token = new URL(request.url).searchParams.get("token");
+        yield this._io.register(server, { token });
+        return new Response(null, { status: 101, webSocket: client });
+      });
+    }
+  };
+  const getDurableObjectNamespace = (env) => {
+    const namespace = env[binding];
+    if (!namespace) {
+      throw new Error(`Could not find DurableObject binding: ${binding}`);
+    }
+    return namespace;
+  };
+  const authHandler = (request, env) => __async(void 0, null, function* () {
+    if (!authorize)
+      return null;
+    const { pathname, searchParams } = new URL(request.url);
+    const matcher = match(`${endpoint}/authorize`);
+    const matched = matcher(pathname);
+    if (!matched)
+      return null;
+    const roomId = searchParams.get("room");
+    if (!roomId) {
+      return new Response("Not found", {
+        headers: { "Content-Type": "text/plain" },
+        status: 404
+      });
+    }
+    try {
+      const user = yield authorize({ request, roomId });
+      if (!user)
+        throw new Error();
+      const namespace = getDurableObjectNamespace(env);
+      const durableObjectId = namespace.idFromName(roomId);
+      const token = yield io.createToken({
+        room: durableObjectId.toString(),
+        user
+      });
+      return new Response(token, {
+        headers: { "Content-Type": "text/plain" },
+        status: 200
+      });
+    } catch (err) {
+      return new Response(
+        err instanceof Error ? err.message : "Unauthorized",
+        {
+          headers: { "Content-Type": "text/plain" },
+          status: 403
+        }
+      );
+    }
+  });
+  const roomHandler = (request, env) => __async(void 0, null, function* () {
+    const { pathname } = new URL(request.url);
+    const matcher = match(`${endpoint}/room/:roomId`);
+    const matched = matcher(pathname);
+    if (!matched)
+      return null;
+    const { roomId } = matched.params;
+    if (!roomId) {
+      return new Response("Not found", {
+        headers: { "Content-Type": "text/plain" },
+        status: 404
+      });
+    }
+    const namespace = getDurableObjectNamespace(env);
+    const durableObjectId = namespace.idFromName(roomId);
+    const room = namespace.get(durableObjectId);
+    return room.fetch(request);
+  });
+  const fetch = (request, env) => __async(void 0, null, function* () {
+    return [authHandler, roomHandler].reduce((promise, current) => {
+      return promise.then((value) => value != null ? value : current(request, env));
+    }, Promise.resolve(null));
+  });
+  const handler = {
+    fetch: (request, env) => __async(void 0, null, function* () {
+      var _a, _b;
+      const response = (_a = yield fetch(request, env)) != null ? _a : new Response("Not Found", {
+        headers: { "Content-Type": "text/plain" },
+        status: 404
+      });
+      return (_b = modify == null ? void 0 : modify(request, response, env)) != null ? _b : response;
+    })
+  };
+  return { fetch, DurableObject, handler };
+};
+
 // src/CloudflarePlatform.ts
 import { AbstractPlatform } from "@pluv/io";
 
@@ -60,5 +184,6 @@ var platformCloudflare = () => {
   return new CloudflarePlatform();
 };
 export {
+  createPluvHandler,
   platformCloudflare
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/platform-cloudflare",
-  "version": "0.1.18",
+  "version": "0.2.0",
   "description": "@pluv/io adapter for cloudflare workers",
   "author": "leedavidcs",
   "license": "MIT",
@@ -17,15 +17,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@pluv/io": "^0.4.0",
+    "path-to-regexp": "^6.2.1",
+    "@pluv/io": "^0.4.1",
     "@pluv/types": "^0.2.0"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20230404.0",
+    "@cloudflare/workers-types": "^4.20230511.0",
     "tsup": "^6.7.0",
     "typescript": "^5.0.4",
     "@pluv/tsconfig": "^0.1.6",
-    "eslint-config-pluv": "^0.1.11"
+    "eslint-config-pluv": "^0.1.12"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/createPluvHandler.ts

@@ -0,0 +1,184 @@
+import { IORoom, PluvIO } from "@pluv/io";
+import {
+    InferIOAuthorize,
+    InferIOAuthorizeRequired,
+    InferIOAuthorizeUser,
+    Maybe,
+    MaybePromise,
+} from "@pluv/types";
+import { match } from "path-to-regexp";
+import { CloudflarePlatform } from "./CloudflarePlatform";
+
+export interface AuthorizeFunctionContext {
+    request: Request<any, CfProperties<any>>;
+    roomId: string;
+}
+export type AuthorizeFunction<TPluv extends PluvIO<CloudflarePlatform>> = (
+    ctx: AuthorizeFunctionContext
+) => MaybePromise<Maybe<InferIOAuthorizeUser<InferIOAuthorize<TPluv>>>>;
+
+export type CreatePluvHandlerConfig<
+    TPluv extends PluvIO<CloudflarePlatform>,
+    TBinding extends string,
+    TEnv extends Record<string, any>
+> = {
+    binding: TBinding;
+    endpoint?: string;
+    modify?: (
+        request: Request,
+        response: Response,
+        env: TEnv
+    ) => MaybePromise<Response>;
+    io: TPluv;
+} & (InferIOAuthorizeRequired<InferIOAuthorize<TPluv>> extends true
+    ? { authorize: AuthorizeFunction<TPluv> }
+    : { authorize?: undefined });
+
+export type PluvHandlerFetch<TEnv extends Record<string, any> = {}> = (
+    request: Request,
+    env: TEnv
+) => Promise<Response | null>;
+
+export interface CreatePluvHandlerResult<
+    TEnv extends Record<string, any> = {}
+> {
+    DurableObject: { new (state: DurableObjectState): DurableObject };
+    fetch: PluvHandlerFetch<TEnv>;
+    handler: ExportedHandler<TEnv>;
+}
+
+export const createPluvHandler = <
+    TPluv extends PluvIO<CloudflarePlatform, any, any, any, any, any, any>,
+    TBinding extends string,
+    TEnv extends Record<string, any>
+>(
+    config: CreatePluvHandlerConfig<TPluv, TBinding, TEnv>
+): CreatePluvHandlerResult<TEnv> => {
+    const { authorize, binding, endpoint = "/api/pluv", modify, io } = config;
+
+    const DurableObject = class implements DurableObject {
+        private _io: IORoom<CloudflarePlatform>;
+
+        constructor(state: DurableObjectState) {
+            this._io = io.getRoom(state.id.toString());
+        }
+
+        async fetch(
+            request: Request<any, CfProperties<any>>
+        ): Promise<Response> {
+            const isWSRequest = request.headers.get("Upgrade") === "websocket";
+
+            if (!isWSRequest) {
+                return new Response("Expected websocket", { status: 400 });
+            }
+
+            const { 0: client, 1: server } = new WebSocketPair();
+
+            const token = new URL(request.url).searchParams.get("token");
+
+            await this._io.register(server, { token });
+
+            return new Response(null, { status: 101, webSocket: client });
+        }
+    };
+
+    const getDurableObjectNamespace = (env: TEnv): DurableObjectNamespace => {
+        const namespace = env[binding];
+
+        if (!namespace) {
+            throw new Error(`Could not find DurableObject binding: ${binding}`);
+        }
+
+        return namespace;
+    };
+
+    const authHandler: PluvHandlerFetch<TEnv> = async (request, env) => {
+        if (!authorize) return null;
+
+        const { pathname, searchParams } = new URL(request.url);
+        const matcher = match<{}>(`${endpoint}/authorize`);
+        const matched = matcher(pathname);
+
+        if (!matched) return null;
+
+        const roomId = searchParams.get("room");
+
+        if (!roomId) {
+            return new Response("Not found", {
+                headers: { "Content-Type": "text/plain" },
+                status: 404,
+            });
+        }
+
+        try {
+            const user = await authorize({ request, roomId });
+
+            if (!user) throw new Error();
+
+            const namespace = getDurableObjectNamespace(env);
+            const durableObjectId = namespace.idFromName(roomId);
+
+            const token = await io.createToken({
+                room: durableObjectId.toString(),
+                user,
+            });
+
+            return new Response(token, {
+                headers: { "Content-Type": "text/plain" },
+                status: 200,
+            });
+        } catch (err) {
+            return new Response(
+                err instanceof Error ? err.message : "Unauthorized",
+                {
+                    headers: { "Content-Type": "text/plain" },
+                    status: 403,
+                }
+            );
+        }
+    };
+
+    const roomHandler: PluvHandlerFetch<TEnv> = async (request, env) => {
+        const { pathname } = new URL(request.url);
+        const matcher = match<{ roomId: string }>(`${endpoint}/room/:roomId`);
+        const matched = matcher(pathname);
+
+        if (!matched) return null;
+
+        const { roomId } = matched.params;
+
+        if (!roomId) {
+            return new Response("Not found", {
+                headers: { "Content-Type": "text/plain" },
+                status: 404,
+            });
+        }
+
+        const namespace = getDurableObjectNamespace(env);
+        const durableObjectId = namespace.idFromName(roomId);
+        const room = namespace.get(durableObjectId);
+
+        return room.fetch(request);
+    };
+
+    const fetch: PluvHandlerFetch<TEnv> = async (request, env) => {
+        return [authHandler, roomHandler].reduce((promise, current) => {
+            return promise.then((value) => value ?? current(request, env));
+        }, Promise.resolve<Response | null>(null));
+    };
+
+    const handler: ExportedHandler<TEnv> = {
+        fetch: async (request, env) => {
+            const response =
+                (await fetch(request, env)) ??
+                new Response("Not Found", {
+                    headers: { "Content-Type": "text/plain" },
+                    status: 404,
+                });
+
+            return modify?.(request, response, env) ?? response;
+        },
+    };
+
+    return { fetch, DurableObject, handler };
+};

package/src/index.ts

@@ -1 +1,9 @@
+export type {
+    AuthorizeFunction,
+    AuthorizeFunctionContext,
+    CreatePluvHandlerConfig,
+    CreatePluvHandlerResult,
+    PluvHandlerFetch,
+} from "./createPluvHandler";
+export { createPluvHandler } from "./createPluvHandler";
 export { platformCloudflare } from "./platformCloudflare";