added utils for unauth, verify, and response

server/auth/index.ts

@@ -1,3 +1,6 @@
+export * from "./unauthorizedResponse";
+export * from "./verifySession";
+
 import { Lucia, TimeSpan } from "lucia";
 import { DrizzleSQLiteAdapter } from "@lucia-auth/adapter-drizzle";
 import db from "@server/db";

server/auth/unauthorizedResponse.ts

@@ -0,0 +1,6 @@
+import HttpCode from "@server/types/HttpCode";
+import createHttpError from "http-errors";
+
+export function unauthorized(msg?: string) {
+    return createHttpError(HttpCode.UNAUTHORIZED, msg || "Unauthorized");
+}

server/auth/verifySession.ts

@@ -0,0 +1,9 @@
+import { Request } from "express";
+import { lucia } from "@server/auth";
+
+export async function verifySession(req: Request) {
+    const res = await lucia.validateSession(
+        req.cookies[lucia.sessionCookieName],
+    );
+    return res;
+}

server/routers/auth/login.ts

@@ -7,10 +7,10 @@ import response from "@server/utils/response";
 import { eq } from "drizzle-orm";
 import { NextFunction, Request, Response } from "express";
 import createHttpError from "http-errors";
-import { z } from "zod";
-import { fromError } from "zod-validation-error";
 import { decodeHex } from "oslo/encoding";
 import { TOTPController } from "oslo/otp";
+import { z } from "zod";
+import { fromError } from "zod-validation-error";
 
 export const loginBodySchema = z.object({
     email: z.string().email(),
@@ -45,15 +45,13 @@ export async function login(
     const sessionId = req.cookies[lucia.sessionCookieName];
     const { session: existingSession } = await lucia.validateSession(sessionId);
     if (existingSession) {
-        return res.status(HttpCode.OK).send(
+        return response<null>(res, {
-            response<null>({
+            data: null,
-                data: null,
+            success: true,
-                success: true,
+            error: false,
-                error: false,
+            message: "Already logged in",
-                message: "Already logged in",
+            status: HttpCode.OK,
-                status: HttpCode.OK,
+        });
-            }),
-        );
     }
 
     const existingUserRes = await db
@@ -89,15 +87,13 @@ export async function login(
 
     if (existingUser.twoFactorEnabled) {
         if (!code) {
-            return res.status(HttpCode.ACCEPTED).send(
+            return response<{ codeRequested: boolean }>(res, {
-                response<{ codeRequested: boolean }>({
+                data: { codeRequested: true },
-                    data: { codeRequested: true },
+                success: true,
-                    success: true,
+                error: false,
-                    error: false,
+                message: "Two-factor authentication required",
-                    message: "Two-factor authentication required",
+                status: HttpCode.ACCEPTED,
-                    status: HttpCode.ACCEPTED,
+            });
-                }),
-            );
         }
 
         if (!existingUser.twoFactorSecret) {
@@ -131,13 +127,11 @@ export async function login(
         lucia.createSessionCookie(session.id).serialize(),
     );
 
-    return res.status(HttpCode.OK).send(
+    return response<null>(res, {
-        response<null>({
+        data: null,
-            data: null,
+        success: true,
-            success: true,
+        error: false,
-            error: false,
+        message: "Logged in successfully",
-            message: "Logged in successfully",
+        status: HttpCode.OK,
-            status: HttpCode.OK,
+    });
-        }),
-    );
 }

server/routers/auth/logout.ts

@@ -23,13 +23,11 @@ export async function logout(
     await lucia.invalidateSession(sessionId);
     res.setHeader("Set-Cookie", lucia.createBlankSessionCookie().serialize());
 
-    return res.status(HttpCode.OK).send(
+    return response<null>(res, {
-        response<null>({
+        data: null,
-            data: null,
+        success: true,
-            success: true,
+        error: false,
-            error: false,
+        message: "Logged out successfully",
-            message: "Logged out successfully",
+        status: HttpCode.OK,
-            status: HttpCode.OK,
+    });
-        }),
-    );
 }

server/routers/auth/signup.ts

@@ -28,7 +28,11 @@ export const signupBodySchema = z.object({
 
 export type SignUpBody = z.infer<typeof signupBodySchema>;
 
-export async function signup(req: Request, res: Response, next: NextFunction): Promise<any> {
+export async function signup(
+    req: Request,
+    res: Response,
+    next: NextFunction,
+): Promise<any> {
     const parsedBody = signupBodySchema.safeParse(req.body);
 
     if (!parsedBody.success) {
@@ -64,15 +68,13 @@ export async function signup(req: Request, res: Response, next: NextFunction): P
             lucia.createSessionCookie(session.id).serialize(),
         );
 
-        return res.status(HttpCode.OK).send(
+        return response<null>(res, {
-            response<null>({
+            data: null,
-                data: null,
+            success: true,
-                success: true,
+            error: false,
-                error: false,
+            message: "User created successfully",
-                message: "User created successfully",
+            status: HttpCode.OK,
-                status: HttpCode.OK,
+        });
-            }),
-        );
     } catch (e) {
         if (e instanceof SqliteError && e.code === "SQLITE_CONSTRAINT_UNIQUE") {
             return next(

server/routers/auth/verifyTotp.ts

@@ -0,0 +1,42 @@
+import { Request, Response, NextFunction } from "express";
+import createHttpError from "http-errors";
+import { z } from "zod";
+import { fromError } from "zod-validation-error";
+import { decodeHex } from "oslo/encoding";
+import { TOTPController } from "oslo/otp";
+import HttpCode from "@server/types/HttpCode";
+import { verifySession, lucia, unauthorized } from "@server/auth";
+
+export const verifyTotpBody = z.object({
+    code: z.string(),
+});
+
+export type VerifyTotpBody = z.infer<typeof verifyTotpBody>;
+
+export type VerifyTotpResponse = {
+    valid: boolean;
+};
+
+export async function verifyTotp(
+    req: Request,
+    res: Response,
+    next: NextFunction,
+): Promise<any> {
+    const parsedBody = verifyTotpBody.safeParse(req.body);
+
+    if (!parsedBody.success) {
+        return next(
+            createHttpError(
+                HttpCode.BAD_REQUEST,
+                fromError(parsedBody.error).toString(),
+            ),
+        );
+    }
+
+    const { code } = parsedBody.data;
+
+    const { session, user } = await verifySession(req);
+    if (!session) {
+        return unauthorized();
+    }
+}

server/routers/external.ts

@@ -47,3 +47,4 @@ unauthenticated.use("/auth", authRouter);
 authRouter.put("/signup", auth.signup);
 authRouter.post("/login", auth.login);
 authRouter.post("/logout", auth.logout);
+authRouter.post("/verify-totp", auth.logout);

server/routers/site/createSite.ts

@@ -1,17 +1,19 @@
-import { Request, Response, NextFunction } from 'express';
+import { Request, Response, NextFunction } from "express";
 import response from "@server/utils/response";
-import HttpCode from '@server/types/HttpCode';
+import HttpCode from "@server/types/HttpCode";
 
 // define zod type here
 
-export async function createSite(req: Request, res: Response, next: NextFunction): Promise<any> {
+export async function createSite(
-  return res.status(HttpCode.OK).send(
+    req: Request,
-      response<null>({
+    res: Response,
-          data: null,
+    next: NextFunction,
-          success: true,
+): Promise<any> {
-          error: false,
+    return response<null>(res, {
-          message: "Logged in successfully",
+        data: null,
-          status: HttpCode.OK,
+        success: true,
-      }),
+        error: false,
-  );
+        message: "Logged in successfully",
+        status: HttpCode.OK,
+    });
 }

server/utils/index.ts

@@ -0,0 +1 @@
+export * from "./response";

server/utils/response.ts

@@ -1,19 +1,17 @@
 import { ResponseT } from "@server/types/Response";
+import { Response } from "express";
 
-export const response = <T>({
+export const response = <T>(
-    data,
+    res: Response,
-    success,
+    { data, success, error, message, status }: ResponseT<T>,
-    error,
+) => {
-    message,
+    return res.status(status).send({
-    status,
-}: ResponseT<T>) => {
-    return {
         data,
         success,
         error,
         message,
         status,
-    };
+    });
 };
 
 export default response;