@factiii/auth 0.5.5 → 0.5.6

package/dist/index.js

@@ -42,7 +42,6 @@ __export(index_exports, {
   createAuthRouter: () => createAuthRouter,
   createAuthToken: () => createAuthToken,
   createConsoleEmailAdapter: () => createConsoleEmailAdapter,
-  createDrizzleAdapter: () => createDrizzleAdapter,
   createNoopEmailAdapter: () => createNoopEmailAdapter,
   createOAuthVerifier: () => createOAuthVerifier,
   createPrismaAdapter: () => createPrismaAdapter,
@@ -390,298 +389,10 @@ 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));
-        }
-        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;
-      }
-    }
-  };
-}
-
 // src/utilities/config.ts
 var defaultTokenSettings = {
-  jwtExpiry: 30 * 24 * 60 * 60,
-  // 30 days in seconds
+  jwtExpiry: 365 * 24 * 60 * 60,
+  // 1 year in seconds
   passwordResetExpiryMs: 60 * 60 * 1e3,
   // 1 hour
   otpValidityMs: 15 * 60 * 1e3
@@ -692,8 +403,8 @@ var defaultCookieSettings = {
   sameSite: "Strict",
   httpOnly: false,
   path: "/",
-  maxAge: 30 * 24 * 60 * 60
-  // 30 days in seconds
+  maxAge: 365 * 24 * 60 * 60
+  // 1 year in seconds (matches jwtExpiry)
 };
 var defaultStorageKeys = {
   authToken: "auth-token"
@@ -2282,7 +1993,6 @@ function createAuthRouter(config) {
   createAuthRouter,
   createAuthToken,
   createConsoleEmailAdapter,
-  createDrizzleAdapter,
   createNoopEmailAdapter,
   createOAuthVerifier,
   createPrismaAdapter,

package/dist/index.mjs

@@ -1,5 +1,4 @@
 import {
-  __require,
   biometricVerifySchema,
   changePasswordSchema,
   checkPasswordResetSchema,
@@ -18,7 +17,7 @@ import {
   twoFaResetVerifySchema,
   twoFaVerifySchema,
   verifyEmailSchema
-} from "./chunk-KUYH4DBN.mjs";
+} from "./chunk-EHI4P63M.mjs";
 
 // src/middleware/authGuard.ts
 import { TRPCError } from "@trpc/server";
@@ -331,298 +330,10 @@ 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));
-        }
-        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;
-      }
-    }
-  };
-}
-
 // src/utilities/config.ts
 var defaultTokenSettings = {
-  jwtExpiry: 30 * 24 * 60 * 60,
-  // 30 days in seconds
+  jwtExpiry: 365 * 24 * 60 * 60,
+  // 1 year in seconds
   passwordResetExpiryMs: 60 * 60 * 1e3,
   // 1 hour
   otpValidityMs: 15 * 60 * 1e3
@@ -633,8 +344,8 @@ var defaultCookieSettings = {
   sameSite: "Strict",
   httpOnly: false,
   path: "/",
-  maxAge: 30 * 24 * 60 * 60
-  // 30 days in seconds
+  maxAge: 365 * 24 * 60 * 60
+  // 1 year in seconds (matches jwtExpiry)
 };
 var defaultStorageKeys = {
   authToken: "auth-token"
@@ -2144,7 +1855,6 @@ export {
   createAuthRouter,
   createAuthToken,
   createConsoleEmailAdapter,
-  createDrizzleAdapter,
   createNoopEmailAdapter,
   createOAuthVerifier,
   createPrismaAdapter,

package/dist/validators.mjs

@@ -17,7 +17,7 @@ import {
   twoFaResetVerifySchema,
   twoFaVerifySchema,
   verifyEmailSchema
-} from "./chunk-KUYH4DBN.mjs";
+} from "./chunk-EHI4P63M.mjs";
 export {
   biometricVerifySchema,
   changePasswordSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@factiii/auth",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "publishConfig": {
     "access": "public"
   },
@@ -37,6 +37,11 @@
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
     },
+    "./drizzle": {
+      "types": "./dist/drizzle.d.ts",
+      "import": "./dist/drizzle.mjs",
+      "require": "./dist/drizzle.js"
+    },
     "./validators": {
       "types": "./dist/validators.d.ts",
       "import": "./dist/validators.mjs",