@slotchain/sdk 1.1.3 → 1.1.4

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/service-client.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from 'axios';
-import { ApiResponse, Service, ServiceWithItems, Category } from '../types/api';
+import { ApiResponse, Service, ServiceWithItems, SlotServiceWithItems, Category } from '../types/api';
 
 export class ServiceClient {
   constructor(private client: AxiosInstance) {}
@@ -20,10 +20,95 @@ export class ServiceClient {
     return response.data;
   }
 
+  /**
+   * Get services for a tenant (full list with optional filters)
+   * GET /api/v1/services
+   * 
+   * @param options - Query options
+   * @param options.tenantId - Tenant ID (UUID) - required if tenantSlug not provided
+   * @param options.tenantSlug - Tenant slug - required if tenantId not provided
+   * @param options.slotId - Slot ID (DEPRECATED - accepted but ignored for API compatibility)
+   * @param options.isActive - Filter by active status
+   * @param options.includeItems - Include nested service items (default: false)
+   * @param options.page - Page number (default: 1)
+   * @param options.limit - Items per page (default: 20, max: 100)
+   * @returns Services with optional pagination metadata
+   */
+  async getServicesByTenant(options: {
+    tenantId?: string;
+    tenantSlug?: string;
+    slotId?: string; // DEPRECATED - accepted but ignored
+    isActive?: boolean;
+    includeItems?: boolean;
+    page?: number;
+    limit?: number;
+  }): Promise<ApiResponse<Service[] | ServiceWithItems[]>> {
+    // Validate that either tenantId or tenantSlug is provided
+    if (!options.tenantId && !options.tenantSlug) {
+      return {
+        success: false,
+        error: {
+          code: 'MISSING_TENANT_ID',
+          message: 'tenantId or tenantSlug is required',
+        },
+      };
+    }
+
+    // Build query parameters
+    const params: Record<string, any> = {};
+    
+    if (options.tenantId) {
+      params.tenant_id = options.tenantId;
+    }
+    if (options.tenantSlug) {
+      params.tenantSlug = options.tenantSlug;
+    }
+    if (options.slotId) {
+      // Include for API compatibility, even though it's ignored
+      params.slot_id = options.slotId;
+    }
+    if (options.isActive !== undefined) {
+      params.is_active = options.isActive;
+    }
+    if (options.includeItems) {
+      params.includeItems = true;
+    }
+    if (options.page !== undefined) {
+      params.page = options.page;
+    }
+    if (options.limit !== undefined) {
+      params.limit = Math.min(options.limit, 100); // Enforce max limit
+    }
+
+    const response = await this.client.get<ApiResponse<Service[] | ServiceWithItems[]>>(
+      '/api/v1/services',
+      { params }
+    );
+    return response.data;
+  }
+
+  /**
+   * Get services for a specific slot
+   * GET /api/v1/slots/:id/services
+   * 
+   * Note: Services are tenant-level entities. This endpoint returns all active services
+   * for the slot's tenant with items included. The response uses 'items' property (not 'serviceItems').
+   * 
+   * @param slotId - Slot ID (UUID)
+   * @returns Services with nested items (always includes items, only active services)
+   */
+  async getServicesBySlot(slotId: string): Promise<ApiResponse<SlotServiceWithItems[]>> {
+    const response = await this.client.get<ApiResponse<SlotServiceWithItems[]>>(
+      `/api/v1/slots/${slotId}/services`
+    );
+    return response.data;
+  }
+
   /**
    * List services by tenant slug
    * GET /api/v1/services?tenantSlug=:slug
    * 
+   * @deprecated Consider using getServicesByTenant() for better type safety and validation
    * @param slug - Tenant slug (or use tenant_id in list() method)
    * @param params - Optional parameters (includeItems, page, limit, is_active)
    * @returns List of services for the tenant
@@ -48,6 +133,7 @@ export class ServiceClient {
    * List services with optional filters
    * GET /api/v1/services
    * 
+   * @deprecated Consider using getServicesByTenant() for better type safety and validation
    * @param params - Query parameters (tenant_id, tenantSlug, slot_id, page, limit, is_active, includeItems)
    * @returns Paginated list of services
    */

package/src/clients/slot-client.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from 'axios';
-import { ApiResponse, Slot, ServiceWithItems, Tenant } from '../types/api';
+import { ApiResponse, Slot, SlotServiceWithItems, Tenant } from '../types/api';
 
 export class SlotClient {
   constructor(private client: AxiosInstance) {}
@@ -113,11 +113,14 @@ export class SlotClient {
    * Get all active services for a slot with their items
    * GET /api/v1/slots/:id/services
    * 
-   * @param id - Slot ID
-   * @returns Services with nested service items
+   * Note: Services are tenant-level entities. This endpoint returns all active services
+   * for the slot's tenant with items included. The response uses 'items' property (not 'serviceItems').
+   * 
+   * @param id - Slot ID (UUID)
+   * @returns Services with nested items (always includes items, only active services)
    */
-  async getServices(id: string): Promise<ApiResponse<ServiceWithItems[]>> {
-    const response = await this.client.get<ApiResponse<ServiceWithItems[]>>(
+  async getServices(id: string): Promise<ApiResponse<SlotServiceWithItems[]>> {
+    const response = await this.client.get<ApiResponse<SlotServiceWithItems[]>>(
       `/api/v1/slots/${id}/services`
     );
     return response.data;

package/src/index.ts

@@ -26,6 +26,7 @@ export type {
   Service,
   ServiceItem,
   ServiceWithItems,
+  SlotServiceWithItems,
   ServiceItemWithService,
   Category,
   Slot,

package/src/types/api.ts

@@ -59,23 +59,35 @@ export interface TenantBranding {
  */
 export interface ServiceItem {
   id: string;
-  serviceId: string;
+  service_id: string;
   name: string;
   description?: string;
   price?: number;
   duration?: number;
-  available?: boolean;
-  // TODO: Add actual service item properties
+  is_available?: boolean;
+  sort_order?: number;
+  created_at: string;
+  updated_at: string;
 }
 
 /**
- * Enhanced Service type with nested service items
+ * Enhanced Service type with nested service items (for tenant endpoint)
+ * Uses 'serviceItems' property name
  */
 export interface ServiceWithItems extends Service {
   /** Array of service items nested within this service (optional, may be empty array) */
   serviceItems?: ServiceItem[];
 }
 
+/**
+ * Service with items for slot endpoint
+ * Uses 'items' property name (different from tenant endpoint)
+ */
+export interface SlotServiceWithItems extends Service {
+  /** Array of service items nested within this service (always included for slot endpoint) */
+  items: ServiceItem[];
+}
+
 /**
  * Service item with parent service reference
  */
@@ -148,12 +160,16 @@ export interface ListBookingsOptions {
 
 export interface Service {
   id: string;
-  tenantId: string;
+  tenant_id: string;
+  slot_id?: string; // Present but not used in queries
   name: string;
   description?: string;
+  category?: string;
+  is_active?: boolean;
   duration?: number;
   price?: number;
-  // TODO: Add actual service properties
+  created_at: string;
+  updated_at: string;
 }
 
 export interface Slot {