clear-router 2.1.12 → 2.3.0

package/dist/hono/index.cjs

@@ -0,0 +1,227 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_router = require('../router-Ba2MVNn-.cjs');
+
+//#region src/hono/router.ts
+/**
+* @class clear-router Hono Router
+* @description Laravel-style routing system for Hono using shared clear-router core
+* @author 3m1n3nc3
+* @repository https://github.com/toneflix/clear-router
+*/
+var Router = class Router extends require_router.CoreRouter {
+	static bodyCache = /* @__PURE__ */ new WeakMap();
+	static toResponse(ctx, value) {
+		if (value instanceof Response) return value;
+		if (typeof value === "undefined") return void 0;
+		if (value === null) return ctx.body(null);
+		if (typeof value === "string") return ctx.text(value);
+		if (typeof value === "object") return ctx.json(value);
+		return ctx.text(String(value));
+	}
+	static getParams(ctx) {
+		try {
+			const raw = ctx.req.param?.();
+			return raw && typeof raw === "object" ? raw : {};
+		} catch {
+			return {};
+		}
+	}
+	static async readBodyCached(ctx) {
+		if (this.bodyCache.has(ctx)) {
+			const cached = this.bodyCache.get(ctx) || {};
+			ctx.req.getBody = () => cached;
+			return cached;
+		}
+		let body = {};
+		const contentType = (ctx.req.header("content-type") || "").toLowerCase();
+		if (contentType.includes("application/json")) body = await ctx.req.json().catch(() => ({}));
+		else if (contentType.includes("multipart/form-data") || contentType.includes("application/x-www-form-urlencoded")) body = await ctx.req.parseBody().then((v) => v).catch(() => ({}));
+		ctx.req.getBody = () => body;
+		this.bodyCache.set(ctx, body);
+		return body;
+	}
+	/**
+	* Resolve method override from query, headers, or body
+	* 
+	* @param methods 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static add(methods, path, handler, middlewares) {
+		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) {
+		super.apiResource(basePath, controller, options);
+	}
+	/**
+	* Define a GET route
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static get(path, handler, middlewares) {
+		super.get(path, handler, middlewares);
+	}
+	/**
+	* Define a POST route
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static post(path, handler, middlewares) {
+		super.post(path, handler, middlewares);
+	}
+	/**
+	* Define a PUT route
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static put(path, handler, middlewares) {
+		super.put(path, handler, middlewares);
+	}
+	/**
+	* Define a DELETE route
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static delete(path, handler, middlewares) {
+		super.delete(path, handler, middlewares);
+	}
+	/**
+	* Define a PATCH route 
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static patch(path, handler, middlewares) {
+		super.patch(path, handler, middlewares);
+	}
+	/**
+	* Define an OPTIONS route
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static options(path, handler, middlewares) {
+		super.options(path, handler, middlewares);
+	}
+	/**
+	* Define a HEAD route
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static head(path, handler, middlewares) {
+		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  - Middleware or array of middlewares to apply
+	* @param callback     - Function that defines the routes to which the middlewares will be applied
+	*/
+	static middleware(middlewares, callback) {
+		super.middleware(middlewares, callback);
+	}
+	static allRoutes(type) {
+		return super.allRoutes(type);
+	}
+	/**
+	* Apply the defined routes to a Hono application instance
+	* 
+	* @param app  The Hono application instance
+	* @returns    The Hono application instance with the applied routes
+	*/
+	static apply(app) {
+		for (const route of this.routes) {
+			let handlerFunction = null;
+			let instance = null;
+			try {
+				const resolved = this.resolveHandler(route);
+				handlerFunction = resolved.handlerFunction;
+				instance = resolved.instance;
+			} 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}`);
+				app[method](route.path, ...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;
+					Router.bindRequestToInstance(ctx, inst, route, {
+						body: reqBody,
+						query: ctx.req.query(),
+						params: Router.getParams(ctx)
+					});
+					const result = handlerFunction(ctx, inst.clearRequest);
+					const resolved = await Promise.resolve(result);
+					return Router.toResponse(ctx, resolved);
+				});
+				if ([
+					"put",
+					"patch",
+					"delete"
+				].includes(method)) app.post(route.path, ...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;
+					Router.bindRequestToInstance(ctx, inst, route, {
+						body: reqBody,
+						query: ctx.req.query(),
+						params: Router.getParams(ctx)
+					});
+					const result = handlerFunction(ctx, inst.clearRequest);
+					const resolved = await Promise.resolve(result);
+					return Router.toResponse(ctx, resolved);
+				});
+			}
+		}
+		return app;
+	}
+};
+
+//#endregion
+exports.Router = Router;

package/dist/hono/index.d.cts

@@ -0,0 +1,141 @@
+import { d as ApiResourceMiddleware, f as ControllerAction, m as HttpMethod, n as ClearRequest, p as ControllerHandler, r as Route, t as CoreRouter } from "../router-DLmimm_U.cjs";
+import { Context, HonoRequest, MiddlewareHandler } from "hono";
+
+//#region types/hono.d.ts
+type RequestWithGetBody = HonoRequest & {
+  getBody: () => Record<string, any>;
+};
+type HttpContext = Context & {
+  req: RequestWithGetBody;
+};
+type RouteHandler = (ctx: HttpContext, req: ClearRequest) => any | Promise<any>;
+type Handler = RouteHandler | ControllerHandler;
+type Middleware = MiddlewareHandler;
+type HonoApp = { [K in 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head']: (path: string, ...handlers: Middleware[]) => any };
+//#endregion
+//#region src/hono/router.d.ts
+/**
+ * @class clear-router Hono Router
+ * @description Laravel-style routing system for Hono using shared clear-router core
+ * @author 3m1n3nc3
+ * @repository https://github.com/toneflix/clear-router
+ */
+declare class Router extends CoreRouter {
+  private static readonly bodyCache;
+  private static toResponse;
+  private static getParams;
+  private static readBodyCached;
+  /**
+   * Resolve method override from query, headers, or body
+   *
+   * @param methods
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static add(methods: HttpMethod | HttpMethod[], path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * 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>;
+  }): void;
+  /**
+   * Define a GET route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static get(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * Define a POST route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static post(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * Define a PUT route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static put(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * Define a DELETE route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static delete(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * Define a PATCH route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static patch(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * Define an OPTIONS route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static options(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * Define a HEAD route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static head(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * Define a group of routes with a common prefix and optional middlewares
+   *
+   * @param prefix
+   * @param callback
+   * @param middlewares
+   */
+  static group(prefix: string, callback: () => void | Promise<void>, middlewares?: Middleware[]): Promise<void>;
+  /**
+   * Apply middlewares to a group of routes defined within the callback
+   *
+   * @param middlewares  - Middleware or array of middlewares to apply
+   * @param callback     - Function that defines the routes to which the middlewares will be applied
+   */
+  static middleware(middlewares: Middleware[], callback: () => void): void;
+  /**
+   * Get all defined routes, optionally organized by path or method
+   */
+  static allRoutes(): Array<Route<HttpContext, Middleware, Handler>>;
+  /**
+   * @param type  - 'path' to get routes organized by path
+   */
+  static allRoutes(type: 'path'): Record<string, Route<HttpContext, Middleware, Handler>>;
+  /**
+   * @param type  - 'method' to get routes organized by method
+   */
+  static allRoutes(type: 'method'): { [method in Uppercase<HttpMethod>]?: Array<Route<HttpContext, Middleware, Handler>> };
+  /**
+   * Apply the defined routes to a Hono application instance
+   *
+   * @param app  The Hono application instance
+   * @returns    The Hono application instance with the applied routes
+   */
+  static apply(app: HonoApp): HonoApp;
+}
+//#endregion
+export { Router };

package/dist/hono/index.d.mts

@@ -0,0 +1,141 @@
+import { d as ApiResourceMiddleware, f as ControllerAction, m as HttpMethod, n as ClearRequest, p as ControllerHandler, r as Route, t as CoreRouter } from "../router-cWYmcfTX.mjs";
+import { Context, HonoRequest, MiddlewareHandler } from "hono";
+
+//#region types/hono.d.ts
+type RequestWithGetBody = HonoRequest & {
+  getBody: () => Record<string, any>;
+};
+type HttpContext = Context & {
+  req: RequestWithGetBody;
+};
+type RouteHandler = (ctx: HttpContext, req: ClearRequest) => any | Promise<any>;
+type Handler = RouteHandler | ControllerHandler;
+type Middleware = MiddlewareHandler;
+type HonoApp = { [K in 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head']: (path: string, ...handlers: Middleware[]) => any };
+//#endregion
+//#region src/hono/router.d.ts
+/**
+ * @class clear-router Hono Router
+ * @description Laravel-style routing system for Hono using shared clear-router core
+ * @author 3m1n3nc3
+ * @repository https://github.com/toneflix/clear-router
+ */
+declare class Router extends CoreRouter {
+  private static readonly bodyCache;
+  private static toResponse;
+  private static getParams;
+  private static readBodyCached;
+  /**
+   * Resolve method override from query, headers, or body
+   *
+   * @param methods
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static add(methods: HttpMethod | HttpMethod[], path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * 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>;
+  }): void;
+  /**
+   * Define a GET route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static get(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * Define a POST route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static post(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * Define a PUT route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static put(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * Define a DELETE route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static delete(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * Define a PATCH route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static patch(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * Define an OPTIONS route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static options(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * Define a HEAD route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static head(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
+  /**
+   * Define a group of routes with a common prefix and optional middlewares
+   *
+   * @param prefix
+   * @param callback
+   * @param middlewares
+   */
+  static group(prefix: string, callback: () => void | Promise<void>, middlewares?: Middleware[]): Promise<void>;
+  /**
+   * Apply middlewares to a group of routes defined within the callback
+   *
+   * @param middlewares  - Middleware or array of middlewares to apply
+   * @param callback     - Function that defines the routes to which the middlewares will be applied
+   */
+  static middleware(middlewares: Middleware[], callback: () => void): void;
+  /**
+   * Get all defined routes, optionally organized by path or method
+   */
+  static allRoutes(): Array<Route<HttpContext, Middleware, Handler>>;
+  /**
+   * @param type  - 'path' to get routes organized by path
+   */
+  static allRoutes(type: 'path'): Record<string, Route<HttpContext, Middleware, Handler>>;
+  /**
+   * @param type  - 'method' to get routes organized by method
+   */
+  static allRoutes(type: 'method'): { [method in Uppercase<HttpMethod>]?: Array<Route<HttpContext, Middleware, Handler>> };
+  /**
+   * Apply the defined routes to a Hono application instance
+   *
+   * @param app  The Hono application instance
+   * @returns    The Hono application instance with the applied routes
+   */
+  static apply(app: HonoApp): HonoApp;
+}
+//#endregion
+export { Router };