Merge pull request #175 from sejori/params

feat: /added/:params/to/routes

lib/Server.ts

@@ -1,30 +1,46 @@
 import { Server as stdServer } from "https://deno.land/[email protected]/http/server.ts"
-import { Router } from "./utils/Router.ts"
+import { Router, _Route } from "./utils/Router.ts"
 import { Cascade, PromiseMiddleware } from "./utils/Cascade.ts"
-import { Middleware, Route } from "./types.ts"
+import { Middleware } from "./types.ts"
 
 export class RequestContext {
-  server: Server
-  request: Request
+  url: URL
+  _route: _Route | undefined
   state: Record<string, unknown>
+  params: Record<string, unknown> = {}
 
-  constructor(server: Server, request: Request, state?: Record<string, unknown>) {
-    this.server = server
-    this.request = request
-    this.state = state
-      ? state 
-      : {}
+  constructor(
+    public server: Server, 
+    public request: Request, 
+    state?: Record<string, unknown>
+  ) {
+    this.url = new URL(request.url)
+    this.state = state ? state : {}
+  }
+
+  get route () {
+    return this._route
+  }
+
+  set route (r: _Route | undefined) {
+    this._route = r;
+    if (r?.params) {
+      const pathBits = this.url.pathname.split("/")
+      for (const param in r.params) {
+        this.params[param] = pathBits[r.params[param]]
+      }
+    }
   }
 }
 
 export class Server extends Router {
   stdServer: stdServer | undefined
   port = 7777
-  hostname = "0.0.0.0"
+  hostname = "127.0.0.1"
   middleware: PromiseMiddleware[] = []
   routers: Router[] = [] 
 
-  public get allRoutes(): Route[] {
+  public get allRoutes(): _Route[] {
     return [ this, ...this.routers].map(router => router.routes).flat()
   }
 
@@ -93,14 +109,13 @@ export class Server extends Router {
    */
   async requestHandler(request: Request): Promise<Response> {
     const ctx: RequestContext = new RequestContext(this, request)
-    const requestURL = new URL(ctx.request.url)
 
-    const route = this.allRoutes.find(route => 
-      route.path === requestURL.pathname && 
+    ctx.route = this.allRoutes.find(route => 
+      route.regexPath.test(ctx.url.pathname) && 
       route.method === request.method
     )
-    
-    return await new Cascade(ctx, route).start()
+
+    return await new Cascade(ctx).start()
   }
 
   /**

lib/utils/Cascade.ts

@@ -1,5 +1,5 @@
 import { RequestContext } from "../Server.ts"
-import { Middleware, Result, Next, Route } from "../types.ts"
+import { Middleware, Result, Next } from "../types.ts"
 
 export type PromiseMiddleware = (ctx: RequestContext, next: Next) => Promise<Result>
 
@@ -11,9 +11,9 @@ export class Cascade {
   called = 0
   toCall: PromiseMiddleware[]
 
-  constructor(public ctx: RequestContext, private route?: Route) {
-    this.toCall = this.route
-      ? [...this.ctx.server.middleware, ...this.route.middleware as PromiseMiddleware[], this.route.handler as PromiseMiddleware]
+  constructor(public ctx: RequestContext) {
+    this.toCall = this.ctx.route
+      ? [...this.ctx.server.middleware, ...this.ctx.route.middleware as PromiseMiddleware[], this.ctx.route.handler as PromiseMiddleware]
       : [...this.ctx.server.middleware]
   }
 

lib/utils/Router.ts

@@ -1,8 +1,37 @@
 import { Middleware, Handler, Route } from "../types.ts"
 import { Cascade } from "./Cascade.ts"
 
+export class _Route implements Route {
+  path: `/${string}`
+  params: Record<string, number> = {}
+  regexPath: RegExp
+  method?: "GET" | "POST" | "PUT" | "DELETE"
+  middleware?: Middleware[] | Middleware
+  handler: Handler
+
+  constructor(routeObj: Route) {
+    if (!routeObj.path) throw new Error("Route is missing path")
+    if (!routeObj.handler) throw new Error("Route is missing handler")
+
+    this.path = routeObj.path
+    this.path.split("/").forEach((str, i) => {
+      if (str[0] === ":") this.params[str.slice(1)] = i
+    });
+    this.regexPath = this.params 
+      ? new RegExp(this.path.replaceAll(/(?<=\/):(.)*?(?=\/|$)/g, "(.)*"))
+      : new RegExp(this.path)
+
+    this.method = routeObj.method || "GET"
+    this.handler = Cascade.promisify(routeObj.handler!) as Handler
+    this.middleware = [routeObj.middleware]
+      .flat()
+      .filter(Boolean)
+      .map((mware) => Cascade.promisify(mware!))
+  }
+}
+
 export class Router {
-  constructor(public routes: Route[] = []) {}
+  constructor(public routes: _Route[] = []) {}
 
   static applyDefaults(routeObj: Partial<Route>): Route {
     if (!routeObj.path) throw new Error("Route is missing path")
@@ -11,9 +40,9 @@ export class Router {
     routeObj.method = routeObj.method || "GET"
     routeObj.handler = Cascade.promisify(routeObj.handler!) as Handler
     routeObj.middleware = [routeObj.middleware]
-        .flat()
-        .filter(Boolean)
-        .map((mware) => Cascade.promisify(mware!))
+      .flat()
+      .filter(Boolean)
+      .map((mware) => Cascade.promisify(mware!))
 
     return routeObj as Route
   }
@@ -45,7 +74,7 @@ export class Router {
       throw new Error(`Route with path ${routeObj.path} already exists!`)
     }
 
-    const fullRoute = Router.applyDefaults(routeObj)
+    const fullRoute = new _Route(routeObj as Route)
     this.routes.push(fullRoute)
 
     return fullRoute

tests/server_test.ts

@@ -85,4 +85,16 @@ Deno.test("SERVER", async (t) => {
 
     assert(body["middleware1"] && body["middleware2"] && body["middleware3"])
   })
+
+  await t.step("params discovered in RequestContext creation", async () => {
+    const newServer = new Server();
+
+    newServer.addRoute("/hello/:id/world/:name", (ctx) => {
+      return new Response(JSON.stringify({ id: ctx.params["id"], name: ctx.params["name"] }))
+    })
+
+    const res = await newServer.requestHandler(new Request("http://localhost:7777/hello/123/world/bruno"))
+    const json = await res.json()
+    assert(json.id === "123" && json.name === "bruno")
+  })
 })

tests/utils/Cascade_test.ts

@@ -1,6 +1,7 @@
 import { assert } from "https://deno.land/[email protected]/testing/asserts.ts"
 import { Server, RequestContext } from "../../lib/Server.ts"
 import { Cascade } from "../../lib/utils/Cascade.ts"
+import { _Route } from "../../lib/utils/Router.ts"
 import { 
   testMiddleware1,
   testMiddleware2,
@@ -11,8 +12,7 @@ import {
 Deno.test("UTIL: Cascade", async (t) => {
   const testServer = new Server()
   const testContext = new RequestContext(testServer, new Request("http://localhost"))
-
-  const cascade = new Cascade(testContext, {
+  testContext._route = new _Route({
     path: "/",
     middleware: [
       testMiddleware1,
@@ -22,6 +22,8 @@ Deno.test("UTIL: Cascade", async (t) => {
     ],
     handler: testHandler
   })
+
+  const cascade = new Cascade(testContext)
 
   const result = await cascade.start()
 

tests/utils/Router_test.ts

@@ -30,7 +30,8 @@ Deno.test("ROUTER", async (t) => {
   await t.step ("routers on server can be subsequently editted", () => {
     const server = new Server()
 
-    const aRouter = new Router([
+    const aRouter = new Router()
+    aRouter.addRoutes([
       { path: "/route", handler: testHandler },
       { path: "/route2", handler: testHandler },
       { path: "/route3", handler: testHandler }
@@ -70,4 +71,12 @@ Deno.test("ROUTER", async (t) => {
     assert(putRoute.method === "PUT")
     assert(deleteRoute.method === "DELETE")
   })
+
+  await t.step("Params correctly stored", () => {
+    const router = new Router()
+    router.addRoute("/hello/:id/world/:name", () => new Response("Hi!"))
+
+    assert(router.routes[0].params["id"] === 2)
+    assert(router.routes[0].params["name"] === 4)
+  })
 })