refactor: use hono instead of manual request handling

Author: shiftinv

deno.json

@@ -12,10 +12,10 @@
         }
     },
     "imports": {
+        "@hono/hono": "jsr:@hono/hono@^4.6.13",
         "@lambdalisue/github-emoji": "jsr:@lambdalisue/github-emoji@^1.0.0",
         "@std/encoding": "jsr:@std/encoding@^1.0.5",
-        "@std/log": "jsr:@std/log@^0.224.11",
-        "x/http_errors": "https://deno.land/x/[email protected]/mod.ts"
+        "@std/log": "jsr:@std/log@^0.224.11"
     },
     "unstable": [
         "kv"

deno.lock

@@ -3,12 +3,12 @@ import { UrlConfig } from "./types.d.ts";
 import { requestLog, wildcardMatch } from "./util.ts";
 
 export default async function filter(
-    headers: Headers,
+    headers: Record<string, string>,
     json: any,
     config: UrlConfig,
 ): Promise<string | null> {
     const reqLog = requestLog(headers);
-    const event = headers.get("x-github-event") || "unknown";
+    const event = headers["x-github-event"] || "unknown";
     const login: string | undefined = json.sender?.login?.toLowerCase();
 
     // ignore events that Discord won't render anyway

src/filter.ts

@@ -1,63 +1,40 @@
-import * as httpErrors from "x/http_errors";
+import { HTTPException } from "@hono/hono/http-exception";
 
-import config from "./config.ts";
-import { hasKey, verify } from "./crypto.ts";
 import filterWebhook from "./filter.ts";
 import fixupEmbeds from "./formatter.ts";
 import { UrlConfig } from "./types.d.ts";
 import { parseBool, requestLog } from "./util.ts";
 import { sendWebhook } from "./webhook.ts";
 
 export default async function handle(
-    req: Request,
-): Promise<Response | [Response, Record<string, string>]> {
-    const url = new URL(req.url);
-
-    // redirect to repo if `GET /`
-    if (req.method === "GET" && config.mainRedirect && url.pathname === "/") {
-        return Response.redirect(config.mainRedirect);
-    }
-
-    // everything else should be a POST
-    if (req.method !== "POST") {
-        throw httpErrors.createError(405);
-    }
-
-    // split url into parts
-    const [, id, token] = url.pathname.split("/");
-    if (!id || !token) {
-        throw httpErrors.createError(400);
-    }
-
-    // verify signature
-    if (hasKey) {
-        const signature = url.searchParams.get("sig");
-        if (!signature) throw httpErrors.createError(400);
-        if (!(await verify(`${id}/${token}`, signature))) throw httpErrors.createError(403);
-    }
-
-    // extract data
-    const urlConfig = getUrlConfig(url.searchParams);
-    const data = await req.text();
-    const json: Record<string, any> = JSON.parse(data);
+    json: Record<string, any>,
+    headers: Record<string, string>,
+    queryParams: Record<string, string>,
+    id: string,
+    token: string,
+): Promise<[Response, Record<string, string>]> {
+    const urlConfig = getUrlConfig(queryParams);
 
     // do the thing
-    const filterReason = await filterWebhook(req.headers, json, urlConfig);
+    const filterReason = await filterWebhook(headers, json, urlConfig);
     if (filterReason !== null) {
-        const reqLog = requestLog(req.headers);
+        const reqLog = requestLog(headers);
         reqLog.debug(`handler: ignored due to '${filterReason}'`);
-        return new Response(`Ignored by webhook filter (reason: ${filterReason})`, { status: 203 });
+        return [
+            new Response(`Ignored by webhook filter (reason: ${filterReason})`, { status: 203 }),
+            {},
+        ];
     }
 
     // mutate `json` in-place (fixing codeblocks etc.)
     fixupEmbeds(json);
 
-    return await sendWebhook(id, token, req.headers, json);
+    return await sendWebhook(id, token, headers, json);
 }
 
-function getUrlConfig(params: URLSearchParams): UrlConfig {
+function getUrlConfig(params: Record<string, string>): UrlConfig {
     const config: UrlConfig = {};
-    for (const [key, value] of params) {
+    for (const [key, value] of Object.entries(params)) {
         switch (key) {
             case "sig":
                 continue;
@@ -71,7 +48,7 @@ function getUrlConfig(params: URLSearchParams): UrlConfig {
                 config.commentBurstLimit = parseInt(value);
                 break;
             default:
-                throw httpErrors.createError(418, `Unknown config option: ${key}`);
+                throw new HTTPException(418, { message: `Unknown config option: ${key}` });
         }
     }
     return config;

src/handler.ts

@@ -1,9 +1,11 @@
+import { Hono } from "@hono/hono";
+import { HTTPException } from "@hono/hono/http-exception";
+import { logger } from "@hono/hono/logger";
 import * as log from "@std/log";
-import * as httpErrors from "x/http_errors";
 
 import config from "./config.ts";
+import { hasKey, verify } from "./crypto.ts";
 import handler from "./handler.ts";
-import { requestLog } from "./util.ts";
 
 function setupLogs() {
     log.setup({
@@ -21,28 +23,30 @@ function setupLogs() {
     });
 }
 
-async function handleRequest(req: Request, info: Deno.ServeHandlerInfo): Promise<Response> {
-    const reqLog = requestLog(req.headers);
+const app = new Hono();
 
-    let res: Response;
-    let meta: Record<string, string> | null = null;
-    try {
-        const webhookResult = await handler(req);
-        if (webhookResult instanceof Response) {
-            res = webhookResult;
-        } else {
-            [res, meta] = webhookResult;
-        }
-    } catch (err) {
-        if (err instanceof httpErrors.HttpError && err.expose) {
-            reqLog.warn(`http error: ${err.message}`);
-            res = new Response(err.message, { status: err.status });
-        } else {
-            reqLog.critical(err);
-            res = new Response("Internal Server Error", { status: 500 });
+app.use(logger());
+
+if (config.mainRedirect) {
+    app.get("/", (c) => {
+        return c.redirect(config.mainRedirect!);
+    });
+}
+
+app.post("/:id/:token", async (c) => {
+    const { id, token } = c.req.param();
+
+    // verify signature
+    if (hasKey) {
+        const signature = c.req.query("sig");
+        if (!signature || !(await verify(`${id}/${token}`, signature))) {
+            throw new HTTPException(403);
         }
     }
 
+    const data = await c.req.json();
+    let [res, meta] = await handler(data, c.req.header(), c.req.query(), id, token);
+
     // clone response to make headers mutable
     res = new Response(res.body, res);
 
@@ -60,15 +64,8 @@ async function handleRequest(req: Request, info: Deno.ServeHandlerInfo): Promise
         res.headers.delete(header);
     }
 
-    // log request
-    const respLen = res.headers.get("content-length") || 0;
-    const addr = info.remoteAddr;
-    reqLog.info(
-        `http: ${addr.hostname}:${addr.port} - ${req.method} ${req.url} ${res.status} ${respLen}`,
-    );
-
     return res;
-}
+});
 
 if (import.meta.main) {
     setupLogs();
@@ -77,10 +74,12 @@ if (import.meta.main) {
         log.info("url signing enabled");
     }
 
-    log.info(`starting webserver on ${config.hostname}:${config.port}`);
-    Deno.serve({
-        hostname: config.hostname,
-        port: config.port,
-        onListen: () => log.info(`listening on ${config.hostname}:${config.port}`),
-    }, handleRequest);
+    Deno.serve(
+        {
+            hostname: config.hostname,
+            port: config.port,
+            onListen: () => log.info(`listening on ${config.hostname}:${config.port}`),
+        },
+        app.fetch,
+    );
 }

src/main.ts

@@ -33,8 +33,8 @@ export function wildcardMatch(pattern: string, target: string): boolean {
 /**
  * logging proxy that adds some metadata to log messages
  */
-export function requestLog(headers: Headers) {
-    const deliveryId = headers.get("x-github-delivery");
+export function requestLog(headers: Record<string, string>) {
+    const deliveryId = headers["x-github-delivery"];
     const prefix = deliveryId ? `[${deliveryId}] ` : "";
 
     // ugh

src/util.ts

@@ -4,7 +4,7 @@ import { requestLog, sleep } from "./util.ts";
 export async function sendWebhook(
     id: string,
     token: string,
-    headers: Headers,
+    headers: Record<string, string>,
     data: Record<string, any>,
 ): Promise<[Response, Record<string, string>]> {
     const reqLog = requestLog(headers);