Merge branch 'feat/admin-pages'

5 files changed, 83 insertions, 245 deletions

diff --git a/frontend/app/.server/api/client.ts b/frontend/app/.server/api/client.ts
index a78180b..0db4c14 100644
--- a/frontend/app/.server/api/client.ts
+++ b/frontend/app/.server/api/client.ts
@@ -1,5 +1,5 @@
 import createClient from "openapi-fetch";
-import type { operations, paths } from "./schema";
+import type { paths } from "./schema";
 
 const apiClient = createClient<paths>({
 	baseUrl:
@@ -46,50 +46,3 @@ export async function apiGetToken(token: string) {
 	if (error) throw new Error(error.message);
 	return data;
 }
-
-export async function adminApiGetUsers(token: string) {
-	const { data, error } = await apiClient.GET("/admin/users", {
-		params: {
-			header: { Authorization: `Bearer ${token}` },
-		},
-	});
-	if (error) throw new Error(error.message);
-	return data;
-}
-
-export async function adminApiGetGames(token: string) {
-	const { data, error } = await apiClient.GET("/admin/games", {
-		params: {
-			header: { Authorization: `Bearer ${token}` },
-		},
-	});
-	if (error) throw new Error(error.message);
-	return data;
-}
-
-export async function adminApiGetGame(token: string, gameId: number) {
-	const { data, error } = await apiClient.GET("/admin/games/{game_id}", {
-		params: {
-			header: { Authorization: `Bearer ${token}` },
-			path: { game_id: gameId },
-		},
-	});
-	if (error) throw new Error(error.message);
-	return data;
-}
-
-export async function adminApiPutGame(
-	token: string,
-	gameId: number,
-	body: operations["adminPutGame"]["requestBody"]["content"]["application/json"],
-) {
-	const { data, error } = await apiClient.PUT("/admin/games/{game_id}", {
-		params: {
-			header: { Authorization: `Bearer ${token}` },
-			path: { game_id: gameId },
-		},
-		body,
-	});
-	if (error) throw new Error(error.message);
-	return data;
-}
diff --git a/frontend/app/.server/api/schema.d.ts b/frontend/app/.server/api/schema.d.ts
index 1c8cead..88067a8 100644
--- a/frontend/app/.server/api/schema.d.ts
+++ b/frontend/app/.server/api/schema.d.ts
@@ -72,58 +72,6 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/admin/users": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /** List all users */
-        get: operations["adminGetUsers"];
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/admin/games": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /** List games */
-        get: operations["adminGetGames"];
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/admin/games/{game_id}": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /** Get a game */
-        get: operations["adminGetGame"];
-        /** Update a game */
-        put: operations["adminPutGame"];
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -433,129 +381,4 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
-    adminGetUsers: {
-        parameters: {
-            query?: never;
-            header: {
-                Authorization: components["parameters"]["header_authorization"];
-            };
-            path?: never;
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description List of users */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        users: components["schemas"]["User"][];
-                    };
-                };
-            };
-            401: components["responses"]["Unauthorized"];
-            403: components["responses"]["Forbidden"];
-        };
-    };
-    adminGetGames: {
-        parameters: {
-            query?: never;
-            header: {
-                Authorization: components["parameters"]["header_authorization"];
-            };
-            path?: never;
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description List of games */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        games: components["schemas"]["Game"][];
-                    };
-                };
-            };
-            401: components["responses"]["Unauthorized"];
-            403: components["responses"]["Forbidden"];
-        };
-    };
-    adminGetGame: {
-        parameters: {
-            query?: never;
-            header: {
-                Authorization: components["parameters"]["header_authorization"];
-            };
-            path: {
-                game_id: components["parameters"]["path_game_id"];
-            };
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description A game */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        game: components["schemas"]["Game"];
-                    };
-                };
-            };
-            401: components["responses"]["Unauthorized"];
-            403: components["responses"]["Forbidden"];
-            404: components["responses"]["NotFound"];
-        };
-    };
-    adminPutGame: {
-        parameters: {
-            query?: never;
-            header: {
-                Authorization: components["parameters"]["header_authorization"];
-            };
-            path: {
-                game_id: components["parameters"]["path_game_id"];
-            };
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": {
-                    /**
-                     * @example closed
-                     * @enum {string}
-                     */
-                    state?: "closed" | "waiting_entries" | "waiting_start" | "prepare" | "starting" | "gaming" | "finished";
-                    /** @example Game 1 */
-                    display_name?: string;
-                    /** @example 360 */
-                    duration_seconds?: number;
-                    /** @example 946684800 */
-                    started_at?: number | null;
-                    /** @example 1 */
-                    problem_id?: number | null;
-                };
-            };
-        };
-        responses: {
-            /** @description Successfully updated */
-            204: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
-            400: components["responses"]["BadRequest"];
-            401: components["responses"]["Unauthorized"];
-            403: components["responses"]["Forbidden"];
-            404: components["responses"]["NotFound"];
-        };
-    };
 }
diff --git a/frontend/app/.server/auth.ts b/frontend/app/.server/auth.ts
index a4811e2..2c9d23c 100644
--- a/frontend/app/.server/auth.ts
+++ b/frontend/app/.server/auth.ts
@@ -1,10 +1,12 @@
+import { redirect } from "@remix-run/node";
 import type { Session } from "@remix-run/server-runtime";
 import { jwtDecode } from "jwt-decode";
 import { Authenticator } from "remix-auth";
 import { FormStrategy } from "remix-auth-form";
 import { apiPostLogin } from "./api/client";
 import { components } from "./api/schema";
-import { sessionStorage } from "./session";
+import { createUnstructuredCookie } from "./cookie";
+import { cookieOptions, sessionStorage } from "./session";
 
 const authenticator = new Authenticator<string>(sessionStorage);
 
@@ -19,15 +21,40 @@ authenticator.use(
 
 export type User = components["schemas"]["User"];
 
+// This cookie is used to directly store the JWT for the API server.
+// Remix's createCookie() returns "structured" cookies, which cannot be reused directly by non-Remix servers.
+const tokenCookie = createUnstructuredCookie("albatross_token", cookieOptions);
+
 export async function login(request: Request): Promise<never> {
-	return await authenticator.authenticate("default", request, {
-		successRedirect: "/dashboard",
+	const jwt = await authenticator.authenticate("default", request, {
 		failureRedirect: "/login",
 	});
+
+	const session = await sessionStorage.getSession(
+		request.headers.get("cookie"),
+	);
+	session.set(authenticator.sessionKey, jwt);
+
+	throw redirect("/dashboard", {
+		headers: [
+			["Set-Cookie", await sessionStorage.commitSession(session)],
+			["Set-Cookie", await tokenCookie.serialize(jwt)],
+		],
+	});
 }
 
 export async function logout(request: Request | Session): Promise<never> {
-	return await authenticator.logout(request, { redirectTo: "/" });
+	try {
+		return await authenticator.logout(request, { redirectTo: "/" });
+	} catch (response) {
+		if (response instanceof Response) {
+			response.headers.append(
+				"Set-Cookie",
+				await tokenCookie.serialize("", { maxAge: 0, expires: new Date(0) }),
+			);
+		}
+		throw response;
+	}
 }
 
 export async function ensureUserLoggedIn(
@@ -40,16 +67,6 @@ export async function ensureUserLoggedIn(
 	return { user, token };
 }
 
-export async function ensureAdminUserLoggedIn(
-	request: Request | Session,
-): Promise<{ user: User; token: string }> {
-	const { user, token } = await ensureUserLoggedIn(request);
-	if (!user.is_admin) {
-		throw new Error("Forbidden");
-	}
-	return { user, token };
-}
-
 export async function ensureUserNotLoggedIn(
 	request: Request | Session,
 ): Promise<null> {
diff --git a/frontend/app/.server/cookie.ts b/frontend/app/.server/cookie.ts
new file mode 100644
index 0000000..cccbe78
--- /dev/null
+++ b/frontend/app/.server/cookie.ts
@@ -0,0 +1,41 @@
+import { Cookie, CookieOptions } from "@remix-run/server-runtime";
+import { parse, serialize } from "cookie";
+
+// Remix's createCookie() returns "structured" cookies, which are cookies that hold a JSON-encoded object.
+// This is not suitable for interoperation with other systems that expect a simple string value.
+// This function creates an "unstructured" cookie, a simple plain text.
+export function createUnstructuredCookie(
+	name: string,
+	cookieOptions?: CookieOptions,
+): Cookie {
+	const { secrets = [], ...options } = {
+		path: "/",
+		sameSite: "lax" as const,
+		...cookieOptions,
+	};
+
+	return {
+		get name() {
+			return name;
+		},
+		get isSigned() {
+			return secrets.length > 0;
+		},
+		get expires() {
+			return typeof options.maxAge !== "undefined"
+				? new Date(Date.now() + options.maxAge * 1000)
+				: options.expires;
+		},
+		async parse(cookieHeader, parseOptions) {
+			if (!cookieHeader) return null;
+			const cookies = parse(cookieHeader, { ...options, ...parseOptions });
+			return name in cookies ? cookies[name] : null;
+		},
+		async serialize(value, serializeOptions) {
+			return serialize(name, value, {
+				...options,
+				...serializeOptions,
+			});
+		},
+	};
+}
diff --git a/frontend/app/.server/session.ts b/frontend/app/.server/session.ts
index 79810f4..102bcd2 100644
--- a/frontend/app/.server/session.ts
+++ b/frontend/app/.server/session.ts
@@ -1,13 +1,17 @@
 import { createCookieSessionStorage } from "@remix-run/node";
 
+export const cookieOptions = {
+	sameSite: "lax" as const,
+	path: "/",
+	httpOnly: true,
+	// secure: process.env.NODE_ENV === "production",
+	secure: false, // TODO
+	secrets: ["TODO"],
+};
+
 export const sessionStorage = createCookieSessionStorage({
 	cookie: {
 		name: "albatross_session",
-		sameSite: "lax",
-		path: "/",
-		httpOnly: true,
-		secrets: ["TODO"],
-		// secure: process.env.NODE_ENV === "production",
-		secure: false, // TODO
+		...cookieOptions,
 	},
 });