clear-router 2.7.7 → 2.8.1

package/dist/{Request-BhTJDR_5.d.mts → Request-Ci0UQ-Vl.d.mts}

@@ -40,6 +40,12 @@ declare class Response {
 }
 //#endregion
 //#region src/Route.d.ts
+/**
+ * @class clear-router Route
+ * @description A route describes a single enpoint on clear-router
+ * @author 3m1n3nc3
+ * @repository https://github.com/arkstack-tmp/clear-router
+ */
 declare class Route<X = any, M = Middleware$1 | Middleware$4, H = any> {
   ctx: X;
   body: RequestData;
@@ -61,9 +67,30 @@ declare class Route<X = any, M = Middleware$1 | Middleware$4, H = any> {
     registrationPaths?: string[];
     parameters?: RouteParameter[];
     onName?: (name: string, route: Route<X, M, H>, previousName?: string) => void;
+    normalizeMiddleware?: (middleware: M) => M;
   });
   private onName?;
+  private normalizeMiddleware?;
+  /**
+   * Set the route name
+   *
+   * @param name
+   * @returns
+   */
   name(name: string): this;
+  /**
+   * Register one or more middleware that will be executed before the route.
+   *
+   * @param middlewares
+   * @returns
+   */
+  middleware(middlewares: M[] | M): this;
+  /**
+   * Get the path generated and accessible by this route
+   *
+   * @param params
+   * @returns
+   */
   toPath(params?: RequestData): string;
 }
 //#endregion

package/dist/ResourceRouteSelection.cjs

@@ -0,0 +1,26 @@
+
+//#region src/ResourceRouteSelection.ts
+var ResourceRouteSelection = class {
+	constructor(routes) {
+		this.routes = routes;
+	}
+	/**
+	* Register one or more middleware that will be executed before the route.
+	* 
+	* @param middlewares 
+	* @returns 
+	*/
+	middleware(middlewares) {
+		for (const route of this.routes) route.middleware(middlewares);
+		return this;
+	}
+	all() {
+		return this.routes;
+	}
+	first() {
+		return this.routes[0];
+	}
+};
+
+//#endregion
+exports.ResourceRouteSelection = ResourceRouteSelection;

package/dist/ResourceRouteSelection.d.cts

@@ -0,0 +1,20 @@
+import { Middleware } from "./types/express.cjs";
+import { Middleware as Middleware$1 } from "./types/h3.cjs";
+import { Route } from "./Route.cjs";
+
+//#region src/ResourceRouteSelection.d.ts
+declare class ResourceRouteSelection<X = any, M = Middleware$1 | Middleware, H = any> {
+  readonly routes: Array<Route<X, M, H>>;
+  constructor(routes: Array<Route<X, M, H>>);
+  /**
+   * Register one or more middleware that will be executed before the route.
+   *
+   * @param middlewares
+   * @returns
+   */
+  middleware(middlewares: M[] | M): this;
+  all(): Array<Route<X, M, H>>;
+  first(): Route<X, M, H> | undefined;
+}
+//#endregion
+export { ResourceRouteSelection };

package/dist/ResourceRouteSelection.d.mts

@@ -0,0 +1,20 @@
+import { Middleware } from "./types/express.mjs";
+import { Middleware as Middleware$1 } from "./types/h3.mjs";
+import { Route } from "./Route.mjs";
+
+//#region src/ResourceRouteSelection.d.ts
+declare class ResourceRouteSelection<X = any, M = Middleware$1 | Middleware, H = any> {
+  readonly routes: Array<Route<X, M, H>>;
+  constructor(routes: Array<Route<X, M, H>>);
+  /**
+   * Register one or more middleware that will be executed before the route.
+   *
+   * @param middlewares
+   * @returns
+   */
+  middleware(middlewares: M[] | M): this;
+  all(): Array<Route<X, M, H>>;
+  first(): Route<X, M, H> | undefined;
+}
+//#endregion
+export { ResourceRouteSelection };

package/dist/ResourceRouteSelection.mjs

@@ -0,0 +1,25 @@
+//#region src/ResourceRouteSelection.ts
+var ResourceRouteSelection = class {
+	constructor(routes) {
+		this.routes = routes;
+	}
+	/**
+	* Register one or more middleware that will be executed before the route.
+	* 
+	* @param middlewares 
+	* @returns 
+	*/
+	middleware(middlewares) {
+		for (const route of this.routes) route.middleware(middlewares);
+		return this;
+	}
+	all() {
+		return this.routes;
+	}
+	first() {
+		return this.routes[0];
+	}
+};
+
+//#endregion
+export { ResourceRouteSelection };

package/dist/ResourceRoutes.cjs

@@ -0,0 +1,150 @@
+const require_ResourceRouteSelection = require('./ResourceRouteSelection.cjs');
+const require_helpers = require('./core/helpers.cjs');
+require('./core/index.cjs');
+
+//#region src/ResourceRoutes.ts
+/**
+* @class clear-router ResourceRoutes
+* @description A ResourceRoutes creates a collection of resourceful routes in a single call
+* @author 3m1n3nc3
+* @repository https://github.com/arkstack-tmp/clear-router
+*/
+var ResourceRoutes = class ResourceRoutes {
+	static actions = {
+		index: {
+			method: "get",
+			path: "/"
+		},
+		show: {
+			method: "get",
+			path: "/:{param}"
+		},
+		create: {
+			method: "post",
+			path: "/"
+		},
+		update: {
+			method: "put",
+			path: "/:{param}"
+		},
+		destroy: {
+			method: "delete",
+			path: "/:{param}"
+		}
+	};
+	routes = {};
+	options;
+	chainedMiddlewares = [];
+	constructor(basePath, controller, paramName, options, registerRoute, removeRoute) {
+		this.basePath = basePath;
+		this.controller = controller;
+		this.paramName = paramName;
+		this.registerRoute = registerRoute;
+		this.removeRoute = removeRoute;
+		this.options = options ?? {};
+	}
+	register() {
+		this.clear();
+		const preController = typeof this.controller === "function" ? new this.controller() : this.controller;
+		for (const action of this.selectedActions()) {
+			if (typeof preController[action] !== "function") continue;
+			const definition = this.definitionFor(action);
+			const route = this.registerRoute({
+				action,
+				method: definition.method,
+				path: `${this.basePath}${definition.path}`,
+				handler: [this.controller, action],
+				middlewares: this.resolveActionMiddlewares(action),
+				name: `${this.nameFor(definition.path)}.${action.toLowerCase()}`
+			});
+			this.routes[action] = route;
+		}
+		for (const middlewares of this.chainedMiddlewares) this.middleware(middlewares, false);
+		return this;
+	}
+	/**
+	* Only register routes for the provided actions.
+	*/
+	only(action, ...actions) {
+		this.options.only = Array.from(new Set(require_helpers.wrap(action).concat(actions)));
+		return this.register();
+	}
+	/**
+	* Register all resource routes except the provided actions.
+	*/
+	except(action, ...actions) {
+		this.options.except = Array.from(new Set(require_helpers.wrap(action).concat(actions)));
+		return this.register();
+	}
+	/**
+	* Register one or more middleware that will be executed before the route.
+	*/
+	middleware(middlewares, remember = true) {
+		if (remember) this.chainedMiddlewares.push(middlewares);
+		for (const route of Object.values(this.routes)) route?.middleware(middlewares);
+		return this;
+	}
+	action(action) {
+		return this.routes[action];
+	}
+	index() {
+		return this.routes.index;
+	}
+	show() {
+		return this.routes.show;
+	}
+	create() {
+		return this.routes.create;
+	}
+	update() {
+		return this.routes.update;
+	}
+	destroy() {
+		return this.routes.destroy;
+	}
+	get() {
+		return this.byMethod("get");
+	}
+	post() {
+		return this.byMethod("post");
+	}
+	put() {
+		return this.byMethod("put");
+	}
+	delete() {
+		return this.byMethod("delete");
+	}
+	selectedActions() {
+		const actions = this.options.only?.length ? this.options.only : Object.keys(ResourceRoutes.actions);
+		const except = new Set(this.options.except ?? []);
+		return actions.filter((action) => !except.has(action));
+	}
+	definitionFor(action) {
+		const definition = ResourceRoutes.actions[action];
+		return {
+			method: definition.method,
+			path: definition.path.replace("{param}", this.paramName)
+		};
+	}
+	resolveActionMiddlewares(action) {
+		const middlewares = this.isActionMiddlewareMap(this.options.middlewares) ? this.options.middlewares[action] : this.options.middlewares;
+		return Array.isArray(middlewares) ? middlewares : middlewares ? [middlewares] : void 0;
+	}
+	isActionMiddlewareMap(middlewares) {
+		if (!middlewares || Array.isArray(middlewares) || typeof middlewares !== "object") return false;
+		return Object.keys(ResourceRoutes.actions).some((action) => action in middlewares);
+	}
+	nameFor(path) {
+		return `${this.basePath}${path}`.replace(/\/:[^/]+|\/\{[^}]+\}/g, "").replace(/\{(\w+):[^}]+\}/g, "$1").replace(/\/|:|[{}]/g, ".").replace(/\.{2,}/g, ".").replace(/^\.|\.$/g, "");
+	}
+	byMethod(method) {
+		return new require_ResourceRouteSelection.ResourceRouteSelection(Object.values(this.routes).filter((route) => Boolean(route?.methods.includes(method))));
+	}
+	clear() {
+		for (const route of Object.values(this.routes)) if (route) this.removeRoute(route);
+		for (const key of Object.keys(this.routes)) delete this.routes[key];
+	}
+};
+
+//#endregion
+exports.ResourceRoutes = ResourceRoutes;

package/dist/ResourceRoutes.d.cts

@@ -0,0 +1,96 @@
+import { ApiResourceMiddleware, HttpMethod, ResourceAction } from "./types/basic.cjs";
+import { Middleware } from "./types/express.cjs";
+import { Middleware as Middleware$1 } from "./types/h3.cjs";
+import { Route } from "./Route.cjs";
+import { ResourceRouteSelection } from "./ResourceRouteSelection.cjs";
+
+//#region src/ResourceRoutes.d.ts
+type ResourceRouteDefinition = {
+  method: HttpMethod;
+  path: string;
+};
+type ResourceRouteRegistrar<X, M, H> = (input: {
+  action: ResourceAction;
+  method: HttpMethod;
+  path: string;
+  handler: any;
+  middlewares?: M[];
+  name: string;
+}) => Route<X, M, H>;
+type ResourceRouteRemover<X, M, H> = (route: Route<X, M, H>) => void;
+type ResourceRoutesOptions<M = any> = {
+  only?: ResourceAction[];
+  except?: ResourceAction[];
+  middlewares?: ApiResourceMiddleware<M>;
+};
+/**
+ * @class clear-router ResourceRoutes
+ * @description A ResourceRoutes creates a collection of resourceful routes in a single call
+ * @author 3m1n3nc3
+ * @repository https://github.com/arkstack-tmp/clear-router
+ */
+declare class ResourceRoutes<X = any, M = Middleware$1 | Middleware, H = any> {
+  readonly basePath: string;
+  readonly controller: any;
+  readonly paramName: string;
+  protected readonly registerRoute: ResourceRouteRegistrar<X, M, H>;
+  protected readonly removeRoute: ResourceRouteRemover<X, M, H>;
+  static actions: {
+    readonly index: {
+      readonly method: "get";
+      readonly path: "/";
+    };
+    readonly show: {
+      readonly method: "get";
+      readonly path: "/:{param}";
+    };
+    readonly create: {
+      readonly method: "post";
+      readonly path: "/";
+    };
+    readonly update: {
+      readonly method: "put";
+      readonly path: "/:{param}";
+    };
+    readonly destroy: {
+      readonly method: "delete";
+      readonly path: "/:{param}";
+    };
+  };
+  readonly routes: Partial<Record<ResourceAction, Route<X, M, H>>>;
+  protected options: ResourceRoutesOptions<M>;
+  protected chainedMiddlewares: Array<M[] | M>;
+  constructor(basePath: string, controller: any, paramName: string, options: ResourceRoutesOptions<M> | undefined, registerRoute: ResourceRouteRegistrar<X, M, H>, removeRoute: ResourceRouteRemover<X, M, H>);
+  register(): this;
+  /**
+   * Only register routes for the provided actions.
+   */
+  only(action: ResourceAction | ResourceAction[], ...actions: ResourceAction[]): this;
+  /**
+   * Register all resource routes except the provided actions.
+   */
+  except(action: ResourceAction | ResourceAction[], ...actions: ResourceAction[]): this;
+  /**
+   * Register one or more middleware that will be executed before the route.
+   */
+  middleware(middlewares: M[] | M, remember?: boolean): this;
+  action(action: ResourceAction): Route<X, M, H> | undefined;
+  index(): Route<X, M, H> | undefined;
+  show(): Route<X, M, H> | undefined;
+  create(): Route<X, M, H> | undefined;
+  update(): Route<X, M, H> | undefined;
+  destroy(): Route<X, M, H> | undefined;
+  get(): ResourceRouteSelection<X, M, H>;
+  post(): ResourceRouteSelection<X, M, H>;
+  put(): ResourceRouteSelection<X, M, H>;
+  delete(): ResourceRouteSelection<X, M, H>;
+  protected selectedActions(): ResourceAction[];
+  protected definitionFor(action: ResourceAction): ResourceRouteDefinition;
+  protected resolveActionMiddlewares(action: ResourceAction): M[] | undefined;
+  protected isActionMiddlewareMap(middlewares: ApiResourceMiddleware<M> | undefined): middlewares is { [K in ResourceAction]?: M | M[] };
+  protected nameFor(path: string): string;
+  protected byMethod(method: HttpMethod): ResourceRouteSelection<X, M, H>;
+  protected clear(): void;
+}
+//#endregion
+export { ResourceRoutes };

package/dist/ResourceRoutes.d.mts

@@ -0,0 +1,96 @@
+import { ApiResourceMiddleware, HttpMethod, ResourceAction } from "./types/basic.mjs";
+import { Middleware } from "./types/express.mjs";
+import { Middleware as Middleware$1 } from "./types/h3.mjs";
+import { Route } from "./Route.mjs";
+import { ResourceRouteSelection } from "./ResourceRouteSelection.mjs";
+
+//#region src/ResourceRoutes.d.ts
+type ResourceRouteDefinition = {
+  method: HttpMethod;
+  path: string;
+};
+type ResourceRouteRegistrar<X, M, H> = (input: {
+  action: ResourceAction;
+  method: HttpMethod;
+  path: string;
+  handler: any;
+  middlewares?: M[];
+  name: string;
+}) => Route<X, M, H>;
+type ResourceRouteRemover<X, M, H> = (route: Route<X, M, H>) => void;
+type ResourceRoutesOptions<M = any> = {
+  only?: ResourceAction[];
+  except?: ResourceAction[];
+  middlewares?: ApiResourceMiddleware<M>;
+};
+/**
+ * @class clear-router ResourceRoutes
+ * @description A ResourceRoutes creates a collection of resourceful routes in a single call
+ * @author 3m1n3nc3
+ * @repository https://github.com/arkstack-tmp/clear-router
+ */
+declare class ResourceRoutes<X = any, M = Middleware$1 | Middleware, H = any> {
+  readonly basePath: string;
+  readonly controller: any;
+  readonly paramName: string;
+  protected readonly registerRoute: ResourceRouteRegistrar<X, M, H>;
+  protected readonly removeRoute: ResourceRouteRemover<X, M, H>;
+  static actions: {
+    readonly index: {
+      readonly method: "get";
+      readonly path: "/";
+    };
+    readonly show: {
+      readonly method: "get";
+      readonly path: "/:{param}";
+    };
+    readonly create: {
+      readonly method: "post";
+      readonly path: "/";
+    };
+    readonly update: {
+      readonly method: "put";
+      readonly path: "/:{param}";
+    };
+    readonly destroy: {
+      readonly method: "delete";
+      readonly path: "/:{param}";
+    };
+  };
+  readonly routes: Partial<Record<ResourceAction, Route<X, M, H>>>;
+  protected options: ResourceRoutesOptions<M>;
+  protected chainedMiddlewares: Array<M[] | M>;
+  constructor(basePath: string, controller: any, paramName: string, options: ResourceRoutesOptions<M> | undefined, registerRoute: ResourceRouteRegistrar<X, M, H>, removeRoute: ResourceRouteRemover<X, M, H>);
+  register(): this;
+  /**
+   * Only register routes for the provided actions.
+   */
+  only(action: ResourceAction | ResourceAction[], ...actions: ResourceAction[]): this;
+  /**
+   * Register all resource routes except the provided actions.
+   */
+  except(action: ResourceAction | ResourceAction[], ...actions: ResourceAction[]): this;
+  /**
+   * Register one or more middleware that will be executed before the route.
+   */
+  middleware(middlewares: M[] | M, remember?: boolean): this;
+  action(action: ResourceAction): Route<X, M, H> | undefined;
+  index(): Route<X, M, H> | undefined;
+  show(): Route<X, M, H> | undefined;
+  create(): Route<X, M, H> | undefined;
+  update(): Route<X, M, H> | undefined;
+  destroy(): Route<X, M, H> | undefined;
+  get(): ResourceRouteSelection<X, M, H>;
+  post(): ResourceRouteSelection<X, M, H>;
+  put(): ResourceRouteSelection<X, M, H>;
+  delete(): ResourceRouteSelection<X, M, H>;
+  protected selectedActions(): ResourceAction[];
+  protected definitionFor(action: ResourceAction): ResourceRouteDefinition;
+  protected resolveActionMiddlewares(action: ResourceAction): M[] | undefined;
+  protected isActionMiddlewareMap(middlewares: ApiResourceMiddleware<M> | undefined): middlewares is { [K in ResourceAction]?: M | M[] };
+  protected nameFor(path: string): string;
+  protected byMethod(method: HttpMethod): ResourceRouteSelection<X, M, H>;
+  protected clear(): void;
+}
+//#endregion
+export { ResourceRoutes };

package/dist/ResourceRoutes.mjs

@@ -0,0 +1,150 @@
+import { ResourceRouteSelection } from "./ResourceRouteSelection.mjs";
+import { wrap } from "./core/helpers.mjs";
+import "./core/index.mjs";
+
+//#region src/ResourceRoutes.ts
+/**
+* @class clear-router ResourceRoutes
+* @description A ResourceRoutes creates a collection of resourceful routes in a single call
+* @author 3m1n3nc3
+* @repository https://github.com/arkstack-tmp/clear-router
+*/
+var ResourceRoutes = class ResourceRoutes {
+	static actions = {
+		index: {
+			method: "get",
+			path: "/"
+		},
+		show: {
+			method: "get",
+			path: "/:{param}"
+		},
+		create: {
+			method: "post",
+			path: "/"
+		},
+		update: {
+			method: "put",
+			path: "/:{param}"
+		},
+		destroy: {
+			method: "delete",
+			path: "/:{param}"
+		}
+	};
+	routes = {};
+	options;
+	chainedMiddlewares = [];
+	constructor(basePath, controller, paramName, options, registerRoute, removeRoute) {
+		this.basePath = basePath;
+		this.controller = controller;
+		this.paramName = paramName;
+		this.registerRoute = registerRoute;
+		this.removeRoute = removeRoute;
+		this.options = options ?? {};
+	}
+	register() {
+		this.clear();
+		const preController = typeof this.controller === "function" ? new this.controller() : this.controller;
+		for (const action of this.selectedActions()) {
+			if (typeof preController[action] !== "function") continue;
+			const definition = this.definitionFor(action);
+			const route = this.registerRoute({
+				action,
+				method: definition.method,
+				path: `${this.basePath}${definition.path}`,
+				handler: [this.controller, action],
+				middlewares: this.resolveActionMiddlewares(action),
+				name: `${this.nameFor(definition.path)}.${action.toLowerCase()}`
+			});
+			this.routes[action] = route;
+		}
+		for (const middlewares of this.chainedMiddlewares) this.middleware(middlewares, false);
+		return this;
+	}
+	/**
+	* Only register routes for the provided actions.
+	*/
+	only(action, ...actions) {
+		this.options.only = Array.from(new Set(wrap(action).concat(actions)));
+		return this.register();
+	}
+	/**
+	* Register all resource routes except the provided actions.
+	*/
+	except(action, ...actions) {
+		this.options.except = Array.from(new Set(wrap(action).concat(actions)));
+		return this.register();
+	}
+	/**
+	* Register one or more middleware that will be executed before the route.
+	*/
+	middleware(middlewares, remember = true) {
+		if (remember) this.chainedMiddlewares.push(middlewares);
+		for (const route of Object.values(this.routes)) route?.middleware(middlewares);
+		return this;
+	}
+	action(action) {
+		return this.routes[action];
+	}
+	index() {
+		return this.routes.index;
+	}
+	show() {
+		return this.routes.show;
+	}
+	create() {
+		return this.routes.create;
+	}
+	update() {
+		return this.routes.update;
+	}
+	destroy() {
+		return this.routes.destroy;
+	}
+	get() {
+		return this.byMethod("get");
+	}
+	post() {
+		return this.byMethod("post");
+	}
+	put() {
+		return this.byMethod("put");
+	}
+	delete() {
+		return this.byMethod("delete");
+	}
+	selectedActions() {
+		const actions = this.options.only?.length ? this.options.only : Object.keys(ResourceRoutes.actions);
+		const except = new Set(this.options.except ?? []);
+		return actions.filter((action) => !except.has(action));
+	}
+	definitionFor(action) {
+		const definition = ResourceRoutes.actions[action];
+		return {
+			method: definition.method,
+			path: definition.path.replace("{param}", this.paramName)
+		};
+	}
+	resolveActionMiddlewares(action) {
+		const middlewares = this.isActionMiddlewareMap(this.options.middlewares) ? this.options.middlewares[action] : this.options.middlewares;
+		return Array.isArray(middlewares) ? middlewares : middlewares ? [middlewares] : void 0;
+	}
+	isActionMiddlewareMap(middlewares) {
+		if (!middlewares || Array.isArray(middlewares) || typeof middlewares !== "object") return false;
+		return Object.keys(ResourceRoutes.actions).some((action) => action in middlewares);
+	}
+	nameFor(path) {
+		return `${this.basePath}${path}`.replace(/\/:[^/]+|\/\{[^}]+\}/g, "").replace(/\{(\w+):[^}]+\}/g, "$1").replace(/\/|:|[{}]/g, ".").replace(/\.{2,}/g, ".").replace(/^\.|\.$/g, "");
+	}
+	byMethod(method) {
+		return new ResourceRouteSelection(Object.values(this.routes).filter((route) => Boolean(route?.methods.includes(method))));
+	}
+	clear() {
+		for (const route of Object.values(this.routes)) if (route) this.removeRoute(route);
+		for (const key of Object.keys(this.routes)) delete this.routes[key];
+	}
+};
+
+//#endregion
+export { ResourceRoutes };

package/dist/Route.cjs

@@ -1,5 +1,11 @@
 
 //#region src/Route.ts
+/**
+* @class clear-router Route
+* @description A route describes a single enpoint on clear-router
+* @author 3m1n3nc3
+* @repository https://github.com/arkstack-tmp/clear-router
+*/
 var Route = class {
 	ctx;
 	body = {};
@@ -29,14 +35,40 @@ var Route = class {
 		this.controllerName = Array.isArray(handler) ? handler[0]?.name : void 0;
 		this.actionName = Array.isArray(handler) ? handler[1] : typeof handler === "function" ? handler.constructor.name ?? handler.name : void 0;
 		this.onName = options.onName;
+		this.normalizeMiddleware = options.normalizeMiddleware;
 	}
 	onName;
+	normalizeMiddleware;
+	/**
+	* Set the route name
+	* 
+	* @param name 
+	* @returns 
+	*/
 	name(name) {
 		const previousName = this.routeName;
 		this.routeName = name;
 		this.onName?.(name, this, previousName);
 		return this;
 	}
+	/**
+	* Register one or more middleware that will be executed before the route.
+	* 
+	* @param middlewares 
+	* @returns 
+	*/
+	middleware(middlewares) {
+		const normalized = (Array.isArray(middlewares) ? middlewares : [middlewares]).map((middleware) => this.normalizeMiddleware?.(middleware) ?? middleware);
+		this.middlewares.push(...normalized);
+		this.middlewareCount = this.middlewares.length;
+		return this;
+	}
+	/**
+	* Get the path generated and accessible by this route
+	* 
+	* @param params 
+	* @returns 
+	*/
 	toPath(params = {}) {
 		return this.path.replace(/\/?\{([^{}]+)\}/g, (segment, raw) => {
 			const optional = raw.endsWith("?");