feat: docs/api updates

apps/api/server/routes/api/auth/login.post.ts

@@ -0,0 +1,43 @@
+import {z} from "zod";
+import {useDecrypt} from "~/utils/hash-password";
+
+const userSchema = z.object({
+    email: z.string().email("This is not a valid email"),
+    password: z.string().min(8).max(20),
+});
+
+export default defineEventHandler(async (event) => {
+    const {email, password} = await readValidatedBody(event, userSchema.parse);
+
+    const user = await usePrisma().user.findUnique({
+        where: {
+            email,
+        },
+        select: {
+            id: true,
+            email: true,
+            username: true,
+            password: true,
+            image: true,
+        },
+    });
+
+    if (user) {
+        const match = await useDecrypt(password, user.password);
+
+        if (match) {
+            setCookie(event, 'auth_token', useGenerateToken(user.id), {
+                secure: true,
+                httpOnly: true,
+                sameSite: 'none',
+            });
+
+            return {
+                email: user.email,
+                username: user.username,
+                bio: user.bio,
+                image: user.image,
+            };
+        }
+    }
+});

apps/api/server/routes/api/auth/logout.post.ts

@@ -0,0 +1,5 @@
+export default defineEventHandler(async (event) => {
+    deleteCookie(event, 'auth_token');
+
+    return "Logged out";
+});

apps/api/server/routes/api/auth/signup.post.ts

@@ -0,0 +1,58 @@
+import {z} from "zod";
+
+const userSchema = z.object({
+    username: z.string().min(3).max(20),
+    email: z.string().email("This is not a valid email"),
+    password: z.string().min(8).max(20),
+});
+
+export default defineEventHandler(async (event) => {
+    const {username, email, password} = await readValidatedBody(event, userSchema.parse);
+
+    const existingUser = await usePrisma().user.findUnique({
+        where: {
+            OR: [
+                { email },
+                { username },
+            ]
+        },
+        select: {
+            id: true,
+        },
+    });
+
+    if (existingUser) {
+        return createError({
+            status: 422,
+            statusMessage: 'Unprocessable Content',
+            data: "User already exists"
+        });
+    }
+
+    const hashedPassword = await useHashPassword(password);
+
+    const newUser = await usePrisma().user.create({
+        data: {
+            username,
+            email,
+            password: hashedPassword
+        },
+        select: {
+            id: true,
+            email: true,
+            username: true,
+            image: true
+        }
+    });
+
+    setCookie(event, 'auth_token', useGenerateToken(newUser.id));
+    setResponseStatus(event, 201);
+
+    return {
+        id: newUser.id,
+        username: newUser.username,
+        email: newUser.email,
+        image: newUser.image,
+    }
+});
+

apps/api/server/routes/api/profile/[id].get.ts

@@ -0,0 +1,15 @@
+export default defineEventHandler(async (event) =>  {
+    const id = getRouterParam(event, 'id');
+
+    const profile = await usePrisma().profile.findUnique({
+        where: {
+            id
+        },
+        select: {
+            id: true,
+            username: true,
+            bio: true,
+            image: true,
+        }
+    })
+});

apps/api/server/routes/api/profile/[id].put.ts

@@ -0,0 +1,27 @@
+import {z} from "zod";
+
+const profileSchema = z.object({
+    image: z.string().url().optional(),
+    bio: z.string().optional(),
+});
+
+export default defineEventHandler(async (event) => {
+    useCheckAuth('required');
+
+    const id = getRouterParam(event, 'id');
+    const body = readValidatedBody(event, profileSchema.parse);
+
+    const updatedProfile = await usePrisma().update({
+        where: {
+            id
+        },
+        select: {
+            id: true,
+            username: true,
+            bio: true,
+            image: true,
+        }
+    });
+
+    return updatedProfile;
+});

apps/api/server/utils/auth.ts

@@ -1,9 +1,7 @@
 import jwt from "jsonwebtoken";
-import {LoginPayload} from "~/models/login-payload.model";
 
 export const useCheckAuth = (mode: 'optional' | 'required') => (event) => {
-    const {authorization} = getHeaders(event);
-    const token = authorization?.split(' ')[1];
+    const token = getCookie(event, 'auth_token');
 
     if (!token && mode === 'required') {
         throw createError({
@@ -14,7 +12,7 @@ export const useCheckAuth = (mode: 'optional' | 'required') => (event) => {
     }
 
     if (token) {
-        const verified = jwt.verify(token, process.env.JWT_SECRET) as LoginPayload;
+        const verified = jwt.verify(token, process.env.JWT_SECRET);
 
         if (!verified) {
             throw createError({

apps/api/server/utils/hash-password.ts

@@ -3,3 +3,7 @@ import bcrypt from 'bcryptjs';
 export const useHashPassword = (password: string) => {
     return bcrypt.hash(password, 10);
 }
+
+export const useDecrypt = (input: string, password: string) => {
+    return bcrypt.compare(input, password);
+}

apps/documentation/astro.config.mjs

@@ -1,8 +1,9 @@
 import {defineConfig} from 'astro/config';
 import starlight from '@astrojs/starlight';
-
 import tailwind from "@astrojs/tailwind";
 
+import react from "@astrojs/react";
+
 // https://astro.build/config
 export default defineConfig({
     integrations: [starlight({