clear-router 2.8.2 → 2.8.4

package/dist/ClearRequest.d.cts

@@ -1,10 +1,10 @@
-import { RequestData } from "./types/basic.cjs";
 import { Middleware } from "./types/express.cjs";
 import { Middleware as Middleware$1 } from "./types/fastify.cjs";
 import { Middleware as Middleware$2 } from "./types/h3.cjs";
 import { Middleware as Middleware$3 } from "./types/hono.cjs";
 import { Middleware as Middleware$4 } from "./types/koa.cjs";
 import { Route } from "./Route.cjs";
+import { RequestData } from "./types/basic.cjs";
 
 //#region src/ClearRequest.d.ts
 declare class ClearRequest<X = any, M = Middleware$2 | Middleware | Middleware$1 | Middleware$3 | Middleware$4> {

package/dist/ClearRequest.d.mts

@@ -1,10 +1,10 @@
-import { RequestData } from "./types/basic.mjs";
 import { Middleware } from "./types/express.mjs";
 import { Middleware as Middleware$1 } from "./types/fastify.mjs";
 import { Middleware as Middleware$2 } from "./types/h3.mjs";
 import { Middleware as Middleware$3 } from "./types/hono.mjs";
 import { Middleware as Middleware$4 } from "./types/koa.mjs";
 import { Route } from "./Route.mjs";
+import { RequestData } from "./types/basic.mjs";
 
 //#region src/ClearRequest.d.ts
 declare class ClearRequest<X = any, M = Middleware$2 | Middleware | Middleware$1 | Middleware$3 | Middleware$4> {

package/dist/Controller.d.cts

@@ -1,5 +1,5 @@
-import { RequestData } from "./types/basic.cjs";
 import { ClearRequest } from "./ClearRequest.cjs";
+import { RequestData } from "./types/basic.cjs";
 
 //#region src/Controller.d.ts
 declare abstract class Controller<X = any> {

package/dist/Controller.d.mts

@@ -1,5 +1,5 @@
-import { RequestData } from "./types/basic.mjs";
 import { ClearRequest } from "./ClearRequest.mjs";
+import { RequestData } from "./types/basic.mjs";
 
 //#region src/Controller.d.ts
 declare abstract class Controller<X = any> {

package/dist/ResourceRoutes.cjs

@@ -64,6 +64,10 @@ var ResourceRoutes = class ResourceRoutes {
 	}
 	/**
 	* Only register routes for the provided actions.
+	* 
+	* @param action 
+	* @param actions 
+	* @returns 
 	*/
 	only(action, ...actions) {
 		this.options.only = Array.from(new Set(require_helpers.wrap(action).concat(actions)));
@@ -71,6 +75,10 @@ var ResourceRoutes = class ResourceRoutes {
 	}
 	/**
 	* Register all resource routes except the provided actions.
+	* 
+	* @param action 
+	* @param actions 
+	* @returns 
 	*/
 	except(action, ...actions) {
 		this.options.except = Array.from(new Set(require_helpers.wrap(action).concat(actions)));
@@ -78,6 +86,10 @@ var ResourceRoutes = class ResourceRoutes {
 	}
 	/**
 	* Register one or more middleware that will be executed before the route.
+	* 
+	* @param middlewares 
+	* @param remember 
+	* @returns 
 	*/
 	middleware(middlewares, remember = true) {
 		if (remember) this.chainedMiddlewares.push(middlewares);

package/dist/ResourceRoutes.d.cts

@@ -1,28 +1,10 @@
-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 { ApiResourceMiddleware, HttpMethod, ResourceAction, ResourceRouteDefinition, ResourceRouteRegistrar, ResourceRouteRemover, ResourceRoutesOptions } from "./types/basic.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
@@ -64,14 +46,26 @@ declare class ResourceRoutes<X = any, M = Middleware$1 | Middleware, H = any> {
   register(): this;
   /**
    * Only register routes for the provided actions.
+   *
+   * @param action
+   * @param actions
+   * @returns
    */
   only(action: ResourceAction | ResourceAction[], ...actions: ResourceAction[]): this;
   /**
    * Register all resource routes except the provided actions.
+   *
+   * @param action
+   * @param actions
+   * @returns
    */
   except(action: ResourceAction | ResourceAction[], ...actions: ResourceAction[]): this;
   /**
    * Register one or more middleware that will be executed before the route.
+   *
+   * @param middlewares
+   * @param remember
+   * @returns
    */
   middleware(middlewares: M[] | M, remember?: boolean): this;
   action(action: ResourceAction): Route<X, M, H> | undefined;

package/dist/ResourceRoutes.d.mts

@@ -1,28 +1,10 @@
-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 { ApiResourceMiddleware, HttpMethod, ResourceAction, ResourceRouteDefinition, ResourceRouteRegistrar, ResourceRouteRemover, ResourceRoutesOptions } from "./types/basic.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
@@ -64,14 +46,26 @@ declare class ResourceRoutes<X = any, M = Middleware$1 | Middleware, H = any> {
   register(): this;
   /**
    * Only register routes for the provided actions.
+   *
+   * @param action
+   * @param actions
+   * @returns
    */
   only(action: ResourceAction | ResourceAction[], ...actions: ResourceAction[]): this;
   /**
    * Register all resource routes except the provided actions.
+   *
+   * @param action
+   * @param actions
+   * @returns
    */
   except(action: ResourceAction | ResourceAction[], ...actions: ResourceAction[]): this;
   /**
    * Register one or more middleware that will be executed before the route.
+   *
+   * @param middlewares
+   * @param remember
+   * @returns
    */
   middleware(middlewares: M[] | M, remember?: boolean): this;
   action(action: ResourceAction): Route<X, M, H> | undefined;

package/dist/ResourceRoutes.mjs

@@ -64,6 +64,10 @@ var ResourceRoutes = class ResourceRoutes {
 	}
 	/**
 	* Only register routes for the provided actions.
+	* 
+	* @param action 
+	* @param actions 
+	* @returns 
 	*/
 	only(action, ...actions) {
 		this.options.only = Array.from(new Set(wrap(action).concat(actions)));
@@ -71,6 +75,10 @@ var ResourceRoutes = class ResourceRoutes {
 	}
 	/**
 	* Register all resource routes except the provided actions.
+	* 
+	* @param action 
+	* @param actions 
+	* @returns 
 	*/
 	except(action, ...actions) {
 		this.options.except = Array.from(new Set(wrap(action).concat(actions)));
@@ -78,6 +86,10 @@ var ResourceRoutes = class ResourceRoutes {
 	}
 	/**
 	* Register one or more middleware that will be executed before the route.
+	* 
+	* @param middlewares 
+	* @param remember 
+	* @returns 
 	*/
 	middleware(middlewares, remember = true) {
 		if (remember) this.chainedMiddlewares.push(middlewares);

package/dist/{Request-Ci0UQ-Vl.d.mts → Route-tq-rge1g.d.mts}

@@ -1,9 +1,9 @@
+import { Middleware } from "./types/express.mjs";
+import { Middleware as Middleware$1 } from "./types/fastify.mjs";
+import { Middleware as Middleware$2 } from "./types/h3.mjs";
+import { Middleware as Middleware$3 } from "./types/hono.mjs";
+import { Middleware as Middleware$4 } from "./types/koa.mjs";
 import { HttpMethod, RequestData } from "./types/basic.mjs";
-import { Middleware } from "./types/fastify.mjs";
-import { Middleware as Middleware$1 } from "./types/h3.mjs";
-import { Middleware as Middleware$2 } from "./types/hono.mjs";
-import { Middleware as Middleware$3 } from "./types/koa.mjs";
-import { Middleware as Middleware$4 } from "./types/express.mjs";
 
 //#region src/Contracts.d.ts
 /**
@@ -16,6 +16,26 @@ interface RouteParameter {
   optional: boolean;
 }
 //#endregion
+//#region src/core/Request.d.ts
+declare class Request<X = any, M = any> extends ClearRequest<X, M> {
+  original?: any;
+  method: string;
+  path: string;
+  url: string;
+  headers: Headers | Record<string, any>;
+  constructor(init?: Partial<Request<X, M>> & {
+    body?: RequestData;
+    query?: RequestData;
+    params?: RequestData;
+    route?: Route<X, M>;
+  });
+  getBody(): RequestData;
+  header(name: string): string;
+  param(name: string): any;
+  input(name: string): any;
+  is(method: HttpMethod | string): boolean;
+}
+//#endregion
 //#region src/core/Response.d.ts
 declare class Response {
   [key: string]: any;
@@ -39,6 +59,25 @@ declare class Response {
   noContent(): this;
 }
 //#endregion
+//#region src/ClearRequest.d.ts
+declare class ClearRequest<X = any, M = Middleware$2 | Middleware | Middleware$1 | Middleware$3 | Middleware$4> {
+  [key: string]: any;
+  /**
+   * @param body - Parsed request body
+   */
+  body: RequestData;
+  /**
+   * @param query - Parsed query parameters
+   */
+  query: RequestData;
+  /**
+   * @param params - Parsed route parameters
+   */
+  params: RequestData;
+  route: Route<X, M>;
+  constructor(init?: Partial<ClearRequest>);
+}
+//#endregion
 //#region src/Route.d.ts
 /**
  * @class clear-router Route
@@ -46,7 +85,7 @@ declare class Response {
  * @author 3m1n3nc3
  * @repository https://github.com/arkstack-tmp/clear-router
  */
-declare class Route<X = any, M = Middleware$1 | Middleware$4, H = any> {
+declare class Route<X = any, M = Middleware$2 | Middleware, H = any> {
   ctx: X;
   body: RequestData;
   query: RequestData;
@@ -94,43 +133,4 @@ declare class Route<X = any, M = Middleware$1 | Middleware$4, H = any> {
   toPath(params?: RequestData): string;
 }
 //#endregion
-//#region src/ClearRequest.d.ts
-declare class ClearRequest<X = any, M = Middleware$1 | Middleware$4 | Middleware | Middleware$2 | Middleware$3> {
-  [key: string]: any;
-  /**
-   * @param body - Parsed request body
-   */
-  body: RequestData;
-  /**
-   * @param query - Parsed query parameters
-   */
-  query: RequestData;
-  /**
-   * @param params - Parsed route parameters
-   */
-  params: RequestData;
-  route: Route<X, M>;
-  constructor(init?: Partial<ClearRequest>);
-}
-//#endregion
-//#region src/core/Request.d.ts
-declare class Request<X = any, M = any> extends ClearRequest<X, M> {
-  original?: any;
-  method: string;
-  path: string;
-  url: string;
-  headers: Headers | Record<string, any>;
-  constructor(init?: Partial<Request<X, M>> & {
-    body?: RequestData;
-    query?: RequestData;
-    params?: RequestData;
-    route?: Route<X, M>;
-  });
-  getBody(): RequestData;
-  header(name: string): string;
-  param(name: string): any;
-  input(name: string): any;
-  is(method: HttpMethod | string): boolean;
-}
-//#endregion
-export { Response as n, ClearHttpContext as r, Request as t };
+export { ClearHttpContext as i, Response as n, Request as r, Route as t };

package/dist/Route.d.cts

@@ -1,8 +1,8 @@
-import { HttpMethod, RequestData } from "./types/basic.cjs";
 import { RouteParameter } from "./Contracts.cjs";
 import { Middleware } from "./types/express.cjs";
 import { Middleware as Middleware$1 } from "./types/h3.cjs";
 import { ClearRequest } from "./ClearRequest.cjs";
+import { HttpMethod, RequestData } from "./types/basic.cjs";
 
 //#region src/Route.d.ts
 /**

package/dist/Route.d.mts

@@ -1,8 +1,8 @@
-import { HttpMethod, RequestData } from "./types/basic.mjs";
 import { RouteParameter } from "./Contracts.mjs";
 import { Middleware } from "./types/express.mjs";
 import { Middleware as Middleware$1 } from "./types/h3.mjs";
 import { ClearRequest } from "./ClearRequest.mjs";
+import { HttpMethod, RequestData } from "./types/basic.mjs";
 
 //#region src/Route.d.ts
 /**

package/dist/RouteGroup.cjs

@@ -0,0 +1,150 @@
+const require_helpers = require('./core/helpers.cjs');
+let node_path = require("node:path");
+let node_fs_promises = require("node:fs/promises");
+
+//#region src/RouteGroup.ts
+/**
+* @class clear-router RouteGroup
+* @description A route group describes a collection of routes on clear-router
+* @author 3m1n3nc3
+* @repository https://github.com/arkstack-tmp/clear-router
+*/
+var RouteGroup = class {
+	checks = [];
+	conditions = [];
+	registration;
+	routes = /* @__PURE__ */ new Set();
+	unfilteredSources = /* @__PURE__ */ new Set();
+	constructor(options) {
+		this.options = options;
+		this.registration = this.register();
+	}
+	/**
+	* Returning a falsy value will stop route group registration
+	* 
+	* @param condition 
+	* @returns 
+	*/
+	when(condition) {
+		this.conditions.push(condition);
+		const unfilteredSources = Array.from(this.unfilteredSources);
+		if (unfilteredSources.length) this.checks.push(this.registration.then(async () => {
+			for (const source of unfilteredSources) if (!await condition(source)) {
+				this.rollback();
+				break;
+			}
+		}));
+		return this;
+	}
+	/**
+	* Register one or more middleware that will be executed before every route in the group.
+	*
+	* @param middlewares
+	* @returns
+	*/
+	middleware(middlewares) {
+		this.checks.push(this.registration.then(() => {
+			for (const route of this.routes) route.middleware(middlewares);
+		}));
+		return this;
+	}
+	/**
+	* Attaches callbacks for the resolution and/or rejection of the RouteGroup.
+	* 
+	* @param onfulfilled 
+	* @param onrejected 
+	* @returns 
+	*/
+	then(onfulfilled, onrejected) {
+		return Promise.all([this.registration, ...this.checks]).then(() => void 0).then(onfulfilled, onrejected);
+	}
+	/**
+	* Register the routes
+	*/
+	async register() {
+		const current = this.options.context.getStore();
+		const previousPrefix = current?.prefix ?? this.options.defaultPrefix;
+		const previousMiddlewares = current?.groupMiddlewares ?? this.options.defaultMiddlewares;
+		const fullPrefix = [previousPrefix, this.options.prefix].filter(Boolean).join("/");
+		const nextContext = {
+			prefix: this.options.normalizePath(fullPrefix),
+			groupMiddlewares: [...previousMiddlewares, ...this.options.middlewares || []],
+			routeCollectors: [...current?.routeCollectors ?? [], this.routes]
+		};
+		await this.options.context.run(nextContext, async () => {
+			for (const entry of Array.isArray(this.options.source) ? this.options.source : [this.options.source]) {
+				if (typeof entry === "function") {
+					if (!this.conditions.length) this.unfilteredSources.add(entry);
+					else if (!await this.accepts(entry)) continue;
+					await Promise.resolve(entry());
+					continue;
+				}
+				const resolved = await this.resolveFiles(entry);
+				if (!resolved.directory && !await this.accepts(entry)) continue;
+				for (const file of resolved.files) {
+					if (resolved.directory && !await this.accepts(file)) continue;
+					await require_helpers.importFile(file);
+				}
+			}
+		});
+	}
+	/**
+	* Rollback the route registration
+	*/
+	rollback() {
+		for (const route of this.routes) this.options.removeRoute(route);
+	}
+	/**
+	* Check whether a callback or path should be registered.
+	* 
+	* @param source 
+	* @returns 
+	*/
+	async accepts(source) {
+		for (const condition of this.conditions) if (!await condition(source)) return false;
+		return true;
+	}
+	/**
+	* Resolve files from the group path
+	* 
+	* @param source 
+	* @returns 
+	*/
+	async resolveFiles(source) {
+		const resolved = (0, node_path.isAbsolute)(source) ? source : (0, node_path.resolve)(process.cwd(), source);
+		let sourceStat;
+		try {
+			sourceStat = await (0, node_fs_promises.stat)(resolved);
+		} catch {
+			throw new Error(`Route group source not found: ${source}`);
+		}
+		if (sourceStat.isFile()) return {
+			directory: false,
+			files: [resolved]
+		};
+		if (!sourceStat.isDirectory()) throw new Error(`Route group source must be a file or directory: ${source}`);
+		return {
+			directory: true,
+			files: await this.readDirectory(resolved)
+		};
+	}
+	/**
+	* Read all the files in the configured directory
+	* 
+	* @param directory 
+	* @returns 
+	*/
+	async readDirectory(directory) {
+		const entries = await (0, node_fs_promises.readdir)(directory, { withFileTypes: true });
+		const files = [];
+		for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+			const path = (0, node_path.join)(directory, entry.name);
+			if (entry.isDirectory()) files.push(...await this.readDirectory(path));
+			else if (entry.isFile() && /\.(?:[cm]?ts)$/.test(entry.name) && !entry.name.endsWith(".d.ts")) files.push(path);
+		}
+		return files;
+	}
+};
+
+//#endregion
+exports.RouteGroup = RouteGroup;

package/dist/RouteGroup.d.cts

@@ -0,0 +1,73 @@
+import { Middleware } from "./types/express.cjs";
+import { Middleware as Middleware$1 } from "./types/h3.cjs";
+import { RouteGroupCondition, RouteGroupOptions } from "./types/basic.cjs";
+
+//#region src/RouteGroup.d.ts
+/**
+ * @class clear-router RouteGroup
+ * @description A route group describes a collection of routes on clear-router
+ * @author 3m1n3nc3
+ * @repository https://github.com/arkstack-tmp/clear-router
+ */
+declare class RouteGroup<X = any, M = Middleware$1 | Middleware, H = any> implements PromiseLike<void> {
+  private readonly options;
+  private readonly checks;
+  private readonly conditions;
+  private readonly registration;
+  private readonly routes;
+  private readonly unfilteredSources;
+  constructor(options: RouteGroupOptions);
+  /**
+   * Returning a falsy value will stop route group registration
+   *
+   * @param condition
+   * @returns
+   */
+  when(condition: RouteGroupCondition): this;
+  /**
+   * Register one or more middleware that will be executed before every route in the group.
+   *
+   * @param middlewares
+   * @returns
+   */
+  middleware(middlewares: M[] | M): this;
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the RouteGroup.
+   *
+   * @param onfulfilled
+   * @param onrejected
+   * @returns
+   */
+  then<TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+  /**
+   * Register the routes
+   */
+  private register;
+  /**
+  * Rollback the route registration
+  */
+  private rollback;
+  /**
+   * Check whether a callback or path should be registered.
+   *
+   * @param source
+   * @returns
+   */
+  private accepts;
+  /**
+   * Resolve files from the group path
+   *
+   * @param source
+   * @returns
+   */
+  private resolveFiles;
+  /**
+   * Read all the files in the configured directory
+   *
+   * @param directory
+   * @returns
+   */
+  private readDirectory;
+}
+//#endregion
+export { RouteGroup };

package/dist/RouteGroup.d.mts

@@ -0,0 +1,73 @@
+import { Middleware } from "./types/express.mjs";
+import { Middleware as Middleware$1 } from "./types/h3.mjs";
+import { RouteGroupCondition, RouteGroupOptions } from "./types/basic.mjs";
+
+//#region src/RouteGroup.d.ts
+/**
+ * @class clear-router RouteGroup
+ * @description A route group describes a collection of routes on clear-router
+ * @author 3m1n3nc3
+ * @repository https://github.com/arkstack-tmp/clear-router
+ */
+declare class RouteGroup<X = any, M = Middleware$1 | Middleware, H = any> implements PromiseLike<void> {
+  private readonly options;
+  private readonly checks;
+  private readonly conditions;
+  private readonly registration;
+  private readonly routes;
+  private readonly unfilteredSources;
+  constructor(options: RouteGroupOptions);
+  /**
+   * Returning a falsy value will stop route group registration
+   *
+   * @param condition
+   * @returns
+   */
+  when(condition: RouteGroupCondition): this;
+  /**
+   * Register one or more middleware that will be executed before every route in the group.
+   *
+   * @param middlewares
+   * @returns
+   */
+  middleware(middlewares: M[] | M): this;
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the RouteGroup.
+   *
+   * @param onfulfilled
+   * @param onrejected
+   * @returns
+   */
+  then<TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+  /**
+   * Register the routes
+   */
+  private register;
+  /**
+  * Rollback the route registration
+  */
+  private rollback;
+  /**
+   * Check whether a callback or path should be registered.
+   *
+   * @param source
+   * @returns
+   */
+  private accepts;
+  /**
+   * Resolve files from the group path
+   *
+   * @param source
+   * @returns
+   */
+  private resolveFiles;
+  /**
+   * Read all the files in the configured directory
+   *
+   * @param directory
+   * @returns
+   */
+  private readDirectory;
+}
+//#endregion
+export { RouteGroup };