@factiii/auth 0.5.5 → 0.5.6

package/dist/drizzle.js

@@ -0,0 +1,308 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/drizzle.ts
+var drizzle_exports = {};
+__export(drizzle_exports, {
+  createDrizzleAdapter: () => createDrizzleAdapter
+});
+module.exports = __toCommonJS(drizzle_exports);
+
+// src/adapters/drizzleAdapter.ts
+var import_drizzle_orm = require("drizzle-orm");
+function createDrizzleAdapter(db, tables) {
+  const { users, sessions, otps, passwordResets, devices, admins } = tables;
+  return {
+    user: {
+      async findByEmailInsensitive(email) {
+        const rows = await db.select().from(users).where(import_drizzle_orm.sql`lower(${users.email}) = lower(${email})`).limit(1);
+        return rows[0] ?? null;
+      },
+      async findByUsernameInsensitive(username) {
+        const rows = await db.select().from(users).where(import_drizzle_orm.sql`lower(${users.username}) = lower(${username})`).limit(1);
+        return rows[0] ?? null;
+      },
+      async findByEmailOrUsernameInsensitive(identifier) {
+        const rows = await db.select().from(users).where(
+          (0, import_drizzle_orm.or)(
+            import_drizzle_orm.sql`lower(${users.email}) = lower(${identifier})`,
+            import_drizzle_orm.sql`lower(${users.username}) = lower(${identifier})`
+          )
+        ).limit(1);
+        return rows[0] ?? null;
+      },
+      async findByEmailOrOAuthId(email, oauthId) {
+        const rows = await db.select().from(users).where(
+          (0, import_drizzle_orm.or)(
+            import_drizzle_orm.sql`lower(${users.email}) = lower(${email})`,
+            (0, import_drizzle_orm.eq)(users.oauthId, oauthId)
+          )
+        ).limit(1);
+        return rows[0] ?? null;
+      },
+      async findById(id) {
+        const rows = await db.select().from(users).where((0, import_drizzle_orm.eq)(users.id, id)).limit(1);
+        return rows[0] ?? null;
+      },
+      async findActiveById(id) {
+        const rows = await db.select().from(users).where((0, import_drizzle_orm.and)((0, import_drizzle_orm.eq)(users.id, id), (0, import_drizzle_orm.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((0, import_drizzle_orm.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, (0, import_drizzle_orm.eq)(sessions.userId, users.id)).where((0, import_drizzle_orm.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((0, import_drizzle_orm.eq)(sessions.id, id)).returning();
+        return rows[0];
+      },
+      async updateLastUsed(id) {
+        await db.update(sessions).set({ lastUsed: /* @__PURE__ */ new Date() }).where((0, import_drizzle_orm.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, (0, import_drizzle_orm.eq)(sessions.userId, users.id)).where((0, import_drizzle_orm.eq)(sessions.id, id)).limit(1);
+        return rows[0];
+      },
+      async revoke(id) {
+        await db.update(sessions).set({ revokedAt: /* @__PURE__ */ new Date() }).where((0, import_drizzle_orm.eq)(sessions.id, id));
+      },
+      async findActiveByUserId(userId, excludeSessionId) {
+        const conditions = [(0, import_drizzle_orm.eq)(sessions.userId, userId), (0, import_drizzle_orm.isNull)(sessions.revokedAt)];
+        if (excludeSessionId !== void 0) {
+          conditions.push((0, import_drizzle_orm.ne)(sessions.id, excludeSessionId));
+        }
+        const activeRows = await db.select({
+          id: sessions.id,
+          socketId: sessions.socketId,
+          userId: sessions.userId
+        }).from(sessions).where((0, import_drizzle_orm.and)(...conditions));
+        return activeRows;
+      },
+      async revokeAllByUserId(userId, excludeSessionId) {
+        const conditions = [(0, import_drizzle_orm.eq)(sessions.userId, userId), (0, import_drizzle_orm.isNull)(sessions.revokedAt)];
+        if (excludeSessionId !== void 0) {
+          conditions.push((0, import_drizzle_orm.ne)(sessions.id, excludeSessionId));
+        }
+        await db.update(sessions).set({ revokedAt: /* @__PURE__ */ new Date() }).where((0, import_drizzle_orm.and)(...conditions));
+      },
+      async findTwoFaSecretsByUserId(userId) {
+        const secretRows = await db.select({ twoFaSecret: sessions.twoFaSecret }).from(sessions).where((0, import_drizzle_orm.and)((0, import_drizzle_orm.eq)(sessions.userId, userId), (0, import_drizzle_orm.isNotNull)(sessions.twoFaSecret)));
+        return secretRows;
+      },
+      async clearTwoFaSecrets(userId, excludeSessionId) {
+        const conditions = [(0, import_drizzle_orm.eq)(sessions.userId, userId)];
+        if (excludeSessionId !== void 0) {
+          conditions.push((0, import_drizzle_orm.ne)(sessions.id, excludeSessionId));
+        }
+        await db.update(sessions).set({ twoFaSecret: null }).where((0, import_drizzle_orm.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, (0, import_drizzle_orm.eq)(sessions.deviceId, devices.id)).where((0, import_drizzle_orm.and)((0, import_drizzle_orm.eq)(sessions.id, id), (0, import_drizzle_orm.eq)(sessions.userId, userId))).limit(1);
+        if (!rows[0]) return null;
+        const row = rows[0];
+        const device = row.device;
+        return {
+          twoFaSecret: row.twoFaSecret,
+          deviceId: row.deviceId,
+          device: device?.pushToken ? { pushToken: device.pushToken } : null
+        };
+      },
+      async revokeByDevicePushToken(userId, pushToken, excludeSessionId) {
+        const deviceRows = await db.select({ id: devices.id }).from(devices).where((0, import_drizzle_orm.eq)(devices.pushToken, pushToken)).limit(1);
+        if (!deviceRows[0]) return;
+        await db.update(sessions).set({ revokedAt: /* @__PURE__ */ new Date() }).where(
+          (0, import_drizzle_orm.and)(
+            (0, import_drizzle_orm.eq)(sessions.userId, userId),
+            (0, import_drizzle_orm.ne)(sessions.id, excludeSessionId),
+            (0, import_drizzle_orm.isNull)(sessions.revokedAt),
+            (0, import_drizzle_orm.eq)(sessions.deviceId, deviceRows[0].id)
+          )
+        );
+      },
+      async clearDeviceId(userId, deviceId) {
+        await db.update(sessions).set({ deviceId: null }).where((0, import_drizzle_orm.and)((0, import_drizzle_orm.eq)(sessions.userId, userId), (0, import_drizzle_orm.eq)(sessions.deviceId, deviceId)));
+      }
+    },
+    otp: {
+      async findValidByUserAndCode(userId, code) {
+        const rows = await db.select().from(otps).where(
+          (0, import_drizzle_orm.and)((0, import_drizzle_orm.eq)(otps.userId, userId), (0, import_drizzle_orm.eq)(otps.code, code), (0, import_drizzle_orm.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((0, import_drizzle_orm.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((0, import_drizzle_orm.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((0, import_drizzle_orm.eq)(passwordResets.id, id));
+      },
+      async deleteAllByUserId(userId) {
+        await db.delete(passwordResets).where((0, import_drizzle_orm.eq)(passwordResets.userId, userId));
+      }
+    },
+    device: {
+      async findByTokenSessionAndUser(pushToken, sessionId, userId) {
+        const rows = await db.select({ id: devices.id }).from(devices).where((0, import_drizzle_orm.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(
+            (0, import_drizzle_orm.and)(
+              (0, import_drizzle_orm.eq)(tables.devicesToSessions.deviceId, rows[0].id),
+              (0, import_drizzle_orm.eq)(tables.devicesToSessions.sessionId, sessionId)
+            )
+          ).limit(1);
+          const userLink = await db.select().from(tables.devicesToUsers).where(
+            (0, import_drizzle_orm.and)(
+              (0, import_drizzle_orm.eq)(tables.devicesToUsers.deviceId, rows[0].id),
+              (0, import_drizzle_orm.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((0, import_drizzle_orm.eq)(devices.pushToken, pushToken)).limit(1);
+        let deviceId;
+        if (existing[0]) {
+          deviceId = existing[0].id;
+        } else {
+          const insertedRows = await db.insert(devices).values({ pushToken }).returning({ id: devices.id });
+          deviceId = insertedRows[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((0, import_drizzle_orm.eq)(sessions.id, sessionId));
+      },
+      async findByUserAndToken(userId, pushToken) {
+        if (tables.devicesToUsers) {
+          const joinRows = await db.select({ id: devices.id }).from(devices).innerJoin(
+            tables.devicesToUsers,
+            (0, import_drizzle_orm.eq)(devices.id, tables.devicesToUsers.deviceId)
+          ).where(
+            (0, import_drizzle_orm.and)(
+              (0, import_drizzle_orm.eq)(devices.pushToken, pushToken),
+              (0, import_drizzle_orm.eq)(tables.devicesToUsers.userId, userId)
+            )
+          ).limit(1);
+          return joinRows[0] ? { id: joinRows[0].id } : null;
+        }
+        const rows = await db.select({ id: devices.id }).from(devices).where((0, import_drizzle_orm.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(
+            (0, import_drizzle_orm.and)(
+              (0, import_drizzle_orm.eq)(tables.devicesToUsers.deviceId, deviceId),
+              (0, import_drizzle_orm.eq)(tables.devicesToUsers.userId, userId)
+            )
+          );
+        }
+      },
+      async hasRemainingUsers(deviceId) {
+        if (tables.devicesToUsers) {
+          const remainingRows = await db.select({ userId: tables.devicesToUsers.userId }).from(tables.devicesToUsers).where((0, import_drizzle_orm.eq)(tables.devicesToUsers.deviceId, deviceId)).limit(1);
+          return remainingRows.length > 0;
+        }
+        return false;
+      },
+      async delete(id) {
+        await db.delete(devices).where((0, import_drizzle_orm.eq)(devices.id, id));
+      }
+    },
+    admin: {
+      async findByUserId(userId) {
+        const rows = await db.select({ ip: admins.ip }).from(admins).where((0, import_drizzle_orm.eq)(admins.userId, userId)).limit(1);
+        return rows[0] ?? null;
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDrizzleAdapter
+});

package/dist/drizzle.mjs

@@ -0,0 +1,281 @@
+// src/adapters/drizzleAdapter.ts
+import { eq, and, or, isNull, isNotNull, gte, ne, sql } from "drizzle-orm";
+function createDrizzleAdapter(db, tables) {
+  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));
+        }
+        const activeRows = await db.select({
+          id: sessions.id,
+          socketId: sessions.socketId,
+          userId: sessions.userId
+        }).from(sessions).where(and(...conditions));
+        return activeRows;
+      },
+      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) {
+        const secretRows = await db.select({ twoFaSecret: sessions.twoFaSecret }).from(sessions).where(and(eq(sessions.userId, userId), isNotNull(sessions.twoFaSecret)));
+        return secretRows;
+      },
+      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];
+        const device = row.device;
+        return {
+          twoFaSecret: row.twoFaSecret,
+          deviceId: row.deviceId,
+          device: device?.pushToken ? { pushToken: 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 insertedRows = await db.insert(devices).values({ pushToken }).returning({ id: devices.id });
+          deviceId = insertedRows[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 joinRows = 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 joinRows[0] ? { id: joinRows[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 remainingRows = await db.select({ userId: tables.devicesToUsers.userId }).from(tables.devicesToUsers).where(eq(tables.devicesToUsers.deviceId, deviceId)).limit(1);
+          return remainingRows.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;
+      }
+    }
+  };
+}
+export {
+  createDrizzleAdapter
+};