clear-router 2.7.6 → 2.8.0

package/dist/express/router.d.mts

@@ -0,0 +1,132 @@
+import { ApiResourceMiddleware, ControllerAction, HttpMethod } from "../types/basic.mjs";
+import { Handler, HttpContext, Middleware } from "../types/express.mjs";
+import { Route } from "../Route.mjs";
+import { ResourceRoutes } from "../ResourceRoutes.mjs";
+import { CoreRouter } from "../core/router.mjs";
+import { Router } from "express";
+
+//#region src/express/router.d.ts
+/**
+ * @class clear-router Express Router
+ * @description Laravel-style routing system for Express.js and H3 with support for CommonJS, ESM, and TypeScript
+ * @author Refkinscallv
+ * @author 3m1n3nc3
+ * @repository https://github.com/arkstack-tmp/clear-router
+ */
+declare class Router$1 extends CoreRouter {
+  protected static routerStateNamespace: string;
+  private static ensureRequestBodyAccessor;
+  private static sendReturnValue;
+  /**
+   * Adds a new route to the router.
+   *
+   * @param methods
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static add(methods: HttpMethod | HttpMethod[], path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Define a resourceful API controller with standard CRUD routes
+   *
+   * @param basePath
+   * @param controller
+   * @param options
+   */
+  static apiResource(basePath: string, controller: any, options?: {
+    only?: ControllerAction[];
+    except?: ControllerAction[];
+    middlewares?: ApiResourceMiddleware<Middleware>;
+  }): ResourceRoutes<HttpContext, Middleware, Handler>;
+  /**
+   * Adds a new GET route to the router.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static get(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Adds a new POST route to the router.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static post(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Adds a new PUT route to the router.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static put(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Adds a new DELETE route to the router.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static delete(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Adds a new PATCH route to the router.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static patch(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Adds a new OPTIONS route to the router.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static options(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Adds a new HEAD route to the router.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static head(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Defines a group of routes with a common prefix.
+   *
+   * @param prefix
+   * @param callback
+   * @param middlewares
+   */
+  static group(prefix: string, callback: () => void | Promise<void>, middlewares?: Middleware[]): Promise<void>;
+  /**
+   * Adds global middlewares to the router, which will be applied to all routes.
+   *
+   * @param middlewares
+   * @param callback
+   */
+  static middleware(middlewares: Middleware[], callback: () => void): void;
+  /**
+   * Retrieves all registered routes in the router, optionally organized by path or method.
+   *
+   * @param type
+   */
+  static allRoutes(): Array<Route<HttpContext, Middleware, Handler>>;
+  static allRoutes(type: 'path'): Record<string, Route<HttpContext, Middleware, Handler>>;
+  static allRoutes(type: 'method'): { [method in Uppercase<HttpMethod>]?: Array<Route<HttpContext, Middleware, Handler>> };
+  static allRoutes(type: 'name'): Record<string, Route<HttpContext, Middleware, Handler>>;
+  static route(name: string): Route<HttpContext, Middleware, Handler> | undefined;
+  /**
+   * Applies the registered routes to the given Express router instance, setting up the necessary
+   * handlers and middlewares for each route.
+   *
+   * @param router
+   */
+  static apply(router: Router): void;
+  static apply(router: Router): Promise<void>;
+}
+//#endregion
+export { Router$1 as Router };

package/dist/express/router.mjs

@@ -0,0 +1,265 @@
+import { CoreRouter } from "../core/router.mjs";
+import { isFetchResponse, resolveResponseMeta, responseWasSent } from "../core/responses.mjs";
+
+//#region src/express/router.ts
+/**
+* @class clear-router Express Router
+* @description Laravel-style routing system for Express.js and H3 with support for CommonJS, ESM, and TypeScript
+* @author Refkinscallv
+* @author 3m1n3nc3
+* @repository https://github.com/arkstack-tmp/clear-router
+*/
+var Router = class Router extends CoreRouter {
+	static routerStateNamespace = "clear-router:express";
+	static ensureRequestBodyAccessor(req) {
+		if (typeof req.getBody !== "function") req.getBody = () => req.body ?? {};
+	}
+	static async sendReturnValue(ctx, value, method, path) {
+		const { req, res } = ctx;
+		if (responseWasSent(res) || value === res || responseWasSent(value)) return;
+		const meta = resolveResponseMeta(value, {
+			headers: req.headers,
+			method,
+			path
+		});
+		if (!meta) return;
+		res.status(meta.status);
+		meta.headers?.forEach((headerValue, key) => {
+			res.setHeader(key, headerValue);
+		});
+		if (isFetchResponse(meta.body)) {
+			meta.body.headers.forEach((headerValue, key) => {
+				res.setHeader(key, headerValue);
+			});
+			res.status(meta.body.status);
+			const body = Buffer.from(await meta.body.arrayBuffer());
+			res.send(body);
+			return;
+		}
+		if (meta.contentType && !res.getHeader("Content-Type")) res.setHeader("Content-Type", meta.contentType);
+		if (meta.isEmpty) {
+			res.sendStatus(meta.status);
+			return;
+		}
+		res.send(meta.body);
+	}
+	/**
+	* Adds a new route to the router.
+	* 
+	* @param methods 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static add(methods, path, handler, middlewares) {
+		return super.add(methods, path, handler, middlewares);
+	}
+	/**
+	* Define a resourceful API controller with standard CRUD routes
+	* 
+	* @param basePath 
+	* @param controller 
+	* @param options 
+	*/
+	static apiResource(basePath, controller, options) {
+		return super.apiResource(basePath, controller, options);
+	}
+	/**
+	* Adds a new GET route to the router.
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static get(path, handler, middlewares) {
+		return super.get(path, handler, middlewares);
+	}
+	/**
+	* Adds a new POST route to the router.
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static post(path, handler, middlewares) {
+		return super.post(path, handler, middlewares);
+	}
+	/**
+	* Adds a new PUT route to the router.
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static put(path, handler, middlewares) {
+		return super.put(path, handler, middlewares);
+	}
+	/**
+	* Adds a new DELETE route to the router.
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static delete(path, handler, middlewares) {
+		return super.delete(path, handler, middlewares);
+	}
+	/**
+	* Adds a new PATCH route to the router.
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static patch(path, handler, middlewares) {
+		return super.patch(path, handler, middlewares);
+	}
+	/**
+	* Adds a new OPTIONS route to the router.
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static options(path, handler, middlewares) {
+		return super.options(path, handler, middlewares);
+	}
+	/**
+	* Adds a new HEAD route to the router.
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static head(path, handler, middlewares) {
+		return super.head(path, handler, middlewares);
+	}
+	/**
+	* Defines a group of routes with a common prefix.
+	* 
+	* @param prefix 
+	* @param callback 
+	* @param middlewares 
+	*/
+	static async group(prefix, callback, middlewares) {
+		await super.group(prefix, callback, middlewares);
+	}
+	/**
+	* Adds global middlewares to the router, which will be applied to all routes.
+	* 
+	* @param middlewares 
+	* @param callback 
+	*/
+	static middleware(middlewares, callback) {
+		super.middleware(middlewares, callback);
+	}
+	static allRoutes(type) {
+		return super.allRoutes(type);
+	}
+	static route(name) {
+		return super.route(name);
+	}
+	static async apply(router) {
+		for (const route of this.orderedRoutes()) {
+			let handlerFunction = null;
+			let instance = null;
+			let bindingTarget;
+			let bindingMethod;
+			let bindingHandler;
+			let bindingMetadata;
+			try {
+				const resolved = this.resolveHandler(route);
+				handlerFunction = resolved.handlerFunction;
+				instance = resolved.instance;
+				bindingTarget = resolved.bindingTarget;
+				bindingMethod = resolved.bindingMethod;
+				bindingHandler = resolved.bindingHandler;
+				bindingMetadata = resolved.bindingMetadata;
+			} catch (error) {
+				console.error(`[ROUTES] Error setting up route ${route.path}:`, error.message);
+				throw error;
+			}
+			if (!handlerFunction) continue;
+			for (const method of route.methods) {
+				const allowedMethods = [
+					"get",
+					"post",
+					"put",
+					"delete",
+					"patch",
+					"options",
+					"head"
+				];
+				if (method === "options" && route.methods.length > 1) continue;
+				if (!allowedMethods.includes(method)) {
+					const error = /* @__PURE__ */ new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
+					console.error("[ROUTES]", error.message);
+					throw error;
+				}
+				for (const registrationPath of route.registrationPaths) 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");
+					return next();
+				}, ...route.middlewares || [], async (req, res, next) => {
+					try {
+						Router.ensureRequestBodyAccessor(req);
+						const ctx = {
+							req,
+							res,
+							next
+						};
+						const inst = instance ?? route;
+						Router.bindRequestToInstance(ctx, inst, route, {
+							body: ctx.req.getBody(),
+							query: ctx.req.query,
+							params: ctx.req.params,
+							method
+						});
+						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
+						const resolved = await Promise.resolve(result);
+						const outgoing = typeof resolved === "undefined" && ctx.clearResponse?.sent ? ctx.clearResponse : resolved;
+						await Router.sendReturnValue(ctx, outgoing, method, route.path);
+					} catch (error) {
+						next(error);
+					}
+				});
+				if ([
+					"put",
+					"patch",
+					"delete"
+				].includes(method)) for (const registrationPath of route.registrationPaths) 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();
+					return next();
+				}, ...route.middlewares || [], async (req, res, next) => {
+					try {
+						Router.ensureRequestBodyAccessor(req);
+						const ctx = {
+							req,
+							res,
+							next
+						};
+						const inst = instance ?? route;
+						Router.bindRequestToInstance(ctx, inst, route, {
+							body: ctx.req.getBody(),
+							query: ctx.req.query,
+							params: ctx.req.params,
+							method
+						});
+						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
+						const resolved = await Promise.resolve(result);
+						const outgoing = typeof resolved === "undefined" && ctx.clearResponse?.sent ? ctx.clearResponse : resolved;
+						await Router.sendReturnValue(ctx, outgoing, method, route.path);
+					} catch (error) {
+						next(error);
+					}
+				});
+			}
+		}
+	}
+};
+
+//#endregion
+export { Router as default };

package/dist/fastify/index.cjs

@@ -1,256 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-require('../bindings-CLsZjOEy.cjs');
-const require_router = require('../router-C6W-k6sS.cjs');
-const require_responses = require('../responses-Bvnk0uvc.cjs');
+const require_router = require('./router.cjs');
 
-//#region src/fastify/router.ts
-/**
-* @class clear-router Fastify Router
-* @description Laravel-style routing system for Fastify using shared clear-router core
-* @author 3m1n3nc3
-* @repository https://github.com/arkstack-tmp/clear-router
-*/
-var Router = class Router extends require_router.CoreRouter {
-	static routerStateNamespace = "clear-router:fastify";
-	static ensureRequestBodyAccessor(req) {
-		if (typeof req.getBody !== "function") req.getBody = () => req.body ?? {};
-	}
-	static async sendReturnValue(req, reply, value, method, path) {
-		if (require_responses.responseWasSent(reply) || value === reply || require_responses.responseWasSent(value)) return value;
-		const meta = require_responses.resolveResponseMeta(value, {
-			headers: req.headers,
-			method,
-			path
-		});
-		if (!meta) return void 0;
-		reply.code(meta.status);
-		meta.headers?.forEach((headerValue, key) => {
-			reply.header(key, headerValue);
-		});
-		if (require_responses.isFetchResponse(meta.body)) {
-			meta.body.headers.forEach((headerValue, key) => {
-				reply.header(key, headerValue);
-			});
-			reply.code(meta.body.status);
-			return reply.send(Buffer.from(await meta.body.arrayBuffer()));
-		}
-		if (meta.contentType) reply.type(meta.contentType);
-		if (meta.isEmpty) return reply.send();
-		return reply.send(meta.body);
-	}
-	/**
-	* Add a route to the router
-	* 
-	* @param methods       HTTP methods for the route
-	* @param path          Route path
-	* @param handler       Route handler function
-	* @param middlewares   Optional middlewares for the route
-	*/
-	static add(methods, path, handler, middlewares) {
-		return super.add(methods, path, handler, middlewares);
-	}
-	/**
-	* Define a resourceful API controller with standard CRUD routes
-	* 
-	* @param basePath     Base path for the resource
-	* @param controller   Controller class or instance
-	* @param options      Optional configuration for the resource
-	*/
-	static apiResource(basePath, controller, options) {
-		super.apiResource(basePath, controller, options);
-	}
-	/**
-	* Define a GET route
-	* 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static get(path, handler, middlewares) {
-		return super.get(path, handler, middlewares);
-	}
-	/**
-	* Define a POST route
-	* 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static post(path, handler, middlewares) {
-		return super.post(path, handler, middlewares);
-	}
-	/**
-	* Define a PUT route
-	* 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static put(path, handler, middlewares) {
-		return super.put(path, handler, middlewares);
-	}
-	/**
-	* Define a DELETE route
-	* 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static delete(path, handler, middlewares) {
-		return super.delete(path, handler, middlewares);
-	}
-	/**
-	* Define a PATCH route
-	* 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static patch(path, handler, middlewares) {
-		return super.patch(path, handler, middlewares);
-	}
-	/**
-	* Define an OPTIONS route
-	* 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static options(path, handler, middlewares) {
-		return super.options(path, handler, middlewares);
-	}
-	/**
-	* Define a HEAD route
-	* 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static head(path, handler, middlewares) {
-		return super.head(path, handler, middlewares);
-	}
-	/**
-	* Define a group of routes with a common prefix and optional middlewares
-	* 
-	* @param prefix 
-	* @param callback 
-	* @param middlewares 
-	*/
-	static async group(prefix, callback, middlewares) {
-		await super.group(prefix, callback, middlewares);
-	}
-	/**
-	* Apply middlewares to a group of routes defined within the callback
-	* 
-	* @param middlewares 
-	* @param callback 
-	*/
-	static middleware(middlewares, callback) {
-		super.middleware(middlewares, callback);
-	}
-	static allRoutes(type) {
-		return super.allRoutes(type);
-	}
-	static route(name) {
-		return super.route(name);
-	}
-	/**
-	* Apply the defined routes to a Fastify application instance
-	* 
-	* @param app  - The Fastify application instance
-	* @returns    The Fastify application instance with the applied routes
-	*/
-	static apply(app) {
-		for (const route of Array.from(this.routes)) {
-			let handlerFunction = null;
-			let instance = null;
-			let bindingTarget;
-			let bindingMethod;
-			let bindingHandler;
-			let bindingMetadata;
-			try {
-				const resolved = this.resolveHandler(route);
-				handlerFunction = resolved.handlerFunction;
-				instance = resolved.instance;
-				bindingTarget = resolved.bindingTarget;
-				bindingMethod = resolved.bindingMethod;
-				bindingHandler = resolved.bindingHandler;
-				bindingMetadata = resolved.bindingMetadata;
-			} catch (error) {
-				console.error(`[ROUTES] Error setting up route ${route.path}:`, error.message);
-				throw error;
-			}
-			if (!handlerFunction) continue;
-			for (const method of route.methods) {
-				const allowedMethods = [
-					"get",
-					"post",
-					"put",
-					"delete",
-					"patch",
-					"options",
-					"head"
-				];
-				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({
-					method: method.toUpperCase(),
-					url: registrationPath,
-					preHandler: route.middlewares,
-					handler: async (req, reply) => {
-						Router.ensureRequestBodyAccessor(req);
-						const override = Router.resolveMethodOverride(req.method, req.headers, req.body);
-						if (method === "post" && override && override !== "post") return reply.code(404).send();
-						const ctx = {
-							req,
-							reply
-						};
-						const inst = instance ?? route;
-						Router.bindRequestToInstance(ctx, inst, route, {
-							body: ctx.req.getBody(),
-							query: ctx.req.query ?? {},
-							params: ctx.req.params ?? {},
-							method
-						});
-						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
-						const resolved = await Promise.resolve(result);
-						const outgoing = typeof resolved === "undefined" && ctx.clearResponse?.sent ? ctx.clearResponse : resolved;
-						return Router.sendReturnValue(req, reply, outgoing, method, route.path);
-					}
-				});
-				if ([
-					"put",
-					"patch",
-					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) app.route({
-					method: "POST",
-					url: registrationPath,
-					preHandler: route.middlewares,
-					handler: async (req, reply) => {
-						Router.ensureRequestBodyAccessor(req);
-						if (Router.resolveMethodOverride(req.method, req.headers, req.body) !== method) return reply.code(404).send();
-						const ctx = {
-							req,
-							reply
-						};
-						const inst = instance ?? route;
-						Router.bindRequestToInstance(ctx, inst, route, {
-							body: ctx.req.getBody(),
-							query: ctx.req.query ?? {},
-							params: ctx.req.params ?? {},
-							method
-						});
-						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
-						const resolved = await Promise.resolve(result);
-						const outgoing = typeof resolved === "undefined" && ctx.clearResponse?.sent ? ctx.clearResponse : resolved;
-						return Router.sendReturnValue(req, reply, outgoing, method, route.path);
-					}
-				});
-			}
-		}
-		return app;
-	}
-};
-
-//#endregion
-exports.Router = Router;
+exports.Router = require_router;