@cfworker/web 5.0.0 → 5.0.2

package/src/cookies.ts

@@ -1,30 +0,0 @@
-import {
-  parse as parseCookie,
-  serialize as serializeCookie,
-  SerializeOptions
-} 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?: SerializeOptions): void {
-    this.responseHeaders.append(
-      'Set-Cookie',
-      serializeCookie(name, val, options)
-    );
-  }
-}

package/src/declarations.d.ts

@@ -1,10 +0,0 @@
-// secure-json-parse's types rely on node's Buffer
-type Buffer = never;
-
-interface WorkerGlobalScopeEventMap {
-  fetch: FetchEvent;
-}
-
-interface ErrorConstructor {
-  captureStackTrace(thisArg: any, func: any): void;
-}

package/src/http-error.ts

@@ -1,36 +0,0 @@
-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.message[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/middleware.ts

@@ -1,34 +0,0 @@
-import { Context } from './context.js';
-
-export type Middleware = (
-  context: Context,
-  next: () => Promise<void>
-) => Promise<void> | void;
-
-export function composeMiddleware(middleware: Middleware[]): Middleware {
-  if (!Array.isArray(middleware))
-    throw new TypeError('Middleware stack must be an array!');
-  for (const fn of middleware) {
-    if (typeof fn !== 'function')
-      throw new TypeError('Middleware must be composed of functions!');
-  }
-
-  return function (context, next) {
-    // last called middleware #
-    let index = -1;
-    return dispatch(0);
-    function dispatch(i: number): Promise<void> {
-      if (i <= index)
-        return Promise.reject(new Error('next() called multiple times'));
-      index = i;
-      let fn = middleware[i];
-      if (i === middleware.length) fn = next;
-      if (!fn) return Promise.resolve();
-      try {
-        return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
-      } catch (err) {
-        return Promise.reject(err);
-      }
-    }
-  };
-}

package/src/normalize-pathname.ts

@@ -1,22 +0,0 @@
-import { HttpError } from './http-error';
-import { Middleware } from './middleware';
-
-export function normalizePathname(pathname: string): 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

@@ -1,59 +0,0 @@
-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(): Promise<ArrayBuffer> {
-    if (!this._arrayBuffer) {
-      this._arrayBuffer = this.request.arrayBuffer();
-    }
-    return this._arrayBuffer;
-  }
-
-  public formData(): Promise<FormData> {
-    if (!this._formData) {
-      this._formData = this.request.formData();
-    }
-    return this._formData;
-  }
-
-  public json(reviver?: Reviver): Promise<any> {
-    if (!this._json) {
-      this._json = this.text().then(text => safeParse(text, reviver));
-    }
-    return this._json;
-  }
-
-  public text(): Promise<string> {
-    if (!this._text) {
-      this._text = this.request.text();
-    }
-    return this._text;
-  }
-}

package/src/response-builder.ts

@@ -1,158 +0,0 @@
-import statuses from 'statuses';
-
-export type ExtendedBodyInit =
-  | BodyInit
-  | boolean
-  | Date
-  | number
-  | object
-  | null;
-
-export class ResponseBuilder {
-  public readonly headers: Headers = new Headers();
-  private _status = 404;
-  private _explicitStatus = false;
-  private _implicitType = false;
-  private _body: ExtendedBodyInit = null;
-  private _stringifyBody = false;
-
-  get status(): number {
-    return this._status;
-  }
-  set status(value) {
-    this._explicitStatus = true;
-    this._status = value;
-    if (this.body && statuses.empty[value]) {
-      this.body = null;
-    }
-  }
-
-  get statusText(): string {
-    return statuses.message[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): void {
-    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(): string {
-    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(): string | null {
-    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(): Response {
-    const { body: rawBody, status, statusText, headers } = this;
-    const body = this._stringifyBody
-      ? JSON.stringify(rawBody)
-      : (rawBody as BodyInit);
-    return new Response(body, { status, statusText, headers });
-  }
-}

package/src/router.ts

@@ -1,146 +0,0 @@
-import { Key, pathToRegexp, PathToRegexpOptions } from 'path-to-regexp';
-import { Context } from './context.js';
-import { composeMiddleware, Middleware } from './middleware.js';
-
-export type Predicate = (context: Context) => boolean;
-
-export const Method: (method: string) => Predicate = (method: string) => {
-  method = method.toUpperCase();
-  return ({ req }: Context) => req.method === method;
-};
-export const Get: Predicate = Method('get');
-export const Post: Predicate = Method('post');
-export const Put: Predicate = Method('put');
-export const Patch: Predicate = Method('patch');
-export const Delete: Predicate = Method('delete');
-export const Head: Predicate = Method('head');
-export const Options: Predicate = Method('options');
-
-export const Header: (header: string, value: string) => Predicate = (
-  header: string,
-  value: string
-) => {
-  value = value.toLowerCase();
-  return ({ req }: Context) => req.headers.get(header) === value;
-};
-export const Host: (host: string) => Predicate = (host: string) =>
-  Header('host', host);
-
-export const Path: (
-  pattern: string,
-  options?: PathToRegexpOptions
-) => Predicate = (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(regexp.keys, match, params);
-    return true;
-  };
-};
-
-export type RouteCondition = (context: Context) => boolean;
-
-export interface Route {
-  conditions: RouteCondition[];
-  middleware: Middleware;
-}
-
-export interface RouterOptions {
-  pathToRegExpOptions?: PathToRegexpOptions;
-}
-
-export const defaultRouterOptions: RouterOptions = {
-  pathToRegExpOptions: {
-    strict: true
-  }
-};
-
-export class Router {
-  private readonly routes: Route[];
-
-  constructor(private readonly options: RouterOptions = defaultRouterOptions) {
-    this.routes = [];
-  }
-
-  public get(pathname: string, ...middleware: Middleware[]): Router {
-    const opts = this.options.pathToRegExpOptions;
-    return this.compose([Get, Path(pathname, opts)], ...middleware);
-  }
-
-  public post(pathname: string, ...middleware: Middleware[]): Router {
-    const opts = this.options.pathToRegExpOptions;
-    return this.compose([Post, Path(pathname, opts)], ...middleware);
-  }
-
-  public put(pathname: string, ...middleware: Middleware[]): Router {
-    const opts = this.options.pathToRegExpOptions;
-    return this.compose([Put, Path(pathname, opts)], ...middleware);
-  }
-
-  public patch(pathname: string, ...middleware: Middleware[]): Router {
-    const opts = this.options.pathToRegExpOptions;
-    return this.compose([Patch, Path(pathname, opts)], ...middleware);
-  }
-
-  public delete(pathname: string, ...middleware: Middleware[]): Router {
-    const opts = this.options.pathToRegExpOptions;
-    return this.compose([Delete, Path(pathname, opts)], ...middleware);
-  }
-
-  public head(pathname: string, ...middleware: Middleware[]): Router {
-    const opts = this.options.pathToRegExpOptions;
-    return this.compose([Head, Path(pathname, opts)], ...middleware);
-  }
-
-  public all(pathname: string, ...middleware: Middleware[]): Router {
-    const opts = this.options.pathToRegExpOptions;
-    return this.compose([Path(pathname, opts)], ...middleware);
-  }
-
-  public middleware: Middleware = async (ctx, next) => {
-    const resolved = this.resolve(ctx);
-
-    if (resolved) {
-      await resolved.middleware(ctx, next);
-    } else {
-      await next();
-    }
-  };
-
-  public compose(
-    conditions: RouteCondition[],
-    ...middleware: Middleware[]
-  ): Router {
-    this.routes.push({
-      conditions,
-      middleware: composeMiddleware(middleware)
-    });
-    return this;
-  }
-
-  public resolve(ctx: Context): Route | undefined {
-    return this.routes.find(
-      ({ conditions }) =>
-        conditions.length === 0 || conditions.every(c => c(ctx))
-    );
-  }
-}
-
-function collectParameters(
-  keys: Key[],
-  match: RegExpMatchArray,
-  params: Record<string, string>
-) {
-  for (let i = 1; i < match.length; i++) {
-    const name = keys[i - 1].name;
-    const value = match[i];
-    if (!value) {
-      continue;
-    }
-    params[name] = decodeURIComponent(value);
-  }
-}

package/src/validate.ts

@@ -1,121 +0,0 @@
-import {
-  dereference,
-  OutputUnit,
-  Schema,
-  validate as schemaValidate
-} from '@cfworker/json-schema';
-import { HttpError } from './http-error.js';
-import { Middleware } from './middleware.js';
-
-export interface RequestSchemas {
-  body?: Schema;
-  headers?: Schema;
-  params?: Schema;
-  search?: Schema;
-}
-
-export type RequestPart = keyof RequestSchemas;
-
-export type RequestParser = (data: URLSearchParams | FormData) => any;
-
-const draft = '2019-09';
-
-const hasBody: Record<string, true> = {
-  POST: true,
-  PUT: true,
-  DELETE: true,
-  PATCH: true
-};
-
-function middlewareFactory(
-  schemas: RequestSchemas,
-  parser: RequestParser = Object.fromEntries,
-  lookup: Record<string, Schema | boolean> = Object.create(null)
-): Middleware {
-  const {
-    headers: $headers,
-    search: $search,
-    params: $params,
-    body: $body
-  } = schemas;
-
-  if ($headers) {
-    dereference($headers, { ...lookup });
-  }
-  if ($search) {
-    dereference($search, { ...lookup });
-  }
-  if ($params) {
-    dereference($params, { ...lookup });
-  }
-  if ($body) {
-    dereference($body, { ...lookup });
-  }
-
-  return async ({ req }, next) => {
-    if ($params) {
-      validateRequestPart('params', req.params, $params, lookup);
-    }
-    if ($headers) {
-      const headers = Object.fromEntries(req.headers);
-      validateRequestPart('headers', headers, $headers, lookup);
-    }
-    if ($search) {
-      const search = parser(req.url.searchParams);
-      validateRequestPart('search', search, $search, lookup);
-    }
-    if ($body && hasBody[req.method]) {
-      let body: any;
-      const contentType = req.headers.get('content-type') || '';
-      if (
-        contentType === 'application/x-www-form-urlencoded' ||
-        contentType.startsWith('application/x-www-form-urlencoded;') ||
-        contentType.startsWith('multipart/form-data;')
-      ) {
-        const form = await req.body.formData();
-        body = parser(form);
-      } else {
-        body = await req.body.json();
-      }
-      validateRequestPart('body', body, $body, lookup);
-    }
-    await next();
-  };
-}
-
-export const messages: Record<RequestPart, string> = {
-  params: 'Parameters in request path are invalid.',
-  headers: 'Headers are invalid.',
-  search: 'Query string parameters are invalid.',
-  body: 'Body is invalid.'
-};
-
-export interface RequestValidationErrorBody {
-  status: 400;
-  part: RequestPart;
-  message: string;
-  errors: OutputUnit[];
-  schema: Schema;
-}
-
-function validateRequestPart(
-  part: RequestPart,
-  instance: any,
-  schema: Schema,
-  lookup: Record<string, boolean | Schema>
-) {
-  const result = schemaValidate(instance, schema, draft, lookup);
-  if (result.valid) {
-    return;
-  }
-  const errorBody: RequestValidationErrorBody = {
-    status: 400,
-    part,
-    message: messages[part],
-    errors: result.errors,
-    schema
-  };
-  throw new HttpError(400, errorBody);
-}
-
-export const validate: typeof middlewareFactory = middlewareFactory;