Skip to content

Scheduling infrastructure for absolutely everyone.

fix: handle existing users on invite token flow (#26217)

Pedro Castro170203051f20
diff --git a/apps/web/modules/signup-view.tsx b/apps/web/modules/signup-view.tsx
index 10f33c8a44f..4ca7c48932b 100644
--- a/apps/web/modules/signup-view.tsx
+++ b/apps/web/modules/signup-view.tsx
@@ -16,6 +16,7 @@ import { z } from "zod";
import getStripe from "@calcom/app-store/stripepayment/lib/client";
import { getPremiumPlanPriceValue } from "@calcom/app-store/stripepayment/lib/utils";
+import { fetchSignup, isUserAlreadyExistsError, hasCheckoutSession } from "@calcom/features/auth/signup/lib/fetchSignup";
import { getOrgUsernameFromEmail } from "@calcom/features/auth/signup/utils/getOrgUsernameFromEmail";
import { getOrgFullOrigin } from "@calcom/features/ee/organizations/lib/orgDomains";
import ServerTrans from "@calcom/lib/components/ServerTrans";
@@ -222,23 +223,6 @@ export default function Signup({
const loadingSubmitState = isSubmitSuccessful || isSubmitting;
const displayBackButton = token ? false : displayEmailForm;
- const handleErrorsAndStripe = async (resp: Response) => {
- if (!resp.ok) {
- const err = await resp.json();
- if (err.checkoutSessionId) {
- const stripe = await getStripe();
- if (stripe) {
- const { error } = await stripe.redirectToCheckout({
- sessionId: err.checkoutSessionId,
- });
- console.warn(error.message);
- }
- } else {
- throw new Error(err.message);
- }
- }
- };
-
const isPlatformUser = redirectUrl?.includes("platform") && redirectUrl?.includes("new");
const signUp: SubmitHandler<FormValues> = async (_data) => {
@@ -252,77 +236,90 @@ export default function Signup({
username_taken: usernameTaken,
});
- await fetch("/api/auth/signup", {
- body: JSON.stringify({
- ...data,
- language: i18n.language,
- token,
- }),
- headers: {
- "Content-Type": "application/json",
- "cf-access-token": cfToken ?? "invalid-token",
- },
- method: "POST",
- })
- .then(handleErrorsAndStripe)
- .then(async () => {
- if (process.env.NEXT_PUBLIC_GTM_ID)
- pushGTMEvent("create_account", { email: data.email, user: data.username, lang: data.language });
-
- // telemetry.event(telemetryEventTypes.signup, collectPageParameters());
-
- const gettingStartedPath = onboardingV3Enabled ? "onboarding/getting-started" : "getting-started";
- const verifyOrGettingStarted = emailVerificationEnabled ? "auth/verify-email" : gettingStartedPath;
- const gettingStartedWithPlatform = "settings/platform/new";
-
- const constructCallBackIfUrlPresent = () => {
- if (isOrgInviteByLink) {
- return `${WEBAPP_URL}/${searchParams.get("callbackUrl")}`;
- }
-
- return addOrUpdateQueryParam(`${WEBAPP_URL}/${searchParams.get("callbackUrl")}`, "from", "signup");
- };
+ try {
+ const result = await fetchSignup(
+ {
+ ...data,
+ language: i18n.language,
+ token,
+ },
+ cfToken
+ );
+
+ if (!result.ok) {
+ if (isUserAlreadyExistsError(result)) {
+ showToast(t("account_already_exists_please_login"), "warning");
+ const callbackUrl = token ? `/teams?token=${token}` : "/event-types";
+ setTimeout(() => {
+ router.push(`/auth/login?callbackUrl=${encodeURIComponent(callbackUrl)}`);
+ }, 3000);
+ return;
+ }
- const constructCallBackIfUrlNotPresent = () => {
- if (isPlatformUser) {
- return `${WEBAPP_URL}/${gettingStartedWithPlatform}?from=signup`;
+ if (hasCheckoutSession(result)) {
+ const stripe = await getStripe();
+ if (stripe) {
+ const { error } = await stripe.redirectToCheckout({
+ sessionId: result.error.checkoutSessionId,
+ });
+ if (error) console.warn(error.message);
}
+ return;
+ }
- return `${WEBAPP_URL}/${verifyOrGettingStarted}?from=signup`;
- };
+ throw new Error(result.error.message);
+ }
- const constructCallBackUrl = () => {
- const callbackUrlSearchParams = searchParams?.get("callbackUrl");
+ if (process.env.NEXT_PUBLIC_GTM_ID) {
+ pushGTMEvent("create_account", { email: data.email, user: data.username, lang: data.language });
+ }
- return callbackUrlSearchParams
- ? constructCallBackIfUrlPresent()
- : constructCallBackIfUrlNotPresent();
- };
+ const gettingStartedPath = onboardingV3Enabled ? "onboarding/getting-started" : "getting-started";
+ const verifyOrGettingStarted = emailVerificationEnabled ? "auth/verify-email" : gettingStartedPath;
+ const gettingStartedWithPlatform = "settings/platform/new";
- const callBackUrl = constructCallBackUrl();
+ const constructCallBackIfUrlPresent = () => {
+ if (isOrgInviteByLink) {
+ return `${WEBAPP_URL}/${searchParams.get("callbackUrl")}`;
+ }
+ return addOrUpdateQueryParam(`${WEBAPP_URL}/${searchParams.get("callbackUrl")}`, "from", "signup");
+ };
- await signIn<"credentials">("credentials", {
- ...data,
- callbackUrl: callBackUrl,
- });
- })
- .catch((err) => {
- setTurnstileKey((k) => k + 1);
- formMethods.setValue("cfToken", undefined);
-
- if (err.message === INVALID_CLOUDFLARE_TOKEN_ERROR) {
- return;
+ const constructCallBackIfUrlNotPresent = () => {
+ if (isPlatformUser) {
+ return `${WEBAPP_URL}/${gettingStartedWithPlatform}?from=signup`;
}
+ return `${WEBAPP_URL}/${verifyOrGettingStarted}?from=signup`;
+ };
- posthog.capture("signup_form_submit_error", {
- has_token: !!token,
- is_org_invite: isOrgInviteByLink,
- org_slug: orgSlug,
- is_premium_username: premiumUsername,
- error_message: err.message,
- });
- formMethods.setError("apiError", { message: err.message });
+ const constructCallBackUrl = () => {
+ const callbackUrlSearchParams = searchParams?.get("callbackUrl");
+ return callbackUrlSearchParams ? constructCallBackIfUrlPresent() : constructCallBackIfUrlNotPresent();
+ };
+
+ await signIn<"credentials">("credentials", {
+ ...data,
+ callbackUrl: constructCallBackUrl(),
});
+ } catch (err) {
+ setTurnstileKey((k) => k + 1);
+ formMethods.setValue("cfToken", undefined);
+
+ const errorMessage = err instanceof Error ? err.message : t("unexpected_error_try_again");
+
+ if (errorMessage === INVALID_CLOUDFLARE_TOKEN_ERROR) {
+ return;
+ }
+
+ posthog.capture("signup_form_submit_error", {
+ has_token: !!token,
+ is_org_invite: isOrgInviteByLink,
+ org_slug: orgSlug,
+ is_premium_username: premiumUsername,
+ error_message: errorMessage,
+ });
+ formMethods.setError("apiError", { message: errorMessage });
+ }
};
return (
@@ -563,7 +560,7 @@ export default function Signup({
const username = formMethods.getValues("username");
if (!username) {
// should not be reached but needed to bypass type errors
- showToast("error", t("username_required"));
+ showToast(t("username_required"), "error");
return;
}
diff --git a/apps/web/playwright/signup.e2e.ts b/apps/web/playwright/signup.e2e.ts
index 2d7131c1dcc..ddfa820bf0a 100644
--- a/apps/web/playwright/signup.e2e.ts
+++ b/apps/web/playwright/signup.e2e.ts
@@ -1,5 +1,6 @@
import type { Page } from "@playwright/test";
import { expect } from "@playwright/test";
+import { hashSync } from "bcryptjs";
import { randomBytes } from "node:crypto";
import { APP_NAME, IS_PREMIUM_USERNAME_ENABLED, IS_MAILHOG_ENABLED } from "@calcom/lib/constants";
@@ -115,6 +116,86 @@ test.describe("Email Signup Flow Test", async () => {
expect(alertMessageInner).toContain(alertMessageInner);
});
});
+
+ test("Signup with org invite token for existing user redirects to login without overwriting password", async ({
+ page,
+ prisma,
+ }) => {
+ const originalPassword = "OriginalPass99!";
+ const attackerPassword = "AttackerPass99!";
+ const testEmail = `existing-user-${Date.now()}@example.com`;
+
+ // Create existing user without emailVerified to bypass server-side check
+ const hashedPassword = hashSync(originalPassword, 12);
+ const existingUser = await prisma.user.create({
+ data: {
+ email: testEmail,
+ username: `existing-user-${Date.now()}`,
+ password: { create: { hash: hashedPassword } },
+ emailVerified: null,
+ },
+ });
+
+ // Create org invite token for the existing user's email
+ const token = randomBytes(32).toString("hex");
+ const org = await prisma.team.create({
+ data: {
+ name: "Test Org",
+ slug: `test-org-${Date.now()}`,
+ isOrganization: true,
+ },
+ });
+
+ await prisma.verificationToken.create({
+ data: {
+ identifier: existingUser.email,
+ token,
+ expires: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+ teamId: org.id,
+ },
+ });
+
+ // Clear any existing session before attempting signup
+ await page.context().clearCookies();
+
+ // Try to signup with the invite token using a different password
+ await page.goto(`/signup?token=${token}`);
+ await expect(page.getByTestId("signup-submit-button")).toBeVisible();
+
+ await page.locator('input[name="password"]').fill(attackerPassword);
+
+ // Intercept the signup API request to verify 409 response
+ const responsePromise = page.waitForResponse(
+ (response) => response.url().includes("/api/auth/signup") && response.request().method() === "POST"
+ );
+
+ const submitButton = page.getByTestId("signup-submit-button");
+ await submitButton.click();
+
+ // Verify API returns 409 (user already exists)
+ const response = await responsePromise;
+ expect(response.status()).toBe(409);
+
+ const responseBody = await response.json();
+ expect(responseBody.message).toBe("user_already_exists");
+
+ // Should redirect to login (toast shows and redirects after 3s)
+ await expect(page).toHaveURL(/\/auth\/login/, { timeout: 8000 });
+
+ // Verify original password still works by logging in
+ await page.locator('input[name="email"]').fill(existingUser.email);
+ await page.locator('input[name="password"]').fill(originalPassword);
+ await page.locator('button[type="submit"]').click();
+
+ // Should successfully login with original password
+ await expect(page).toHaveURL(/\/(getting-started|event-types|teams)/, { timeout: 8000 });
+
+ // Cleanup
+ await prisma.verificationToken.deleteMany({ where: { token } });
+ await prisma.user.delete({ where: { id: existingUser.id } });
+ await prisma.team.delete({ where: { id: org.id } });
+ });
+
test("Premium Username Flow - creates stripe checkout", async ({ page, users, prisma }) => {
// eslint-disable-next-line playwright/no-skipped-test
test.skip(!IS_PREMIUM_USERNAME_ENABLED, "Only run on Cal.com");
@@ -182,7 +263,7 @@ test.describe("Email Signup Flow Test", async () => {
// Verify that the username is the same as the one provided and isn't accidentally changed to email derived username - That happens only for organization member signup
expect(dbUser?.username).toBe(userToCreate.username);
});
- test("Signup fields prefilled with query params", async ({ page, users }) => {
+ test("Signup fields prefilled with query params", async ({ page, users: _users }) => {
const signupUrlWithParams = "/signup?username=rick-jones&email=rick-jones%40example.com";
await page.goto(signupUrlWithParams);
await preventFlakyTest(page);
@@ -354,7 +435,7 @@ test.describe("Email Signup Flow Test", async () => {
});
});
- test("Checkbox for cookie consent does not need to be checked", async ({ page, users }) => {
+ test("Checkbox for cookie consent does not need to be checked", async ({ page, users: _users }) => {
await page.goto("/signup");
await preventFlakyTest(page);
diff --git a/apps/web/public/static/locales/en/common.json b/apps/web/public/static/locales/en/common.json
index ccc4558feb5..4b37268f812 100644
--- a/apps/web/public/static/locales/en/common.json
+++ b/apps/web/public/static/locales/en/common.json
@@ -4185,5 +4185,6 @@
"audit_logs_owner_not_in_organization": "The booking owner is not a member of your organization.",
"audit_logs_permission_denied": "You do not have permission to view audit logs for this booking.",
"audit_logs_permission_check_error": "An error occurred while checking permissions.",
+ "account_already_exists_please_login": "An account with this email already exists. Please log in to accept the invitation.",
"ADD_NEW_STRINGS_ABOVE_THIS_LINE_TO_PREVENT_MERGE_CONFLICTS": "↑↑↑↑↑↑↑↑↑↑↑↑↑ Add your new strings above here ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑"
}
diff --git a/packages/features/auth/signup/constants.ts b/packages/features/auth/signup/constants.ts
new file mode 100644
index 00000000000..9d8f9b47224
--- /dev/null
+++ b/packages/features/auth/signup/constants.ts
@@ -0,0 +1,6 @@
+export const SIGNUP_ERROR_CODES = {
+ USER_ALREADY_EXISTS: "user_already_exists",
+ INVALID_SERVER_RESPONSE: "invalid_server_response",
+} as const;
+
+export type SignupErrorCode = (typeof SIGNUP_ERROR_CODES)[keyof typeof SIGNUP_ERROR_CODES];
diff --git a/packages/features/auth/signup/handlers/__tests__/calcomHandler.test.ts b/packages/features/auth/signup/handlers/__tests__/calcomHandler.test.ts
new file mode 100644
index 00000000000..a8ba3265480
--- /dev/null
+++ b/packages/features/auth/signup/handlers/__tests__/calcomHandler.test.ts
@@ -0,0 +1,105 @@
+import type { Mock } from "vitest";
+import { vi } from "vitest";
+
+import type { MockResponse } from "./mocks/next.mocks";
+
+// Hoisted imports for proper mock initialization
+const {
+ prismaMock,
+ resetPrismaMock,
+ createPrismaMock,
+} = (await vi.hoisted(
+ async () => await import("./mocks/prisma.mocks")
+)) as Awaited<typeof import("./mocks/prisma.mocks")>;
+
+const {
+ createNextServerMock,
+ createNextHeadersMock,
+} = (await vi.hoisted(
+ async () => await import("./mocks/next.mocks")
+)) as Awaited<typeof import("./mocks/next.mocks")>;
+
+const {
+ createMockTeam,
+ createMockFoundToken,
+} = (await vi.hoisted(
+ async () => await import("./mocks/signup.factories")
+)) as Awaited<typeof import("./mocks/signup.factories")>;
+
+const mockFindTokenByToken: Mock = vi.fn();
+const mockValidateAndGetCorrectedUsernameForTeam: Mock = vi.fn();
+
+type UsernameStatus = {
+ statusCode: 200 | 402 | 418;
+ requestedUserName: string;
+ json: { available: boolean; premium: boolean };
+};
+
+type InnerHandler = (body: Record<string, string>, status: UsernameStatus) => Promise<MockResponse>;
+
+let capturedHandler: InnerHandler | null = null;
+
+vi.mock("next/server", createNextServerMock);
+vi.mock("next/headers", createNextHeadersMock);
+vi.mock("@calcom/prisma", createPrismaMock);
+vi.mock("@calcom/prisma/client", createPrismaMock);
+vi.mock("@calcom/lib/logger", () => ({
+ default: { getSubLogger: () => ({ warn: vi.fn(), error: vi.fn(), debug: vi.fn(), info: vi.fn() }) },
+}));
+vi.mock("@calcom/lib/auth/hashPassword", () => ({ hashPassword: vi.fn().mockResolvedValue("hashed") }));
+vi.mock("@calcom/lib/constants", () => ({ WEBAPP_URL: "http://localhost:3000" }));
+vi.mock("@calcom/lib/tracking", () => ({ getTrackingFromCookies: vi.fn().mockReturnValue({}) }));
+vi.mock("@calcom/app-store/stripepayment/lib/utils", () => ({ getPremiumMonthlyPlanPriceId: vi.fn() }));
+vi.mock("@calcom/features/auth/lib/getLocaleFromRequest", () => ({ getLocaleFromRequest: vi.fn().mockResolvedValue("en") }));
+vi.mock("@calcom/features/auth/lib/verifyEmail", () => ({ sendEmailVerification: vi.fn() }));
+vi.mock("@calcom/features/auth/signup/utils/createOrUpdateMemberships", () => ({ createOrUpdateMemberships: vi.fn() }));
+vi.mock("@calcom/features/auth/signup/utils/prefillAvatar", () => ({ prefillAvatar: vi.fn() }));
+vi.mock("@calcom/features/auth/signup/utils/validateUsername", () => ({
+ validateAndGetCorrectedUsernameAndEmail: vi.fn().mockResolvedValue({ isValid: true, username: "testuser" }),
+}));
+vi.mock("@calcom/features/ee/billing/di/containers/Billing", () => ({
+ getBillingProviderService: vi.fn().mockReturnValue({
+ createCustomer: vi.fn().mockResolvedValue({ stripeCustomerId: "cus_123" }),
+ }),
+}));
+vi.mock("@calcom/features/watchlist/lib/telemetry", () => ({ sentrySpan: {} }));
+vi.mock("@calcom/features/watchlist/operations/check-if-email-in-watchlist.controller", () => ({
+ checkIfEmailIsBlockedInWatchlistController: vi.fn().mockResolvedValue(false),
+}));
+vi.mock("@calcom/web/lib/buildLegacyCtx", () => ({ buildLegacyRequest: vi.fn() }));
+vi.mock("../../utils/organization", () => ({ joinAnyChildTeamOnOrgInvite: vi.fn() }));
+vi.mock("../../utils/token", () => ({
+ findTokenByToken: (...args: unknown[]) => mockFindTokenByToken(...args),
+ throwIfTokenExpired: vi.fn(),
+ validateAndGetCorrectedUsernameForTeam: (...args: unknown[]) => mockValidateAndGetCorrectedUsernameForTeam(...args),
+}));
+
+// Capture inner handler from usernameHandler wrapper
+vi.mock("@calcom/lib/server/username", () => ({
+ usernameHandler: (handler: InnerHandler) => {
+ capturedHandler = handler;
+ return handler;
+ },
+}));
+
+// Import after mocks
+await import("../calcomHandler");
+import { runP2002TestSuite } from "./p2002.test-suite";
+
+function callHandler(body: Record<string, string | undefined>): Promise<MockResponse> {
+ if (!capturedHandler) throw new Error("Handler not captured");
+ return capturedHandler(body as Record<string, string>, {
+ statusCode: 200,
+ requestedUserName: body.username || "testuser",
+ json: { available: true, premium: false },
+ });
+}
+
+runP2002TestSuite("calcomHandler", callHandler, () => {
+ vi.clearAllMocks();
+ resetPrismaMock();
+ mockFindTokenByToken.mockResolvedValue(createMockFoundToken());
+ mockValidateAndGetCorrectedUsernameForTeam.mockResolvedValue("testuser");
+ prismaMock.team.findUnique.mockResolvedValue(createMockTeam() as never);
+ prismaMock.verificationToken.delete.mockResolvedValue({} as never);
+});
diff --git a/packages/features/auth/signup/handlers/__tests__/mocks/next.mocks.ts b/packages/features/auth/signup/handlers/__tests__/mocks/next.mocks.ts
new file mode 100644
index 00000000000..35459474e7d
--- /dev/null
+++ b/packages/features/auth/signup/handlers/__tests__/mocks/next.mocks.ts
@@ -0,0 +1,40 @@
+import type { Mock } from "vitest";
+import { vi } from "vitest";
+
+// biome-ignore lint/style/useExportsLast: interface needed before function that uses it
+export interface MockResponse {
+ status: number;
+ body: unknown;
+ json: () => Promise<unknown>;
+}
+
+function createMockNextResponse(body: unknown, init?: { status?: number }): MockResponse {
+ if (init?.status === undefined) {
+ throw new Error("NextResponse.json() called without explicit status");
+ }
+ return {
+ status: init.status,
+ body,
+ json: () => Promise.resolve(body),
+ };
+}
+
+export function createNextServerMock(): {
+ NextResponse: { json: (body: unknown, init?: { status?: number }) => MockResponse };
+} {
+ return {
+ NextResponse: {
+ json: (body: unknown, init?: { status?: number }) => createMockNextResponse(body, init),
+ },
+ };
+}
+
+export function createNextHeadersMock(): {
+ cookies: Mock;
+ headers: Mock;
+} {
+ return {
+ cookies: vi.fn().mockResolvedValue({ getAll: () => [] }),
+ headers: vi.fn().mockResolvedValue(new Map()),
+ };
+}
diff --git a/packages/features/auth/signup/handlers/__tests__/mocks/prisma.mocks.ts b/packages/features/auth/signup/handlers/__tests__/mocks/prisma.mocks.ts
new file mode 100644
index 00000000000..c0e166dbda9
--- /dev/null
+++ b/packages/features/auth/signup/handlers/__tests__/mocks/prisma.mocks.ts
@@ -0,0 +1,57 @@
+import { mockDeep, mockReset, type DeepMockProxy } from "vitest-mock-extended";
+
+import type { PrismaClient } from "@calcom/prisma";
+
+// Prisma mock instance (singleton)
+export const prismaMock: DeepMockProxy<PrismaClient> = mockDeep<PrismaClient>();
+
+export function resetPrismaMock(): void {
+ mockReset(prismaMock);
+}
+
+// Custom P2002 error class for testing unique constraint violations
+export class MockPrismaClientKnownRequestError extends Error {
+ code: string;
+ meta?: { target?: string[] };
+
+ constructor(message: string, { code, meta }: { code: string; meta?: { target?: string[] } }) {
+ super(message);
+ this.name = "PrismaClientKnownRequestError";
+ this.code = code;
+ this.meta = meta;
+ }
+}
+
+export function createPrismaMock(): {
+ default: DeepMockProxy<PrismaClient>;
+ prisma: DeepMockProxy<PrismaClient>;
+ Prisma: { PrismaClientKnownRequestError: typeof MockPrismaClientKnownRequestError };
+} {
+ return {
+ default: prismaMock,
+ prisma: prismaMock,
+ Prisma: { PrismaClientKnownRequestError: MockPrismaClientKnownRequestError },
+ };
+}
+
+// P2002 error factories
+export function createP2002Error(target: string[]): MockPrismaClientKnownRequestError {
+ return new MockPrismaClientKnownRequestError("Unique constraint failed", {
+ code: "P2002",
+ meta: { target },
+ });
+}
+
+export function createP2002ErrorWithoutTarget(): MockPrismaClientKnownRequestError {
+ return new MockPrismaClientKnownRequestError("Unique constraint failed", {
+ code: "P2002",
+ meta: {},
+ });
+}
+
+export function createGenericPrismaError(): MockPrismaClientKnownRequestError {
+ return new MockPrismaClientKnownRequestError("Record not found", {
+ code: "P2025",
+ meta: {},
+ });
+}
diff --git a/packages/features/auth/signup/handlers/__tests__/mocks/signup.factories.ts b/packages/features/auth/signup/handlers/__tests__/mocks/signup.factories.ts
new file mode 100644
index 00000000000..2057b74cdda
--- /dev/null
+++ b/packages/features/auth/signup/handlers/__tests__/mocks/signup.factories.ts
@@ -0,0 +1,60 @@
+export interface MockTeam {
+ id: number;
+ isOrganization: boolean;
+ parent: { id: number; slug: string; organizationSettings: null } | null;
+ organizationSettings: null;
+}
+
+export interface MockFoundToken {
+ id: number;
+ teamId: number | null;
+ expires: Date;
+}
+
+export interface MockUser {
+ id: number;
+}
+
+export interface SignupBody {
+ email: string;
+ password: string;
+ username: string;
+ language: string;
+ token?: string;
+}
+
+export function createMockTeam(overrides: Partial<MockTeam> = {}): MockTeam {
+ return {
+ id: 1,
+ isOrganization: true,
+ parent: null,
+ organizationSettings: null,
+ ...overrides,
+ };
+}
+
+export function createMockFoundToken(overrides: Partial<MockFoundToken> = {}): MockFoundToken {
+ return {
+ id: 1,
+ teamId: 1,
+ expires: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+ ...overrides,
+ };
+}
+
+export function createMockUser(overrides: Partial<MockUser> = {}): MockUser {
+ return {
+ id: 1,
+ ...overrides,
+ };
+}
+
+export function createSignupBody(overrides: Partial<SignupBody> = {}): SignupBody {
+ return {
+ email: "[email protected]",
+ password: "ValidPassword123!",
+ username: "testuser",
+ language: "en",
+ ...overrides,
+ };
+}
diff --git a/packages/features/auth/signup/handlers/__tests__/p2002.test-suite.ts b/packages/features/auth/signup/handlers/__tests__/p2002.test-suite.ts
new file mode 100644
index 00000000000..76ea04e24ec
--- /dev/null
+++ b/packages/features/auth/signup/handlers/__tests__/p2002.test-suite.ts
@@ -0,0 +1,137 @@
+import { describe, it, expect, beforeEach } from "vitest";
+
+import { SIGNUP_ERROR_CODES } from "../../constants";
+import type { MockResponse } from "./mocks/next.mocks";
+import {
+ prismaMock,
+ createP2002Error,
+ createP2002ErrorWithoutTarget,
+ createGenericPrismaError,
+} from "./mocks/prisma.mocks";
+import { createSignupBody, createMockUser } from "./mocks/signup.factories";
+
+import type { SignupBody } from "./mocks/signup.factories";
+
+type CallHandler = (body: SignupBody) => Promise<MockResponse>;
+
+// biome-ignore lint/complexity/noExcessiveLinesPerFunction: test suite contains multiple test cases
+export function runP2002TestSuite(
+ handlerName: string,
+ callHandler: CallHandler,
+ setupMocks: () => void
+): void {
+ describe(`${handlerName} – signup P2002 contract`, () => {
+ describe("P2002 Error Handling (non-token flow)", () => {
+ beforeEach(setupMocks);
+
+ it("returns 409 when target includes 'email'", async () => {
+ prismaMock.user.create.mockRejectedValue(createP2002Error(["email"]));
+
+ const response = await callHandler(createSignupBody());
+
+ expect(response.status).toBe(409);
+ expect(await response.json()).toEqual({
+ message: SIGNUP_ERROR_CODES.USER_ALREADY_EXISTS,
+ });
+ });
+
+ it("returns 409 when target includes 'email' among other fields", async () => {
+ prismaMock.user.create.mockRejectedValue(createP2002Error(["id", "email", "username"]));
+
+ const response = await callHandler(createSignupBody());
+
+ expect(response.status).toBe(409);
+ expect(await response.json()).toEqual({
+ message: SIGNUP_ERROR_CODES.USER_ALREADY_EXISTS,
+ });
+ });
+
+ it("returns 409 when target is 'username' only", async () => {
+ prismaMock.user.create.mockRejectedValue(createP2002Error(["username"]));
+
+ const response = await callHandler(createSignupBody());
+
+ expect(response.status).toBe(409);
+ expect(await response.json()).toEqual({
+ message: SIGNUP_ERROR_CODES.USER_ALREADY_EXISTS,
+ });
+ });
+
+ it("re-throws when target is empty", async () => {
+ const error = createP2002ErrorWithoutTarget();
+ prismaMock.user.create.mockRejectedValue(error);
+
+ await expect(callHandler(createSignupBody())).rejects.toThrow(error);
+ });
+
+ it("re-throws when target is undefined", async () => {
+ const error = createP2002Error([]);
+ error.meta = undefined;
+ prismaMock.user.create.mockRejectedValue(error);
+
+ await expect(callHandler(createSignupBody())).rejects.toThrow(error);
+ });
+
+ it("re-throws non-P2002 Prisma errors", async () => {
+ const error = createGenericPrismaError();
+ prismaMock.user.create.mockRejectedValue(error);
+
+ await expect(callHandler(createSignupBody())).rejects.toThrow(error);
+ });
+
+ it("re-throws generic errors", async () => {
+ const error = new Error("Database connection failed");
+ prismaMock.user.create.mockRejectedValue(error);
+
+ await expect(callHandler(createSignupBody())).rejects.toThrow(error);
+ });
+ });
+
+ describe("Successful Creation", () => {
+ beforeEach(setupMocks);
+
+ it("returns 201 when user is created (non-token flow)", async () => {
+ prismaMock.user.create.mockResolvedValue(createMockUser());
+
+ const response = await callHandler(createSignupBody());
+
+ expect(response.status).toBe(201);
+ });
+
+ it("returns 201 when user is created via invite (token flow)", async () => {
+ prismaMock.user.findUnique.mockResolvedValue(null as never);
+ prismaMock.user.findFirst.mockResolvedValue(null as never);
+ prismaMock.user.upsert.mockResolvedValue(createMockUser() as never);
+
+ const response = await callHandler(createSignupBody({ token: "valid-token" }));
+
+ expect(response.status).toBe(201);
+ });
+ });
+
+ describe("Invite flow - existing user validation", () => {
+ beforeEach(setupMocks);
+
+ it("returns 409 when user exists but was not invited to this team", async () => {
+ prismaMock.user.findUnique.mockResolvedValue({ id: 99, invitedTo: 999 } as never);
+
+ const response = await callHandler(createSignupBody({ token: "valid-token" }));
+
+ expect(response.status).toBe(409);
+ expect(await response.json()).toEqual({
+ message: SIGNUP_ERROR_CODES.USER_ALREADY_EXISTS,
+ });
+ });
+
+ it("returns 201 when user exists and was invited to this team", async () => {
+ prismaMock.user.findUnique.mockResolvedValue({ id: 99, invitedTo: 1 } as never);
+ prismaMock.user.findFirst.mockResolvedValue(null as never);
+ prismaMock.user.upsert.mockResolvedValue(createMockUser() as never);
+
+ const response = await callHandler(createSignupBody({ token: "valid-token" }));
+
+ expect(response.status).toBe(201);
+ });
+ });
+ });
+}
diff --git a/packages/features/auth/signup/handlers/__tests__/selfHostedHandler.test.ts b/packages/features/auth/signup/handlers/__tests__/selfHostedHandler.test.ts
new file mode 100644
index 00000000000..7fcb740bece
--- /dev/null
+++ b/packages/features/auth/signup/handlers/__tests__/selfHostedHandler.test.ts
@@ -0,0 +1,65 @@
+import type { Mock } from "vitest";
+import { vi } from "vitest";
+
+// Hoisted imports for proper mock initialization
+const {
+ prismaMock,
+ resetPrismaMock,
+ createPrismaMock,
+} = (await vi.hoisted(
+ async () => await import("./mocks/prisma.mocks")
+)) as Awaited<typeof import("./mocks/prisma.mocks")>;
+
+const { createNextServerMock } = (await vi.hoisted(
+ async () => await import("./mocks/next.mocks")
+)) as Awaited<typeof import("./mocks/next.mocks")>;
+
+const {
+ createMockTeam,
+ createMockFoundToken,
+} = (await vi.hoisted(
+ async () => await import("./mocks/signup.factories")
+)) as Awaited<typeof import("./mocks/signup.factories")>;
+
+const mockFindTokenByToken: Mock = vi.fn();
+const mockValidateAndGetCorrectedUsernameForTeam: Mock = vi.fn();
+
+vi.mock("next/server", createNextServerMock);
+vi.mock("@calcom/prisma", createPrismaMock);
+vi.mock("@calcom/prisma/client", createPrismaMock);
+vi.mock("@calcom/lib/logger", () => ({
+ default: { getSubLogger: () => ({ warn: vi.fn(), error: vi.fn(), debug: vi.fn(), info: vi.fn() }) },
+}));
+vi.mock("@calcom/lib/auth/hashPassword", () => ({ hashPassword: vi.fn().mockResolvedValue("hashed") }));
+vi.mock("@calcom/lib/slugify", () => ({ default: vi.fn((s: string) => s.toLowerCase()) }));
+vi.mock("@calcom/lib/constants", () => ({ IS_PREMIUM_USERNAME_ENABLED: false }));
+vi.mock("@calcom/lib/server/username", () => ({ isUsernameReservedDueToMigration: vi.fn().mockResolvedValue(false) }));
+vi.mock("@calcom/features/auth/lib/verifyEmail", () => ({ sendEmailVerification: vi.fn() }));
+vi.mock("@calcom/features/auth/signup/utils/createOrUpdateMemberships", () => ({ createOrUpdateMemberships: vi.fn() }));
+vi.mock("@calcom/features/auth/signup/utils/validateUsername", () => ({
+ validateAndGetCorrectedUsernameAndEmail: vi.fn().mockResolvedValue({ isValid: true, username: "testuser" }),
+}));
+vi.mock("../../utils/organization", () => ({ joinAnyChildTeamOnOrgInvite: vi.fn() }));
+vi.mock("../../utils/prefillAvatar", () => ({ prefillAvatar: vi.fn() }));
+vi.mock("../../utils/token", () => ({
+ findTokenByToken: (...args: unknown[]) => mockFindTokenByToken(...args),
+ throwIfTokenExpired: vi.fn(),
+ validateAndGetCorrectedUsernameForTeam: (...args: unknown[]) => mockValidateAndGetCorrectedUsernameForTeam(...args),
+}));
+
+// Import after mocks
+import handler from "../selfHostedHandler";
+import { runP2002TestSuite } from "./p2002.test-suite";
+
+function callHandler(body: Record<string, string | undefined>): ReturnType<typeof handler> {
+ return handler(body as Record<string, string>);
+}
+
+runP2002TestSuite("selfHostedHandler", callHandler, () => {
+ vi.clearAllMocks();
+ resetPrismaMock();
+ mockFindTokenByToken.mockResolvedValue(createMockFoundToken());
+ mockValidateAndGetCorrectedUsernameForTeam.mockResolvedValue("testuser");
+ prismaMock.team.findUnique.mockResolvedValue(createMockTeam() as never);
+ prismaMock.verificationToken.delete.mockResolvedValue({} as never);
+});
diff --git a/packages/features/auth/signup/handlers/calcomHandler.ts b/packages/features/auth/signup/handlers/calcomHandler.ts
index 6573e4ddd21..3d9d1a33a68 100644
--- a/packages/features/auth/signup/handlers/calcomHandler.ts
+++ b/packages/features/auth/signup/handlers/calcomHandler.ts
@@ -14,15 +14,17 @@ import { hashPassword } from "@calcom/lib/auth/hashPassword";
import { WEBAPP_URL } from "@calcom/lib/constants";
import { HttpError } from "@calcom/lib/http-error";
import logger from "@calcom/lib/logger";
+import { isPrismaError } from "@calcom/lib/server/getServerErrorFromUnknown";
import type { CustomNextApiHandler } from "@calcom/lib/server/username";
import { usernameHandler } from "@calcom/lib/server/username";
import { getTrackingFromCookies } from "@calcom/lib/tracking";
-import { prisma } from "@calcom/prisma";
+import prisma from "@calcom/prisma";
import { CreationSource } from "@calcom/prisma/enums";
import { IdentityProvider } from "@calcom/prisma/enums";
import { signupSchema } from "@calcom/prisma/zod-utils";
import { buildLegacyRequest } from "@calcom/web/lib/buildLegacyCtx";
+import { SIGNUP_ERROR_CODES } from "../constants";
import { joinAnyChildTeamOnOrgInvite } from "../utils/organization";
import {
findTokenByToken,
@@ -83,6 +85,16 @@ const handler: CustomNextApiHandler = async (body, usernameStatus) => {
teamId: foundToken?.teamId ?? null,
isSignup: true,
});
+
+ if (foundToken?.teamId) {
+ const existingUser = await prisma.user.findUnique({
+ where: { email },
+ select: { invitedTo: true },
+ });
+ if (existingUser && existingUser.invitedTo !== foundToken.teamId) {
+ return NextResponse.json({ message: SIGNUP_ERROR_CODES.USER_ALREADY_EXISTS }, { status: 409 });
+ }
+ }
} else {
const usernameAndEmailValidation = await validateAndGetCorrectedUsernameAndEmail({
username,
@@ -167,29 +179,57 @@ const handler: CustomNextApiHandler = async (body, usernameStatus) => {
});
if (team) {
const organizationId = team.isOrganization ? team.id : team.parent?.id ?? null;
- const user = await prisma.user.upsert({
- where: { email },
- update: {
- username,
- emailVerified: new Date(Date.now()),
- identityProvider: IdentityProvider.CAL,
- password: {
- upsert: {
- create: { hash: hashedPassword },
- update: { hash: hashedPassword },
+
+ if (username) {
+ const existingUserByUsername = await prisma.user.findFirst({
+ where: {
+ username,
+ organizationId,
+ NOT: { email },
+ },
+ select: { id: true },
+ });
+ if (existingUserByUsername) {
+ return NextResponse.json({ message: SIGNUP_ERROR_CODES.USER_ALREADY_EXISTS }, { status: 409 });
+ }
+ }
+
+ let user: { id: number };
+ try {
+ user = await prisma.user.upsert({
+ where: { email },
+ update: {
+ username,
+ emailVerified: new Date(Date.now()),
+ identityProvider: IdentityProvider.CAL,
+ password: {
+ upsert: {
+ create: { hash: hashedPassword },
+ update: { hash: hashedPassword },
+ },
},
+ organizationId,
},
- organizationId,
- },
- create: {
- username,
- email,
- identityProvider: IdentityProvider.CAL,
- password: { create: { hash: hashedPassword } },
- organizationId,
- },
- });
- // Wrapping in a transaction as if one fails we want to rollback the whole thing to preventa any data inconsistencies
+ create: {
+ username,
+ email,
+ emailVerified: new Date(Date.now()),
+ identityProvider: IdentityProvider.CAL,
+ password: { create: { hash: hashedPassword } },
+ organizationId,
+ },
+ select: { id: true },
+ });
+ } catch (error) {
+ if (isPrismaError(error) && error.code === "P2002") {
+ const target = String(error.meta?.target ?? "");
+ if (target.includes("email") || target.includes("username")) {
+ return NextResponse.json({ message: SIGNUP_ERROR_CODES.USER_ALREADY_EXISTS }, { status: 409 });
+ }
+ }
+ throw error;
+ }
+
await createOrUpdateMemberships({
user,
team,
@@ -212,19 +252,33 @@ const handler: CustomNextApiHandler = async (body, usernameStatus) => {
});
} else {
// Create the user
- await prisma.user.create({
- data: {
- username,
- email,
- locked: shouldLockByDefault,
- password: { create: { hash: hashedPassword } },
- metadata: {
- stripeCustomerId: customer.stripeCustomerId,
- checkoutSessionId,
+ try {
+ await prisma.user.create({
+ data: {
+ username,
+ email,
+ locked: shouldLockByDefault,
+ password: { create: { hash: hashedPassword } },
+ metadata: {
+ stripeCustomerId: customer.stripeCustomerId,
+ checkoutSessionId,
+ },
+ creationSource: CreationSource.WEBAPP,
},
- creationSource: CreationSource.WEBAPP,
- },
- });
+ });
+ } catch (error) {
+ // Fallback for race conditions where user was created between our check and create
+ if (isPrismaError(error) && error.code === "P2002") {
+ const target = String(error.meta?.target ?? "");
+ if (target.includes("email") || target.includes("username")) {
+ return NextResponse.json(
+ { message: SIGNUP_ERROR_CODES.USER_ALREADY_EXISTS },
+ { status: 409 }
+ );
+ }
+ }
+ throw error;
+ }
if (process.env.AVATARAPI_USERNAME && process.env.AVATARAPI_PASSWORD) {
await prefillAvatar({ email });
}
diff --git a/packages/features/auth/signup/handlers/selfHostedHandler.ts b/packages/features/auth/signup/handlers/selfHostedHandler.ts
index 69d88ccc23c..e5252e52cf4 100644
--- a/packages/features/auth/signup/handlers/selfHostedHandler.ts
+++ b/packages/features/auth/signup/handlers/selfHostedHandler.ts
@@ -7,12 +7,14 @@ import { validateAndGetCorrectedUsernameAndEmail } from "@calcom/features/auth/s
import { hashPassword } from "@calcom/lib/auth/hashPassword";
import { IS_PREMIUM_USERNAME_ENABLED } from "@calcom/lib/constants";
import logger from "@calcom/lib/logger";
+import { isPrismaError } from "@calcom/lib/server/getServerErrorFromUnknown";
import { isUsernameReservedDueToMigration } from "@calcom/lib/server/username";
import slugify from "@calcom/lib/slugify";
import prisma from "@calcom/prisma";
import { IdentityProvider } from "@calcom/prisma/enums";
import { signupSchema } from "@calcom/prisma/zod-utils";
+import { SIGNUP_ERROR_CODES } from "../constants";
import { joinAnyChildTeamOnOrgInvite } from "../utils/organization";
import { prefillAvatar } from "../utils/prefillAvatar";
import {
@@ -42,6 +44,16 @@ export default async function handler(body: Record<string, string>) {
teamId: foundToken?.teamId,
isSignup: true,
});
+
+ if (foundToken?.teamId) {
+ const existingUser = await prisma.user.findUnique({
+ where: { email: userEmail },
+ select: { invitedTo: true },
+ });
+ if (existingUser && existingUser.invitedTo !== foundToken.teamId) {
+ return NextResponse.json({ message: SIGNUP_ERROR_CODES.USER_ALREADY_EXISTS }, { status: 409 });
+ }
+ }
} else {
const userValidation = await validateAndGetCorrectedUsernameAndEmail({
username,
@@ -89,30 +101,56 @@ export default async function handler(body: Record<string, string>) {
}
const organizationId = team.isOrganization ? team.id : team.parent?.id ?? null;
- const user = await prisma.user.upsert({
- where: { email: userEmail },
- update: {
- username: correctedUsername,
- password: {
- upsert: {
- create: { hash: hashedPassword },
- update: { hash: hashedPassword },
- },
- },
- emailVerified: new Date(Date.now()),
- identityProvider: IdentityProvider.CAL,
- organizationId,
- },
- create: {
+
+ const existingUserByUsername = await prisma.user.findFirst({
+ where: {
username: correctedUsername,
- email: userEmail,
- password: { create: { hash: hashedPassword } },
- identityProvider: IdentityProvider.CAL,
organizationId,
+ NOT: { email: userEmail },
},
+ select: { id: true },
});
+ if (existingUserByUsername) {
+ return NextResponse.json({ message: SIGNUP_ERROR_CODES.USER_ALREADY_EXISTS }, { status: 409 });
+ }
- const { membership } = await createOrUpdateMemberships({
+ let user: { id: number };
+ try {
+ user = await prisma.user.upsert({
+ where: { email: userEmail },
+ update: {
+ username: correctedUsername,
+ emailVerified: new Date(Date.now()),
+ identityProvider: IdentityProvider.CAL,
+ password: {
+ upsert: {
+ create: { hash: hashedPassword },
+ update: { hash: hashedPassword },
+ },
+ },
+ organizationId,
+ },
+ create: {
+ username: correctedUsername,
+ email: userEmail,
+ emailVerified: new Date(Date.now()),
+ identityProvider: IdentityProvider.CAL,
+ password: { create: { hash: hashedPassword } },
+ organizationId,
+ },
+ select: { id: true },
+ });
+ } catch (error) {
+ if (isPrismaError(error) && error.code === "P2002") {
+ const target = String(error.meta?.target ?? "");
+ if (target.includes("email") || target.includes("username")) {
+ return NextResponse.json({ message: SIGNUP_ERROR_CODES.USER_ALREADY_EXISTS }, { status: 409 });
+ }
+ }
+ throw error;
+ }
+
+ await createOrUpdateMemberships({
user,
team,
});
@@ -146,26 +184,30 @@ export default async function handler(body: Record<string, string>) {
);
}
}
- await prisma.user.upsert({
- where: { email: userEmail },
- update: {
- username: correctedUsername,
- password: {
- upsert: {
- create: { hash: hashedPassword },
- update: { hash: hashedPassword },
- },
+
+ try {
+ await prisma.user.create({
+ data: {
+ username: correctedUsername,
+ email: userEmail,
+ password: { create: { hash: hashedPassword } },
+ identityProvider: IdentityProvider.CAL,
},
- emailVerified: new Date(Date.now()),
- identityProvider: IdentityProvider.CAL,
- },
- create: {
- username: correctedUsername,
- email: userEmail,
- password: { create: { hash: hashedPassword } },
- identityProvider: IdentityProvider.CAL,
- },
- });
+ select: { id: true },
+ });
+ } catch (error) {
+ // Fallback for race conditions where user was created between our check and create
+ if (isPrismaError(error) && error.code === "P2002") {
+ const target = String(error.meta?.target ?? "");
+ if (target.includes("email") || target.includes("username")) {
+ return NextResponse.json(
+ { message: SIGNUP_ERROR_CODES.USER_ALREADY_EXISTS },
+ { status: 409 }
+ );
+ }
+ }
+ throw error;
+ }
if (process.env.AVATARAPI_USERNAME && process.env.AVATARAPI_PASSWORD) {
await prefillAvatar({ email: userEmail });
diff --git a/packages/features/auth/signup/lib/fetchSignup.test.ts b/packages/features/auth/signup/lib/fetchSignup.test.ts
new file mode 100644
index 00000000000..d1d394cee38
--- /dev/null
+++ b/packages/features/auth/signup/lib/fetchSignup.test.ts
@@ -0,0 +1,103 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+
+import { SIGNUP_ERROR_CODES } from "../constants";
+import { fetchSignup, isUserAlreadyExistsError, hasCheckoutSession } from "./fetchSignup";
+
+function createJsonResponse(json: unknown, status = 200) {
+ return new Response(JSON.stringify(json), {
+ status,
+ headers: { "content-type": "application/json" },
+ });
+}
+
+describe("fetchSignup", () => {
+ let fetchSpy: ReturnType<typeof vi.spyOn>;
+
+ beforeEach(() => {
+ fetchSpy = vi.spyOn(global, "fetch");
+ });
+
+ afterEach(() => {
+ fetchSpy.mockRestore();
+ });
+
+ it("returns success when signup completes", async () => {
+ fetchSpy.mockResolvedValue(createJsonResponse({ message: "Created user" }));
+
+ const result = await fetchSignup({
+ email: "[email protected]",
+ password: "password123",
+ language: "en",
+ });
+
+ expect(result.ok).toBe(true);
+ });
+
+ it("returns error with status code when signup fails", async () => {
+ fetchSpy.mockResolvedValue(createJsonResponse({ message: "Username is already taken" }, 409));
+
+ const result = await fetchSignup({
+ email: "[email protected]",
+ password: "password123",
+ language: "en",
+ });
+
+ expect(result.ok).toBe(false);
+ if (!result.ok) {
+ expect(result.status).toBe(409);
+ }
+ });
+});
+
+describe("isUserAlreadyExistsError", () => {
+ it("returns true for 409 with user_already_exists message", () => {
+ const result = {
+ ok: false as const,
+ status: 409,
+ error: { message: SIGNUP_ERROR_CODES.USER_ALREADY_EXISTS },
+ };
+
+ expect(isUserAlreadyExistsError(result)).toBe(true);
+ });
+
+ it("returns false for other error messages", () => {
+ const result = {
+ ok: false as const,
+ status: 409,
+ error: { message: "Username is already taken" },
+ };
+
+ expect(isUserAlreadyExistsError(result)).toBe(false);
+ });
+
+ it("returns false for success responses", () => {
+ const result = {
+ ok: true as const,
+ data: { message: "Created user" },
+ };
+
+ expect(isUserAlreadyExistsError(result)).toBe(false);
+ });
+});
+
+describe("hasCheckoutSession", () => {
+ it("returns true when checkoutSessionId exists", () => {
+ const result = {
+ ok: false as const,
+ status: 402,
+ error: { message: "Payment required", checkoutSessionId: "cs_123" },
+ };
+
+ expect(hasCheckoutSession(result)).toBe(true);
+ });
+
+ it("returns false when checkoutSessionId is absent", () => {
+ const result = {
+ ok: false as const,
+ status: 409,
+ error: { message: "Error" },
+ };
+
+ expect(hasCheckoutSession(result)).toBe(false);
+ });
+});
diff --git a/packages/features/auth/signup/lib/fetchSignup.ts b/packages/features/auth/signup/lib/fetchSignup.ts
new file mode 100644
index 00000000000..c665d8359f7
--- /dev/null
+++ b/packages/features/auth/signup/lib/fetchSignup.ts
@@ -0,0 +1,68 @@
+import { SIGNUP_ERROR_CODES } from "../constants";
+
+type SignupData = {
+ username?: string;
+ email: string;
+ password: string;
+ language: string;
+ token?: string;
+};
+
+type SignupSuccessResponse = {
+ message: string;
+ stripeCustomerId?: string;
+};
+
+type SignupErrorResponse = {
+ message: string;
+ checkoutSessionId?: string;
+};
+
+type SignupResponse = SignupSuccessResponse | SignupErrorResponse;
+
+export type SignupResult =
+ | { ok: true; data: SignupSuccessResponse }
+ | { ok: false; status: number; error: SignupErrorResponse };
+
+export async function fetchSignup(data: SignupData, cfToken?: string): Promise<SignupResult> {
+ const response = await fetch("/api/auth/signup", {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ "cf-access-token": cfToken ?? "invalid-token",
+ },
+ body: JSON.stringify(data),
+ });
+
+ const contentType = response.headers.get("content-type");
+ if (!contentType?.includes("application/json")) {
+ return {
+ ok: false,
+ status: response.status,
+ error: { message: SIGNUP_ERROR_CODES.INVALID_SERVER_RESPONSE },
+ };
+ }
+
+ const json = (await response.json()) as SignupResponse;
+
+ if (!response.ok) {
+ return {
+ ok: false,
+ status: response.status,
+ error: json as SignupErrorResponse,
+ };
+ }
+
+ return {
+ ok: true,
+ data: json as SignupSuccessResponse,
+ };
+}
+
+export function isUserAlreadyExistsError(result: SignupResult): boolean {
+ return !result.ok && result.status === 409 && result.error.message === SIGNUP_ERROR_CODES.USER_ALREADY_EXISTS;
+}
+
+export function hasCheckoutSession(result: SignupResult): result is { ok: false; status: number; error: SignupErrorResponse & { checkoutSessionId: string } } {
+ return !result.ok && !!result.error.checkoutSessionId;
+}
diff --git a/packages/lib/server/getServerErrorFromUnknown.ts b/packages/lib/server/getServerErrorFromUnknown.ts
index 36ed769be46..8009f23a7dd 100644
--- a/packages/lib/server/getServerErrorFromUnknown.ts
+++ b/packages/lib/server/getServerErrorFromUnknown.ts
@@ -18,8 +18,12 @@ function isZodError(cause: unknown): cause is ZodError {
return cause instanceof ZodError || (hasName(cause) && cause.name === "ZodError");
}
+// Fallback to code check when instanceof fails due to different Prisma client instances
function isPrismaError(cause: unknown): cause is Prisma.PrismaClientKnownRequestError {
- return cause instanceof Prisma.PrismaClientKnownRequestError;
+ return (
+ cause instanceof Prisma.PrismaClientKnownRequestError ||
+ (cause instanceof Error && "code" in cause && typeof cause.code === "string" && cause.code.startsWith("P"))
+ );
}
function parseZodErrorIssues(issues: ZodIssue[]): string {
@@ -201,3 +205,5 @@ function getServerErrorFromPrismaError(
}
return getHttpError({ statusCode: 400, cause, traceId, tracedData });
}
+
+export { isPrismaError };