Added NodePlatformAdapter and fixed bug in platform independent functions and added Demo.

src/router.ts

@@ -1,17 +1,29 @@
 import handler from "./handler";
 import {
 	path,
-	method,
 	response,
 	request,
 	ChainInterrupted,
+	AllMismatchInterrupted,
+	responder,
 } from "./interface/index";
 import { defaultHeaders } from "./interface/response";
 import route from "./route";
+import { method, methodENUM } from "./interface/method";
+import {
+	createPlatformAdapater,
+	platformAdapaterConstructor,
+	platformAdapater,
+} from "./platform";
 
 export class router<K = any, V = any> {
 	public routes: route[];
 
+	public errorResponder: (
+		errorCode: number,
+		errorMessage?: string
+	) => responder<K, V>;
+
 	constructor(routes: route[] = []) {
 		this.routes = routes;
 	}
@@ -22,7 +34,7 @@ export class router<K = any, V = any> {
 	}
 
 	binding(path: path, handler: handler<K, V>) {
-		this.add(new route([path], handler));
+		this.add(new route([path], [handler]));
 		return this;
 	}
 
@@ -42,11 +54,11 @@ export class router<K = any, V = any> {
 				const answer = await responder(request);
 				if (answer instanceof response) {
 					return answer;
-				} else if (answer instanceof String) {
+				} else if (typeof answer == "string") {
 					return new response(answer);
-				} else if (answer instanceof Number) {
+				} else if (typeof answer == "number") {
 					return new response(answer.toString());
-				} else if (answer instanceof Object) {
+				} else if (typeof answer == "object") {
 					return new response(
 						JSON.stringify(answer),
 						200,
@@ -63,7 +75,7 @@ export class router<K = any, V = any> {
 
 	use(routers: router[], path: path): void {
 		routers.forEach((router) => {
-			this.binding(path, router.toHandler(path));
+			this.binding(path, router.toHandler());
 		});
 	}
 
@@ -73,23 +85,22 @@ export class router<K = any, V = any> {
 		return Router;
 	}
 
-	async respond(request: request<K>, basePath: path): Promise<response<V>> {
+	async _respond(
+		request: request<K>,
+		responseMessage: response<V> = new response<V>("")
+	): Promise<response<V>> {
 		request.originURL = request.url;
-		request.url.pathname = request.url.pathname.replace(basePath, "");
+		request.url.pathname = request.params["0"]
+			? "/" + request.params["0"]
+			: request.originURL.pathname;
 
-		let responseMessage: response<V> = new response("");
+		let mismatchCount = 0;
 
 		for (let route of this.routes) {
-			if (
-				route.handler.method != request.method ||
-				route.handler.method != method.ANY
-			) {
-				continue;
-			}
-
 			const isMatched = await route.exec(request.url.pathname);
 
 			if (!isMatched.matched) {
+				mismatchCount++;
 				continue;
 			}
 
@@ -97,35 +108,104 @@ export class router<K = any, V = any> {
 				request.params[e.name] = e.value;
 			});
 
-			let thisResponse = await route.handler.respond(request, responseMessage);
-			if (thisResponse instanceof response) {
-				responseMessage = thisResponse;
+			try {
+				let thisResponse: response<V> | void = responseMessage;
+				for (let handler of route.handlers) {
+					if (
+						handler.method != request.method &&
+						handler.method != methodENUM.ANY
+					) {
+						continue;
+					}
+					thisResponse = await handler.respond(
+						request,
+						thisResponse ?? responseMessage
+					);
+				}
+				if (thisResponse instanceof response) {
+					responseMessage = thisResponse;
+				} else {
+					// means that the handler is a middleware that doesn't change the response
+					throw AllMismatchInterrupted;
+				}
+			} catch (e) {
+				if (e === ChainInterrupted) {
+					return e.response;
+				}
+				if (e === AllMismatchInterrupted) mismatchCount++;
+				else {
+					if (typeof this.errorResponder == "function") {
+						responseMessage =
+							(await this.errorResponder(500, e.toString() + "\n")(request)) ??
+							new response(e.toString(), 500);
+						console.log(e);
+					} else {
+						throw e;
+					}
+				}
 			}
 		}
 
+		if (mismatchCount == this.routes.length) {
+			throw AllMismatchInterrupted;
+		}
+
 		return responseMessage;
 	}
 
-	toHandler(basePath: path): handler<K, V> {
-		return this.create(method.ANY, (request: request<K>) => {
-			return this.respond(request, basePath);
-		});
+	public respond = this._respond;
+
+	toHandler(): handler<K, V> {
+		return new handler(methodENUM.ANY, [
+			(request: request<K>, responseMessage?: response<V>) => {
+				return this.respond(request, responseMessage ?? new response(""));
+			},
+		]);
+	}
+
+	useErrorResponder(
+		errorResponder: (
+			errorCode: number,
+			errorMessage?: string
+		) => responder<K, V>
+	): this {
+		this.errorResponder = errorResponder;
+		return this;
 	}
 }
 
 export default router;
 
 export class rootRouter<K = any, V = any> extends router<K, V> {
-	private readonly originRespond = this.respond;
-	async respond(request: request<K>, basePath: path): Promise<response<V>> {
+	public adapater: platformAdapater<K, V>;
+	errorResponder =
+		(errorCode: number, errorMessage?: string) =>
+		async (_request: request<K>): Promise<response<V>> =>
+			new response(errorMessage ?? "", errorCode);
+
+	respond = async (request: request<K>): Promise<response<V>> => {
+		let responseMessage: response<V> = new response("");
 		try {
-			return this.originRespond(request, basePath);
+			responseMessage = await this._respond(request, responseMessage);
 		} catch (e) {
 			if (e === ChainInterrupted) {
-				return e.response;
+				return responseMessage;
+			} else if (e === AllMismatchInterrupted) {
+				responseMessage =
+					(await this.errorResponder(404, "404 Not Found\n")(request)) ??
+					new response("404 Not Found\n", 404);
 			} else {
-				throw e;
+				responseMessage =
+					(await this.errorResponder(500, e.toString() + "\n")(request)) ??
+					new response(e.toString(), 500);
+				console.log(e);
 			}
 		}
+
+		return responseMessage;
+	};
+	useAdapater(adapater: platformAdapaterConstructor): this {
+		this.adapater = createPlatformAdapater(adapater, this);
+		return this;
 	}
 }