@adonisjs/http-server 8.0.0-next.0 → 8.0.0-next.2

package/build/{chunk-VYBTM3NC.js → chunk-Z5EN426L.js}

@@ -876,6 +876,8 @@ function safeDecodeURI(path, useSemicolonDelimiter) {
 }
 
 // src/router/route.ts
+import StringBuilder from "@poppinss/utils/string_builder";
+import string2 from "@poppinss/utils/string";
 var Route = class extends Macroable4 {
   /**
    * Route pattern
@@ -938,8 +940,10 @@ var Route = class extends Macroable4 {
     this.#routerMiddleware = routerMiddleware;
     this.#pattern = options.pattern;
     this.#methods = options.methods;
-    this.#handler = this.#resolveRouteHandle(options.handler);
     this.#globalMatchers = options.globalMatchers;
+    const { handler, routeName } = this.#resolveRouteHandle(options.handler);
+    this.#handler = handler;
+    this.#name = routeName;
   }
   /**
    * Resolves the route handler string expression to a
@@ -951,24 +955,35 @@ var Route = class extends Macroable4 {
       const method = parts.length === 1 ? "handle" : parts.pop();
       const moduleRefId = parts.join(".");
       return {
-        reference: handler,
-        ...moduleImporter(() => this.#app.import(moduleRefId), method).toHandleMethod(),
-        name: handler
+        handler: {
+          reference: handler,
+          ...moduleImporter(() => this.#app.import(moduleRefId), method).toHandleMethod(),
+          name: handler
+        },
+        routeName: `${new StringBuilder(moduleRefId.split("/").pop()).removeSuffix("controller").snakeCase()}.${string2.snakeCase(method)}`
       };
     }
     if (Array.isArray(handler)) {
-      if (is.class(handler[0])) {
+      const controller = handler[0];
+      const method = handler[1] ?? "handle";
+      if (is.class(controller)) {
         return {
-          reference: handler,
-          ...moduleCaller(handler[0], handler[1] || "handle").toHandleMethod()
+          handler: {
+            reference: handler,
+            ...moduleCaller(controller, method).toHandleMethod()
+          },
+          routeName: `${new StringBuilder(controller.name).removeSuffix("controller").snakeCase()}.${string2.snakeCase(method)}`
         };
       }
       return {
-        reference: handler,
-        ...moduleImporter(handler[0], handler[1] || "handle").toHandleMethod()
+        handler: {
+          reference: handler,
+          ...moduleImporter(controller, method).toHandleMethod()
+        },
+        routeName: `${new StringBuilder(controller.name).removeSuffix("controller").snakeCase()}.${string2.snakeCase(method)}`
       };
     }
-    return handler;
+    return { handler };
   }
   /**
    * Returns an object of param matchers by merging global and local
@@ -3366,7 +3381,6 @@ var Response = class extends Macroable6 {
 
 // src/router/main.ts
 import is3 from "@sindresorhus/is";
-import lodash2 from "@poppinss/utils/lodash";
 import { moduleImporter as moduleImporter3 } from "@adonisjs/fold";
 import { RuntimeException as RuntimeException5 } from "@poppinss/utils/exception";
 
@@ -3506,113 +3520,6 @@ var RoutesStore = class {
   }
 };
 
-// src/client/router.ts
-var RouterClient = class {
-  /**
-   * List of route references kept for lookup.
-   */
-  routes;
-  /**
-   * The lookup strategies to follow when generating URL builder
-   * types and client
-   */
-  lookupStrategies = ["name", "pattern"];
-  constructor(routes) {
-    this.routes = routes ?? {};
-  }
-  /**
-   * Register route JSON payload
-   */
-  register(route) {
-    this.routes[route.domain] = this.routes[route.domain] || [];
-    this.routes[route.domain].push(route);
-  }
-  /**
-   * Define the lookup strategies to follow when generating URL builder
-   * types and client.
-   */
-  updateLookupStrategies(strategies) {
-    this.lookupStrategies = strategies;
-    return this;
-  }
-  /**
-   * Finds a route by its identifier. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
-   *
-   * When "followLookupStrategy" is enabled, the lookup will be performed
-   * on the basis of the lookup strategy enabled via the "lookupStrategies"
-   * method. The default lookupStrategy is "name" and "pattern".
-   */
-  find(routeIdentifier, domain, method, followLookupStrategy) {
-    if (!domain) {
-      let route = null;
-      for (const routeDomain of Object.keys(this.routes)) {
-        route = this.find(routeIdentifier, routeDomain, method, followLookupStrategy);
-        if (route) {
-          break;
-        }
-      }
-      return route;
-    }
-    const routes = this.routes[domain];
-    if (!routes) {
-      return null;
-    }
-    const lookupByName = !followLookupStrategy || this.lookupStrategies.includes("name");
-    const lookupByPattern = !followLookupStrategy || this.lookupStrategies.includes("pattern");
-    const lookupByController = !followLookupStrategy || this.lookupStrategies.includes("controller");
-    return routes.find((route) => {
-      if (method && !route.methods.includes(method)) {
-        return false;
-      }
-      if (route.name === routeIdentifier && lookupByName || route.pattern === routeIdentifier && lookupByPattern) {
-        return true;
-      }
-      if (typeof route.handler === "function" || !lookupByController) {
-        return false;
-      }
-      return route.handler.reference === routeIdentifier;
-    }) || null;
-  }
-  /**
-   * Finds a route by its identifier. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
-   *
-   * An error is raised when unable to find the route.
-   *
-   * When "followLookupStrategy" is enabled, the lookup will be performed
-   * on the basis of the lookup strategy enabled via the "lookupStrategies"
-   * method. The default lookupStrategy is "name" and "pattern".
-   */
-  findOrFail(routeIdentifier, domain, method, followLookupStrategy) {
-    const route = this.find(routeIdentifier, domain, method, followLookupStrategy);
-    if (!route) {
-      throw new Error(`Cannot lookup route "${routeIdentifier}"`);
-    }
-    return route;
-  }
-  /**
-   * Check if a route exists. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
-   *
-   * When "followLookupStrategy" is enabled, the lookup will be performed
-   * on the basis of the lookup strategy enabled via the "lookupStrategies"
-   * method. The default lookupStrategy is "name" and "pattern".
-   */
-  has(routeIdentifier, domain, method, followLookupStrategy) {
-    return !!this.find(routeIdentifier, domain, method, followLookupStrategy);
-  }
-  /**
-   * Returns a list of routes grouped by their domain names
-   */
-  toJSON() {
-    return this.routes;
-  }
-};
-
 // src/router/legacy/url_builder.ts
 var UrlBuilder = class {
   /**
@@ -3747,30 +3654,7 @@ var RouteMatchers = class extends Macroable7 {
   }
 };
 
-// src/define_middleware.ts
-import { moduleImporter as moduleImporter2 } from "@adonisjs/fold";
-function middlewareReferenceBuilder(name, middleware) {
-  const handler = moduleImporter2(middleware, "handle").toHandleMethod();
-  return function(...args) {
-    return {
-      ...handler,
-      name,
-      reference: middleware,
-      args: args[0]
-    };
-  };
-}
-function defineNamedMiddleware(collection) {
-  return Object.keys(collection).reduce(
-    (result, key) => {
-      result[key] = middlewareReferenceBuilder(key, collection[key]);
-      return result;
-    },
-    {}
-  );
-}
-
-// src/client/url_builder.ts
+// src/router/url_builder.ts
 function createURL(identifier, tokens, searchParamsStringifier, params, options) {
   const uriSegments = [];
   const paramsArray = Array.isArray(params) ? params : null;
@@ -3891,6 +3775,29 @@ function createUrlBuilder(router, searchParamsStringifier) {
   return urlFor;
 }
 
+// src/define_middleware.ts
+import { moduleImporter as moduleImporter2 } from "@adonisjs/fold";
+function middlewareReferenceBuilder(name, middleware) {
+  const handler = moduleImporter2(middleware, "handle").toHandleMethod();
+  return function(...args) {
+    return {
+      ...handler,
+      name,
+      reference: middleware,
+      args: args[0]
+    };
+  };
+}
+function defineNamedMiddleware(collection) {
+  return Object.keys(collection).reduce(
+    (result, key) => {
+      result[key] = middlewareReferenceBuilder(key, collection[key]);
+      return result;
+    },
+    {}
+  );
+}
+
 // src/router/signed_url_builder.ts
 function createSignedURL(identifier, tokens, searchParamsStringifier, encryption, params, options) {
   const signature = encryption.verifier.sign(
@@ -3985,7 +3892,7 @@ function createSignedUrlBuilder(router, encryption, searchParamsStringifier) {
 }
 
 // src/router/main.ts
-var Router = class extends RouterClient {
+var Router = class {
   /**
    * Flag to avoid re-comitting routes to the store
    */
@@ -4049,8 +3956,11 @@ var Router = class extends RouterClient {
    * methods.
    */
   urlBuilder;
+  /**
+   * List of route references kept for lookup.
+   */
+  routes = {};
   constructor(app, encryption, qsParser) {
-    super();
     this.#app = app;
     this.#encryption = encryption;
     this.qs = qsParser;
@@ -4059,6 +3969,13 @@ var Router = class extends RouterClient {
       signedUrlFor: createSignedUrlBuilder(this, this.#encryption, this.qs.stringify)
     };
   }
+  /**
+   * Register route JSON payload
+   */
+  register(route) {
+    this.routes[route.domain] = this.routes[route.domain] || [];
+    this.routes[route.domain].push(route);
+  }
   /**
    * Push a give router entity to the list of routes or the
    * recently opened group.
@@ -4232,7 +4149,7 @@ var Router = class extends RouterClient {
       const routeNames = routeNamesByDomain.get(route.domain);
       if (route.name && routeNames.has(route.name)) {
         throw new RuntimeException5(
-          `Route with duplicate name found. A route with name "${route.name}" already exists`
+          `A route with name "${route.name}" already exists. It may happen when two routes use the same controller, so make sure to give explicit names to these routes`
         );
       }
       if (route.name) {
@@ -4249,6 +4166,80 @@ var Router = class extends RouterClient {
     this.#openedGroups = [];
     this.#commited = true;
   }
+  /**
+   * Finds a route by its identifier. The identifier can be the
+   * route name, controller.method name or the route pattern
+   * itself.
+   *
+   * When "disableLegacyLookup" is set, the lookup will be performed
+   * only using the route name
+   */
+  find(routeIdentifier, domain, method, disableLegacyLookup) {
+    if (!domain) {
+      let route = null;
+      for (const routeDomain of Object.keys(this.routes)) {
+        route = this.find(routeIdentifier, routeDomain, method, disableLegacyLookup);
+        if (route) {
+          break;
+        }
+      }
+      return route;
+    }
+    const routes = this.routes[domain];
+    if (!routes) {
+      return null;
+    }
+    const lookupByName = true;
+    const lookupByPattern = !disableLegacyLookup;
+    const lookupByController = !disableLegacyLookup;
+    return routes.find((route) => {
+      if (method && !route.methods.includes(method)) {
+        return false;
+      }
+      if (route.name === routeIdentifier && lookupByName || route.pattern === routeIdentifier && lookupByPattern) {
+        return true;
+      }
+      if (typeof route.handler === "function" || !lookupByController) {
+        return false;
+      }
+      return route.handler.reference === routeIdentifier;
+    }) || null;
+  }
+  /**
+   * Finds a route by its identifier. The identifier can be the
+   * route name, controller.method name or the route pattern
+   * itself.
+   *
+   * An error is raised when unable to find the route.
+   *
+   * When "disableLegacyLookup" is set, the lookup will be performed
+   * only using the route name
+   */
+  findOrFail(routeIdentifier, domain, method, disableLegacyLookup) {
+    const route = this.find(routeIdentifier, domain, method, disableLegacyLookup);
+    if (!route) {
+      throw new Error(`Cannot lookup route "${routeIdentifier}"`);
+    }
+    return route;
+  }
+  /**
+   * Check if a route exists. The identifier can be the
+   * route name, controller.method name or the route pattern
+   * itself.
+   *
+   * When "followLookupStrategy" is enabled, the lookup will be performed
+   * on the basis of the lookup strategy enabled via the "lookupStrategies"
+   * method. The default lookupStrategy is "name" and "pattern".
+   */
+  has(routeIdentifier, domain, method, followLookupStrategy) {
+    return !!this.find(routeIdentifier, domain, method, followLookupStrategy);
+  }
+  /**
+   * Returns a list of routes grouped by their domain names
+   */
+  toJSON() {
+    return this.routes;
+  }
   /**
    * Generates types for the URL builder. These types must
    * be written inside a file for the URL builder to
@@ -4279,21 +4270,11 @@ var Router = class extends RouterClient {
         routesList["ALL"] = routesList["ALL"] ?? {};
         routesList[method] = routesList[method] ?? {};
         const identifiers = [];
-        if (this.lookupStrategies.includes("pattern")) {
-          if (!routesList[method][route.pattern]) {
-            identifiers.push(route.pattern);
-          }
-        }
-        if (this.lookupStrategies.includes("name") && route.name) {
+        if (route.name) {
           identifiers.push(
             domain && routesList[method][route.name] ? `${domain}@${route.name}` : route.name
           );
         }
-        if (this.lookupStrategies.includes("controller") && "reference" in route.handler && typeof route.handler.reference === "string") {
-          identifiers.push(
-            domain && routesList[method][route.handler.reference] ? `${domain}@${route.handler.reference}` : route.handler.reference
-          );
-        }
         identifiers.forEach((identifier) => {
           routesList["ALL"][identifier] = {
             params,
@@ -4329,38 +4310,6 @@ var Router = class extends RouterClient {
       return result;
     }, []).join("\n");
   }
-  generateClient() {
-    const routesForClient = Object.keys(this.routes).reduce(
-      (result, domain) => {
-        const routes = this.routes[domain];
-        result[domain] = routes.map((route) => {
-          const controller = "reference" in route.handler && typeof route.handler.reference === "string" ? route.handler.reference : void 0;
-          return {
-            pattern: route.pattern,
-            name: route.name,
-            handler: {
-              reference: controller
-            },
-            methods: route.methods,
-            domain: route.domain,
-            tokens: route.tokens.map((tokens) => {
-              return lodash2.pick(tokens, ["val", "type", "end"]);
-            })
-          };
-        });
-        return result;
-      },
-      {}
-    );
-    return `import type { RoutesList } from '@adonisjs/core/types/http'
-import { RouterClient, createUrlBuilder, ClientRouteJSON } from 'adonisjs/core/http/client'
-
-const routes = ${JSON.stringify(routesForClient)} satisfies { [domain: string]: ClientRouteJSON[] }
-const router = new RouterClient(routes)
-export const urlFor = createUrlBuilder<RoutesList>(router, (qs) => {
-  return new URLSearchParams(qs).toString()
-})`;
-  }
   /**
    * Find route for a given URL, method and optionally domain
    */
@@ -4912,8 +4861,8 @@ var Server = class {
 
 // src/define_config.ts
 import proxyAddr from "proxy-addr";
-import string2 from "@poppinss/utils/string";
-import lodash3 from "@poppinss/utils/lodash";
+import string3 from "@poppinss/utils/string";
+import lodash2 from "@poppinss/utils/lodash";
 function defineConfig(config) {
   const { trustProxy: trustProxy2, ...rest } = config;
   const defaults = {
@@ -4950,9 +4899,9 @@ function defineConfig(config) {
       }
     }
   };
-  const normalizedConfig = lodash3.merge({}, defaults, rest);
+  const normalizedConfig = lodash2.merge({}, defaults, rest);
   if (normalizedConfig.cookie.maxAge) {
-    normalizedConfig.cookie.maxAge = string2.seconds.parse(normalizedConfig.cookie.maxAge);
+    normalizedConfig.cookie.maxAge = string3.seconds.parse(normalizedConfig.cookie.maxAge);
   }
   if (typeof trustProxy2 === "boolean") {
     const tpValue = trustProxy2;

package/build/factories/http_context.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from '@adonisjs/logger';
-import type { Request } from '../src/request.js';
-import type { Response } from '../src/response.js';
-import { HttpContext } from '../src/http_context/main.js';
+import type { Request } from '../src/request.ts';
+import type { Response } from '../src/response.ts';
+import { HttpContext } from '../src/http_context/main.ts';
 type FactoryParameters = {
     request: Request;
     response: Response;

package/build/factories/main.d.ts

@@ -1,6 +1,6 @@
-export { RouterFactory } from './router.js';
-export { RequestFactory } from './request.js';
-export { ResponseFactory } from './response.js';
-export { ServerFactory } from './server_factory.js';
-export { HttpContextFactory } from './http_context.js';
-export { QsParserFactory } from './qs_parser_factory.js';
+export { RouterFactory } from './router.ts';
+export { RequestFactory } from './request.ts';
+export { ResponseFactory } from './response.ts';
+export { ServerFactory } from './server_factory.ts';
+export { HttpContextFactory } from './http_context.ts';
+export { QsParserFactory } from './qs_parser_factory.ts';

package/build/factories/main.js

@@ -6,7 +6,7 @@ import {
   Router,
   Server,
   defineConfig
-} from "../chunk-VYBTM3NC.js";
+} from "../chunk-Z5EN426L.js";
 import "../chunk-ASX56VAK.js";
 
 // factories/router.ts

package/build/factories/qs_parser_factory.d.ts

@@ -1,5 +1,5 @@
-import { Qs } from '../src/qs.js';
-import type { QSParserConfig } from '../src/types/qs.js';
+import { Qs } from '../src/qs.ts';
+import type { QSParserConfig } from '../src/types/qs.ts';
 /**
  * QS Parser factory is used to generate the query string
  * parser for testing

package/build/factories/request.d.ts

@@ -1,7 +1,7 @@
 import type { Encryption } from '@adonisjs/encryption';
 import { IncomingMessage, ServerResponse } from 'node:http';
-import { Request } from '../src/request.js';
-import { type RequestConfig } from '../src/types/request.js';
+import { Request } from '../src/request.ts';
+import { type RequestConfig } from '../src/types/request.ts';
 type FactoryParameters = {
     url: string;
     method: string;

package/build/factories/response.d.ts

@@ -1,8 +1,8 @@
 import type { Encryption } from '@adonisjs/encryption';
 import { IncomingMessage, ServerResponse } from 'node:http';
-import { Response } from '../src/response.js';
-import { type Router } from '../src/router/main.js';
-import { type ResponseConfig } from '../src/types/response.js';
+import { Response } from '../src/response.ts';
+import { type Router } from '../src/router/main.ts';
+import { type ResponseConfig } from '../src/types/response.ts';
 type FactoryParameters = {
     req: IncomingMessage;
     res: ServerResponse;

package/build/factories/router.d.ts

@@ -1,6 +1,6 @@
 import type { Encryption } from '@adonisjs/encryption';
 import type { Application } from '@adonisjs/application';
-import { Router } from '../src/router/main.js';
+import { Router } from '../src/router/main.ts';
 type FactoryParameters = {
     app: Application<any>;
     encryption: Encryption;

package/build/factories/server_factory.d.ts

@@ -2,8 +2,8 @@ import { Logger } from '@adonisjs/logger';
 import { Emitter } from '@adonisjs/events';
 import type { Encryption } from '@adonisjs/encryption';
 import type { Application } from '@adonisjs/application';
-import { Server } from '../src/server/main.js';
-import type { ServerConfig } from '../src/types/server.js';
+import { Server } from '../src/server/main.ts';
+import type { ServerConfig } from '../src/types/server.ts';
 type FactoryParameters = {
     app: Application<any>;
     logger: Logger;

package/build/factories/url_builder_factory.d.ts

@@ -1,6 +1,6 @@
 import type { Encryption } from '@adonisjs/encryption';
 import type { Router } from '../src/router/main.ts';
-import { type LookupList } from '../src/client/types.ts';
+import { type LookupList } from '../src/types/url_builder.ts';
 type FactoryParameters = {
     router: Router;
     encryption: Encryption;
@@ -18,8 +18,8 @@ export declare class URLBuilderFactory<Routes extends LookupList> {
      * Create URL builder helpers
      */
     create(): {
-        urlFor: import("../src/client/types.ts").UrlFor<Routes>;
-        signedUrlFor: import("../src/client/types.ts").UrlFor<Routes, import("../src/client/types.ts").SignedURLOptions>;
+        urlFor: import("../src/types/url_builder.ts").UrlFor<Routes>;
+        signedUrlFor: import("../src/types/url_builder.ts").UrlFor<Routes, import("../src/types/url_builder.ts").SignedURLOptions>;
     };
 }
 export {};

package/build/index.d.ts

@@ -1,16 +1,16 @@
-export * as errors from './src/errors.js';
-export { Request } from './src/request.js';
-export { Response } from './src/response.js';
-export { Redirect } from './src/redirect.js';
-export { Server } from './src/server/main.js';
-export { Router } from './src/router/main.js';
-export { Route } from './src/router/route.js';
-export { BriskRoute } from './src/router/brisk.js';
-export { RouteGroup } from './src/router/group.js';
-export { defineConfig } from './src/define_config.js';
-export { CookieClient } from './src/cookies/client.js';
-export { HttpContext } from './src/http_context/main.js';
-export { RouteResource } from './src/router/resource.js';
-export { ResponseStatus } from './src/response_status.js';
-export { ExceptionHandler } from './src/exception_handler.js';
-export * as tracingChannels from './src/tracing_channels.js';
+export * as errors from './src/errors.ts';
+export { Request } from './src/request.ts';
+export { Response } from './src/response.ts';
+export { Redirect } from './src/redirect.ts';
+export { Server } from './src/server/main.ts';
+export { Router } from './src/router/main.ts';
+export { Route } from './src/router/route.ts';
+export { BriskRoute } from './src/router/brisk.ts';
+export { RouteGroup } from './src/router/group.ts';
+export { defineConfig } from './src/define_config.ts';
+export { CookieClient } from './src/cookies/client.ts';
+export { HttpContext } from './src/http_context/main.ts';
+export { RouteResource } from './src/router/resource.ts';
+export { ResponseStatus } from './src/response_status.ts';
+export { ExceptionHandler } from './src/exception_handler.ts';
+export * as tracingChannels from './src/tracing_channels.ts';

package/build/index.js

@@ -20,7 +20,7 @@ import {
   errors_exports,
   parseRange,
   tracing_channels_exports
-} from "./chunk-VYBTM3NC.js";
+} from "./chunk-Z5EN426L.js";
 import "./chunk-ASX56VAK.js";
 
 // src/exception_handler.ts

package/build/src/cookies/serializer.d.ts

@@ -1,5 +1,5 @@
 import type { Encryption } from '@adonisjs/encryption';
-import type { CookieOptions } from '../types/response.js';
+import type { CookieOptions } from '../types/response.ts';
 /**
  * Cookies serializer is used to serialize a value to be set on the `Set-Cookie`
  * header. You can `encode`, `sign` on `encrypt` cookies using the serializer

package/build/src/define_config.d.ts

@@ -1,4 +1,4 @@
-import type { ServerConfig } from './types/server.js';
+import type { ServerConfig } from './types/server.ts';
 type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
 };

package/build/src/define_middleware.d.ts

@@ -1,5 +1,5 @@
 import type { LazyImport, UnWrapLazyImport } from '@poppinss/utils/types';
-import type { GetMiddlewareArgs, MiddlewareAsClass, ParsedGlobalMiddleware } from './types/middleware.js';
+import type { GetMiddlewareArgs, MiddlewareAsClass, ParsedGlobalMiddleware } from './types/middleware.ts';
 /**
  * Define an collection of named middleware. The collection gets converted
  * into a collection of factory functions. Calling the function returns