feat: rewrite to hono sdflkjfsd;

package.json

@@ -26,6 +26,7 @@
         "@planetscale/database": "^1.8.0",
         "@prisma/client": "^5.0.0",
         "@typescript-eslint/eslint-plugin": "^6.0.0",
+        "hono": "^3.3.4",
         "itty-router": "^4.0.14",
         "lucia": "^2.0.0",
         "prettier": "^3.0.0",

src/index.ts

@@ -1,5 +1,38 @@
-import { router } from "@/handler";
+import { Hono } from "hono";
+import { Env } from "./worker-configuration";
+import assetRoute from "./routes/asset/assetRoute";
+import discordRoute from "./routes/discord/discordRoute";
+import ocGeneratorRoute from "./routes/oc-generators/ocGeneratorRoutes";
+import searchRoute from "./routes/search/searchRoute";
+import gamesRoute from "./routes/games/gamesRoute";
+import userRoute from "./routes/user/userRoute";
 
-export default {
-    fetch: router.handle,
-};
+interface Bindings extends Env {
+    [key: string]: unknown;
+}
+
+const app = new Hono<{ Bindings: Bindings }>();
+
+app.get("/status", (c) => {
+    c.status(200);
+    return c.json({ status: "ok" });
+});
+app.get("/", (c) => {
+    c.status(200);
+    return c.json({ status: "ok", routes: app.routes });
+});
+app.route("/asset", assetRoute);
+app.route("/discord", discordRoute);
+app.route("/oc-generators", ocGeneratorRoute);
+app.route("/search", searchRoute);
+app.route("/games", gamesRoute);
+app.route("/user", userRoute);
+app.all("*", (c) => {
+    c.status(404);
+    return c.json({ status: "not found" });
+});
+
+// https://hono.dev/api/hono#showroutes
+app.showRoutes();
+
+export default app;

src/lib/helpers/responses/notFoundResponse.ts

@@ -1,14 +1,14 @@
 // helper function to create a 404 Not Found response
 export function createNotFoundResponse(errorMessage, responseHeaders) {
-    const responseBody = {
-        success: false,
-        status: "error",
-        error: "404 Not Found",
-        message: errorMessage,
-    };
-
-    return new Response(JSON.stringify(responseBody), {
-        status: 404,
-        headers: responseHeaders,
-    });
+    return new Response(
+        JSON.stringify({
+            success: false,
+            status: "error",
+            error: errorMessage,
+        }),
+        {
+            status: 404,
+            headers: responseHeaders,
+        }
+    );
 }

src/lib/planetscale.ts

@@ -1,7 +1,8 @@
 import { connect } from "@planetscale/database";
+import { Env } from "../worker-configuration";
 
 // useful wrapper for planetscale connection
-export function getConnection(env) {
+export function getConnection(env: Env) {
     const config = {
         // this can be set with "wrangler secret put" or through the planetscale integration on cf dashboard
         host: env.DATABASE_HOST,

src/lib/query.ts

@@ -5,28 +5,33 @@ type queryParameter = string | number;
 
 export const getSearchResults = async (
     query: string,
-    game: string[],
-    asset: string[],
-    tags: string[],
-    env: Env
+    gameArray: string[],
+    assetArray: string[],
+    tagsArray: string[],
+    c
 ): Promise<Asset[]> => {
     let sqlQuery = `SELECT * FROM assets WHERE 1=1`;
     const parameters = [];
 
     sqlQuery = addQueryToSqlQuery(query, sqlQuery, parameters);
-    sqlQuery = addGameToSqlQuery(game, sqlQuery, parameters);
-    sqlQuery = addAssetToSqlQuery(asset, sqlQuery, parameters);
-    sqlQuery = addTagsToSqlQuery(tags, sqlQuery, parameters);
+    sqlQuery = addGameToSqlQuery(gameArray, sqlQuery, parameters);
+    sqlQuery = addAssetToSqlQuery(assetArray, sqlQuery, parameters);
+    sqlQuery = addTagsToSqlQuery(tagsArray, sqlQuery, parameters);
 
     sqlQuery += ` ORDER BY uploaded_date DESC`;
 
     sqlQuery = limitResults(sqlQuery);
 
-    if (!query && !game.length && !asset.length && !tags.length) {
+    if (
+        !query &&
+        !gameArray.length &&
+        !assetArray.length &&
+        !tagsArray.length
+    ) {
         sqlQuery = `SELECT * FROM assets ORDER BY uploaded_date DESC LIMIT 30`;
     }
 
-    const db = await getConnection(env);
+    const db = await getConnection(c.env);
 
     return await db
         .execute(sqlQuery, parameters)
@@ -46,42 +51,42 @@ const addQueryToSqlQuery = (
 };
 
 const addGameToSqlQuery = (
-    game: string[],
+    gameArray: string[],
     sqlQuery: string,
     parameters: queryParameter[]
 ): string => {
-    if (game.length) {
-        sqlQuery += ` AND game IN (${game.map(() => "?").join(",")})`;
-        parameters.push(...game);
+    if (gameArray.length) {
+        sqlQuery += ` AND game IN (${gameArray.map(() => "?").join(",")})`;
+        parameters.push(...gameArray);
     }
     return sqlQuery;
 };
 
 const addAssetToSqlQuery = (
-    asset: string[],
+    assetArray: string[],
     sqlQuery: string,
     parameters: queryParameter[]
 ): string => {
-    if (asset.length) {
-        sqlQuery += ` AND asset_category IN (${asset
+    if (assetArray.length) {
+        sqlQuery += ` AND asset_category IN (${assetArray
             .map(() => "?")
             .join(",")})`;
-        parameters.push(...asset);
+        parameters.push(...assetArray);
     }
     return sqlQuery;
 };
 
 const addTagsToSqlQuery = (
-    tags: string[],
+    tagsArray: string[],
     sqlQuery: string,
     parameters: queryParameter[]
 ): string => {
-    if (tags.length) {
-        sqlQuery += ` AND tags IN (${tags
+    if (tagsArray.length) {
+        sqlQuery += ` AND tags IN (${tagsArray
             .map(() => "?")
             .join(",")
             .toUpperCase()})`;
-        parameters.push(...tags);
+        parameters.push(...tagsArray);
     }
     return sqlQuery;
 };

src/lib/types/auth.ts

@@ -2,10 +2,7 @@ export interface LoginBody {
     username: string;
     password: string;
 }
-
-export interface RegisterBody {
-    username: string;
+export interface RegisterBody extends LoginBody {
     email: string;
-    password: string;
     passwordConfirm: string;
 }

src/routes/asset/assetRoute.ts

@@ -0,0 +1,15 @@
+import { Hono } from "hono";
+import { getAssetFromId } from "./getAssetFromId";
+import { downloadAsset } from "./downloadAsset";
+
+const assetRoute = new Hono();
+
+assetRoute.get("/:id", async (c) => {
+    return getAssetFromId(c);
+});
+
+assetRoute.get("/download/:assetId", async (c) => {
+    return downloadAsset(c);
+});
+
+export default assetRoute;

src/routes/download/downloadFile.ts → src/routes/asset/downloadAsset.ts

@@ -3,19 +3,13 @@ import type { Asset } from "@/lib/types/asset";
 import { getConnection } from "@/lib/planetscale";
 import { createNotFoundResponse } from "@/lib/helpers/responses/notFoundResponse";
 
-export const downloadFile = async (
-    request: Request,
-    env: Env
-): Promise<Response> => {
-    const url = new URL(request.url);
-    const id = url.pathname.split("/")[2];
+export const downloadAsset = async (c) => {
+    const { assetId } = c.req.param();
 
-    if (!id || isNaN(parseInt(id))) throw new Error("No ID provided");
-
-    const db = await getConnection(env);
+    const db = await getConnection(c.env);
 
     const row = await db
-        .execute("SELECT * FROM assets WHERE id = ?", [id])
+        .execute("SELECT * FROM assets WHERE id = ?", [assetId])
         .then((row) => row.rows[0] as Asset | undefined);
 
     if (!row)
@@ -30,7 +24,7 @@ export const downloadFile = async (
 
     await db.execute(
         "UPDATE assets SET download_count = download_count + 1 WHERE id = ?",
-        [id]
+        [assetId]
     );
 
     return new Response(blob, {

src/routes/asset/getAssetFromId.ts

@@ -3,22 +3,15 @@ import type { Asset } from "@/lib/types/asset";
 import { getConnection } from "@/lib/planetscale";
 import { createNotFoundResponse } from "@/lib/helpers/responses/notFoundResponse";
 
-export const getAssetFromId = async (
-    request: Request,
-    env: Env
-): Promise<Response> => {
-    const url = new URL(request.url);
-    const id = url.pathname.split("/")[2];
-
-    if (!id || isNaN(parseInt(id))) throw new Error("No ID provided");
-
-    const cacheKey = new Request(url.toString(), request);
+export const getAssetFromId = async (c) => {
+    const { id } = c.req.param();
+    const cacheKey = new Request(c.req.url.toString(), c.req);
     const cache = caches.default;
     let response = await cache.match(cacheKey);
 
     if (response) return response;
 
-    const db = await getConnection(env);
+    const db = await getConnection(c.env);
 
     const row = await db
         .execute("SELECT * FROM assets WHERE id = ?", [id])
@@ -62,16 +55,15 @@ export const getAssetFromId = async (
         };
     });
 
-    response = new Response(
-        JSON.stringify({
+    response = c.json(
+        {
             success: true,
             status: "ok",
             asset,
             similarAssets,
-        }),
-        {
-            headers: responseHeaders,
-        }
+        },
+        200,
+        responseHeaders
     );
 
     response.headers.set("Cache-Control", "s-maxage=604800");