create_vip_booking_request

Instructions

Implementation Reference

• src/services/vipBookings.ts:679-797 (handler)

  The main handler function that creates a VIP booking request. Validates all inputs (venue_id, booking_date, arrival_time, party_size, customer_name, email, phone), checks VIP booking is enabled for the venue, resolves booking window dates, looks up table pricing if preferred_table_code is provided, inserts the booking into vip_booking_requests, records a status event in vip_booking_status_events, creates a pending agent task in vip_agent_tasks, and sends a confirmation email via sendBookingSubmittedEmail.

  export async function createVipBookingRequest(
    supabase: SupabaseClient,
    input: CreateVipBookingRequestInput,
    options?: { resendApiKey?: string },
  ): Promise<VipBookingCreateResult> {
    const venueId = ensureUuid(input.venue_id, "venue_id");
    const bookingDate = normalizeBookingDate(input.booking_date);
    const arrivalTime = normalizeArrivalTime(input.arrival_time);
    const partySize = normalizePartySize(input.party_size);
    const customerName = normalizeCustomerName(input.customer_name);
    const customerEmail = normalizeCustomerEmail(input.customer_email);
    const customerPhone = normalizeCustomerPhone(input.customer_phone);
    const preferredTableCode = normalizeOptionalTableCode(input.preferred_table_code);
    const specialRequests = normalizeOptionalText(input.special_requests, 2000);
  
    const window = await resolveBookingWindow(supabase, venueId);
    if (bookingDate < window.currentServiceDate || bookingDate > window.maxServiceDate) {
      throw new NightlifeError(
        "INVALID_BOOKING_REQUEST",
        `booking_date must be between ${window.currentServiceDate} and ${window.maxServiceDate}.`,
      );
    }
  
    let minSpend: number | null = null;
    let minSpendCurrency: string | null = null;
    let tableWarning: string | null = null;
  
    if (preferredTableCode) {
      const pricing = await lookupTablePricing(supabase, venueId, preferredTableCode, bookingDate);
      if (!pricing.found) {
        tableWarning = `Table "${preferredTableCode}" was not found in our system for this venue. The booking request has been submitted and the venue will confirm table availability.`;
      }
      minSpend = pricing.minSpend;
      minSpendCurrency = pricing.currency;
    }
  
    const { data: created, error: createError } = await supabase
      .from("vip_booking_requests")
      .insert({
        venue_id: venueId,
        booking_date: bookingDate,
        arrival_time: arrivalTime,
        party_size: partySize,
        customer_name: customerName,
        customer_email: customerEmail,
        customer_phone: customerPhone,
        preferred_table_code: preferredTableCode,
        min_spend: minSpend,
        min_spend_currency: minSpendCurrency,
        special_requests: specialRequests,
        status: "submitted",
        status_message: DEFAULT_STATUS_MESSAGE,
      })
      .select("id,status,created_at,status_message")
      .single<VipBookingInsertRow>();
  
    if (createError || !created) {
      throw new NightlifeError("REQUEST_WRITE_FAILED", "Failed to create VIP booking request.", {
        cause: createError?.message || "Unknown insert error",
      });
    }
  
    const { error: eventError } = await supabase
      .from("vip_booking_status_events")
      .insert({
        booking_request_id: created.id,
        from_status: null,
        to_status: "submitted",
        actor_type: "customer",
        note: "VIP booking request sent to venue booking desk.",
      });
  
    const { error: taskError } = await supabase
      .from("vip_agent_tasks")
      .insert({
        booking_request_id: created.id,
        task_type: "new_vip_request",
        status: "pending",
        attempt_count: 0,
        next_attempt_at: new Date().toISOString(),
      });
  
    if (eventError || taskError) {
      throw new NightlifeError(
        "REQUEST_WRITE_FAILED",
        "Failed to submit VIP booking request.",
        {
          cause: {
            status_event_error: eventError?.message || null,
            task_error: taskError?.message || null,
          },
        },
      );
    }
  
    // Send submitted email (fire-and-forget)
    if (options?.resendApiKey) {
      try {
        const { sendBookingSubmittedEmail } = await import("./email.js");
        await sendBookingSubmittedEmail(supabase, options.resendApiKey, created.id);
      } catch (emailError) {
        logEvent("email.send_error", {
          booking_request_id: created.id,
          error: emailError instanceof Error ? emailError.message : "Unknown error",
        });
      }
    }
  
    return {
      booking_request_id: created.id,
      status: created.status,
      created_at: created.created_at,
      message: created.status_message,
      preferred_table_code: preferredTableCode,
      min_spend: minSpend,
      min_spend_currency: minSpendCurrency,
      table_warning: tableWarning,
    };
  }

• src/tools/vipBookings.ts:18-28 (schema)

  Input schema for the create_vip_booking_request tool using Zod validation. Defines required fields: venue_id, booking_date, arrival_time, party_size, customer_name, customer_email, customer_phone; and optional fields: preferred_table_code, special_requests.

  export const createVipBookingInputSchema = {
    venue_id: z.string().min(1),
    booking_date: z.string().min(1),
    arrival_time: z.string().min(1),
    party_size: z.number().int().min(1).max(30),
    customer_name: z.string().min(1),
    customer_email: z.string().min(1),
    customer_phone: z.string().min(1),
    preferred_table_code: z.string().optional(),
    special_requests: z.string().optional(),
  };

• src/tools/vipBookings.ts:30-39 (schema)

  Output schema for the create_vip_booking_request tool using Zod. Returns booking_request_id, status, created_at, message, preferred_table_code, min_spend, min_spend_currency, and table_warning.

  export const createVipBookingOutputSchema = z.object({
    booking_request_id: z.string(),
    status: z.enum(["submitted", "in_review", "deposit_required", "confirmed", "rejected", "cancelled"]),
    created_at: z.string(),
    message: z.string(),
    preferred_table_code: z.string().nullable(),
    min_spend: z.number().nullable(),
    min_spend_currency: z.string().nullable(),
    table_warning: z.string().nullable(),
  });

• src/tools/vipBookings.ts:141-156 (registration)

  Registers the create_vip_booking_request tool with the MCP server via server.registerTool(). Wires up description, inputSchema, outputSchema, and the handler callback that calls createVipBookingRequest from the services layer.

  export function registerVipBookingTools(server: McpServer, deps: ToolDeps): void {
    server.registerTool(
      "create_vip_booking_request",
      {
        description: createVipBookingToolDescription,
        inputSchema: createVipBookingInputSchema,
        outputSchema: createVipBookingOutputSchema,
      },
      async (args) => runTool(
        "create_vip_booking_request",
        createVipBookingOutputSchema,
        async () => createVipBookingRequest(deps.supabase, args, {
          resendApiKey: deps.config.resendApiKey ?? undefined,
        }),
      ),
    );

• src/types.ts:210-219 (helper)

  TypeScript interface VipBookingCreateResult defining the return type shape for the createVipBookingRequest handler.

  export interface VipBookingCreateResult {
    booking_request_id: string;
    status: VipBookingStatus;
    created_at: string;
    message: string;
    preferred_table_code: string | null;
    min_spend: number | null;
    min_spend_currency: string | null;
    table_warning: string | null;
  }