@cfworker/web 1.9.0

package/src/router.ts

@@ -0,0 +1,141 @@
+import {
+  Key,
+  ParseOptions,
+  pathToRegexp,
+  TokensToRegexpOptions
+} 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;
+};
+export const Get = Method('get');
+export const Post = Method('post');
+export const Put = Method('put');
+export const Patch = Method('patch');
+export const Delete = Method('delete');
+export const Head = Method('head');
+export const Options = Method('options');
+
+export const Header = (header: string, value: string) => {
+  value = value.toLowerCase();
+  return ({ req }: Context) => req.headers.get(header) === value;
+};
+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);
+
+  return ({ req: { url, params } }: Context) => {
+    const match = url.pathname.match(regExp);
+    if (!match) {
+      return false;
+    }
+    collectParameters(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[]) {
+    const opts = this.options.pathToRegExpOptions;
+    return this.compose([Get, Path(pathname, opts)], ...middleware);
+  }
+
+  public post(pathname: string, ...middleware: Middleware[]) {
+    const opts = this.options.pathToRegExpOptions;
+    return this.compose([Post, Path(pathname, opts)], ...middleware);
+  }
+
+  public put(pathname: string, ...middleware: Middleware[]) {
+    const opts = this.options.pathToRegExpOptions;
+    return this.compose([Put, Path(pathname, opts)], ...middleware);
+  }
+
+  public patch(pathname: string, ...middleware: Middleware[]) {
+    const opts = this.options.pathToRegExpOptions;
+    return this.compose([Patch, Path(pathname, opts)], ...middleware);
+  }
+
+  public delete(pathname: string, ...middleware: Middleware[]) {
+    const opts = this.options.pathToRegExpOptions;
+    return this.compose([Delete, Path(pathname, opts)], ...middleware);
+  }
+
+  public head(pathname: string, ...middleware: Middleware[]) {
+    const opts = this.options.pathToRegExpOptions;
+    return this.compose([Head, Path(pathname, opts)], ...middleware);
+  }
+
+  public all(pathname: string, ...middleware: Middleware[]) {
+    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[]) {
+    this.routes.push({
+      conditions,
+      middleware: composeMiddleware(middleware)
+    });
+    return this;
+  }
+
+  private resolve(ctx: Context) {
+    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/to-object.ts

@@ -0,0 +1,15 @@
+/**
+ * Convert an iterable to an object.
+ */
+export function toObject<
+  TKey extends string | number | symbol,
+  TValue
+>(iterable: {
+  [Symbol.iterator](): IterableIterator<[TKey, TValue]>;
+}): Record<TKey, TValue> {
+  const obj = Object.create(null) as Record<TKey, TValue>;
+  for (const [key, value] of iterable) {
+    obj[key] = value;
+  }
+  return obj;
+}

package/src/validate.ts

@@ -0,0 +1,122 @@
+import {
+  dereference,
+  OutputUnit,
+  Schema,
+  validate as schemaValidate
+} from '@cfworker/json-schema';
+import { HttpError } from './http-error.js';
+import { Middleware } from './middleware.js';
+import { toObject } from './to-object.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 = toObject,
+  lookup = 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 = toObject(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 = middlewareFactory;

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig-base",
+  "compilerOptions": {
+    "target": "esnext",
+    "lib": ["esnext", "webworker"],
+    "types": ["@cfworker/worker-types", "@cloudflare/workers-types"],
+    "outDir": "dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"],
+  "references": [{ "path": "../json-schema" }]
+}