@bool-ts/core 1.3.2 → 1.4.1

package/dist/decorators/http.js

@@ -1,17 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Options = exports.Delete = exports.Patch = exports.Put = exports.Post = exports.Get = exports.controllerRoutesKey = void 0;
-const http_1 = require("../http");
-const ultils_1 = require("../ultils");
-const zodSchema_1 = require("./zodSchema");
-exports.controllerRoutesKey = "__bool:controller.routes__";
+export const controllerRoutesKey = Symbol.for("__bool:controller.routes__");
 const defaultDecorator = (path, method) => (target, methodName, descriptor) => {
     if (!(descriptor.value instanceof Function)) {
-        throw Error(`${method} decorator only use for method.`);
+        throw Error(`${method} decorator only use for class method.`);
     }
     // Define controller metadata
-    Reflect.defineMetadata(exports.controllerRoutesKey, [
-        ...Reflect.getOwnMetadata(exports.controllerRoutesKey, target.constructor) || [],
+    Reflect.defineMetadata(controllerRoutesKey, [
+        ...(Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || []),
         {
             path: !path.startsWith("/") ? `/${path}` : path,
             httpMethod: method.toUpperCase(),
@@ -19,128 +13,47 @@ const defaultDecorator = (path, method) => (target, methodName, descriptor) => {
             descriptor: descriptor
         }
     ], target.constructor);
-    // Define route parameters zod validation
-    const currentMethod = descriptor.value;
-    const isAsync = descriptor.value instanceof ultils_1.AsyncFunction;
-    if (!isAsync) {
-        descriptor.value = function () {
-            const zodSchemaMetadata = Reflect.getOwnMetadata(zodSchema_1.controllerRouteZodSchemaKey, target.constructor, methodName);
-            if (zodSchemaMetadata) {
-                for (const zodSchemaProp in zodSchemaMetadata) {
-                    const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-                    try {
-                        const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
-                        if (!validation.success) {
-                            throw new http_1.HttpClientError({
-                                httpCode: 400,
-                                message: `Validation at the [${methodName}] method fails at positional argument [${tmpZodMetadata.index}].`,
-                                data: validation.error.issues
-                            });
-                        }
-                        arguments[tmpZodMetadata.index] = validation.data;
-                    }
-                    catch (error) {
-                        if (error instanceof http_1.HttpClientError) {
-                            throw error;
-                        }
-                        throw new http_1.HttpServerError({
-                            httpCode: 500,
-                            message: `Validation at the [${methodName}] method error at positional argument [${tmpZodMetadata.index}].`,
-                            data: !(error instanceof Error) ? error : [{
-                                    message: error.message,
-                                    code: error.name,
-                                    cause: error.cause
-                                }]
-                        });
-                    }
-                }
-            }
-            return currentMethod.apply(this, arguments);
-        };
-    }
-    else {
-        descriptor.value = async function () {
-            const zodSchemaMetadata = Reflect.getOwnMetadata(zodSchema_1.controllerRouteZodSchemaKey, target.constructor, methodName);
-            if (zodSchemaMetadata) {
-                for (const zodSchemaProp in zodSchemaMetadata) {
-                    const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-                    try {
-                        const validation = await tmpZodMetadata.schema.safeParseAsync(arguments[tmpZodMetadata.index]);
-                        if (!validation.success) {
-                            throw new http_1.HttpClientError({
-                                httpCode: 400,
-                                message: `Validation at the [${methodName}] method fails at positional argument [${tmpZodMetadata.index}].`,
-                                data: validation.error.issues
-                            });
-                        }
-                        arguments[tmpZodMetadata.index] = validation.data;
-                    }
-                    catch (error) {
-                        if (error instanceof http_1.HttpClientError) {
-                            throw error;
-                        }
-                        throw new http_1.HttpServerError({
-                            httpCode: 500,
-                            message: `Validation at the [${methodName}] method error at positional argument [${tmpZodMetadata.index}].`,
-                            data: !(error instanceof Error) ? error : [{
-                                    message: error.message,
-                                    code: error.name,
-                                    cause: error.cause
-                                }]
-                        });
-                    }
-                }
-            }
-            return currentMethod.apply(this, arguments);
-        };
-    }
 };
 /**
  *
  * @param path
  * @returns
  */
-const Get = (path = "/") => defaultDecorator(path, "Get");
-exports.Get = Get;
+export const Get = (path = "/") => defaultDecorator(path, "Get");
 /**
  *
  * @param path
  * @returns
  */
-const Post = (path = "/") => defaultDecorator(path, "Post");
-exports.Post = Post;
+export const Post = (path = "/") => defaultDecorator(path, "Post");
 /**
  *
  * @param path
  * @returns
  */
-const Put = (path = "/") => defaultDecorator(path, "Put");
-exports.Put = Put;
+export const Put = (path = "/") => defaultDecorator(path, "Put");
 /**
  *
  * @param path
  * @returns
  */
-const Patch = (path = "/") => defaultDecorator(path, "Patch");
-exports.Patch = Patch;
+export const Patch = (path = "/") => defaultDecorator(path, "Patch");
 /**
  *
  * @param path
  * @returns
  */
-const Delete = (path = "/") => defaultDecorator(path, "Delete");
-exports.Delete = Delete;
+export const Delete = (path = "/") => defaultDecorator(path, "Delete");
 /**
  *
  * @param path
  * @returns
  */
-const Options = (path = "/") => defaultDecorator(path, "Options");
-exports.Options = Options;
-exports.default = {
-    Get: exports.Get,
-    Post: exports.Post,
-    Put: exports.Put,
-    Patch: exports.Patch,
-    Delete: exports.Delete
+export const Options = (path = "/") => defaultDecorator(path, "Options");
+export default {
+    Get,
+    Post,
+    Put,
+    Patch,
+    Delete
 };

package/dist/decorators/index.d.ts

@@ -1,3 +1,4 @@
+export { Headers, Body, Params, Param, Query, EArgumentTypes } from "./arguments";
 export { Controller, controllerKey } from "./controller";
 export { Inject, injectKey } from "./inject";
 export { Injectable, injectableKey } from "./injectable";

package/dist/decorators/index.js

@@ -1,26 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.controllerRouteZodSchemaKey = exports.ZodSchema = exports.controllerRoutesKey = exports.Options = exports.Delete = exports.Patch = exports.Put = exports.Post = exports.Get = exports.moduleKey = exports.Module = exports.injectableKey = exports.Injectable = exports.injectKey = exports.Inject = exports.controllerKey = exports.Controller = void 0;
-var controller_1 = require("./controller");
-Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return controller_1.Controller; } });
-Object.defineProperty(exports, "controllerKey", { enumerable: true, get: function () { return controller_1.controllerKey; } });
-var inject_1 = require("./inject");
-Object.defineProperty(exports, "Inject", { enumerable: true, get: function () { return inject_1.Inject; } });
-Object.defineProperty(exports, "injectKey", { enumerable: true, get: function () { return inject_1.injectKey; } });
-var injectable_1 = require("./injectable");
-Object.defineProperty(exports, "Injectable", { enumerable: true, get: function () { return injectable_1.Injectable; } });
-Object.defineProperty(exports, "injectableKey", { enumerable: true, get: function () { return injectable_1.injectableKey; } });
-var module_1 = require("./module");
-Object.defineProperty(exports, "Module", { enumerable: true, get: function () { return module_1.Module; } });
-Object.defineProperty(exports, "moduleKey", { enumerable: true, get: function () { return module_1.moduleKey; } });
-var http_1 = require("./http");
-Object.defineProperty(exports, "Get", { enumerable: true, get: function () { return http_1.Get; } });
-Object.defineProperty(exports, "Post", { enumerable: true, get: function () { return http_1.Post; } });
-Object.defineProperty(exports, "Put", { enumerable: true, get: function () { return http_1.Put; } });
-Object.defineProperty(exports, "Patch", { enumerable: true, get: function () { return http_1.Patch; } });
-Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return http_1.Delete; } });
-Object.defineProperty(exports, "Options", { enumerable: true, get: function () { return http_1.Options; } });
-Object.defineProperty(exports, "controllerRoutesKey", { enumerable: true, get: function () { return http_1.controllerRoutesKey; } });
-var zodSchema_1 = require("./zodSchema");
-Object.defineProperty(exports, "ZodSchema", { enumerable: true, get: function () { return zodSchema_1.ZodSchema; } });
-Object.defineProperty(exports, "controllerRouteZodSchemaKey", { enumerable: true, get: function () { return zodSchema_1.controllerRouteZodSchemaKey; } });
+export { Headers, Body, Params, Param, Query, EArgumentTypes } from "./arguments";
+export { Controller, controllerKey } from "./controller";
+export { Inject, injectKey } from "./inject";
+export { Injectable, injectableKey } from "./injectable";
+export { Module, moduleKey } from "./module";
+export { Get, Post, Put, Patch, Delete, Options, controllerRoutesKey } from "./http";
+export { ZodSchema, controllerRouteZodSchemaKey } from "./zodSchema";

package/dist/decorators/inject.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Inject = exports.injectKey = void 0;
-exports.injectKey = "design:paramtypes";
-const Inject = (classDefinition) => {
+export const injectKey = "design:paramtypes";
+export const Inject = (classDefinition) => {
     return (target, methodName, parameterIndex) => {
-        const designParameterTypes = Reflect.getMetadata(exports.injectKey, target) || [];
+        const designParameterTypes = Reflect.getMetadata(injectKey, target) || [];
         designParameterTypes[parameterIndex] = classDefinition;
-        Reflect.defineMetadata(exports.injectKey, designParameterTypes, target);
+        Reflect.defineMetadata(injectKey, designParameterTypes, target);
     };
 };
-exports.Inject = Inject;
-exports.default = exports.Inject;
+export default Inject;

package/dist/decorators/injectable.d.ts

@@ -1,3 +1,3 @@
-export declare const injectableKey = "__bool:injectable__";
-export declare const Injectable: () => <T extends Object>(target: T, context?: ClassDecoratorContext) => T;
+export declare const injectableKey: unique symbol;
+export declare const Injectable: () => <T extends Object>(target: T) => T;
 export default Injectable;

package/dist/decorators/injectable.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Injectable = exports.injectableKey = void 0;
-exports.injectableKey = "__bool:injectable__";
-const Injectable = () => (target, context) => {
-    Reflect.defineMetadata(exports.injectableKey, undefined, target);
+export const injectableKey = Symbol.for("__bool:injectable__");
+export const Injectable = () => (target) => {
+    Reflect.defineMetadata(injectableKey, undefined, target);
     return target;
 };
-exports.Injectable = Injectable;
-exports.default = exports.Injectable;
+export default Injectable;

package/dist/decorators/module.d.ts

@@ -5,6 +5,8 @@ export type TModuleOptions = Partial<{
     allowOrigins: string | Array<string>;
     allowMethods: Array<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS">;
 }> | undefined;
-export declare const moduleKey = "__bool:module__";
-export declare const Module: (args?: TModuleOptions) => <T extends new (...args: any[]) => {}>(target: T, context?: ClassDecoratorContext) => T;
+export declare const moduleKey: unique symbol;
+export declare const Module: (args?: TModuleOptions) => <T extends {
+    new (...args: any[]): {};
+}>(target: T) => T;
 export default Module;

package/dist/decorators/module.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Module = exports.moduleKey = void 0;
-exports.moduleKey = "__bool:module__";
-const Module = (args) => (target, context) => {
-    Reflect.defineMetadata(exports.moduleKey, args, target);
+export const moduleKey = Symbol.for("__bool:module__");
+export const Module = (args) => (target) => {
+    Reflect.defineMetadata(moduleKey, args, target);
     return target;
 };
-exports.Module = Module;
-exports.default = exports.Module;
+export default Module;

package/dist/decorators/zodSchema.d.ts

@@ -1,3 +1,3 @@
 import * as Zod from "zod";
-export declare const controllerRouteZodSchemaKey = "__bool:controller.route.zodSchema__";
+export declare const controllerRouteZodSchemaKey: unique symbol;
 export declare const ZodSchema: (schema: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;

package/dist/decorators/zodSchema.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZodSchema = exports.controllerRouteZodSchemaKey = void 0;
-exports.controllerRouteZodSchemaKey = "__bool:controller.route.zodSchema__";
-const ZodSchema = (schema) => {
+import * as Zod from "zod";
+export const controllerRouteZodSchemaKey = Symbol.for("__bool:controller.route.zodSchema__");
+export const ZodSchema = (schema) => {
     return (target, methodName, parameterIndex) => {
         if (!methodName) {
             return;
         }
-        const zodSchemasMetadata = Reflect.getOwnMetadata(exports.controllerRouteZodSchemaKey, target.constructor, methodName) || {};
+        const zodSchemasMetadata = Reflect.getOwnMetadata(controllerRouteZodSchemaKey, target.constructor, methodName) || {};
         zodSchemasMetadata[`paramterIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             schema: schema
         };
-        Reflect.defineMetadata(exports.controllerRouteZodSchemaKey, zodSchemasMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(controllerRouteZodSchemaKey, zodSchemasMetadata, target.constructor, methodName);
     };
 };
-exports.ZodSchema = ZodSchema;

package/dist/entities/index.d.ts

@@ -0,0 +1,3 @@
+export { Route } from "./route";
+export { Router } from "./router";
+export { RouterGroup } from "./routerGroup";

package/dist/entities/index.js

@@ -0,0 +1,3 @@
+export { Route } from "./route";
+export { Router } from "./router";
+export { RouterGroup } from "./routerGroup";

package/dist/entities/route.d.ts

@@ -0,0 +1,101 @@
+import type { THttpMethods } from "../http";
+type THandler<T = unknown> = Required<{
+    constructor: new (...args: Array<any>) => T;
+    funcName: string | symbol;
+    func: (...args: Array<any>) => unknown;
+}>;
+export declare class Route {
+    static rootPattern: string;
+    readonly alias: string;
+    private _map;
+    constructor(alias: string);
+    test(pathname: string, method: keyof THttpMethods): Readonly<{
+        params: Record<string, string>;
+        handlers: Array<THandler>;
+    }> | false | undefined;
+    /**
+     *
+     */
+    isMatch(pathname: string, method: keyof THttpMethods): boolean | undefined;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    get(...handlers: Array<THandler>): this;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    post(...handlers: Array<THandler>): this;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    put(...handlers: Array<THandler>): this;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    delete(...handlers: Array<THandler>): this;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    connect(...handlers: Array<THandler>): this | Map<keyof THttpMethods, Required<{
+        constructor: new (...args: Array<any>) => unknown;
+        funcName: string | symbol;
+        func: (...args: Array<any>) => unknown;
+    }>[]>;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    options(...handlers: Array<THandler>): this | Map<keyof THttpMethods, Required<{
+        constructor: new (...args: Array<any>) => unknown;
+        funcName: string | symbol;
+        func: (...args: Array<any>) => unknown;
+    }>[]>;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    trace(...handlers: Array<THandler>): this | Map<keyof THttpMethods, Required<{
+        constructor: new (...args: Array<any>) => unknown;
+        funcName: string | symbol;
+        func: (...args: Array<any>) => unknown;
+    }>[]>;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    patch(...handlers: Array<THandler>): this | Map<keyof THttpMethods, Required<{
+        constructor: new (...args: Array<any>) => unknown;
+        funcName: string | symbol;
+        func: (...args: Array<any>) => unknown;
+    }>[]>;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    private _thinAlias;
+    /**
+     * Internal get fullpath after check regular expression
+     * @returns
+     */
+    get _fullPath(): string;
+    /**
+     * Internal get filterd path after check regular expression
+     * @returns
+     */
+    get _filteredPath(): string;
+}
+export default Route;

package/dist/entities/route.js

@@ -0,0 +1,257 @@
+"use strict";
+export class Route {
+    static rootPattern = ":([a-z0-9A-Z_.-]{1,})";
+    alias;
+    _map = new Map();
+    constructor(alias) {
+        this.alias = this._thinAlias(alias);
+    }
+    test(pathname, method) {
+        try {
+            const handlers = this._map.get(method);
+            const aliasSplitted = this.alias.split("/");
+            const currentPathNameSplitted = this._thinAlias(pathname).split("/");
+            if (!handlers) {
+                return undefined;
+            }
+            // Compare splitted length
+            if (aliasSplitted.length !== currentPathNameSplitted.length) {
+                return undefined;
+            }
+            const parameters = Object();
+            for (let index = 0; index < aliasSplitted.length; index++) {
+                const aliasPart = aliasSplitted[index];
+                const pathnamePart = currentPathNameSplitted[index];
+                // Check pathmane path match a dynamic syntax, if no match => start compare equal or not
+                if (!new RegExp(Route.rootPattern, "g").test(aliasPart)) {
+                    if (aliasPart !== pathnamePart)
+                        return undefined;
+                }
+                else {
+                    let isFailed = false;
+                    aliasPart.replace(new RegExp(Route.rootPattern, "g"), (match, key, offset) => {
+                        if (offset === 0) {
+                            Object.assign(parameters, {
+                                [key]: pathnamePart
+                            });
+                        }
+                        return match;
+                    });
+                    if (isFailed) {
+                        console.log(3, "isFailed", isFailed);
+                        return undefined;
+                    }
+                }
+                continue;
+            }
+            return Object.freeze({
+                params: parameters,
+                handlers: handlers
+            });
+        }
+        catch (err) {
+            console.error(err);
+            return false;
+        }
+    }
+    /**
+     *
+     */
+    isMatch(pathname, method) {
+        try {
+            const handlers = this._map.get(method);
+            if (!handlers) {
+                return undefined;
+            }
+            const aliasSplitted = this.alias.split("/");
+            const currentPathNameSplitted = this._thinAlias(pathname).split("/");
+            // Compare splitted length
+            if (aliasSplitted.length !== currentPathNameSplitted.length) {
+                return false;
+            }
+            const parameters = Object();
+            for (let index = 0; index < aliasSplitted.length; index++) {
+                const aliasPart = aliasSplitted[index];
+                const pathnamePart = currentPathNameSplitted[index];
+                // Check pathmane path match a dynamic syntax, if no match => start compare equal or not
+                if (!new RegExp(Route.rootPattern, "g").test(aliasPart)) {
+                    if (aliasPart !== pathnamePart) {
+                        return false;
+                    }
+                }
+                else {
+                    let isFailed = false;
+                    aliasPart.replace(new RegExp(Route.rootPattern, "g"), (subString, key, value) => {
+                        if (!new RegExp(value, "g").test(pathnamePart)) {
+                            isFailed = true;
+                        }
+                        else {
+                            Object.assign(parameters, {
+                                [key]: pathnamePart
+                            });
+                        }
+                        return "";
+                    });
+                    if (isFailed) {
+                        return false;
+                    }
+                }
+                continue;
+            }
+            return true;
+        }
+        catch (err) {
+            console.error(err);
+            return undefined;
+        }
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    get(...handlers) {
+        const currentHandlers = this._map.get("GET");
+        if (!currentHandlers) {
+            this._map.set("GET", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    post(...handlers) {
+        const currentHandlers = this._map.get("POST");
+        if (!currentHandlers) {
+            this._map.set("POST", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    put(...handlers) {
+        const currentHandlers = this._map.get("PUT");
+        if (!currentHandlers) {
+            this._map.set("PUT", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    delete(...handlers) {
+        const currentHandlers = this._map.get("DELETE");
+        if (!currentHandlers) {
+            this._map.set("DELETE", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    connect(...handlers) {
+        const currentHandlers = this._map.get("CONNECT");
+        if (!currentHandlers) {
+            return this._map.set("CONNECT", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    options(...handlers) {
+        const currentHandlers = this._map.get("OPTIONS");
+        if (!currentHandlers) {
+            return this._map.set("OPTIONS", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    trace(...handlers) {
+        const currentHandlers = this._map.get("TRACE");
+        if (!currentHandlers) {
+            return this._map.set("TRACE", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    patch(...handlers) {
+        const currentHandlers = this._map.get("PATCH");
+        if (!currentHandlers) {
+            return this._map.set("PATCH", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    _thinAlias(alias) {
+        return alias.replace(new RegExp("[/]{2,}", "g"), "/").replace(new RegExp("^[/]|[/]$", "g"), "");
+    }
+    /**
+     * Internal get fullpath after check regular expression
+     * @returns
+     */
+    get _fullPath() {
+        // Split path to start filter
+        const pathSplited = this.alias.split("/");
+        const blockFiltered = pathSplited.map((value, index) => {
+            // Initialize full parameter regex to validate
+            let validateReg = new RegExp(":([a-z0-9A-Z_.-]{1,})(\\(.*?\\))", "g");
+            if (!validateReg.test(value)) {
+                // Initialize key parameter regex to validate
+                validateReg = new RegExp(":([a-z0-9A-Z_.-]{1,})", "g");
+                if (!validateReg.test(value)) {
+                    return value;
+                }
+                return value.replace(validateReg, (value, index) => `${value}(.*?)`);
+            }
+            return value;
+        });
+        return blockFiltered.join("/");
+    }
+    /**
+     * Internal get filterd path after check regular expression
+     * @returns
+     */
+    get _filteredPath() {
+        // Split path to start filter
+        const pathSplited = this.alias.split("/");
+        //
+        const blockFiltered = pathSplited.map((value, index) => {
+            let validateReg = new RegExp(":([a-z0-9A-Z_.-]{1,})((.*?))", "g");
+            if (!validateReg.test(value)) {
+                // Initialize key parameter regex to validate
+                validateReg = new RegExp(":([a-z0-9A-Z_.-]{1,})", "g");
+                if (!validateReg.test(value)) {
+                    return value;
+                }
+                return value.replace(validateReg, (value, index) => "(.*?)");
+            }
+            return value.replace(validateReg, (subString, arg_01, arg_02) => arg_02);
+        });
+        return blockFiltered.join("/");
+    }
+}
+export default Route;