clear-router 2.7.6 → 2.8.0

package/dist/h3/router.d.cts

@@ -0,0 +1,133 @@
+import { ApiResourceMiddleware, ControllerAction, HttpMethod } from "../types/basic.cjs";
+import { H3App, Handler, HttpContext, Middleware as Middleware$1 } from "../types/h3.cjs";
+import { Route } from "../Route.cjs";
+import { ResourceRoutes } from "../ResourceRoutes.cjs";
+import { CoreRouter } from "../core/router.cjs";
+import { H3 } from "h3";
+
+//#region src/h3/router.d.ts
+/**
+ * @class clear-router H3 Router
+ * @description Laravel-style routing system for Express.js and H3 with support for CommonJS, ESM, and TypeScript
+ * @author 3m1n3nc3
+ * @repository https://github.com/arkstack-tmp/clear-router
+ */
+declare class Router extends CoreRouter {
+  protected static routerStateNamespace: string;
+  private static readonly bodyCache;
+  private static toResponse;
+  private static readBodyCached;
+  /**
+   * 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$1[] | Middleware$1): Route<HttpContext, Middleware$1, 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$1>;
+  }): ResourceRoutes<HttpContext, Middleware$1, Handler>;
+  /**
+   * Adds a new GET route to the router with the specified path, handler, and optional middlewares.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static get(path: string, handler: Handler, middlewares?: Middleware$1[] | Middleware$1): Route<HttpContext, Middleware$1, Handler>;
+  /**
+   * Adds a new POST route to the router with the specified path, handler, and optional middlewares.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static post(path: string, handler: Handler, middlewares?: Middleware$1[] | Middleware$1): Route<HttpContext, Middleware$1, Handler>;
+  /**
+   * Adds a new PUT route to the router with the specified path, handler, and optional middlewares.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static put(path: string, handler: Handler, middlewares?: Middleware$1[] | Middleware$1): Route<HttpContext, Middleware$1, Handler>;
+  /**
+   * Adds a new DELETE route to the router with the specified path, handler, and optional middlewares.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static delete(path: string, handler: Handler, middlewares?: Middleware$1[] | Middleware$1): Route<HttpContext, Middleware$1, Handler>;
+  /**
+   * Adds a new PATCH route to the router with the specified path, handler, and optional middlewares.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static patch(path: string, handler: Handler, middlewares?: Middleware$1[] | Middleware$1): Route<HttpContext, Middleware$1, Handler>;
+  /**
+   * Adds a new OPTIONS route to the router with the specified path, handler, and optional middlewares.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static options(path: string, handler: Handler, middlewares?: Middleware$1[] | Middleware$1): Route<HttpContext, Middleware$1, Handler>;
+  /**
+   * Adds a new HEAD route to the router.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static head(path: string, handler: Handler, middlewares?: Middleware$1[] | Middleware$1): Route<HttpContext, Middleware$1, 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$1[]): Promise<void>;
+  /**
+   * Adds global middlewares to the router, which will be applied to all routes.
+   *
+   * @param middlewares
+   * @param callback
+   */
+  static middleware(middlewares: Middleware$1[], callback: () => void): void;
+  /**
+   * Retrieves all registered routes in the router, optionally organized by path or method
+   * for easier access and management.
+   *
+   * @param type
+   */
+  static allRoutes(): Array<Route<HttpContext, Middleware$1, Handler>>;
+  static allRoutes(type: 'path'): Record<string, Route<HttpContext, Middleware$1, Handler>>;
+  static allRoutes(type: 'method'): { [method in Uppercase<HttpMethod>]?: Array<Route<HttpContext, Middleware$1, Handler>> };
+  static allRoutes(type: 'name'): Record<string, Route<HttpContext, Middleware$1, Handler>>;
+  static route(name: string): Route<HttpContext, Middleware$1, Handler> | undefined;
+  /**
+   * Applies the registered routes to the given H3 application instance, setting up the
+   * necessary handlers and middlewares for each route.
+   *
+   * @param app
+   * @returns
+   */
+  static apply(app: H3): H3App;
+}
+//#endregion
+export { Router };

package/dist/h3/router.d.mts

@@ -0,0 +1,133 @@
+import { ApiResourceMiddleware, ControllerAction, HttpMethod } from "../types/basic.mjs";
+import { H3App, Handler, HttpContext, Middleware as Middleware$1 } from "../types/h3.mjs";
+import { Route } from "../Route.mjs";
+import { ResourceRoutes } from "../ResourceRoutes.mjs";
+import { CoreRouter } from "../core/router.mjs";
+import { H3 } from "h3";
+
+//#region src/h3/router.d.ts
+/**
+ * @class clear-router H3 Router
+ * @description Laravel-style routing system for Express.js and H3 with support for CommonJS, ESM, and TypeScript
+ * @author 3m1n3nc3
+ * @repository https://github.com/arkstack-tmp/clear-router
+ */
+declare class Router extends CoreRouter {
+  protected static routerStateNamespace: string;
+  private static readonly bodyCache;
+  private static toResponse;
+  private static readBodyCached;
+  /**
+   * 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$1[] | Middleware$1): Route<HttpContext, Middleware$1, 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$1>;
+  }): ResourceRoutes<HttpContext, Middleware$1, Handler>;
+  /**
+   * Adds a new GET route to the router with the specified path, handler, and optional middlewares.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static get(path: string, handler: Handler, middlewares?: Middleware$1[] | Middleware$1): Route<HttpContext, Middleware$1, Handler>;
+  /**
+   * Adds a new POST route to the router with the specified path, handler, and optional middlewares.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static post(path: string, handler: Handler, middlewares?: Middleware$1[] | Middleware$1): Route<HttpContext, Middleware$1, Handler>;
+  /**
+   * Adds a new PUT route to the router with the specified path, handler, and optional middlewares.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static put(path: string, handler: Handler, middlewares?: Middleware$1[] | Middleware$1): Route<HttpContext, Middleware$1, Handler>;
+  /**
+   * Adds a new DELETE route to the router with the specified path, handler, and optional middlewares.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static delete(path: string, handler: Handler, middlewares?: Middleware$1[] | Middleware$1): Route<HttpContext, Middleware$1, Handler>;
+  /**
+   * Adds a new PATCH route to the router with the specified path, handler, and optional middlewares.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static patch(path: string, handler: Handler, middlewares?: Middleware$1[] | Middleware$1): Route<HttpContext, Middleware$1, Handler>;
+  /**
+   * Adds a new OPTIONS route to the router with the specified path, handler, and optional middlewares.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static options(path: string, handler: Handler, middlewares?: Middleware$1[] | Middleware$1): Route<HttpContext, Middleware$1, Handler>;
+  /**
+   * Adds a new HEAD route to the router.
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static head(path: string, handler: Handler, middlewares?: Middleware$1[] | Middleware$1): Route<HttpContext, Middleware$1, 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$1[]): Promise<void>;
+  /**
+   * Adds global middlewares to the router, which will be applied to all routes.
+   *
+   * @param middlewares
+   * @param callback
+   */
+  static middleware(middlewares: Middleware$1[], callback: () => void): void;
+  /**
+   * Retrieves all registered routes in the router, optionally organized by path or method
+   * for easier access and management.
+   *
+   * @param type
+   */
+  static allRoutes(): Array<Route<HttpContext, Middleware$1, Handler>>;
+  static allRoutes(type: 'path'): Record<string, Route<HttpContext, Middleware$1, Handler>>;
+  static allRoutes(type: 'method'): { [method in Uppercase<HttpMethod>]?: Array<Route<HttpContext, Middleware$1, Handler>> };
+  static allRoutes(type: 'name'): Record<string, Route<HttpContext, Middleware$1, Handler>>;
+  static route(name: string): Route<HttpContext, Middleware$1, Handler> | undefined;
+  /**
+   * Applies the registered routes to the given H3 application instance, setting up the
+   * necessary handlers and middlewares for each route.
+   *
+   * @param app
+   * @returns
+   */
+  static apply(app: H3): H3App;
+}
+//#endregion
+export { Router };

package/dist/h3/router.mjs

@@ -0,0 +1,260 @@
+import { CoreRouter } from "../core/router.mjs";
+import { resolveResponseMeta } from "../core/responses.mjs";
+import { HTTPResponse, getQuery, getRouterParams, readBody } from "h3";
+
+//#region src/h3/router.ts
+/**
+* @class clear-router H3 Router
+* @description Laravel-style routing system for Express.js and H3 with support for CommonJS, ESM, and TypeScript
+* @author 3m1n3nc3
+* @repository https://github.com/arkstack-tmp/clear-router
+*/
+var Router = class Router extends CoreRouter {
+	static routerStateNamespace = "clear-router:h3";
+	static bodyCache = /* @__PURE__ */ new WeakMap();
+	static toResponse(ctx, value, method, path) {
+		const meta = resolveResponseMeta(value, {
+			headers: ctx.req.headers,
+			method,
+			path,
+			status: typeof ctx.res.status === "number" && ctx.res.status !== 200 ? ctx.res.status : void 0
+		});
+		if (!meta) return void 0;
+		if (meta.isNativeResponse) return meta.body;
+		const headers = meta.headers ? {} : meta.contentType ? { "Content-Type": meta.contentType } : void 0;
+		meta.headers?.forEach((headerValue, key) => {
+			if (headers) headers[key] = headerValue;
+		});
+		return new HTTPResponse(meta.contentType?.startsWith("application/json") ? JSON.stringify(meta.body) : meta.isEmpty ? null : meta.body, {
+			status: meta.status,
+			headers
+		});
+	}
+	static async readBodyCached(ctx) {
+		if (this.bodyCache.has(ctx)) {
+			const cached = this.bodyCache.get(ctx);
+			ctx.req.getBody = () => cached;
+			return cached;
+		}
+		let body = {};
+		if (ctx.req.headers.get("content-type")?.includes("multipart/form-data")) (await ctx.req.formData()).forEach((value, key) => {
+			body[key] = value;
+		});
+		else body = await readBody(ctx) ?? {};
+		ctx.req.getBody = () => body;
+		this.bodyCache.set(ctx, body);
+		return 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 with the specified path, handler, and optional middlewares.
+	* 
+	* @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 with the specified path, handler, and optional middlewares.
+	* 
+	* @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 with the specified path, handler, and optional middlewares.
+	* 
+	* @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 with the specified path, handler, and optional middlewares.
+	* 
+	* @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 with the specified path, handler, and optional middlewares.
+	* 
+	* @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 with the specified path, handler, and optional middlewares.
+	* 
+	* @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);
+	}
+	/**
+	* Applies the registered routes to the given H3 application instance, setting up the 
+	* necessary handlers and middlewares for each route.
+	* 
+	* @param app 
+	* @returns 
+	*/
+	static apply(app) {
+		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) 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;
+						Router.bindRequestToInstance(ctx, inst, route, {
+							body: reqBody,
+							query: getQuery(ctx),
+							params: getRouterParams(ctx, { decode: true }),
+							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.toResponse(ctx, outgoing, method, route.path);
+					} catch (error) {
+						return error;
+					}
+				}, { middleware: route.middlewares });
+				if ([
+					"put",
+					"patch",
+					"delete"
+				].includes(method)) for (const registrationPath of route.registrationPaths) 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;
+						Router.bindRequestToInstance(ctx, inst, route, {
+							body: reqBody,
+							query: getQuery(ctx),
+							params: getRouterParams(ctx, { decode: true }),
+							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.toResponse(ctx, outgoing, method, route.path);
+					} catch (error) {
+						return error;
+					}
+				}, { middleware: route.middlewares });
+			}
+		}
+		return app;
+	}
+};
+
+//#endregion
+export { Router as default };