@cfworker/web 1.14.0 → 2.0.0

package/dist/accepts.js

@@ -7,12 +7,13 @@ const parseAcceptLanguage = preferredLanguages;
 const parseAcceptEncoding = preferredEncodings;
 const parseAcceptCharset = preferredCharsets;
 export class Accepts {
+    headers;
+    _type = undefined;
+    _language = undefined;
+    _encoding = undefined;
+    _charset = undefined;
     constructor(headers) {
         this.headers = headers;
-        this._type = undefined;
-        this._language = undefined;
-        this._encoding = undefined;
-        this._charset = undefined;
     }
     type(...values) {
         if (!this._type) {

package/dist/application.d.ts

@@ -7,6 +7,5 @@ export declare class Application {
     handleRequest(request: Request, env: any, context: {
         waitUntil(promise: Promise<any>): void;
     }): Promise<Response>;
-    listen(): void;
     private invokeMiddleware;
 }

package/dist/application.js

@@ -4,9 +4,8 @@ import { HttpError } from './http-error.js';
 import { composeMiddleware } from './middleware.js';
 const resolved = Promise.resolve();
 export class Application {
-    constructor() {
-        this.middleware = [];
-    }
+    middleware = [];
+    _composedMiddleware;
     get composedMiddleware() {
         if (!this._composedMiddleware) {
             this._composedMiddleware = composeMiddleware(this.middleware);
@@ -21,10 +20,6 @@ export class Application {
     async handleRequest(request, env, context) {
         return this.invokeMiddleware(new Context(request, env, context), this.composedMiddleware);
     }
-    listen() {
-        const middleware = this.composedMiddleware;
-        addEventListener('fetch', event => event.respondWith(this.invokeMiddleware(Context.fromFetchEvent(event), middleware)));
-    }
     async invokeMiddleware(context, middleware) {
         try {
             await middleware(context, () => resolved);

package/dist/context.d.ts

@@ -8,7 +8,6 @@ export declare class Context {
     readonly res: ResponseBuilder;
     readonly cookies: Cookies;
     readonly state: any;
-    static fromFetchEvent(event: FetchEvent): Context;
     constructor(request: Request, environmentBindings: any, _context: {
         waitUntil(promise: Promise<any>): void;
     });

package/dist/context.js

@@ -2,6 +2,12 @@ import { Cookies } from './cookies.js';
 import { Req } from './req.js';
 import { ResponseBuilder } from './response-builder.js';
 export class Context {
+    environmentBindings;
+    _context;
+    req;
+    res;
+    cookies;
+    state;
     constructor(request, environmentBindings, _context) {
         this.environmentBindings = environmentBindings;
         this._context = _context;
@@ -10,11 +16,6 @@ export class Context {
         this.cookies = new Cookies(request.headers, this.res.headers);
         this.state = {};
     }
-    static fromFetchEvent(event) {
-        return new Context(event.request, globalThis, {
-            waitUntil: event.waitUntil.bind(event)
-        });
-    }
     waitUntil(promise) {
         this._context.waitUntil(promise);
     }

package/dist/cookies.js

@@ -1,6 +1,8 @@
 import { parse as parseCookie, serialize as serializeCookie } from 'cookie';
 const noCookies = Object.create(null);
 export class Cookies {
+    responseHeaders;
+    requestCookies;
     constructor(requestHeaders, responseHeaders) {
         this.responseHeaders = responseHeaders;
         const cookie = requestHeaders.get('cookie');

package/dist/http-error.js

@@ -1,5 +1,8 @@
 import statuses from 'statuses';
 export class HttpError extends Error {
+    status;
+    statusText;
+    body;
     constructor(status, body) {
         const statusText = statuses.message[status];
         super(statusText);

package/dist/middleware.d.ts

@@ -1,3 +1,3 @@
 import { Context } from './context.js';
-export declare type Middleware = (context: Context, next: () => Promise<void>) => Promise<void> | void;
+export type Middleware = (context: Context, next: () => Promise<void>) => Promise<void> | void;
 export declare function composeMiddleware(middleware: Middleware[]): Middleware;

package/dist/req.js

@@ -1,6 +1,13 @@
 import { safeParse } from 'secure-json-parse';
 import { Accepts } from './accepts.js';
 export class Req {
+    raw;
+    method;
+    url;
+    headers;
+    params;
+    accepts;
+    body;
     constructor(request) {
         this.raw = request;
         this.method = request.method;
@@ -12,6 +19,11 @@ export class Req {
     }
 }
 export class ReqBody {
+    request;
+    _arrayBuffer;
+    _formData;
+    _json;
+    _text;
     constructor(request) {
         this.request = request;
     }

package/dist/response-builder.d.ts

@@ -1,4 +1,4 @@
-export declare type ExtendedBodyInit = BodyInit | boolean | Date | number | object | null;
+export type ExtendedBodyInit = BodyInit | boolean | Date | number | object | null;
 export declare class ResponseBuilder {
     readonly headers: Headers;
     private _status;

package/dist/response-builder.js

@@ -1,13 +1,11 @@
 import statuses from 'statuses';
 export class ResponseBuilder {
-    constructor() {
-        this.headers = new Headers();
-        this._status = 404;
-        this._explicitStatus = false;
-        this._implicitType = false;
-        this._body = null;
-        this._stringifyBody = false;
-    }
+    headers = new Headers();
+    _status = 404;
+    _explicitStatus = false;
+    _implicitType = false;
+    _body = null;
+    _stringifyBody = false;
     get status() {
         return this._status;
     }

package/dist/router.d.ts

@@ -1,7 +1,6 @@
-import { ParseOptions, TokensToRegexpOptions } from 'path-to-regexp';
+import { PathToRegexpOptions } from 'path-to-regexp';
 import { Context } from './context.js';
 import { Middleware } from './middleware.js';
-export declare type PathToRegExpOptions = TokensToRegexpOptions & ParseOptions;
 export declare const Method: (method: string) => ({ req }: Context) => boolean;
 export declare const Get: ({ req }: Context) => boolean;
 export declare const Post: ({ req }: Context) => boolean;
@@ -13,14 +12,14 @@ export declare const Options: ({ req }: Context) => boolean;
 export declare const Header: (header: string, value: string) => ({ req }: Context) => boolean;
 export declare const Host: (host: string) => ({ req }: Context) => boolean;
 export declare const Referer: (host: string) => ({ req }: Context) => boolean;
-export declare const Path: (pattern: string, options?: PathToRegExpOptions) => ({ req: { url, params } }: Context) => boolean;
-export declare type RouteCondition = (context: Context) => boolean;
+export declare const Path: (pattern: string, options?: PathToRegexpOptions) => ({ req: { url, params } }: Context) => boolean;
+export type RouteCondition = (context: Context) => boolean;
 export interface Route {
     conditions: RouteCondition[];
     middleware: Middleware;
 }
 export interface RouterOptions {
-    pathToRegExpOptions?: PathToRegExpOptions;
+    pathToRegExpOptions?: PathToRegexpOptions;
 }
 export declare const defaultRouterOptions: RouterOptions;
 export declare class Router {

package/dist/router.js

@@ -18,14 +18,13 @@ export const Header = (header, value) => {
 export const Host = (host) => Header('host', host);
 export const Referer = (host) => Header('referer', host);
 export const Path = (pattern, options) => {
-    const keys = [];
-    const regExp = pathToRegexp(pattern, keys, options);
+    const regExp = pathToRegexp(pattern, options);
     return ({ req: { url, params } }) => {
         const match = url.pathname.match(regExp);
         if (!match) {
             return false;
         }
-        collectParameters(keys, match, params);
+        collectParameters(regExp.keys, match, params);
         return true;
     };
 };
@@ -33,17 +32,10 @@ export const defaultRouterOptions = {
     pathToRegExpOptions: { strict: true }
 };
 export class Router {
+    options;
+    routes;
     constructor(options = defaultRouterOptions) {
         this.options = options;
-        this.middleware = async (ctx, next) => {
-            const resolved = this.resolve(ctx);
-            if (resolved) {
-                await resolved.middleware(ctx, next);
-            }
-            else {
-                await next();
-            }
-        };
         this.routes = [];
     }
     get(pathname, ...middleware) {
@@ -74,6 +66,15 @@ export class Router {
         const opts = this.options.pathToRegExpOptions;
         return this.compose([Path(pathname, opts)], ...middleware);
     }
+    middleware = async (ctx, next) => {
+        const resolved = this.resolve(ctx);
+        if (resolved) {
+            await resolved.middleware(ctx, next);
+        }
+        else {
+            await next();
+        }
+    };
     compose(conditions, ...middleware) {
         this.routes.push({
             conditions,

package/dist/validate.d.ts

@@ -6,8 +6,8 @@ export interface RequestSchemas {
     params?: Schema;
     search?: Schema;
 }
-export declare type RequestPart = keyof RequestSchemas;
-export declare type RequestParser = (data: URLSearchParams | FormData) => any;
+export type RequestPart = keyof RequestSchemas;
+export type RequestParser = (data: URLSearchParams | FormData) => any;
 declare function middlewareFactory(schemas: RequestSchemas, parser?: RequestParser, lookup?: any): Middleware;
 export declare const messages: Record<RequestPart, string>;
 export interface RequestValidationErrorBody {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfworker/web",
-  "version": "1.14.0",
+  "version": "2.0.0",
   "description": "Web framework for Cloudflare Workers and service workers, inspired by Koa and fastify",
   "keywords": [
     "middleware",
@@ -31,29 +31,29 @@
   "scripts": {
     "build": "tsc --build",
     "clean": "tsc --build --clean",
-    "test": "cfworker test test/**/*.spec.ts --nocheck"
+    "pretest": "esbuild test/test.ts --target=esnext --bundle --format=esm --conditions=worker,browser --outdir=dist-test --ignore-annotations",
+    "test": "node ../../test.mjs"
   },
   "dependencies": {
-    "@cfworker/json-schema": "^1.12.6",
-    "@cfworker/worker-types": "^1.12.3",
-    "@cloudflare/workers-types": "^2.2.2",
-    "@types/cookie": "^0.5.1",
-    "@types/html-escaper": "^3.0.0",
-    "@types/statuses": "^2.0.0",
-    "cookie": "^0.5.0",
+    "@cfworker/json-schema": "^2.0.0",
+    "@types/cookie": "^0.6.0",
+    "@types/html-escaper": "^3.0.2",
+    "@types/statuses": "^2.0.5",
+    "cookie": "^0.6.0",
     "html-escaper": "^3.0.3",
     "negotiator": "^0.6.3",
-    "path-to-regexp": "^6.2.1",
-    "secure-json-parse": "^2.5.0",
+    "path-to-regexp": "^7.1.0",
+    "secure-json-parse": "^2.7.0",
     "statuses": "^2.0.1"
   },
   "devDependencies": {
-    "@cfworker/dev": "^1.14.2",
-    "@types/chai": "^4.3.3",
-    "@types/mocha": "^10.0.0",
-    "chai": "^4.3.6",
+    "@types/chai": "^4.3.17",
+    "@types/mocha": "^10.0.7",
+    "chai": "^5.1.1",
+    "esbuild": "^0.23.1",
     "jsonpointer": "^5.0.1",
-    "mocha": "^10.0.0",
-    "typescript": "^4.8.4"
+    "mocha": "^10.7.3",
+    "typescript": "^5.5.4",
+    "wrangler": "^3.72.0"
   }
 }

package/src/application.ts

@@ -35,15 +35,6 @@ export class Application {
     );
   }
 
-  public listen() {
-    const middleware = this.composedMiddleware;
-    addEventListener('fetch', event =>
-      event.respondWith(
-        this.invokeMiddleware(Context.fromFetchEvent(event), middleware)
-      )
-    );
-  }
-
   private async invokeMiddleware(context: Context, middleware: Middleware) {
     try {
       await middleware(context, () => resolved);

package/src/context.ts

@@ -8,12 +8,6 @@ export class Context {
   public readonly cookies: Cookies;
   public readonly state: any;
 
-  static fromFetchEvent(event: FetchEvent) {
-    return new Context(event.request, globalThis as any, {
-      waitUntil: event.waitUntil.bind(event)
-    });
-  }
-
   constructor(
     request: Request,
     public readonly environmentBindings: any,

package/src/declarations.d.ts

@@ -4,3 +4,7 @@ type Buffer = never;
 interface WorkerGlobalScopeEventMap {
   fetch: FetchEvent;
 }
+
+interface ErrorConstructor {
+  captureStackTrace(thisArg: any, func: any): void;
+}

package/src/router.ts

@@ -1,14 +1,7 @@
-import {
-  Key,
-  ParseOptions,
-  pathToRegexp,
-  TokensToRegexpOptions
-} from 'path-to-regexp';
+import { Key, pathToRegexp, PathToRegexpOptions } from 'path-to-regexp';
 import { Context } from './context.js';
 import { composeMiddleware, Middleware } from './middleware.js';
 
-export type PathToRegExpOptions = TokensToRegexpOptions & ParseOptions;
-
 export const Method = (method: string) => {
   method = method.toUpperCase();
   return ({ req }: Context) => req.method === method;
@@ -28,16 +21,15 @@ export const Header = (header: string, value: string) => {
 export const Host = (host: string) => Header('host', host);
 export const Referer = (host: string) => Header('referer', host);
 
-export const Path = (pattern: string, options?: PathToRegExpOptions) => {
-  const keys: Key[] = [];
-  const regExp = pathToRegexp(pattern, keys, options);
+export const Path = (pattern: string, options?: PathToRegexpOptions) => {
+  const regExp = pathToRegexp(pattern, options);
 
   return ({ req: { url, params } }: Context) => {
     const match = url.pathname.match(regExp);
     if (!match) {
       return false;
     }
-    collectParameters(keys, match, params);
+    collectParameters(regExp.keys, match, params);
     return true;
   };
 };
@@ -50,7 +42,7 @@ export interface Route {
 }
 
 export interface RouterOptions {
-  pathToRegExpOptions?: PathToRegExpOptions;
+  pathToRegExpOptions?: PathToRegexpOptions;
 }
 
 export const defaultRouterOptions: RouterOptions = {

package/tsconfig.json

@@ -1,14 +1,8 @@
 {
   "extends": "../../tsconfig-base",
   "compilerOptions": {
-    "target": "ES2021",
+    "target": "ESNext",
     "lib": ["ESNext", "WebWorker", "Webworker.Iterable"],
-    "types": [
-      "chai",
-      "mocha",
-      "@cfworker/worker-types",
-      "@cloudflare/workers-types"
-    ],
     "outDir": "dist",
     "rootDir": "./src"
   },