@getmicdrop/venue-calendar 3.3.1 → 3.3.3

package/src/lib/api/promo.ts

@@ -1,164 +0,0 @@
-/**
- * Promo Codes API
- *
- * Functions for validating and checking promo codes
- * in the public checkout flow.
- */
-
-import { logger } from '../utils/logger.js';
-import { getPublicBaseUrl } from './client.js';
-import type { PromoValidationResponse, HasPromoCodesResponse } from './types.js';
-
-/**
- * Validate a promo code for an event
- *
- * Checks if a promo code is valid and returns its effects:
- * - Discount amount and type
- * - Hidden ticket reveal
- *
- * @param eventId - The event ID
- * @param code - The promo code to validate
- * @returns Validation result with discount info
- */
-export async function validatePromoCode(
-  eventId: string | number,
-  code: string
-): Promise<PromoValidationResponse> {
-  try {
-    if (!code || !code.trim()) {
-      return { valid: false, error: 'Promo code is required' };
-    }
-
-    // API uses GET with code in URL path
-    const encodedCode = encodeURIComponent(code.trim());
-    const response = await fetch(
-      `${getPublicBaseUrl()}/promo-codes/validate/${eventId}/${encodedCode}`
-    );
-
-    if (!response.ok) {
-      // 404 = invalid code, other errors are server issues
-      if (response.status === 404) {
-        return { valid: false, error: 'Invalid promo code' };
-      }
-      const errorData = await response.json().catch(() => ({}));
-      return { valid: false, error: errorData.error || 'Failed to validate code' };
-    }
-
-    const result = await response.json();
-    return {
-      valid: result.valid ?? true,
-      revealHiddenTickets: result.revealHiddenTickets,
-      revealTicketIds: result.revealTicketIds,
-      provideDiscount: result.provideDiscount,
-      discountType: result.discountType,
-      amount: result.amount,
-      code: result.code || code,
-    };
-  } catch (error) {
-    logger.error('Error validating promo code:', error);
-    return { valid: false, error: 'Network error validating code' };
-  }
-}
-
-/**
- * Check if promo codes are available for an event
- *
- * Used to conditionally show/hide the promo code input field.
- *
- * @param eventId - The event ID
- * @returns Whether promo codes exist for this event
- */
-export async function hasPromoCodes(eventId: string | number): Promise<boolean> {
-  try {
-    const response = await fetch(
-      `${getPublicBaseUrl()}/promo-codes/check/${eventId}`
-    );
-
-    if (!response.ok) {
-      // If endpoint doesn't exist or errors, default to showing the input
-      return true;
-    }
-
-    const result: HasPromoCodesResponse = await response.json();
-    return result.hasPromoCodes === true;
-  } catch (error) {
-    logger.error('Error checking promo codes availability:', error);
-    // Default to showing promo input if we can't check
-    return true;
-  }
-}
-
-/**
- * Apply a promo code to a cart
- *
- * This updates the cart with the promo code discount.
- *
- * @param cartId - The cart UUID
- * @param code - The promo code to apply
- * @returns Success status
- */
-export async function applyPromoCode(
-  cartId: string,
-  code: string
-): Promise<{ success: boolean; error?: string }> {
-  try {
-    const response = await fetch(
-      `${getPublicBaseUrl()}/orders/${cartId}/apply-promo`,
-      {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ code }),
-      }
-    );
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      return {
-        success: false,
-        error: errorData.error || 'Failed to apply promo code',
-      };
-    }
-
-    return { success: true };
-  } catch (error) {
-    logger.error('Error applying promo code:', error);
-    return { success: false, error: 'Network error applying code' };
-  }
-}
-
-/**
- * Remove a promo code from a cart
- *
- * @param cartId - The cart UUID
- * @returns Success status
- */
-export async function removePromoCode(
-  cartId: string
-): Promise<{ success: boolean; error?: string }> {
-  try {
-    const response = await fetch(
-      `${getPublicBaseUrl()}/orders/${cartId}/remove-promo`,
-      {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      }
-    );
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      return {
-        success: false,
-        error: errorData.error || 'Failed to remove promo code',
-      };
-    }
-
-    return { success: true };
-  } catch (error) {
-    logger.error('Error removing promo code:', error);
-    return { success: false, error: 'Network error removing code' };
-  }
-}

package/src/lib/api/transformers/event.ts

@@ -1,248 +0,0 @@
-/**
- * Event Transformer
- *
- * Normalizes API event responses to a consistent format.
- * Handles image URL resolution and CTA state calculation.
- */
-
-import type { Event, AvailableTicket } from '../types.js';
-
-// CDN base URL for images
-const CDN_BASE_URL = 'https://micdrop-images.sfo3.digitaloceanspaces.com';
-
-/**
- * Raw API event response (may have varying field names)
- */
-interface ApiEvent {
-  eventID?: number;
-  id?: number;
-  ID?: number;
-  name?: string;
-  title?: string;
-  slug?: string;
-  description?: string;
-  date?: string;
-  startDateTime?: string;
-  start_date_time?: string;
-  endDateTime?: string;
-  end_date_time?: string;
-  doorsOpenTime?: string;
-  doors_open_time?: string;
-  timezone?: string;
-  time_zone?: string;
-  venueId?: number;
-  venue_id?: number;
-  venueName?: string;
-  venue_name?: string;
-  venueAddress?: string;
-  venue_address?: string;
-  location?: string;
-  imageUrl?: string;
-  imageURL?: string;
-  image_url?: string;
-  image?: string;
-  status?: string;
-  isPublished?: boolean;
-  is_published?: boolean;
-  isCancelled?: boolean;
-  is_cancelled?: boolean;
-  availableTickets?: any[];
-  available_tickets?: any[];
-  tickets?: any[];
-  ticketsAvailable?: number;
-  tickets_available?: number;
-  ticketsSold?: number;
-  tickets_sold?: number;
-  minPrice?: number;
-  min_price?: number;
-  maxPrice?: number;
-  max_price?: number;
-  ctaText?: string;
-  cta_text?: string;
-  ctaState?: string;
-  cta_state?: string;
-  showPerformers?: boolean;
-  show_performers?: boolean;
-  eventSeriesId?: number;
-  event_series_id?: number;
-  seriesInstanceNumber?: number;
-  series_instance_number?: number;
-}
-
-/**
- * Get CDN image URL
- *
- * Prepends the CDN base URL if the path is relative.
- */
-export function getCDNImageUrl(path: string | undefined): string {
-  if (!path) return '';
-  if (path.startsWith('http')) return path;
-  return `${CDN_BASE_URL}/${path.replace(/^\//, '')}`;
-}
-
-/**
- * Extract image URL from event with fallbacks
- */
-export function getEventImageUrl(apiEvent: ApiEvent): string {
-  const rawUrl =
-    apiEvent.imageUrl ||
-    apiEvent.imageURL ||
-    apiEvent.image_url ||
-    apiEvent.image ||
-    '';
-
-  return getCDNImageUrl(rawUrl);
-}
-
-/**
- * Calculate CTA state based on ticket availability
- */
-export function calculateCtaState(
-  apiEvent: ApiEvent
-): 'available' | 'sold_out' | 'coming_soon' | 'ended' {
-  // Check explicit CTA state first
-  const explicitState = apiEvent.ctaState || apiEvent.cta_state;
-  if (explicitState) {
-    return explicitState as any;
-  }
-
-  // Check if event is cancelled or ended
-  if (apiEvent.isCancelled || apiEvent.is_cancelled) {
-    return 'ended';
-  }
-
-  // Check event date
-  const eventDate = apiEvent.startDateTime || apiEvent.start_date_time || apiEvent.date;
-  if (eventDate) {
-    const eventTime = new Date(eventDate).getTime();
-    const now = Date.now();
-
-    if (eventTime < now) {
-      return 'ended';
-    }
-  }
-
-  // Check ticket availability
-  const availableCount =
-    apiEvent.ticketsAvailable ?? apiEvent.tickets_available;
-
-  if (availableCount !== undefined) {
-    if (availableCount <= 0) {
-      return 'sold_out';
-    }
-    return 'available';
-  }
-
-  // Check tickets array
-  const tickets =
-    apiEvent.availableTickets ||
-    apiEvent.available_tickets ||
-    apiEvent.tickets ||
-    [];
-
-  if (tickets.length === 0) {
-    return 'coming_soon';
-  }
-
-  const totalAvailable = tickets.reduce((sum: number, t: any) => {
-    const qty =
-      t.quantityAvailable ?? t.quantity_available ?? t.quantity ?? 0;
-    const sold = t.quantitySold ?? t.quantity_sold ?? 0;
-    return sum + Math.max(0, qty - sold);
-  }, 0);
-
-  if (totalAvailable <= 0) {
-    return 'sold_out';
-  }
-
-  return 'available';
-}
-
-/**
- * Transform a raw API ticket to normalized AvailableTicket
- */
-export function transformTicket(apiTicket: any): AvailableTicket {
-  return {
-    id: apiTicket.id || apiTicket.ID,
-    name: apiTicket.name || apiTicket.ticketName || '',
-    description: apiTicket.description,
-    price: apiTicket.price || 0,
-    quantity: apiTicket.quantity || apiTicket.totalQuantity || 0,
-    quantitySold: apiTicket.quantitySold || apiTicket.quantity_sold || 0,
-    quantityAvailable:
-      apiTicket.quantityAvailable ||
-      apiTicket.quantity_available ||
-      (apiTicket.quantity || 0) - (apiTicket.quantitySold || 0),
-    minPerOrder: apiTicket.minPerOrder || apiTicket.min_per_order || 1,
-    maxPerOrder: apiTicket.maxPerOrder || apiTicket.max_per_order || 10,
-    saleStartDate: apiTicket.saleStartDate || apiTicket.sale_start_date,
-    saleEndDate: apiTicket.saleEndDate || apiTicket.sale_end_date,
-    isHidden: apiTicket.isHidden || apiTicket.is_hidden || false,
-    revealWithPromoCode:
-      apiTicket.revealWithPromoCode || apiTicket.reveal_with_promo_code,
-    ticketType: apiTicket.ticketType || apiTicket.ticket_type || 0,
-    sectionId: apiTicket.sectionId || apiTicket.section_id,
-    sortOrder: apiTicket.sortOrder || apiTicket.sort_order || 0,
-  };
-}
-
-/**
- * Transform a raw API event to normalized Event
- */
-export function transformEvent(apiEvent: ApiEvent): Event {
-  // Extract tickets array from various possible field names
-  const rawTickets =
-    apiEvent.availableTickets ||
-    apiEvent.available_tickets ||
-    apiEvent.tickets ||
-    [];
-
-  const tickets = rawTickets.map(transformTicket);
-
-  // Calculate min/max prices from tickets
-  const prices = tickets.map((t) => t.price).filter((p) => p > 0);
-  const minPrice = prices.length > 0 ? Math.min(...prices) : undefined;
-  const maxPrice = prices.length > 0 ? Math.max(...prices) : undefined;
-
-  return {
-    eventID: apiEvent.eventID || apiEvent.id || apiEvent.ID || 0,
-    id: apiEvent.id || apiEvent.ID,
-    name: apiEvent.name || apiEvent.title || '',
-    title: apiEvent.title || apiEvent.name,
-    slug: apiEvent.slug,
-    description: apiEvent.description,
-    date: apiEvent.date || apiEvent.startDateTime || apiEvent.start_date_time || '',
-    startDateTime: apiEvent.startDateTime || apiEvent.start_date_time,
-    endDateTime: apiEvent.endDateTime || apiEvent.end_date_time,
-    doorsOpenTime: apiEvent.doorsOpenTime || apiEvent.doors_open_time,
-    timezone: apiEvent.timezone || apiEvent.time_zone,
-    venueId: apiEvent.venueId || apiEvent.venue_id,
-    venueName: apiEvent.venueName || apiEvent.venue_name,
-    venueAddress: apiEvent.venueAddress || apiEvent.venue_address,
-    location: apiEvent.location || apiEvent.venueAddress || apiEvent.venue_address,
-    imageUrl: getEventImageUrl(apiEvent),
-    imageURL: getEventImageUrl(apiEvent),
-    status: apiEvent.status,
-    isPublished: apiEvent.isPublished ?? apiEvent.is_published,
-    isCancelled: apiEvent.isCancelled ?? apiEvent.is_cancelled,
-    availableTickets: tickets,
-    ticketsAvailable:
-      apiEvent.ticketsAvailable ??
-      apiEvent.tickets_available ??
-      tickets.reduce((sum, t) => sum + (t.quantityAvailable || 0), 0),
-    ticketsSold: apiEvent.ticketsSold ?? apiEvent.tickets_sold,
-    minPrice: apiEvent.minPrice ?? apiEvent.min_price ?? minPrice,
-    maxPrice: apiEvent.maxPrice ?? apiEvent.max_price ?? maxPrice,
-    ctaText: apiEvent.ctaText || apiEvent.cta_text,
-    ctaState: calculateCtaState(apiEvent),
-    showPerformers: apiEvent.showPerformers ?? apiEvent.show_performers,
-    eventSeriesId: apiEvent.eventSeriesId || apiEvent.event_series_id,
-    seriesInstanceNumber:
-      apiEvent.seriesInstanceNumber || apiEvent.series_instance_number,
-  };
-}
-
-/**
- * Legacy transformer name for backwards compatibility
- */
-export const transformEventData = transformEvent;

package/src/lib/api/transformers/index.ts

@@ -1,29 +0,0 @@
-/**
- * Transformers Index
- *
- * Re-exports all transformer functions for convenient importing.
- */
-
-// Order transformers
-export {
-  transformOrder,
-  transformTicket,
-  transformOrderForDisplay,
-} from './order.js';
-
-// Event transformers
-export {
-  transformEvent,
-  transformEventData, // Legacy alias
-  transformTicket as transformAvailableTicket,
-  getCDNImageUrl,
-  getEventImageUrl,
-  calculateCtaState,
-} from './event.js';
-
-// Venue transformers
-export {
-  transformVenue,
-  extractVenueFees,
-  formatVenueAddress,
-} from './venue.js';

package/src/lib/api/transformers/order.ts

@@ -1,207 +0,0 @@
-/**
- * Order Transformer
- *
- * Normalizes API order responses to a consistent format.
- * Handles variations in field names between different API versions.
- */
-
-import type { Order, PurchasedTicket } from '../types.js';
-
-/**
- * Raw API order response (may have varying field names)
- */
-interface ApiOrder {
-  uuid?: string;
-  id?: number;
-  ID?: number;
-  customerEmail?: string;
-  email?: string;
-  customer_email?: string;
-  customerFirstName?: string;
-  firstName?: string;
-  first_name?: string;
-  customerLastName?: string;
-  lastName?: string;
-  last_name?: string;
-  status?: string;
-  totalAmount?: number;
-  total?: number;
-  total_amount?: number;
-  subtotal?: number;
-  serviceFeesAmount?: number;
-  serviceFee?: number;
-  service_fee?: number;
-  service_fees_amount?: number;
-  taxAmount?: number;
-  tax?: number;
-  tax_amount?: number;
-  discount?: number;
-  paymentIntentId?: string;
-  payment_intent_id?: string;
-  paymentMethod?: string;
-  payment_method?: string;
-  purchasedTickets?: any[];
-  tickets?: any[];
-  purchased_tickets?: any[];
-  createdAt?: string;
-  created_at?: string;
-  updatedAt?: string;
-  updated_at?: string;
-}
-
-/**
- * Raw API ticket response
- */
-interface ApiTicket {
-  uuid?: string;
-  id?: number;
-  ID?: number;
-  ticketNumber?: string;
-  ticket_number?: string;
-  orderId?: string | number;
-  order_id?: string | number;
-  attendeeFirstName?: string;
-  attendee_first_name?: string;
-  firstName?: string;
-  attendeeLastName?: string;
-  attendee_last_name?: string;
-  lastName?: string;
-  attendeeEmail?: string;
-  attendee_email?: string;
-  email?: string;
-  ticketName?: string;
-  ticket_name?: string;
-  name?: string;
-  ticketTypeId?: number;
-  ticket_type_id?: number;
-  purchasePrice?: number;
-  purchase_price?: number;
-  price?: number;
-  status?: string;
-  checkedIn?: boolean;
-  checked_in?: boolean;
-  checkedInAt?: string;
-  checked_in_at?: string;
-}
-
-/**
- * Transform a raw API ticket to normalized PurchasedTicket
- */
-export function transformTicket(apiTicket: ApiTicket): PurchasedTicket {
-  return {
-    uuid: apiTicket.uuid || String(apiTicket.id || apiTicket.ID || ''),
-    id: apiTicket.id || apiTicket.ID,
-    ticketNumber: apiTicket.ticketNumber || apiTicket.ticket_number,
-    orderId: apiTicket.orderId || apiTicket.order_id,
-    attendeeFirstName:
-      apiTicket.attendeeFirstName ||
-      apiTicket.attendee_first_name ||
-      apiTicket.firstName,
-    attendeeLastName:
-      apiTicket.attendeeLastName ||
-      apiTicket.attendee_last_name ||
-      apiTicket.lastName,
-    attendeeEmail:
-      apiTicket.attendeeEmail || apiTicket.attendee_email || apiTicket.email,
-    ticketName:
-      apiTicket.ticketName || apiTicket.ticket_name || apiTicket.name || '',
-    ticketTypeId: apiTicket.ticketTypeId || apiTicket.ticket_type_id,
-    purchasePrice:
-      apiTicket.purchasePrice ||
-      apiTicket.purchase_price ||
-      apiTicket.price ||
-      0,
-    status: apiTicket.status,
-    checkedIn: apiTicket.checkedIn || apiTicket.checked_in,
-    checkedInAt: apiTicket.checkedInAt || apiTicket.checked_in_at,
-  };
-}
-
-/**
- * Transform a raw API order to normalized Order
- *
- * Handles various field name patterns:
- * - camelCase (customerEmail)
- * - snake_case (customer_email)
- * - Shortened names (email)
- */
-export function transformOrder(apiOrder: ApiOrder): Order {
-  // Extract tickets array from various possible field names
-  const rawTickets =
-    apiOrder.purchasedTickets ||
-    apiOrder.tickets ||
-    apiOrder.purchased_tickets ||
-    [];
-
-  return {
-    uuid: apiOrder.uuid || String(apiOrder.id || apiOrder.ID || ''),
-    id: apiOrder.id || apiOrder.ID,
-    customerEmail:
-      apiOrder.customerEmail ||
-      apiOrder.email ||
-      apiOrder.customer_email ||
-      '',
-    customerFirstName:
-      apiOrder.customerFirstName ||
-      apiOrder.firstName ||
-      apiOrder.first_name,
-    customerLastName:
-      apiOrder.customerLastName ||
-      apiOrder.lastName ||
-      apiOrder.last_name,
-    status: apiOrder.status || 'unknown',
-    totalAmount:
-      apiOrder.totalAmount ||
-      apiOrder.total ||
-      apiOrder.total_amount ||
-      0,
-    subtotal: apiOrder.subtotal,
-    serviceFeesAmount:
-      apiOrder.serviceFeesAmount ||
-      apiOrder.serviceFee ||
-      apiOrder.service_fee ||
-      apiOrder.service_fees_amount ||
-      0,
-    taxAmount:
-      apiOrder.taxAmount || apiOrder.tax || apiOrder.tax_amount || 0,
-    discount: apiOrder.discount || 0,
-    paymentIntentId:
-      apiOrder.paymentIntentId || apiOrder.payment_intent_id,
-    paymentMethod: apiOrder.paymentMethod || apiOrder.payment_method,
-    purchasedTickets: rawTickets.map(transformTicket),
-    createdAt: apiOrder.createdAt || apiOrder.created_at,
-    updatedAt: apiOrder.updatedAt || apiOrder.updated_at,
-  };
-}
-
-/**
- * Transform order for display on success page
- *
- * Returns a simplified object with display-ready values.
- */
-export function transformOrderForDisplay(apiOrder: ApiOrder): {
-  orderId: string;
-  displayOrderId: string;
-  email: string;
-  customerName: string;
-  total: number;
-  formattedTotal: string;
-  ticketCount: number;
-  status: string;
-} {
-  const order = transformOrder(apiOrder);
-  const displayId = order.uuid.split('-')[0] || order.uuid;
-
-  return {
-    orderId: order.uuid,
-    displayOrderId: displayId,
-    email: order.customerEmail,
-    customerName: [order.customerFirstName, order.customerLastName]
-      .filter(Boolean)
-      .join(' '),
-    total: order.totalAmount,
-    formattedTotal: `$${(order.totalAmount / 100).toFixed(2)}`,
-    ticketCount: order.purchasedTickets.length,
-    status: order.status,
-  };
-}