@wix/headless-bookings 0.0.9 → 0.0.11

package/dist/services/service/service.d.ts

@@ -2,8 +2,43 @@
  * Service Service - Reactive service data management
  * Handles loading and managing a single service's data, loading state, and errors.
  */
-import { type Signal } from '@wix/services-definitions/core-services/signals';
+import { type Signal, type ReadOnlySignal } from '@wix/services-definitions/core-services/signals';
 import { services } from '@wix/bookings';
+import type { MoneyData } from '@wix/headless-components/react';
+/**
+ * Actions object for service selection
+ */
+export interface ServiceActions {
+    /** Replace entire selection with this service (with current modifiers) */
+    select: () => void;
+    /** Add this service to selection (with current modifiers) */
+    add: () => void;
+    /** Remove this service from selection */
+    remove: () => void;
+}
+/**
+ * Payment data derived from service payment information
+ *
+ * @interface ServicePaymentData
+ */
+export interface ServicePaymentData {
+    /** The service payment information from the service */
+    servicePayment: services.Payment | undefined;
+    /** The rate type of the service (FIXED, VARIED, CUSTOM, NO_FEE, etc.) */
+    rateType: services.Payment['rateType'] | undefined;
+    /** Primary price (used for FIXED or VARIED default) */
+    money: MoneyData | null;
+    /** Minimum price (used for VARIED) */
+    minPrice: MoneyData | null;
+    /** Maximum price (used for VARIED) */
+    maxPrice: MoneyData | null;
+    /** Price description text (used for CUSTOM) */
+    priceDescription: string | null;
+    /** Whether the service has add-ons available */
+    hasAddOns: boolean;
+    /** Whether the service has pricing plans available */
+    hasPricingPlans: boolean;
+}
 /**
  * API interface for the Service service, providing reactive service data management.
  *
@@ -11,19 +46,23 @@ import { services } from '@wix/bookings';
  */
 export interface ServiceServiceAPI {
     /** Reactive signal containing the current service data */
-    service: Signal<services.Service>;
+    serviceSignal: Signal<services.Service>;
     /** Reactive signal indicating if a service is currently being loaded */
-    isLoading: Signal<boolean>;
+    isLoadingSignal: Signal<boolean>;
     /** Reactive signal containing any error message, or null if no error */
-    error: Signal<string | null>;
+    errorSignal: Signal<string | null>;
     /** Function to load a service by its id */
-    loadService: (id: string) => Promise<void>;
-    /** Function to select this service (replaces entire selection) */
-    select: () => void;
-    /** Function to add this service to the selection */
-    add: () => void;
-    /** Function to remove this service from the selection */
-    remove: () => void;
+    loadServiceById: (id: string) => Promise<void>;
+    /** Indicates if BookingService is available (false in showcase mode/lead nurturing) */
+    bookableSignal: ReadOnlySignal<boolean>;
+    /** Indicates if the current service is selected in BookingService */
+    selectedSignal: ReadOnlySignal<boolean>;
+    /** Indicates if the service requires availability selection (true for APPOINTMENT and CLASS, false for COURSE) */
+    requiresAvailabilitySignal: ReadOnlySignal<boolean>;
+    /** Reactive signal containing computed payment data derived from service */
+    paymentDataSignal: ReadOnlySignal<ServicePaymentData>;
+    /** Actions object containing service selection actions (only work when bookable is true) */
+    actions: ServiceActions;
 }
 /**
  * Service definition for the Service service.
@@ -47,6 +86,10 @@ export interface ServiceServiceConfig {
     service?: services.Service;
     /** The service ID to load if no initial service is provided */
     serviceId?: string;
+    /** The service slug to load if no initial service is provided */
+    serviceSlug?: string;
+    /** The app ID to filter services by app and determine bookable */
+    appId?: string;
 }
 /**
  * Implementation of the Service service that manages reactive service data.
@@ -70,9 +113,9 @@ export interface ServiceServiceConfig {
  *
  * function ServiceDisplay() {
  *   const serviceService = useService(ServiceServiceDefinition);
- *   const service = serviceService.service.get();
- *   const isLoading = serviceService.isLoading.get();
- *   const error = serviceService.error.get();
+ *   const service = serviceService.serviceSignal.get();
+ *   const isLoading = serviceService.isLoadingSignal.get();
+ *   const error = serviceService.errorSignal.get();
  *
  *   if (isLoading) return <div>Loading...</div>;
  *   if (error) return <div>Error: {error}</div>;
@@ -101,15 +144,19 @@ export type NotFoundServiceServiceConfigResult = {
  * This function is designed to be called during the build or server-side rendering phase
  * to pre-fetch service data before the React components are hydrated on the client.
  *
- * @param slug - The slug of the service to load (e.g., "group-trainings", "yoga-class")
+ * @param params - Either `{ slug: string, appId?: string }` or `{ serviceId: string, appId?: string }`
  * @returns A promise that resolves to either a success result with the config or a notFound result
  *
  * @example
  * ```ts
  * // In an Astro page or API route
- * import { loadServiceServiceConfig } from '@wix/headless-bookings/services';
+ * import { loadServiceServiceInitialData } from '@wix/headless-bookings/services';
+ *
+ * // Load by slug
+ * const serviceResult = await loadServiceServiceInitialData({ slug: 'group-trainings' });
  *
- * const serviceResult = await loadServiceServiceConfig('group-trainings');
+ * // Load by serviceId
+ * const serviceResult = await loadServiceServiceInitialData({ serviceId: 'service-id-123' });
  *
  * if (serviceResult.type === 'notFound') {
  *   return Astro.redirect('/404');
@@ -118,4 +165,10 @@ export type NotFoundServiceServiceConfigResult = {
  * const serviceConfig = serviceResult.config;
  * ```
  */
-export declare function loadServiceServiceConfig(slug: string): Promise<SuccessServiceServiceConfigResult | NotFoundServiceServiceConfigResult>;
+export declare function loadServiceServiceInitialData(params: {
+    slug: string;
+    appId?: string;
+} | {
+    serviceId: string;
+    appId?: string;
+}): Promise<SuccessServiceServiceConfigResult | NotFoundServiceServiceConfigResult>;

package/dist/services/service/service.js

@@ -4,8 +4,14 @@
  */
 import { defineService, implementService } from '@wix/services-definitions';
 import { SignalsServiceDefinition, } from '@wix/services-definitions/core-services/signals';
-import { getServiceById, getServiceBySlug, } from '../../api/query-service/index.js';
-import { BookingServiceDefinition } from '../booking/booking.js';
+import { services } from '@wix/bookings';
+import { getServiceById, getServiceBySlug, } from '../../api/query-services/index.js';
+import { BookingServiceDefinition, } from '../booking/booking.js';
+import { convertToMoneyData } from '../../utils/money.js';
+/**
+ * Booking app ID constant
+ */
+const BOOKING_APP_ID = '13d21c63-b5ec-5912-8397-c3a5ddb27a97';
 /**
  * Service definition for the Service service.
  * This defines the contract that the ServiceService must implement.
@@ -35,9 +41,9 @@ export const ServiceServiceDefinition = defineService('service');
  *
  * function ServiceDisplay() {
  *   const serviceService = useService(ServiceServiceDefinition);
- *   const service = serviceService.service.get();
- *   const isLoading = serviceService.isLoading.get();
- *   const error = serviceService.error.get();
+ *   const service = serviceService.serviceSignal.get();
+ *   const isLoading = serviceService.isLoadingSignal.get();
+ *   const error = serviceService.errorSignal.get();
  *
  *   if (isLoading) return <div>Loading...</div>;
  *   if (error) return <div>Error: {error}</div>;
@@ -48,55 +54,170 @@ export const ServiceServiceDefinition = defineService('service');
  */
 export const ServiceService = implementService.withConfig()(ServiceServiceDefinition, ({ getService, config }) => {
     const signalsService = getService(SignalsServiceDefinition);
-    const bookingService = getService(BookingServiceDefinition);
-    const service = signalsService.signal(config.service);
-    const isLoading = signalsService.signal(!!config.serviceId);
-    const error = signalsService.signal(null);
-    const loadService = async (id) => {
-        isLoading.set(true);
-        error.set(null);
-        const serviceResponse = await getServiceById(id);
+    // Try to get BookingService (optional dependency for showcase mode)
+    let bookingService = null;
+    try {
+        bookingService = getService(BookingServiceDefinition);
+    }
+    catch {
+        // BookingService not available - showcase mode
+        bookingService = null;
+    }
+    // Initialize service signal - use empty service object if not provided
+    const initialService = config.service || {};
+    const serviceSignal = signalsService.signal(initialService);
+    const isLoadingSignal = signalsService.signal(!!config.serviceId);
+    const errorSignal = signalsService.signal(null);
+    // Default appId to BOOKING_APP_ID if not provided
+    const appId = config.appId ?? BOOKING_APP_ID;
+    // bookable signal - true if appId equals booking app ID
+    const bookableSignal = signalsService.computed(() => {
+        return appId === BOOKING_APP_ID;
+    });
+    // selected signal - true if current service is in BookingService preferences
+    const selectedSignal = signalsService.computed(() => {
+        if (!bookingService)
+            return false;
+        const currentService = serviceSignal.get();
+        if (!currentService._id)
+            return false;
+        const services = bookingService.services.get();
+        return services.some((selection) => selection.service._id === currentService._id);
+    });
+    // requiresAvailability signal - true for APPOINTMENT and CLASS types
+    const requiresAvailabilitySignal = signalsService.computed(() => {
+        const currentService = serviceSignal.get();
+        const serviceType = currentService.type;
+        return (serviceType === services.ServiceType.APPOINTMENT ||
+            serviceType === services.ServiceType.CLASS);
+    });
+    // paymentData signal - computed payment data from service
+    const paymentDataSignal = signalsService.computed(() => {
+        const service = serviceSignal.get();
+        const payment = service.payment;
+        const rateType = payment?.rateType;
+        // Initialize all price-related values
+        let money = null;
+        let minPrice = null;
+        let maxPrice = null;
+        let priceDescription = null;
+        // Extract pricing based on rate type
+        if (payment) {
+            switch (rateType) {
+                case services.RateType.FIXED:
+                    // FIXED: Use payment.fixed.price
+                    money = convertToMoneyData(payment.fixed?.price);
+                    break;
+                case services.RateType.VARIED:
+                    // VARIED: Use defaultPrice as money, plus min/max for range
+                    money = convertToMoneyData(payment.varied?.defaultPrice);
+                    minPrice = convertToMoneyData(payment.varied?.minPrice);
+                    maxPrice = convertToMoneyData(payment.varied?.maxPrice);
+                    break;
+                case services.RateType.CUSTOM:
+                    // CUSTOM: Use description text (no numeric price)
+                    priceDescription = payment.custom?.description || null;
+                    break;
+                case services.RateType.NO_FEE:
+                    // NO_FEE: Free service (amount = 0)
+                    money = { amount: 0, currency: 'USD' };
+                    break;
+                default:
+                    // UNKNOWN_RATE_TYPE or undefined - leave all null
+                    break;
+            }
+        }
+        // Derive service capabilities
+        const hasAddOns = (service.addOnGroups?.length ?? 0) > 0;
+        const hasPricingPlans = (payment?.pricingPlanIds?.length ?? 0) > 0;
+        return {
+            servicePayment: payment,
+            rateType,
+            money,
+            minPrice,
+            maxPrice,
+            priceDescription,
+            hasAddOns,
+            hasPricingPlans,
+        };
+    });
+    const loadServiceById = async (id) => {
+        isLoadingSignal.set(true);
+        errorSignal.set(null);
+        const serviceResponse = await getServiceById(id, appId);
         if (!serviceResponse.service) {
-            error.set('Service not found');
-            isLoading.set(false);
+            errorSignal.set('Service not found');
+            isLoadingSignal.set(false);
         }
         else {
-            service.set(serviceResponse.service);
-            error.set(null);
-            isLoading.set(false);
+            serviceSignal.set(serviceResponse.service);
+            errorSignal.set(null);
+            isLoadingSignal.set(false);
         }
     };
-    // Auto-load if serviceId is provided but no service data
-    if (config.serviceId && !config.service) {
-        loadService(config.serviceId);
-    }
-    // Action methods for booking
-    const select = () => {
-        const currentService = service.get();
-        bookingService.selectedServices.set([currentService]);
-    };
-    const add = () => {
-        const currentService = service.get();
-        const selectedServices = bookingService.selectedServices.get();
-        bookingService.selectedServices.set([
-            ...selectedServices,
-            currentService,
-        ]);
+    const loadServiceBySlug = async (slug) => {
+        isLoadingSignal.set(true);
+        errorSignal.set(null);
+        const serviceResponse = await getServiceBySlug(slug, appId);
+        if (!serviceResponse.service) {
+            errorSignal.set('Service not found');
+            isLoadingSignal.set(false);
+        }
+        else {
+            serviceSignal.set(serviceResponse.service);
+            errorSignal.set(null);
+            isLoadingSignal.set(false);
+        }
     };
-    const remove = () => {
-        const currentService = service.get();
-        const selectedServices = bookingService.selectedServices.get();
-        const filtered = selectedServices.filter((s) => s._id !== currentService._id);
-        bookingService.selectedServices.set(filtered);
+    // Auto-load if serviceId or serviceSlug is provided but no service data
+    // Priority: service > serviceSlug > serviceId
+    if (!config.service) {
+        if (config.serviceSlug) {
+            loadServiceBySlug(config.serviceSlug);
+        }
+        else if (config.serviceId) {
+            loadServiceById(config.serviceId);
+        }
+    }
+    // Action methods for booking - only work when bookable is true
+    const actions = {
+        select: () => {
+            if (!bookableSignal.get() || !bookingService)
+                return;
+            const currentService = serviceSignal.get();
+            const selection = {
+                service: currentService,
+            };
+            bookingService.actions.setServices([selection]);
+        },
+        add: () => {
+            if (!bookableSignal.get() || !bookingService)
+                return;
+            const currentService = serviceSignal.get();
+            const selection = {
+                service: currentService,
+            };
+            bookingService.actions.addService(selection);
+        },
+        remove: () => {
+            if (!bookableSignal.get() || !bookingService)
+                return;
+            const currentService = serviceSignal.get();
+            if (currentService._id) {
+                bookingService.actions.removeService(currentService._id);
+            }
+        },
     };
     return {
-        service,
-        isLoading,
-        error,
-        loadService,
-        select,
-        add,
-        remove,
+        serviceSignal,
+        isLoadingSignal,
+        errorSignal,
+        loadServiceById,
+        bookableSignal,
+        selectedSignal,
+        requiresAvailabilitySignal,
+        paymentDataSignal,
+        actions,
     };
 });
 /**
@@ -104,15 +225,19 @@ export const ServiceService = implementService.withConfig()(ServiceServiceDefini
  * This function is designed to be called during the build or server-side rendering phase
  * to pre-fetch service data before the React components are hydrated on the client.
  *
- * @param slug - The slug of the service to load (e.g., "group-trainings", "yoga-class")
+ * @param params - Either `{ slug: string, appId?: string }` or `{ serviceId: string, appId?: string }`
  * @returns A promise that resolves to either a success result with the config or a notFound result
  *
  * @example
  * ```ts
  * // In an Astro page or API route
- * import { loadServiceServiceConfig } from '@wix/headless-bookings/services';
+ * import { loadServiceServiceInitialData } from '@wix/headless-bookings/services';
+ *
+ * // Load by slug
+ * const serviceResult = await loadServiceServiceInitialData({ slug: 'group-trainings' });
  *
- * const serviceResult = await loadServiceServiceConfig('group-trainings');
+ * // Load by serviceId
+ * const serviceResult = await loadServiceServiceInitialData({ serviceId: 'service-id-123' });
  *
  * if (serviceResult.type === 'notFound') {
  *   return Astro.redirect('/404');
@@ -121,9 +246,17 @@ export const ServiceService = implementService.withConfig()(ServiceServiceDefini
  * const serviceConfig = serviceResult.config;
  * ```
  */
-export async function loadServiceServiceConfig(slug) {
+export async function loadServiceServiceInitialData(params) {
     try {
-        const serviceResponse = await getServiceBySlug(slug);
+        // Default appId to BOOKING_APP_ID if not provided
+        const finalAppId = params.appId ?? BOOKING_APP_ID;
+        let serviceResponse;
+        if ('slug' in params) {
+            serviceResponse = await getServiceBySlug(params.slug, finalAppId);
+        }
+        else {
+            serviceResponse = await getServiceById(params.serviceId, finalAppId);
+        }
         if (!serviceResponse.service) {
             return { type: 'notFound' };
         }
@@ -131,11 +264,13 @@ export async function loadServiceServiceConfig(slug) {
             type: 'success',
             config: {
                 service: serviceResponse.service,
+                appId: finalAppId,
             },
         };
     }
     catch (error) {
-        console.error(`Failed to load service for slug "${slug}":`, error);
+        const identifier = 'slug' in params ? `slug "${params.slug}"` : `id "${params.serviceId}"`;
+        console.error(`Failed to load service for ${identifier}:`, error);
         return { type: 'notFound' };
     }
 }

package/dist/services/service-list/service-list.d.ts

@@ -0,0 +1,157 @@
+/**
+ * ServiceList Service - Reactive service list data management
+ * Handles querying and pagination of services list (NO selection management)
+ */
+import { type Signal, type ReadOnlySignal } from '@wix/services-definitions/core-services/signals';
+import { services } from '@wix/bookings';
+import type { QueryServicesRequest, PagingMetadata } from '../../api/query-services/index.js';
+export type { ServiceListFilters } from '../../api/query-services/index.js';
+/**
+ * Query options without paging metadata (user-controlled request params)
+ * Effect subscribes to changes in this signal to trigger re-fetches
+ */
+export type QueryOptions = Omit<QueryServicesRequest, 'pagingMetadata'>;
+/**
+ * Configuration for the ServiceList service
+ */
+export interface ServiceListServiceConfig {
+    services?: services.Service[];
+    options?: QueryServicesRequest;
+}
+/**
+ * Actions object for service list operations
+ */
+export interface ServiceListActions {
+    loadMore: (count: number) => Promise<void>;
+    setQueryOptions: (options: QueryOptions) => void;
+}
+/**
+ * API interface for the ServiceList service
+ */
+export interface ServiceListServiceAPI {
+    /** Reactive signal containing the list of services */
+    servicesSignal: Signal<services.Service[]>;
+    /** Reactive signal containing current query options (appId, filters, sort) - changes trigger re-fetch */
+    queryOptionsSignal: Signal<QueryOptions>;
+    /** Reactive signal containing pagination metadata (limit, offset, count, hasNext) - updated after fetches */
+    pagingMetadataSignal: Signal<PagingMetadata>;
+    /** Reactive signal indicating if services are currently being loaded */
+    isLoadingSignal: Signal<boolean>;
+    /** Reactive signal containing any error message, or null if no error */
+    errorSignal: Signal<string | null>;
+    /** Actions object containing query actions */
+    actions: ServiceListActions;
+    /** Reactive signal indicating if there are more services to load */
+    hasMoreServicesSignal: ReadOnlySignal<boolean>;
+}
+/**
+ * Service definition for the ServiceList service
+ */
+export declare const ServiceListServiceDefinition: string & {
+    __api: ServiceListServiceAPI;
+    __config: ServiceListServiceConfig;
+    isServiceDefinition?: boolean;
+} & ServiceListServiceAPI;
+/**
+ * Implementation of the ServiceList service that manages reactive services list data.
+ * This service provides signals for services data, query options, pagination metadata
+ * (including hasNext flag), loading state, and error handling.
+ * It automatically re-fetches services when query options change.
+ *
+ * @example
+ * ```tsx
+ * import { ServiceListService, ServiceListServiceDefinition } from '@wix/bookings/services';
+ * import { useService } from '@wix/services-manager-react';
+ *
+ * function ServicesComponent({ serviceListConfig }) {
+ *   return (
+ *     <ServiceProvider services={createServicesMap([
+ *       [ServiceListServiceDefinition, ServiceListService.withConfig(serviceListConfig)]
+ *     ])}>
+ *       <ServicesDisplay />
+ *     </ServiceProvider>
+ *   );
+ * }
+ *
+ * function ServicesDisplay() {
+ *   const serviceListService = useService(ServiceListServiceDefinition);
+ *   const services = serviceListService.servicesSignal.get();
+ *   const isLoading = serviceListService.isLoadingSignal.get();
+ *   const error = serviceListService.errorSignal.get();
+ *   const pagingMetadata = serviceListService.pagingMetadataSignal.get();
+ *   const hasMore = serviceListService.hasMoreServicesSignal.get();
+ *
+ *   if (isLoading) return <div>Loading services...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return (
+ *     <div>
+ *       {services.map(service => (
+ *         <div key={service._id}>
+ *           <h3>{service.name}</h3>
+ *           <p>{service.description}</p>
+ *         </div>
+ *       ))}
+ *       {hasMore && (
+ *         <button onClick={() => serviceListService.actions.loadMore(10)}>
+ *           Load More
+ *         </button>
+ *       )}
+ *       {pagingMetadata.hasNext && (
+ *         <span>More services available</span>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare const ServiceListService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: ServiceListServiceAPI;
+    __config: ServiceListServiceConfig;
+    isServiceDefinition?: boolean;
+} & ServiceListServiceAPI, ServiceListServiceConfig>;
+/**
+ * Result types for service list loading operations
+ */
+export type SuccessServiceListServiceConfigResult = {
+    type: 'success';
+    config: ServiceListServiceConfig;
+};
+export type ErrorServiceListServiceConfigResult = {
+    type: 'error';
+    error: Error;
+};
+/**
+ * Load service list configuration for Server-Side Rendering (SSR).
+ * This function is designed to be called during the build or server-side rendering phase
+ * to pre-fetch services data before the React components are hydrated on the client.
+ * The returned config includes paging metadata with hasNext flag indicating if more services are available.
+ *
+ * @param options - Query options following QueryServicesRequest type, or a URL string (to be implemented)
+ * @returns A promise that resolves to either a success result with the config or an error result
+ *
+ * @example
+ * ```ts
+ * // In an Astro page or API route
+ * import { loadServiceListServiceInitialData } from '@wix/bookings/services';
+ *
+ * // Load with query options
+ * const serviceListResult = await loadServiceListServiceInitialData({
+ *   appId: '13d21c63-b5ec-5912-8397-c3a5ddb27a97',
+ *   pagingMetadata: { limit: 20, offset: 0 },
+ * });
+ *
+ * if (serviceListResult.type === 'error') {
+ *   console.error('Failed to load services:', serviceListResult.error);
+ *   return Astro.redirect('/500');
+ * }
+ *
+ * const serviceListConfig = serviceListResult.config;
+ *
+ * // Check if more services are available
+ * if (serviceListConfig.options?.pagingMetadata?.hasNext) {
+ *   // More services can be loaded
+ * }
+ * ```
+ */
+export declare function loadServiceListServiceInitialData(options: QueryServicesRequest): Promise<SuccessServiceListServiceConfigResult | ErrorServiceListServiceConfigResult>;