@cfworker/web 1.9.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Jeremy Danyow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,91 @@
+# @cfworker/web
+
+![](https://badgen.net/bundlephobia/minzip/@cfworker/web)
+![](https://badgen.net/bundlephobia/min/@cfworker/web)
+![](https://badgen.net/bundlephobia/dependency-count/@cfworker/web)
+![](https://badgen.net/bundlephobia/tree-shaking/@cfworker/web)
+![](https://badgen.net/npm/types/@cfworker/web?icon=typescript)
+
+Web framework for Cloudflare Workers and service workers, inspired by Koa and fastify.
+
+```ts
+import {
+  Application,
+  Middleware,
+  Router,
+  validate,
+  normalizePathnameMiddleware
+} from '@cfworker/web';
+
+const router = new Router();
+
+// Add the homepage route.
+router.get('/', ({ res }) => {
+  res.body = `
+    <h1>@cfworker/web demo</h1>
+    <h2 id="example-routes">Example routes</h2>
+    <ol aria-labelledby="example-routes">
+      <li><a href="/greetings/hello">A valid greeting</a></li>
+      <li><a href="/greetings/hell">An invalid greeting</a></li>
+      <li><a href="/error">A route with a bug</a></li>
+    </ol>
+    <img src="favicon.ico" alt="cfworker logo">`;
+});
+
+// Add a greeting route with validation.
+router.get(
+  '/greetings/:greeting',
+  validate({
+    params: {
+      required: ['greeting'],
+      properties: {
+        greeting: {
+          minLength: 5,
+          maxLength: 10
+        }
+      }
+    }
+  }),
+  ({ req, res }) => {
+    res.body = req.params;
+  }
+);
+
+// Add a route to demonstrate exception handling.
+router.get('/error', () => {
+  // @ts-ignore - this route has a bug!
+  req.this.method.does.not.exist();
+});
+
+// Favicon route for fun :)
+router.get('/favicon.ico', ({ res }) => {
+  res.type = 'image/svg+xml';
+  res.body = `
+      <svg xmlns="http://www.w3.org/2000/svg" baseProfile="full" width="200" height="200">
+        <rect width="100%" height="100%" fill="#F38020"/>
+        <text font-size="120" font-family="Arial, Helvetica, sans-serif" text-anchor="end" fill="#FFF" x="185" y="185">W</text>
+      </svg>`;
+});
+
+// Simple CORS middleware.
+const cors: Middleware = async ({ res }, next) => {
+  res.headers.set('access-control-allow-origin', '*');
+  await next();
+};
+
+// Compose the application
+new Application()
+  .use(normalizePathnameMiddleware)
+  .use(cors)
+  .use(router.middleware)
+  .listen();
+```
+
+[To run this example](/packages/examples/web/index.ts):
+
+```
+git clone https://github.com/cfworker/cfworker
+cd cfworker
+npm install
+npm run start-web --workspace=@cfworker/examples
+```

package/dist/accepts.d.ts

@@ -0,0 +1,12 @@
+export declare class Accepts {
+    private readonly headers;
+    private _type;
+    private _language;
+    private _encoding;
+    private _charset;
+    constructor(headers: Headers);
+    type<T extends string>(...values: T[]): T | false;
+    language<T extends string>(...values: T[]): T | false;
+    encoding<T extends string>(...values: T[]): T | false;
+    charset<T extends string>(...values: T[]): T | false;
+}

package/dist/accepts.js

@@ -0,0 +1,77 @@
+import { preferredCharsets } from 'negotiator/lib/charset.js';
+import { preferredEncodings } from 'negotiator/lib/encoding.js';
+import { preferredLanguages } from 'negotiator/lib/language.js';
+import { preferredMediaTypes } from 'negotiator/lib/mediaType.js';
+const parseAccept = preferredMediaTypes;
+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;
+    }
+    type(...values) {
+        if (!this._type) {
+            const header = this.headers.get('accept');
+            this._type = header ? parseAccept(header.toLowerCase()) : [];
+        }
+        for (const accepted of this._type) {
+            for (const value of values) {
+                if (value === accepted ||
+                    (accepted.startsWith('*') && value.endsWith(accepted.substr(1))) ||
+                    (accepted.endsWith('*') &&
+                        value.startsWith(accepted.substr(0, accepted.length - 2)))) {
+                    return value;
+                }
+            }
+        }
+        return false;
+    }
+    language(...values) {
+        if (!this._language) {
+            const header = this.headers.get('accept-language');
+            this._language = header ? parseAcceptLanguage(header.toLowerCase()) : [];
+        }
+        for (const accepted of this._language) {
+            for (const value of values) {
+                if (value === accepted || value.startsWith(accepted)) {
+                    return value;
+                }
+            }
+        }
+        return false;
+    }
+    encoding(...values) {
+        if (!this._encoding) {
+            const header = this.headers.get('accept-encoding');
+            this._encoding = header ? parseAcceptEncoding(header.toLowerCase()) : [];
+        }
+        for (const accepted of this._encoding) {
+            for (const value of values) {
+                if (value === accepted) {
+                    return value;
+                }
+            }
+        }
+        return false;
+    }
+    charset(...values) {
+        if (!this._charset) {
+            const header = this.headers.get('accept-charset');
+            this._charset = header ? parseAcceptCharset(header.toLowerCase()) : [];
+        }
+        for (const accepted of this._charset) {
+            for (const value of values) {
+                if (value === accepted) {
+                    return value;
+                }
+            }
+        }
+        return false;
+    }
+}

package/dist/application.d.ts

@@ -0,0 +1,8 @@
+import { Middleware } from './middleware.js';
+export declare class Application {
+    private readonly middleware;
+    use(middleware: Middleware): this;
+    listen(): void;
+    private handleFetch;
+    private invokeMiddleware;
+}

package/dist/application.js

@@ -0,0 +1,39 @@
+import statuses from 'statuses';
+import { Context } from './context.js';
+import { HttpError } from './http-error.js';
+import { composeMiddleware } from './middleware.js';
+const resolved = Promise.resolve();
+export class Application {
+    middleware = [];
+    use(middleware) {
+        this.middleware.push(middleware);
+        return this;
+    }
+    listen() {
+        const middleware = composeMiddleware(this.middleware);
+        addEventListener('fetch', event => this.handleFetch(event, middleware));
+    }
+    handleFetch(event, middleware) {
+        const context = new Context(event);
+        event.respondWith(Promise.race([
+            this.invokeMiddleware(context, middleware),
+            context.responded
+        ]));
+    }
+    async invokeMiddleware(context, middleware) {
+        try {
+            await middleware(context, () => resolved);
+            return context.res.create();
+        }
+        catch (err) {
+            console.error(err);
+            if (err instanceof HttpError) {
+                return err.toResponse();
+            }
+            const status = 500;
+            const statusText = statuses[500];
+            const headers = { 'content-type': 'text/plain' };
+            return new Response(statusText, { status, statusText, headers });
+        }
+    }
+}

package/dist/context.d.ts

@@ -0,0 +1,14 @@
+import { Cookies } from './cookies.js';
+import { Req } from './req.js';
+import { ResponseBuilder } from './response-builder.js';
+export declare class Context {
+    private readonly event;
+    readonly req: Req;
+    readonly res: ResponseBuilder;
+    readonly cookies: Cookies;
+    readonly respondWith: (response: Response) => void;
+    readonly responded: Promise<Response>;
+    readonly state: any;
+    constructor(event: FetchEvent);
+    waitUntil(promise: Promise<any>): void;
+}

package/dist/context.js

@@ -0,0 +1,26 @@
+import { Cookies } from './cookies.js';
+import { Req } from './req.js';
+import { ResponseBuilder } from './response-builder.js';
+export class Context {
+    event;
+    req;
+    res;
+    cookies;
+    respondWith;
+    responded;
+    state;
+    constructor(event) {
+        this.event = event;
+        const request = event.request;
+        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 = {};
+    }
+    waitUntil(promise) {
+        this.event.waitUntil(promise);
+    }
+}

package/dist/cookies.d.ts

@@ -0,0 +1,8 @@
+import { CookieSerializeOptions } from 'cookie';
+export declare class Cookies {
+    private readonly responseHeaders;
+    private readonly requestCookies;
+    constructor(requestHeaders: Headers, responseHeaders: Headers);
+    get(name: string): string | null;
+    set(name: string, val: string, options?: CookieSerializeOptions): void;
+}

package/dist/cookies.js

@@ -0,0 +1,17 @@
+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');
+        this.requestCookies = cookie ? parseCookie(cookie) : noCookies;
+    }
+    get(name) {
+        return this.requestCookies[name] || null;
+    }
+    set(name, val, options) {
+        this.responseHeaders.append('Set-Cookie', serializeCookie(name, val, options));
+    }
+}

package/dist/http-error.d.ts

@@ -0,0 +1,7 @@
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: string | object;
+    constructor(status: number, body: string | object);
+    toResponse(): Response;
+}

package/dist/http-error.js

@@ -0,0 +1,31 @@
+import statuses from 'statuses';
+export class HttpError extends Error {
+    status;
+    statusText;
+    body;
+    constructor(status, body) {
+        const statusText = statuses[statuses(status)];
+        super(statusText);
+        this.name = this.constructor.name;
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+    }
+    toResponse() {
+        let body = this.body || this.statusText;
+        let contentType;
+        if (typeof body === 'string') {
+            contentType = 'text/plain';
+        }
+        else {
+            contentType = 'application/json';
+            body = JSON.stringify(body);
+        }
+        const { status, statusText } = this;
+        const headers = { 'content-type': contentType };
+        return new Response(body, { status, statusText, headers });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { escape as htmlEncode } from 'html-escaper';
+export * from './accepts.js';
+export * from './application.js';
+export * from './context.js';
+export * from './cookies.js';
+export * from './http-error.js';
+export * from './middleware.js';
+export * from './normalize-pathname.js';
+export * from './req.js';
+export * from './response-builder.js';
+export * from './router.js';
+export * from './to-object.js';
+export * from './validate.js';

package/dist/index.js

@@ -0,0 +1,13 @@
+export { escape as htmlEncode } from 'html-escaper';
+export * from './accepts.js';
+export * from './application.js';
+export * from './context.js';
+export * from './cookies.js';
+export * from './http-error.js';
+export * from './middleware.js';
+export * from './normalize-pathname.js';
+export * from './req.js';
+export * from './response-builder.js';
+export * from './router.js';
+export * from './to-object.js';
+export * from './validate.js';

package/dist/middleware.d.ts

@@ -0,0 +1,4 @@
+import compose, { Middleware as GenericMiddleware } from 'koa-compose';
+import { Context } from './context.js';
+export declare type Middleware = GenericMiddleware<Context>;
+export declare const composeMiddleware: typeof compose;

package/dist/middleware.js

@@ -0,0 +1,2 @@
+import compose from 'koa-compose';
+export const composeMiddleware = compose;

package/dist/normalize-pathname.d.ts

@@ -0,0 +1,3 @@
+import { Middleware } from './middleware';
+export declare function normalizePathname(pathname: string): string;
+export declare const normalizePathnameMiddleware: Middleware;

package/dist/normalize-pathname.js

@@ -0,0 +1,17 @@
+import { HttpError } from './http-error';
+export function normalizePathname(pathname) {
+    return decodeURIComponent(pathname).replace(/\/\/+/g, '/').normalize();
+}
+export const normalizePathnameMiddleware = async ({ req }, next) => {
+    const pathname = req.url.pathname;
+    try {
+        req.url.pathname = normalizePathname(pathname);
+    }
+    catch (err) {
+        if (err instanceof URIError) {
+            throw new HttpError(400, `Unable to decode pathname "${pathname}".`);
+        }
+        throw err;
+    }
+    await next();
+};

package/dist/req.d.ts

@@ -0,0 +1,24 @@
+import { Reviver } from 'secure-json-parse';
+import { Accepts } from './accepts.js';
+export declare class Req {
+    readonly raw: Request;
+    readonly method: string;
+    readonly url: URL;
+    readonly headers: Headers;
+    readonly params: Record<string, string>;
+    readonly accepts: Accepts;
+    readonly body: ReqBody;
+    constructor(request: Request);
+}
+export declare class ReqBody {
+    private readonly request;
+    private _arrayBuffer;
+    private _formData;
+    private _json;
+    private _text;
+    constructor(request: Request);
+    arrayBuffer(): Promise<ArrayBuffer>;
+    formData(): Promise<FormData>;
+    json(reviver?: Reviver): Promise<any>;
+    text(): Promise<string>;
+}