@getmicdrop/venue-calendar 3.1.0 → 3.3.0

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

@@ -0,0 +1,248 @@
+/**
+ * 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

@@ -0,0 +1,29 @@
+/**
+ * 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

@@ -0,0 +1,207 @@
+/**
+ * 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,
+  };
+}

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

@@ -0,0 +1,118 @@
+/**
+ * Venue Transformer
+ *
+ * Normalizes API venue responses to a consistent format.
+ */
+
+import type { Venue } from '../types.js';
+
+// CDN base URL for images
+const CDN_BASE_URL = 'https://micdrop-images.sfo3.digitaloceanspaces.com';
+
+/**
+ * Raw API venue response (may have varying field names)
+ */
+interface ApiVenue {
+  id?: number;
+  ID?: number;
+  name?: string;
+  slug?: string;
+  address?: string;
+  googleLocationNameCache?: string;
+  google_location_name_cache?: string;
+  city?: string;
+  state?: string;
+  zipCode?: string;
+  zip_code?: string;
+  country?: string;
+  timezone?: string;
+  time_zone?: string;
+  logoUrl?: string;
+  logo_url?: string;
+  logo?: string;
+  serviceFeePercentage?: number;
+  service_fee_percentage?: number;
+  serviceFeeCents?: number;
+  service_fee_cents?: number;
+  taxPercentage?: number;
+  tax_percentage?: number;
+  organizationId?: number;
+  organization_id?: number;
+}
+
+/**
+ * Get CDN image URL for venue logo
+ */
+function getLogoUrl(path: string | undefined): string {
+  if (!path) return '';
+  if (path.startsWith('http')) return path;
+  return `${CDN_BASE_URL}/${path.replace(/^\//, '')}`;
+}
+
+/**
+ * Transform a raw API venue to normalized Venue
+ */
+export function transformVenue(apiVenue: ApiVenue): Venue {
+  const logoPath =
+    apiVenue.logoUrl || apiVenue.logo_url || apiVenue.logo;
+
+  return {
+    id: apiVenue.id || apiVenue.ID || 0,
+    name: apiVenue.name || '',
+    slug: apiVenue.slug,
+    address: apiVenue.address,
+    googleLocationNameCache:
+      apiVenue.googleLocationNameCache ||
+      apiVenue.google_location_name_cache,
+    city: apiVenue.city,
+    state: apiVenue.state,
+    zipCode: apiVenue.zipCode || apiVenue.zip_code,
+    country: apiVenue.country,
+    timezone: apiVenue.timezone || apiVenue.time_zone,
+    logoUrl: getLogoUrl(logoPath),
+    serviceFeePercentage:
+      apiVenue.serviceFeePercentage ??
+      apiVenue.service_fee_percentage ??
+      0,
+    serviceFeeCents:
+      apiVenue.serviceFeeCents ?? apiVenue.service_fee_cents ?? 0,
+    taxPercentage:
+      apiVenue.taxPercentage ?? apiVenue.tax_percentage ?? 0,
+    organizationId:
+      apiVenue.organizationId || apiVenue.organization_id,
+  };
+}
+
+/**
+ * Extract fee configuration from venue
+ */
+export function extractVenueFees(apiVenue: ApiVenue): {
+  serviceFeePercentage: number;
+  serviceFeeCents: number;
+  taxPercentage: number;
+} {
+  return {
+    serviceFeePercentage:
+      apiVenue.serviceFeePercentage ??
+      apiVenue.service_fee_percentage ??
+      0,
+    serviceFeeCents:
+      apiVenue.serviceFeeCents ?? apiVenue.service_fee_cents ?? 0,
+    taxPercentage:
+      apiVenue.taxPercentage ?? apiVenue.tax_percentage ?? 0,
+  };
+}
+
+/**
+ * Get formatted venue address
+ */
+export function formatVenueAddress(venue: Venue): string {
+  const parts = [
+    venue.address,
+    venue.city,
+    venue.state,
+    venue.zipCode,
+  ].filter(Boolean);
+
+  return parts.join(', ');
+}