feature: neverthrow (#4474)

Author: Hugos68

pnpm-lock.yaml

@@ -139,6 +139,7 @@ catalog:
   vitest-browser-react: 2.2.0
   vitest-browser-svelte: 2.1.1
   zimmerframe: 1.1.4
+  neverthrow: 8.2.0
 
 catalogMode: strict
 

pnpm-workspace.yaml

@@ -34,6 +34,7 @@
 		"better-auth": "catalog:",
 		"drizzle-kit": "catalog:",
 		"drizzle-orm": "catalog:",
+		"neverthrow": "catalog:",
 		"playwright": "catalog:",
 		"postgres": "catalog:",
 		"sharp": "catalog:",

sites/plus.skeleton.dev/package.json

@@ -1,20 +1,33 @@
 import { getRequestEvent, query } from '$app/server';
 import { getUser } from './get-user.remote';
-import { redirect } from '@sveltejs/kit';
+import { error, redirect } from '@sveltejs/kit';
 import { auth } from '$lib/server/auth/auth';
 import { resolve } from '$app/paths';
+import { ResultAsync } from 'neverthrow';
 
 export const getAccounts = query(async () => {
 	const event = getRequestEvent();
-	const user = await getUser();
 
-	if (!user) {
+	const userResult = await ResultAsync.fromPromise(getUser(), (e) => new Error('Failed to fetch user', { cause: e }));
+
+	if (userResult.isErr()) {
+		error(500, userResult.error.message);
+	}
+
+	if (!userResult.value) {
 		redirect(303, resolve('/auth/sign-in'));
 	}
 
-	const accounts = await auth.api.listUserAccounts({
-		headers: event.request.headers,
-	});
+	const accountsResult = await ResultAsync.fromPromise(
+		auth.api.listUserAccounts({
+			headers: event.request.headers,
+		}),
+		(e) => new Error('Failed to fetch user accounts', { cause: e }),
+	);
+
+	if (accountsResult.isErr()) {
+		error(500, accountsResult.error.message);
+	}
 
-	return accounts;
+	return accountsResult.value;
 });

sites/plus.skeleton.dev/src/lib/remote/auth/get-accounts.remote.ts

@@ -2,28 +2,25 @@ import { form, getRequestEvent } from '$app/server';
 import { error, redirect } from '@sveltejs/kit';
 import { auth } from '$lib/server/auth/auth';
 import { LinkAccountSchema } from '$lib/schemas/auth/link-account-schema';
+import { ResultAsync } from 'neverthrow';
 
 export const linkAccount = form(LinkAccountSchema, async (data) => {
 	const event = getRequestEvent();
 
-	try {
-		const linkAccount = await auth.api.linkSocialAccount({
+	const linkAccountResult = await ResultAsync.fromPromise(
+		auth.api.linkSocialAccount({
 			headers: event.request.headers,
 			body: {
 				provider: data.providerId,
 				callbackURL: data.callbackURL,
 			},
-		});
+		}),
+		(e) => new Error('Failed to link account', { cause: e }),
+	);
 
-		if (!linkAccount.redirect || !linkAccount.url) {
-			error(500, 'Failed to link account');
-		}
-
-		redirect(303, linkAccount.url);
-	} catch (e) {
-		if (e instanceof Error) {
-			throw error(400, e.message);
-		}
-		throw error(400, 'An unknown error occurred while linking the account');
+	if (linkAccountResult.isErr()) {
+		error(500, linkAccountResult.error.message);
 	}
+
+	redirect(303, linkAccountResult.value.url);
 });

sites/plus.skeleton.dev/src/lib/remote/auth/link-account.remote.ts

@@ -2,21 +2,31 @@ import { form, getRequestEvent } from '$app/server';
 import { auth } from '$lib/server/auth/auth';
 import { error, redirect } from '@sveltejs/kit';
 import { SignInSchema } from '$lib/schemas/auth/sign-in-schema';
+import { ResultAsync } from 'neverthrow';
 
 export const signIn = form(SignInSchema, async (data) => {
 	const event = getRequestEvent();
 
-	const signIn = await auth.api.signInSocial({
-		headers: event.request.headers,
-		body: {
-			provider: data.providerId,
-			callbackURL: data.callbackURL,
+	const signInResult = await ResultAsync.fromPromise(
+		auth.api.signInSocial({
+			headers: event.request.headers,
+			body: {
+				provider: data.providerId,
+				callbackURL: data.callbackURL,
+			},
+		}),
+		(e) => {
+			return new Error('Failed to initiate social sign in', {
+				cause: e,
+			});
 		},
-	});
+	);
 
-	if (!signIn.redirect || !signIn.url) {
-		error(500, 'Failed to initiate social sign-in');
+	if (signInResult.isErr()) {
+		error(400, signInResult.error.message);
 	}
 
-	redirect(303, signIn.url);
+	if (signInResult.value.redirect && signInResult.value.url) {
+		redirect(303, signInResult.value.url);
+	}
 });

sites/plus.skeleton.dev/src/lib/remote/auth/sign-in.remote.ts

@@ -1,22 +1,23 @@
 import { form, getRequestEvent } from '$app/server';
 import { error } from '@sveltejs/kit';
 import { auth } from '$lib/server/auth/auth';
+import { ResultAsync } from 'neverthrow';
 
 export const signOut = form('unchecked', async () => {
 	const event = getRequestEvent();
 
-	try {
-		const signOut = await auth.api.signOut({
+	const signOutResult = await ResultAsync.fromPromise(
+		auth.api.signOut({
 			headers: event.request.headers,
-		});
+		}),
+		(e) => new Error('Failed to sign out', { cause: e }),
+	);
 
-		if (!signOut.success) {
-			error(500, 'Failed to sign out');
-		}
-	} catch (e) {
-		if (e instanceof Error) {
-			throw error(400, e.message);
-		}
-		throw error(400, 'An unknown error occurred while signing out');
+	if (signOutResult.isErr()) {
+		error(500, signOutResult.error.message);
+	}
+
+	if (!signOutResult.value.success) {
+		error(500, 'Failed to sign out');
 	}
 });

sites/plus.skeleton.dev/src/lib/remote/auth/sign-out.remote.ts

@@ -2,21 +2,22 @@ import { form, getRequestEvent } from '$app/server';
 import { error } from '@sveltejs/kit';
 import { auth } from '$lib/server/auth/auth';
 import { UnlinkAccountSchema } from '$lib/schemas/auth/unlink-account-schema';
+import { ResultAsync } from 'neverthrow';
 
 export const unlinkAccount = form(UnlinkAccountSchema, async (data) => {
 	const event = getRequestEvent();
 
-	try {
-		await auth.api.unlinkAccount({
+	const unlinkAccountResult = await ResultAsync.fromPromise(
+		auth.api.unlinkAccount({
 			headers: event.request.headers,
 			body: {
 				providerId: data.providerId,
 			},
-		});
-	} catch (e) {
-		if (e instanceof Error) {
-			throw error(400, e.message);
-		}
-		throw error(400, 'An unknown error occurred while unlinking the account');
+		}),
+		(e) => new Error('Failed to unlink account', { cause: e }),
+	);
+
+	if (unlinkAccountResult.isErr()) {
+		error(400, unlinkAccountResult.error.message);
 	}
 });