clear-router 2.8.8 → 2.9.0

package/dist/express/router.mjs

@@ -11,6 +11,9 @@ import { isFetchResponse, resolveResponseMeta, responseWasSent } from "../core/r
 */
 var Router = class Router extends CoreRouter {
 	static routerStateNamespace = "clear-router:express";
+	static formatWildcardParam(name) {
+		return `*${name}`;
+	}
 	static ensureRequestBodyAccessor(req) {
 		if (typeof req.getBody !== "function") req.getBody = () => req.body ?? {};
 	}
@@ -196,7 +199,7 @@ var Router = class Router extends CoreRouter {
 					console.error("[ROUTES]", error.message);
 					throw error;
 				}
-				for (const registrationPath of route.registrationPaths) router[method](registrationPath, (req, _res, next) => {
+				for (const registrationPath of this.resolveRegistrationPaths(route)) router[method](registrationPath, (req, _res, next) => {
 					Router.ensureRequestBodyAccessor(req);
 					const override = Router.resolveMethodOverride(req.method, req.headers, req.body);
 					if (method === "post" && override && override !== "post") return next("route");
@@ -210,10 +213,13 @@ var Router = class Router extends CoreRouter {
 							next
 						};
 						const inst = instance ?? route;
+						const params = Router.matchRoute(route, ctx, ctx.req.params);
+						if (params === false) return next("route");
+						Object.assign(ctx.req.params, params);
 						Router.bindRequestToInstance(ctx, inst, route, {
 							body: ctx.req.getBody(),
 							query: ctx.req.query,
-							params: ctx.req.params,
+							params,
 							method
 						});
 						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
@@ -228,7 +234,7 @@ var Router = class Router extends CoreRouter {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) router.post(registrationPath, (req, _res, next) => {
+				].includes(method)) for (const registrationPath of this.resolveRegistrationPaths(route)) router.post(registrationPath, (req, _res, next) => {
 					Router.ensureRequestBodyAccessor(req);
 					if (Router.resolveMethodOverride(req.method, req.headers, req.body) !== method) return next("route");
 					req.method = method.toUpperCase();
@@ -242,10 +248,13 @@ var Router = class Router extends CoreRouter {
 							next
 						};
 						const inst = instance ?? route;
+						const params = Router.matchRoute(route, ctx, ctx.req.params);
+						if (params === false) return next("route");
+						Object.assign(ctx.req.params, params);
 						Router.bindRequestToInstance(ctx, inst, route, {
 							body: ctx.req.getBody(),
 							query: ctx.req.query,
-							params: ctx.req.params,
+							params,
 							method
 						});
 						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);

package/dist/fastify/router.cjs

@@ -10,6 +10,9 @@ const require_responses = require('../core/responses.cjs');
 */
 var Router = class Router extends require_CoreRouter.CoreRouter {
 	static routerStateNamespace = "clear-router:fastify";
+	static formatWildcardParam() {
+		return "*";
+	}
 	static ensureRequestBodyAccessor(req) {
 		if (typeof req.getBody !== "function") req.getBody = () => req.body ?? {};
 	}
@@ -191,7 +194,7 @@ var Router = class Router extends require_CoreRouter.CoreRouter {
 				];
 				if (method === "options" && route.methods.length > 1) continue;
 				if (!allowedMethods.includes(method)) throw new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-				for (const registrationPath of route.registrationPaths) app.route({
+				for (const registrationPath of this.resolveRegistrationPaths(route)) app.route({
 					method: method.toUpperCase(),
 					url: registrationPath,
 					preHandler: route.middlewares,
@@ -204,10 +207,13 @@ var Router = class Router extends require_CoreRouter.CoreRouter {
 							reply
 						};
 						const inst = instance ?? route;
+						const params = Router.matchRoute(route, ctx, ctx.req.params ?? {});
+						if (params === false) return reply.code(404).send();
+						Object.assign(ctx.req.params ??= {}, params);
 						Router.bindRequestToInstance(ctx, inst, route, {
 							body: ctx.req.getBody(),
 							query: ctx.req.query ?? {},
-							params: ctx.req.params ?? {},
+							params,
 							method
 						});
 						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
@@ -220,7 +226,7 @@ var Router = class Router extends require_CoreRouter.CoreRouter {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) app.route({
+				].includes(method)) for (const registrationPath of this.resolveRegistrationPaths(route)) app.route({
 					method: "POST",
 					url: registrationPath,
 					preHandler: route.middlewares,
@@ -232,10 +238,13 @@ var Router = class Router extends require_CoreRouter.CoreRouter {
 							reply
 						};
 						const inst = instance ?? route;
+						const params = Router.matchRoute(route, ctx, ctx.req.params ?? {});
+						if (params === false) return reply.code(404).send();
+						Object.assign(ctx.req.params ??= {}, params);
 						Router.bindRequestToInstance(ctx, inst, route, {
 							body: ctx.req.getBody(),
 							query: ctx.req.query ?? {},
-							params: ctx.req.params ?? {},
+							params,
 							method
 						});
 						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);

package/dist/fastify/router.d.cts

@@ -14,6 +14,7 @@ import { CoreRouter } from "../core/CoreRouter.cjs";
  */
 declare class Router extends CoreRouter {
   protected static routerStateNamespace: string;
+  protected static formatWildcardParam(): string;
   private static ensureRequestBodyAccessor;
   private static sendReturnValue;
   /**

package/dist/fastify/router.d.mts

@@ -14,6 +14,7 @@ import { CoreRouter } from "../core/CoreRouter.mjs";
  */
 declare class Router extends CoreRouter {
   protected static routerStateNamespace: string;
+  protected static formatWildcardParam(): string;
   private static ensureRequestBodyAccessor;
   private static sendReturnValue;
   /**

package/dist/fastify/router.mjs

@@ -10,6 +10,9 @@ import { isFetchResponse, resolveResponseMeta, responseWasSent } from "../core/r
 */
 var Router = class Router extends CoreRouter {
 	static routerStateNamespace = "clear-router:fastify";
+	static formatWildcardParam() {
+		return "*";
+	}
 	static ensureRequestBodyAccessor(req) {
 		if (typeof req.getBody !== "function") req.getBody = () => req.body ?? {};
 	}
@@ -191,7 +194,7 @@ var Router = class Router extends CoreRouter {
 				];
 				if (method === "options" && route.methods.length > 1) continue;
 				if (!allowedMethods.includes(method)) throw new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-				for (const registrationPath of route.registrationPaths) app.route({
+				for (const registrationPath of this.resolveRegistrationPaths(route)) app.route({
 					method: method.toUpperCase(),
 					url: registrationPath,
 					preHandler: route.middlewares,
@@ -204,10 +207,13 @@ var Router = class Router extends CoreRouter {
 							reply
 						};
 						const inst = instance ?? route;
+						const params = Router.matchRoute(route, ctx, ctx.req.params ?? {});
+						if (params === false) return reply.code(404).send();
+						Object.assign(ctx.req.params ??= {}, params);
 						Router.bindRequestToInstance(ctx, inst, route, {
 							body: ctx.req.getBody(),
 							query: ctx.req.query ?? {},
-							params: ctx.req.params ?? {},
+							params,
 							method
 						});
 						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
@@ -220,7 +226,7 @@ var Router = class Router extends CoreRouter {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) app.route({
+				].includes(method)) for (const registrationPath of this.resolveRegistrationPaths(route)) app.route({
 					method: "POST",
 					url: registrationPath,
 					preHandler: route.middlewares,
@@ -232,10 +238,13 @@ var Router = class Router extends CoreRouter {
 							reply
 						};
 						const inst = instance ?? route;
+						const params = Router.matchRoute(route, ctx, ctx.req.params ?? {});
+						if (params === false) return reply.code(404).send();
+						Object.assign(ctx.req.params ??= {}, params);
 						Router.bindRequestToInstance(ctx, inst, route, {
 							body: ctx.req.getBody(),
 							query: ctx.req.query ?? {},
-							params: ctx.req.params ?? {},
+							params,
 							method
 						});
 						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);

package/dist/h3/router.cjs

@@ -11,6 +11,9 @@ let h3 = require("h3");
 */
 var Router = class Router extends require_CoreRouter.CoreRouter {
 	static routerStateNamespace = "clear-router:h3";
+	static formatWildcardParam(name) {
+		return `**:${name}`;
+	}
 	static bodyCache = /* @__PURE__ */ new WeakMap();
 	static toResponse(ctx, value, method, path) {
 		const meta = require_responses.resolveResponseMeta(value, {
@@ -205,17 +208,20 @@ var Router = class Router extends require_CoreRouter.CoreRouter {
 					console.error("[ROUTES]", error.message);
 					throw error;
 				}
-				for (const registrationPath of route.registrationPaths) app[method](registrationPath, async (event) => {
+				for (const registrationPath of this.resolveRegistrationPaths(route)) app[method](registrationPath, async (event) => {
 					try {
 						const ctx = event;
 						const reqBody = await Router.readBodyCached(ctx);
 						const override = Router.resolveMethodOverride(ctx.req.method, ctx.req.headers, reqBody);
 						if (method === "post" && override && override !== "post") return;
 						const inst = instance ?? route;
+						const params = Router.matchRoute(route, ctx, (0, h3.getRouterParams)(ctx, { decode: true }));
+						if (params === false) return Symbol.for("h3.notFound");
+						ctx.context = Object.assign(ctx.context ?? {}, { params });
 						Router.bindRequestToInstance(ctx, inst, route, {
 							body: reqBody,
 							query: (0, h3.getQuery)(ctx),
-							params: (0, h3.getRouterParams)(ctx, { decode: true }),
+							params,
 							method
 						});
 						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
@@ -230,16 +236,19 @@ var Router = class Router extends require_CoreRouter.CoreRouter {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) app.post(registrationPath, async (event) => {
+				].includes(method)) for (const registrationPath of this.resolveRegistrationPaths(route)) app.post(registrationPath, async (event) => {
 					try {
 						const ctx = event;
 						const reqBody = await Router.readBodyCached(ctx);
 						if (Router.resolveMethodOverride(ctx.req.method, ctx.req.headers, reqBody) !== method) return Symbol.for("h3.notFound");
 						const inst = instance ?? route;
+						const params = Router.matchRoute(route, ctx, (0, h3.getRouterParams)(ctx, { decode: true }));
+						if (params === false) return Symbol.for("h3.notFound");
+						ctx.context = Object.assign(ctx.context ?? {}, { params });
 						Router.bindRequestToInstance(ctx, inst, route, {
 							body: reqBody,
 							query: (0, h3.getQuery)(ctx),
-							params: (0, h3.getRouterParams)(ctx, { decode: true }),
+							params,
 							method
 						});
 						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);

package/dist/h3/router.d.cts

@@ -15,6 +15,7 @@ import { H3 } from "h3";
  */
 declare class Router extends CoreRouter {
   protected static routerStateNamespace: string;
+  protected static formatWildcardParam(name: string): string;
   private static readonly bodyCache;
   private static toResponse;
   private static readBodyCached;

package/dist/h3/router.d.mts

@@ -15,6 +15,7 @@ import { H3 } from "h3";
  */
 declare class Router extends CoreRouter {
   protected static routerStateNamespace: string;
+  protected static formatWildcardParam(name: string): string;
   private static readonly bodyCache;
   private static toResponse;
   private static readBodyCached;

package/dist/h3/router.mjs

@@ -11,6 +11,9 @@ import { HTTPResponse, getQuery, getRouterParams, readBody } from "h3";
 */
 var Router = class Router extends CoreRouter {
 	static routerStateNamespace = "clear-router:h3";
+	static formatWildcardParam(name) {
+		return `**:${name}`;
+	}
 	static bodyCache = /* @__PURE__ */ new WeakMap();
 	static toResponse(ctx, value, method, path) {
 		const meta = resolveResponseMeta(value, {
@@ -205,17 +208,20 @@ var Router = class Router extends CoreRouter {
 					console.error("[ROUTES]", error.message);
 					throw error;
 				}
-				for (const registrationPath of route.registrationPaths) app[method](registrationPath, async (event) => {
+				for (const registrationPath of this.resolveRegistrationPaths(route)) app[method](registrationPath, async (event) => {
 					try {
 						const ctx = event;
 						const reqBody = await Router.readBodyCached(ctx);
 						const override = Router.resolveMethodOverride(ctx.req.method, ctx.req.headers, reqBody);
 						if (method === "post" && override && override !== "post") return;
 						const inst = instance ?? route;
+						const params = Router.matchRoute(route, ctx, getRouterParams(ctx, { decode: true }));
+						if (params === false) return Symbol.for("h3.notFound");
+						ctx.context = Object.assign(ctx.context ?? {}, { params });
 						Router.bindRequestToInstance(ctx, inst, route, {
 							body: reqBody,
 							query: getQuery(ctx),
-							params: getRouterParams(ctx, { decode: true }),
+							params,
 							method
 						});
 						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
@@ -230,16 +236,19 @@ var Router = class Router extends CoreRouter {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) app.post(registrationPath, async (event) => {
+				].includes(method)) for (const registrationPath of this.resolveRegistrationPaths(route)) app.post(registrationPath, async (event) => {
 					try {
 						const ctx = event;
 						const reqBody = await Router.readBodyCached(ctx);
 						if (Router.resolveMethodOverride(ctx.req.method, ctx.req.headers, reqBody) !== method) return Symbol.for("h3.notFound");
 						const inst = instance ?? route;
+						const params = Router.matchRoute(route, ctx, getRouterParams(ctx, { decode: true }));
+						if (params === false) return Symbol.for("h3.notFound");
+						ctx.context = Object.assign(ctx.context ?? {}, { params });
 						Router.bindRequestToInstance(ctx, inst, route, {
 							body: reqBody,
 							query: getQuery(ctx),
-							params: getRouterParams(ctx, { decode: true }),
+							params,
 							method
 						});
 						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);

package/dist/hono/router.cjs

@@ -10,6 +10,9 @@ const require_responses = require('../core/responses.cjs');
 */
 var Router = class Router extends require_CoreRouter.CoreRouter {
 	static routerStateNamespace = "clear-router:hono";
+	static formatWildcardParam(name) {
+		return `:${name}{.+}`;
+	}
 	static bodyCache = /* @__PURE__ */ new WeakMap();
 	static toResponse(ctx, value, method, path) {
 		const meta = require_responses.resolveResponseMeta(value, {
@@ -204,16 +207,18 @@ var Router = class Router extends require_CoreRouter.CoreRouter {
 				];
 				if (method === "options" && route.methods.length > 1) continue;
 				if (!allowedMethods.includes(method)) throw new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-				for (const registrationPath of route.registrationPaths) app[method](registrationPath, ...route.middlewares || [], async (context) => {
+				for (const registrationPath of this.resolveRegistrationPaths(route)) app[method](registrationPath, ...route.middlewares || [], async (context) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					const override = Router.resolveMethodOverride(ctx.req.method, ctx.req.header(), reqBody);
 					if (method === "post" && override && override !== "post") return;
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, Router.getParams(ctx));
+					if (params === false) return ctx.notFound();
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.req.query(),
-						params: Router.getParams(ctx),
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
@@ -225,15 +230,17 @@ var Router = class Router extends require_CoreRouter.CoreRouter {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) app.post(registrationPath, ...route.middlewares || [], async (context) => {
+				].includes(method)) for (const registrationPath of this.resolveRegistrationPaths(route)) app.post(registrationPath, ...route.middlewares || [], async (context) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					if (Router.resolveMethodOverride(ctx.req.method, ctx.req.header(), reqBody) !== method) return;
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, Router.getParams(ctx));
+					if (params === false) return ctx.notFound();
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.req.query(),
-						params: Router.getParams(ctx),
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);

package/dist/hono/router.d.cts

@@ -14,6 +14,7 @@ import { CoreRouter } from "../core/CoreRouter.cjs";
  */
 declare class Router extends CoreRouter {
   protected static routerStateNamespace: string;
+  protected static formatWildcardParam(name: string): string;
   private static readonly bodyCache;
   private static toResponse;
   private static getParams;

package/dist/hono/router.d.mts

@@ -14,6 +14,7 @@ import { CoreRouter } from "../core/CoreRouter.mjs";
  */
 declare class Router extends CoreRouter {
   protected static routerStateNamespace: string;
+  protected static formatWildcardParam(name: string): string;
   private static readonly bodyCache;
   private static toResponse;
   private static getParams;

package/dist/hono/router.mjs

@@ -10,6 +10,9 @@ import { resolveResponseMeta } from "../core/responses.mjs";
 */
 var Router = class Router extends CoreRouter {
 	static routerStateNamespace = "clear-router:hono";
+	static formatWildcardParam(name) {
+		return `:${name}{.+}`;
+	}
 	static bodyCache = /* @__PURE__ */ new WeakMap();
 	static toResponse(ctx, value, method, path) {
 		const meta = resolveResponseMeta(value, {
@@ -204,16 +207,18 @@ var Router = class Router extends CoreRouter {
 				];
 				if (method === "options" && route.methods.length > 1) continue;
 				if (!allowedMethods.includes(method)) throw new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-				for (const registrationPath of route.registrationPaths) app[method](registrationPath, ...route.middlewares || [], async (context) => {
+				for (const registrationPath of this.resolveRegistrationPaths(route)) app[method](registrationPath, ...route.middlewares || [], async (context) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					const override = Router.resolveMethodOverride(ctx.req.method, ctx.req.header(), reqBody);
 					if (method === "post" && override && override !== "post") return;
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, Router.getParams(ctx));
+					if (params === false) return ctx.notFound();
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.req.query(),
-						params: Router.getParams(ctx),
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
@@ -225,15 +230,17 @@ var Router = class Router extends CoreRouter {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) app.post(registrationPath, ...route.middlewares || [], async (context) => {
+				].includes(method)) for (const registrationPath of this.resolveRegistrationPaths(route)) app.post(registrationPath, ...route.middlewares || [], async (context) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					if (Router.resolveMethodOverride(ctx.req.method, ctx.req.header(), reqBody) !== method) return;
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, Router.getParams(ctx));
+					if (params === false) return ctx.notFound();
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.req.query(),
-						params: Router.getParams(ctx),
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);

package/dist/index.cjs

@@ -4,6 +4,7 @@ const require_Controller = require('./Controller.cjs');
 const require_Route = require('./Route.cjs');
 const require_helpers = require('./core/helpers.cjs');
 const require_RouteGroup = require('./RouteGroup.cjs');
+const require_RouteRegistrar = require('./RouteRegistrar.cjs');
 const require_Request = require('./core/Request.cjs');
 const require_Response = require('./core/Response.cjs');
 const require_plugins = require('./core/plugins.cjs');
@@ -17,6 +18,8 @@ exports.Request = require_Request.Request;
 exports.Response = require_Response.Response;
 exports.Route = require_Route.Route;
 exports.RouteGroup = require_RouteGroup.RouteGroup;
+exports.RouteRegistrar = require_RouteRegistrar.RouteRegistrar;
 exports.definePlugin = require_plugins.definePlugin;
 exports.importFile = require_helpers.importFile;
+exports.parseDomainParameters = require_Route.parseDomainParameters;
 exports.wrap = require_helpers.wrap;

package/dist/index.d.cts

@@ -1,11 +1,12 @@
 import { ClearHttpContext, RouteParameter } from "./Contracts.cjs";
 import { Response } from "./core/Response.cjs";
 import { ClearRequest } from "./ClearRequest.cjs";
-import { Route } from "./Route.cjs";
+import { Route, parseDomainParameters } from "./Route.cjs";
 import { Request } from "./core/Request.cjs";
 import { ClearRouterPlugin, ClearRouterPluginArgumentsContext, ClearRouterPluginContext, ClearRouterPluginInput, ClearRouterPluginRequestContext, PluginArgumentsResolver, PluginBind, PluginBindFactory, PluginBindValue, PluginSetupResult, definePlugin } from "./core/plugins.cjs";
 import { Controller } from "./Controller.cjs";
 import { RouteGroup } from "./RouteGroup.cjs";
+import { RouteRegistrar, RouteRegistrarGroupFactory } from "./RouteRegistrar.cjs";
 import { CoreRouter } from "./core/CoreRouter.cjs";
 import { importFile, wrap } from "./core/helpers.cjs";
-export { ClearHttpContext, ClearRequest, ClearRouterPlugin, ClearRouterPluginArgumentsContext, ClearRouterPluginContext, ClearRouterPluginInput, ClearRouterPluginRequestContext, Controller, CoreRouter, PluginArgumentsResolver, PluginBind, PluginBindFactory, PluginBindValue, PluginSetupResult, Request, Response, Route, RouteGroup, RouteParameter, definePlugin, importFile, wrap };
+export { ClearHttpContext, ClearRequest, ClearRouterPlugin, ClearRouterPluginArgumentsContext, ClearRouterPluginContext, ClearRouterPluginInput, ClearRouterPluginRequestContext, Controller, CoreRouter, PluginArgumentsResolver, PluginBind, PluginBindFactory, PluginBindValue, PluginSetupResult, Request, Response, Route, RouteGroup, RouteParameter, RouteRegistrar, RouteRegistrarGroupFactory, definePlugin, importFile, parseDomainParameters, wrap };

package/dist/index.d.mts

@@ -1,11 +1,12 @@
 import { ClearHttpContext, RouteParameter } from "./Contracts.mjs";
 import { Response } from "./core/Response.mjs";
 import { ClearRequest } from "./ClearRequest.mjs";
-import { Route } from "./Route.mjs";
+import { Route, parseDomainParameters } from "./Route.mjs";
 import { Request } from "./core/Request.mjs";
 import { ClearRouterPlugin, ClearRouterPluginArgumentsContext, ClearRouterPluginContext, ClearRouterPluginInput, ClearRouterPluginRequestContext, PluginArgumentsResolver, PluginBind, PluginBindFactory, PluginBindValue, PluginSetupResult, definePlugin } from "./core/plugins.mjs";
 import { Controller } from "./Controller.mjs";
 import { RouteGroup } from "./RouteGroup.mjs";
+import { RouteRegistrar, RouteRegistrarGroupFactory } from "./RouteRegistrar.mjs";
 import { CoreRouter } from "./core/CoreRouter.mjs";
 import { importFile, wrap } from "./core/helpers.mjs";
-export { ClearHttpContext, ClearRequest, ClearRouterPlugin, ClearRouterPluginArgumentsContext, ClearRouterPluginContext, ClearRouterPluginInput, ClearRouterPluginRequestContext, Controller, CoreRouter, PluginArgumentsResolver, PluginBind, PluginBindFactory, PluginBindValue, PluginSetupResult, Request, Response, Route, RouteGroup, RouteParameter, definePlugin, importFile, wrap };
+export { ClearHttpContext, ClearRequest, ClearRouterPlugin, ClearRouterPluginArgumentsContext, ClearRouterPluginContext, ClearRouterPluginInput, ClearRouterPluginRequestContext, Controller, CoreRouter, PluginArgumentsResolver, PluginBind, PluginBindFactory, PluginBindValue, PluginSetupResult, Request, Response, Route, RouteGroup, RouteParameter, RouteRegistrar, RouteRegistrarGroupFactory, definePlugin, importFile, parseDomainParameters, wrap };

package/dist/index.mjs

@@ -1,12 +1,13 @@
 import { ClearRequest } from "./ClearRequest.mjs";
 import { Controller } from "./Controller.mjs";
-import { Route } from "./Route.mjs";
+import { Route, parseDomainParameters } from "./Route.mjs";
 import { importFile, wrap } from "./core/helpers.mjs";
 import { RouteGroup } from "./RouteGroup.mjs";
+import { RouteRegistrar } from "./RouteRegistrar.mjs";
 import { Request } from "./core/Request.mjs";
 import { Response } from "./core/Response.mjs";
 import { definePlugin } from "./core/plugins.mjs";
 import { CoreRouter } from "./core/CoreRouter.mjs";
 import "./core/index.mjs";
 
-export { ClearRequest, Controller, CoreRouter, Request, Response, Route, RouteGroup, definePlugin, importFile, wrap };
+export { ClearRequest, Controller, CoreRouter, Request, Response, Route, RouteGroup, RouteRegistrar, definePlugin, importFile, parseDomainParameters, wrap };

package/dist/koa/router.cjs

@@ -10,6 +10,9 @@ const require_responses = require('../core/responses.cjs');
 */
 var Router = class Router extends require_CoreRouter.CoreRouter {
 	static routerStateNamespace = "clear-router:koa";
+	static formatWildcardParam(name) {
+		return `*${name}`;
+	}
 	static bodyCache = /* @__PURE__ */ new WeakMap();
 	static async readBodyCached(ctx) {
 		if (this.bodyCache.has(ctx)) {
@@ -214,16 +217,19 @@ var Router = class Router extends require_CoreRouter.CoreRouter {
 				];
 				if (method === "options" && route.methods.length > 1) continue;
 				if (!allowedMethods.includes(method)) throw new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-				for (const registrationPath of route.registrationPaths) router[method](registrationPath, ...route.middlewares || [], async (context, next) => {
+				for (const registrationPath of this.resolveRegistrationPaths(route)) router[method](registrationPath, ...route.middlewares || [], async (context, next) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					const override = Router.resolveMethodOverride(ctx.method, ctx.headers, reqBody);
 					if (method === "post" && override && override !== "post") return next();
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, ctx.params ?? {});
+					if (params === false) return next();
+					Object.assign(ctx.params ??= {}, params);
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.query,
-						params: ctx.params ?? {},
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
@@ -235,15 +241,18 @@ var Router = class Router extends require_CoreRouter.CoreRouter {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) router.post(registrationPath, ...route.middlewares || [], async (context, next) => {
+				].includes(method)) for (const registrationPath of this.resolveRegistrationPaths(route)) router.post(registrationPath, ...route.middlewares || [], async (context, next) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					if (Router.resolveMethodOverride(ctx.method, ctx.headers, reqBody) !== method) return next();
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, ctx.params ?? {});
+					if (params === false) return next();
+					Object.assign(ctx.params ??= {}, params);
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.query,
-						params: ctx.params ?? {},
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);

package/dist/koa/router.d.cts

@@ -14,6 +14,7 @@ import { CoreRouter } from "../core/CoreRouter.cjs";
  */
 declare class Router extends CoreRouter {
   protected static routerStateNamespace: string;
+  protected static formatWildcardParam(name: string): string;
   private static readonly bodyCache;
   private static readBodyCached;
   private static readBody;

package/dist/koa/router.d.mts

@@ -14,6 +14,7 @@ import { CoreRouter } from "../core/CoreRouter.mjs";
  */
 declare class Router extends CoreRouter {
   protected static routerStateNamespace: string;
+  protected static formatWildcardParam(name: string): string;
   private static readonly bodyCache;
   private static readBodyCached;
   private static readBody;

package/dist/koa/router.mjs

@@ -10,6 +10,9 @@ import { isFetchResponse, resolveResponseMeta } from "../core/responses.mjs";
 */
 var Router = class Router extends CoreRouter {
 	static routerStateNamespace = "clear-router:koa";
+	static formatWildcardParam(name) {
+		return `*${name}`;
+	}
 	static bodyCache = /* @__PURE__ */ new WeakMap();
 	static async readBodyCached(ctx) {
 		if (this.bodyCache.has(ctx)) {
@@ -214,16 +217,19 @@ var Router = class Router extends CoreRouter {
 				];
 				if (method === "options" && route.methods.length > 1) continue;
 				if (!allowedMethods.includes(method)) throw new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-				for (const registrationPath of route.registrationPaths) router[method](registrationPath, ...route.middlewares || [], async (context, next) => {
+				for (const registrationPath of this.resolveRegistrationPaths(route)) router[method](registrationPath, ...route.middlewares || [], async (context, next) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					const override = Router.resolveMethodOverride(ctx.method, ctx.headers, reqBody);
 					if (method === "post" && override && override !== "post") return next();
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, ctx.params ?? {});
+					if (params === false) return next();
+					Object.assign(ctx.params ??= {}, params);
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.query,
-						params: ctx.params ?? {},
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
@@ -235,15 +241,18 @@ var Router = class Router extends CoreRouter {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) router.post(registrationPath, ...route.middlewares || [], async (context, next) => {
+				].includes(method)) for (const registrationPath of this.resolveRegistrationPaths(route)) router.post(registrationPath, ...route.middlewares || [], async (context, next) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					if (Router.resolveMethodOverride(ctx.method, ctx.headers, reqBody) !== method) return next();
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, ctx.params ?? {});
+					if (params === false) return next();
+					Object.assign(ctx.params ??= {}, params);
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.query,
-						params: ctx.params ?? {},
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);