@cfworker/web 1.9.0

package/dist/req.js

@@ -0,0 +1,54 @@
+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;
+        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 {
+    request;
+    _arrayBuffer;
+    _formData;
+    _json;
+    _text;
+    constructor(request) {
+        this.request = request;
+    }
+    arrayBuffer() {
+        if (!this._arrayBuffer) {
+            this._arrayBuffer = this.request.arrayBuffer();
+        }
+        return this._arrayBuffer;
+    }
+    formData() {
+        if (!this._formData) {
+            this._formData = this.request.formData();
+        }
+        return this._formData;
+    }
+    json(reviver) {
+        if (!this._json) {
+            this._json = this.text().then(text => safeParse(text, reviver));
+        }
+        return this._json;
+    }
+    text() {
+        if (!this._text) {
+            this._text = this.request.text();
+        }
+        return this._text;
+    }
+}

package/dist/response-builder.d.ts

@@ -0,0 +1,22 @@
+export declare type ExtendedBodyInit = BodyInit | boolean | Date | number | object | null;
+export declare class ResponseBuilder {
+    readonly headers: Headers;
+    private _status;
+    private _explicitStatus;
+    private _implicitType;
+    private _body;
+    private _stringifyBody;
+    get status(): number;
+    set status(value: number);
+    get statusText(): string;
+    get body(): ExtendedBodyInit | null;
+    set body(value: ExtendedBodyInit | null);
+    redirect(url: string | URL): void;
+    get type(): string;
+    set type(value: string);
+    get lastModified(): string | Date | null;
+    set lastModified(value: string | Date | null);
+    get etag(): string | null;
+    set etag(value: string | null);
+    create(): Response;
+}

package/dist/response-builder.js

@@ -0,0 +1,133 @@
+import statuses from 'statuses';
+export class ResponseBuilder {
+    headers = new Headers();
+    _status = 404;
+    _explicitStatus = false;
+    _implicitType = false;
+    _body = null;
+    _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) {
+        this._body = value;
+        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;
+        }
+        if (!this._explicitStatus) {
+            this._status = 200;
+        }
+        if (value instanceof Blob ||
+            value instanceof FormData ||
+            value instanceof URLSearchParams ||
+            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) {
+        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) {
+        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;
+        return new Response(body, { status, statusText, headers });
+    }
+}
+const Blob = self.Blob || class {
+};

package/dist/router.d.ts

@@ -0,0 +1,40 @@
+import { ParseOptions, TokensToRegexpOptions } 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;
+export declare const Put: ({ req }: Context) => boolean;
+export declare const Patch: ({ req }: Context) => boolean;
+export declare const Delete: ({ req }: Context) => boolean;
+export declare const Head: ({ req }: Context) => boolean;
+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 | undefined) => ({ req: { url, params } }: Context) => boolean;
+export declare type RouteCondition = (context: Context) => boolean;
+export interface Route {
+    conditions: RouteCondition[];
+    middleware: Middleware;
+}
+export interface RouterOptions {
+    pathToRegExpOptions?: PathToRegExpOptions;
+}
+export declare const defaultRouterOptions: RouterOptions;
+export declare class Router {
+    private readonly options;
+    private readonly routes;
+    constructor(options?: RouterOptions);
+    get(pathname: string, ...middleware: Middleware[]): this;
+    post(pathname: string, ...middleware: Middleware[]): this;
+    put(pathname: string, ...middleware: Middleware[]): this;
+    patch(pathname: string, ...middleware: Middleware[]): this;
+    delete(pathname: string, ...middleware: Middleware[]): this;
+    head(pathname: string, ...middleware: Middleware[]): this;
+    all(pathname: string, ...middleware: Middleware[]): this;
+    middleware: Middleware;
+    compose(conditions: RouteCondition[], ...middleware: Middleware[]): this;
+    private resolve;
+}

package/dist/router.js

@@ -0,0 +1,99 @@
+import { pathToRegexp } from 'path-to-regexp';
+import { composeMiddleware } from './middleware.js';
+export const Method = (method) => {
+    method = method.toUpperCase();
+    return ({ req }) => 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, value) => {
+    value = value.toLowerCase();
+    return ({ req }) => req.headers.get(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);
+    return ({ req: { url, params } }) => {
+        const match = url.pathname.match(regExp);
+        if (!match) {
+            return false;
+        }
+        collectParameters(keys, match, params);
+        return true;
+    };
+};
+export const defaultRouterOptions = {
+    pathToRegExpOptions: { strict: true }
+};
+export class Router {
+    options;
+    routes;
+    constructor(options = defaultRouterOptions) {
+        this.options = options;
+        this.routes = [];
+    }
+    get(pathname, ...middleware) {
+        const opts = this.options.pathToRegExpOptions;
+        return this.compose([Get, Path(pathname, opts)], ...middleware);
+    }
+    post(pathname, ...middleware) {
+        const opts = this.options.pathToRegExpOptions;
+        return this.compose([Post, Path(pathname, opts)], ...middleware);
+    }
+    put(pathname, ...middleware) {
+        const opts = this.options.pathToRegExpOptions;
+        return this.compose([Put, Path(pathname, opts)], ...middleware);
+    }
+    patch(pathname, ...middleware) {
+        const opts = this.options.pathToRegExpOptions;
+        return this.compose([Patch, Path(pathname, opts)], ...middleware);
+    }
+    delete(pathname, ...middleware) {
+        const opts = this.options.pathToRegExpOptions;
+        return this.compose([Delete, Path(pathname, opts)], ...middleware);
+    }
+    head(pathname, ...middleware) {
+        const opts = this.options.pathToRegExpOptions;
+        return this.compose([Head, Path(pathname, opts)], ...middleware);
+    }
+    all(pathname, ...middleware) {
+        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,
+            middleware: composeMiddleware(middleware)
+        });
+        return this;
+    }
+    resolve(ctx) {
+        return this.routes.find(({ conditions }) => conditions.length === 0 || conditions.every(c => c(ctx)));
+    }
+}
+function collectParameters(keys, match, params) {
+    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/dist/to-object.d.ts

@@ -0,0 +1,3 @@
+export declare function toObject<TKey extends string | number | symbol, TValue>(iterable: {
+    [Symbol.iterator](): IterableIterator<[TKey, TValue]>;
+}): Record<TKey, TValue>;

package/dist/to-object.js

@@ -0,0 +1,7 @@
+export function toObject(iterable) {
+    const obj = Object.create(null);
+    for (const [key, value] of iterable) {
+        obj[key] = value;
+    }
+    return obj;
+}

package/dist/validate.d.ts

@@ -0,0 +1,21 @@
+import { OutputUnit, Schema } from '@cfworker/json-schema';
+import { Middleware } from './middleware.js';
+export interface RequestSchemas {
+    body?: Schema;
+    headers?: Schema;
+    params?: Schema;
+    search?: Schema;
+}
+export declare type RequestPart = keyof RequestSchemas;
+export declare 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 {
+    status: 400;
+    part: RequestPart;
+    message: string;
+    errors: OutputUnit[];
+    schema: Schema;
+}
+export declare const validate: typeof middlewareFactory;
+export {};

package/dist/validate.js

@@ -0,0 +1,74 @@
+import { dereference, validate as schemaValidate } from '@cfworker/json-schema';
+import { HttpError } from './http-error.js';
+import { toObject } from './to-object.js';
+const draft = '2019-09';
+const hasBody = {
+    POST: true,
+    PUT: true,
+    DELETE: true,
+    PATCH: true
+};
+function middlewareFactory(schemas, parser = toObject, lookup = Object.create(null)) {
+    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;
+            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 = {
+    params: 'Parameters in request path are invalid.',
+    headers: 'Headers are invalid.',
+    search: 'Query string parameters are invalid.',
+    body: 'Body is invalid.'
+};
+function validateRequestPart(part, instance, schema, lookup) {
+    const result = schemaValidate(instance, schema, draft, lookup);
+    if (result.valid) {
+        return;
+    }
+    const errorBody = {
+        status: 400,
+        part,
+        message: messages[part],
+        errors: result.errors,
+        schema
+    };
+    throw new HttpError(400, errorBody);
+}
+export const validate = middlewareFactory;