Skip to content

Scheduling infrastructure for absolutely everyone.

feat: TOUTOC in handleSeats (#27389)

sean-brydonbe4bb3fcde8d
diff --git a/packages/features/bookings/lib/handleSeats/create/createNewSeat.integration-test.ts b/packages/features/bookings/lib/handleSeats/create/createNewSeat.integration-test.ts
new file mode 100644
index 00000000000..4dd2b7f65f8
--- /dev/null
+++ b/packages/features/bookings/lib/handleSeats/create/createNewSeat.integration-test.ts
@@ -0,0 +1,501 @@
+import { describe, it, expect, beforeAll, afterEach } from "vitest";
+
+import { prisma } from "@calcom/prisma";
+import { BookingStatus } from "@calcom/prisma/enums";
+import { ErrorCode } from "@calcom/lib/errorCodes";
+
+import { addSeatToBooking } from "./createNewSeat";
+
+// Track resources to clean up
+const createdBookingIds: number[] = [];
+let testUserId: number;
+let testEventTypeId: number;
+
+async function clearTestData() {
+ if (createdBookingIds.length > 0) {
+ await prisma.bookingSeat.deleteMany({
+ where: { bookingId: { in: createdBookingIds } },
+ });
+ await prisma.attendee.deleteMany({
+ where: { bookingId: { in: createdBookingIds } },
+ });
+ await prisma.booking.deleteMany({
+ where: { id: { in: createdBookingIds } },
+ });
+ createdBookingIds.length = 0;
+ }
+}
+
+describe("createNewSeat Race Condition Prevention (Integration)", () => {
+ beforeAll(async () => {
+ // Use existing seed user
+ const testUser = await prisma.user.findFirstOrThrow({
+ where: { email: "[email protected]" },
+ });
+ testUserId = testUser.id;
+
+ // Find or create a test event type with seats
+ let eventType = await prisma.eventType.findFirst({
+ where: {
+ userId: testUserId,
+ seatsPerTimeSlot: { not: null },
+ },
+ });
+
+ if (!eventType) {
+ eventType = await prisma.eventType.create({
+ data: {
+ title: "Seated Test Event",
+ slug: `seated-test-event-${Date.now()}`,
+ length: 30,
+ userId: testUserId,
+ seatsPerTimeSlot: 2,
+ seatsShowAttendees: false,
+ },
+ });
+ }
+ testEventTypeId = eventType.id;
+ });
+
+ afterEach(async () => {
+ await clearTestData();
+ });
+
+ it("should prevent overbooking when concurrent requests race for the last seat", async () => {
+ const bookingUid = `race-test-${Date.now()}`;
+ const startTime = new Date(Date.now() + 24 * 60 * 60 * 1000);
+ const endTime = new Date(startTime.getTime() + 30 * 60 * 1000);
+ const seatsPerTimeSlot = 2;
+
+ // Create a booking first
+ const booking = await prisma.booking.create({
+ data: {
+ uid: bookingUid,
+ userId: testUserId,
+ eventTypeId: testEventTypeId,
+ status: BookingStatus.ACCEPTED,
+ startTime,
+ endTime,
+ title: "Race Condition Test Booking",
+ },
+ });
+
+ createdBookingIds.push(booking.id);
+
+ // Create 1 existing seat (out of 2)
+ const attendee = await prisma.attendee.create({
+ data: {
+ email: "[email protected]",
+ name: "Existing Seat",
+ timeZone: "UTC",
+ locale: "en",
+ bookingId: booking.id,
+ },
+ });
+
+ await prisma.bookingSeat.create({
+ data: {
+ referenceUid: `existing-seat-${Date.now()}`,
+ data: {},
+ bookingId: booking.id,
+ attendeeId: attendee.id,
+ },
+ });
+
+ // Fire 2 concurrent requests for the last seat using the actual addSeatToBooking function
+ const results = await Promise.allSettled([
+ addSeatToBooking({
+ bookingUid,
+ bookingId: booking.id,
+ bookingStatus: BookingStatus.ACCEPTED,
+ seatsPerTimeSlot,
+ attendee: {
+ email: "[email protected]",
+ name: "Racer 1",
+ timeZone: "UTC",
+ locale: "en",
+ },
+ seatData: {},
+ }),
+ addSeatToBooking({
+ bookingUid,
+ bookingId: booking.id,
+ bookingStatus: BookingStatus.ACCEPTED,
+ seatsPerTimeSlot,
+ attendee: {
+ email: "[email protected]",
+ name: "Racer 2",
+ timeZone: "UTC",
+ locale: "en",
+ },
+ seatData: {},
+ }),
+ ]);
+
+ // Count successes and failures
+ const successes = results.filter((r) => r.status === "fulfilled");
+ const failures = results.filter(
+ (r) => r.status === "rejected" && (r.reason as Error).message === ErrorCode.BookingSeatsFull
+ );
+
+ // Exactly 1 should succeed, 1 should fail with BookingSeatsFull
+ expect(successes.length).toBe(1);
+ expect(failures.length).toBe(1);
+
+ // Verify final seat count is exactly 2 (1 existing + 1 new)
+ const finalBooking = await prisma.booking.findUnique({
+ where: { uid: bookingUid },
+ select: {
+ attendees: {
+ select: {
+ id: true,
+ bookingSeat: {
+ select: {
+ id: true,
+ },
+ },
+ },
+ },
+ },
+ });
+
+ const finalSeatCount = finalBooking?.attendees.filter((a) => !!a.bookingSeat).length;
+ expect(finalSeatCount).toBe(2);
+ });
+
+ it("should allow both bookings when enough seats are available", async () => {
+ const bookingUid = `multi-seat-test-${Date.now()}`;
+ const startTime = new Date(Date.now() + 24 * 60 * 60 * 1000);
+ const endTime = new Date(startTime.getTime() + 30 * 60 * 1000);
+ const seatsPerTimeSlot = 3; // 3 seats available
+
+ // Create a booking with no seats taken yet
+ const booking = await prisma.booking.create({
+ data: {
+ uid: bookingUid,
+ userId: testUserId,
+ eventTypeId: testEventTypeId,
+ status: BookingStatus.ACCEPTED,
+ startTime,
+ endTime,
+ title: "Multi Seat Test Booking",
+ },
+ });
+
+ createdBookingIds.push(booking.id);
+
+ // Fire 2 concurrent requests when there are 3 seats available
+ const results = await Promise.allSettled([
+ addSeatToBooking({
+ bookingUid,
+ bookingId: booking.id,
+ bookingStatus: BookingStatus.ACCEPTED,
+ seatsPerTimeSlot,
+ attendee: {
+ email: "[email protected]",
+ name: "Booker 1",
+ timeZone: "UTC",
+ locale: "en",
+ },
+ seatData: {},
+ }),
+ addSeatToBooking({
+ bookingUid,
+ bookingId: booking.id,
+ bookingStatus: BookingStatus.ACCEPTED,
+ seatsPerTimeSlot,
+ attendee: {
+ email: "[email protected]",
+ name: "Booker 2",
+ timeZone: "UTC",
+ locale: "en",
+ },
+ seatData: {},
+ }),
+ ]);
+
+ // Both should succeed
+ const successes = results.filter((r) => r.status === "fulfilled");
+ expect(successes.length).toBe(2);
+
+ // Verify final seat count is 2
+ const finalBooking = await prisma.booking.findUnique({
+ where: { uid: bookingUid },
+ select: {
+ attendees: {
+ select: {
+ id: true,
+ bookingSeat: {
+ select: {
+ id: true,
+ },
+ },
+ },
+ },
+ },
+ });
+
+ const finalSeatCount = finalBooking?.attendees.filter((a) => !!a.bookingSeat).length;
+ expect(finalSeatCount).toBe(2);
+ });
+
+ it("should reject booking when event is already full", async () => {
+ const bookingUid = `full-event-test-${Date.now()}`;
+ const startTime = new Date(Date.now() + 24 * 60 * 60 * 1000);
+ const endTime = new Date(startTime.getTime() + 30 * 60 * 1000);
+ const seatsPerTimeSlot = 2;
+
+ // Create a booking first
+ const booking = await prisma.booking.create({
+ data: {
+ uid: bookingUid,
+ userId: testUserId,
+ eventTypeId: testEventTypeId,
+ status: BookingStatus.ACCEPTED,
+ startTime,
+ endTime,
+ title: "Full Event Test Booking",
+ },
+ });
+
+ createdBookingIds.push(booking.id);
+
+ // Create 2 seats (filling all available seats)
+ const attendee1 = await prisma.attendee.create({
+ data: {
+ email: "[email protected]",
+ name: "Seat 1",
+ timeZone: "UTC",
+ locale: "en",
+ bookingId: booking.id,
+ },
+ });
+
+ await prisma.bookingSeat.create({
+ data: {
+ referenceUid: `seat1-${Date.now()}`,
+ data: {},
+ bookingId: booking.id,
+ attendeeId: attendee1.id,
+ },
+ });
+
+ const attendee2 = await prisma.attendee.create({
+ data: {
+ email: "[email protected]",
+ name: "Seat 2",
+ timeZone: "UTC",
+ locale: "en",
+ bookingId: booking.id,
+ },
+ });
+
+ await prisma.bookingSeat.create({
+ data: {
+ referenceUid: `seat2-${Date.now()}`,
+ data: {},
+ bookingId: booking.id,
+ attendeeId: attendee2.id,
+ },
+ });
+
+ // Try to add another seat - should fail
+ await expect(
+ addSeatToBooking({
+ bookingUid,
+ bookingId: booking.id,
+ bookingStatus: BookingStatus.ACCEPTED,
+ seatsPerTimeSlot,
+ attendee: {
+ email: "[email protected]",
+ name: "Late Comer",
+ timeZone: "UTC",
+ locale: "en",
+ },
+ seatData: {},
+ })
+ ).rejects.toThrow(ErrorCode.BookingSeatsFull);
+
+ // Verify seat count is still 2
+ const finalBooking = await prisma.booking.findUnique({
+ where: { uid: bookingUid },
+ select: {
+ attendees: {
+ select: {
+ id: true,
+ bookingSeat: {
+ select: {
+ id: true,
+ },
+ },
+ },
+ },
+ },
+ });
+
+ const finalSeatCount = finalBooking?.attendees.filter((a) => !!a.bookingSeat).length;
+ expect(finalSeatCount).toBe(2);
+ });
+
+ it("should allow booking when seatsPerTimeSlot is 0 (falsy)", async () => {
+ // This tests the fix for the bug where null/undefined seatsPerTimeSlot
+ // would fallback to 0 and incorrectly reject all bookings because
+ // 0 <= currentSeatCount was always true
+ const bookingUid = `zero-seats-test-${Date.now()}`;
+ const startTime = new Date(Date.now() + 24 * 60 * 60 * 1000);
+ const endTime = new Date(startTime.getTime() + 30 * 60 * 1000);
+ const seatsPerTimeSlot = 0; // Simulates null/undefined fallback
+
+ // Create a booking
+ const booking = await prisma.booking.create({
+ data: {
+ uid: bookingUid,
+ userId: testUserId,
+ eventTypeId: testEventTypeId,
+ status: BookingStatus.ACCEPTED,
+ startTime,
+ endTime,
+ title: "Zero Seats Test Booking",
+ },
+ });
+
+ createdBookingIds.push(booking.id);
+
+ // Add a seat with seatsPerTimeSlot = 0 - should succeed
+ const result = await addSeatToBooking({
+ bookingUid,
+ bookingId: booking.id,
+ bookingStatus: BookingStatus.ACCEPTED,
+ seatsPerTimeSlot,
+ attendee: {
+ email: "[email protected]",
+ name: "Booker",
+ timeZone: "UTC",
+ locale: "en",
+ },
+ seatData: {},
+ });
+
+ expect(result).toBeDefined();
+ expect(result?.referenceUid).toBeDefined();
+
+ // Verify the seat was created
+ const finalBooking = await prisma.booking.findUnique({
+ where: { uid: bookingUid },
+ select: {
+ attendees: {
+ select: {
+ id: true,
+ bookingSeat: {
+ select: {
+ id: true,
+ },
+ },
+ },
+ },
+ },
+ });
+
+ const finalSeatCount = finalBooking?.attendees.filter((a) => !!a.bookingSeat).length;
+ expect(finalSeatCount).toBe(1);
+ });
+
+ it("should allow multiple bookings when seatsPerTimeSlot is 0 (no limit)", async () => {
+ const bookingUid = `zero-seats-multi-test-${Date.now()}`;
+ const startTime = new Date(Date.now() + 24 * 60 * 60 * 1000);
+ const endTime = new Date(startTime.getTime() + 30 * 60 * 1000);
+ const seatsPerTimeSlot = 0; // No limit enforced
+
+ // Create a booking
+ const booking = await prisma.booking.create({
+ data: {
+ uid: bookingUid,
+ userId: testUserId,
+ eventTypeId: testEventTypeId,
+ status: BookingStatus.ACCEPTED,
+ startTime,
+ endTime,
+ title: "Zero Seats Multi Test Booking",
+ },
+ });
+
+ createdBookingIds.push(booking.id);
+
+ // Create existing seats
+ const attendee1 = await prisma.attendee.create({
+ data: {
+ email: "[email protected]",
+ name: "Existing 1",
+ timeZone: "UTC",
+ locale: "en",
+ bookingId: booking.id,
+ },
+ });
+
+ await prisma.bookingSeat.create({
+ data: {
+ referenceUid: `existing1-${Date.now()}`,
+ data: {},
+ bookingId: booking.id,
+ attendeeId: attendee1.id,
+ },
+ });
+
+ const attendee2 = await prisma.attendee.create({
+ data: {
+ email: "[email protected]",
+ name: "Existing 2",
+ timeZone: "UTC",
+ locale: "en",
+ bookingId: booking.id,
+ },
+ });
+
+ await prisma.bookingSeat.create({
+ data: {
+ referenceUid: `existing2-${Date.now()}`,
+ data: {},
+ bookingId: booking.id,
+ attendeeId: attendee2.id,
+ },
+ });
+
+ // Add another seat with seatsPerTimeSlot = 0 - should succeed even with existing seats
+ const result = await addSeatToBooking({
+ bookingUid,
+ bookingId: booking.id,
+ bookingStatus: BookingStatus.ACCEPTED,
+ seatsPerTimeSlot,
+ attendee: {
+ email: "[email protected]",
+ name: "New Booker",
+ timeZone: "UTC",
+ locale: "en",
+ },
+ seatData: {},
+ });
+
+ expect(result).toBeDefined();
+ expect(result?.referenceUid).toBeDefined();
+
+ // Verify total seat count is 3 (2 existing + 1 new)
+ const finalBooking = await prisma.booking.findUnique({
+ where: { uid: bookingUid },
+ select: {
+ attendees: {
+ select: {
+ id: true,
+ bookingSeat: {
+ select: {
+ id: true,
+ },
+ },
+ },
+ },
+ },
+ });
+
+ const finalSeatCount = finalBooking?.attendees.filter((a) => !!a.bookingSeat).length;
+ expect(finalSeatCount).toBe(3);
+ });
+});
diff --git a/packages/features/bookings/lib/handleSeats/create/createNewSeat.ts b/packages/features/bookings/lib/handleSeats/create/createNewSeat.ts
index ea6d7249250..638469a7c5f 100644
--- a/packages/features/bookings/lib/handleSeats/create/createNewSeat.ts
+++ b/packages/features/bookings/lib/handleSeats/create/createNewSeat.ts
@@ -1,4 +1,3 @@
-
import { cloneDeep } from "lodash";
import { uuid } from "short-uuid";
@@ -14,12 +13,120 @@ import EventManager from "@calcom/features/bookings/lib/EventManager";
import { ErrorCode } from "@calcom/lib/errorCodes";
import { HttpError } from "@calcom/lib/http-error";
import prisma from "@calcom/prisma";
-import type { Prisma } from "@calcom/prisma/client";
+import type { Prisma, PrismaClient } from "@calcom/prisma/client";
import { BookingStatus } from "@calcom/prisma/enums";
import { findBookingQuery } from "../../handleNewBooking/findBookingQuery";
import type { IEventTypePaymentCredentialType } from "../../handleNewBooking/types";
-import type { SeatedBooking, NewSeatedBookingObject, HandleSeatsResultBooking } from "../types";
+import type {
+ SeatedBooking,
+ NewSeatedBookingObject,
+ HandleSeatsResultBooking,
+} from "../types";
+
+export type AddSeatInput = {
+ bookingUid: string;
+ bookingId: number;
+ bookingStatus: BookingStatus;
+ seatsPerTimeSlot: number;
+ attendee: {
+ email: string;
+ phoneNumber?: string;
+ name: string;
+ timeZone: string;
+ locale: string;
+ };
+ seatData: {
+ description?: string;
+ responses?: Prisma.InputJsonValue | null;
+ };
+ metadata?: Record<string, string>;
+};
+
+/**
+ * Atomically adds a seat to a booking with race condition protection.
+ * Uses a transaction with a fresh read to prevent TOCTOU race conditions
+ * where concurrent requests could exceed the seat limit.
+ */
+export async function addSeatToBooking(
+ input: AddSeatInput,
+ prismaClient: PrismaClient = prisma
+) {
+ const referenceUid = uuid();
+
+ return prismaClient.$transaction(async (tx) => {
+ // Lock the booking row with FOR UPDATE to prevent concurrent modifications
+ // This ensures only one transaction can read and modify seat count at a time
+ await tx.$queryRaw`SELECT id FROM "Booking" WHERE uid = ${input.bookingUid} FOR UPDATE`;
+
+ // Fresh read inside transaction to get the current seat count
+ const freshBooking = await tx.booking.findUnique({
+ where: { uid: input.bookingUid },
+ select: {
+ attendees: {
+ select: {
+ bookingSeat: {
+ select: { id: true },
+ },
+ },
+ },
+ },
+ });
+
+ if (!freshBooking) {
+ throw new HttpError({ statusCode: 404, message: "Booking not found" });
+ }
+
+ // Check seat availability with fresh data
+ // Only enforce the limit when seatsPerTimeSlot > 0 (matching original behavior
+ // where falsy seatsPerTimeSlot would skip this check entirely)
+ const currentSeatCount = freshBooking.attendees.filter(
+ (attendee) => !!attendee.bookingSeat
+ ).length;
+ if (input.seatsPerTimeSlot > 0 && input.seatsPerTimeSlot <= currentSeatCount) {
+ throw new HttpError({
+ statusCode: 409,
+ message: ErrorCode.BookingSeatsFull,
+ });
+ }
+
+ // Create the attendee and seat atomically within the transaction
+ await tx.booking.update({
+ where: { uid: input.bookingUid },
+ data: {
+ attendees: {
+ create: {
+ email: input.attendee.email,
+ phoneNumber: input.attendee.phoneNumber,
+ name: input.attendee.name,
+ timeZone: input.attendee.timeZone,
+ locale: input.attendee.locale,
+ bookingSeat: {
+ create: {
+ referenceUid,
+ data: {
+ description: input.seatData.description,
+ responses: input.seatData.responses,
+ },
+ metadata: input.metadata,
+ booking: {
+ connect: { id: input.bookingId },
+ },
+ },
+ },
+ },
+ },
+ ...(input.bookingStatus === BookingStatus.CANCELLED && {
+ status: BookingStatus.ACCEPTED,
+ }),
+ },
+ });
+
+ return await tx.bookingSeat.findUnique({
+ where: { referenceUid },
+ });
+ });
+}
const createNewSeat = async (
rescheduleSeatedBookingObject: NewSeatedBookingObject,
@@ -46,17 +153,15 @@ const createNewSeat = async (
let resultBooking: HandleSeatsResultBooking;
// Need to add translation for attendees to pass type checks. Since these values are never written to the db we can just use the new attendee language
const bookingAttendees = seatedBooking.attendees.map((attendee) => {
- return { ...attendee, language: { translate: tAttendees, locale: attendeeLanguage ?? "en" } };
+ return {
+ ...attendee,
+ language: { translate: tAttendees, locale: attendeeLanguage ?? "en" },
+ };
});
- if (
- eventType.seatsPerTimeSlot &&
- eventType.seatsPerTimeSlot <= seatedBooking.attendees.filter((attendee) => !!attendee.bookingSeat).length
- ) {
- throw new HttpError({ statusCode: 409, message: ErrorCode.BookingSeatsFull });
- }
-
- const videoCallReference = seatedBooking.references.find((reference) => reference.type.includes("_video"));
+ const videoCallReference = seatedBooking.references.find((reference) =>
+ reference.type.includes("_video")
+ );
if (videoCallReference) {
evt.videoCallData = {
@@ -67,50 +172,33 @@ const createNewSeat = async (
};
}
- const attendeeUniqueId = uuid();
-
const inviteeToAdd = invitee[0];
- await prisma.booking.update({
- where: {
- uid: seatedBooking.uid,
- },
- data: {
- attendees: {
- create: {
- email: inviteeToAdd.email,
- phoneNumber: inviteeToAdd.phoneNumber,
- name: inviteeToAdd.name,
- timeZone: inviteeToAdd.timeZone,
- locale: inviteeToAdd.language.locale,
- bookingSeat: {
- create: {
- referenceUid: attendeeUniqueId,
- data: {
- description: additionalNotes,
- responses,
- },
- metadata,
- booking: {
- connect: {
- id: seatedBooking.id,
- },
- },
- },
- },
- },
- },
- ...(seatedBooking.status === BookingStatus.CANCELLED && { status: BookingStatus.ACCEPTED }),
+ // Use addSeatToBooking which handles the race condition protection via transaction
+ const newBookingSeat = await addSeatToBooking({
+ bookingUid: seatedBooking.uid,
+ bookingId: seatedBooking.id,
+ bookingStatus: seatedBooking.status,
+ seatsPerTimeSlot: eventType.seatsPerTimeSlot ?? 0,
+ attendee: {
+ email: inviteeToAdd.email,
+ phoneNumber: inviteeToAdd.phoneNumber,
+ name: inviteeToAdd.name,
+ timeZone: inviteeToAdd.timeZone,
+ locale: inviteeToAdd.language.locale,
},
- });
-
- const newBookingSeat = await prisma.bookingSeat.findUnique({
- where: {
- referenceUid: attendeeUniqueId,
+ seatData: {
+ description: additionalNotes,
+ responses,
},
+ metadata,
});
- const attendeeWithSeat = { ...inviteeToAdd, bookingSeat: newBookingSeat ?? null };
+ const attendeeUniqueId = newBookingSeat?.referenceUid ?? "";
+ const attendeeWithSeat = {
+ ...inviteeToAdd,
+ bookingSeat: newBookingSeat ?? null,
+ };
evt = { ...evt, attendees: [...bookingAttendees, attendeeWithSeat] };
evt.attendeeSeatId = attendeeUniqueId;
@@ -130,16 +218,20 @@ const createNewSeat = async (
let isHostConfirmationEmailsDisabled = false;
let isAttendeeConfirmationEmailDisabled = false;
- isHostConfirmationEmailsDisabled = eventType.metadata?.disableStandardEmails?.confirmation?.host || false;
+ isHostConfirmationEmailsDisabled =
+ eventType.metadata?.disableStandardEmails?.confirmation?.host || false;
isAttendeeConfirmationEmailDisabled =
- eventType.metadata?.disableStandardEmails?.confirmation?.attendee || false;
+ eventType.metadata?.disableStandardEmails?.confirmation?.attendee ||
+ false;
if (isHostConfirmationEmailsDisabled) {
- isHostConfirmationEmailsDisabled = allowDisablingHostConfirmationEmails(workflows);
+ isHostConfirmationEmailsDisabled =
+ allowDisablingHostConfirmationEmails(workflows);
}
if (isAttendeeConfirmationEmailDisabled) {
- isAttendeeConfirmationEmailDisabled = allowDisablingAttendeeConfirmationEmails(workflows);
+ isAttendeeConfirmationEmailDisabled =
+ allowDisablingAttendeeConfirmationEmails(workflows);
}
await sendScheduledSeatsEmailsAndSMS(
copyEvent,
@@ -152,16 +244,27 @@ const createNewSeat = async (
);
}
const credentials = await refreshCredentials(allCredentials);
- const apps = eventTypeAppMetadataOptionalSchema.parse(eventType?.metadata?.apps);
- const eventManager = new EventManager({ ...organizerUser, credentials }, apps);
+ const apps = eventTypeAppMetadataOptionalSchema.parse(
+ eventType?.metadata?.apps
+ );
+ const eventManager = new EventManager(
+ { ...organizerUser, credentials },
+ apps
+ );
await eventManager.updateCalendarAttendees(evt, seatedBooking);
const foundBooking = await findBookingQuery(seatedBooking.id);
- if (!Number.isNaN(paymentAppData.price) && paymentAppData.price > 0 && !!seatedBooking) {
+ if (
+ !Number.isNaN(paymentAppData.price) &&
+ paymentAppData.price > 0 &&
+ !!seatedBooking
+ ) {
const credentialPaymentAppCategories = await prisma.credential.findMany({
where: {
- ...(paymentAppData.credentialId ? { id: paymentAppData.credentialId } : { userId: organizerUser.id }),
+ ...(paymentAppData.credentialId
+ ? { id: paymentAppData.credentialId }
+ : { userId: organizerUser.id }),
app: {
categories: {
hasSome: ["payment"],
@@ -180,15 +283,23 @@ const createNewSeat = async (
},
});
- const eventTypePaymentAppCredential = credentialPaymentAppCategories.find((credential) => {
- return credential.appId === paymentAppData.appId;
- });
+ const eventTypePaymentAppCredential = credentialPaymentAppCategories.find(
+ (credential) => {
+ return credential.appId === paymentAppData.appId;
+ }
+ );
if (!eventTypePaymentAppCredential) {
- throw new HttpError({ statusCode: 400, message: ErrorCode.MissingPaymentCredential });
+ throw new HttpError({
+ statusCode: 400,
+ message: ErrorCode.MissingPaymentCredential,
+ });
}
if (!eventTypePaymentAppCredential?.appId) {
- throw new HttpError({ statusCode: 400, message: ErrorCode.MissingPaymentAppId });
+ throw new HttpError({
+ statusCode: 400,
+ message: ErrorCode.MissingPaymentAppId,
+ });
}
const payment = await handlePayment({
@@ -202,7 +313,8 @@ const createNewSeat = async (
}
: {},
},
- paymentAppCredentials: eventTypePaymentAppCredential as IEventTypePaymentCredentialType,
+ paymentAppCredentials:
+ eventTypePaymentAppCredential as IEventTypePaymentCredentialType,
booking: seatedBooking,
bookerName: fullName,
bookerEmail,