@adonisjs/http-server 5.7.4 → 5.10.0

package/build/adonis-typings/http-server.d.ts

@@ -7,6 +7,7 @@
  * file that was distributed with this source code.
  */
 /// <reference types="node" />
+/// <reference types="node" />
 declare module '@ioc:Adonis/Core/Server' {
     import { Server as HttpsServer } from 'https';
     import { RouterContract } from '@ioc:Adonis/Core/Route';

package/build/adonis-typings/request.d.ts

@@ -7,6 +7,7 @@
  * file that was distributed with this source code.
  */
 /// <reference types="node" />
+/// <reference types="node" />
 declare module '@ioc:Adonis/Core/Request' {
     import { UrlWithStringQuery } from 'url';
     import { MacroableConstructorContract } from 'macroable';

package/build/adonis-typings/response.d.ts

@@ -7,6 +7,8 @@
  * file that was distributed with this source code.
  */
 /// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
 declare module '@ioc:Adonis/Core/Response' {
     import { ServerResponse, IncomingMessage } from 'http';
     import { MacroableConstructorContract } from 'macroable';

package/build/adonis-typings/route.d.ts

@@ -89,7 +89,9 @@ declare module '@ioc:Adonis/Core/Route' {
     export type MethodNode = {
         tokens: any[];
         routes: {
-            [pattern: string]: RouteNode;
+            [pattern: string]: RouteNode & {
+                params: string[];
+            };
         };
     };
     /**
@@ -116,27 +118,20 @@ declare module '@ioc:Adonis/Core/Route' {
         domain?: string;
         matchers: RouteMatchersNode;
     };
-    /**
-     * Shape of the identifier node of the URL builder
-     */
-    export type LookupStoreIdentifier = {
-        handler: RouteHandler;
-        methods: string[];
-        pattern: string;
-        name?: string;
-    };
     /**
      * Shape of the routes tree maintained by the UrlBuilder
      */
     export type LookupStoreTree = {
-        [domain: string]: LookupStoreIdentifier[];
+        [domain: string]: RouteJSON[];
     };
     /**
      * Shape of the matched route for a pattern, method and domain. We set
      * them as spread options to the context.
      */
     export type MatchedRoute = {
-        route: RouteNode;
+        route: RouteNode & {
+            params: string[];
+        };
         /**
          * A unique key for the looked up route
          */
@@ -350,6 +345,7 @@ declare module '@ioc:Adonis/Core/Route' {
         qs?: Record<string, any>;
         domain?: string;
         prefixUrl?: string;
+        disableRouteLookup?: boolean;
     } & Record<string, any>;
     /**
      * Options for making a signed url
@@ -489,6 +485,21 @@ declare module '@ioc:Adonis/Core/Route' {
      * directly
      */
     export interface LookupStoreContract {
+        /**
+         * Find a route by indentifier. Optionally one can find routes inside
+         * a given domain
+         */
+        find(routeIdentifier: string, domainPattern?: string): RouteJSON | null;
+        /**
+         * Find a route by indentifier or fail. Optionally one can find routes inside
+         * a given domain
+         */
+        findOrFail(routeIdentifier: string, domainPattern?: string): RouteJSON;
+        /**
+         * Find if a route for given identifier exists. Optionally one can find routes inside
+         * a given domain
+         */
+        has(routeIdentifier: string, domainPattern?: string): boolean;
         /**
          * Get the builder instance for the main domain
          */
@@ -518,6 +529,11 @@ declare module '@ioc:Adonis/Core/Route' {
          * Generate url for the given route
          */
         make(identifier: string): string;
+        /**
+         * Disable route lookup and consider identifier
+         * as the route pattern
+         */
+        disableRouteLookup(): this;
         /**
          * Generate signed url for the given route
          */

package/build/src/Request/index.d.ts

@@ -8,6 +8,7 @@
  */
 /// <reference path="../../adonis-typings/index.d.ts" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { Macroable } from 'macroable';
 import { UrlWithStringQuery } from 'url';
 import { ServerResponse, IncomingMessage, IncomingHttpHeaders } from 'http';

package/build/src/Response/index.d.ts

@@ -8,6 +8,7 @@
  */
 /// <reference path="../../adonis-typings/index.d.ts" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { Macroable } from 'macroable';
 import { ServerResponse, IncomingMessage } from 'http';
 import { CookieOptions, CastableHeader, ResponseConfig, ResponseStream, ResponseContract, RedirectContract } from '@ioc:Adonis/Core/Response';

package/build/src/Router/LookupStore.d.ts

@@ -1,5 +1,24 @@
-import { RouteJSON, LookupStoreTree, UrlBuilderContract, LookupStoreIdentifier } from '@ioc:Adonis/Core/Route';
+import { RouteJSON, LookupStoreTree, UrlBuilderContract, LookupStoreContract } from '@ioc:Adonis/Core/Route';
 import { EncryptionContract } from '@ioc:Adonis/Core/Encryption';
+/**
+ * A class to encapsulate finding routes
+ */
+declare class Routes {
+    private routes;
+    constructor(routes: RouteJSON[]);
+    /**
+     * Find a route by indentifier
+     */
+    find(routeIdentifier: string): RouteJSON | null;
+    /**
+     * Find a route by indentifier or fail
+     */
+    findOrFail(routeIdentifier: string): RouteJSON;
+    /**
+     * Find if a route exists
+     */
+    has(routeIdentifier: string): boolean;
+}
 /**
  * Url builder is responsible for building the URLs
  */
@@ -14,20 +33,20 @@ export declare class UrlBuilder implements UrlBuilderContract {
      * A custom query string to append to the URL
      */
     private queryString;
+    /**
+     * A boolean to know if the route should be looked
+     * up inside the route store or not
+     */
+    private lookupRoute;
     /**
      * A baseUrl to prefix to the endpoint
      */
     private baseUrl;
-    constructor(encryption: EncryptionContract, routes: LookupStoreIdentifier[]);
+    constructor(encryption: EncryptionContract, routes: Routes);
     /**
      * Processes the pattern against the params
      */
     private processPattern;
-    /**
-     * Finds the route inside the list of registered routes and
-     * raises exception when unable to
-     */
-    private findRouteOrFail;
     /**
      * Suffix the query string to the URL
      */
@@ -36,6 +55,11 @@ export declare class UrlBuilder implements UrlBuilderContract {
      * Prefix a custom url to the final URI
      */
     prefixUrl(url: string): this;
+    /**
+     * Disable route lookup. Calling this method considers
+     * the "identifier" as the route pattern
+     */
+    disableRouteLookup(): this;
     /**
      * Append query string to the final URI
      */
@@ -60,7 +84,7 @@ export declare class UrlBuilder implements UrlBuilderContract {
  * The look up store to make URLs for a given route by looking
  * it by its name, route handler or the pattern directly.
  */
-export declare class LookupStore {
+export declare class LookupStore implements LookupStoreContract {
     private encryption;
     /**
      * Shape of the registered routes. Optimized for lookups
@@ -79,4 +103,20 @@ export declare class LookupStore {
      * Returns the route builder a given domain.
      */
     builderForDomain(domainPattern: string): UrlBuilder;
+    /**
+     * Find a route by indentifier. Optionally one can find routes inside
+     * a given domain
+     */
+    find(routeIdentifier: string, domainPattern?: string): RouteJSON | null;
+    /**
+     * Find a route by indentifier or fail. Optionally one can find routes inside
+     * a given domain
+     */
+    findOrFail(routeIdentifier: string, domainPattern?: string): RouteJSON;
+    /**
+     * Find if a route for given identifier exists. Optionally one can find routes inside
+     * a given domain
+     */
+    has(routeIdentifier: string, domainPattern?: string): boolean;
 }
+export {};

package/build/src/Router/LookupStore.js

@@ -15,6 +15,38 @@ exports.LookupStore = exports.UrlBuilder = void 0;
 const qs_1 = __importDefault(require("qs"));
 const encodeurl_1 = __importDefault(require("encodeurl"));
 const RouterException_1 = require("../Exceptions/RouterException");
+/**
+ * A class to encapsulate finding routes
+ */
+class Routes {
+    constructor(routes) {
+        this.routes = routes;
+    }
+    /**
+     * Find a route by indentifier
+     */
+    find(routeIdentifier) {
+        return (this.routes.find(({ name, pattern, handler }) => {
+            return (name === routeIdentifier || pattern === routeIdentifier || handler === routeIdentifier);
+        }) || null);
+    }
+    /**
+     * Find a route by indentifier or fail
+     */
+    findOrFail(routeIdentifier) {
+        const route = this.find(routeIdentifier);
+        if (!route) {
+            throw RouterException_1.RouterException.cannotLookupRoute(routeIdentifier);
+        }
+        return route;
+    }
+    /**
+     * Find if a route exists
+     */
+    has(routeIdentifier) {
+        return !!this.find(routeIdentifier);
+    }
+}
 /**
  * Url builder is responsible for building the URLs
  */
@@ -26,6 +58,11 @@ class UrlBuilder {
          * A custom query string to append to the URL
          */
         this.queryString = {};
+        /**
+         * A boolean to know if the route should be looked
+         * up inside the route store or not
+         */
+        this.lookupRoute = true;
     }
     /**
      * Processes the pattern against the params
@@ -75,19 +112,6 @@ class UrlBuilder {
         }
         return url.join('/');
     }
-    /**
-     * Finds the route inside the list of registered routes and
-     * raises exception when unable to
-     */
-    findRouteOrFail(identifier) {
-        const route = this.routes.find(({ name, pattern, handler }) => {
-            return name === identifier || pattern === identifier || handler === identifier;
-        });
-        if (!route) {
-            throw RouterException_1.RouterException.cannotLookupRoute(identifier);
-        }
-        return route;
-    }
     /**
      * Suffix the query string to the URL
      */
@@ -105,6 +129,14 @@ class UrlBuilder {
         this.baseUrl = url;
         return this;
     }
+    /**
+     * Disable route lookup. Calling this method considers
+     * the "identifier" as the route pattern
+     */
+    disableRouteLookup() {
+        this.lookupRoute = false;
+        return this;
+    }
     /**
      * Append query string to the final URI
      */
@@ -129,16 +161,28 @@ class UrlBuilder {
      * Generate url for the given route identifier
      */
     make(identifier) {
-        const route = this.findRouteOrFail(identifier);
-        const url = this.processPattern(route.pattern);
+        let url;
+        if (this.lookupRoute) {
+            const route = this.routes.findOrFail(identifier);
+            url = this.processPattern(route.pattern);
+        }
+        else {
+            url = this.processPattern(identifier);
+        }
         return this.suffixQueryString(this.baseUrl ? `${this.baseUrl}${url}` : url);
     }
     /**
      * Generate url for the given route identifier
      */
     makeSigned(identifier, options) {
-        const route = this.findRouteOrFail(identifier);
-        const url = this.processPattern(route.pattern);
+        let url;
+        if (this.lookupRoute) {
+            const route = this.routes.findOrFail(identifier);
+            url = this.processPattern(route.pattern);
+        }
+        else {
+            url = this.processPattern(identifier);
+        }
         /*
          * Making the signature from the qualified url. We do not prefix the domain when
          * making signature, since it just makes the signature big.
@@ -174,12 +218,7 @@ class LookupStore {
     register(route) {
         const domain = route.domain || 'root';
         this.tree[domain] = this.tree[domain] || [];
-        this.tree[domain].push({
-            methods: route.methods,
-            name: route.name,
-            handler: route.handler,
-            pattern: route.pattern,
-        });
+        this.tree[domain].push(route);
     }
     /**
      * Returns the route builder for the root domain
@@ -195,7 +234,31 @@ class LookupStore {
         if (!domainRoutes && domainPattern !== 'root') {
             throw RouterException_1.RouterException.cannotLookupDomain(domainPattern);
         }
-        return new UrlBuilder(this.encryption, domainRoutes || []);
+        return new UrlBuilder(this.encryption, new Routes(domainRoutes || []));
+    }
+    /**
+     * Find a route by indentifier. Optionally one can find routes inside
+     * a given domain
+     */
+    find(routeIdentifier, domainPattern) {
+        const routes = this.tree[domainPattern || 'root'] || [];
+        return new Routes(routes || []).find(routeIdentifier);
+    }
+    /**
+     * Find a route by indentifier or fail. Optionally one can find routes inside
+     * a given domain
+     */
+    findOrFail(routeIdentifier, domainPattern) {
+        const routes = this.tree[domainPattern || 'root'] || [];
+        return new Routes(routes || []).findOrFail(routeIdentifier);
+    }
+    /**
+     * Find if a route for given identifier exists. Optionally one can find routes inside
+     * a given domain
+     */
+    has(routeIdentifier, domainPattern) {
+        const routes = this.tree[domainPattern || 'root'] || [];
+        return new Routes(routes || []).has(routeIdentifier);
     }
 }
 exports.LookupStore = LookupStore;

package/build/src/Router/Store.js

@@ -143,6 +143,7 @@ class Store {
                 }
             }
         }
+        routeJSON.params = new Array(...collectedParams);
         collectedParams.clear();
         route.methods.forEach((method) => {
             const methodRoutes = this.getMethodRoutes(route.domain || 'root', method);

package/build/src/Router/index.d.ts

@@ -14,6 +14,7 @@ import { RouteGroup } from './Group';
 import { BriskRoute } from './BriskRoute';
 import { RouteResource } from './Resource';
 import { RouteMatchers } from './Matchers';
+import { LookupStore } from './LookupStore';
 /**
  * Router class exposes unified API to create new routes, group them or
  * create route resources.
@@ -27,8 +28,7 @@ import { RouteMatchers } from './Matchers';
  * })
  * ```
  */
-export declare class Router implements RouterContract {
-    private encryption;
+export declare class Router extends LookupStore implements RouterContract {
     private routeProcessor?;
     /**
      * Collection of routes, including route resource and route
@@ -52,10 +52,6 @@ export declare class Router implements RouterContract {
      * Global matchers to test route params against regular expressions.
      */
     private paramMatchers;
-    /**
-     * The lookup store instance
-     */
-    private lookupStore;
     /**
      * Store with tokenized routes
      */
@@ -133,14 +129,6 @@ export declare class Router implements RouterContract {
      * Find route for a given URL, method and optionally domain
      */
     match(url: string, method: string, domain?: string): null | MatchedRoute;
-    /**
-     * Access to the URL builder
-     */
-    builder(): import("./LookupStore").UrlBuilder;
-    /**
-     * Access to the URL builder for a specific domain
-     */
-    builderForDomain(domainPattern: string): import("./LookupStore").UrlBuilder;
     /**
      * Makes url to a registered route by looking it up with the route pattern,
      * name or the controller.method

package/build/src/Router/index.js

@@ -33,9 +33,9 @@ const LookupStore_1 = require("./LookupStore");
  * })
  * ```
  */
-class Router {
+class Router extends LookupStore_1.LookupStore {
     constructor(encryption, routeProcessor) {
-        this.encryption = encryption;
+        super(encryption);
         this.routeProcessor = routeProcessor;
         /**
          * Collection of routes, including route resource and route
@@ -59,10 +59,6 @@ class Router {
          * Global matchers to test route params against regular expressions.
          */
         this.paramMatchers = {};
-        /**
-         * The lookup store instance
-         */
-        this.lookupStore = new LookupStore_1.LookupStore(this.encryption);
         /**
          * Store with tokenized routes
          */
@@ -224,7 +220,7 @@ class Router {
      * Returns a flat list of routes JSON
      */
     toJSON() {
-        const lookupStoreRoutes = this.lookupStore.tree;
+        const lookupStoreRoutes = this.tree;
         const domains = Object.keys(lookupStoreRoutes);
         return domains.reduce((result, domain) => {
             result[domain] = lookupStoreRoutes[domain].map((route) => {
@@ -264,7 +260,7 @@ class Router {
             /**
              * Register the route with the lookup store
              */
-            this.lookupStore.register(route);
+            this.register(route);
             this.store.add(route);
         });
         this.routes = [];
@@ -303,18 +299,6 @@ class Router {
         }
         return response;
     }
-    /**
-     * Access to the URL builder
-     */
-    builder() {
-        return this.lookupStore.builder();
-    }
-    /**
-     * Access to the URL builder for a specific domain
-     */
-    builderForDomain(domainPattern) {
-        return this.lookupStore.builderForDomain(domainPattern);
-    }
     /**
      * Makes url to a registered route by looking it up with the route pattern,
      * name or the controller.method
@@ -327,6 +311,7 @@ class Router {
         normalizedOptions.params && builder.params(normalizedOptions.params);
         normalizedOptions.qs && builder.qs(normalizedOptions.qs);
         normalizedOptions.prefixUrl && builder.prefixUrl(normalizedOptions.prefixUrl);
+        normalizedOptions.disableRouteLookup && builder.disableRouteLookup();
         return builder.make(routeIdentifier);
     }
     /**
@@ -341,6 +326,7 @@ class Router {
         normalizedOptions.params && builder.params(normalizedOptions.params);
         normalizedOptions.qs && builder.qs(normalizedOptions.qs);
         normalizedOptions.prefixUrl && builder.prefixUrl(normalizedOptions.prefixUrl);
+        normalizedOptions.disableRouteLookup && builder.disableRouteLookup();
         return builder.makeSigned(routeIdentifier, normalizedOptions);
     }
 }

package/build/src/Server/PreCompiler/index.js

@@ -44,7 +44,15 @@ class PreCompiler {
                 returnValue = await routeHandler.handler(ctx);
             }
             else {
-                returnValue = await this.resolver.call(routeHandler, undefined, [ctx]);
+                returnValue = await this.resolver.call(routeHandler, undefined, (controller) => {
+                    /**
+                     * Allowing controller to provide the controller method argument
+                     */
+                    if (typeof controller['getHandlerArguments'] === 'function') {
+                        return controller['getHandlerArguments'](ctx);
+                    }
+                    return [ctx];
+                });
             }
             if ((0, helpers_2.useReturnValue)(returnValue, ctx)) {
                 ctx.response.send(returnValue);

package/build/src/Server/index.d.ts

@@ -8,6 +8,7 @@
  */
 /// <reference path="../../adonis-typings/index.d.ts" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { Server as HttpsServer } from 'https';
 import { EncryptionContract } from '@ioc:Adonis/Core/Encryption';
 import { ApplicationContract } from '@ioc:Adonis/Core/Application';

package/build/src/helpers.d.ts

@@ -48,6 +48,7 @@ export declare function normalizeMakeUrlOptions(params?: any[] | MakeUrlOptions,
     qs: any;
     domain: string | undefined;
     prefixUrl: string | undefined;
+    disableRouteLookup: boolean;
 };
 /**
  * Normalizes the make signed url options by allowing params to appear on
@@ -60,6 +61,7 @@ export declare function normalizeMakeSignedUrlOptions(params?: any[] | MakeSigne
     prefixUrl: string | undefined;
     expiresIn: any;
     purpose: any;
+    disableRouteLookup: boolean;
 };
 /**
  * Wraps `fs.stat` to promise interface.

package/build/src/helpers.js

@@ -143,13 +143,14 @@ function normalizeMakeUrlOptions(params, options) {
     const qs = options.qs || params['qs'];
     const domain = options.domain;
     const prefixUrl = options.prefixUrl;
+    const disableRouteLookup = options.disableRouteLookup || false;
     /**
      * Using legacy options
      */
     onIntersect(params, ['prefixDomain', 'domainParams', 'qs', 'params'], () => {
         process.emitWarning('DeprecationWarning', 'You are using legacy the API of the "Route.makeUrl". We recommend reading the docs and use the latest API');
     });
-    return { params: normalizedParams, qs, domain, prefixUrl };
+    return { params: normalizedParams, qs, domain, prefixUrl, disableRouteLookup };
 }
 exports.normalizeMakeUrlOptions = normalizeMakeUrlOptions;
 /**
@@ -168,13 +169,14 @@ function normalizeMakeSignedUrlOptions(params, options) {
     const purpose = options.purpose || params['purpose'];
     const domain = options.domain;
     const prefixUrl = options.prefixUrl;
+    const disableRouteLookup = options.disableRouteLookup || false;
     /**
      * Using legacy options
      */
     onIntersect(params, ['prefixDomain', 'domainParams', 'qs', 'params', 'purpose', 'expiresIn'], () => {
         process.emitWarning('DeprecationWarning', 'You are using legacy the API of the "Route.makeSignedUrl". We recommend reading the docs and use the latest API');
     });
-    return { params: normalizedParams, qs, domain, prefixUrl, expiresIn, purpose };
+    return { params: normalizedParams, qs, domain, prefixUrl, expiresIn, purpose, disableRouteLookup };
 }
 exports.normalizeMakeSignedUrlOptions = normalizeMakeSignedUrlOptions;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonisjs/http-server",
-  "version": "5.7.4",
+  "version": "5.10.0",
   "description": "AdonisJS HTTP server with support packed with Routing and Cookies",
   "main": "build/providers/HttpServerProvider.js",
   "files": [
@@ -36,44 +36,44 @@
   "author": "virk,adonisjs",
   "license": "MIT",
   "devDependencies": {
-    "@adonisjs/application": "^5.2.1",
+    "@adonisjs/application": "^5.2.5",
     "@adonisjs/encryption": "^4.0.8",
     "@adonisjs/mrm-preset": "^5.0.3",
-    "@adonisjs/require-ts": "^2.0.11",
-    "@japa/assert": "^1.3.3",
+    "@adonisjs/require-ts": "^2.0.12",
+    "@japa/assert": "^1.3.4",
     "@japa/run-failed-tests": "^1.0.7",
-    "@japa/runner": "^2.0.6",
+    "@japa/runner": "^2.0.8",
     "@japa/spec-reporter": "^1.1.12",
     "@poppinss/dev-utils": "^2.0.3",
-    "@types/cookie": "^0.4.1",
+    "@types/cookie": "^0.5.1",
     "@types/ms": "^0.7.31",
-    "@types/node": "^17.0.23",
+    "@types/node": "^17.0.35",
     "@types/pluralize": "0.0.29",
     "@types/proxy-addr": "^2.0.0",
     "@types/qs": "^6.9.7",
     "@types/supertest": "^2.0.12",
-    "autocannon": "^7.8.1",
+    "autocannon": "^7.9.0",
     "commitizen": "^4.2.4",
     "cross-env": "^7.0.3",
     "cz-conventional-changelog": "^3.3.0",
     "del-cli": "^4.0.1",
-    "eslint": "^8.12.0",
+    "eslint": "^8.16.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-adonis": "^2.1.0",
     "eslint-plugin-prettier": "^4.0.0",
-    "fastify": "^3.27.4",
+    "fastify": "^3.29.0",
     "github-label-sync": "^2.2.0",
     "http-status-codes": "^2.2.0",
-    "husky": "^7.0.4",
-    "middie": "^6.0.0",
+    "husky": "^8.0.1",
+    "middie": "^6.1.0",
     "mrm": "^4.0.0",
     "np": "^7.6.1",
     "pem": "^1.14.6",
     "prettier": "^2.6.2",
     "reflect-metadata": "^0.1.13",
-    "supertest": "^6.2.2",
-    "ts-node": "^10.7.0",
-    "typescript": "^4.6.3"
+    "supertest": "^6.2.3",
+    "ts-node": "^10.8.0",
+    "typescript": "^4.7.2"
   },
   "peerDependencies": {
     "@adonisjs/application": "^5.0.0",
@@ -98,11 +98,11 @@
   },
   "dependencies": {
     "@poppinss/matchit": "^3.1.2",
-    "@poppinss/utils": "^4.0.3",
+    "@poppinss/utils": "^4.0.4",
     "accepts": "^1.3.8",
     "co-compose": "^7.0.2",
     "content-disposition": "^0.5.4",
-    "cookie": "^0.4.2",
+    "cookie": "^0.5.0",
     "destroy": "^1.2.0",
     "encodeurl": "^1.0.2",
     "etag": "^1.8.1",