@robelest/convex-auth 0.0.2-preview.0 → 0.0.2-preview.2

package/src/server/implementation/mutations/createAccountFromCredentials.ts

@@ -5,7 +5,8 @@ import { ConvexCredentialsConfig } from "../../types.js";
 import { upsertUserAndAccount } from "../users.js";
 import { getAuthSessionId } from "../sessions.js";
 import { LOG_LEVELS, logWithLevel, maybeRedact } from "../utils.js";
-import { createAuthDb } from "../db.js";
+import { authDb } from "../db.js";
+import { AUTH_STORE_REF } from "./storeRef.js";
 
 export const createAccountFromCredentialsArgs = v.object({
   provider: v.string(),
@@ -37,18 +38,12 @@ export async function createAccountFromCredentialsImpl(
     shouldLinkViaEmail,
     shouldLinkViaPhone,
   } = args;
-  const authDb =
-    config.component !== undefined ? createAuthDb(ctx, config.component) : null;
+  const db = authDb(ctx, config);
   const provider = getProviderOrThrow(providerId) as ConvexCredentialsConfig;
-  const existingAccount =
-    authDb !== null
-      ? ((await authDb.accounts.get(provider.id, account.id)) as Doc<"account"> | null)
-      : await ctx.db
-          .query("account")
-          .withIndex("providerAndAccountId", (q) =>
-            q.eq("provider", provider.id).eq("providerAccountId", account.id),
-          )
-          .unique();
+  const existingAccount = (await db.accounts.get(
+    provider.id,
+    account.id,
+  )) as Doc<"account"> | null;
   if (existingAccount !== null) {
     if (
       account.secret !== undefined &&
@@ -63,10 +58,7 @@ export async function createAccountFromCredentialsImpl(
     return {
       account: existingAccount,
       // TODO: Ian removed this,
-      user:
-        authDb !== null
-          ? ((await authDb.users.getById(existingAccount.userId)) as unknown as Doc<"user">)
-          : (await ctx.db.get(existingAccount.userId))!,
+      user: (await db.users.getById(existingAccount.userId)) as unknown as Doc<"user">,
     };
   }
 
@@ -89,14 +81,8 @@ export async function createAccountFromCredentialsImpl(
   );
 
   return {
-    account:
-      authDb !== null
-        ? ((await authDb.accounts.getById(accountId)) as Doc<"account">)
-        : (await ctx.db.get(accountId))!,
-    user:
-      authDb !== null
-        ? ((await authDb.users.getById(userId)) as unknown as Doc<"user">)
-        : (await ctx.db.get(userId))!,
+    account: (await db.accounts.getById(accountId)) as Doc<"account">,
+    user: (await db.users.getById(userId)) as unknown as Doc<"user">,
   };
 }
 
@@ -104,7 +90,7 @@ export const callCreateAccountFromCredentials = async (
   ctx: ActionCtx,
   args: Infer<typeof createAccountFromCredentialsArgs>,
 ): Promise<ReturnType> => {
-  return ctx.runMutation("auth:store" as any, {
+  return ctx.runMutation(AUTH_STORE_REF, {
     args: {
       type: "createAccountFromCredentials",
       ...args,

package/src/server/implementation/mutations/createVerificationCode.ts

@@ -5,7 +5,8 @@ import { EmailConfig, PhoneConfig } from "../../types.js";
 import { getAccountOrThrow, upsertUserAndAccount } from "../users.js";
 import { getAuthSessionId } from "../sessions.js";
 import { LOG_LEVELS, logWithLevel, sha256 } from "../utils.js";
-import { createAuthDb } from "../db.js";
+import { authDb } from "../db.js";
+import { AUTH_STORE_REF } from "./storeRef.js";
 
 export const createVerificationCodeArgs = v.object({
   accountId: v.optional(v.string()),
@@ -35,24 +36,14 @@ export async function createVerificationCodeImpl(
     accountId: existingAccountId,
     allowExtraProviders,
   } = args;
-  const authDb =
-    config.component !== undefined ? createAuthDb(ctx, config.component) : null;
+  const db = authDb(ctx, config);
   const typedExistingAccountId = existingAccountId as
     | GenericId<"account">
     | undefined;
   const existingAccount =
     typedExistingAccountId !== undefined
       ? await getAccountOrThrow(ctx, typedExistingAccountId, config)
-      : authDb !== null
-        ? await authDb.accounts.get(providerId, email ?? phone!)
-        : await ctx.db
-            .query("account")
-            .withIndex("providerAndAccountId", (q) =>
-              q
-                .eq("provider", providerId)
-                .eq("providerAccountId", email ?? phone!),
-            )
-            .unique();
+      : await db.accounts.get(providerId, email ?? phone!);
 
   const provider = getProviderOrThrow(providerId, allowExtraProviders) as
     | EmailConfig
@@ -84,7 +75,7 @@ export const callCreateVerificationCode = async (
   ctx: ActionCtx,
   args: Infer<typeof createVerificationCodeArgs>,
 ): Promise<ReturnType> => {
-  return ctx.runMutation("auth:store" as any, {
+  return ctx.runMutation(AUTH_STORE_REF, {
     args: {
       type: "createVerificationCode",
       ...args,
@@ -101,39 +92,17 @@ async function generateUniqueVerificationCode(
   { email, phone }: { email?: string; phone?: string },
   config: Provider.Config,
 ) {
-  const authDb =
-    config.component !== undefined ? createAuthDb(ctx, config.component) : null;
-  const existingCode =
-    authDb !== null
-      ? await authDb.verificationCodes.getByAccountId(accountId)
-      : await ctx.db
-          .query("verification")
-          .withIndex("accountId", (q) => q.eq("accountId", accountId))
-          .unique();
+  const db = authDb(ctx, config);
+  const existingCode = await db.verificationCodes.getByAccountId(accountId);
   if (existingCode !== null) {
-    if (authDb !== null) {
-      await authDb.verificationCodes.delete(existingCode._id);
-    } else {
-      await ctx.db.delete(existingCode._id);
-    }
-  }
-  if (authDb !== null) {
-    await authDb.verificationCodes.create({
-      accountId,
-      provider,
-      code: await sha256(code),
-      expirationTime,
-      emailVerified: email,
-      phoneVerified: phone,
-    });
-  } else {
-    await ctx.db.insert("verification", {
-      accountId,
-      provider,
-      code: await sha256(code),
-      expirationTime,
-      emailVerified: email,
-      phoneVerified: phone,
-    });
+    await db.verificationCodes.delete(existingCode._id);
   }
+  await db.verificationCodes.create({
+    accountId,
+    provider,
+    code: await sha256(code),
+    expirationTime,
+    emailVerified: email,
+    phoneVerified: phone,
+  });
 }

package/src/server/implementation/mutations/invalidateSessions.ts

@@ -3,7 +3,8 @@ import { deleteSession } from "../sessions.js";
 import { ActionCtx, MutationCtx } from "../types.js";
 import { LOG_LEVELS, logWithLevel } from "../utils.js";
 import * as Provider from "../provider.js";
-import { createAuthDb } from "../db.js";
+import { authDb } from "../db.js";
+import { AUTH_STORE_REF } from "./storeRef.js";
 
 export const invalidateSessionsArgs = v.object({
   userId: v.string(),
@@ -14,7 +15,7 @@ export const callInvalidateSessions = async (
   ctx: ActionCtx,
   args: Infer<typeof invalidateSessionsArgs>,
 ): Promise<void> => {
-  return ctx.runMutation("auth:store" as any, {
+  return ctx.runMutation(AUTH_STORE_REF, {
     args: {
       type: "invalidateSessions",
       ...args,
@@ -31,13 +32,7 @@ export const invalidateSessionsImpl = async (
   const { userId, except } = args;
   const exceptSet = new Set(except ?? []);
   const typedUserId = userId as GenericId<"user">;
-  const sessions =
-    config.component !== undefined
-      ? await createAuthDb(ctx, config.component).sessions.listByUser(typedUserId)
-      : await ctx.db
-          .query("session")
-          .withIndex("userId", (q) => q.eq("userId", typedUserId))
-          .collect();
+  const sessions = await authDb(ctx, config).sessions.listByUser(typedUserId);
   for (const session of sessions) {
     if (!exceptSet.has(session._id)) {
       await deleteSession(ctx, session, config);

package/src/server/implementation/mutations/modifyAccount.ts

@@ -3,7 +3,8 @@ import { ActionCtx, MutationCtx } from "../types.js";
 import { GetProviderOrThrowFunc, hash } from "../provider.js";
 import { LOG_LEVELS, logWithLevel, maybeRedact } from "../utils.js";
 import * as Provider from "../provider.js";
-import { createAuthDb } from "../db.js";
+import { authDb } from "../db.js";
+import { AUTH_STORE_REF } from "./storeRef.js";
 
 export const modifyAccountArgs = v.object({
   provider: v.string(),
@@ -17,8 +18,7 @@ export async function modifyAccountImpl(
   config: Provider.Config,
 ): Promise<void> {
   const { provider, account } = args;
-  const authDb =
-    config.component !== undefined ? createAuthDb(ctx, config.component) : null;
+  const db = authDb(ctx, config);
   logWithLevel(LOG_LEVELS.DEBUG, "retrieveAccountWithCredentialsImpl args:", {
     provider: provider,
     account: {
@@ -26,29 +26,15 @@ export async function modifyAccountImpl(
       secret: maybeRedact(account.secret ?? ""),
     },
   });
-  const existingAccount =
-    authDb !== null
-      ? await authDb.accounts.get(provider, account.id)
-      : await ctx.db
-          .query("account")
-          .withIndex("providerAndAccountId", (q) =>
-            q.eq("provider", provider).eq("providerAccountId", account.id),
-          )
-          .unique();
+  const existingAccount = await db.accounts.get(provider, account.id);
   if (existingAccount === null) {
     throw new Error(
       `Cannot modify account with ID ${account.id} because it does not exist`,
     );
   }
-  if (authDb !== null) {
-    await authDb.accounts.patch(existingAccount._id, {
-      secret: await hash(getProviderOrThrow(provider), account.secret),
-    });
-  } else {
-    await ctx.db.patch(existingAccount._id, {
-      secret: await hash(getProviderOrThrow(provider), account.secret),
-    });
-  }
+  await db.accounts.patch(existingAccount._id, {
+    secret: await hash(getProviderOrThrow(provider), account.secret),
+  });
   return;
 }
 
@@ -56,7 +42,7 @@ export const callModifyAccount = async (
   ctx: ActionCtx,
   args: Infer<typeof modifyAccountArgs>,
 ): Promise<void> => {
-  return ctx.runMutation("auth:store" as any, {
+  return ctx.runMutation(AUTH_STORE_REF, {
     args: {
       type: "modifyAccount",
       ...args,

package/src/server/implementation/mutations/refreshSession.ts

@@ -1,5 +1,5 @@
 import { Infer, v } from "convex/values";
-import { ActionCtx, MutationCtx } from "../types.js";
+import { ActionCtx, Doc, MutationCtx } from "../types.js";
 import * as Provider from "../provider.js";
 import { logWithLevel, maybeRedact } from "../utils.js";
 import {
@@ -11,7 +11,8 @@ import {
   refreshTokenIfValid,
 } from "../refreshTokens.js";
 import { generateTokensForSession } from "../sessions.js";
-import { createAuthDb } from "../db.js";
+import { authDb } from "../db.js";
+import { AUTH_STORE_REF } from "./storeRef.js";
 
 export const refreshSessionArgs = v.object({
   refreshToken: v.string(),
@@ -28,8 +29,7 @@ export async function refreshSessionImpl(
   getProviderOrThrow: Provider.GetProviderOrThrowFunc,
   config: Provider.Config,
 ): Promise<ReturnType> {
-  const authDb =
-    config.component !== undefined ? createAuthDb(ctx, config.component) : null;
+  const db = authDb(ctx, config);
   const { refreshToken } = args;
   const { refreshTokenId, sessionId: tokenSessionId } =
     parseRefreshToken(refreshToken);
@@ -49,21 +49,14 @@ export async function refreshSessionImpl(
   if (validationResult === null) {
     // Replicating `deleteSession` but ensuring that we delete both the session
     // and the refresh token, even if one of them is missing.
-    let session = null;
+    let session: Doc<"session"> | null = null;
     try {
-      session =
-        authDb !== null
-          ? await authDb.sessions.getById(tokenSessionId)
-          : await ctx.db.get(tokenSessionId);
+      session = await db.sessions.getById(tokenSessionId);
     } catch {
       logWithLevel("DEBUG", "Skipping invalid session id during refresh cleanup");
     }
     if (session !== null) {
-      if (authDb !== null) {
-        await authDb.sessions.delete(session._id);
-      } else {
-        await ctx.db.delete(session._id);
-      }
+      await db.sessions.delete(session._id);
     }
     try {
       await deleteAllRefreshTokens(ctx, tokenSessionId, config);
@@ -83,15 +76,9 @@ export async function refreshSessionImpl(
 
   // First use -- mark as used and generate new refresh token
   if (tokenFirstUsed === undefined) {
-    if (authDb !== null) {
-      await authDb.refreshTokens.patch(refreshTokenId, {
-        firstUsedTime: Date.now(),
-      });
-    } else {
-      await ctx.db.patch(refreshTokenId, {
-        firstUsedTime: Date.now(),
-      });
-    }
+    await db.refreshTokens.patch(refreshTokenId, {
+      firstUsedTime: Date.now(),
+    });
     const result = await generateTokensForSession(ctx, config, {
       userId,
       sessionId,
@@ -179,7 +166,7 @@ export const callRefreshSession = async (
   ctx: ActionCtx,
   args: Infer<typeof refreshSessionArgs>,
 ): Promise<ReturnType> => {
-  return ctx.runMutation("auth:store" as any, {
+  return ctx.runMutation(AUTH_STORE_REF, {
     args: {
       type: "refreshSession",
       ...args,

package/src/server/implementation/mutations/retrieveAccountWithCredentials.ts

@@ -7,7 +7,8 @@ import {
 } from "../rateLimit.js";
 import * as Provider from "../provider.js";
 import { LOG_LEVELS, logWithLevel, maybeRedact } from "../utils.js";
-import { createAuthDb } from "../db.js";
+import { authDb } from "../db.js";
+import { AUTH_STORE_REF } from "./storeRef.js";
 
 export const retrieveAccountWithCredentialsArgs = v.object({
   provider: v.string(),
@@ -27,8 +28,7 @@ export async function retrieveAccountWithCredentialsImpl(
   config: Provider.Config,
 ): Promise<ReturnType> {
   const { provider: providerId, account } = args;
-  const authDb =
-    config.component !== undefined ? createAuthDb(ctx, config.component) : null;
+  const db = authDb(ctx, config);
   logWithLevel(LOG_LEVELS.DEBUG, "retrieveAccountWithCredentialsImpl args:", {
     provider: providerId,
     account: {
@@ -36,15 +36,10 @@ export async function retrieveAccountWithCredentialsImpl(
       secret: maybeRedact(account.secret ?? ""),
     },
   });
-  const existingAccount =
-    authDb !== null
-      ? ((await authDb.accounts.get(providerId, account.id)) as Doc<"account"> | null)
-      : await ctx.db
-          .query("account")
-          .withIndex("providerAndAccountId", (q) =>
-            q.eq("provider", providerId).eq("providerAccountId", account.id),
-          )
-          .unique();
+  const existingAccount = (await db.accounts.get(
+    providerId,
+    account.id,
+  )) as Doc<"account"> | null;
   if (existingAccount === null) {
     return "InvalidAccountId";
   }
@@ -67,10 +62,7 @@ export async function retrieveAccountWithCredentialsImpl(
   return {
     account: existingAccount,
     // TODO: Ian removed this
-    user:
-      authDb !== null
-        ? ((await authDb.users.getById(existingAccount.userId)) as unknown as Doc<"user">)
-        : (await ctx.db.get(existingAccount.userId))!,
+    user: (await db.users.getById(existingAccount.userId)) as unknown as Doc<"user">,
   };
 }
 
@@ -78,7 +70,7 @@ export const callRetreiveAccountWithCredentials = async (
   ctx: ActionCtx,
   args: Infer<typeof retrieveAccountWithCredentialsArgs>,
 ): Promise<ReturnType> => {
-  return ctx.runMutation("auth:store" as any, {
+  return ctx.runMutation(AUTH_STORE_REF, {
     args: {
       type: "retrieveAccountWithCredentials",
       ...args,

package/src/server/implementation/mutations/signIn.ts

@@ -6,6 +6,7 @@ import {
   maybeGenerateTokensForSession,
 } from "../sessions.js";
 import { LOG_LEVELS, logWithLevel } from "../utils.js";
+import { AUTH_STORE_REF } from "./storeRef.js";
 
 export const signInArgs = v.object({
   userId: v.string(),
@@ -42,7 +43,7 @@ export const callSignIn = async (
   ctx: ActionCtx,
   args: Infer<typeof signInArgs>,
 ): Promise<ReturnType> => {
-  return ctx.runMutation("auth:store" as any, {
+  return ctx.runMutation(AUTH_STORE_REF, {
     args: {
       type: "signIn",
       ...args,

package/src/server/implementation/mutations/signOut.ts

@@ -2,7 +2,8 @@ import { GenericId } from "convex/values";
 import { ActionCtx, MutationCtx } from "../types.js";
 import { deleteSession, getAuthSessionId } from "../sessions.js";
 import * as Provider from "../provider.js";
-import { createAuthDb } from "../db.js";
+import { authDb } from "../db.js";
+import { AUTH_STORE_REF } from "./storeRef.js";
 
 type ReturnType = {
   userId: GenericId<"user">;
@@ -13,14 +14,10 @@ export async function signOutImpl(
   ctx: MutationCtx,
   config: Provider.Config,
 ): Promise<ReturnType> {
-  const authDb =
-    config.component !== undefined ? createAuthDb(ctx, config.component) : null;
+  const db = authDb(ctx, config);
   const sessionId = await getAuthSessionId(ctx);
   if (sessionId !== null) {
-    const session =
-      authDb !== null
-        ? await authDb.sessions.getById(sessionId)
-        : await ctx.db.get(sessionId);
+    const session = await db.sessions.getById(sessionId);
     if (session !== null) {
       await deleteSession(ctx, session, config);
       return { userId: session.userId, sessionId: session._id };
@@ -30,7 +27,7 @@ export async function signOutImpl(
 }
 
 export const callSignOut = async (ctx: ActionCtx): Promise<void> => {
-  return ctx.runMutation("auth:store" as any, {
+  return ctx.runMutation(AUTH_STORE_REF, {
     args: {
       type: "signOut",
     },

package/src/server/implementation/mutations/storeRef.ts

@@ -0,0 +1,7 @@
+/**
+ * Internal function reference for the library's store dispatch mutation.
+ *
+ * This remains string-based because the library code cannot import the
+ * consumer app's generated `internal` API module.
+ */
+export const AUTH_STORE_REF = "auth:store" as any;

package/src/server/implementation/mutations/userOAuth.ts

@@ -4,7 +4,8 @@ import * as Provider from "../provider.js";
 import { OAuthConfig } from "@auth/core/providers/oauth.js";
 import { upsertUserAndAccount } from "../users.js";
 import { generateRandomString, logWithLevel, sha256 } from "../utils.js";
-import { createAuthDb } from "../db.js";
+import { authDb } from "../db.js";
+import { AUTH_STORE_REF } from "./storeRef.js";
 
 const OAUTH_SIGN_IN_EXPIRATION_MS = 1000 * 60 * 2; // 2 minutes
 
@@ -25,26 +26,11 @@ export async function userOAuthImpl(
 ): Promise<ReturnType> {
   logWithLevel("DEBUG", "userOAuthImpl args:", args);
   const { profile, provider, providerAccountId, signature } = args;
-  const authDb =
-    config.component !== undefined ? createAuthDb(ctx, config.component) : null;
+  const db = authDb(ctx, config);
   const providerConfig = getProviderOrThrow(provider) as OAuthConfig<any>;
-  const existingAccount =
-    authDb !== null
-      ? await authDb.accounts.get(provider, providerAccountId)
-      : await ctx.db
-          .query("account")
-          .withIndex("providerAndAccountId", (q) =>
-            q.eq("provider", provider).eq("providerAccountId", providerAccountId),
-          )
-          .unique();
+  const existingAccount = await db.accounts.get(provider, providerAccountId);
 
-  const verifier =
-    authDb !== null
-      ? await authDb.verifiers.getBySignature(signature)
-      : await ctx.db
-          .query("verifier")
-          .withIndex("signature", (q) => q.eq("signature", signature))
-          .unique();
+  const verifier = await db.verifiers.getBySignature(signature);
   if (verifier === null) {
     throw new Error("Invalid state");
   }
@@ -58,44 +44,18 @@ export async function userOAuthImpl(
   );
 
   const code = generateRandomString(8, "0123456789");
-  if (authDb !== null) {
-    await authDb.verifiers.delete(verifier._id);
-  } else {
-    await ctx.db.delete(verifier._id);
-  }
-  const existingVerificationCode =
-    authDb !== null
-      ? await authDb.verificationCodes.getByAccountId(accountId)
-      : await ctx.db
-          .query("verification")
-          .withIndex("accountId", (q) => q.eq("accountId", accountId))
-          .unique();
+  await db.verifiers.delete(verifier._id);
+  const existingVerificationCode = await db.verificationCodes.getByAccountId(accountId);
   if (existingVerificationCode !== null) {
-    if (authDb !== null) {
-      await authDb.verificationCodes.delete(existingVerificationCode._id);
-    } else {
-      await ctx.db.delete(existingVerificationCode._id);
-    }
+    await db.verificationCodes.delete(existingVerificationCode._id);
   }
-  if (authDb !== null) {
-    await authDb.verificationCodes.create({
-      code: await sha256(code),
-      accountId,
-      provider,
-      expirationTime: Date.now() + OAUTH_SIGN_IN_EXPIRATION_MS,
-      verifier: verifier._id,
-    });
-  } else {
-    await ctx.db.insert("verification", {
+  await db.verificationCodes.create({
       code: await sha256(code),
       accountId,
       provider,
       expirationTime: Date.now() + OAUTH_SIGN_IN_EXPIRATION_MS,
-      // The use of a verifier means we don't need an identifier
-      // during verification.
       verifier: verifier._id,
     });
-  }
   return code;
 }
 
@@ -103,7 +63,7 @@ export const callUserOAuth = async (
   ctx: ActionCtx,
   args: Infer<typeof userOAuthArgs>,
 ): Promise<ReturnType> => {
-  return ctx.runMutation("auth:store" as any, {
+  return ctx.runMutation(AUTH_STORE_REF, {
     args: {
       type: "userOAuth",
       ...args,

package/src/server/implementation/mutations/verifier.ts

@@ -2,7 +2,8 @@ import { GenericId } from "convex/values";
 import { ActionCtx, MutationCtx } from "../types.js";
 import { getAuthSessionId } from "../sessions.js";
 import * as Provider from "../provider.js";
-import { createAuthDb } from "../db.js";
+import { authDb } from "../db.js";
+import { AUTH_STORE_REF } from "./storeRef.js";
 
 type ReturnType = GenericId<"verifier">;
 
@@ -11,17 +12,11 @@ export async function verifierImpl(
   config: Provider.Config,
 ): Promise<ReturnType> {
   const sessionId = (await getAuthSessionId(ctx)) ?? undefined;
-  if (config.component !== undefined) {
-    return (await createAuthDb(ctx, config.component).verifiers.create(sessionId)) as
-      ReturnType;
-  }
-  return await ctx.db.insert("verifier", {
-    sessionId,
-  });
+  return (await authDb(ctx, config).verifiers.create(sessionId)) as ReturnType;
 }
 
 export const callVerifier = async (ctx: ActionCtx): Promise<ReturnType> => {
-  return ctx.runMutation("auth:store" as any, {
+  return ctx.runMutation(AUTH_STORE_REF, {
     args: {
       type: "verifier",
     },

package/src/server/implementation/mutations/verifierSignature.ts

@@ -1,7 +1,8 @@
 import { GenericId, Infer, v } from "convex/values";
 import { ActionCtx, MutationCtx } from "../types.js";
 import * as Provider from "../provider.js";
-import { createAuthDb } from "../db.js";
+import { authDb } from "../db.js";
+import { AUTH_STORE_REF } from "./storeRef.js";
 
 export const verifierSignatureArgs = v.object({
   verifier: v.string(),
@@ -16,26 +17,19 @@ export async function verifierSignatureImpl(
   config: Provider.Config,
 ): Promise<ReturnType> {
   const { verifier, signature } = args;
-  const authDb =
-    config.component !== undefined ? createAuthDb(ctx, config.component) : null;
-  const verifierDoc =
-    authDb !== null
-      ? await authDb.verifiers.getById(verifier as GenericId<"verifier">)
-      : await ctx.db.get(verifier as GenericId<"verifier">);
+  const db = authDb(ctx, config);
+  const verifierDoc = await db.verifiers.getById(verifier as GenericId<"verifier">);
   if (verifierDoc === null) {
     throw new Error("Invalid verifier");
   }
-  if (authDb !== null) {
-    return await authDb.verifiers.patch(verifierDoc._id, { signature });
-  }
-  return await ctx.db.patch(verifierDoc._id, { signature });
+  return await db.verifiers.patch(verifierDoc._id, { signature });
 }
 
 export const callVerifierSignature = async (
   ctx: ActionCtx,
   args: Infer<typeof verifierSignatureArgs>,
 ): Promise<void> => {
-  return ctx.runMutation("auth:store" as any, {
+  return ctx.runMutation(AUTH_STORE_REF, {
     args: {
       type: "verifierSignature",
       ...args,