@growsober/sdk 1.0.0

package/src/api/mutations/bookings.ts

@@ -0,0 +1,190 @@
+import {
+  useMutation,
+  useQueryClient,
+  UseMutationOptions,
+  UseMutationResult,
+} from '@tanstack/react-query';
+import { getApiClient } from '../client';
+import type { BookingResponse } from '../types';
+import { bookingKeys } from '../queries/bookings';
+import { eventKeys } from '../queries/events';
+
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+
+/**
+ * Create a new booking for an event
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCreateBooking();
+ *
+ * // Simple usage - just pass eventId
+ * mutate({ eventId: 'event-123' });
+ *
+ * // With optional data
+ * mutate({
+ *   eventId: 'event-123',
+ *   ticketCount: 2,
+ *   notes: 'Vegetarian meal preferred'
+ * });
+ * ```
+ */
+export function useCreateBooking(
+  options?: Omit<
+    UseMutationOptions<
+      BookingResponse,
+      Error,
+      { eventId: string; ticketCount?: number; notes?: string }
+    >,
+    'mutationFn'
+  >
+): UseMutationResult<
+  BookingResponse,
+  Error,
+  { eventId: string; ticketCount?: number; notes?: string }
+> {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      eventId,
+      ticketCount,
+      notes,
+    }: {
+      eventId: string;
+      ticketCount?: number;
+      notes?: string;
+    }): Promise<BookingResponse> => {
+      const client = getApiClient();
+      const data: any = {};
+      if (ticketCount) data.ticketCount = ticketCount;
+      if (notes) data.notes = notes;
+      const response = await client.post(`/api/v1/events/${eventId}/book`, data);
+      return response.data;
+    },
+    onSuccess: (newBooking, variables, context) => {
+      // Invalidate user's bookings list
+      queryClient.invalidateQueries({ queryKey: bookingKeys.mine() });
+
+      // Invalidate all booking lists
+      queryClient.invalidateQueries({ queryKey: bookingKeys.lists() });
+
+      // Invalidate the event to reflect updated booking count
+      queryClient.invalidateQueries({
+        queryKey: eventKeys.detail(variables.eventId)
+      });
+
+      // Invalidate event bookings if applicable
+      queryClient.invalidateQueries({
+        queryKey: eventKeys.bookings(variables.eventId)
+      });
+
+      // Invalidate ambient events
+      queryClient.invalidateQueries({ queryKey: eventKeys.ambient() });
+
+      // Call user's onSuccess if provided
+    },
+    ...options,
+  });
+}
+
+/**
+ * Cancel a booking
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCancelBooking();
+ *
+ * mutate('booking-123');
+ * ```
+ */
+export function useCancelBooking(
+  options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>
+): UseMutationResult<void, Error, string> {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (id: string): Promise<void> => {
+      const client = getApiClient();
+      await client.delete(`/api/v1/bookings/${id}`);
+    },
+    onSuccess: (data, bookingId, context) => {
+      // Remove the booking from cache
+      queryClient.removeQueries({ queryKey: bookingKeys.detail(bookingId) });
+
+      // Invalidate user's bookings list
+      queryClient.invalidateQueries({ queryKey: bookingKeys.mine() });
+
+      // Invalidate all booking lists
+      queryClient.invalidateQueries({ queryKey: bookingKeys.lists() });
+
+      // Invalidate QR code cache
+      queryClient.removeQueries({ queryKey: bookingKeys.qrCode(bookingId) });
+
+      // Invalidate events to reflect updated booking counts
+      queryClient.invalidateQueries({ queryKey: eventKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: eventKeys.upcoming() });
+      queryClient.invalidateQueries({ queryKey: eventKeys.ambient() });
+
+      // Call user's onSuccess if provided
+    },
+    ...options,
+  });
+}
+
+/**
+ * Check in a booking
+ *
+ * Note: This is typically used by event hosts/ambassadors to check in attendees
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCheckInBooking();
+ *
+ * mutate('booking-123');
+ * ```
+ */
+export function useCheckInBooking(
+  options?: Omit<UseMutationOptions<BookingResponse, Error, string>, 'mutationFn'>
+): UseMutationResult<BookingResponse, Error, string> {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (id: string): Promise<BookingResponse> => {
+      const client = getApiClient();
+      const response = await client.post(`/api/v1/bookings/${id}/check-in`);
+      return response.data;
+    },
+    onSuccess: (checkedInBooking, bookingId, context) => {
+      // Update the booking in cache
+      queryClient.setQueryData(
+        bookingKeys.detail(bookingId),
+        checkedInBooking
+      );
+
+      // Invalidate user's bookings list to reflect check-in status
+      queryClient.invalidateQueries({ queryKey: bookingKeys.mine() });
+
+      // Invalidate all booking lists
+      queryClient.invalidateQueries({ queryKey: bookingKeys.lists() });
+
+      // Invalidate event bookings if applicable
+      if (checkedInBooking.eventId) {
+        queryClient.invalidateQueries({
+          queryKey: eventKeys.bookings(checkedInBooking.eventId)
+        });
+      }
+
+      // Call user's onSuccess if provided
+    },
+    ...options,
+  });
+}

package/src/api/mutations/event-chat.ts

@@ -0,0 +1,177 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { getApiClient } from '../client';
+import { eventChatKeys } from '../queries/event-chat';
+import type {
+  ChatMemberResponse,
+  MessageResponse,
+  EventChatResponse,
+  SendMessageRequest,
+  UpdateMessageRequest,
+  UpdateChatSettingsRequest,
+  UpdateMemberSettingsRequest,
+} from '../types';
+
+// ============================================================================
+// CHAT MANAGEMENT
+// ============================================================================
+
+/**
+ * Update chat settings (hosts only)
+ */
+export function useUpdateChatSettings(eventId: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (data: UpdateChatSettingsRequest) => {
+      const client = getApiClient();
+      const response = await client.put<EventChatResponse>(
+        `/events/${eventId}/chat/settings`,
+        data
+      );
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: eventChatKeys.chat(eventId) });
+    },
+  });
+}
+
+// ============================================================================
+// MEMBER MANAGEMENT
+// ============================================================================
+
+/**
+ * Join event chat
+ */
+export function useJoinEventChat(eventId: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async () => {
+      const client = getApiClient();
+      const response = await client.post<ChatMemberResponse>(
+        `/events/${eventId}/chat/join`
+      );
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: eventChatKeys.chat(eventId) });
+      queryClient.invalidateQueries({ queryKey: eventChatKeys.members(eventId) });
+    },
+  });
+}
+
+/**
+ * Leave event chat
+ */
+export function useLeaveEventChat(eventId: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async () => {
+      const client = getApiClient();
+      await client.post(`/events/${eventId}/chat/leave`);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: eventChatKeys.chat(eventId) });
+      queryClient.invalidateQueries({ queryKey: eventChatKeys.members(eventId) });
+    },
+  });
+}
+
+/**
+ * Update member settings (mute, nickname)
+ */
+export function useUpdateMemberSettings(eventId: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (data: UpdateMemberSettingsRequest) => {
+      const client = getApiClient();
+      const response = await client.put<ChatMemberResponse>(
+        `/events/${eventId}/chat/settings/me`,
+        data
+      );
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: eventChatKeys.members(eventId) });
+    },
+  });
+}
+
+/**
+ * Mark messages as read
+ */
+export function useMarkMessagesAsRead(eventId: string) {
+  return useMutation({
+    mutationFn: async () => {
+      const client = getApiClient();
+      await client.post(`/events/${eventId}/chat/read`);
+    },
+  });
+}
+
+// ============================================================================
+// MESSAGES
+// ============================================================================
+
+/**
+ * Send a message
+ */
+export function useSendEventChatMessage(eventId: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (data: SendMessageRequest) => {
+      const client = getApiClient();
+      const response = await client.post<MessageResponse>(
+        `/events/${eventId}/chat/messages`,
+        data
+      );
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: eventChatKeys.messages(eventId) });
+      queryClient.invalidateQueries({ queryKey: eventChatKeys.chat(eventId) });
+    },
+  });
+}
+
+/**
+ * Update a message
+ */
+export function useUpdateEventChatMessage(eventId: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({ messageId, content }: { messageId: string } & UpdateMessageRequest) => {
+      const client = getApiClient();
+      const response = await client.put<MessageResponse>(
+        `/events/${eventId}/chat/messages/${messageId}`,
+        { content }
+      );
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: eventChatKeys.messages(eventId) });
+    },
+  });
+}
+
+/**
+ * Delete a message
+ */
+export function useDeleteEventChatMessage(eventId: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (messageId: string) => {
+      const client = getApiClient();
+      await client.delete(`/events/${eventId}/chat/messages/${messageId}`);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: eventChatKeys.messages(eventId) });
+    },
+  });
+}

package/src/api/mutations/events.ts

@@ -0,0 +1,273 @@
+import {
+  useMutation,
+  useQueryClient,
+  UseMutationOptions,
+  UseMutationResult,
+} from '@tanstack/react-query';
+import { getApiClient } from '../client';
+import type { EventResponse, CreateEventRequest, UpdateEventRequest } from '../types';
+import { eventKeys } from '../queries/events';
+
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+
+/**
+ * Create a new event
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCreateEvent();
+ *
+ * mutate({
+ *   title: 'Yoga in the Park',
+ *   description: 'Join us for morning yoga',
+ *   startDate: new Date('2025-01-15T10:00:00Z'),
+ *   // ... other fields
+ * });
+ * ```
+ */
+export function useCreateEvent(
+  options?: Omit<
+    UseMutationOptions<EventResponse, Error, CreateEventRequest>,
+    'mutationFn'
+  >
+): UseMutationResult<EventResponse, Error, CreateEventRequest> {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (data: CreateEventRequest): Promise<EventResponse> => {
+      const client = getApiClient();
+      const response = await client.post('/api/v1/events', data);
+      return response.data;
+    },
+    onSuccess: (newEvent, variables, context) => {
+      // Invalidate all event lists to include the new event
+      queryClient.invalidateQueries({ queryKey: eventKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: eventKeys.upcoming() });
+
+      // If the event is featured, invalidate featured events
+      if (newEvent.isFeatured) {
+        queryClient.invalidateQueries({ queryKey: eventKeys.featured() });
+      }
+
+      // Call user's onSuccess if provided
+    },
+    ...options,
+  });
+}
+
+/**
+ * Update an existing event
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useUpdateEvent();
+ *
+ * mutate({
+ *   id: 'event-123',
+ *   data: {
+ *     title: 'Updated Event Title',
+ *     isFeatured: true,
+ *   }
+ * });
+ * ```
+ */
+export function useUpdateEvent(
+  options?: Omit<
+    UseMutationOptions<
+      EventResponse,
+      Error,
+      { id: string; data: UpdateEventRequest }
+    >,
+    'mutationFn'
+  >
+): UseMutationResult<EventResponse, Error, { id: string; data: UpdateEventRequest }> {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      id,
+      data,
+    }: {
+      id: string;
+      data: UpdateEventRequest;
+    }): Promise<EventResponse> => {
+      const client = getApiClient();
+      const response = await client.put(`/api/v1/events/${id}`, data);
+      return response.data;
+    },
+    onSuccess: (updatedEvent, variables, context) => {
+      // Update the specific event in cache
+      queryClient.setQueryData(
+        eventKeys.detail(variables.id),
+        updatedEvent
+      );
+
+      // If the event has a slug, update the slug-based query too
+      if (updatedEvent.slug && typeof updatedEvent.slug === 'string') {
+        queryClient.setQueryData(
+          eventKeys.detailBySlug(updatedEvent.slug),
+          updatedEvent
+        );
+      }
+
+      // Invalidate lists to reflect changes in ordering/filtering
+      queryClient.invalidateQueries({ queryKey: eventKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: eventKeys.upcoming() });
+      queryClient.invalidateQueries({ queryKey: eventKeys.featured() });
+
+      // Call user's onSuccess if provided
+    },
+    ...options,
+  });
+}
+
+/**
+ * Delete an event
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useDeleteEvent();
+ *
+ * mutate('event-123');
+ * ```
+ */
+export function useDeleteEvent(
+  options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>
+): UseMutationResult<void, Error, string> {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (id: string): Promise<void> => {
+      const client = getApiClient();
+      await client.delete(`/api/v1/events/${id}`);
+    },
+    onSuccess: (data, eventId, context) => {
+      // Remove the event from cache
+      queryClient.removeQueries({ queryKey: eventKeys.detail(eventId) });
+
+      // Invalidate all lists
+      queryClient.invalidateQueries({ queryKey: eventKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: eventKeys.upcoming() });
+      queryClient.invalidateQueries({ queryKey: eventKeys.featured() });
+
+      // Call user's onSuccess if provided
+    },
+    ...options,
+  });
+}
+
+/**
+ * Cancel an event
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCancelEvent();
+ *
+ * mutate('event-123');
+ * ```
+ */
+export function useCancelEvent(
+  options?: Omit<UseMutationOptions<EventResponse, Error, string>, 'mutationFn'>
+): UseMutationResult<EventResponse, Error, string> {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (id: string): Promise<EventResponse> => {
+      const client = getApiClient();
+      const response = await client.post(`/api/v1/events/${id}/cancel`);
+      return response.data;
+    },
+    onSuccess: (cancelledEvent, eventId, context) => {
+      // Update the specific event in cache
+      queryClient.setQueryData(
+        eventKeys.detail(eventId),
+        cancelledEvent
+      );
+
+      // If the event has a slug, update the slug-based query too
+      if (cancelledEvent.slug && typeof cancelledEvent.slug === 'string') {
+        queryClient.setQueryData(
+          eventKeys.detailBySlug(cancelledEvent.slug),
+          cancelledEvent
+        );
+      }
+
+      // Invalidate lists to reflect the cancelled status
+      queryClient.invalidateQueries({ queryKey: eventKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: eventKeys.upcoming() });
+      queryClient.invalidateQueries({ queryKey: eventKeys.featured() });
+
+      // Invalidate bookings for this event
+      queryClient.invalidateQueries({ queryKey: eventKeys.bookings(eventId) });
+
+      // Call user's onSuccess if provided
+    },
+    ...options,
+  });
+}
+
+/**
+ * Publish an event
+ *
+ * Note: This mutation is provided for future compatibility.
+ * The API endpoint exists but may require specific permissions.
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = usePublishEvent();
+ *
+ * mutate('event-123');
+ * ```
+ */
+export function usePublishEvent(
+  options?: Omit<UseMutationOptions<EventResponse, Error, string>, 'mutationFn'>
+): UseMutationResult<EventResponse, Error, string> {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (id: string): Promise<EventResponse> => {
+      const client = getApiClient();
+      const response = await client.post(`/api/v1/events/${id}/publish`);
+      return response.data;
+    },
+    onSuccess: (publishedEvent, eventId, context) => {
+      // Update the specific event in cache
+      queryClient.setQueryData(
+        eventKeys.detail(eventId),
+        publishedEvent
+      );
+
+      // If the event has a slug, update the slug-based query too
+      if (publishedEvent.slug && typeof publishedEvent.slug === 'string') {
+        queryClient.setQueryData(
+          eventKeys.detailBySlug(publishedEvent.slug),
+          publishedEvent
+        );
+      }
+
+      // Invalidate lists to reflect the published status
+      queryClient.invalidateQueries({ queryKey: eventKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: eventKeys.upcoming() });
+
+      // If the event is featured, invalidate featured events
+      if (publishedEvent.isFeatured) {
+        queryClient.invalidateQueries({ queryKey: eventKeys.featured() });
+      }
+
+      // Call user's onSuccess if provided
+    },
+    ...options,
+  });
+}