@cfworker/web 1.12.5 → 1.13.0

package/dist/application.d.ts

@@ -1,8 +1,12 @@
 import { Middleware } from './middleware.js';
 export declare class Application {
     private readonly middleware;
+    private _composedMiddleware?;
+    private get composedMiddleware();
     use(middleware: Middleware): this;
+    handleRequest(request: Request, env: any, context: {
+        waitUntil(promise: Promise<any>): void;
+    }): Promise<Response>;
     listen(): void;
-    private handleFetch;
     private invokeMiddleware;
 }

package/dist/application.js

@@ -7,20 +7,23 @@ export class Application {
     constructor() {
         this.middleware = [];
     }
+    get composedMiddleware() {
+        if (!this._composedMiddleware) {
+            this._composedMiddleware = composeMiddleware(this.middleware);
+        }
+        return this._composedMiddleware;
+    }
     use(middleware) {
         this.middleware.push(middleware);
+        this._composedMiddleware = undefined;
         return this;
     }
-    listen() {
-        const middleware = composeMiddleware(this.middleware);
-        addEventListener('fetch', event => this.handleFetch(event, middleware));
+    async handleRequest(request, env, context) {
+        return this.invokeMiddleware(new Context(request, env, context), this.composedMiddleware);
     }
-    handleFetch(event, middleware) {
-        const context = new Context(event);
-        event.respondWith(Promise.race([
-            this.invokeMiddleware(context, middleware),
-            context.responded
-        ]));
+    listen() {
+        const middleware = this.composedMiddleware;
+        addEventListener('fetch', event => event.respondWith(this.invokeMiddleware(Context.fromFetchEvent(event), middleware)));
     }
     async invokeMiddleware(context, middleware) {
         try {

package/dist/context.d.ts

@@ -2,13 +2,15 @@ import { Cookies } from './cookies.js';
 import { Req } from './req.js';
 import { ResponseBuilder } from './response-builder.js';
 export declare class Context {
-    private readonly event;
+    readonly env: any;
+    private readonly _context;
     readonly req: Req;
     readonly res: ResponseBuilder;
     readonly cookies: Cookies;
-    readonly respondWith: (response: Response) => void;
-    readonly responded: Promise<Response>;
     readonly state: any;
-    constructor(event: FetchEvent);
+    static fromFetchEvent(event: FetchEvent): Context;
+    constructor(request: Request, env: any, _context: {
+        waitUntil(promise: Promise<any>): void;
+    });
     waitUntil(promise: Promise<any>): void;
 }

package/dist/context.js

@@ -2,18 +2,20 @@ import { Cookies } from './cookies.js';
 import { Req } from './req.js';
 import { ResponseBuilder } from './response-builder.js';
 export class Context {
-    constructor(event) {
-        this.event = event;
-        const request = event.request;
+    constructor(request, env, _context) {
+        this.env = env;
+        this._context = _context;
         this.req = new Req(request);
         this.res = new ResponseBuilder();
         this.cookies = new Cookies(request.headers, this.res.headers);
-        this.responded = new Promise(resolve => {
-            this.respondWith = resolve;
-        });
         this.state = {};
     }
+    static fromFetchEvent(event) {
+        return new Context(event.request, globalThis, {
+            waitUntil: event.waitUntil.bind(event)
+        });
+    }
     waitUntil(promise) {
-        this.event.waitUntil(promise);
+        this._context.waitUntil(promise);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfworker/web",
-  "version": "1.12.5",
+  "version": "1.13.0",
   "description": "Web framework for Cloudflare Workers and service workers, inspired by Koa and fastify",
   "keywords": [
     "middleware",
@@ -34,7 +34,7 @@
     "test": "cfworker test test/**/*.spec.ts --nocheck"
   },
   "dependencies": {
-    "@cfworker/json-schema": "^1.12.5",
+    "@cfworker/json-schema": "^1.12.6",
     "@cfworker/worker-types": "^1.12.3",
     "@cloudflare/workers-types": "^2.2.2",
     "@types/cookie": "^0.5.1",

package/src/application.ts

@@ -7,24 +7,40 @@ const resolved = Promise.resolve();
 
 export class Application {
   private readonly middleware: Middleware[] = [];
+  private _composedMiddleware?: Middleware;
+
+  private get composedMiddleware() {
+    if (!this._composedMiddleware) {
+      this._composedMiddleware = composeMiddleware(this.middleware);
+    }
+    return this._composedMiddleware;
+  }
 
   public use(middleware: Middleware) {
     this.middleware.push(middleware);
+    this._composedMiddleware = undefined;
     return this;
   }
 
-  public listen() {
-    const middleware = composeMiddleware(this.middleware);
-    addEventListener('fetch', event => this.handleFetch(event, middleware));
+  public async handleRequest(
+    request: Request,
+    env: any,
+    context: {
+      waitUntil(promise: Promise<any>): void;
+    }
+  ): Promise<Response> {
+    return this.invokeMiddleware(
+      new Context(request, env, context),
+      this.composedMiddleware
+    );
   }
 
-  private handleFetch(event: FetchEvent, middleware: Middleware) {
-    const context = new Context(event);
-    event.respondWith(
-      Promise.race([
-        this.invokeMiddleware(context, middleware),
-        context.responded
-      ])
+  public listen() {
+    const middleware = this.composedMiddleware;
+    addEventListener('fetch', event =>
+      event.respondWith(
+        this.invokeMiddleware(Context.fromFetchEvent(event), middleware)
+      )
     );
   }
 

package/src/context.ts

@@ -6,23 +6,28 @@ export class Context {
   public readonly req: Req;
   public readonly res: ResponseBuilder;
   public readonly cookies: Cookies;
-  public readonly respondWith!: (response: Response) => void;
-  public readonly responded: Promise<Response>;
   public readonly state: any;
 
-  constructor(private readonly event: FetchEvent) {
-    const request = event.request;
+  static fromFetchEvent(event: FetchEvent) {
+    return new Context(event.request, globalThis as any, {
+      waitUntil: event.waitUntil.bind(event)
+    });
+  }
+
+  constructor(
+    request: Request,
+    public readonly env: any,
+    private readonly _context: {
+      waitUntil(promise: Promise<any>): void;
+    }
+  ) {
     this.req = new Req(request);
     this.res = new ResponseBuilder();
     this.cookies = new Cookies(request.headers, this.res.headers);
-    this.responded = new Promise<Response>(resolve => {
-      // @ts-ignore
-      this.respondWith = resolve;
-    });
     this.state = {};
   }
 
   public waitUntil(promise: Promise<any>) {
-    this.event.waitUntil(promise);
+    this._context.waitUntil(promise);
   }
 }

package/src/declarations.d.ts

@@ -1,2 +1,6 @@
 // secure-json-parse's types rely on node's Buffer
 type Buffer = never;
+
+interface WorkerGlobalScopeEventMap {
+  fetch: FetchEvent;
+}