@cfworker/web 1.9.0

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@cfworker/web",
+  "version": "1.9.0",
+  "description": "Web framework for Cloudflare Workers and service workers, inspired by Koa and fastify",
+  "keywords": [
+    "middleware",
+    "cloudflare",
+    "worker",
+    "workers",
+    "service-worker"
+  ],
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "source": "src/index.ts",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "src/**/*",
+    "tsconfig.json",
+    "README.md",
+    "package.json"
+  ],
+  "repository": "https://github.com/cfworker/cfworker",
+  "author": "Jeremy Danyow <jdanyow@gmail.com>",
+  "homepage": "https://github.com/cfworker/cfworker/tree/master/packages/web/README.md",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "clean": "tsc --build --clean",
+    "test": "cfworker test test/**/*.spec.ts --nocheck"
+  },
+  "dependencies": {
+    "@cfworker/json-schema": "^1.9.0",
+    "@cfworker/worker-types": "^1.9.0",
+    "@cloudflare/workers-types": "^2.1.0",
+    "@types/cookie": "^0.4.0",
+    "@types/html-escaper": "^3.0.0",
+    "@types/json-pointer": "^1.0.30",
+    "@types/koa-compose": "^3.2.5",
+    "@types/secure-json-parse": "^1.0.2",
+    "@types/statuses": "^1.5.0",
+    "cookie": "^0.4.1",
+    "html-escaper": "^3.0.3",
+    "koa-compose": "^4.1.0",
+    "negotiator": "^0.6.2",
+    "path-to-regexp": "^6.2.0",
+    "secure-json-parse": "^2.3.2",
+    "statuses": "^1.5.0"
+  },
+  "devDependencies": {
+    "@cfworker/dev": "^1.9.0",
+    "@types/chai": "^4.2.16",
+    "@types/mocha": "^8.2.2",
+    "chai": "^4.3.4",
+    "json-pointer": "^0.6.1",
+    "mocha": "^8.3.2",
+    "typescript": "^4.4.3"
+  },
+  "gitHead": "d333ff940566a7acc384ab791d8b73bed2a9a211"
+}

package/src/accepts.ts

@@ -0,0 +1,87 @@
+// @ts-ignore
+import { preferredCharsets } from 'negotiator/lib/charset.js';
+// @ts-ignore
+import { preferredEncodings } from 'negotiator/lib/encoding.js';
+// @ts-ignore
+import { preferredLanguages } from 'negotiator/lib/language.js';
+// @ts-ignore
+import { preferredMediaTypes } from 'negotiator/lib/mediaType.js';
+
+const parseAccept = preferredMediaTypes as (header: string) => string[];
+const parseAcceptLanguage = preferredLanguages as (header: string) => string[];
+const parseAcceptEncoding = preferredEncodings as (header: string) => string[];
+const parseAcceptCharset = preferredCharsets as (header: string) => string[];
+
+export class Accepts {
+  private _type: string[] | undefined = undefined;
+  private _language: string[] | undefined = undefined;
+  private _encoding: string[] | undefined = undefined;
+  private _charset: string[] | undefined = undefined;
+
+  constructor(private readonly headers: Headers) {}
+
+  public type<T extends string>(...values: T[]): T | false {
+    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;
+  }
+
+  public language<T extends string>(...values: T[]): T | false {
+    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;
+  }
+
+  public encoding<T extends string>(...values: T[]): T | false {
+    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;
+  }
+
+  public charset<T extends string>(...values: T[]): T | false {
+    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/src/application.ts

@@ -0,0 +1,48 @@
+import statuses from 'statuses';
+import { Context } from './context.js';
+import { HttpError } from './http-error.js';
+import { composeMiddleware, Middleware } from './middleware.js';
+
+const resolved = Promise.resolve();
+
+export class Application {
+  private readonly middleware: Middleware[] = [];
+
+  public use(middleware: Middleware) {
+    this.middleware.push(middleware);
+    return this;
+  }
+
+  public listen() {
+    const middleware = composeMiddleware(this.middleware);
+    addEventListener('fetch', event => this.handleFetch(event, middleware));
+  }
+
+  private handleFetch(event: FetchEvent, middleware: Middleware) {
+    const context = new Context(event);
+    event.respondWith(
+      Promise.race([
+        this.invokeMiddleware(context, middleware),
+        context.responded
+      ])
+    );
+  }
+
+  private async invokeMiddleware(context: Context, middleware: 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/src/context.ts

@@ -0,0 +1,28 @@
+import { Cookies } from './cookies.js';
+import { Req } from './req.js';
+import { ResponseBuilder } from './response-builder.js';
+
+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;
+    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);
+  }
+}

package/src/cookies.ts

@@ -0,0 +1,30 @@
+import {
+  CookieSerializeOptions,
+  parse as parseCookie,
+  serialize as serializeCookie
+} from 'cookie';
+
+const noCookies = Object.create(null);
+
+export class Cookies {
+  private readonly requestCookies: Record<string, string>;
+
+  constructor(
+    requestHeaders: Headers,
+    private readonly responseHeaders: Headers
+  ) {
+    const cookie = requestHeaders.get('cookie');
+    this.requestCookies = cookie ? parseCookie(cookie) : noCookies;
+  }
+
+  public get(name: string): string | null {
+    return this.requestCookies[name] || null;
+  }
+
+  public set(name: string, val: string, options?: CookieSerializeOptions) {
+    this.responseHeaders.append(
+      'Set-Cookie',
+      serializeCookie(name, val, options)
+    );
+  }
+}

package/src/http-error.ts

@@ -0,0 +1,36 @@
+import statuses from 'statuses';
+
+export class HttpError extends Error {
+  public readonly status: number;
+  public readonly statusText: string;
+  public readonly body: string | object;
+
+  constructor(status: number, body: string | object) {
+    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;
+  }
+
+  public toResponse(): Response {
+    let body = this.body || this.statusText;
+    let contentType: string;
+    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/src/index.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/src/middleware.ts

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

package/src/normalize-pathname.ts

@@ -0,0 +1,22 @@
+import { HttpError } from './http-error';
+import { Middleware } from './middleware';
+
+export function normalizePathname(pathname: string) {
+  return decodeURIComponent(pathname).replace(/\/\/+/g, '/').normalize();
+}
+
+export const normalizePathnameMiddleware: Middleware = 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/src/req.ts

@@ -0,0 +1,59 @@
+import { Reviver, safeParse } from 'secure-json-parse';
+import { Accepts } from './accepts.js';
+
+export class Req {
+  public readonly raw: Request;
+  public readonly method: string;
+  public readonly url: URL;
+  public readonly headers: Headers;
+  public readonly params: Record<string, string>;
+  public readonly accepts: Accepts;
+  public readonly body: ReqBody;
+
+  constructor(request: Request) {
+    this.raw = request;
+    this.method = request.method;
+    this.url = new URL(request.url);
+    this.headers = request.headers;
+    this.params = Object.create(null);
+    this.accepts = new Accepts(request.headers);
+    this.body = new ReqBody(request);
+  }
+}
+
+export class ReqBody {
+  private _arrayBuffer: Promise<ArrayBuffer> | undefined;
+  private _formData: Promise<FormData> | undefined;
+  private _json: Promise<any> | undefined;
+  private _text: Promise<string> | undefined;
+
+  constructor(private readonly request: Request) {}
+
+  public arrayBuffer() {
+    if (!this._arrayBuffer) {
+      this._arrayBuffer = this.request.arrayBuffer();
+    }
+    return this._arrayBuffer;
+  }
+
+  public formData() {
+    if (!this._formData) {
+      this._formData = this.request.formData();
+    }
+    return this._formData;
+  }
+
+  public json(reviver?: Reviver) {
+    if (!this._json) {
+      this._json = this.text().then(text => safeParse(text, reviver));
+    }
+    return this._json;
+  }
+
+  public text() {
+    if (!this._text) {
+      this._text = this.request.text();
+    }
+    return this._text;
+  }
+}

package/src/response-builder.ts

@@ -0,0 +1,161 @@
+import statuses from 'statuses';
+
+export type ExtendedBodyInit =
+  | BodyInit
+  | boolean
+  | Date
+  | number
+  | object
+  | null;
+
+export class ResponseBuilder {
+  public readonly headers = new Headers();
+  private _status = 404;
+  private _explicitStatus = false;
+  private _implicitType = false;
+  private _body: ExtendedBodyInit = null;
+  private _stringifyBody = false;
+
+  get status() {
+    return this._status;
+  }
+  set status(value) {
+    this._explicitStatus = true;
+    this._status = value;
+    if (this.body && statuses.empty[value]) {
+      this.body = null;
+    }
+  }
+
+  get statusText() {
+    return statuses[this._status]!;
+  }
+
+  get body() {
+    return this._body;
+  }
+  set body(value: ExtendedBodyInit | null) {
+    this._body = value;
+
+    // no content
+    if (value === null) {
+      if (!statuses.empty[this.status]) {
+        this._status = 204;
+      }
+      this.headers.delete('content-type');
+      this.headers.delete('content-length');
+      this.headers.delete('transfer-encoding');
+      return;
+    }
+
+    // set the status
+    if (!this._explicitStatus) {
+      this._status = 200;
+    }
+
+    // set Content-Type
+    if (
+      // Response will automatically use Blob's type.
+      value instanceof Blob ||
+      // Response will automatically use multipart/form-data.
+      value instanceof FormData ||
+      // Response will automatically use application/x-www-form-urlencoded.
+      value instanceof URLSearchParams ||
+      // Cannot determine Content-Type.
+      ArrayBuffer.isView(value) ||
+      value instanceof ArrayBuffer ||
+      value instanceof ReadableStream
+    ) {
+      this._stringifyBody = false;
+      if (this._implicitType) {
+        this._implicitType = false;
+        this.headers.delete('content-type');
+      }
+    } else if (typeof value === 'string') {
+      this._stringifyBody = false;
+      if (!this.headers.has('content-type') || this._implicitType) {
+        this._implicitType = true;
+        if (/^\s*</.test(value)) {
+          this.headers.set('content-type', 'text/html;charset=UTF-8');
+        } else {
+          this.headers.set('content-type', 'text/plain;charset=UTF-8');
+        }
+      }
+    } else {
+      this._stringifyBody = true;
+      this._implicitType = true;
+      this.headers.set('content-type', 'application/json;charset=UTF-8');
+    }
+  }
+
+  redirect(url: string | URL) {
+    if (url instanceof URL) {
+      url = url.href;
+    }
+
+    this.headers.set('location', url);
+
+    if (!statuses.redirect[this.status]) {
+      this.status = 302;
+    }
+
+    this.type = 'text/plain;charset=UTF-8';
+    this.body = `Redirecting to ${url}.`;
+  }
+
+  get type() {
+    const type = this.headers.get('content-type');
+    if (!type) {
+      return '';
+    }
+    return type.split(';', 1)[0];
+  }
+  set type(value) {
+    this._implicitType = false;
+    if (value) {
+      this.headers.set('content-type', value);
+    } else {
+      this.headers.delete('content-type');
+    }
+  }
+
+  get lastModified() {
+    const date = this.headers.get('last-modified');
+    return date ? new Date(date) : null;
+  }
+  set lastModified(value: string | Date | null) {
+    if (value === null) {
+      this.headers.delete('last-modified');
+      return;
+    }
+    if (typeof value === 'string') {
+      value = new Date(value);
+    }
+    this.headers.set('last-modified', value.toUTCString());
+  }
+
+  get etag() {
+    return this.headers.get('etag');
+  }
+  set etag(value) {
+    if (value) {
+      if (!/^(W\/)?"/.test(value)) {
+        value = `"${value}"`;
+      }
+      this.headers.set('etag', value);
+    } else {
+      this.headers.delete('etag');
+    }
+  }
+
+  create() {
+    const { body: rawBody, status, statusText, headers } = this;
+    const body = this._stringifyBody
+      ? JSON.stringify(rawBody)
+      : (rawBody as BodyInit);
+    return new Response(body, { status, statusText, headers });
+  }
+}
+
+// Cloudflare workers do not define the Blob class.
+const Blob = self.Blob || ((class {} as any) as Blob);