@getmicdrop/venue-calendar 3.3.1 → 3.3.3

package/src/lib/api/client.ts

@@ -1,210 +0,0 @@
-/**
- * API Client for MicDrop Public Checkout API
- *
- * Provides a centralized HTTP client with:
- * - Configurable base URL
- * - Error handling and logging
- * - Request/response typing
- * - IP address capture for payment intents
- */
-
-import { logger } from '../utils/logger.js';
-import type { ApiConfig, ApiResponse } from './types.js';
-
-// Default API configuration
-const DEFAULT_CONFIG: Required<ApiConfig> = {
-  baseUrl: 'https://get-micdrop.com',
-  timeout: 30000,
-  onError: (error: Error) => logger.error('API Error:', error),
-};
-
-// Global configuration (can be overridden)
-let globalConfig: Required<ApiConfig> = { ...DEFAULT_CONFIG };
-
-/**
- * Configure the API client
- */
-export function configureApi(config: Partial<ApiConfig>): void {
-  globalConfig = { ...globalConfig, ...config };
-}
-
-/**
- * Get the current API configuration
- */
-export function getApiConfig(): Required<ApiConfig> {
-  return { ...globalConfig };
-}
-
-/**
- * Get the public API base URL for v2 endpoints
- */
-export function getPublicBaseUrl(): string {
-  return `${globalConfig.baseUrl}/api/v2/public`;
-}
-
-/**
- * Get the legacy public API base URL
- */
-export function getLegacyPublicUrl(): string {
-  return `${globalConfig.baseUrl}/api/public`;
-}
-
-/**
- * Get the orders API base URL
- */
-export function getOrdersPublicUrl(): string {
-  return `${globalConfig.baseUrl}/api/orders/public`;
-}
-
-/**
- * Get the user's IP address for payment intents
- */
-export async function getClientIP(): Promise<string> {
-  try {
-    const response = await fetch('https://api.ipify.org?format=json');
-    const data = await response.json();
-    return data.ip || '';
-  } catch (error) {
-    logger.warn('Could not fetch client IP:', error);
-    return '';
-  }
-}
-
-/**
- * Make a GET request to the API
- */
-export async function apiGet<T>(
-  endpoint: string,
-  options?: RequestInit
-): Promise<ApiResponse<T>> {
-  return apiRequest<T>('GET', endpoint, undefined, options);
-}
-
-/**
- * Make a POST request to the API
- */
-export async function apiPost<T>(
-  endpoint: string,
-  body?: unknown,
-  options?: RequestInit
-): Promise<ApiResponse<T>> {
-  return apiRequest<T>('POST', endpoint, body, options);
-}
-
-/**
- * Make a PUT request to the API
- */
-export async function apiPut<T>(
-  endpoint: string,
-  body?: unknown,
-  options?: RequestInit
-): Promise<ApiResponse<T>> {
-  return apiRequest<T>('PUT', endpoint, body, options);
-}
-
-/**
- * Make a DELETE request to the API
- */
-export async function apiDelete<T>(
-  endpoint: string,
-  options?: RequestInit
-): Promise<ApiResponse<T>> {
-  return apiRequest<T>('DELETE', endpoint, undefined, options);
-}
-
-/**
- * Core API request function
- */
-async function apiRequest<T>(
-  method: string,
-  endpoint: string,
-  body?: unknown,
-  options?: RequestInit
-): Promise<ApiResponse<T>> {
-  const url = endpoint.startsWith('http')
-    ? endpoint
-    : `${getPublicBaseUrl()}${endpoint}`;
-
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), globalConfig.timeout);
-
-  try {
-    const response = await fetch(url, {
-      method,
-      headers: {
-        'Content-Type': 'application/json',
-        ...options?.headers,
-      },
-      body: body ? JSON.stringify(body) : undefined,
-      credentials: 'include',
-      signal: controller.signal,
-      ...options,
-    });
-
-    clearTimeout(timeoutId);
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      const error = new Error(
-        errorData.error || errorData.message || `HTTP ${response.status}`
-      );
-      globalConfig.onError(error);
-
-      return {
-        success: false,
-        error: errorData.error || errorData.message || `HTTP ${response.status}`,
-        statusCode: response.status,
-      };
-    }
-
-    const data = await response.json();
-    return {
-      success: true,
-      data: data as T,
-      statusCode: response.status,
-    };
-  } catch (error) {
-    clearTimeout(timeoutId);
-
-    const errorMessage =
-      error instanceof Error
-        ? error.name === 'AbortError'
-          ? 'Request timed out'
-          : error.message
-        : 'Unknown error';
-
-    globalConfig.onError(error instanceof Error ? error : new Error(errorMessage));
-
-    return {
-      success: false,
-      error: errorMessage,
-    };
-  }
-}
-
-/**
- * Simple fetch wrapper for backwards compatibility
- * Returns data directly or null on error
- */
-export async function simpleFetch<T>(
-  url: string,
-  options?: RequestInit
-): Promise<T | null> {
-  try {
-    const response = await fetch(url, {
-      credentials: 'include',
-      ...options,
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      logger.error(`API request failed: ${response.status}`, errorData);
-      return null;
-    }
-
-    return response.json();
-  } catch (error) {
-    logger.error('API request error:', error);
-    return null;
-  }
-}

package/src/lib/api/events.ts

@@ -1,358 +0,0 @@
-/**
- * Events API
- *
- * Functions for fetching event data, tickets, and performers
- * in the public checkout flow.
- */
-
-import { logger } from '../utils/logger.js';
-import { getPublicBaseUrl, simpleFetch } from './client.js';
-import type {
-  Event,
-  AvailableTicket,
-  EventPerformersResponse,
-  SeriesOccurrencesResponse,
-} from './types.js';
-
-/**
- * Fetch event details
- *
- * Gets full event information including venue and ticket data.
- *
- * @param eventId - The event ID
- * @param customFetch - Optional custom fetch function (for SSR)
- * @returns Event details or null on error
- */
-export async function fetchEventDetails(
-  eventId: string | number,
-  customFetch: typeof fetch = fetch
-): Promise<Event | null> {
-  try {
-    const response = await customFetch(`${getPublicBaseUrl()}/events/${eventId}`);
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch event details: ${response.status}`);
-    }
-
-    return response.json();
-  } catch (error) {
-    logger.error('Error fetching event details:', error);
-    return null;
-  }
-}
-
-/**
- * Fetch available tickets for an event
- *
- * Returns all ticket types that are currently available for sale.
- *
- * @param eventId - The event ID
- * @returns Array of available tickets
- */
-export async function fetchEventTickets(
-  eventId: string | number
-): Promise<AvailableTicket[]> {
-  try {
-    const response = await fetch(
-      `${getPublicBaseUrl()}/tickets/event/${eventId}`
-    );
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch tickets: ${response.status}`);
-    }
-
-    const tickets = await response.json();
-    return Array.isArray(tickets) ? tickets : [];
-  } catch (error) {
-    logger.error('Error fetching tickets:', error);
-    return [];
-  }
-}
-
-/**
- * Fetch performers for an event
- *
- * Returns the lineup with pre-resolved avatar URLs.
- *
- * @param eventId - The event ID
- * @returns Performers list and visibility flag
- */
-export async function fetchEventPerformers(
-  eventId: string | number
-): Promise<EventPerformersResponse> {
-  try {
-    if (!eventId) {
-      logger.warn('fetchEventPerformers called without eventId');
-      return { performers: [], showPerformers: false };
-    }
-
-    const response = await fetch(
-      `${getPublicBaseUrl()}/events/${eventId}/performers`
-    );
-
-    if (!response.ok) {
-      logger.error(
-        `Failed to fetch performers: ${response.status} ${response.statusText}`
-      );
-      return { performers: [], showPerformers: false };
-    }
-
-    const data = await response.json();
-    return {
-      performers: Array.isArray(data.performers) ? data.performers : [],
-      showPerformers: data.showPerformers === true,
-    };
-  } catch (error) {
-    logger.error('Error fetching event performers:', error);
-    return { performers: [], showPerformers: false };
-  }
-}
-
-/**
- * Fetch all venues for an organization
- *
- * @param orgId - The organization ID
- * @returns Array of venues
- */
-export async function fetchAllVenues(orgId: string | number): Promise<any[]> {
-  try {
-    if (!orgId) {
-      logger.warn('fetchAllVenues called without orgId');
-      return [];
-    }
-
-    const response = await fetch(
-      `${getPublicBaseUrl()}/venues/organization/${orgId}`
-    );
-
-    if (!response.ok) {
-      logger.error(
-        `Failed to fetch venues: ${response.status} ${response.statusText}`
-      );
-      return [];
-    }
-
-    const venues = await response.json();
-    return Array.isArray(venues) ? venues : [];
-  } catch (error) {
-    logger.error('Error fetching venues:', error);
-    return [];
-  }
-}
-
-/**
- * Fetch events for a venue
- *
- * @param venueId - The venue ID
- * @returns Array of events
- */
-export async function fetchVenueEvents(venueId: string | number): Promise<Event[]> {
-  try {
-    if (!venueId) {
-      logger.warn('fetchVenueEvents called without venueId');
-      return [];
-    }
-
-    const response = await fetch(
-      `${getPublicBaseUrl()}/events/venue/${venueId}`
-    );
-
-    if (!response.ok) {
-      logger.error(
-        `Failed to fetch venue events: ${response.status} ${response.statusText}`
-      );
-      return [];
-    }
-
-    const events = await response.json();
-    return Array.isArray(events) ? events : [];
-  } catch (error) {
-    logger.error('Error fetching venue events:', error);
-    return [];
-  }
-}
-
-/**
- * Get events for a specific month
- *
- * Used for calendar views to efficiently load events.
- *
- * @param venueId - The venue ID
- * @param year - The year (e.g., 2024)
- * @param month - The month (1-12)
- * @returns Array of events for the month
- */
-export async function getMonthEvents(
-  venueId: string | number,
-  year: number,
-  month: number
-): Promise<Event[]> {
-  try {
-    const response = await fetch(
-      `${getPublicBaseUrl()}/events/venue/${venueId}/month/${year}/${month}`
-    );
-
-    if (!response.ok) {
-      logger.error(`Failed to fetch month events: ${response.status}`);
-      return [];
-    }
-
-    const data = await response.json();
-    return Array.isArray(data.events) ? data.events : Array.isArray(data) ? data : [];
-  } catch (error) {
-    logger.error('Error fetching month events:', error);
-    return [];
-  }
-}
-
-/**
- * Get events for an organization for a specific month
- *
- * @param orgId - The organization ID
- * @param year - The year (e.g., 2024)
- * @param month - The month (1-12)
- * @returns Array of events for the month
- */
-export async function getOrgMonthEvents(
-  orgId: string | number,
-  year: number,
-  month: number
-): Promise<Event[]> {
-  try {
-    const response = await fetch(
-      `${getPublicBaseUrl()}/events/organization/${orgId}/month/${year}/${month}`
-    );
-
-    if (!response.ok) {
-      logger.error(`Failed to fetch org month events: ${response.status}`);
-      return [];
-    }
-
-    const data = await response.json();
-    return Array.isArray(data.events) ? data.events : Array.isArray(data) ? data : [];
-  } catch (error) {
-    logger.error('Error fetching org month events:', error);
-    return [];
-  }
-}
-
-/**
- * Get series occurrences for date selector
- *
- * Returns all instances of a recurring event series.
- *
- * @param eventSeriesId - The series ID
- * @returns Series occurrences
- */
-export async function getSeriesOccurrences(
-  eventSeriesId: number
-): Promise<SeriesOccurrencesResponse | null> {
-  try {
-    const response = await fetch(
-      `${getPublicBaseUrl()}/series/${eventSeriesId}/occurrences`
-    );
-
-    if (!response.ok) {
-      logger.error(`Failed to fetch series occurrences: ${response.status}`);
-      return null;
-    }
-
-    return response.json();
-  } catch (error) {
-    logger.error('Error fetching series occurrences:', error);
-    return null;
-  }
-}
-
-/**
- * Fetch series occurrences with CTA state
- *
- * Returns full series data including availability status.
- *
- * @param eventSeriesId - The series ID
- * @param venueId - The venue ID
- * @returns Series occurrences with CTA state
- */
-export async function fetchSeriesOccurrences(
-  eventSeriesId: number,
-  venueId: string | number
-): Promise<SeriesOccurrencesResponse | null> {
-  try {
-    const response = await fetch(
-      `${getPublicBaseUrl()}/series/${eventSeriesId}/occurrences?venueId=${venueId}`
-    );
-
-    if (!response.ok) {
-      logger.error(`Failed to fetch series with CTA: ${response.status}`);
-      return null;
-    }
-
-    return response.json();
-  } catch (error) {
-    logger.error('Error fetching series occurrences:', error);
-    return null;
-  }
-}
-
-/**
- * Check event password
- *
- * Validates password for password-protected events.
- *
- * @param eventId - The event ID
- * @param password - The password to check
- * @returns Whether the password is valid
- */
-export async function checkEventPassword(
-  eventId: string | number,
-  password: string
-): Promise<boolean> {
-  try {
-    const encodedPassword = encodeURIComponent(password);
-    const response = await fetch(
-      `${getPublicBaseUrl()}/events/${eventId}/check-password/${encodedPassword}`
-    );
-
-    if (!response.ok) {
-      return false;
-    }
-
-    const result = await response.json();
-    return result.valid === true;
-  } catch (error) {
-    logger.error('Error checking event password:', error);
-    return false;
-  }
-}
-
-/**
- * Test network connection
- *
- * Health check endpoint for connectivity testing.
- *
- * @param orgId - Optional org ID
- * @param venueId - Optional venue ID
- * @returns Whether the connection is working
- */
-export async function testNetworkConnection(
-  orgId?: string | number,
-  venueId?: string | number
-): Promise<boolean> {
-  try {
-    // Use a simple endpoint to test connectivity
-    const url = venueId
-      ? `${getPublicBaseUrl()}/events/venue/${venueId}`
-      : orgId
-      ? `${getPublicBaseUrl()}/venues/organization/${orgId}`
-      : `${getPublicBaseUrl()}/health`;
-
-    const response = await fetch(url, {
-      method: 'HEAD',
-    });
-
-    return response.ok;
-  } catch (error) {
-    logger.error('Network connection test failed:', error);
-    return false;
-  }
-}