Teach handler to accept various methods

deno/app.ts

@@ -1,39 +1,75 @@
 import { services } from "./services.ts";
 import {
     DenoRequest,
-    massageMethod,DenoResponse,
+    DenoResponse,
+    InternalHandler,
+    massageMethod,
     Method,
     ProcessedRoute,
-    Request,
+    Request as Request,
     Route,
 } from "./types.ts";
 
 import { routes } from "./routes.ts";
 
 services.logging.log({ source: "logging", text: ["1"] });
-const processedRoutes: ProcessedRoute[] = routes.map(
+const processedRoutes: { [K in Method]: ProcessedRoute[] } = {
+    "GET": [],
+    "POST": [],
+    "PUT": [],
+    "PATCH": [],
+    "DELETE": [],
+};
+
+function isPromise<T>(value: T | Promise<T>): value is Promise<T> {
+    return typeof (value as any)?.then === "function";
+}
+
+routes.forEach(
     (route: Route, _idx: number, _allRoutes: Route[]) => {
         const pattern: URLPattern = new URLPattern({ pathname: route.path });
-        const method: Method = route.method;
-        const handler = async (denoRequest: DenoRequest) => {
+        const methodList = route.methods;
+
+        const handler: InternalHandler = async (denoRequest: DenoRequest) => {
+            const method = massageMethod(denoRequest.method);
+
+            if (!methodList.includes(method)) {
+                // XXX: Worth asserting this?
+            }
+
+            const p = new URL(denoRequest.url);
+            const path = p.pathname;
+
             const req: Request = {
-                pattern: route.pattern,
-                path: denoRequest.path,
-                method: massageMethod(denoRequest.method),
+                pattern: route.path,
+                path,
+                method,
                 parameters: { one: 1, two: 2 },
                 denoRequest,
             };
-            return route.handler(req);
+
+            const retval = route.handler(req);
+            if (isPromise(retval)) {
+                return await retval;
+            } else {
+                return retval;
+            }
         };
 
-        const retval: ProcessedRoute = { pattern, method, handler };
+        for (const [_idx, method] of methodList.entries()) {
+            const pr: ProcessedRoute = { pattern, method, handler };
 
-        return retval;
+            processedRoutes[method].push(pr);
+        }
     },
 );
 
 async function handler(req: DenoRequest): Promise<DenoResponse> {
-    for (const [idx, pr] of processedRoutes.entries()) {
+    const m = req.method;
+    const m1 = massageMethod(m);
+
+    const byMethod = processedRoutes[m1];
+    for (const [_idx, pr] of byMethod.entries()) {
         const match = pr.pattern.exec(req.url);
         if (match) {
             const resp = await pr.handler(req);

deno/routes.ts

@@ -16,15 +16,6 @@ import {
     UserRequest,
 } from "./types.ts";
 
-const phandler: Handler = async (_req: Request) => {
-    const code = httpCodes.success.OK;
-    return {
-        code,
-        result: "it is ok ",
-        contentType: contentTypes.text.plain,
-    };
-};
-
 // FIXME: Obviously put this somewhere else
 const okText = (out: string) => {
     const code = httpCodes.success.OK;
@@ -39,18 +30,18 @@ const okText = (out: string) => {
 const routes: Route[] = [
     {
         path: "/slow",
-        methods: ["get"],
-        handler: async (_req) => {
+        methods: ["GET"],
+        handler: async (_req: Request) => {
             console.log("starting slow request");
-            await sleep(10);
+            await sleep(2);
             console.log("finishing slow request");
             return okText("that was slow");
         },
     },
     {
         path: "/list",
-        methods: ["get"],
-        handler: async (_req) => {
+        methods: ["GET"],
+        handler: (_req: Request) => {
             const code = httpCodes.success.OK;
             const lr = (rr: Route[]) => {
                 const ret = rr.map((r: Route) => {
@@ -70,22 +61,22 @@ const routes: Route[] = [
     },
     {
         path: "/ok",
-        methods: ["get"],
-        handler: async (_req) => {
+        methods: ["GET", "POST", "PUT"],
+        handler: (req: Request) => {
             const code = httpCodes.success.OK;
             const rn = services.random.randomNumber();
 
             return {
                 code,
-                result: "it is ok " + rn,
+                result: `that was ${req.method} (${rn})`,
                 contentType: contentTypes.text.plain,
             };
         },
     },
     {
         path: "/alsook",
-        methods: ["get"],
-        handler: async (_req) => {
+        methods: ["GET"],
+        handler: (_req) => {
             const code = httpCodes.success.OK;
             return {
                 code,

deno/services.ts

@@ -4,7 +4,6 @@ import { randomNumber } from "https://deno.land/x/random_number/mod.ts";
 import { config } from "./config.ts";
 import { getLogs, log } from "./logging.ts";
 
-
 //const database = Client({
 
 //})

deno/types.ts

@@ -18,7 +18,7 @@ const methodParser = z.union([
 export type Method = z.infer<typeof methodParser>;
 
 const massageMethod = (input: string): Method => {
-    const r = methodParser.parse(input.toUpperCase())
+    const r = methodParser.parse(input.toUpperCase());
 
     return r;
 };
@@ -33,10 +33,14 @@ export type Request = {
     parameters: object;
     denoRequest: globalThis.Request;
 };
+
+export type InternalHandler = (req: DenoRequest) => Promise<Response>;
+
+export type Handler = (req: Request) => Promise<Response> | Response;
 export type ProcessedRoute = {
     pattern: URLPattern;
     method: Method;
-    handler: Handler;
+    handler: InternalHandler;
 };
 
 export type Response = {
@@ -45,8 +49,6 @@ export type Response = {
     result: string;
 };
 
-export type Handler = (req: Request) => Promise<Response>;
-
 export type Route = {
     path: string;
     methods: Method[];