@slotchain/sdk 1.1.3 → 1.2.0

package/src/clients/__tests__/service-client.spec.ts

@@ -0,0 +1,450 @@
+/**
+ * Unit tests for ServiceClient.getServicesByTenant() and getServicesBySlot()
+ * 
+ * Tests cover:
+ * - getServicesByTenant() with various parameter combinations
+ * - getServicesBySlot() with valid/invalid slot IDs
+ * - Type safety for ServiceWithItems vs SlotServiceWithItems
+ * - Error handling for all error codes
+ */
+
+import axios from 'axios';
+import axiosMockAdapter from 'axios-mock-adapter';
+import { ServiceClient } from '../service-client';
+import type { Service, ServiceWithItems, SlotServiceWithItems } from '../../types/api';
+
+describe('ServiceClient', () => {
+  let mockAdapter: axiosMockAdapter;
+  let client: axios.AxiosInstance;
+  let serviceClient: ServiceClient;
+
+  beforeEach(() => {
+    // Create a new axios instance for each test
+    client = axios.create({
+      baseURL: 'https://api.slotly.dev',
+    });
+    mockAdapter = new axiosMockAdapter(client, { delayResponse: 0 });
+    serviceClient = new ServiceClient(client);
+  });
+
+  afterEach(() => {
+    mockAdapter.restore();
+  });
+
+  describe('getServicesByTenant()', () => {
+    describe('With tenantId', () => {
+      it('should return services without items when includeItems is false', async () => {
+        const mockServices: Service[] = [
+          {
+            id: 'service-1',
+            tenant_id: 'tenant-123',
+            name: 'Consultation',
+            description: 'Initial consultation',
+            is_active: true,
+            created_at: '2024-01-01T00:00:00Z',
+            updated_at: '2024-01-01T00:00:00Z',
+          },
+        ];
+
+        mockAdapter
+          .onGet('/api/v1/services', { params: { tenant_id: 'tenant-123' } })
+          .reply(200, {
+            success: true,
+            data: mockServices,
+          });
+
+        const result = await serviceClient.getServicesByTenant({
+          tenantId: 'tenant-123',
+          includeItems: false,
+        });
+
+        expect(result.success).toBe(true);
+        expect(result.data).toBeDefined();
+        expect(Array.isArray(result.data)).toBe(true);
+        expect(result.data?.length).toBe(1);
+        expect(result.data?.[0].id).toBe('service-1');
+        expect('serviceItems' in (result.data?.[0] || {})).toBe(false);
+      });
+
+      it('should return services with items when includeItems is true', async () => {
+        const mockServices: ServiceWithItems[] = [
+          {
+            id: 'service-1',
+            tenant_id: 'tenant-123',
+            name: 'Consultation',
+            description: 'Initial consultation',
+            is_active: true,
+            created_at: '2024-01-01T00:00:00Z',
+            updated_at: '2024-01-01T00:00:00Z',
+            serviceItems: [
+              {
+                id: 'item-1',
+                service_id: 'service-1',
+                name: 'Standard Consultation',
+                price: 100,
+                is_available: true,
+                created_at: '2024-01-01T00:00:00Z',
+                updated_at: '2024-01-01T00:00:00Z',
+              },
+            ],
+          },
+        ];
+
+        mockAdapter
+          .onGet('/api/v1/services', { params: { tenant_id: 'tenant-123', includeItems: true } })
+          .reply(200, {
+            success: true,
+            data: mockServices,
+          });
+
+        const result = await serviceClient.getServicesByTenant({
+          tenantId: 'tenant-123',
+          includeItems: true,
+        });
+
+        expect(result.success).toBe(true);
+        expect(result.data).toBeDefined();
+        expect(Array.isArray(result.data)).toBe(true);
+        const firstService = result.data?.[0] as ServiceWithItems;
+        expect(firstService.serviceItems).toBeDefined();
+        expect(firstService.serviceItems?.length).toBe(1);
+      });
+
+      it('should include pagination metadata when provided', async () => {
+        const mockServices: Service[] = [
+          {
+            id: 'service-1',
+            tenant_id: 'tenant-123',
+            name: 'Consultation',
+            is_active: true,
+            created_at: '2024-01-01T00:00:00Z',
+            updated_at: '2024-01-01T00:00:00Z',
+          },
+        ];
+
+        mockAdapter
+          .onGet('/api/v1/services', { params: { tenant_id: 'tenant-123', page: 1, limit: 20 } })
+          .reply(200, {
+            success: true,
+            data: mockServices,
+            pagination: {
+              page: 1,
+              limit: 20,
+              total: 50,
+              totalPages: 3,
+            },
+          });
+
+        const result = await serviceClient.getServicesByTenant({
+          tenantId: 'tenant-123',
+          page: 1,
+          limit: 20,
+        });
+
+        expect(result.success).toBe(true);
+        expect(result.pagination).toBeDefined();
+        expect(result.pagination?.page).toBe(1);
+        expect(result.pagination?.total).toBe(50);
+      });
+
+      it('should filter by isActive when provided', async () => {
+        const mockServices: Service[] = [
+          {
+            id: 'service-1',
+            tenant_id: 'tenant-123',
+            name: 'Active Service',
+            is_active: true,
+            created_at: '2024-01-01T00:00:00Z',
+            updated_at: '2024-01-01T00:00:00Z',
+          },
+        ];
+
+        mockAdapter
+          .onGet('/api/v1/services', { params: { tenant_id: 'tenant-123', is_active: true } })
+          .reply(200, {
+            success: true,
+            data: mockServices,
+          });
+
+        const result = await serviceClient.getServicesByTenant({
+          tenantId: 'tenant-123',
+          isActive: true,
+        });
+
+        expect(result.success).toBe(true);
+        expect(result.data?.length).toBe(1);
+        expect(result.data?.[0].is_active).toBe(true);
+      });
+    });
+
+    describe('With tenantSlug', () => {
+      it('should return services when using tenantSlug', async () => {
+        const mockServices: Service[] = [
+          {
+            id: 'service-1',
+            tenant_id: 'tenant-123',
+            name: 'Consultation',
+            is_active: true,
+            created_at: '2024-01-01T00:00:00Z',
+            updated_at: '2024-01-01T00:00:00Z',
+          },
+        ];
+
+        mockAdapter
+          .onGet('/api/v1/services', { params: { tenantSlug: 'sn-cleaning-co' } })
+          .reply(200, {
+            success: true,
+            data: mockServices,
+          });
+
+        const result = await serviceClient.getServicesByTenant({
+          tenantSlug: 'sn-cleaning-co',
+        });
+
+        expect(result.success).toBe(true);
+        expect(result.data).toBeDefined();
+        expect(result.data?.length).toBe(1);
+      });
+    });
+
+    describe('Error handling', () => {
+      it('should return MISSING_TENANT_ID error when neither tenantId nor tenantSlug provided', async () => {
+        const result = await serviceClient.getServicesByTenant({});
+
+        expect(result.success).toBe(false);
+        expect(result.error).toBeDefined();
+        expect(result.error?.code).toBe('MISSING_TENANT_ID');
+        expect(result.error?.message).toContain('tenantId or tenantSlug is required');
+      });
+
+      it('should handle TENANT_NOT_FOUND error', async () => {
+        mockAdapter
+          .onGet('/api/v1/services', { params: { tenantSlug: 'invalid-tenant' } })
+          .reply(404, {
+            success: false,
+            error: {
+              code: 'TENANT_NOT_FOUND',
+              message: 'Tenant with slug "invalid-tenant" not found',
+            },
+          });
+
+        const result = await serviceClient.getServicesByTenant({
+          tenantSlug: 'invalid-tenant',
+        });
+
+        expect(result.success).toBe(false);
+        expect(result.error?.code).toBe('TENANT_NOT_FOUND');
+      });
+
+      it('should handle INTERNAL_ERROR', async () => {
+        mockAdapter
+          .onGet('/api/v1/services', { params: { tenant_id: 'tenant-123' } })
+          .reply(500, {
+            success: false,
+            error: {
+              code: 'INTERNAL_ERROR',
+              message: 'Internal server error',
+            },
+          });
+
+        const result = await serviceClient.getServicesByTenant({
+          tenantId: 'tenant-123',
+        });
+
+        expect(result.success).toBe(false);
+        expect(result.error?.code).toBe('INTERNAL_ERROR');
+      });
+
+      it('should enforce max limit of 100', async () => {
+        const mockServices: Service[] = [];
+
+        mockAdapter
+          .onGet('/api/v1/services', { params: { tenant_id: 'tenant-123', limit: 100 } })
+          .reply(200, {
+            success: true,
+            data: mockServices,
+          });
+
+        // Request with limit > 100 should be capped at 100
+        await serviceClient.getServicesByTenant({
+          tenantId: 'tenant-123',
+          limit: 150,
+        });
+
+        // Verify the request was made with limit: 100
+        expect(mockAdapter.history.get.length).toBe(1);
+        const request = mockAdapter.history.get[0];
+        expect(request.params?.limit).toBe(100);
+      });
+    });
+
+    describe('Deprecated slotId parameter', () => {
+      it('should accept slotId parameter for compatibility', async () => {
+        const mockServices: Service[] = [
+          {
+            id: 'service-1',
+            tenant_id: 'tenant-123',
+            name: 'Consultation',
+            is_active: true,
+            created_at: '2024-01-01T00:00:00Z',
+            updated_at: '2024-01-01T00:00:00Z',
+          },
+        ];
+
+        mockAdapter
+          .onGet('/api/v1/services', { params: { tenant_id: 'tenant-123', slot_id: 'slot-123' } })
+          .reply(200, {
+            success: true,
+            data: mockServices,
+          });
+
+        const result = await serviceClient.getServicesByTenant({
+          tenantId: 'tenant-123',
+          slotId: 'slot-123', // Deprecated but accepted
+        });
+
+        expect(result.success).toBe(true);
+        // Verify slot_id was included in request (even though API ignores it)
+        expect(mockAdapter.history.get[0].params?.slot_id).toBe('slot-123');
+      });
+    });
+  });
+
+  describe('getServicesBySlot()', () => {
+    describe('Valid slot ID', () => {
+      it('should return services with items property (not serviceItems)', async () => {
+        const mockServices: SlotServiceWithItems[] = [
+          {
+            id: 'service-1',
+            tenant_id: 'tenant-123',
+            name: 'Consultation',
+            is_active: true,
+            created_at: '2024-01-01T00:00:00Z',
+            updated_at: '2024-01-01T00:00:00Z',
+            items: [
+              {
+                id: 'item-1',
+                service_id: 'service-1',
+                name: 'Standard Consultation',
+                price: 100,
+                is_available: true,
+                created_at: '2024-01-01T00:00:00Z',
+                updated_at: '2024-01-01T00:00:00Z',
+              },
+            ],
+          },
+        ];
+
+        mockAdapter
+          .onGet('/api/v1/slots/slot-123/services')
+          .reply(200, {
+            success: true,
+            data: mockServices,
+          });
+
+        const result = await serviceClient.getServicesBySlot('slot-123');
+
+        expect(result.success).toBe(true);
+        expect(result.data).toBeDefined();
+        expect(Array.isArray(result.data)).toBe(true);
+        expect(result.data?.length).toBe(1);
+        
+        const firstService = result.data?.[0];
+        expect(firstService?.items).toBeDefined();
+        expect(firstService?.items.length).toBe(1);
+        // Verify it uses 'items' not 'serviceItems'
+        expect('serviceItems' in (firstService || {})).toBe(false);
+      });
+
+      it('should only return active services', async () => {
+        const mockServices: SlotServiceWithItems[] = [
+          {
+            id: 'service-1',
+            tenant_id: 'tenant-123',
+            name: 'Active Service',
+            is_active: true,
+            created_at: '2024-01-01T00:00:00Z',
+            updated_at: '2024-01-01T00:00:00Z',
+            items: [],
+          },
+        ];
+
+        mockAdapter
+          .onGet('/api/v1/slots/slot-123/services')
+          .reply(200, {
+            success: true,
+            data: mockServices,
+          });
+
+        const result = await serviceClient.getServicesBySlot('slot-123');
+
+        expect(result.success).toBe(true);
+        expect(result.data?.every(s => s.is_active === true)).toBe(true);
+      });
+
+      it('should always include items (even if empty array)', async () => {
+        const mockServices: SlotServiceWithItems[] = [
+          {
+            id: 'service-1',
+            tenant_id: 'tenant-123',
+            name: 'Service without items',
+            is_active: true,
+            created_at: '2024-01-01T00:00:00Z',
+            updated_at: '2024-01-01T00:00:00Z',
+            items: [],
+          },
+        ];
+
+        mockAdapter
+          .onGet('/api/v1/slots/slot-123/services')
+          .reply(200, {
+            success: true,
+            data: mockServices,
+          });
+
+        const result = await serviceClient.getServicesBySlot('slot-123');
+
+        expect(result.success).toBe(true);
+        expect(result.data?.[0].items).toBeDefined();
+        expect(Array.isArray(result.data?.[0].items)).toBe(true);
+      });
+    });
+
+    describe('Error handling', () => {
+      it('should handle SLOT_NOT_FOUND error', async () => {
+        mockAdapter
+          .onGet('/api/v1/slots/invalid-slot/services')
+          .reply(404, {
+            success: false,
+            error: {
+              code: 'SLOT_NOT_FOUND',
+              message: 'Slot with id "invalid-slot" not found',
+            },
+          });
+
+        const result = await serviceClient.getServicesBySlot('invalid-slot');
+
+        expect(result.success).toBe(false);
+        expect(result.error?.code).toBe('SLOT_NOT_FOUND');
+      });
+
+      it('should handle INTERNAL_ERROR', async () => {
+        mockAdapter
+          .onGet('/api/v1/slots/slot-123/services')
+          .reply(500, {
+            success: false,
+            error: {
+              code: 'INTERNAL_ERROR',
+              message: 'Internal server error',
+            },
+          });
+
+        const result = await serviceClient.getServicesBySlot('slot-123');
+
+        expect(result.success).toBe(false);
+        expect(result.error?.code).toBe('INTERNAL_ERROR');
+      });
+    });
+  });
+});
+

package/src/clients/customer-client.ts

@@ -1,5 +1,14 @@
 import { AxiosInstance } from 'axios';
-import { ApiResponse, Customer, Booking } from '../types/api';
+import {
+  ApiResponse,
+  Customer,
+  CustomerIdentity,
+  CustomerWithIdentities,
+  CustomerWithBookings,
+  NotificationPreferences,
+  FindOrCreateCustomerOptions,
+  ResolveCustomerOptions,
+} from '../types/api';
 
 export class CustomerClient {
   constructor(private client: AxiosInstance) {}
@@ -58,11 +67,8 @@ export class CustomerClient {
   /**
    * Create a new customer
    * POST /api/v1/customers
-   * 
-   * @param data - Customer creation data (tenant_id, name, email required)
-   * @returns Created customer
    */
-  async create(data: Partial<Customer>): Promise<ApiResponse<Customer>> {
+  async create(data: Partial<Customer> & { tenant_id: string; name: string; email: string }): Promise<ApiResponse<Customer>> {
     const response = await this.client.post<ApiResponse<Customer>>(
       '/api/v1/customers',
       data
@@ -119,14 +125,25 @@ export class CustomerClient {
   }
 
   /**
-   * Get autocomplete data from existing customers and bookings
-   * GET /api/v1/customers/autocomplete
-   * 
-   * @param tenantId - Tenant ID (required)
-   * @returns Autocomplete data
+   * Get autocomplete data from existing customers and bookings.
+   * GET /api/v1/customers/autocomplete?tenantId=:tenantId
    */
-  async autocomplete(tenantId: string): Promise<ApiResponse<any>> {
-    const response = await this.client.get<ApiResponse<any>>(
+  async autocomplete(tenantId: string): Promise<ApiResponse<{
+    companies: string[];
+    jobTitles: string[];
+    experienceLevels: string[];
+    cities: string[];
+    states: string[];
+    zipCodes: string[];
+  }>> {
+    const response = await this.client.get<ApiResponse<{
+      companies: string[];
+      jobTitles: string[];
+      experienceLevels: string[];
+      cities: string[];
+      states: string[];
+      zipCodes: string[];
+    }>>(
       '/api/v1/customers/autocomplete',
       { params: { tenantId } }
     );
@@ -134,32 +151,115 @@ export class CustomerClient {
   }
 
   /**
-   * Get all bookings for a customer
-   * GET /api/v1/customers/bookings
-   * 
-   * @param params - Query parameters (email optional, userId optional, tenantId required)
-   * @returns Customer bookings data
+   * Get all bookings for a customer, grouped by slot.
+   * GET /api/v1/customers/bookings?tenantId=:id
    */
   async getBookings(params: {
     email?: string;
     userId?: string;
     tenantId: string;
-  }): Promise<ApiResponse<{
-    customer: Customer | null;
-    bookings: Booking[];
-    groupedBySlot: Record<string, Booking[]>;
-    total: number;
-  }>> {
-    const response = await this.client.get<ApiResponse<{
-      customer: Customer | null;
-      bookings: Booking[];
-      groupedBySlot: Record<string, Booking[]>;
-      total: number;
-    }>>(
+  }): Promise<ApiResponse<CustomerWithBookings>> {
+    const response = await this.client.get<ApiResponse<CustomerWithBookings>>(
       '/api/v1/customers/bookings',
       { params }
     );
     return response.data;
   }
+
+  // ─── Atomic upsert ────────────────────────────────────────────────────────
+
+  /**
+   * Atomic upsert: find an existing customer by email within a tenant, or create one.
+   * POST /api/v1/customers/find-or-create
+   */
+  async findOrCreate(options: FindOrCreateCustomerOptions): Promise<ApiResponse<Customer & { created: boolean }>> {
+    const response = await this.client.post<ApiResponse<Customer & { created: boolean }>>(
+      '/api/v1/customers/find-or-create',
+      options
+    );
+    return response.data;
+  }
+
+  /**
+   * Resolve a customer from an IDP identity or email.
+   * Tries idpId lookup (customer_users) first, then falls back to email.
+   * POST /api/v1/customers/resolve
+   */
+  async resolve(options: ResolveCustomerOptions): Promise<ApiResponse<Customer | null>> {
+    const response = await this.client.post<ApiResponse<Customer | null>>(
+      '/api/v1/customers/resolve',
+      options
+    );
+    return response.data;
+  }
+
+  // ─── IDP Identity Management ─────────────────────────────────────────────
+
+  /**
+   * Get a customer with their linked IDP identities (customer_users rows).
+   * GET /api/v1/customers/:id?include_identities=true
+   */
+  async getWithIdentities(id: string): Promise<ApiResponse<CustomerWithIdentities>> {
+    const response = await this.client.get<ApiResponse<CustomerWithIdentities>>(
+      `/api/v1/customers/${id}`,
+      { params: { include_identities: true } }
+    );
+    return response.data;
+  }
+
+  /**
+   * Link an IDP user ID to a customer (creates a customer_users row).
+   * POST /api/v1/customers/:id/users
+   */
+  async linkUser(
+    customerId: string,
+    idpId: string,
+    options?: { role?: CustomerIdentity['role']; is_primary?: boolean }
+  ): Promise<ApiResponse<CustomerIdentity>> {
+    const response = await this.client.post<ApiResponse<CustomerIdentity>>(
+      `/api/v1/customers/${customerId}/users`,
+      { idp_id: idpId, role: options?.role ?? 'member', is_primary: options?.is_primary ?? false }
+    );
+    return response.data;
+  }
+
+  /**
+   * Unlink an IDP user from a customer (deletes the customer_users row).
+   * DELETE /api/v1/customers/:id/users/:idpId
+   */
+  async unlinkUser(customerId: string, idpId: string): Promise<ApiResponse<void>> {
+    const response = await this.client.delete<ApiResponse<void>>(
+      `/api/v1/customers/${customerId}/users/${encodeURIComponent(idpId)}`
+    );
+    return response.data;
+  }
+
+  // ─── Notification Preferences ────────────────────────────────────────────
+
+  /**
+   * Get notification preferences for a customer.
+   * GET /api/v1/customers/:id/preferences/notifications
+   */
+  async getNotificationPreferences(customerId: string): Promise<ApiResponse<NotificationPreferences>> {
+    const response = await this.client.get<ApiResponse<NotificationPreferences>>(
+      `/api/v1/customers/${customerId}/preferences/notifications`
+    );
+    return response.data;
+  }
+
+  /**
+   * Update notification preferences for a customer (partial merge).
+   * PATCH /api/v1/customers/:id/preferences/notifications
+   */
+  async updateNotificationPreferences(
+    customerId: string,
+    preferences: Partial<NotificationPreferences>
+  ): Promise<ApiResponse<NotificationPreferences>> {
+    const response = await this.client.patch<ApiResponse<NotificationPreferences>>(
+      `/api/v1/customers/${customerId}/preferences/notifications`,
+      preferences
+    );
+    return response.data;
+  }
 }