feat: base router abstracted

lib/context.ts

@@ -0,0 +1,12 @@
+import { BaseRouter } from "./routers/_Router.ts";
+
+export class RequestContext<T extends object = Record<string, unknown>> {
+    url: URL;
+    state: T;
+    params: Record<string, string> = {};
+
+    constructor(public router: BaseRouter, public request: Request, state?: T) {
+      this.url = new URL(request.url);
+      this.state = state ? state : ({} as T);
+    }
+  }

lib/handlers/ssr.ts

@@ -1,4 +1,4 @@
-import { RequestContext } from "../routers/httpRouter.ts";
+import { RequestContext } from "../context.ts";
 import { Crypto } from "../utils/Crypto.ts";
 import { mergeHeaders } from "../utils/helpers.ts";
 import { Handler, HandlerOptions } from "../types.ts";

lib/routers/_router.ts

@@ -1,18 +1,19 @@
-import { Handler, Middleware, RequestContext } from "../types.ts";
+import { RequestContext } from "../context.ts";
+import { Handler, Middleware } from "../types.ts";
 import { Cascade } from "../utils/Cascade.ts";
 
-export interface RouteConfig {
+export interface BaseRouteConfig {
   path: string;
   middleware?: Middleware | Middleware[];
   handler?: Handler;
 }
 
-export class Route {
+export class BaseRoute {
   path: string;
   middleware: Middleware[];
   handler?: Handler;
 
-  constructor(routeObj: RouteConfig) {
+  constructor(routeObj: BaseRouteConfig) {
     this.path = routeObj.path;
     this.handler = routeObj.handler && Cascade.promisify(routeObj.handler);
     this.middleware = [routeObj.middleware]
@@ -30,11 +31,11 @@ export class Route {
   }
 }
 
-export class Router<
-  Config extends RouteConfig = RouteConfig,
-  R extends Route = Route
+export class BaseRouter<
+  Config extends BaseRouteConfig = BaseRouteConfig,
+  R extends BaseRoute = BaseRoute
 > {
-  Route = Route;
+  Route = BaseRoute;
 
   constructor(
     public routes: R[] = [], // <- use this as a hashmap for routes
@@ -89,10 +90,10 @@ export class Router<
     const routeObj =
       typeof arg1 !== "string"
         ? arg1
-        : arguments.length === 2 
+        : arguments.length === 2
         ? arg2 instanceof Function
           ? { path: arg1, handler: arg2 as Handler }
-          : { path: arg1, ...arg2 as Omit<Config, "path"> }
+          : { path: arg1, ...(arg2 as Omit<Config, "path">) }
         : {
             path: arg1,
             middleware: arg2 as Middleware | Middleware[],

lib/routers/httpRouter.ts

@@ -1,13 +1,14 @@
-import { Middleware, Handler, RequestContext } from "../types.ts";
-import { Route, Router, RouteConfig } from "./_router.ts";
+import { RequestContext } from "../context.ts";
+import { Middleware, Handler } from "../types.ts";
+import { BaseRoute, BaseRouter, BaseRouteConfig } from "./_Router.ts";
 
-export interface HttpRouteConfig extends RouteConfig {
+export interface HttpRouteConfig extends BaseRouteConfig {
   path: `/${string}`;
   method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
   handler: Handler;
 }
 
-export class HttpRoute extends Route {
+export class HttpRoute extends BaseRoute {
   declare path: `/${string}`;
   declare method: HttpRouteConfig["method"];
 
@@ -47,13 +48,13 @@ export class HttpRoute extends Route {
   }
 }
 
-export class HttpRouter<Config extends RouteConfig = HttpRouteConfig, R extends Route = HttpRoute> extends Router<Config, R> {
+export class HttpRouter<
+  Config extends HttpRouteConfig = HttpRouteConfig,
+  R extends HttpRoute = HttpRoute
+> extends BaseRouter<Config, R> {
   Route = HttpRoute;
 
-  constructor(
-    public routes: R[] = [],
-    public middleware: Middleware[] = []
-  ) {
+  constructor(public routes: R[] = [], public middleware: Middleware[] = []) {
     super();
   }
 
@@ -85,4 +86,3 @@ export class HttpRouter<Config extends RouteConfig = HttpRouteConfig, R extends
     return newRoute;
   };
 }
-export { RequestContext };

lib/types.ts

@@ -1,15 +1,4 @@
-import { Router } from "./routers/_router.ts";
-
-export class RequestContext<T extends object = Record<string, unknown>> {
-  url: URL;
-  state: T;
-  params: Record<string, string> = {};
-
-  constructor(public router: Router, public request: Request, state?: T) {
-    this.url = new URL(request.url);
-    this.state = state ? state : ({} as T);
-  }
-}
+import { RequestContext } from "./context.ts";
 
 export type Result = void | Response | undefined;
 export type Next = () => Promise<Result> | Result;

lib/utils/CacheItem.ts

@@ -1,4 +1,4 @@
-import { RequestContext } from "../types.ts";
+import { RequestContext } from "../context.ts";
 
 export class CacheItem {
   key: string;

lib/utils/Cascade.ts

@@ -1,4 +1,5 @@
-import { RequestContext, Middleware, Result, Next, Handler } from "../types.ts";
+import { RequestContext } from "../context.ts";
+import { Middleware, Result, Next, Handler } from "../types.ts";
 
 export type PromiseHandler = (
   ctx: RequestContext,

lib/utils/Profiler.ts

@@ -1,14 +1,14 @@
-import { Router, Route } from "../routers/_router.ts";
+import { BaseRouter, BaseRoute } from "../routers/_Router.ts";
 
 type ProfileConfig = {
   mode?: "serve" | "handle";
   url?: string;
   count?: number;
-  excludedRoutes?: Route[];
+  excludedRoutes?: BaseRoute[];
 };
 
 type ProfileResults = Record<
-Route["path"],
+  BaseRoute["path"],
   {
     avgTime: number;
     requests: {
@@ -26,7 +26,7 @@ export class Profiler {
    * @param config
    * @returns results: ProfileResults
    */
-  static async run(router: Router, config?: ProfileConfig) {
+  static async run(router: BaseRouter, config?: ProfileConfig) {
     const url = (config && config.url) || `http://localhost:7777`;
     const count = (config && config.count) || 100;
     const excludedRoutes = (config && config.excludedRoutes) || [];