@factiii/auth 0.5.2 → 0.5.4

package/dist/index.mjs

@@ -1,4 +1,5 @@
 import {
+  __require,
   biometricVerifySchema,
   changePasswordSchema,
   checkPasswordResetSchema,
@@ -17,11 +18,265 @@ import {
   twoFaResetVerifySchema,
   twoFaVerifySchema,
   verifyEmailSchema
-} from "./chunk-EHI4P63M.mjs";
+} from "./chunk-KUYH4DBN.mjs";
 
 // src/middleware/authGuard.ts
 import { TRPCError } from "@trpc/server";
 
+// src/adapters/prismaAdapter.ts
+function createPrismaAdapter(prisma) {
+  return {
+    user: {
+      async findByEmailInsensitive(email) {
+        return prisma.user.findFirst({
+          where: { email: { equals: email, mode: "insensitive" } }
+        });
+      },
+      async findByUsernameInsensitive(username) {
+        return prisma.user.findFirst({
+          where: { username: { equals: username, mode: "insensitive" } }
+        });
+      },
+      async findByEmailOrUsernameInsensitive(identifier) {
+        return prisma.user.findFirst({
+          where: {
+            OR: [
+              { email: { equals: identifier, mode: "insensitive" } },
+              { username: { equals: identifier, mode: "insensitive" } }
+            ]
+          }
+        });
+      },
+      async findByEmailOrOAuthId(email, oauthId) {
+        return prisma.user.findFirst({
+          where: {
+            OR: [
+              { email: { equals: email, mode: "insensitive" } },
+              { oauthId: { equals: oauthId } }
+            ]
+          }
+        });
+      },
+      async findById(id) {
+        return prisma.user.findUnique({ where: { id } });
+      },
+      async findActiveById(id) {
+        return prisma.user.findUnique({
+          where: { id, status: "ACTIVE" }
+        });
+      },
+      async create(data) {
+        return prisma.user.create({ data });
+      },
+      async update(id, data) {
+        return prisma.user.update({ where: { id }, data });
+      }
+    },
+    session: {
+      async findById(id) {
+        const session = await prisma.session.findUnique({
+          where: { id },
+          select: {
+            id: true,
+            userId: true,
+            socketId: true,
+            twoFaSecret: true,
+            browserName: true,
+            issuedAt: true,
+            lastUsed: true,
+            revokedAt: true,
+            deviceId: true,
+            user: { select: { status: true, verifiedHumanAt: true } }
+          }
+        });
+        return session;
+      },
+      async create(data) {
+        return prisma.session.create({ data });
+      },
+      async update(id, data) {
+        return prisma.session.update({ where: { id }, data });
+      },
+      async updateLastUsed(id) {
+        const session = await prisma.session.update({
+          where: { id },
+          data: { lastUsed: /* @__PURE__ */ new Date() },
+          select: {
+            id: true,
+            userId: true,
+            socketId: true,
+            twoFaSecret: true,
+            browserName: true,
+            issuedAt: true,
+            lastUsed: true,
+            revokedAt: true,
+            deviceId: true,
+            user: { select: { verifiedHumanAt: true } }
+          }
+        });
+        return session;
+      },
+      async revoke(id) {
+        await prisma.session.update({
+          where: { id },
+          data: { revokedAt: /* @__PURE__ */ new Date() }
+        });
+      },
+      async findActiveByUserId(userId, excludeSessionId) {
+        return prisma.session.findMany({
+          where: {
+            userId,
+            revokedAt: null,
+            ...excludeSessionId ? { NOT: { id: excludeSessionId } } : {}
+          },
+          select: { id: true, socketId: true, userId: true }
+        });
+      },
+      async revokeAllByUserId(userId, excludeSessionId) {
+        await prisma.session.updateMany({
+          where: {
+            userId,
+            revokedAt: null,
+            ...excludeSessionId ? { NOT: { id: excludeSessionId } } : {}
+          },
+          data: { revokedAt: /* @__PURE__ */ new Date() }
+        });
+      },
+      async findTwoFaSecretsByUserId(userId) {
+        return prisma.session.findMany({
+          where: { userId, twoFaSecret: { not: null } },
+          select: { twoFaSecret: true }
+        });
+      },
+      async clearTwoFaSecrets(userId, excludeSessionId) {
+        await prisma.session.updateMany({
+          where: {
+            userId,
+            ...excludeSessionId ? { NOT: { id: excludeSessionId } } : {}
+          },
+          data: { twoFaSecret: null }
+        });
+      },
+      async findByIdWithDevice(id, userId) {
+        const session = await prisma.session.findUnique({
+          where: { id, userId },
+          select: {
+            twoFaSecret: true,
+            deviceId: true,
+            device: { select: { pushToken: true } }
+          }
+        });
+        return session;
+      },
+      async revokeByDevicePushToken(userId, pushToken, excludeSessionId) {
+        await prisma.session.updateMany({
+          where: {
+            userId,
+            id: { not: excludeSessionId },
+            revokedAt: null,
+            device: { pushToken }
+          },
+          data: { revokedAt: /* @__PURE__ */ new Date() }
+        });
+      },
+      async clearDeviceId(userId, deviceId) {
+        await prisma.session.updateMany({
+          where: { userId, deviceId },
+          data: { deviceId: null }
+        });
+      }
+    },
+    otp: {
+      async findValidByUserAndCode(userId, code) {
+        return prisma.oTP.findFirst({
+          where: { userId, code, expiresAt: { gte: /* @__PURE__ */ new Date() } }
+        });
+      },
+      async create(data) {
+        return prisma.oTP.create({ data });
+      },
+      async delete(id) {
+        await prisma.oTP.delete({ where: { id } });
+      }
+    },
+    passwordReset: {
+      async findById(id) {
+        return prisma.passwordReset.findUnique({
+          where: { id },
+          select: { id: true, createdAt: true, userId: true }
+        });
+      },
+      async create(userId) {
+        return prisma.passwordReset.create({
+          data: { userId }
+        });
+      },
+      async delete(id) {
+        await prisma.passwordReset.delete({ where: { id } });
+      },
+      async deleteAllByUserId(userId) {
+        await prisma.passwordReset.deleteMany({ where: { userId } });
+      }
+    },
+    device: {
+      async findByTokenSessionAndUser(pushToken, sessionId, userId) {
+        return prisma.device.findFirst({
+          where: {
+            pushToken,
+            sessions: { some: { id: sessionId } },
+            users: { some: { id: userId } }
+          },
+          select: { id: true }
+        });
+      },
+      async upsertByPushToken(pushToken, sessionId, userId) {
+        await prisma.device.upsert({
+          where: { pushToken },
+          create: {
+            pushToken,
+            sessions: { connect: { id: sessionId } },
+            users: { connect: { id: userId } }
+          },
+          update: {
+            sessions: { connect: { id: sessionId } },
+            users: { connect: { id: userId } }
+          }
+        });
+      },
+      async findByUserAndToken(userId, pushToken) {
+        return prisma.device.findFirst({
+          where: { users: { some: { id: userId } }, pushToken },
+          select: { id: true }
+        });
+      },
+      async disconnectUser(deviceId, userId) {
+        await prisma.device.update({
+          where: { id: deviceId },
+          data: { users: { disconnect: { id: userId } } }
+        });
+      },
+      async hasRemainingUsers(deviceId) {
+        const result = await prisma.device.findUnique({
+          where: { id: deviceId },
+          select: { users: { select: { id: true }, take: 1 } }
+        });
+        return (result?.users.length ?? 0) > 0;
+      },
+      async delete(id) {
+        await prisma.device.delete({ where: { id } });
+      }
+    },
+    admin: {
+      async findByUserId(userId) {
+        return prisma.admin.findFirst({
+          where: { userId },
+          select: { ip: true }
+        });
+      }
+    }
+  };
+}
+
 // src/adapters/email.ts
 function createNoopEmailAdapter() {
   return {
@@ -75,6 +330,291 @@ function createConsoleEmailAdapter() {
   };
 }
 
+// src/adapters/drizzleAdapter.ts
+function createDrizzleAdapter(db, tables) {
+  const {
+    eq,
+    and,
+    or,
+    isNull,
+    isNotNull,
+    gte,
+    ne,
+    sql
+  } = __require("drizzle-orm");
+  const { users, sessions, otps, passwordResets, devices, admins } = tables;
+  return {
+    user: {
+      async findByEmailInsensitive(email) {
+        const rows = await db.select().from(users).where(sql`lower(${users.email}) = lower(${email})`).limit(1);
+        return rows[0] ?? null;
+      },
+      async findByUsernameInsensitive(username) {
+        const rows = await db.select().from(users).where(sql`lower(${users.username}) = lower(${username})`).limit(1);
+        return rows[0] ?? null;
+      },
+      async findByEmailOrUsernameInsensitive(identifier) {
+        const rows = await db.select().from(users).where(
+          or(
+            sql`lower(${users.email}) = lower(${identifier})`,
+            sql`lower(${users.username}) = lower(${identifier})`
+          )
+        ).limit(1);
+        return rows[0] ?? null;
+      },
+      async findByEmailOrOAuthId(email, oauthId) {
+        const rows = await db.select().from(users).where(
+          or(
+            sql`lower(${users.email}) = lower(${email})`,
+            eq(users.oauthId, oauthId)
+          )
+        ).limit(1);
+        return rows[0] ?? null;
+      },
+      async findById(id) {
+        const rows = await db.select().from(users).where(eq(users.id, id)).limit(1);
+        return rows[0] ?? null;
+      },
+      async findActiveById(id) {
+        const rows = await db.select().from(users).where(and(eq(users.id, id), eq(users.status, "ACTIVE"))).limit(1);
+        return rows[0] ?? null;
+      },
+      async create(data) {
+        const rows = await db.insert(users).values(data).returning();
+        return rows[0];
+      },
+      async update(id, data) {
+        const rows = await db.update(users).set(data).where(eq(users.id, id)).returning();
+        return rows[0];
+      }
+    },
+    session: {
+      async findById(id) {
+        const rows = await db.select({
+          id: sessions.id,
+          userId: sessions.userId,
+          socketId: sessions.socketId,
+          twoFaSecret: sessions.twoFaSecret,
+          browserName: sessions.browserName,
+          issuedAt: sessions.issuedAt,
+          lastUsed: sessions.lastUsed,
+          revokedAt: sessions.revokedAt,
+          deviceId: sessions.deviceId,
+          user: {
+            status: users.status,
+            verifiedHumanAt: users.verifiedHumanAt
+          }
+        }).from(sessions).innerJoin(users, eq(sessions.userId, users.id)).where(eq(sessions.id, id)).limit(1);
+        return rows[0] ?? null;
+      },
+      async create(data) {
+        const rows = await db.insert(sessions).values(data).returning();
+        return rows[0];
+      },
+      async update(id, data) {
+        const rows = await db.update(sessions).set(data).where(eq(sessions.id, id)).returning();
+        return rows[0];
+      },
+      async updateLastUsed(id) {
+        await db.update(sessions).set({ lastUsed: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id));
+        const rows = await db.select({
+          id: sessions.id,
+          userId: sessions.userId,
+          socketId: sessions.socketId,
+          twoFaSecret: sessions.twoFaSecret,
+          browserName: sessions.browserName,
+          issuedAt: sessions.issuedAt,
+          lastUsed: sessions.lastUsed,
+          revokedAt: sessions.revokedAt,
+          deviceId: sessions.deviceId,
+          user: {
+            verifiedHumanAt: users.verifiedHumanAt
+          }
+        }).from(sessions).innerJoin(users, eq(sessions.userId, users.id)).where(eq(sessions.id, id)).limit(1);
+        return rows[0];
+      },
+      async revoke(id) {
+        await db.update(sessions).set({ revokedAt: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id));
+      },
+      async findActiveByUserId(userId, excludeSessionId) {
+        const conditions = [eq(sessions.userId, userId), isNull(sessions.revokedAt)];
+        if (excludeSessionId !== void 0) {
+          conditions.push(ne(sessions.id, excludeSessionId));
+        }
+        return db.select({
+          id: sessions.id,
+          socketId: sessions.socketId,
+          userId: sessions.userId
+        }).from(sessions).where(and(...conditions));
+      },
+      async revokeAllByUserId(userId, excludeSessionId) {
+        const conditions = [eq(sessions.userId, userId), isNull(sessions.revokedAt)];
+        if (excludeSessionId !== void 0) {
+          conditions.push(ne(sessions.id, excludeSessionId));
+        }
+        await db.update(sessions).set({ revokedAt: /* @__PURE__ */ new Date() }).where(and(...conditions));
+      },
+      async findTwoFaSecretsByUserId(userId) {
+        return db.select({ twoFaSecret: sessions.twoFaSecret }).from(sessions).where(and(eq(sessions.userId, userId), isNotNull(sessions.twoFaSecret)));
+      },
+      async clearTwoFaSecrets(userId, excludeSessionId) {
+        const conditions = [eq(sessions.userId, userId)];
+        if (excludeSessionId !== void 0) {
+          conditions.push(ne(sessions.id, excludeSessionId));
+        }
+        await db.update(sessions).set({ twoFaSecret: null }).where(and(...conditions));
+      },
+      async findByIdWithDevice(id, userId) {
+        const rows = await db.select({
+          twoFaSecret: sessions.twoFaSecret,
+          deviceId: sessions.deviceId,
+          device: {
+            pushToken: devices.pushToken
+          }
+        }).from(sessions).leftJoin(devices, eq(sessions.deviceId, devices.id)).where(and(eq(sessions.id, id), eq(sessions.userId, userId))).limit(1);
+        if (!rows[0]) return null;
+        const row = rows[0];
+        return {
+          twoFaSecret: row.twoFaSecret,
+          deviceId: row.deviceId,
+          device: row.device?.pushToken ? { pushToken: row.device.pushToken } : null
+        };
+      },
+      async revokeByDevicePushToken(userId, pushToken, excludeSessionId) {
+        const deviceRows = await db.select({ id: devices.id }).from(devices).where(eq(devices.pushToken, pushToken)).limit(1);
+        if (!deviceRows[0]) return;
+        await db.update(sessions).set({ revokedAt: /* @__PURE__ */ new Date() }).where(
+          and(
+            eq(sessions.userId, userId),
+            ne(sessions.id, excludeSessionId),
+            isNull(sessions.revokedAt),
+            eq(sessions.deviceId, deviceRows[0].id)
+          )
+        );
+      },
+      async clearDeviceId(userId, deviceId) {
+        await db.update(sessions).set({ deviceId: null }).where(and(eq(sessions.userId, userId), eq(sessions.deviceId, deviceId)));
+      }
+    },
+    otp: {
+      async findValidByUserAndCode(userId, code) {
+        const rows = await db.select().from(otps).where(
+          and(eq(otps.userId, userId), eq(otps.code, code), gte(otps.expiresAt, /* @__PURE__ */ new Date()))
+        ).limit(1);
+        return rows[0] ?? null;
+      },
+      async create(data) {
+        const rows = await db.insert(otps).values(data).returning();
+        return rows[0];
+      },
+      async delete(id) {
+        await db.delete(otps).where(eq(otps.id, id));
+      }
+    },
+    passwordReset: {
+      async findById(id) {
+        const rows = await db.select({
+          id: passwordResets.id,
+          createdAt: passwordResets.createdAt,
+          userId: passwordResets.userId
+        }).from(passwordResets).where(eq(passwordResets.id, id)).limit(1);
+        return rows[0] ?? null;
+      },
+      async create(userId) {
+        const rows = await db.insert(passwordResets).values({ userId }).returning();
+        return rows[0];
+      },
+      async delete(id) {
+        await db.delete(passwordResets).where(eq(passwordResets.id, id));
+      },
+      async deleteAllByUserId(userId) {
+        await db.delete(passwordResets).where(eq(passwordResets.userId, userId));
+      }
+    },
+    device: {
+      async findByTokenSessionAndUser(pushToken, sessionId, userId) {
+        const rows = await db.select({ id: devices.id }).from(devices).where(eq(devices.pushToken, pushToken)).limit(1);
+        if (!rows[0]) return null;
+        if (tables.devicesToSessions && tables.devicesToUsers) {
+          const sessionLink = await db.select().from(tables.devicesToSessions).where(
+            and(
+              eq(tables.devicesToSessions.deviceId, rows[0].id),
+              eq(tables.devicesToSessions.sessionId, sessionId)
+            )
+          ).limit(1);
+          const userLink = await db.select().from(tables.devicesToUsers).where(
+            and(
+              eq(tables.devicesToUsers.deviceId, rows[0].id),
+              eq(tables.devicesToUsers.userId, userId)
+            )
+          ).limit(1);
+          if (!sessionLink[0] || !userLink[0]) return null;
+        }
+        return { id: rows[0].id };
+      },
+      async upsertByPushToken(pushToken, sessionId, userId) {
+        const existing = await db.select({ id: devices.id }).from(devices).where(eq(devices.pushToken, pushToken)).limit(1);
+        let deviceId;
+        if (existing[0]) {
+          deviceId = existing[0].id;
+        } else {
+          const rows = await db.insert(devices).values({ pushToken }).returning({ id: devices.id });
+          deviceId = rows[0].id;
+        }
+        if (tables.devicesToSessions) {
+          await db.insert(tables.devicesToSessions).values({ deviceId, sessionId }).onConflictDoNothing();
+        }
+        if (tables.devicesToUsers) {
+          await db.insert(tables.devicesToUsers).values({ deviceId, userId }).onConflictDoNothing();
+        }
+        await db.update(sessions).set({ deviceId }).where(eq(sessions.id, sessionId));
+      },
+      async findByUserAndToken(userId, pushToken) {
+        if (tables.devicesToUsers) {
+          const rows2 = await db.select({ id: devices.id }).from(devices).innerJoin(
+            tables.devicesToUsers,
+            eq(devices.id, tables.devicesToUsers.deviceId)
+          ).where(
+            and(
+              eq(devices.pushToken, pushToken),
+              eq(tables.devicesToUsers.userId, userId)
+            )
+          ).limit(1);
+          return rows2[0] ? { id: rows2[0].id } : null;
+        }
+        const rows = await db.select({ id: devices.id }).from(devices).where(eq(devices.pushToken, pushToken)).limit(1);
+        return rows[0] ? { id: rows[0].id } : null;
+      },
+      async disconnectUser(deviceId, userId) {
+        if (tables.devicesToUsers) {
+          await db.delete(tables.devicesToUsers).where(
+            and(
+              eq(tables.devicesToUsers.deviceId, deviceId),
+              eq(tables.devicesToUsers.userId, userId)
+            )
+          );
+        }
+      },
+      async hasRemainingUsers(deviceId) {
+        if (tables.devicesToUsers) {
+          const rows = await db.select({ userId: tables.devicesToUsers.userId }).from(tables.devicesToUsers).where(eq(tables.devicesToUsers.deviceId, deviceId)).limit(1);
+          return rows.length > 0;
+        }
+        return false;
+      },
+      async delete(id) {
+        await db.delete(devices).where(eq(devices.id, id));
+      }
+    },
+    admin: {
+      async findByUserId(userId) {
+        const rows = await db.select({ ip: admins.ip }).from(admins).where(eq(admins.userId, userId)).limit(1);
+        return rows[0] ?? null;
+      }
+    }
+  };
+}
+
 // src/utilities/config.ts
 var defaultTokenSettings = {
   jwtExpiry: 30 * 24 * 60 * 60,
@@ -105,9 +645,16 @@ var defaultFeatures = {
   otpLogin: true
 };
 function createAuthConfig(config) {
+  if (!config.database && !config.prisma) {
+    throw new Error(
+      "@factiii/auth: Provide either a `database` adapter or a `prisma` client in config."
+    );
+  }
+  const database = config.database ?? createPrismaAdapter(config.prisma);
   const emailService = config.emailService ?? createNoopEmailAdapter();
   return {
     ...config,
+    database,
     features: { ...defaultFeatures, ...config.features },
     tokenSettings: { ...defaultTokenSettings, ...config.tokenSettings },
     cookieSettings: { ...defaultCookieSettings, ...config.cookieSettings },
@@ -225,6 +772,7 @@ function isTokenInvalidError(error) {
 function createAuthGuard(config, t) {
   const storageKeys = config.storageKeys ?? defaultStorageKeys;
   const cookieSettings = { ...defaultCookieSettings, ...config.cookieSettings };
+  const database = config.database ?? createPrismaAdapter(config.prisma);
   const revokeSession = async (ctx, sessionId, description, errorStack, path) => {
     clearAuthCookie(ctx.res, cookieSettings, storageKeys);
     if (config.hooks?.logError) {
@@ -261,15 +809,9 @@ ${errorStack}` : null,
     }
     if (sessionId) {
       try {
-        await config.prisma.session.update({
-          where: { id: sessionId },
-          data: { revokedAt: /* @__PURE__ */ new Date() }
-        });
+        await database.session.revoke(sessionId);
         if (config.hooks?.onSessionRevoked) {
-          const session = await config.prisma.session.findUnique({
-            where: { id: sessionId },
-            select: { id: true, userId: true, socketId: true }
-          });
+          const session = await database.session.findById(sessionId);
           if (session) {
             await config.hooks.onSessionRevoked(session.userId, session.socketId, description);
           }
@@ -294,23 +836,7 @@ ${errorStack}` : null,
           secret: config.secrets.jwt,
           ignoreExpiration: meta?.ignoreExpiration ?? false
         });
-        const session = await config.prisma.session.findUnique({
-          where: {
-            id: decodedToken.id
-          },
-          select: {
-            userId: true,
-            user: {
-              select: {
-                status: true,
-                verifiedHumanAt: true
-              }
-            },
-            revokedAt: true,
-            socketId: true,
-            id: true
-          }
-        });
+        const session = await database.session.findById(decodedToken.id);
         if (!session) {
           await revokeSession(
             ctx,
@@ -364,10 +890,7 @@ ${errorStack}` : null,
           });
         }
         if (meta?.adminRequired) {
-          const admin = await config.prisma.admin.findFirst({
-            where: { userId: session.userId },
-            select: { ip: true }
-          });
+          const admin = await database.admin.findByUserId(session.userId);
           if (!admin || admin.ip !== ctx.ip) {
             await revokeSession(
               ctx,
@@ -622,19 +1145,14 @@ var BaseProcedureFactory = class {
       if (this.config.hooks?.beforeRegister) {
         await this.config.hooks.beforeRegister(typedInput);
       }
-      const usernameCheck = await this.config.prisma.user.findFirst({
-        where: { username: { equals: username, mode: "insensitive" } }
-      });
+      const usernameCheck = await this.config.database.user.findByUsernameInsensitive(username);
       if (usernameCheck) {
         throw new TRPCError2({
           code: "CONFLICT",
           message: "An account already exists with that username."
         });
       }
-      const emailCheck = await this.config.prisma.user.findFirst({
-        where: { email: { equals: email, mode: "insensitive" } },
-        select: { id: true }
-      });
+      const emailCheck = await this.config.database.user.findByEmailInsensitive(email);
       if (emailCheck) {
         throw new TRPCError2({
           code: "CONFLICT",
@@ -642,30 +1160,25 @@ var BaseProcedureFactory = class {
         });
       }
       const hashedPassword = await hashPassword(password);
-      const user = await this.config.prisma.user.create({
-        data: {
-          username,
-          email,
-          password: hashedPassword,
-          status: "ACTIVE",
-          tag: this.config.features.biometric ? "BOT" : "HUMAN",
-          twoFaEnabled: false,
-          emailVerificationStatus: "UNVERIFIED",
-          verifiedHumanAt: null
-        }
+      const user = await this.config.database.user.create({
+        username,
+        email,
+        password: hashedPassword,
+        status: "ACTIVE",
+        tag: this.config.features.biometric ? "BOT" : "HUMAN",
+        twoFaEnabled: false,
+        emailVerificationStatus: "UNVERIFIED",
+        verifiedHumanAt: null
       });
       if (this.config.hooks?.onUserCreated) {
         await this.config.hooks.onUserCreated(user.id, typedInput);
       }
       const extraSessionData = this.config.hooks?.getSessionData ? await this.config.hooks.getSessionData(typedInput) : {};
-      const session = await this.config.prisma.session.create({
-        data: {
-          userId: user.id,
-          browserName: detectBrowser(userAgent),
-          socketId: null,
-          ...extraSessionData
-        },
-        select: { id: true, userId: true }
+      const session = await this.config.database.session.create({
+        userId: user.id,
+        browserName: detectBrowser(userAgent),
+        socketId: null,
+        ...extraSessionData
       });
       if (this.config.hooks?.onSessionCreated) {
         await this.config.hooks.onSessionCreated(session.id, typedInput);
@@ -703,24 +1216,7 @@ var BaseProcedureFactory = class {
       if (this.config.hooks?.beforeLogin) {
         await this.config.hooks.beforeLogin(typedInput);
       }
-      const user = await this.config.prisma.user.findFirst({
-        where: {
-          OR: [
-            { email: { equals: username, mode: "insensitive" } },
-            { username: { equals: username, mode: "insensitive" } }
-          ]
-        },
-        select: {
-          id: true,
-          status: true,
-          password: true,
-          twoFaEnabled: true,
-          email: true,
-          username: true,
-          oauthProvider: true,
-          verifiedHumanAt: true
-        }
-      });
+      const user = await this.config.database.user.findByEmailOrUsernameInsensitive(username);
       if (!user) {
         throw new TRPCError2({
           code: "FORBIDDEN",
@@ -756,14 +1252,12 @@ var BaseProcedureFactory = class {
         if (!code) {
           return {
             success: false,
-            requires2FA: true
+            requires2FA: true,
+            userId: user.id
           };
         }
         let validCode = false;
-        const secrets = await this.config.prisma.session.findMany({
-          where: { userId: user.id, twoFaSecret: { not: null } },
-          select: { twoFaSecret: true }
-        });
+        const secrets = await this.config.database.session.findTwoFaSecretsByUserId(user.id);
         for (const s of secrets) {
           if (s.twoFaSecret && await verifyTotp(code, cleanBase32String(s.twoFaSecret))) {
             validCode = true;
@@ -771,14 +1265,13 @@ var BaseProcedureFactory = class {
           }
         }
         if (!validCode) {
-          const checkOTP = await this.config.prisma.oTP.findFirst({
-            where: { userId: user.id, code: Number(code), expiresAt: { gte: /* @__PURE__ */ new Date() } }
-          });
+          const checkOTP = await this.config.database.otp.findValidByUserAndCode(
+            user.id,
+            Number(code)
+          );
           if (checkOTP) {
             validCode = true;
-            await this.config.prisma.oTP.delete({
-              where: { id: checkOTP.id }
-            });
+            await this.config.database.otp.delete(checkOTP.id);
           }
         }
         if (!validCode) {
@@ -789,24 +1282,11 @@ var BaseProcedureFactory = class {
         }
       }
       const extraSessionData = this.config.hooks?.getSessionData ? await this.config.hooks.getSessionData(typedInput) : {};
-      const session = await this.config.prisma.session.create({
-        data: {
-          userId: user.id,
-          browserName: detectBrowser(userAgent),
-          socketId: null,
-          ...extraSessionData
-        },
-        select: {
-          id: true,
-          userId: true,
-          socketId: true,
-          browserName: true,
-          issuedAt: true,
-          lastUsed: true,
-          revokedAt: true,
-          deviceId: true,
-          twoFaSecret: true
-        }
+      const session = await this.config.database.session.create({
+        userId: user.id,
+        browserName: detectBrowser(userAgent),
+        socketId: null,
+        ...extraSessionData
       });
       if (this.config.hooks?.onUserLogin) {
         await this.config.hooks.onUserLogin(user.id, session.id);
@@ -837,15 +1317,9 @@ var BaseProcedureFactory = class {
     return this.authProcedure.meta({ ignoreExpiration: true }).mutation(async ({ ctx }) => {
       const { userId, sessionId } = ctx;
       if (sessionId) {
-        await this.config.prisma.session.update({
-          where: { id: sessionId },
-          data: { revokedAt: /* @__PURE__ */ new Date() }
-        });
+        await this.config.database.session.revoke(sessionId);
         if (userId) {
-          await this.config.prisma.user.update({
-            where: { id: userId },
-            data: { isActive: false }
-          });
+          await this.config.database.user.update(userId, { isActive: false });
         }
         if (this.config.hooks?.afterLogout) {
           await this.config.hooks.afterLogout(userId, sessionId, ctx.socketId);
@@ -857,15 +1331,7 @@ var BaseProcedureFactory = class {
   }
   refresh() {
     return this.authProcedure.query(async ({ ctx }) => {
-      const session = await this.config.prisma.session.update({
-        where: { id: ctx.sessionId },
-        data: { lastUsed: /* @__PURE__ */ new Date() },
-        select: {
-          id: true,
-          userId: true,
-          user: { select: { verifiedHumanAt: true } }
-        }
-      });
+      const session = await this.config.database.session.updateLastUsed(ctx.sessionId);
       if (this.config.hooks?.onRefresh) {
         this.config.hooks.onRefresh(session.userId).catch(() => {
         });
@@ -890,22 +1356,14 @@ var BaseProcedureFactory = class {
     return this.authProcedure.input(endAllSessionsSchema).mutation(async ({ ctx, input }) => {
       const { skipCurrentSession } = input;
       const { userId, sessionId } = ctx;
-      const sessionsToRevoke = await this.config.prisma.session.findMany({
-        where: {
-          userId,
-          revokedAt: null,
-          ...skipCurrentSession ? { NOT: { id: sessionId } } : {}
-        },
-        select: { socketId: true, id: true, userId: true }
-      });
-      await this.config.prisma.session.updateMany({
-        where: {
-          userId,
-          revokedAt: null,
-          ...skipCurrentSession ? { NOT: { id: sessionId } } : {}
-        },
-        data: { revokedAt: /* @__PURE__ */ new Date() }
-      });
+      const sessionsToRevoke = await this.config.database.session.findActiveByUserId(
+        userId,
+        skipCurrentSession ? sessionId : void 0
+      );
+      await this.config.database.session.revokeAllByUserId(
+        userId,
+        skipCurrentSession ? sessionId : void 0
+      );
       for (const session of sessionsToRevoke) {
         if (this.config.hooks?.onSessionRevoked) {
           await this.config.hooks.onSessionRevoked(
@@ -916,10 +1374,7 @@ var BaseProcedureFactory = class {
         }
       }
       if (!skipCurrentSession) {
-        await this.config.prisma.user.update({
-          where: { id: userId },
-          data: { isActive: false }
-        });
+        await this.config.database.user.update(userId, { isActive: false });
       }
       return { success: true, revokedCount: sessionsToRevoke.length };
     });
@@ -934,10 +1389,7 @@ var BaseProcedureFactory = class {
           message: "New password cannot be the same as current password"
         });
       }
-      const user = await this.config.prisma.user.findUnique({
-        where: { id: userId },
-        select: { password: true }
-      });
+      const user = await this.config.database.user.findById(userId);
       if (!user) {
         throw new TRPCError2({ code: "NOT_FOUND", message: "User not found" });
       }
@@ -955,14 +1407,8 @@ var BaseProcedureFactory = class {
         });
       }
       const hashedPassword = await hashPassword(newPassword);
-      await this.config.prisma.user.update({
-        where: { id: userId },
-        data: { password: hashedPassword }
-      });
-      await this.config.prisma.session.updateMany({
-        where: { userId, revokedAt: null, NOT: { id: sessionId } },
-        data: { revokedAt: /* @__PURE__ */ new Date() }
-      });
+      await this.config.database.user.update(userId, { password: hashedPassword });
+      await this.config.database.session.revokeAllByUserId(userId, sessionId);
       if (this.config.hooks?.onPasswordChanged) {
         await this.config.hooks.onPasswordChanged(userId);
       }
@@ -975,11 +1421,8 @@ var BaseProcedureFactory = class {
   sendPasswordResetEmail() {
     return this.procedure.input(requestPasswordResetSchema).mutation(async ({ input }) => {
       const { email } = input;
-      const user = await this.config.prisma.user.findFirst({
-        where: { email: { equals: email, mode: "insensitive" }, status: "ACTIVE" },
-        select: { id: true, password: true, email: true }
-      });
-      if (!user) {
+      const user = await this.config.database.user.findByEmailInsensitive(email);
+      if (!user || user.status !== "ACTIVE") {
         return { message: "If an account exists with that email, a reset link has been sent." };
       }
       if (!user.password) {
@@ -988,10 +1431,8 @@ var BaseProcedureFactory = class {
           message: "This account uses social login. Please use that method."
         });
       }
-      await this.config.prisma.passwordReset.deleteMany({ where: { userId: user.id } });
-      const passwordReset = await this.config.prisma.passwordReset.create({
-        data: { userId: user.id }
-      });
+      await this.config.database.passwordReset.deleteAllByUserId(user.id);
+      const passwordReset = await this.config.database.passwordReset.create(user.id);
       if (this.config.emailService) {
         await this.config.emailService.sendPasswordResetEmail(user.email, String(passwordReset.id));
       }
@@ -1001,15 +1442,12 @@ var BaseProcedureFactory = class {
   checkPasswordReset() {
     return this.procedure.input(checkPasswordResetSchema).query(async ({ input }) => {
       const { token } = input;
-      const passwordReset = await this.config.prisma.passwordReset.findUnique({
-        where: { id: token },
-        select: { id: true, createdAt: true, userId: true }
-      });
+      const passwordReset = await this.config.database.passwordReset.findById(token);
       if (!passwordReset) {
         throw new TRPCError2({ code: "NOT_FOUND", message: "Invalid reset token." });
       }
       if (passwordReset.createdAt.getTime() + this.config.tokenSettings.passwordResetExpiryMs < Date.now()) {
-        await this.config.prisma.passwordReset.delete({ where: { id: token } });
+        await this.config.database.passwordReset.delete(token);
         throw new TRPCError2({ code: "FORBIDDEN", message: "Reset token expired." });
       }
       return { valid: true };
@@ -1018,31 +1456,23 @@ var BaseProcedureFactory = class {
   resetPassword() {
     return this.procedure.input(resetPasswordSchema).mutation(async ({ input }) => {
       const { token, password } = input;
-      const passwordReset = await this.config.prisma.passwordReset.findFirst({
-        where: { id: token },
-        select: { id: true, createdAt: true, userId: true }
-      });
+      const passwordReset = await this.config.database.passwordReset.findById(token);
       if (!passwordReset) {
         throw new TRPCError2({ code: "NOT_FOUND", message: "Invalid reset token." });
       }
       if (passwordReset.createdAt.getTime() + this.config.tokenSettings.passwordResetExpiryMs < Date.now()) {
-        await this.config.prisma.passwordReset.delete({ where: { id: token } });
+        await this.config.database.passwordReset.delete(token);
         throw new TRPCError2({ code: "FORBIDDEN", message: "Reset token expired." });
       }
       const hashedPassword = await hashPassword(password);
-      await this.config.prisma.user.update({
-        where: { id: passwordReset.userId },
-        data: { password: hashedPassword }
-      });
-      await this.config.prisma.passwordReset.delete({ where: { id: token } });
-      const sessionsToRevoke = await this.config.prisma.session.findMany({
-        where: { userId: passwordReset.userId, revokedAt: null },
-        select: { id: true, socketId: true, userId: true }
-      });
-      await this.config.prisma.session.updateMany({
-        where: { userId: passwordReset.userId, revokedAt: null },
-        data: { revokedAt: /* @__PURE__ */ new Date() }
+      await this.config.database.user.update(passwordReset.userId, {
+        password: hashedPassword
       });
+      await this.config.database.passwordReset.delete(token);
+      const sessionsToRevoke = await this.config.database.session.findActiveByUserId(
+        passwordReset.userId
+      );
+      await this.config.database.session.revokeAllByUserId(passwordReset.userId);
       for (const session of sessionsToRevoke) {
         if (this.config.hooks?.onSessionRevoked) {
           await this.config.hooks.onSessionRevoked(
@@ -1079,9 +1509,9 @@ var BiometricProcedureFactory = class {
     return this.authProcedure.input(biometricVerifySchema).mutation(async ({ ctx }) => {
       this.checkConfig();
       const { userId } = ctx;
-      await this.config.prisma.user.update({
-        where: { id: userId },
-        data: { verifiedHumanAt: /* @__PURE__ */ new Date(), tag: "HUMAN" }
+      await this.config.database.user.update(userId, {
+        verifiedHumanAt: /* @__PURE__ */ new Date(),
+        tag: "HUMAN"
       });
       if (this.config.hooks?.onBiometricVerified) {
         await this.config.hooks.onBiometricVerified(userId);
@@ -1093,10 +1523,7 @@ var BiometricProcedureFactory = class {
     return this.authProcedure.query(async ({ ctx }) => {
       this.checkConfig();
       const { userId } = ctx;
-      const user = await this.config.prisma.user.findUnique({
-        where: { id: userId },
-        select: { verifiedHumanAt: true }
-      });
+      const user = await this.config.database.user.findById(userId);
       if (!user) {
         throw new TRPCError3({ code: "NOT_FOUND", message: "User not found" });
       }
@@ -1143,10 +1570,7 @@ var EmailVerificationProcedureFactory = class {
     return this.authProcedure.mutation(async ({ ctx }) => {
       this.checkConfig();
       const { userId } = ctx;
-      const user = await this.config.prisma.user.findUnique({
-        where: { id: userId, status: "ACTIVE" },
-        select: { id: true, email: true, emailVerificationStatus: true }
-      });
+      const user = await this.config.database.user.findActiveById(userId);
       if (!user) {
         throw new TRPCError4({ code: "NOT_FOUND", message: "User not found" });
       }
@@ -1154,9 +1578,9 @@ var EmailVerificationProcedureFactory = class {
         return { message: "Email is already verified", emailSent: false };
       }
       const otp = randomUUID();
-      await this.config.prisma.user.update({
-        where: { id: userId },
-        data: { emailVerificationStatus: "PENDING", otpForEmailVerification: otp }
+      await this.config.database.user.update(userId, {
+        emailVerificationStatus: "PENDING",
+        otpForEmailVerification: otp
       });
       if (this.config.emailService) {
         try {
@@ -1174,10 +1598,7 @@ var EmailVerificationProcedureFactory = class {
       this.checkConfig();
       const { userId } = ctx;
       const { code } = input;
-      const user = await this.config.prisma.user.findUnique({
-        where: { id: userId, status: "ACTIVE" },
-        select: { id: true, emailVerificationStatus: true, otpForEmailVerification: true }
-      });
+      const user = await this.config.database.user.findActiveById(userId);
       if (!user) {
         throw new TRPCError4({ code: "NOT_FOUND", message: "User not found" });
       }
@@ -1187,9 +1608,9 @@ var EmailVerificationProcedureFactory = class {
       if (code !== user.otpForEmailVerification) {
         throw new TRPCError4({ code: "BAD_REQUEST", message: "Invalid verification code" });
       }
-      await this.config.prisma.user.update({
-        where: { id: userId },
-        data: { emailVerificationStatus: "VERIFIED", otpForEmailVerification: null }
+      await this.config.database.user.update(userId, {
+        emailVerificationStatus: "VERIFIED",
+        otpForEmailVerification: null
       });
       if (this.config.hooks?.onEmailVerified) {
         await this.config.hooks.onEmailVerified(userId);
@@ -1201,10 +1622,7 @@ var EmailVerificationProcedureFactory = class {
     return this.authProcedure.query(async ({ ctx }) => {
       this.checkConfig();
       const { userId } = ctx;
-      const user = await this.config.prisma.user.findUnique({
-        where: { id: userId },
-        select: { emailVerificationStatus: true, email: true }
-      });
+      const user = await this.config.database.user.findById(userId);
       if (!user) {
         throw new TRPCError4({ code: "NOT_FOUND", message: "User not found" });
       }
@@ -1258,23 +1676,7 @@ var OAuthLoginProcedureFactory = class {
           message: "Email not provided by OAuth provider"
         });
       }
-      let user = await this.config.prisma.user.findFirst({
-        where: {
-          OR: [{ email: { equals: email, mode: "insensitive" } }, { oauthId: { equals: oauthId } }]
-        },
-        select: {
-          id: true,
-          status: true,
-          email: true,
-          username: true,
-          password: true,
-          oauthProvider: true,
-          oauthId: true,
-          twoFaEnabled: true,
-          verifiedHumanAt: true,
-          emailVerificationStatus: true
-        }
-      });
+      let user = await this.config.database.user.findByEmailOrOAuthId(email, oauthId);
       if (user?.oauthProvider && user.oauthProvider !== provider) {
         throw new TRPCError5({
           code: "BAD_REQUEST",
@@ -1289,19 +1691,17 @@ var OAuthLoginProcedureFactory = class {
       }
       if (!user) {
         const generateUsername = this.config.generateUsername ?? (() => `user_${Date.now()}`);
-        user = await this.config.prisma.user.create({
-          data: {
-            username: generateUsername(),
-            email,
-            password: null,
-            emailVerificationStatus: "VERIFIED",
-            oauthProvider: provider,
-            oauthId,
-            status: "ACTIVE",
-            tag: this.config.features.biometric ? "BOT" : "HUMAN",
-            twoFaEnabled: false,
-            verifiedHumanAt: null
-          }
+        user = await this.config.database.user.create({
+          username: generateUsername(),
+          email,
+          password: null,
+          emailVerificationStatus: "VERIFIED",
+          oauthProvider: provider,
+          oauthId,
+          status: "ACTIVE",
+          tag: this.config.features.biometric ? "BOT" : "HUMAN",
+          twoFaEnabled: false,
+          verifiedHumanAt: null
         });
         if (this.config.hooks?.onUserCreated) {
           await this.config.hooks.onUserCreated(user.id, typedInput);
@@ -1317,24 +1717,11 @@ var OAuthLoginProcedureFactory = class {
         throw new TRPCError5({ code: "FORBIDDEN", message: "Your account has been banned." });
       }
       const extraSessionData = this.config.hooks?.getSessionData ? await this.config.hooks.getSessionData(typedInput) : {};
-      const session = await this.config.prisma.session.create({
-        data: {
-          userId: user.id,
-          browserName: detectBrowser(userAgent),
-          socketId: null,
-          ...extraSessionData
-        },
-        select: {
-          id: true,
-          userId: true,
-          socketId: true,
-          browserName: true,
-          issuedAt: true,
-          lastUsed: true,
-          revokedAt: true,
-          deviceId: true,
-          twoFaSecret: true
-        }
+      const session = await this.config.database.session.create({
+        userId: user.id,
+        browserName: detectBrowser(userAgent),
+        socketId: null,
+        ...extraSessionData
       });
       if (this.config.hooks?.onUserLogin) {
         await this.config.hooks.onUserLogin(user.id, session.id);
@@ -1391,10 +1778,7 @@ var TwoFaProcedureFactory = class {
     return this.authProcedure.mutation(async ({ ctx }) => {
       this.checkConfig();
       const { userId, sessionId } = ctx;
-      const user = await this.config.prisma.user.findFirst({
-        where: { id: userId },
-        select: { twoFaEnabled: true, oauthProvider: true, password: true }
-      });
+      const user = await this.config.database.user.findById(userId);
       if (!user) {
         throw new TRPCError6({ code: "NOT_FOUND", message: "User not found." });
       }
@@ -1408,10 +1792,7 @@ var TwoFaProcedureFactory = class {
         throw new TRPCError6({ code: "BAD_REQUEST", message: "2FA already enabled." });
       }
       if (this.config.features.twoFaRequiresDevice !== false) {
-        const checkSession = await this.config.prisma.session.findFirst({
-          where: { userId, id: sessionId },
-          select: { deviceId: true }
-        });
+        const checkSession = await this.config.database.session.findById(sessionId);
         if (!checkSession?.deviceId) {
           throw new TRPCError6({
             code: "BAD_REQUEST",
@@ -1419,23 +1800,11 @@ var TwoFaProcedureFactory = class {
           });
         }
       }
-      await this.config.prisma.session.updateMany({
-        where: { userId, revokedAt: null, NOT: { id: sessionId } },
-        data: { revokedAt: /* @__PURE__ */ new Date() }
-      });
-      await this.config.prisma.session.updateMany({
-        where: { userId, NOT: { id: sessionId } },
-        data: { twoFaSecret: null }
-      });
+      await this.config.database.session.revokeAllByUserId(userId, sessionId);
+      await this.config.database.session.clearTwoFaSecrets(userId, sessionId);
       const secret = generateTotpSecret();
-      await this.config.prisma.user.update({
-        where: { id: userId },
-        data: { twoFaEnabled: true }
-      });
-      await this.config.prisma.session.update({
-        where: { id: sessionId },
-        data: { twoFaSecret: secret }
-      });
+      await this.config.database.user.update(userId, { twoFaEnabled: true });
+      await this.config.database.session.update(sessionId, { twoFaSecret: secret });
       if (this.config.hooks?.onTwoFaStatusChanged) {
         await this.config.hooks.onTwoFaStatusChanged(userId, true);
       }
@@ -1447,10 +1816,7 @@ var TwoFaProcedureFactory = class {
       this.checkConfig();
       const { userId, sessionId } = ctx;
       const { password } = input;
-      const user = await this.config.prisma.user.findFirst({
-        where: { id: userId },
-        select: { password: true, status: true, oauthProvider: true }
-      });
+      const user = await this.config.database.user.findById(userId);
       if (!user) {
         throw new TRPCError6({ code: "NOT_FOUND", message: "User not found." });
       }
@@ -1473,14 +1839,8 @@ var TwoFaProcedureFactory = class {
       if (!isMatch) {
         throw new TRPCError6({ code: "FORBIDDEN", message: "Incorrect password." });
       }
-      await this.config.prisma.user.update({
-        where: { id: userId },
-        data: { twoFaEnabled: false }
-      });
-      await this.config.prisma.session.update({
-        where: { id: sessionId },
-        data: { twoFaSecret: null }
-      });
+      await this.config.database.user.update(userId, { twoFaEnabled: false });
+      await this.config.database.session.update(sessionId, { twoFaSecret: null });
       if (this.config.hooks?.onTwoFaStatusChanged) {
         await this.config.hooks.onTwoFaStatusChanged(userId, false);
       }
@@ -1492,10 +1852,7 @@ var TwoFaProcedureFactory = class {
       this.checkConfig();
       const { userId, sessionId } = ctx;
       const { pushCode } = input;
-      const user = await this.config.prisma.user.findFirst({
-        where: { id: userId },
-        select: { twoFaEnabled: true, oauthProvider: true }
-      });
+      const user = await this.config.database.user.findById(userId);
       if (user?.oauthProvider) {
         throw new TRPCError6({
           code: "FORBIDDEN",
@@ -1505,10 +1862,7 @@ var TwoFaProcedureFactory = class {
       if (!user?.twoFaEnabled) {
         throw new TRPCError6({ code: "BAD_REQUEST", message: "2FA not enabled." });
       }
-      const session = await this.config.prisma.session.findUnique({
-        where: { id: sessionId, userId },
-        select: { twoFaSecret: true, device: { select: { pushToken: true } } }
-      });
+      const session = await this.config.database.session.findByIdWithDevice(sessionId, userId);
       if (!session?.device) {
         throw new TRPCError6({ code: "BAD_REQUEST", message: "Invalid request" });
       }
@@ -1520,10 +1874,7 @@ var TwoFaProcedureFactory = class {
         return { secret: session.twoFaSecret };
       }
       const secret = generateTotpSecret();
-      await this.config.prisma.session.update({
-        where: { id: sessionId },
-        data: { twoFaSecret: secret }
-      });
+      await this.config.database.session.update(sessionId, { twoFaSecret: secret });
       return { secret };
     });
   }
@@ -1531,11 +1882,8 @@ var TwoFaProcedureFactory = class {
     return this.procedure.input(twoFaResetSchema).mutation(async ({ input }) => {
       this.checkConfig();
       const { username, password } = input;
-      const user = await this.config.prisma.user.findFirst({
-        where: { username: { equals: username, mode: "insensitive" }, twoFaEnabled: true },
-        select: { id: true, password: true, email: true }
-      });
-      if (!user) {
+      const user = await this.config.database.user.findByUsernameInsensitive(username);
+      if (!user || !user.twoFaEnabled) {
         throw new TRPCError6({ code: "UNAUTHORIZED", message: "Invalid credentials." });
       }
       if (!user.password) {
@@ -1550,9 +1898,7 @@ var TwoFaProcedureFactory = class {
       }
       const otp = generateOtp();
       const expiresAt = new Date(Date.now() + this.config.tokenSettings.otpValidityMs);
-      await this.config.prisma.oTP.create({
-        data: { userId: user.id, code: otp, expiresAt }
-      });
+      await this.config.database.otp.create({ userId: user.id, code: otp, expiresAt });
       if (this.config.emailService) {
         await this.config.emailService.sendOTPEmail(user.email, otp);
       }
@@ -1563,30 +1909,17 @@ var TwoFaProcedureFactory = class {
     return this.procedure.input(twoFaResetVerifySchema).mutation(async ({ input }) => {
       this.checkConfig();
       const { code, username } = input;
-      const user = await this.config.prisma.user.findFirst({
-        where: { username: { equals: username, mode: "insensitive" } },
-        select: { id: true }
-      });
+      const user = await this.config.database.user.findByUsernameInsensitive(username);
       if (!user) {
         throw new TRPCError6({ code: "NOT_FOUND", message: "User not found" });
       }
-      const otp = await this.config.prisma.oTP.findFirst({
-        where: { userId: user.id, code, expiresAt: { gte: /* @__PURE__ */ new Date() } }
-      });
+      const otp = await this.config.database.otp.findValidByUserAndCode(user.id, code);
       if (!otp) {
         throw new TRPCError6({ code: "FORBIDDEN", message: "Invalid or expired OTP" });
       }
-      await this.config.prisma.oTP.delete({
-        where: { id: otp.id }
-      });
-      await this.config.prisma.user.update({
-        where: { id: user.id },
-        data: { twoFaEnabled: false }
-      });
-      await this.config.prisma.session.updateMany({
-        where: { userId: user.id },
-        data: { twoFaSecret: null }
-      });
+      await this.config.database.otp.delete(otp.id);
+      await this.config.database.user.update(user.id, { twoFaEnabled: false });
+      await this.config.database.session.clearTwoFaSecrets(user.id);
       return { success: true, message: "2FA has been reset." };
     });
   }
@@ -1595,36 +1928,14 @@ var TwoFaProcedureFactory = class {
       this.checkConfig();
       const { userId, sessionId } = ctx;
       const { pushToken } = input;
-      await this.config.prisma.session.updateMany({
-        where: {
-          userId,
-          id: { not: sessionId },
-          revokedAt: null,
-          device: { pushToken }
-        },
-        data: { revokedAt: /* @__PURE__ */ new Date() }
-      });
-      const checkDevice = await this.config.prisma.device.findFirst({
-        where: {
-          pushToken,
-          sessions: { some: { id: sessionId } },
-          users: { some: { id: userId } }
-        },
-        select: { id: true }
-      });
+      await this.config.database.session.revokeByDevicePushToken(userId, pushToken, sessionId);
+      const checkDevice = await this.config.database.device.findByTokenSessionAndUser(
+        pushToken,
+        sessionId,
+        userId
+      );
       if (!checkDevice) {
-        await this.config.prisma.device.upsert({
-          where: { pushToken },
-          create: {
-            pushToken,
-            sessions: { connect: { id: sessionId } },
-            users: { connect: { id: userId } }
-          },
-          update: {
-            sessions: { connect: { id: sessionId } },
-            users: { connect: { id: userId } }
-          }
-        });
+        await this.config.database.device.upsertByPushToken(pushToken, sessionId, userId);
       }
       return { registered: true };
     });
@@ -1634,30 +1945,13 @@ var TwoFaProcedureFactory = class {
       this.checkConfig();
       const { userId } = ctx;
       const { pushToken } = input;
-      const device = await this.config.prisma.device.findFirst({
-        where: {
-          users: { some: { id: userId } },
-          pushToken
-        },
-        select: { id: true }
-      });
+      const device = await this.config.database.device.findByUserAndToken(userId, pushToken);
       if (device) {
-        await this.config.prisma.session.updateMany({
-          where: { userId, deviceId: device.id },
-          data: { deviceId: null }
-        });
-        await this.config.prisma.device.update({
-          where: { id: device.id },
-          data: { users: { disconnect: { id: userId } } }
-        });
-        const remainingUsers = await this.config.prisma.device.findUnique({
-          where: { id: device.id },
-          select: { users: { select: { id: true }, take: 1 } }
-        });
-        if (!remainingUsers?.users.length) {
-          await this.config.prisma.device.delete({
-            where: { id: device.id }
-          });
+        await this.config.database.session.clearDeviceId(userId, device.id);
+        await this.config.database.device.disconnectUser(device.id, userId);
+        const hasUsers = await this.config.database.device.hasRemainingUsers(device.id);
+        if (!hasUsers) {
+          await this.config.database.device.delete(device.id);
         }
       }
       return { deregistered: true };
@@ -1814,8 +2108,10 @@ export {
   createAuthRouter,
   createAuthToken,
   createConsoleEmailAdapter,
+  createDrizzleAdapter,
   createNoopEmailAdapter,
   createOAuthVerifier,
+  createPrismaAdapter,
   decodeToken,
   defaultAuthConfig,
   defaultCookieSettings,