First build

src/server/environment.ts

@@ -1,8 +1,8 @@
-import type { Logger } from '#root/logger.js'
+import type { Logger } from "#root/logger.js";
 
 export interface Env {
   Variables: {
-    requestId: string
-    logger: Logger
-  }
+    requestId: string;
+    logger: Logger;
+  };
 }

src/server/index.ts

@@ -1,102 +1,98 @@
-import type { Bot } from '#root/bot/index.js'
-import type { Config } from '#root/config.js'
-import type { Logger } from '#root/logger.js'
-import type { Env } from '#root/server/environment.js'
-import { setLogger } from '#root/server/middlewares/logger.js'
-import { requestId } from '#root/server/middlewares/request-id.js'
-import { requestLogger } from '#root/server/middlewares/request-logger.js'
-import { serve } from '@hono/node-server'
-import { webhookCallback } from 'grammy'
-import { Hono } from 'hono'
-import { HTTPException } from 'hono/http-exception'
-import { getPath } from 'hono/utils/url'
+import type { Bot } from "#root/bot/index.js";
+import type { Config } from "#root/config.js";
+import type { Logger } from "#root/logger.js";
+import type { Env } from "#root/server/environment.js";
+import { setLogger } from "#root/server/middlewares/logger.js";
+import { requestId } from "#root/server/middlewares/request-id.js";
+import { requestLogger } from "#root/server/middlewares/request-logger.js";
+import { serve } from "@hono/node-server";
+import { webhookCallback } from "grammy";
+import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { getPath } from "hono/utils/url";
 
 interface Dependencies {
-  bot: Bot
-  config: Config
-  logger: Logger
+  bot: Bot;
+  config: Config;
+  logger: Logger;
 }
 
 export function createServer(dependencies: Dependencies) {
-  const {
-    bot,
-    config,
-    logger,
-  } = dependencies
+  const { bot, config, logger } = dependencies;
 
-  const server = new Hono<Env>()
+  const server = new Hono<Env>();
 
-  server.use(requestId())
-  server.use(setLogger(logger))
-  if (config.isDebug)
-    server.use(requestLogger())
+  server.use(requestId());
+  server.use(setLogger(logger));
+  if (config.isDebug) server.use(requestLogger());
 
   server.onError(async (error, c) => {
     if (error instanceof HTTPException) {
-      if (error.status < 500)
-        c.var.logger.info(error)
-      else
-        c.var.logger.error(error)
+      if (error.status < 500) c.var.logger.info(error);
+      else c.var.logger.error(error);
 
-      return error.getResponse()
+      return error.getResponse();
     }
 
     // unexpected error
     c.var.logger.error({
       err: error,
       method: c.req.raw.method,
-      path: getPath(c.req.raw),
-    })
+      path: getPath(c.req.raw)
+    });
     return c.json(
       {
-        error: 'Oops! Something went wrong.',
+        error: "Oops! Something went wrong."
       },
-      500,
-    )
-  })
+      500
+    );
+  });
 
-  server.get('/', c => c.json({ status: true }))
+  server.get("/", c => c.json({ status: true }));
 
   if (config.isWebhookMode) {
     server.post(
-      '/webhook',
-      webhookCallback(bot, 'hono', {
-        secretToken: config.botWebhookSecret,
-      }),
-    )
+      "/webhook",
+      webhookCallback(bot, "hono", {
+        secretToken: config.botWebhookSecret
+      })
+    );
   }
 
-  return server
+  return server;
 }
 
-export type Server = Awaited<ReturnType<typeof createServer>>
+export type Server = Awaited<ReturnType<typeof createServer>>;
 
-export function createServerManager(server: Server, options: { host: string, port: number }) {
-  let handle: undefined | ReturnType<typeof serve>
+export function createServerManager(
+  server: Server,
+  options: { host: string; port: number }
+) {
+  let handle: undefined | ReturnType<typeof serve>;
   return {
     start() {
-      return new Promise<{ url: string }>((resolve) => {
+      return new Promise<{ url: string }>(resolve => {
         handle = serve(
           {
             fetch: server.fetch,
             hostname: options.host,
-            port: options.port,
+            port: options.port
           },
-          info => resolve({
-            url: info.family === 'IPv6'
-              ? `http://[${info.address}]:${info.port}`
-              : `http://${info.address}:${info.port}`,
-          }),
-        )
-      })
+          info =>
+            resolve({
+              url:
+                info.family === "IPv6"
+                  ? `http://[${info.address}]:${info.port}`
+                  : `http://${info.address}:${info.port}`
+            })
+        );
+      });
     },
     stop() {
-      return new Promise<void>((resolve) => {
-        if (handle)
-          handle.close(() => resolve())
-        else
-          resolve()
-      })
-    },
-  }
+      return new Promise<void>(resolve => {
+        if (handle) handle.close(() => resolve());
+        else resolve();
+      });
+    }
+  };
 }

src/server/middlewares/logger.ts

@@ -1,15 +1,15 @@
-import type { Logger } from '#root/logger.js'
-import type { MiddlewareHandler } from 'hono'
+import type { Logger } from "#root/logger.js";
+import type { MiddlewareHandler } from "hono";
 
 export function setLogger(logger: Logger): MiddlewareHandler {
   return async (c, next) => {
     c.set(
-      'logger',
+      "logger",
       logger.child({
-        requestId: c.get('requestId'),
-      }),
-    )
+        requestId: c.get("requestId")
+      })
+    );
 
-    await next()
-  }
+    await next();
+  };
 }

src/server/middlewares/request-id.ts

@@ -1,10 +1,10 @@
-import type { MiddlewareHandler } from 'hono'
-import { randomUUID } from 'node:crypto'
+import type { MiddlewareHandler } from "hono";
+import { randomUUID } from "node:crypto";
 
 export function requestId(): MiddlewareHandler {
   return async (c, next) => {
-    c.set('requestId', randomUUID())
+    c.set("requestId", randomUUID());
 
-    await next()
-  }
+    await next();
+  };
 }

src/server/middlewares/request-logger.ts

@@ -1,27 +1,27 @@
-import type { MiddlewareHandler } from 'hono'
-import { getPath } from 'hono/utils/url'
+import type { MiddlewareHandler } from "hono";
+import { getPath } from "hono/utils/url";
 
 export function requestLogger(): MiddlewareHandler {
   return async (c, next) => {
-    const { method } = c.req
-    const path = getPath(c.req.raw)
+    const { method } = c.req;
+    const path = getPath(c.req.raw);
 
     c.var.logger.debug({
-      msg: 'Incoming request',
+      msg: "Incoming request",
       method,
-      path,
-    })
-    const startTime = performance.now()
+      path
+    });
+    const startTime = performance.now();
 
-    await next()
+    await next();
 
-    const endTime = performance.now()
+    const endTime = performance.now();
     c.var.logger.debug({
-      msg: 'Request completed',
+      msg: "Request completed",
       method,
       path,
       status: c.res.status,
-      elapsed: endTime - startTime,
-    })
-  }
+      elapsed: endTime - startTime
+    });
+  };
 }