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");