@cfworker/web 2.1.0 → 4.0.0

package/dist/cjs/accepts.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Accepts = void 0;
+const charset_js_1 = require("negotiator/lib/charset.js");
+const encoding_js_1 = require("negotiator/lib/encoding.js");
+const language_js_1 = require("negotiator/lib/language.js");
+const mediaType_js_1 = require("negotiator/lib/mediaType.js");
+const parseAccept = mediaType_js_1.preferredMediaTypes;
+const parseAcceptLanguage = language_js_1.preferredLanguages;
+const parseAcceptEncoding = encoding_js_1.preferredEncodings;
+const parseAcceptCharset = charset_js_1.preferredCharsets;
+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;
+    }
+}
+exports.Accepts = Accepts;

package/dist/{application.d.ts → cjs/application.d.ts}

@@ -3,7 +3,7 @@ export declare class Application {
     private readonly middleware;
     private _composedMiddleware?;
     private get composedMiddleware();
-    use(middleware: Middleware): this;
+    use(middleware: Middleware): Application;
     handleRequest(request: Request, env: any, context: {
         waitUntil(promise: Promise<any>): void;
     }): Promise<Response>;

package/dist/cjs/application.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Application = void 0;
+const statuses_1 = __importDefault(require("statuses"));
+const context_js_1 = require("./context.js");
+const http_error_js_1 = require("./http-error.js");
+const middleware_js_1 = require("./middleware.js");
+const resolved = Promise.resolve();
+class Application {
+    middleware = [];
+    _composedMiddleware;
+    get composedMiddleware() {
+        if (!this._composedMiddleware) {
+            this._composedMiddleware = (0, middleware_js_1.composeMiddleware)(this.middleware);
+        }
+        return this._composedMiddleware;
+    }
+    use(middleware) {
+        this.middleware.push(middleware);
+        this._composedMiddleware = undefined;
+        return this;
+    }
+    async handleRequest(request, env, context) {
+        return this.invokeMiddleware(new context_js_1.Context(request, env, context), this.composedMiddleware);
+    }
+    async invokeMiddleware(context, middleware) {
+        try {
+            await middleware(context, () => resolved);
+            return context.res.create();
+        }
+        catch (err) {
+            console.error(err?.stack ?? err);
+            if (err instanceof http_error_js_1.HttpError) {
+                return err.toResponse();
+            }
+            const status = 500;
+            const statusText = statuses_1.default.message[500];
+            const headers = { 'content-type': 'text/plain' };
+            return new Response(statusText, { status, statusText, headers });
+        }
+    }
+}
+exports.Application = Application;

package/dist/cjs/context.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+const cookies_js_1 = require("./cookies.js");
+const req_js_1 = require("./req.js");
+const response_builder_js_1 = require("./response-builder.js");
+class Context {
+    environmentBindings;
+    _context;
+    req;
+    res;
+    cookies;
+    state;
+    constructor(request, environmentBindings, _context) {
+        this.environmentBindings = environmentBindings;
+        this._context = _context;
+        this.req = new req_js_1.Req(request);
+        this.res = new response_builder_js_1.ResponseBuilder();
+        this.cookies = new cookies_js_1.Cookies(request.headers, this.res.headers);
+        this.state = {};
+    }
+    waitUntil(promise) {
+        this._context.waitUntil(promise);
+    }
+}
+exports.Context = Context;

package/dist/{cookies.d.ts → cjs/cookies.d.ts}

@@ -1,8 +1,8 @@
-import { CookieSerializeOptions } from 'cookie';
+import { SerializeOptions } 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;
+    set(name: string, val: string, options?: SerializeOptions): void;
 }

package/dist/cjs/cookies.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cookies = void 0;
+const cookie_1 = require("cookie");
+const noCookies = Object.create(null);
+class Cookies {
+    responseHeaders;
+    requestCookies;
+    constructor(requestHeaders, responseHeaders) {
+        this.responseHeaders = responseHeaders;
+        const cookie = requestHeaders.get('cookie');
+        this.requestCookies = cookie ? (0, cookie_1.parse)(cookie) : noCookies;
+    }
+    get(name) {
+        return this.requestCookies[name] || null;
+    }
+    set(name, val, options) {
+        this.responseHeaders.append('Set-Cookie', (0, cookie_1.serialize)(name, val, options));
+    }
+}
+exports.Cookies = Cookies;

package/dist/cjs/http-error.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpError = void 0;
+const statuses_1 = __importDefault(require("statuses"));
+class HttpError extends Error {
+    status;
+    statusText;
+    body;
+    constructor(status, body) {
+        const statusText = statuses_1.default.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;
+    }
+    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 });
+    }
+}
+exports.HttpError = HttpError;

package/dist/cjs/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var html_escaper_1 = require("html-escaper");
+Object.defineProperty(exports, "htmlEncode", { enumerable: true, get: function () { return html_escaper_1.escape; } });
+__exportStar(require("./accepts.js"), exports);
+__exportStar(require("./application.js"), exports);
+__exportStar(require("./context.js"), exports);
+__exportStar(require("./cookies.js"), exports);
+__exportStar(require("./http-error.js"), exports);
+__exportStar(require("./middleware.js"), exports);
+__exportStar(require("./normalize-pathname.js"), exports);
+__exportStar(require("./req.js"), exports);
+__exportStar(require("./response-builder.js"), exports);
+__exportStar(require("./router.js"), exports);
+__exportStar(require("./validate.js"), exports);

package/dist/cjs/middleware.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeMiddleware = composeMiddleware;
+function composeMiddleware(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) {
+        let index = -1;
+        return dispatch(0);
+        function dispatch(i) {
+            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/dist/cjs/normalize-pathname.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePathnameMiddleware = void 0;
+exports.normalizePathname = normalizePathname;
+const http_error_1 = require("./http-error");
+function normalizePathname(pathname) {
+    return decodeURIComponent(pathname).replace(/\/\/+/g, '/').normalize();
+}
+const normalizePathnameMiddleware = async ({ req }, next) => {
+    const pathname = req.url.pathname;
+    try {
+        req.url.pathname = normalizePathname(pathname);
+    }
+    catch (err) {
+        if (err instanceof URIError) {
+            throw new http_error_1.HttpError(400, `Unable to decode pathname "${pathname}".`);
+        }
+        throw err;
+    }
+    await next();
+};
+exports.normalizePathnameMiddleware = normalizePathnameMiddleware;

package/dist/cjs/req.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReqBody = exports.Req = void 0;
+const secure_json_parse_1 = require("secure-json-parse");
+const accepts_js_1 = require("./accepts.js");
+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_js_1.Accepts(request.headers);
+        this.body = new ReqBody(request);
+    }
+}
+exports.Req = Req;
+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 => (0, secure_json_parse_1.safeParse)(text, reviver));
+        }
+        return this._json;
+    }
+    text() {
+        if (!this._text) {
+            this._text = this.request.text();
+        }
+        return this._text;
+    }
+}
+exports.ReqBody = ReqBody;

package/dist/cjs/response-builder.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseBuilder = void 0;
+const statuses_1 = __importDefault(require("statuses"));
+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_1.default.empty[value]) {
+            this.body = null;
+        }
+    }
+    get statusText() {
+        return statuses_1.default.message[this._status];
+    }
+    get body() {
+        return this._body;
+    }
+    set body(value) {
+        this._body = value;
+        if (value === null) {
+            if (!statuses_1.default.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_1.default.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 });
+    }
+}
+exports.ResponseBuilder = ResponseBuilder;

package/dist/cjs/router.d.ts

@@ -0,0 +1,39 @@
+import { PathToRegexpOptions } from 'path-to-regexp';
+import { Context } from './context.js';
+import { Middleware } from './middleware.js';
+export type Predicate = (context: Context) => boolean;
+export declare const Method: (method: string) => Predicate;
+export declare const Get: Predicate;
+export declare const Post: Predicate;
+export declare const Put: Predicate;
+export declare const Patch: Predicate;
+export declare const Delete: Predicate;
+export declare const Head: Predicate;
+export declare const Options: Predicate;
+export declare const Header: (header: string, value: string) => Predicate;
+export declare const Host: (host: string) => Predicate;
+export declare const Path: (pattern: string, options?: PathToRegexpOptions) => Predicate;
+export 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[]): Router;
+    post(pathname: string, ...middleware: Middleware[]): Router;
+    put(pathname: string, ...middleware: Middleware[]): Router;
+    patch(pathname: string, ...middleware: Middleware[]): Router;
+    delete(pathname: string, ...middleware: Middleware[]): Router;
+    head(pathname: string, ...middleware: Middleware[]): Router;
+    all(pathname: string, ...middleware: Middleware[]): Router;
+    middleware: Middleware;
+    compose(conditions: RouteCondition[], ...middleware: Middleware[]): Router;
+    resolve(ctx: Context): Route | undefined;
+}

package/dist/cjs/router.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = exports.defaultRouterOptions = exports.Path = exports.Host = exports.Header = exports.Options = exports.Head = exports.Delete = exports.Patch = exports.Put = exports.Post = exports.Get = exports.Method = void 0;
+const path_to_regexp_1 = require("path-to-regexp");
+const middleware_js_1 = require("./middleware.js");
+const Method = (method) => {
+    method = method.toUpperCase();
+    return ({ req }) => req.method === method;
+};
+exports.Method = Method;
+exports.Get = (0, exports.Method)('get');
+exports.Post = (0, exports.Method)('post');
+exports.Put = (0, exports.Method)('put');
+exports.Patch = (0, exports.Method)('patch');
+exports.Delete = (0, exports.Method)('delete');
+exports.Head = (0, exports.Method)('head');
+exports.Options = (0, exports.Method)('options');
+const Header = (header, value) => {
+    value = value.toLowerCase();
+    return ({ req }) => req.headers.get(header) === value;
+};
+exports.Header = Header;
+const Host = (host) => (0, exports.Header)('host', host);
+exports.Host = Host;
+const Path = (pattern, options) => {
+    const { regexp, keys } = (0, path_to_regexp_1.pathToRegexp)(pattern, options);
+    return ({ req: { url, params } }) => {
+        const match = url.pathname.match(regexp);
+        if (!match) {
+            return false;
+        }
+        collectParameters(keys, match, params);
+        return true;
+    };
+};
+exports.Path = Path;
+exports.defaultRouterOptions = {
+    pathToRegExpOptions: {}
+};
+class Router {
+    options;
+    routes;
+    constructor(options = exports.defaultRouterOptions) {
+        this.options = options;
+        this.routes = [];
+    }
+    get(pathname, ...middleware) {
+        const opts = this.options.pathToRegExpOptions;
+        return this.compose([exports.Get, (0, exports.Path)(pathname, opts)], ...middleware);
+    }
+    post(pathname, ...middleware) {
+        const opts = this.options.pathToRegExpOptions;
+        return this.compose([exports.Post, (0, exports.Path)(pathname, opts)], ...middleware);
+    }
+    put(pathname, ...middleware) {
+        const opts = this.options.pathToRegExpOptions;
+        return this.compose([exports.Put, (0, exports.Path)(pathname, opts)], ...middleware);
+    }
+    patch(pathname, ...middleware) {
+        const opts = this.options.pathToRegExpOptions;
+        return this.compose([exports.Patch, (0, exports.Path)(pathname, opts)], ...middleware);
+    }
+    delete(pathname, ...middleware) {
+        const opts = this.options.pathToRegExpOptions;
+        return this.compose([exports.Delete, (0, exports.Path)(pathname, opts)], ...middleware);
+    }
+    head(pathname, ...middleware) {
+        const opts = this.options.pathToRegExpOptions;
+        return this.compose([exports.Head, (0, exports.Path)(pathname, opts)], ...middleware);
+    }
+    all(pathname, ...middleware) {
+        const opts = this.options.pathToRegExpOptions;
+        return this.compose([(0, exports.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: (0, middleware_js_1.composeMiddleware)(middleware)
+        });
+        return this;
+    }
+    resolve(ctx) {
+        return this.routes.find(({ conditions }) => conditions.length === 0 || conditions.every(c => c(ctx)));
+    }
+}
+exports.Router = Router;
+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/{validate.d.ts → cjs/validate.d.ts}

@@ -8,7 +8,7 @@ export interface RequestSchemas {
 }
 export type RequestPart = keyof RequestSchemas;
 export type RequestParser = (data: URLSearchParams | FormData) => any;
-declare function middlewareFactory(schemas: RequestSchemas, parser?: RequestParser, lookup?: any): Middleware;
+declare function middlewareFactory(schemas: RequestSchemas, parser?: RequestParser, lookup?: Record<string, Schema | boolean>): Middleware;
 export declare const messages: Record<RequestPart, string>;
 export interface RequestValidationErrorBody {
     status: 400;