@slotchain/sdk 1.1.0 → 1.1.2

package/README.md

@@ -62,6 +62,7 @@ console.log(tenant.data);
 The SDK provides typed clients for each domain:
 
 - **TenantClient** - Tenant configuration and management
+- **OrganizationClient** - Organization management and tenant associations
 - **BookingClient** - Booking CRUD operations
 - **ServiceClient** - Service management (listServices, create, update, delete, bulkCreate)
 - **SlotClient** - Time slot management and availability
@@ -106,6 +107,30 @@ const booking = await slotly.booking.create({
 });
 ```
 
+### List Bookings by Tenant  
+```ts
+// List bookings for a tenant (single query - fast!)
+const bookings = await slotly.booking.list({
+  tenant_id: 'tenant-123',
+  includeSlot: true,
+  page: 1,
+  limit: 20
+});
+
+// Convenience methods
+const tenantBookings = await slotly.booking.listByTenant('tenant-123');
+const tenantBookingsWithSlots = await slotly.booking.listByTenantWithSlots('tenant-123');
+
+// Access slot information
+if (bookings.success && bookings.data) {
+  bookings.data.forEach(booking => {
+    if ('slots' in booking && booking.slots) {
+      console.log('Slot name:', booking.slots.name);
+    }
+  });
+}
+```
+
 ### Service Management  
 ```ts
 const services = await slotly.service.listServices('bright-accountants');
@@ -114,6 +139,28 @@ if (services.success) {
 }
 ```
 
+### Organization Management  
+```ts
+// Get organization only
+const org = await slotly.organization.getById('org-123');
+
+// Get organization with nested tenants
+const orgWithTenants = await slotly.organization.getById('org-123', {
+  includeTenants: true,
+  page: 1,
+  limit: 10,
+  is_public: true
+});
+
+if (orgWithTenants.success && orgWithTenants.data) {
+  const org = orgWithTenants.data;
+  if ('tenants' in org) {
+    console.log('Organization:', org.name);
+    console.log('Tenants:', org.tenants.map(t => t.name));
+  }
+}
+```
+
 ## Middleware & Auth  
 For your API routes, use the `validateSlotlyRequest()` middleware to enforce both client and optional user auth:
 

package/dist/index.cjs.js

@@ -218,8 +218,30 @@ var BookingClient = class {
     return response.data;
   }
   /**
-   * List bookings
+   * List bookings with enhanced filtering
    * GET /api/v1/bookings
+   *
+   * Supports filtering by tenant_id, slot_id, customer_id, status, and optional nested slot information.
+   *
+   * @param params - Query options (tenant_id, slot_id, customer_id, status, includeSlot, page, limit)
+   * @returns Bookings or BookingsWithSlot based on includeSlot parameter
+   *
+   * @example
+   * ```typescript
+   * // List bookings by tenant (single query - fast!)
+   * const bookings = await slotly.booking.list({
+   *   tenant_id: 'tenant-123',
+   *   includeSlot: true,
+   *   page: 1,
+   *   limit: 20
+   * });
+   *
+   * // List bookings by slot
+   * const slotBookings = await slotly.booking.list({
+   *   slot_id: 'slot-456',
+   *   status: 'confirmed'
+   * });
+   * ```
    */
   async list(params) {
     const response = await this.client.get(
@@ -228,6 +250,59 @@ var BookingClient = class {
     );
     return response.data;
   }
+  /**
+   * List bookings by tenant (convenience method)
+   * GET /api/v1/bookings?tenant_id=:id
+   *
+   * @param tenantId - Tenant ID
+   * @param options - Additional options (includeSlot, page, limit, status)
+   * @returns Bookings or BookingsWithSlot based on includeSlot parameter
+   *
+   * @example
+   * ```typescript
+   * const bookings = await slotly.booking.listByTenant('tenant-123', {
+   *   page: 1,
+   *   limit: 20,
+   *   status: 'confirmed'
+   * });
+   * ```
+   */
+  async listByTenant(tenantId, options) {
+    return this.list({
+      tenant_id: tenantId,
+      ...options
+    });
+  }
+  /**
+   * List bookings by tenant with nested slot information (convenience method)
+   * GET /api/v1/bookings?tenant_id=:id&includeSlot=true
+   *
+   * @param tenantId - Tenant ID
+   * @param options - Additional options (page, limit, status)
+   * @returns BookingsWithSlot (includes nested slot information)
+   *
+   * @example
+   * ```typescript
+   * const bookings = await slotly.booking.listByTenantWithSlots('tenant-123', {
+   *   page: 1,
+   *   limit: 20
+   * });
+   *
+   * // Access slot information
+   * bookings.data.forEach(booking => {
+   *   if (booking.slots) {
+   *     console.log('Slot name:', booking.slots.name);
+   *   }
+   * });
+   * ```
+   */
+  async listByTenantWithSlots(tenantId, options) {
+    return this.list({
+      tenant_id: tenantId,
+      includeSlot: true,
+      ...options
+    });
+  }
   /**
    * Create a new booking (publishes booking.created event)
    * POST /api/v1/bookings
@@ -1143,6 +1218,73 @@ var DataQualityClient = class {
   }
 };
 
+// src/clients/organization-client.ts
+var OrganizationClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get organization by ID or slug
+   * GET /api/v1/organizations/:id
+   *
+   * @param identifier - Organization ID or slug
+   * @param options - Query options (includeTenants, page, limit, is_public)
+   * @returns Organization or OrganizationFullConfig (with nested tenants if includeTenants=true)
+   *
+   * @example
+   * ```typescript
+   * // Get organization only
+   * const org = await slotly.organization.getById('org-123');
+   *
+   * // Get organization with tenants
+   * const orgWithTenants = await slotly.organization.getById('org-123', {
+   *   includeTenants: true,
+   *   page: 1,
+   *   limit: 10,
+   *   is_public: true
+   * });
+   * ```
+   */
+  async getById(identifier, options) {
+    const params = {};
+    if (options?.includeTenants) {
+      params.includeTenants = "true";
+    }
+    if (options?.page !== void 0) {
+      params.page = options.page;
+    }
+    if (options?.limit !== void 0) {
+      params.limit = options.limit;
+    }
+    if (options?.is_public !== void 0) {
+      params.is_public = options.is_public;
+    }
+    const response = await this.client.get(
+      `/api/v1/organizations/${identifier}`,
+      { params }
+    );
+    return response.data;
+  }
+  /**
+   * Get organization by slug (alias for getById)
+   * GET /api/v1/organizations/:slug
+   *
+   * @param slug - Organization slug
+   * @param options - Query options (includeTenants, page, limit, is_public)
+   * @returns Organization or OrganizationFullConfig (with nested tenants if includeTenants=true)
+   *
+   * @example
+   * ```typescript
+   * const org = await slotly.organization.getBySlug('acme-corp', {
+   *   includeTenants: true
+   * });
+   * ```
+   */
+  async getBySlug(slug, options) {
+    return this.getById(slug, options);
+  }
+};
+
 // src/errors.ts
 var SlotlyApiError = class _SlotlyApiError extends Error {
   constructor(code, message, statusCode, details) {
@@ -1474,7 +1616,8 @@ var useSlotly = (options) => {
     flow: new FlowClient(client),
     studio: new StudioClient(client),
     notification: new NotificationClient(client),
-    dataQuality: new DataQualityClient(client)
+    dataQuality: new DataQualityClient(client),
+    organization: new OrganizationClient(client)
   };
 };
 var index_default = useSlotly;