@robelest/convex-auth 0.0.4-preview.2 → 0.0.4-preview.21

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

@@ -1,39 +0,0 @@
-import { GenericId, Infer, v } from "convex/values";
-import { ActionCtx, MutationCtx } from "../types";
-import * as Provider from "../provider";
-import { authDb } from "../db";
-import { AUTH_STORE_REF } from "./store";
-import { throwAuthError } from "../../errors";
-
-export const verifierSignatureArgs = v.object({
-  verifier: v.string(),
-  signature: v.string(),
-});
-
-type ReturnType = void;
-
-export async function verifierSignatureImpl(
-  ctx: MutationCtx,
-  args: Infer<typeof verifierSignatureArgs>,
-  config: Provider.Config,
-): Promise<ReturnType> {
-  const { verifier, signature } = args;
-  const db = authDb(ctx, config);
-  const verifierDoc = await db.verifiers.getById(verifier as GenericId<"verifier">);
-  if (verifierDoc === null) {
-    throwAuthError("INVALID_VERIFIER");
-  }
-  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_REF, {
-    args: {
-      type: "verifierSignature",
-      ...args,
-    },
-  });
-};

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

@@ -1,35 +0,0 @@
-import { GenericId } from "convex/values";
-import { ActionCtx, MutationCtx } from "../types";
-import { deleteSession, getAuthSessionId } from "../sessions";
-import * as Provider from "../provider";
-import { authDb } from "../db";
-import { AUTH_STORE_REF } from "./store";
-
-type ReturnType = {
-  userId: GenericId<"user">;
-  sessionId: GenericId<"session">;
-} | null;
-
-export async function signOutImpl(
-  ctx: MutationCtx,
-  config: Provider.Config,
-): Promise<ReturnType> {
-  const db = authDb(ctx, config);
-  const sessionId = await getAuthSessionId(ctx);
-  if (sessionId !== null) {
-    const session = await db.sessions.getById(sessionId);
-    if (session !== null) {
-      await deleteSession(ctx, session, config);
-      return { userId: session.userId, sessionId: session._id };
-    }
-  }
-  return null;
-}
-
-export const callSignOut = async (ctx: ActionCtx): Promise<void> => {
-  return ctx.runMutation(AUTH_STORE_REF, {
-    args: {
-      type: "signOut",
-    },
-  });
-};

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

@@ -1,7 +0,0 @@
-/**
- * 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/verifier.ts

@@ -1,24 +0,0 @@
-import { GenericId } from "convex/values";
-import { ActionCtx, MutationCtx } from "../types";
-import { getAuthSessionId } from "../sessions";
-import * as Provider from "../provider";
-import { authDb } from "../db";
-import { AUTH_STORE_REF } from "./store";
-
-type ReturnType = GenericId<"verifier">;
-
-export async function verifierImpl(
-  ctx: MutationCtx,
-  config: Provider.Config,
-): Promise<ReturnType> {
-  const sessionId = (await getAuthSessionId(ctx)) ?? undefined;
-  return (await authDb(ctx, config).verifiers.create(sessionId)) as ReturnType;
-}
-
-export const callVerifier = async (ctx: ActionCtx): Promise<ReturnType> => {
-  return ctx.runMutation(AUTH_STORE_REF, {
-    args: {
-      type: "verifier",
-    },
-  });
-};

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

@@ -1,194 +0,0 @@
-import { GenericId, Infer, v } from "convex/values";
-import { ActionCtx, MutationCtx, SessionInfo } from "../types";
-import {
-  isSignInRateLimited,
-  recordFailedSignIn,
-  resetSignInRateLimit,
-} from "../ratelimit";
-import * as Provider from "../provider";
-import {
-  createNewAndDeleteExistingSession,
-  getAuthSessionId,
-  maybeGenerateTokensForSession,
-} from "../sessions";
-import { ConvexAuthConfig } from "../../types";
-import { LOG_LEVELS, logWithLevel, sha256 } from "../utils";
-import { upsertUserAndAccount } from "../users";
-import { authDb } from "../db";
-import { AUTH_STORE_REF } from "./store";
-
-export const verifyCodeAndSignInArgs = v.object({
-  params: v.any(),
-  provider: v.optional(v.string()),
-  verifier: v.optional(v.string()),
-  generateTokens: v.boolean(),
-  allowExtraProviders: v.boolean(),
-});
-
-type ReturnType = null | SessionInfo;
-
-export async function verifyCodeAndSignInImpl(
-  ctx: MutationCtx,
-  args: Infer<typeof verifyCodeAndSignInArgs>,
-  getProviderOrThrow: Provider.GetProviderOrThrowFunc,
-  config: Provider.Config,
-): Promise<ReturnType> {
-  logWithLevel(LOG_LEVELS.DEBUG, "verifyCodeAndSignInImpl args:", {
-    params: { email: args.params.email, phone: args.params.phone },
-    provider: args.provider,
-    verifier: args.verifier,
-    generateTokens: args.generateTokens,
-    allowExtraProviders: args.allowExtraProviders,
-  });
-  const { generateTokens, provider, allowExtraProviders } = args;
-  const identifier = args.params.email ?? args.params.phone;
-  if (identifier !== undefined) {
-    if (await isSignInRateLimited(ctx, identifier, config)) {
-      logWithLevel(
-        LOG_LEVELS.ERROR,
-        "Too many failed attempts to verify code for this email",
-      );
-      return null;
-    }
-  }
-  const verifyResult = await verifyCodeOnly(
-    ctx,
-    args,
-    provider ?? null,
-    getProviderOrThrow,
-    allowExtraProviders,
-    config,
-    await getAuthSessionId(ctx),
-  );
-  if (verifyResult === null) {
-    if (identifier !== undefined) {
-      await recordFailedSignIn(ctx, identifier, config);
-    }
-    return null;
-  }
-  if (identifier !== undefined) {
-    await resetSignInRateLimit(ctx, identifier, config);
-  }
-  const { userId } = verifyResult;
-  const sessionId = await createNewAndDeleteExistingSession(
-    ctx,
-    config,
-    userId,
-  );
-  return await maybeGenerateTokensForSession(
-    ctx,
-    config,
-    userId,
-    sessionId,
-    generateTokens,
-  );
-}
-
-export const callVerifyCodeAndSignIn = async (
-  ctx: ActionCtx,
-  args: Infer<typeof verifyCodeAndSignInArgs>,
-): Promise<ReturnType> => {
-  return ctx.runMutation(AUTH_STORE_REF, {
-    args: {
-      type: "verifyCodeAndSignIn",
-      ...args,
-    },
-  });
-};
-
-async function verifyCodeOnly(
-  ctx: MutationCtx,
-  args: {
-    params: any;
-    verifier?: string;
-    identifier?: string;
-  },
-  /**
-   * There are two providers at play:
-   * 1. the provider that generated the code
-   * 2. the provider the account is tied to.
-   * This is because we allow signing into an account
-   * via another provider, see {@link signInViaProvider}.
-   * This is the first provider.
-   */
-  methodProviderId: string | null,
-  getProviderOrThrow: Provider.GetProviderOrThrowFunc,
-  allowExtraProviders: boolean,
-  config: ConvexAuthConfig,
-  sessionId: GenericId<"session"> | null,
-) {
-  const db = authDb(ctx, config);
-  const { params, verifier } = args;
-  const codeHash = await sha256(params.code);
-  const verificationCode = await db.verificationCodes.getByCode(codeHash);
-  if (verificationCode === null) {
-    logWithLevel(LOG_LEVELS.ERROR, "Invalid verification code");
-    return null;
-  }
-  await db.verificationCodes.delete(verificationCode._id);
-  if (verificationCode.verifier !== verifier) {
-    logWithLevel(LOG_LEVELS.ERROR, "Invalid verifier");
-    return null;
-  }
-  if (verificationCode.expirationTime < Date.now()) {
-    logWithLevel(LOG_LEVELS.ERROR, "Expired verification code");
-    return null;
-  }
-  const { accountId, emailVerified, phoneVerified } = verificationCode;
-  const account = await db.accounts.getById(accountId);
-  if (account === null) {
-    logWithLevel(
-      LOG_LEVELS.ERROR,
-      "Account associated with this email has been deleted",
-    );
-    return null;
-  }
-  if (
-    methodProviderId !== null &&
-    verificationCode.provider !== methodProviderId
-  ) {
-    logWithLevel(
-      LOG_LEVELS.ERROR,
-      `Invalid provider "${methodProviderId}" for given \`code\`, ` +
-        `which was generated by provider "${verificationCode.provider}"`,
-    );
-    return null;
-  }
-  // OTP providers perform an additional check against the provided
-  // params.
-  const methodProvider = getProviderOrThrow(
-    verificationCode.provider,
-    allowExtraProviders,
-  );
-  if (
-    methodProvider !== null &&
-    (methodProvider.type === "email" || methodProvider.type === "phone") &&
-    methodProvider.authorize !== undefined
-  ) {
-    await methodProvider.authorize(args.params, account);
-  }
-  let userId = account.userId;
-  const provider = getProviderOrThrow(account.provider);
-  if (provider.type !== "oauth") {
-    ({ userId } = await upsertUserAndAccount(
-      ctx,
-      sessionId,
-      { existingAccount: account },
-      {
-        type: "verification",
-        provider,
-        profile: {
-          ...(emailVerified !== undefined
-            ? { email: emailVerified, emailVerified: true }
-            : {}),
-          ...(phoneVerified !== undefined
-            ? { phone: phoneVerified, phoneVerified: true }
-            : {}),
-        },
-      },
-      config,
-    ));
-  }
-
-  return { providerAccountId: account.providerAccountId, userId };
-}