routup 0.12.0 → 0.13.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021-2022 Peter Placzek
+Copyright (c) 2022-present Peter Placzek
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -62,16 +62,17 @@ router.listen(3000);
 According to the fact that routup is a minimalistic framework, it depends on plugins to cover some 
 typically http framework functions, which are not integrated in the main package.
 
-| Name                                                           | Description                                                            |
-|----------------------------------------------------------------|------------------------------------------------------------------------|
-| [body](https://www.npmjs.com/package/@routup/body)             | Read and parse the request body.                                       |
-| [cookie](https://www.npmjs.com/package/@routup/cookie)         | Read and parse request cookies and serialize cookies for the response. |
-| [decorators](https://www.npmjs.com/package/@routup/decorators) | Create request handlers with class-, method- & parameter-decorators.   |
-| [prometheus](https://www.npmjs.com/package/@routup/prometheus) | Collect and serve metrics for prometheus.                              |
-| [query](https://www.npmjs.com/package/@routup/query)           | Read and parse the query string of the request url.                    |
-| [rate-limit](https://www.npmjs.com/package/@routup/rate-limit) | Rate limit incoming requests.                                          |
-| [static](https://www.npmjs.com/package/@routup/static)         | Serve static files from a directory.                                   |
-| [swagger](https://www.npmjs.com/package/@routup/swagger)       | Serve generated docs from URL or based on a JSON file.                 |
+| Name                                                                       | Description                                                            |
+|----------------------------------------------------------------------------|------------------------------------------------------------------------|
+| [body](https://www.npmjs.com/package/@routup/body)                         | Read and parse the request body.                                       |
+| [cookie](https://www.npmjs.com/package/@routup/cookie)                     | Read and parse request cookies and serialize cookies for the response. |
+| [decorators](https://www.npmjs.com/package/@routup/decorators)             | Create request handlers with class-, method- & parameter-decorators.   |
+| [prometheus](https://www.npmjs.com/package/@routup/prometheus)             | Collect and serve metrics for prometheus.                              |
+| [query](https://www.npmjs.com/package/@routup/query)                       | Read and parse the query string of the request url.                    |
+| [rate-limit](https://www.npmjs.com/package/@routup/rate-limit)             | Rate limit incoming requests.                                          |
+| [rate-limit-redis](https://www.npmjs.com/package/@routup/rate-limit-redis) | Redis adapter for the rate-limit plugin.                               |
+| [static](https://www.npmjs.com/package/@routup/static)                     | Serve static files from a directory.                                   |
+| [swagger](https://www.npmjs.com/package/@routup/swagger)                   | Serve generated docs from URL or based on a JSON file.                 |
 
 ## License
 

package/dist/handler/index.d.ts

@@ -1,2 +1,2 @@
-export * from './utils';
+export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/handler/utils.d.ts

@@ -1,3 +1,3 @@
-import { Next, Response } from '@routup/core';
-export declare function processHandlerExecutionOutput(res: Response, next: Next, output?: unknown): void;
+import type { Next, Response } from '@routup/core';
+export declare function processHandlerExecutionOutput(res: Response, next: Next, output?: unknown): void;
 //# sourceMappingURL=utils.d.ts.map

package/dist/handler/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/handler/utils.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAQ,MAAM,cAAc,CAAC;AAGpD,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,OAAO,QAiBxF"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/handler/utils.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAInD,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,OAAO,QAiBxF"}

package/dist/index.cjs

@@ -0,0 +1,579 @@
+'use strict';
+
+var core = require('@routup/core');
+var smob = require('smob');
+var http = require('@ebec/http');
+var pathToRegexp = require('path-to-regexp');
+var node_http = require('node:http');
+
+/*
+ * Copyright (c) 2022-2022.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ function isInstance(input, name) {
+    return typeof input === 'object' && input !== null && input['@instanceof'] === Symbol.for(name);
+}
+
+/*
+ * Copyright (c) 2022.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ function isPath(input) {
+    return typeof input === 'string' || input instanceof RegExp;
+}
+
+function isPromise(p) {
+    return smob.isObject(p) && (p instanceof Promise || // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    typeof p.then === 'function');
+}
+
+/* istanbul ignore next */ function createRequestTimeout(res, timeout, done) {
+    const instance = setTimeout(()=>{
+        res.statusCode = http.GatewayTimeoutErrorOptions.statusCode;
+        res.statusMessage = http.GatewayTimeoutErrorOptions.message;
+        res.end();
+    }, timeout);
+    res.once('close', ()=>{
+        clearTimeout(instance);
+        if (typeof done === 'function') {
+            done();
+        }
+    });
+    res.once('error', (e)=>{
+        clearTimeout(instance);
+        if (typeof done === 'function') {
+            done(e);
+        }
+    });
+}
+
+function processHandlerExecutionOutput(res, next, output) {
+    if (isPromise(output)) {
+        output.then((r)=>{
+            if (typeof r !== 'undefined') {
+                core.send(res, r);
+            }
+            return r;
+        }).catch(next);
+        return;
+    }
+    if (typeof output !== 'undefined') {
+        core.send(res, output);
+    }
+}
+
+function decodeParam(val) {
+    /* istanbul ignore next */ if (typeof val !== 'string' || val.length === 0) {
+        return val;
+    }
+    return decodeURIComponent(val);
+}
+class PathMatcher {
+    test(path) {
+        const fastSlash = this.path === '/' && this.regexpOptions.end === false;
+        if (fastSlash) {
+            return true;
+        }
+        return this.regexp.test(path);
+    }
+    exec(path) {
+        let match = null;
+        const fastSlash = this.path === '/' && this.regexpOptions.end === false;
+        if (fastSlash) {
+            return {
+                path: '/',
+                params: {}
+            };
+        }
+        match = this.regexp.exec(path);
+        if (!match) {
+            return undefined;
+        }
+        if (this.path instanceof RegExp) {
+            return {
+                path,
+                params: {
+                    0: decodeParam(match[0])
+                }
+            };
+        }
+        const output = {};
+        for(let i = 1; i < match.length; i++){
+            const key = this.regexpKeys[i - 1];
+            const prop = key.name;
+            const val = decodeParam(match[i]);
+            if (typeof val !== 'undefined') {
+                output[prop] = val;
+            }
+        }
+        return {
+            path: match[0],
+            params: output
+        };
+    }
+    constructor(path, options){
+        this.regexpKeys = [];
+        this.path = path;
+        this.regexpOptions = options || {};
+        if (path instanceof RegExp) {
+            this.regexp = path;
+        } else {
+            this.regexp = pathToRegexp.pathToRegexp(path, this.regexpKeys, options);
+        }
+    }
+}
+
+class Layer {
+    // --------------------------------------------------
+    isError() {
+        return this.fn.length === 4;
+    }
+    dispatch(req, res, meta, next, err) {
+        core.setRequestParams(req, meta.params || {});
+        core.setRequestMountPath(req, meta.mountPath || '/');
+        if (typeof err !== 'undefined') {
+            if (this.fn.length === 4) {
+                try {
+                    this.fn(err, req, res, next);
+                } catch (e) {
+                    /* istanbul ignore next */ /* istanbul ignore next */ if (e instanceof Error) {
+                        next(e);
+                    } else {
+                        next(new http.BadRequestError({
+                            message: 'The request could not be processed by the error handler.'
+                        }));
+                    }
+                }
+                return;
+            }
+            /* istanbul ignore next */ next(err);
+            /* istanbul ignore next */ return;
+        }
+        /* istanbul ignore next */ if (this.fn.length > 3) {
+            next();
+            return;
+        }
+        try {
+            const output = this.fn(req, res, next);
+            processHandlerExecutionOutput(res, next, output);
+        } catch (e) {
+            /* istanbul ignore next */ if (e instanceof Error) {
+                next(e);
+            } else {
+                next(new http.BadRequestError({
+                    message: 'The request could not be processed by the handler.'
+                }));
+            }
+        }
+    }
+    // --------------------------------------------------
+    matchPath(path) {
+        return this.pathMatcher.test(path);
+    }
+    exec(path) {
+        return this.pathMatcher.exec(path);
+    }
+    // --------------------------------------------------
+    constructor(options, fn){
+        this['@instanceof'] = Symbol.for('Layer');
+        this.pathMatcher = new PathMatcher(options.path, options.pathMatcher);
+        this.fn = fn;
+    }
+}
+
+function isLayerInstance(input) {
+    return isInstance(input, 'Layer');
+}
+
+class Route {
+    // --------------------------------------------------
+    matchPath(path) {
+        return this.pathMatcher.test(path);
+    }
+    matchMethod(method) {
+        let name = method.toLowerCase();
+        if (name === core.Method.HEAD && !smob.hasOwnProperty(this.layers, name)) {
+            name = core.Method.GET;
+        }
+        return Object.prototype.hasOwnProperty.call(this.layers, name);
+    }
+    // --------------------------------------------------
+    getMethods() {
+        const keys = Object.keys(this.layers);
+        if (smob.hasOwnProperty(this.layers, core.Method.GET) && !smob.hasOwnProperty(this.layers, core.Method.HEAD)) {
+            keys.push(core.Method.HEAD);
+        }
+        return keys;
+    }
+    // --------------------------------------------------
+    dispatch(req, res, meta, done) {
+        /* istanbul ignore next */ if (!req.method) {
+            done();
+            return;
+        }
+        let name = req.method.toLowerCase();
+        if (name === core.Method.HEAD && !smob.hasOwnProperty(this.layers, name)) {
+            name = core.Method.GET;
+        }
+        const layers = this.layers[name];
+        /* istanbul ignore next */ if (typeof layers === 'undefined' || layers.length === 0 || typeof meta.path === 'undefined') {
+            done();
+            return;
+        }
+        const layerMeta = {
+            ...meta
+        };
+        const output = this.pathMatcher.exec(meta.path);
+        if (output) {
+            layerMeta.params = smob.merge({}, meta.params || {}, output.params);
+        }
+        let index = -1;
+        const next = (err)=>{
+            index++;
+            if (index >= layers.length) {
+                setImmediate(done, err);
+                return;
+            }
+            const layer = layers[index];
+            if (err && !layer.isError()) {
+                next(err);
+                return;
+            }
+            layer.dispatch(req, res, {
+                ...layerMeta
+            }, next);
+        };
+        next();
+    }
+    // --------------------------------------------------
+    register(method, ...handlers) {
+        this.layers[method] = [];
+        for(let i = 0; i < handlers.length; i++){
+            const layer = new Layer({
+                path: this.path,
+                pathMatcher: this.pathMatcherOptions
+            }, handlers[i]);
+            this.layers[method].push(layer);
+        }
+    }
+    get(...handlers) {
+        return this.register(core.Method.GET, ...handlers);
+    }
+    post(...handlers) {
+        return this.register(core.Method.POST, ...handlers);
+    }
+    put(...handlers) {
+        return this.register(core.Method.PUT, ...handlers);
+    }
+    patch(...handlers) {
+        return this.register(core.Method.PATCH, ...handlers);
+    }
+    delete(...handlers) {
+        return this.register(core.Method.DELETE, ...handlers);
+    }
+    head(...handlers) {
+        return this.register(core.Method.HEAD, ...handlers);
+    }
+    options(...handlers) {
+        return this.register(core.Method.OPTIONS, ...handlers);
+    }
+    // --------------------------------------------------
+    isStrictPath() {
+        return typeof this.path !== 'string' || this.path !== '/' && this.path.length !== 0;
+    }
+    // --------------------------------------------------
+    constructor(options){
+        this['@instanceof'] = Symbol.for('Route');
+        this.layers = {};
+        this.path = options.path;
+        this.pathMatcherOptions = {
+            end: true,
+            strict: this.isStrictPath(),
+            ...options.pathMatcher
+        };
+        this.pathMatcher = new PathMatcher(this.path, this.pathMatcherOptions);
+    }
+}
+
+function isRouteInstance(input) {
+    return isInstance(input, 'Route');
+}
+
+function isRouterInstance(input) {
+    return isInstance(input, 'Router');
+}
+class Router {
+    // --------------------------------------------------
+    setPathMatcherOptions(input) {
+        this.pathMatcherOptions = input;
+        if (this.pathMatcher) {
+            this.pathMatcher.regexpOptions = this.pathMatcherOptions;
+        }
+    }
+    setPath(value) {
+        if (value === '/' || !isPath(value)) {
+            this.path = '/';
+            return;
+        }
+        if (typeof value === 'string') {
+            this.path = core.withLeadingSlash(core.withoutTrailingSlash(`${value}`));
+        } else {
+            this.path = value;
+        }
+        this.pathMatcher = new PathMatcher(this.path, this.pathMatcherOptions);
+    }
+    // --------------------------------------------------
+    createListener() {
+        this.isRoot = true;
+        return (req, res)=>{
+            this.dispatch(req, res);
+        };
+    }
+    /* istanbul ignore next */ listen(port) {
+        const server = node_http.createServer(this.createListener());
+        return server.listen(port);
+    }
+    // --------------------------------------------------
+    matchPath(path) {
+        if (this.pathMatcher) {
+            return this.pathMatcher.test(path);
+        }
+        return true;
+    }
+    // --------------------------------------------------
+    dispatch(req, res, meta, done) {
+        let index = -1;
+        meta = meta || {};
+        let allowedMethods = [];
+        if (this.isRoot && typeof this.timeout === 'number') {
+            createRequestTimeout(res, this.timeout, done);
+        }
+        const fn = (err)=>{
+            /* istanbul ignore if */ if (!this.isRoot) {
+                if (typeof done !== 'undefined') {
+                    setImmediate(()=>done(err));
+                }
+                return;
+            }
+            if (typeof err !== 'undefined') {
+                res.statusCode = 400;
+                res.end();
+                return;
+            }
+            if (req.method && req.method.toLowerCase() === core.Method.OPTIONS) {
+                const options = allowedMethods.map((key)=>key.toUpperCase()).join(',');
+                res.setHeader(core.HeaderName.ALLOW, options);
+                core.send(res, options);
+                return;
+            }
+            res.statusCode = 404;
+            res.end();
+        };
+        let path = meta.path || core.useRequestPath(req);
+        if (this.pathMatcher) {
+            const output = this.pathMatcher.exec(path);
+            if (typeof output !== 'undefined') {
+                meta.mountPath = core.cleanDoubleSlashes(`${meta.mountPath || ''}/${output.path}`);
+                if (path === output.path) {
+                    path = '/';
+                } else {
+                    path = core.withLeadingSlash(path.substring(output.path.length));
+                }
+                meta.params = smob.merge(meta.params || {}, output.params);
+            }
+        }
+        meta.path = path;
+        if (!meta.mountPath) {
+            meta.mountPath = '/';
+        }
+        const next = (err)=>{
+            if (index >= this.stack.length) {
+                setImmediate(fn, err);
+                return;
+            }
+            let layer;
+            let match = false;
+            while(!match && index < this.stack.length){
+                index++;
+                layer = this.stack[index];
+                if (isLayerInstance(layer)) {
+                    if (!layer.isError() && err) {
+                        continue;
+                    }
+                    match = layer.matchPath(path);
+                }
+                if (isRouterInstance(layer)) {
+                    match = layer.matchPath(path);
+                }
+                if (isRouteInstance(layer)) {
+                    match = layer.matchPath(path);
+                    if (req.method && !layer.matchMethod(req.method)) {
+                        match = false;
+                        if (req.method.toLowerCase() === core.Method.OPTIONS) {
+                            allowedMethods = smob.mergeArrays(allowedMethods, layer.getMethods(), true);
+                        }
+                    }
+                }
+            }
+            if (!match || !layer) {
+                setImmediate(fn, err);
+                return;
+            }
+            const layerMeta = {
+                ...meta
+            };
+            if (isLayerInstance(layer)) {
+                const output = layer.exec(path);
+                if (output) {
+                    layerMeta.params = smob.merge(output.params, layerMeta.params || {});
+                    layerMeta.mountPath = core.cleanDoubleSlashes(`${layerMeta.mountPath || ''}/${output.path}`);
+                }
+            }
+            if (err) {
+                if (isLayerInstance(layer) && layer.isError()) {
+                    layer.dispatch(req, res, layerMeta, next, err);
+                    return;
+                }
+                /* istanbul ignore next */ setImmediate(next, err);
+                return;
+            }
+            layer.dispatch(req, res, layerMeta, next);
+        };
+        next();
+    }
+    /* istanbul ignore next */ dispatchAsync(req, res) {
+        return new Promise((resolve, reject)=>{
+            this.dispatch(req, res, {}, (err)=>{
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    // --------------------------------------------------
+    route(path) {
+        if (typeof path === 'string' && path.length > 0) {
+            path = core.withLeadingSlash(path);
+        }
+        const index = this.stack.findIndex((item)=>isRouteInstance(item) && item.path === path);
+        if (index !== -1) {
+            return this.stack[index];
+        }
+        const route = new Route({
+            path,
+            pathMatcher: {
+                sensitive: this.pathMatcherOptions.sensitive
+            }
+        });
+        this.stack.push(route);
+        return route;
+    }
+    delete(path, ...handlers) {
+        const route = this.route(path);
+        route.delete(...handlers);
+        return this;
+    }
+    get(path, ...handlers) {
+        const route = this.route(path);
+        route.get(...handlers);
+        return this;
+    }
+    post(path, ...handlers) {
+        const route = this.route(path);
+        route.post(...handlers);
+        return this;
+    }
+    put(path, ...handlers) {
+        const route = this.route(path);
+        route.put(...handlers);
+        return this;
+    }
+    patch(path, ...handlers) {
+        const route = this.route(path);
+        route.patch(...handlers);
+        return this;
+    }
+    head(path, ...handlers) {
+        const route = this.route(path);
+        route.head(...handlers);
+        return this;
+    }
+    options(path, ...handlers) {
+        const route = this.route(path);
+        route.options(...handlers);
+        return this;
+    }
+    use(...input) {
+        /* istanbul ignore next */ if (input.length === 0) {
+            return this;
+        }
+        let path;
+        if (isPath(input[0])) {
+            path = input.shift();
+        }
+        for(let i = 0; i < input.length; i++){
+            const item = input[i];
+            if (isRouterInstance(item)) {
+                if (path) {
+                    item.setPath(path);
+                }
+                item.setPathMatcherOptions(this.pathMatcherOptions);
+                this.stack.push(item);
+                continue;
+            }
+            if (typeof item === 'function') {
+                this.stack.push(new Layer({
+                    path: path || '/',
+                    pathMatcher: {
+                        strict: false,
+                        end: false,
+                        sensitive: this.pathMatcherOptions.sensitive
+                    }
+                }, item));
+            }
+        }
+        return this;
+    }
+    // --------------------------------------------------
+    constructor(ctx){
+        this['@instanceof'] = Symbol.for('Router');
+        /**
+     * Array of mounted layers, routes & routers.
+     *
+     * @protected
+     */ this.stack = [];
+        ctx = ctx || {};
+        this.pathMatcherOptions = {
+            end: false,
+            sensitive: true,
+            ...ctx.pathMatcher || {}
+        };
+        this.timeout = ctx.timeout;
+        this.setPath(ctx.path || '/');
+    }
+}
+
+exports.Layer = Layer;
+exports.PathMatcher = PathMatcher;
+exports.Route = Route;
+exports.Router = Router;
+exports.createRequestTimeout = createRequestTimeout;
+exports.isInstance = isInstance;
+exports.isLayerInstance = isLayerInstance;
+exports.isPath = isPath;
+exports.isPromise = isPromise;
+exports.isRouteInstance = isRouteInstance;
+exports.isRouterInstance = isRouterInstance;
+exports.processHandlerExecutionOutput = processHandlerExecutionOutput;
+Object.keys(core).forEach(function (k) {
+    if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return core[k]; }
+    });
+});
+//# sourceMappingURL=index.cjs.map