wip: replace Prisma error middleware with better-result tryQuery

package.json

@@ -70,6 +70,7 @@
     "@uidotdev/usehooks": "2.4.1",
     "base-vaul": "1.2.1",
     "better-auth": "1.4.17",
+    "better-result": "^2.7.0",
     "boring-avatars": "2.0.4",
     "class-variance-authority": "0.7.1",
     "clsx": "2.1.1",

src/server/db/index.ts

@@ -1,7 +1,44 @@
+import { Result, TaggedError } from 'better-result';
+
 import { envServer } from '@/env/server';
 import { timingStore } from '@/server/timing-store';
 
-import { PrismaClient } from './generated/client';
+import { Prisma, PrismaClient } from './generated/client';
+
+export class PrismaUniqueConstraintError extends TaggedError(
+  'PrismaUniqueConstraintError'
+)<{
+  message: string;
+  target: unknown;
+}>() {}
+
+export class PrismaNotFoundError extends TaggedError('PrismaNotFoundError')<{
+  message: string;
+}>() {}
+
+export class PrismaForeignKeyError extends TaggedError(
+  'PrismaForeignKeyError'
+)<{
+  message: string;
+}>() {}
+
+export class PrismaValidationError extends TaggedError(
+  'PrismaValidationError'
+)<{
+  message: string;
+}>() {}
+
+export class PrismaUnknownError extends TaggedError('PrismaUnknownError')<{
+  message: string;
+  cause: unknown;
+}>() {}
+
+export type PrismaError =
+  | PrismaUniqueConstraintError
+  | PrismaNotFoundError
+  | PrismaForeignKeyError
+  | PrismaValidationError
+  | PrismaUnknownError;
 
 const levels = {
   trace: ['query', 'error', 'warn', 'info'],
@@ -50,3 +87,41 @@ const globalForPrisma = globalThis as unknown as {
 export const db = globalForPrisma.prisma ?? createPrisma();
 
 if (import.meta.env.DEV) globalForPrisma.prisma = db;
+
+export const tryQuery = <T>(promise: Promise<T>) =>
+  Result.tryPromise({
+    try: () => promise,
+    catch: (e): PrismaError => {
+      if (e instanceof Prisma.PrismaClientKnownRequestError) {
+        switch (e.code) {
+          case 'P2002':
+            return new PrismaUniqueConstraintError({
+              message: 'Unique constraint violation',
+              target: e.meta?.target,
+            });
+          case 'P2025':
+            return new PrismaNotFoundError({
+              message: 'Record not found',
+            });
+          case 'P2003':
+            return new PrismaForeignKeyError({
+              message: 'Foreign key constraint violation',
+            });
+          default:
+            return new PrismaUnknownError({
+              message: `Database error: ${e.code}`,
+              cause: e,
+            });
+        }
+      }
+      if (e instanceof Prisma.PrismaClientValidationError) {
+        return new PrismaValidationError({
+          message: 'Database validation error',
+        });
+      }
+      return new PrismaUnknownError({
+        message: e instanceof Error ? e.message : 'Unknown database error',
+        cause: e,
+      });
+    },
+  });