feat: update /users routes to use new DB

src/handler.ts

@@ -7,8 +7,8 @@ import { getGenerator } from "@/routes/oc-generators/getGenerator";
 import { getGenerators } from "@/routes/oc-generators/getGenerators";
 import { getSearch, getRecentAssets } from "@/routes/search/search";
 import { downloadFile } from "@/routes/download/downloadFile";
-// import { getUserById } from "@/routes/user/getUserById";
-// import { getUserBySearch } from "@/routes/user/getUsersBySearch";
+import { getUserByUsername } from "@/routes/user/getUserByUsername";
+import { getUserBySearch } from "@/routes/user/getUsersBySearch";
 import { allGames } from "@/routes/games/allGames";
 import { getAssetFromId } from "@/routes/asset/getAssetFromId";
 
@@ -17,10 +17,10 @@ const router = Router();
 router
     .get("/", errorHandler(index))
     .get("/games", errorHandler(allGames))
-    // .get("/user/:id", errorHandler(getUserById))
+    .get("/user/:name", errorHandler(getUserByUsername))
     .get("/recent", errorHandler(getRecentAssets))
     .get("/asset/:id", errorHandler(getAssetFromId))
-    // .get("/user/search/:name", errorHandler(getUserBySearch))
+    .get("/user/s/:name", errorHandler(getUserBySearch))
     .get("/search", errorHandler(getSearch))
     .get("/download/:id", errorHandler(downloadFile))
     .get("/oc-generators", errorHandler(getGenerators))

src/lib/types/user.ts

@@ -1,10 +1,12 @@
 export interface User {
-    id: number;
-    displayName: string;
-    name: string;
-    avatarUrl: string;
-    discordId: number;
-    bio: string;
-    assetsUploaded: number;
-    roles: string;
+    id: string;
+    avatar_url: string | null;
+    banner_url: string | null;
+    username: string;
+    username_colour: string;
+    bio: string | null;
+    pronouns: string | null;
+    verified: number;
+    date_joined: string;
+    role: string;
 }

src/routes/asset/getAssetFromId.ts

@@ -9,17 +9,8 @@ export const getAssetFromId = async (
     const url = new URL(request.url);
     const id = url.pathname.split("/")[2];
 
-    if (isNaN(parseInt(id))) {
-        return new Response(
-            JSON.stringify({
-                success: false,
-                status: "error",
-                error: "404 Not Found",
-            }),
-            {
-                headers: responseHeaders,
-            }
-        );
+    if (!id || isNaN(parseInt(id))) {
+        throw new Error("No ID provided");
     }
 
     const cacheKey = new Request(url.toString(), request);

src/routes/download/downloadFile.ts

@@ -9,17 +9,8 @@ export const downloadFile = async (
     const url = new URL(request.url);
     const id = url.pathname.split("/")[2];
 
-    if (isNaN(parseInt(id))) {
-        return new Response(
-            JSON.stringify({
-                success: false,
-                status: "error",
-                error: "404 Not Found",
-            }),
-            {
-                headers: responseHeaders,
-            }
-        );
+    if (!id || isNaN(parseInt(id))) {
+        throw new Error("No ID provided");
     }
 
     const db = await getConnection(env);

src/routes/user/getUserByUsername.ts

@@ -0,0 +1,97 @@
+import { responseHeaders } from "@/lib/responseHeaders";
+import type { User } from "@/lib/types/user";
+import type { Asset } from "@/lib/types/asset";
+import { getConnection } from "@/lib/planetscale";
+
+export const getUserByUsername = async (
+    request: Request,
+    env: Env
+): Promise<Response> => {
+    const url = new URL(request.url);
+    const name = url.pathname.split("/")[2];
+
+    if (!name) {
+        throw new Error("No Name provided");
+    }
+
+    const cacheKey = new Request(url.toString(), request);
+
+    const cache = caches.default;
+
+    let response = await cache.match(cacheKey);
+
+    if (response) {
+        return response;
+    }
+
+    const db = await getConnection(env);
+
+    const row = await db
+        .execute("SELECT * FROM auth_user WHERE username = ?", [name])
+        .then((row) => row.rows[0] as User | undefined);
+
+    const user = {
+        id: row.id,
+        username: row.username,
+        avatar_url: row.avatar_url || null,
+        banner_url: row.banner_url || null,
+        bio: row.bio || null,
+        pronouns: row.pronouns || null,
+        verified: row.verified,
+        date_joined: row.date_joined,
+        roles: row.role,
+    };
+
+    const uploadedAssets = await db
+        .execute(
+            "SELECT * FROM assets WHERE uploaded_by = ? ORDER BY uploaded_date DESC LIMIT 5",
+            [user.id]
+        )
+        .then((row) => row.rows as Asset[] | undefined)
+        .then((row) =>
+            row?.map((asset) => {
+                return {
+                    id: asset.id,
+                    name: asset.name,
+                    game: asset.game,
+                    assetCategory: asset.asset_category,
+                    url: asset.url,
+                    tags: asset.tags,
+                    status: asset.status,
+                    uploadedBy: asset.uploaded_by,
+                    uploadedDate: asset.uploaded_date,
+                    fileSize: asset.file_size,
+                };
+            })
+        );
+
+    if (!row) {
+        return new Response(
+            JSON.stringify({
+                success: false,
+                status: "error",
+                error: "404 Not Found",
+            }),
+            {
+                headers: responseHeaders,
+            }
+        );
+    }
+
+    response = new Response(
+        JSON.stringify({
+            success: true,
+            status: "ok",
+            user,
+            uploadedAssets,
+        }),
+        {
+            headers: responseHeaders,
+        }
+    );
+
+    response.headers.set("Cache-Control", "s-maxage=60");
+    await cache.put(cacheKey, response.clone());
+
+    return response;
+};

src/routes/user/getUsersBySearch.ts

@@ -1,5 +1,6 @@
 import { responseHeaders } from "@/lib/responseHeaders";
 import type { User } from "@/lib/types/user";
+import { getConnection } from "@/lib/planetscale";
 
 export const getUserBySearch = async (
     request: Request,
@@ -16,39 +17,34 @@ export const getUserBySearch = async (
     if (response) {
         return response;
     }
-    const row: D1Result<User> = await env.database
-        .prepare(
-            `SELECT * FROM users WHERE displayName = ? OR name = ? OR name LIKE ?`
-        )
-        .bind(name, name, `%${name}%`)
-        .run();
 
-    if (!row.results.length) {
-        return new Response(
-            JSON.stringify({
-                success: false,
-                status: "error",
-                error: "404 Not Found",
-            }),
-            {
-                headers: responseHeaders,
-            }
-        );
+    const db = await getConnection(env);
+
+    const row = await db
+        .execute("SELECT * FROM auth_user WHERE username LIKE ?", [name])
+        .then((row) => row.rows as User[] | undefined);
+
+    if (!row) {
+        throw new Error("No User found");
     }
 
-    const results = row.results.map((result) => ({
-        id: result.id,
-        displayName: result.displayName,
-        name: result.name,
-        url: `/user/${result.id}`,
-        avatarUrl: result.avatarUrl,
-        discordId: result.discordId,
-        bio: result.bio,
-        assetsUploaded: result.assetsUploaded,
-        roles: result.roles,
-    }));
+    const results = row?.map((user) => {
+        return {
+            id: user.id,
+            username: user.username,
+            avatar_url: user.avatar_url || null,
+            banner_url: user.banner_url || null,
+            bio: user.bio || null,
+            pronouns: user.pronouns || null,
+            verified: user.verified,
+            date_joined: user.date_joined,
+            roles: user.role,
+        };
+    });
 
-    results.sort((a, b) => (a.name === name ? -1 : b.name === name ? 1 : 0));
+    results.sort((a, b) =>
+        a.username === name ? -1 : b.username === name ? 1 : 0
+    );
 
     response = new Response(
         JSON.stringify({