Adding the FP approach to the middleware

src/hooks.server.ts

@@ -1,7 +1,11 @@
 import type { Handle } from '@sveltejs/kit';
 
-import { createUser, getUserByAuthId, getAuthUserProfile } from '$lib/services/userService';
-import { verifyToken } from '$lib/verifyToken';
+import * as E from 'fp-ts/lib/Either';
+import * as TE from 'fp-ts/lib/TaskEither';
+import { pipe } from 'fp-ts/lib/function';
+
+import { verifyToken } from '$lib/auth/verifyToken';
+import { getOrCreateUserByAuth } from '$lib/services/userService';
 
 const getTokenFromHeader = (authHeader: string) => authHeader.split(' ')[1];
 
@@ -14,12 +18,15 @@ export const handle: Handle = async ({ event, resolve }) => {
 			throw new Error('Invalid token');
 		}
 
-		const user = await getUserByAuthId(decodedToken.sub);
-		if (user) {
-			event.locals.user = user;
-		} else {
-			const authUserProfile = await getAuthUserProfile({ accessToken });
-			event.locals.user = await createUser({ authUserProfile });
+		const result = await pipe(
+			getOrCreateUserByAuth({ accessToken, authId: decodedToken.sub }),
+			TE.map((user) => {
+				event.locals.user = user;
+			})
+		)();
+
+		if (E.isLeft(result)) {
+			throw new Error('Failed to get or create user');
 		}
 	}
 

src/lib/auth/fetchUser.ts

@@ -0,0 +1,23 @@
+import { PUBLIC_AUTH0_DOMAIN } from '$env/static/public';
+
+import { type AuthUserProfile, AuthUserProfileSchema } from '$lib/types';
+
+export async function fetchAuthUser({
+	accessToken
+}: {
+	accessToken: string;
+}): Promise<AuthUserProfile> {
+	const resp = await fetch(`https://${PUBLIC_AUTH0_DOMAIN}/userinfo`, {
+		headers: {
+			Authorization: `Bearer ${accessToken}`
+		}
+	});
+
+	if (resp.ok) {
+		const profile = await resp.json();
+		return AuthUserProfileSchema.parse(profile);
+	}
+
+	const text = await resp.text();
+	throw new Error(`Failed to fetch auth user. Resp: ${text}, Status: ${resp.status}`);
+}

src/lib/db/userDb.test.ts

@@ -1,12 +1,13 @@
 import { describe, it, vi, type Mocked, expect, beforeEach } from 'vitest';
 import db from '$lib/db';
 
-import { getUser } from './userDb';
+import { getUser, getUserByAuthId, createUser } from './userDb';
 
 vi.mock('$lib/db', () => ({
 	default: {
 		user: {
-			findUnique: vi.fn()
+			findUnique: vi.fn(),
+			create: vi.fn()
 		}
 	}
 }));
@@ -89,3 +90,107 @@ describe('getUser', () => {
 		});
 	});
 });
+
+describe('getUserByAuthId', () => {
+	it('should return a user successfully', async () => {
+		dbUserMock.findUnique.mockResolvedValue({
+			id: 'hello world',
+			name: 'Goerge Costanza',
+			boards: [
+				{
+					id: 'bid_123',
+					notes: [
+						{
+							id: 'nid_333',
+							text: 'hello world'
+						}
+					]
+				}
+			]
+		} as any);
+
+		const result = await getUserByAuthId('auth_123')();
+		expect(result).toBeRightStrictEqual({
+			id: 'hello world',
+			name: 'Goerge Costanza',
+			boards: []
+		});
+	});
+
+	it('should return RecordNotFoundError when the user is null', async () => {
+		dbUserMock.findUnique.mockResolvedValue(null as any);
+
+		const result = await getUserByAuthId('auth_123')();
+		expect(result).toBeLeftStrictEqual({
+			_tag: 'RecordNotFound',
+			message: 'User with authId auth_123 not found'
+		});
+	});
+
+	it('should return a DatabaseError when the db throws an error', async () => {
+		dbUserMock.findUnique.mockRejectedValue(new Error('Something went wrong'));
+
+		const result = await getUserByAuthId('auth_123')();
+		expect(result).toBeLeftStrictEqual({
+			_tag: 'DatabaseError',
+			message: 'Database error',
+			originalError: new Error('Something went wrong')
+		});
+	});
+});
+
+describe('createUser', () => {
+	it('should create a user successfully', async () => {
+		dbUserMock.create.mockResolvedValue({
+			id: 'hello world',
+			name: 'Goerge Costanza',
+			boards: [
+				{
+					id: 'bid_123',
+					notes: [
+						{
+							id: 'nid_333',
+							text: 'hello world'
+						}
+					]
+				}
+			]
+		} as any);
+
+		const result = await createUser({
+			authUserProfile: {
+				email: 'email@foobar.com',
+				email_verified: true,
+				name: 'name',
+				picture: 'picture',
+				sub: 'sub',
+				nickname: 'nickname',
+				updated_at: 'updated_at'
+			}
+		})();
+
+		expect(result._tag).toBe('Right');
+	});
+
+	it('should return a DatabaseError when the db throws an error', async () => {
+		dbUserMock.create.mockRejectedValue(new Error('Something went wrong'));
+
+		const result = await createUser({
+			authUserProfile: {
+				email: 'email@foobar.com',
+				email_verified: true,
+				name: 'name',
+				picture: 'picture',
+				sub: 'sub',
+				nickname: 'nickname',
+				updated_at: 'updated_at'
+			}
+		})();
+
+		expect(result).toBeLeftStrictEqual({
+			_tag: 'DatabaseError',
+			message: 'Database error',
+			originalError: new Error('Something went wrong')
+		});
+	});
+});

src/lib/db/userDb.ts

@@ -2,8 +2,10 @@ import * as TE from 'fp-ts/TaskEither';
 import { pipe } from 'fp-ts/lib/function';
 
 import db from '$lib/db';
-import type { ServerError, User } from '$lib/types';
-import { fromNullableRecord, toDatabasError } from './utils';
+import { generateId } from '$lib/identityGenerator';
+import type { AuthUserProfile, ServerError, User } from '$lib/types';
+
+import { fromNullableRecord, tryDbTask } from './utils';
 
 interface GetUserByIdTaskParams {
 	id: string;
@@ -17,19 +19,17 @@ export const getUser = ({
 	includeNotes = true
 }: GetUserByIdTaskParams): TE.TaskEither<ServerError, User> =>
 	pipe(
-		TE.tryCatch(
-			() =>
-				db.user.findUnique({
-					where: { id },
-					include: {
-						boards: {
-							include: {
-								notes: includeNotes
-							}
+		tryDbTask(() =>
+			db.user.findUnique({
+				where: { id },
+				include: {
+					boards: {
+						include: {
+							notes: includeNotes
 						}
 					}
-				}),
-			toDatabasError
+				}
+			})
 		),
 		TE.chain(fromNullableRecord(`User with id ${id} not found`)),
 		TE.map((user) => ({
@@ -39,3 +39,48 @@ export const getUser = ({
 				: user.boards.map((board) => ({ ...board, notes: includeNotes ? board.notes : [] }))
 		}))
 	);
+
+export const getUserByAuthId = (authId: string): TE.TaskEither<ServerError, User> =>
+	pipe(
+		tryDbTask(() => db.user.findUnique({ where: { authId } })),
+		TE.chain(fromNullableRecord(`User with authId ${authId} not found`)),
+		TE.map((user) => ({
+			...user,
+			boards: []
+		}))
+	);
+
+export const createUser = ({
+	authUserProfile
+}: {
+	authUserProfile: AuthUserProfile;
+}): TE.TaskEither<ServerError, User> => {
+	return tryDbTask(() => {
+		const { email, email_verified, name, picture, sub } = authUserProfile;
+		return db.user.create({
+			data: {
+				id: generateId('uid'),
+				authId: sub,
+				name,
+				email,
+				emailVerified: email_verified,
+				picture,
+				boards: {
+					create: [
+						{
+							id: generateId('bid'),
+							noteOrder: []
+						}
+					]
+				}
+			},
+			include: {
+				boards: {
+					include: {
+						notes: true
+					}
+				}
+			}
+		});
+	});
+};

src/lib/db/utils.ts

@@ -1,5 +1,9 @@
 import * as TE from 'fp-ts/TaskEither';
-import type { DatabaseError, DatabaseResult, RecordNotFoundError } from './types';
+import type { DatabaseError, ServerError, RecordNotFoundError } from '$lib/types';
+
+export const tryDbTask = <T>(func: () => Promise<T>): TE.TaskEither<ServerError, T> => {
+	return TE.tryCatch(func, toDatabasError);
+};
 
 export const toDatabasError = (err: unknown) => {
 	if (err instanceof Error) {
@@ -21,7 +25,7 @@ export const toDatabasError = (err: unknown) => {
 
 export const fromNullableRecord =
 	<T>(message: string) =>
-	(value: T | null): TE.TaskEither<DatabaseResult, T> => {
+	(value: T | null): TE.TaskEither<ServerError, T> => {
 		if (!value) {
 			const recordNotFoundError: RecordNotFoundError = {
 				_tag: 'RecordNotFound',

src/lib/mapApi.ts

@@ -2,7 +2,8 @@ import type { ApiError, ServerError } from '$lib/types';
 
 export const mapToApiError = <T extends ServerError>(err: T): ApiError => {
 	switch (err._tag) {
-		case 'DatabaseError': {
+		case 'DatabaseError':
+		case 'FetchError': {
 			return { status: 500, message: err.message };
 		}
 		case 'RecordNotFound': {