velocious 1.0.107 → 1.0.109

package/dist/src/logger.js

@@ -0,0 +1,154 @@
+// @ts-check
+import Configuration from "./configuration.js";
+import restArgsError from "./utils/rest-args-error.js";
+/**
+ * @param {string} message
+ * @returns {Promise<void>}
+ */
+function consoleLog(message) {
+    return new Promise((resolve) => {
+        if (process.stdout) {
+            process.stdout.write(`${message}\n`, "utf8", () => resolve());
+        }
+        else {
+            console.log(message);
+            resolve();
+        }
+    });
+}
+/**
+ * @param {string} message
+ * @returns {Promise<void>}
+ */
+function consoleError(message) {
+    return new Promise((resolve) => {
+        if (process.stderr) {
+            process.stderr.write(`${message}\n`, "utf8", () => resolve());
+        }
+        else {
+            console.error(message);
+            resolve();
+        }
+    });
+}
+/**
+ * @param {string} message
+ * @returns {Promise<void>}
+ */
+function consoleWarn(message) {
+    return new Promise((resolve) => {
+        if (process.stderr) {
+            process.stderr.write(`${message}\n`, "utf8", () => resolve());
+        }
+        else {
+            console.warn(message);
+            resolve();
+        }
+    });
+}
+/**
+ * @param {...any|function() : Array<any>} messages
+ * @returns {Array<any>} - Either the function result or the messages
+ */
+function functionOrMessages(...messages) {
+    if (messages.length === 1 && typeof messages[0] == "function") {
+        messages = messages[0]();
+    }
+    return messages;
+}
+/**
+ * Converts multiple message parts into a single string.
+ * @param {...any} messages - Parts to combine into a message
+ * @returns {string}
+ */
+function messagesToMessage(...messages) {
+    let message = "";
+    for (const messagePartIndex in messages) {
+        const messagePart = messages[messagePartIndex];
+        if (typeof messagePartIndex == "number" && messagePartIndex > 0) {
+            message += " ";
+        }
+        if (typeof messagePart == "object") {
+            message += JSON.stringify(messagePart);
+        }
+        else {
+            message += messagePart;
+        }
+    }
+    return message;
+}
+class Logger {
+    /**
+     * @param {any} object
+     * @param {object} args
+     * @param {boolean} args.debug
+     */
+    constructor(object, { debug, ...restArgs } = { debug: false }) {
+        restArgsError(restArgs);
+        this._debug = debug;
+        if (typeof object == "string") {
+            this._subject = object;
+        }
+        else {
+            this._object = object;
+            this._subject = object.constructor.name;
+        }
+        if (!this._subject) {
+            throw new Error(`No subject given`);
+        }
+    }
+    /**
+     * @returns {import("./configuration.js").default}
+     */
+    getConfiguration() {
+        if (!this._configuration) {
+            this._configuration = this._object?.configuration || Configuration.current();
+        }
+        return this._configuration;
+    }
+    /**
+     * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}
+     */
+    async debug(...messages) {
+        if (this._debug || this.getConfiguration()?.debug) {
+            await this.log(...messages);
+        }
+    }
+    /**
+     * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}
+     */
+    async log(...messages) {
+        await consoleLog(messagesToMessage(this._subject, ...functionOrMessages(...messages)));
+    }
+    /**
+     * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}
+     */
+    async error(...messages) {
+        await consoleError(messagesToMessage(this._subject, ...functionOrMessages(...messages)));
+    }
+    /**
+     * @param {boolean} newValue
+     * @returns {void}
+     */
+    setDebug(newValue) {
+        this._debug = newValue;
+    }
+    /**
+     * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}
+     */
+    async warn(...messages) {
+        await consoleWarn(messagesToMessage(this._subject, ...functionOrMessages(...messages)));
+    }
+}
+export { Logger };
+/**
+ * @param {any} object
+ * @param {...Parameters<typeof functionOrMessages>} messages - forwarded args
+ */
+export default async function logger(object, ...messages) {
+    const className = object.constructor.name;
+    const configuration = object.configuration || Configuration.current();
+    if (configuration.debug) {
+        await consoleLog(messagesToMessage(className, ...functionOrMessages(...messages)));
+    }
+}

package/dist/src/routes/app-routes.d.ts

@@ -0,0 +1,8 @@
+export default class VelociousRoutesAppRoutes {
+    /**
+     * @param {import("../configuration.js").default} configuration
+     * @returns {Promise<import("./index.js").default>}
+     */
+    static getRoutes(configuration: import("../configuration.js").default): Promise<import("./index.js").default>;
+}
+//# sourceMappingURL=app-routes.d.ts.map

package/dist/src/routes/app-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-routes.d.ts","sourceRoot":"","sources":["../../../src/routes/app-routes.js"],"names":[],"mappings":"AAIA;IACE;;;OAGG;IACH,gCAHW,OAAO,qBAAqB,EAAE,OAAO,GACnC,OAAO,CAAC,OAAO,YAAY,EAAE,OAAO,CAAC,CAOjD;CACF"}

package/dist/src/routes/app-routes.js

@@ -0,0 +1,13 @@
+// @ts-check
+import { digg } from "diggerize";
+export default class VelociousRoutesAppRoutes {
+    /**
+     * @param {import("../configuration.js").default} configuration
+     * @returns {Promise<import("./index.js").default>}
+     */
+    static async getRoutes(configuration) {
+        // Every client need to make their own routes because they probably can't be shared across different worker threads
+        const routesImport = await configuration.getEnvironmentHandler().importApplicationRoutes();
+        return digg(routesImport, "routes");
+    }
+}

package/dist/src/routes/base-route.d.ts

@@ -0,0 +1,60 @@
+export default class VelociousBaseRoute {
+    /** @type {typeof import("./get-route.js").default} */
+    static GetRouteType: typeof import("./get-route.js").default;
+    /** @type {typeof import("./namespace-route.js").default} */
+    static NameSpaceRouteType: typeof import("./namespace-route.js").default;
+    /** @type {typeof import("./post-route.js").default} */
+    static PostRouteType: typeof import("./post-route.js").default;
+    /** @type {typeof import("./resource-route.js").default} */
+    static ResourceRouteType: typeof import("./resource-route.js").default;
+    /** @param {typeof import("./get-route.js").default} RouteClass */
+    static registerRouteGetType(RouteClass: typeof import("./get-route.js").default): void;
+    /** @param {typeof import("./namespace-route.js").default} RouteClass */
+    static registerRouteNamespaceType(RouteClass: typeof import("./namespace-route.js").default): void;
+    /** @param {typeof import("./post-route.js").default} RouteClass */
+    static registerRoutePostType(RouteClass: typeof import("./post-route.js").default): void;
+    /** @param {typeof import("./resource-route.js").default} RouteClass */
+    static registerRouteResourceType(RouteClass: typeof import("./resource-route.js").default): void;
+    /** @type {Array<VelociousBaseRoute>} */
+    routes: Array<VelociousBaseRoute>;
+    /**
+     * @abstract
+     * @param {string} name
+     */
+    get(name: string): void;
+    /**
+     * @param {object} args
+     * @param {Record<string, any>} args.params
+     * @param {string} args.path
+     * @param {import("../http-server/client/request.js").default} args.request
+     * @returns {{restPath: string} | undefined}
+     */
+    matchWithPath({ params, path, request }: {
+        params: Record<string, any>;
+        path: string;
+        request: import("../http-server/client/request.js").default;
+    }): {
+        restPath: string;
+    } | undefined;
+    /**
+     * @abstract
+     * @param {string} name
+     * @param {function(import("./namespace-route.js").default) : void} callback
+     * @returns {void}
+     */
+    namespace(name: string, callback: (arg0: import("./namespace-route.js").default) => void): void;
+    /**
+     * @abstract
+     * @param {string} name
+     * @returns {void}
+     */
+    post(name: string): void;
+    /**
+     * @abstract
+     * @param {string} name
+     * @param {function(import("./resource-route.js").default) : void} callback
+     * @returns {void}
+     */
+    resources(name: string, callback: (arg0: import("./resource-route.js").default) => void): void;
+}
+//# sourceMappingURL=base-route.d.ts.map

package/dist/src/routes/base-route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-route.d.ts","sourceRoot":"","sources":["../../../src/routes/base-route.js"],"names":[],"mappings":"AAEA;IACE,sDAAsD;IACtD,qBADW,cAAc,gBAAgB,EAAE,OAAO,CAC/B;IAEnB,4DAA4D;IAC5D,2BADW,cAAc,sBAAsB,EAAE,OAAO,CAC/B;IAEzB,uDAAuD;IACvD,sBADW,cAAc,iBAAiB,EAAE,OAAO,CAC/B;IAEpB,2DAA2D;IAC3D,0BADW,cAAc,qBAAqB,EAAE,OAAO,CAC/B;IAExB,kEAAkE;IAClE,wCADY,cAAc,gBAAgB,EAAE,OAAO,QAGlD;IAED,wEAAwE;IACxE,8CADY,cAAc,sBAAsB,EAAE,OAAO,QAGxD;IAED,mEAAmE;IACnE,yCADY,cAAc,iBAAiB,EAAE,OAAO,QAGnD;IAED,uEAAuE;IACvE,6CADY,cAAc,qBAAqB,EAAE,OAAO,QAGvD;IAMD,wCAAwC;IACxC,QADW,KAAK,CAAC,kBAAkB,CAAC,CACzB;IAEX;;;OAGG;IACH,UAFW,MAAM,QAEqC;IAEtD;;;;;;OAMG;IACH,yCALG;QAAkC,MAAM,EAAhC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACN,IAAI,EAAjB,MAAM;QACmD,OAAO,EAAhE,OAAO,kCAAkC,EAAE,OAAO;KAC1D,GAAU;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,GAAG,SAAS,CAI1C;IAED;;;;;OAKG;IACH,gBAJW,MAAM,YACN,CAAS,IAAsC,EAAtC,OAAO,sBAAsB,EAAE,OAAO,KAAI,IAAI,GACrD,IAAI,CAE2D;IAE5E;;;;OAIG;IACH,WAHW,MAAM,GACJ,IAAI,CAEuC;IAExD;;;;;OAKG;IACH,gBAJW,MAAM,YACN,CAAS,IAAqC,EAArC,OAAO,qBAAqB,EAAE,OAAO,KAAI,IAAI,GACpD,IAAI,CAE2D;CAC7E"}

package/dist/src/routes/base-route.js

@@ -0,0 +1,67 @@
+// @ts-check
+export default class VelociousBaseRoute {
+    /** @type {typeof import("./get-route.js").default} */
+    static GetRouteType;
+    /** @type {typeof import("./namespace-route.js").default} */
+    static NameSpaceRouteType;
+    /** @type {typeof import("./post-route.js").default} */
+    static PostRouteType;
+    /** @type {typeof import("./resource-route.js").default} */
+    static ResourceRouteType;
+    /** @param {typeof import("./get-route.js").default} RouteClass */
+    static registerRouteGetType(RouteClass) {
+        this.GetRouteType = RouteClass;
+    }
+    /** @param {typeof import("./namespace-route.js").default} RouteClass */
+    static registerRouteNamespaceType(RouteClass) {
+        this.NameSpaceRouteType = RouteClass;
+    }
+    /** @param {typeof import("./post-route.js").default} RouteClass */
+    static registerRoutePostType(RouteClass) {
+        this.PostRouteType = RouteClass;
+    }
+    /** @param {typeof import("./resource-route.js").default} RouteClass */
+    static registerRouteResourceType(RouteClass) {
+        this.ResourceRouteType = RouteClass;
+    }
+    constructor() {
+        // Nothing
+    }
+    /** @type {Array<VelociousBaseRoute>} */
+    routes = [];
+    /**
+     * @abstract
+     * @param {string} name
+     */
+    get(name) { throw new Error("'get' not implemented"); } // eslint-disable-line no-unused-vars
+    /**
+     * @param {object} args
+     * @param {Record<string, any>} args.params
+     * @param {string} args.path
+     * @param {import("../http-server/client/request.js").default} args.request
+     * @returns {{restPath: string} | undefined}
+     */
+    matchWithPath({ params, path, request }) {
+        throw new Error(`No 'matchWithPath' implemented on ${this.constructor.name}`);
+    }
+    /**
+     * @abstract
+     * @param {string} name
+     * @param {function(import("./namespace-route.js").default) : void} callback
+     * @returns {void}
+     */
+    namespace(name, callback) { throw new Error("'namespace' not implemented"); } // eslint-disable-line no-unused-vars
+    /**
+     * @abstract
+     * @param {string} name
+     * @returns {void}
+     */
+    post(name) { throw new Error("'post' not implemented"); } // eslint-disable-line no-unused-vars
+    /**
+     * @abstract
+     * @param {string} name
+     * @param {function(import("./resource-route.js").default) : void} callback
+     * @returns {void}
+     */
+    resources(name, callback) { throw new Error("'resources' not implemented"); } // eslint-disable-line no-unused-vars
+}

package/dist/src/routes/basic-route.d.ts

@@ -0,0 +1,10 @@
+export default class VelociousBasicRoute extends BaseRoute {
+    /**
+     * @param {string} name
+     * @param {function(import("./resource-route.js").default) : void} [callback]
+     * @returns {void}
+     */
+    resources(name: string, callback?: (arg0: import("./resource-route.js").default) => void): void;
+}
+import BaseRoute from "./base-route.js";
+//# sourceMappingURL=basic-route.d.ts.map

package/dist/src/routes/basic-route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-route.d.ts","sourceRoot":"","sources":["../../../src/routes/basic-route.js"],"names":[],"mappings":"AAIA;IAqDE;;;;OAIG;IACH,gBAJW,MAAM,aACN,CAAS,IAAqC,EAArC,OAAO,qBAAqB,EAAE,OAAO,KAAI,IAAI,GACpD,IAAI,CAchB;CACF;sBAzEqB,iBAAiB"}

package/dist/src/routes/basic-route.js

@@ -0,0 +1,61 @@
+// @ts-check
+import BaseRoute from "./base-route.js";
+export default class VelociousBasicRoute extends BaseRoute {
+    /** @param {string} name */
+    get(name) {
+        const GetRoute = VelociousBasicRoute.GetRouteType;
+        const route = new GetRoute({ name });
+        this.routes.push(route);
+    }
+    /**
+     * @param {object} args
+     * @param {Record<string, any>} args.params
+     * @param {string} args.path
+     * @param {import("../http-server/client/request.js").default} args.request
+     * @returns {{restPath: string} | undefined}
+     */
+    matchWithPath({ params, path, request }) {
+        throw new Error(`No 'matchWithPath' implemented on ${this.constructor.name}`);
+    }
+    /**
+     * @param {string} name
+     * @param {function(import("./namespace-route.js").default) : void} callback
+     * @returns {void}
+     */
+    namespace(name, callback) {
+        const NamespaceRoute = VelociousBasicRoute.NameSpaceRouteType;
+        if (!NamespaceRoute)
+            throw new Error("No NamespaceRoute registered");
+        const route = new NamespaceRoute({ name });
+        this.routes.push(route);
+        if (callback) {
+            callback(route);
+        }
+    }
+    /**
+     * @param {string} name
+     * @returns {void}
+     */
+    post(name) {
+        const PostRoute = VelociousBasicRoute.PostRouteType;
+        if (!PostRoute)
+            throw new Error("No PostRoute registered");
+        const route = new PostRoute({ name });
+        this.routes.push(route);
+    }
+    /**
+     * @param {string} name
+     * @param {function(import("./resource-route.js").default) : void} [callback]
+     * @returns {void}
+     */
+    resources(name, callback) {
+        const ResourceRoute = VelociousBasicRoute.ResourceRouteType;
+        if (!ResourceRoute)
+            throw new Error("No ResourceRoute registered");
+        const route = new ResourceRoute({ name });
+        this.routes.push(route);
+        if (callback) {
+            callback(route);
+        }
+    }
+}

package/dist/src/routes/built-in/errors/controller.d.ts

@@ -0,0 +1,5 @@
+export default class BuiltInErrorsController extends Controller {
+    notFound(): Promise<void>;
+}
+import Controller from "../../../controller.js";
+//# sourceMappingURL=controller.d.ts.map

package/dist/src/routes/built-in/errors/controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../../../src/routes/built-in/errors/controller.js"],"names":[],"mappings":"AAEA;IACE,0BAEC;CACF;uBANsB,wBAAwB"}

package/dist/src/routes/built-in/errors/controller.js

@@ -0,0 +1,6 @@
+import Controller from "../../../controller.js";
+export default class BuiltInErrorsController extends Controller {
+    async notFound() {
+        this.render({ status: "not-found" });
+    }
+}

package/dist/src/routes/get-route.d.ts

@@ -0,0 +1,14 @@
+export default VelociousRouteGetRoute;
+declare class VelociousRouteGetRoute extends BaseRoute {
+    /**
+     * @param {object} args
+     * @param {string} args.name
+     */
+    constructor({ name, ...restArgs }: {
+        name: string;
+    });
+    name: string;
+    regExp: RegExp;
+}
+import BaseRoute from "./base-route.js";
+//# sourceMappingURL=get-route.d.ts.map

package/dist/src/routes/get-route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-route.d.ts","sourceRoot":"","sources":["../../../src/routes/get-route.js"],"names":[],"mappings":";AAOA;IACE;;;OAGG;IACH,mCAFG;QAAqB,IAAI,EAAjB,MAAM;KAChB,EAMA;IAFC,aAAgB;IAChB,eAA+D;CAqBlE;sBAjCqB,iBAAiB"}

package/dist/src/routes/get-route.js

@@ -0,0 +1,33 @@
+// @ts-check
+import escapeStringRegexp from "escape-string-regexp";
+import BaseRoute from "./base-route.js";
+import restArgsError from "../utils/rest-args-error.js";
+class VelociousRouteGetRoute extends BaseRoute {
+    /**
+     * @param {object} args
+     * @param {string} args.name
+     */
+    constructor({ name, ...restArgs }) {
+        super();
+        restArgsError(restArgs);
+        this.name = name;
+        this.regExp = new RegExp(`^(${escapeStringRegexp(name)})(.*)$`);
+    }
+    /**
+     * @param {object} args
+     * @param {Record<string, any>} args.params
+     * @param {string} args.path
+     * @param {import("../http-server/client/request.js").default} args.request
+     * @returns {{restPath: string} | undefined}
+     */
+    matchWithPath({ params, path, request }) {
+        const match = path.match(this.regExp);
+        if (match) {
+            const [_beginnigSlash, _matchedName, restPath] = match; // eslint-disable-line no-unused-vars
+            params.action = this.name;
+            return { restPath };
+        }
+    }
+}
+BaseRoute.registerRouteGetType(VelociousRouteGetRoute);
+export default VelociousRouteGetRoute;

package/dist/src/routes/index.d.ts

@@ -0,0 +1,10 @@
+export default class VelociousRoutes {
+    rootRoute: RootRoute;
+    /**
+     * @param {function(import("./root-route.js").default) : void} callback
+     * @returns {void}
+     */
+    draw(callback: (arg0: import("./root-route.js").default) => void): void;
+}
+import RootRoute from "./root-route.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/routes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/routes/index.js"],"names":[],"mappings":"AAQA;IACE,qBAA2B;IAE3B;;;OAGG;IACH,eAHW,CAAS,IAAiC,EAAjC,OAAO,iBAAiB,EAAE,OAAO,KAAI,IAAI,GAChD,IAAI,CAIhB;CACF;sBAbqB,iBAAiB"}

package/dist/src/routes/index.js

@@ -0,0 +1,16 @@
+// @ts-check
+import GetRoute from "./get-route.js"; // eslint-disable-line no-unused-vars
+import NameSpaceRoute from "./namespace-route.js"; // eslint-disable-line no-unused-vars
+import PostRoute from "./post-route.js"; // eslint-disable-line no-unused-vars
+import RootRoute from "./root-route.js";
+import ResourceRoute from "./resource-route.js"; // eslint-disable-line no-unused-vars
+export default class VelociousRoutes {
+    rootRoute = new RootRoute();
+    /**
+     * @param {function(import("./root-route.js").default) : void} callback
+     * @returns {void}
+     */
+    draw(callback) {
+        callback(this.rootRoute);
+    }
+}

package/dist/src/routes/namespace-route.d.ts

@@ -0,0 +1,14 @@
+export default VelociousRouteNamespaceRoute;
+declare class VelociousRouteNamespaceRoute extends BasicRoute {
+    /**
+     * @param {object} args
+     * @param {string} args.name
+     */
+    constructor({ name, ...restArgs }: {
+        name: string;
+    });
+    name: string;
+    regExp: RegExp;
+}
+import BasicRoute from "./basic-route.js";
+//# sourceMappingURL=namespace-route.d.ts.map

package/dist/src/routes/namespace-route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace-route.d.ts","sourceRoot":"","sources":["../../../src/routes/namespace-route.js"],"names":[],"mappings":";AAOA;IACE;;;OAGG;IACH,mCAFG;QAAqB,IAAI,EAAjB,MAAM;KAChB,EAMA;IAFC,aAAgB;IAChB,eAA+D;CAqBlE;uBAjCsB,kBAAkB"}

package/dist/src/routes/namespace-route.js

@@ -0,0 +1,34 @@
+// @ts-check
+import restArgsError from "../utils/rest-args-error.js";
+import BaseRoute from "./base-route.js";
+import BasicRoute from "./basic-route.js";
+import escapeStringRegexp from "escape-string-regexp";
+class VelociousRouteNamespaceRoute extends BasicRoute {
+    /**
+     * @param {object} args
+     * @param {string} args.name
+     */
+    constructor({ name, ...restArgs }) {
+        super();
+        restArgsError(restArgs);
+        this.name = name;
+        this.regExp = new RegExp(`^(${escapeStringRegexp(name)})(.*)$`);
+    }
+    /**
+     * @param {object} args
+     * @param {Record<string, any>} args.params
+     * @param {string} args.path
+     * @param {import("../http-server/client/request.js").default} args.request
+     * @returns {{restPath: string} | undefined}
+     */
+    matchWithPath({ params, path, request }) {
+        const match = path.match(this.regExp);
+        if (match) {
+            const [_beginnigSlash, _matchedName, restPath] = match; // eslint-disable-line no-unused-vars
+            params.controller = this.name;
+            return { restPath };
+        }
+    }
+}
+BaseRoute.registerRouteNamespaceType(VelociousRouteNamespaceRoute);
+export default VelociousRouteNamespaceRoute;

package/dist/src/routes/post-route.d.ts

@@ -0,0 +1,14 @@
+export default VelociousRoutePostRoute;
+declare class VelociousRoutePostRoute extends BaseRoute {
+    /**
+     * @param {object} args
+     * @param {string} args.name
+     */
+    constructor({ name, ...restArgs }: {
+        name: string;
+    });
+    name: string;
+    regExp: RegExp;
+}
+import BaseRoute from "./base-route.js";
+//# sourceMappingURL=post-route.d.ts.map

package/dist/src/routes/post-route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-route.d.ts","sourceRoot":"","sources":["../../../src/routes/post-route.js"],"names":[],"mappings":";AAMA;IACE;;;OAGG;IACH,mCAFG;QAAqB,IAAI,EAAjB,MAAM;KAChB,EAMA;IAFC,aAAgB;IAChB,eAA+D;CAqBlE;sBAlCqB,iBAAiB"}

package/dist/src/routes/post-route.js

@@ -0,0 +1,33 @@
+// @ts-check
+import BaseRoute from "./base-route.js";
+import escapeStringRegexp from "escape-string-regexp";
+import restArgsError from "../utils/rest-args-error.js";
+class VelociousRoutePostRoute extends BaseRoute {
+    /**
+     * @param {object} args
+     * @param {string} args.name
+     */
+    constructor({ name, ...restArgs }) {
+        super();
+        restArgsError(restArgs);
+        this.name = name;
+        this.regExp = new RegExp(`^(${escapeStringRegexp(name)})(.*)$`);
+    }
+    /**
+     * @param {object} args
+     * @param {Record<string, any>} args.params
+     * @param {string} args.path
+     * @param {import("../http-server/client/request.js").default} args.request
+     * @returns {{restPath: string} | undefined}
+     */
+    matchWithPath({ params, path, request }) {
+        const match = path.match(this.regExp);
+        if (match) {
+            const [_beginnigSlash, _matchedName, restPath] = match; // eslint-disable-line no-unused-vars
+            params.action = this.name;
+            return { restPath };
+        }
+    }
+}
+BaseRoute.registerRoutePostType(VelociousRoutePostRoute);
+export default VelociousRoutePostRoute;

package/dist/src/routes/resolver.d.ts

@@ -0,0 +1,27 @@
+export default class VelociousRoutesResolver {
+    /**
+     * @param {object} args
+     * @param {import("../configuration.js").default} args.configuration
+     * @param {import("../http-server/client/request.js").default} args.request
+     * @param {import("../http-server/client/response.js").default} args.response
+     */
+    constructor({ configuration, request, response }: {
+        configuration: import("../configuration.js").default;
+        request: import("../http-server/client/request.js").default;
+        response: import("../http-server/client/response.js").default;
+    });
+    configuration: import("../configuration.js").default;
+    params: any;
+    request: import("../http-server/client/request.js").default;
+    response: import("../http-server/client/response.js").default;
+    resolve(): Promise<void>;
+    /**
+     * @param {import("./base-route.js").default} route
+     * @param {string} path
+     * @returns {{restPath: string} | undefined}
+     */
+    matchPathWithRoutes(route: import("./base-route.js").default, path: string): {
+        restPath: string;
+    } | undefined;
+}
+//# sourceMappingURL=resolver.d.ts.map

package/dist/src/routes/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../../src/routes/resolver.js"],"names":[],"mappings":"AAQA;IACE;;;;;OAKG;IACH,kDAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACoB,OAAO,EAAhE,OAAO,kCAAkC,EAAE,OAAO;QACQ,QAAQ,EAAlE,OAAO,mCAAmC,EAAE,OAAO;KAC7D,EAUA;IAJC,qDAAkC;IAClC,YAA8B;IAC9B,4DAAsB;IACtB,8DAAwB;IAG1B,yBA+CC;IAED;;;;OAIG;IACH,2BAJW,OAAO,iBAAiB,EAAE,OAAO,QACjC,MAAM,GACJ;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,GAAG,SAAS,CAsB1C;CACF"}