replace express with hono

Author: canbax

api/index.ts

@@ -1,53 +1,26 @@
-import express, {
-  Express,
-  Request,
-  Response,
-  NextFunction,
-  RequestHandler,
-} from "express";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
 import { ALL_PLACES } from "../data/geoData.js";
 import { getPlace, findPlace, getTimes } from "../api_src/calculator.js";
 import {
   getCommonTimeRequestParameters,
   getParamsForPlaceSearch,
   isInRange,
 } from "../api_src/util.js";
+import { getPlaceSuggestionsByText, getNearbyPlaces, getPlaceById } from "irem";
+
 import path from "path";
 import { fileURLToPath } from "url";
 import { dirname } from "path";
-import { getPlaceSuggestionsByText, getNearbyPlaces, getPlaceById } from "irem";
-
-export const app: Express = express();
+import { Context } from "hono";
 
-/** use this function like `app.use(allowOriginForAll);` for an express app
- * Make API accessible for all clients. Not for only clients from a specific domain.
- */
-const allowOriginForAll: RequestHandler = (
-  _: Request,
-  res: Response,
-  next: NextFunction,
-) => {
-  res.setHeader("Access-Control-Allow-Credentials", "true");
-  res.setHeader("Access-Control-Allow-Origin", "*");
-  // another common pattern
-  // res.setHeader('Access-Control-Allow-Origin', req.headers.origin);
-  res.setHeader(
-    "Access-Control-Allow-Methods",
-    "GET,OPTIONS,PATCH,DELETE,POST,PUT",
-  );
-  res.setHeader(
-    "Access-Control-Allow-Headers",
-    "X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version",
-  );
-  next();
-};
+const app = new Hono();
 
-app.use(allowOriginForAll);
-app.use(express.static("public"));
-app.use(logIPAdress);
+// Middleware
+app.use("*", cors());
 
 app.get("/api/searchPlaces", searchPlaces);
-app.get("/api/nearbyPlaces", nearByPlaces);
+app.get("/api/nearByPlaces", nearByPlaces);
 app.get("/api/timesForGPS", getTimesForGPS);
 app.get("/api/timesForPlace", getTimesForPlace);
 app.get("/api/timesFromCoordinates", getTimesFromCoordinates);
@@ -71,120 +44,137 @@ app.post("/api/ip", getIPAdress);
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // if not starting with "/api" return index.html page as response so that routes in the static page will work
-app.get(/^\/(?!api).*/, (_, res) => {
-  res.sendFile(path.resolve(__dirname, "..", "public", "index.html"));
+app.get("*", async (c) => {
+  const url = new URL(c.req.url);
+  if (!url.pathname.startsWith("/api")) {
+    const fs = await import("fs/promises");
+    try {
+      const content = await fs.readFile(
+        path.resolve(__dirname, "..", "public", "index.html"),
+        "utf-8",
+      );
+      return c.html(content);
+    } catch {
+      return c.text("index.html not found", 404);
+    }
+  }
+  return c.text("index.html not found", 404);
 });
 
-const PORT = process.env["PORT"] || 3000;
-export const httpServer = app.listen(PORT);
+// For compatibility with some localdev setups, but purely optional for Hono + Workers
+if (
+  process.env["NODE_ENV"] !== "production" &&
+  !process.env["Generic_Worker"]
+) {
+  // try to serve with @hono/node-server if installed, or just log
+  console.log(
+    `To run locally, use 'npm run dev' which uses nodemon/tsx. For production use 'wrangler dev'`,
+  );
+}
 
 /** get a list of countries
- * @param  {} _
- * @param  {} res
  */
-function getCountries(_: Request, res: Response) {
+function getCountries(c: Context) {
   try {
     const r = [];
-    for (const c in ALL_PLACES) {
-      r.push({ code: ALL_PLACES[c].code, name: c });
+    for (const place in ALL_PLACES) {
+      r.push({ code: ALL_PLACES[place].code, name: place });
     }
-    res.send(r.sort((a, b) => a.name.localeCompare(b.name)));
+    return c.json(r.sort((a, b) => a.name.localeCompare(b.name)));
   } catch (e) {
     console.log("error! ", e);
-    res.send("error: " + e);
-  } finally {
-    res.send("error: ");
+    return c.json({ error: String(e) });
   }
 }
 
-function getRegionsOfCountry(req: Request, res: Response) {
-  const country = req.query["country"] as string;
+function getRegionsOfCountry(c: Context) {
+  const country = c.req.query("country") as string;
   if (ALL_PLACES[country]) {
-    res.send(
+    return c.json(
       Object.keys(ALL_PLACES[country].regions).sort((a, b) =>
         a.localeCompare(b),
       ),
     );
   } else {
-    res.send({ error: "NOT FOUND!" });
+    return c.json({ error: "NOT FOUND!" });
   }
 }
 
-function getCitiesOfRegion(req: Request, res: Response) {
-  const country = req.query["country"] as string;
-  const region = req.query["region"] as string;
+function getCitiesOfRegion(c: Context) {
+  const country = c.req.query("country") as string;
+  const region = c.req.query("region") as string;
   if (ALL_PLACES[country] && ALL_PLACES[country].regions[region]) {
-    res.send(
+    return c.json(
       Object.keys(ALL_PLACES[country].regions[region]).sort((a, b) =>
         a.localeCompare(b),
       ),
     );
   } else {
-    res.send({ error: "NOT FOUND!" });
+    return c.json({ error: "NOT FOUND!" });
   }
 }
 
-function getCoordinateData(req: Request, res: Response) {
-  const country = req.query["country"] as string;
-  const region = req.query["region"] as string;
-  const city = req.query["city"] as string;
+function getCoordinateData(c: Context) {
+  const country = c.req.query("country") as string;
+  const region = c.req.query("region") as string;
+  const city = c.req.query("city") as string;
   const coords = getPlace(country, region, city);
   if (coords) {
-    res.send(coords);
+    return c.json(coords);
   } else {
-    res.send({ error: "NOT FOUND!" });
+    return c.json({ error: "NOT FOUND!" });
   }
 }
 
 /**
  * DEPRECATED, use `getTimesForGPS`
  */
-function getTimesFromCoordinates(req: Request, res: Response) {
-  const lat = Number(req.query["lat"] as string);
-  const lng = Number(req.query["lng"] as string);
+function getTimesFromCoordinates(c: Context) {
+  const lat = Number(c.req.query("lat") as string);
+  const lng = Number(c.req.query("lng") as string);
   const { date, days, tzOffset, calculateMethod } =
-    getCommonTimeRequestParameters(req);
+    getCommonTimeRequestParameters(c);
   if (
     isNaN(lat) ||
     isNaN(lng) ||
     !isInRange(lat, -90, 90) ||
     !isInRange(lng, -180, 180)
   ) {
-    res.send({ error: "Invalid coordinates!" });
+    return c.json({ error: "Invalid coordinates!" });
   } else if (days > 1000) {
-    res.send({ error: "days can be maximum 1000!" });
+    return c.json({ error: "days can be maximum 1000!" });
   } else {
     const place = findPlace(lat, lng);
     const times = getTimes(lat, lng, date, days, tzOffset, calculateMethod);
-    res.send({ place, times });
+    return c.json({ place, times });
   }
 }
 
-async function getTimesForGPS(req: Request, res: Response) {
-  const { lat, lng, lang } = getParamsForPlaceSearch(req);
+async function getTimesForGPS(c: Context) {
+  const { lat, lng, lang } = getParamsForPlaceSearch(c);
   const { date, days, tzOffset, calculateMethod } =
-    getCommonTimeRequestParameters(req);
+    getCommonTimeRequestParameters(c);
   if (
     isNaN(lat) ||
     isNaN(lng) ||
     !isInRange(lat, -90, 90) ||
     !isInRange(lng, -180, 180)
   ) {
-    res.send({ error: "Invalid coordinates!" });
+    return c.json({ error: "Invalid coordinates!" });
   } else if (days > 1000) {
-    res.send({ error: "days can be maximum 1000!" });
+    return c.json({ error: "days can be maximum 1000!" });
   } else {
     const [place] = await getNearbyPlaces(lat, lng, lang, 1);
     const times = getTimes(lat, lng, date, days, tzOffset, calculateMethod);
-    res.send({ place, times });
+    return c.json({ place, times });
   }
 }
 
-async function searchPlaces(req: Request, res: Response) {
-  const q = (req.query["q"] ?? "") as string;
+async function searchPlaces(c: Context) {
+  const q = (c.req.query("q") ?? "") as string;
   const { lat, lng, lang, resultCount, countryCode } =
-    getParamsForPlaceSearch(req);
-  res.send(
+    getParamsForPlaceSearch(c);
+  return c.json(
     await getPlaceSuggestionsByText(
       q,
       lang,
@@ -196,88 +186,88 @@ async function searchPlaces(req: Request, res: Response) {
   );
 }
 
-async function nearByPlaces(req: Request, res: Response) {
-  const { lat, lng, lang, resultCount } = getParamsForPlaceSearch(req);
-
-  res.send(await getNearbyPlaces(lat, lng, lang, resultCount));
+async function nearByPlaces(c: Context) {
+  try {
+    const { lat, lng, lang, resultCount } = getParamsForPlaceSearch(c);
+    const places = await getNearbyPlaces(lat, lng, lang, resultCount);
+    return c.json(places);
+  } catch (e) {
+    console.error("nearByPlaces error:", e);
+    return c.json({ error: String(e) }, 500);
+  }
 }
 
-function getPlaceData(req: Request, res: Response) {
-  const lat = Number(req.query["lat"] as string);
-  const lng = Number(req.query["lng"] as string);
+function getPlaceData(c: Context) {
+  const lat = Number(c.req.query("lat") as string);
+  const lng = Number(c.req.query("lng") as string);
   if (lat === undefined || lng === undefined || isNaN(lat) || isNaN(lng)) {
-    res.send({ error: "INVALID coordinates!" });
+    return c.json({ error: "INVALID coordinates!" });
   } else {
-    res.send(findPlace(lat, lng));
+    return c.json(findPlace(lat, lng));
   }
 }
 
-async function getTimesForPlace(req: Request, res: Response) {
-  const placeId = Number(req.query["id"]);
+async function getTimesForPlace(c: Context) {
+  const placeId = Number(c.req.query("id"));
   if (Number.isNaN(placeId)) {
-    res.send({ error: "Id should be a positive integer!" });
-    return;
+    return c.json({ error: "Id should be a positive integer!" });
   }
   const { date, days, tzOffset, calculateMethod } =
-    getCommonTimeRequestParameters(req);
-  const { lang } = getParamsForPlaceSearch(req);
+    getCommonTimeRequestParameters(c);
+  const { lang } = getParamsForPlaceSearch(c);
   const place = await getPlaceById(placeId, lang);
 
   if (!place) {
-    res.send({ error: "Place cannot be found!" });
+    return c.json({ error: "Place cannot be found!" });
   } else if (days > 1000) {
-    res.send({ error: "days can be maximum 1000!" });
+    return c.json({ error: "days can be maximum 1000!" });
   } else {
     const lat = place.latitude;
     const lng = place.longitude;
     const times = getTimes(lat, lng, date, days, tzOffset, calculateMethod);
-    res.send({ place, times });
+    return c.json({ place, times });
   }
 }
 
-async function placeById(req: Request, res: Response) {
-  const placeId = Number(req.query["id"]);
+async function placeById(c: Context) {
+  const placeId = Number(c.req.query("id"));
   if (Number.isNaN(placeId)) {
-    res.send({ error: "Id should be a positive integer!" });
-    return;
+    return c.json({ error: "Id should be a positive integer!" });
   }
-  const { lang } = getParamsForPlaceSearch(req);
+  const { lang } = getParamsForPlaceSearch(c);
   const place = await getPlaceById(placeId, lang);
 
   if (!place) {
-    res.send({ error: "Place cannot be found!" });
+    return c.json({ error: "Place cannot be found!" });
   } else {
-    res.send({ ...place });
+    return c.json({ ...place });
   }
 }
 
 /**
  * DEPRECATED, use `getTimesForPlace`
  */
-function getTimesFromPlace(req: Request, res: Response) {
-  const country = req.query["country"] as string;
-  const region = req.query["region"] as string;
-  const city = req.query["city"] as string;
+function getTimesFromPlace(c: Context) {
+  const country = c.req.query("country") as string;
+  const region = c.req.query("region") as string;
+  const city = c.req.query("city") as string;
   const place = getPlace(country, region, city);
   const { date, days, tzOffset, calculateMethod } =
-    getCommonTimeRequestParameters(req);
+    getCommonTimeRequestParameters(c);
   if (!place) {
-    res.send({ error: "Place cannot be found!" });
+    return c.json({ error: "Place cannot be found!" });
   } else if (days > 1000) {
-    res.send({ error: "days can be maximum 1000!" });
+    return c.json({ error: "days can be maximum 1000!" });
   } else {
     const lat = place.latitude;
     const lng = place.longitude;
     const times = getTimes(lat, lng, date, days, tzOffset, calculateMethod);
-    res.send({ place, times });
+    return c.json({ place, times });
   }
 }
 
-function getIPAdress(req: Request, res: Response) {
-  res.send({ IP: req.headers["x-forwarded-for"] });
+function getIPAdress(c: Context) {
+  return c.json({ IP: c.req.header("x-forwarded-for") });
 }
 
-function logIPAdress(_req: Request, _: Response, next: NextFunction) {
-  next();
-}
 export default app;