@wix/headless-bookings 0.0.0

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

@@ -0,0 +1,136 @@
+import { type Signal } from '@wix/services-definitions/core-services/signals';
+import { services } from '@wix/bookings';
+/**
+ * API interface for the Service service, providing reactive service data management.
+ * This service handles loading and managing a single service's data, loading state, and errors.
+ *
+ * @interface ServiceServiceAPI
+ */
+export interface ServiceServiceAPI {
+    /** Reactive signal containing the current service data */
+    service: Signal<services.Service>;
+    /** Reactive signal indicating if a service is currently being loaded */
+    isLoading: Signal<boolean>;
+    /** Reactive signal containing any error message, or null if no error */
+    error: Signal<string | null>;
+    /** Function to load a service by its id */
+    loadService: (id: string) => Promise<void>;
+}
+/**
+ * Service definition for the Service service.
+ * This defines the contract that the ServiceService must implement.
+ *
+ * @constant
+ */
+export declare const ServiceServiceDefinition: string & {
+    __api: ServiceServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & ServiceServiceAPI;
+/**
+ * Configuration interface required to initialize the ServiceService.
+ * Contains the initial service data that will be loaded into the service.
+ *
+ * @interface ServiceServiceConfig
+ */
+export interface ServiceServiceConfig {
+    /** The initial service data to configure the service with */
+    service?: services.Service;
+    /** The service ID to load if no initial service is provided */
+    serviceId?: string;
+}
+/**
+ * Implementation of the Service service that manages reactive service data.
+ * This service provides signals for service data, loading state, and error handling,
+ * along with methods to dynamically load services.
+ *
+ * @example
+ * ```tsx
+ * import { ServiceService, ServiceServiceDefinition } from '@wix/services/services';
+ * import { useService } from '@wix/services-manager-react';
+ *
+ * function ServiceComponent({ serviceConfig }) {
+ *   return (
+ *     <ServiceProvider services={createServicesMap([
+ *       [ServiceServiceDefinition, ServiceService.withConfig(serviceConfig)]
+ *     ])}>
+ *       <ServiceDisplay />
+ *     </ServiceProvider>
+ *   );
+ * }
+ *
+ * function ServiceDisplay() {
+ *   const serviceService = useService(ServiceServiceDefinition);
+ *   const service = serviceService.service.get();
+ *   const isLoading = serviceService.isLoading.get();
+ *   const error = serviceService.error.get();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return <h1>{service.name}</h1>;
+ * }
+ * ```
+ */
+export declare const ServiceService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: ServiceServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & ServiceServiceAPI, ServiceServiceConfig>;
+/**
+ * Success result interface for service service configuration loading.
+ * Returned when a service is successfully found and loaded.
+ *
+ * @interface SuccessServiceServiceConfigResult
+ */
+export interface SuccessServiceServiceConfigResult {
+    /** Type "success" means that the service was found and the config is valid */
+    type: 'success';
+    /** The service config containing the loaded service data */
+    config: ServiceServiceConfig;
+}
+/**
+ * Not found result interface for service service configuration loading.
+ * Returned when a service with the given id cannot be found.
+ *
+ * @interface NotFoundServiceServiceConfigResult
+ */
+export interface NotFoundServiceServiceConfigResult {
+    /** Type "notFound" means that the service was not found */
+    type: 'notFound';
+}
+/**
+ * Loads service service configuration from the Wix Services API for SSR initialization.
+ * This function is designed to be used during Server-Side Rendering (SSR) to preload
+ * a specific service by id that will be used to configure the ServiceService.
+ *
+ * @param serviceId The service id to load
+ * @returns Promise that resolves to ServiceServiceConfigResult (success with config or notFound)
+ *
+ * @example
+ * ```astro
+ * ---
+ * // Astro page example - pages/service/[id].astro
+ * import { loadServiceServiceConfig } from '@wix/services/services';
+ * import { Service } from '@wix/services/components';
+ *
+ * // Get service id from URL params
+ * const { id } = Astro.params;
+ *
+ * // Load service data during SSR
+ * const serviceResult = await loadServiceServiceConfig(id);
+ *
+ * // Handle not found case
+ * if (serviceResult.type === 'notFound') {
+ *   return Astro.redirect('/404');
+ * }
+ * ---
+ *
+ * <Service.Root serviceConfig={serviceResult.config}>
+ *   <Service.Name>
+ *     {({ name }) => <h1>{name}</h1>}
+ *   </Service.Name>
+ * </Service.Root>
+ * ```
+ */
+export declare function loadServiceServiceConfig(serviceId: string): Promise<SuccessServiceServiceConfigResult | NotFoundServiceServiceConfigResult>;

package/dist/services/service-service.js

@@ -0,0 +1,140 @@
+import { defineService, implementService } from '@wix/services-definitions';
+import { SignalsServiceDefinition, } from '@wix/services-definitions/core-services/signals';
+import { services } from '@wix/bookings';
+/**
+ * Service definition for the Service service.
+ * This defines the contract that the ServiceService must implement.
+ *
+ * @constant
+ */
+export const ServiceServiceDefinition = defineService('service');
+/**
+ * Implementation of the Service service that manages reactive service data.
+ * This service provides signals for service data, loading state, and error handling,
+ * along with methods to dynamically load services.
+ *
+ * @example
+ * ```tsx
+ * import { ServiceService, ServiceServiceDefinition } from '@wix/services/services';
+ * import { useService } from '@wix/services-manager-react';
+ *
+ * function ServiceComponent({ serviceConfig }) {
+ *   return (
+ *     <ServiceProvider services={createServicesMap([
+ *       [ServiceServiceDefinition, ServiceService.withConfig(serviceConfig)]
+ *     ])}>
+ *       <ServiceDisplay />
+ *     </ServiceProvider>
+ *   );
+ * }
+ *
+ * function ServiceDisplay() {
+ *   const serviceService = useService(ServiceServiceDefinition);
+ *   const service = serviceService.service.get();
+ *   const isLoading = serviceService.isLoading.get();
+ *   const error = serviceService.error.get();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return <h1>{service.name}</h1>;
+ * }
+ * ```
+ */
+export const ServiceService = implementService.withConfig()(ServiceServiceDefinition, ({ getService, config }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    const service = signalsService.signal(config.service);
+    const isLoading = signalsService.signal(!!config.serviceId);
+    const error = signalsService.signal(null);
+    const loadService = async (id) => {
+        isLoading.set(true);
+        const serviceResponse = await loadServiceById(id);
+        if (!serviceResponse.service) {
+            error.set('Service not found');
+        }
+        else {
+            service.set(serviceResponse.service);
+            error.set(null);
+        }
+        isLoading.set(false);
+    };
+    if (config.serviceId) {
+        loadService(config.serviceId);
+    }
+    return {
+        service,
+        isLoading,
+        error,
+        loadService,
+    };
+});
+/**
+ * Internal helper function to load a service by its ID from the Wix Services API.
+ * Fetches comprehensive service data including description, categories, media, etc.
+ *
+ * @private
+ * @param {string} id - The service ID to load
+ * @returns {Promise} Service response from the API
+ */
+const loadServiceById = async (id) => {
+    try {
+        const service = await services.getService(id);
+        return { service };
+    }
+    catch (error) {
+        console.error(`Failed to load service for id "${id}":`, error);
+        return { service: null };
+    }
+};
+/**
+ * Loads service service configuration from the Wix Services API for SSR initialization.
+ * This function is designed to be used during Server-Side Rendering (SSR) to preload
+ * a specific service by id that will be used to configure the ServiceService.
+ *
+ * @param serviceId The service id to load
+ * @returns Promise that resolves to ServiceServiceConfigResult (success with config or notFound)
+ *
+ * @example
+ * ```astro
+ * ---
+ * // Astro page example - pages/service/[id].astro
+ * import { loadServiceServiceConfig } from '@wix/services/services';
+ * import { Service } from '@wix/services/components';
+ *
+ * // Get service id from URL params
+ * const { id } = Astro.params;
+ *
+ * // Load service data during SSR
+ * const serviceResult = await loadServiceServiceConfig(id);
+ *
+ * // Handle not found case
+ * if (serviceResult.type === 'notFound') {
+ *   return Astro.redirect('/404');
+ * }
+ * ---
+ *
+ * <Service.Root serviceConfig={serviceResult.config}>
+ *   <Service.Name>
+ *     {({ name }) => <h1>{name}</h1>}
+ *   </Service.Name>
+ * </Service.Root>
+ * ```
+ */
+export async function loadServiceServiceConfig(serviceId) {
+    try {
+        const serviceResponse = await loadServiceById(serviceId);
+        if (!serviceResponse.service) {
+            return { type: 'notFound' };
+        }
+        return {
+            type: 'success',
+            config: {
+                service: serviceResponse.service,
+            },
+        };
+    }
+    catch (error) {
+        console.error(`Failed to load service for id "${serviceId}":`, error);
+        return { type: 'notFound' };
+    }
+}

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

@@ -0,0 +1,184 @@
+import { type Signal, type ReadOnlySignal } from '@wix/services-definitions/core-services/signals';
+import { services } from '@wix/bookings';
+export declare const DEFAULT_QUERY_LIMIT = 100;
+/**
+ * Configuration interface for the Services List service.
+ * Contains the initial services data, search options, and metadata.
+ *
+ * @interface ServicesListServiceConfig
+ */
+export interface ServicesListServiceConfig {
+    /** Array of service objects to initialize the service with */
+    services: services.Service[];
+    /** Search options used to fetch the services */
+    searchOptions?: {
+        cursorPaging?: {
+            limit: number;
+        };
+        filter?: Record<string, any>;
+        sort?: Array<{
+            fieldName: string;
+            order: 'ASC' | 'DESC';
+        }>;
+    };
+    /** Pagination metadata from the search response */
+    pagingMetadata?: {
+        count: number;
+        cursors?: {
+            next?: () => Promise<services.ServicesQueryResult>;
+            prev?: () => Promise<services.ServicesQueryResult>;
+        };
+        hasNext?: boolean;
+    };
+}
+/**
+ * Service definition for the Services List service.
+ * This defines the reactive API contract for managing a list of services with search, pagination, and filtering capabilities.
+ *
+ * @constant
+ */
+export declare const ServicesListServiceDefinition: string & {
+    __api: {
+        /** Reactive signal containing the list of services */
+        services: Signal<services.Service[]>;
+        /** Reactive signal containing pagination metadata */
+        pagingMetadata: Signal<ServicesListServiceConfig["pagingMetadata"]>;
+        /** Reactive signal indicating if services are currently being loaded */
+        isLoading: Signal<boolean>;
+        /** Reactive signal containing any error message, or null if no error*/
+        error: Signal<string | null>;
+        /** Reactive signal containing the current sort configuration */
+        sort: Signal<{
+            fieldName: string;
+            order: "ASC" | "DESC";
+        }[]>;
+        /** Reactive signal containing the current filter configuration */
+        filters: Signal<Record<string, any>>;
+        /** Function to update sort configuration */
+        setSort: (sort: {
+            fieldName: string;
+            order: "ASC" | "DESC";
+        }[]) => void;
+        /** Function to update filter configuration */
+        setFilter: (filter: Record<string, any>) => void;
+        /** Function to reset filter configuration */
+        resetFilter: () => void;
+        /** Reactive signal indicating if any filters are currently applied */
+        isFiltered: () => ReadOnlySignal<boolean>;
+        /** Function to load more services */
+        loadMore: (count: number) => void;
+        /** Reactive signal indicating if there are more services to load */
+        hasMoreServices: ReadOnlySignal<boolean>;
+    };
+    __config: ServicesListServiceConfig;
+    isServiceDefinition?: boolean;
+} & {
+    /** Reactive signal containing the list of services */
+    services: Signal<services.Service[]>;
+    /** Reactive signal containing pagination metadata */
+    pagingMetadata: Signal<ServicesListServiceConfig["pagingMetadata"]>;
+    /** Reactive signal indicating if services are currently being loaded */
+    isLoading: Signal<boolean>;
+    /** Reactive signal containing any error message, or null if no error*/
+    error: Signal<string | null>;
+    /** Reactive signal containing the current sort configuration */
+    sort: Signal<{
+        fieldName: string;
+        order: "ASC" | "DESC";
+    }[]>;
+    /** Reactive signal containing the current filter configuration */
+    filters: Signal<Record<string, any>>;
+    /** Function to update sort configuration */
+    setSort: (sort: {
+        fieldName: string;
+        order: "ASC" | "DESC";
+    }[]) => void;
+    /** Function to update filter configuration */
+    setFilter: (filter: Record<string, any>) => void;
+    /** Function to reset filter configuration */
+    resetFilter: () => void;
+    /** Reactive signal indicating if any filters are currently applied */
+    isFiltered: () => ReadOnlySignal<boolean>;
+    /** Function to load more services */
+    loadMore: (count: number) => void;
+    /** Reactive signal indicating if there are more services to load */
+    hasMoreServices: ReadOnlySignal<boolean>;
+};
+/**
+ * Implementation of the Services List service that manages reactive services data.
+ * This service provides signals for services data, search options, pagination,
+ * loading state, and error handling.
+ */
+export declare const ServicesListService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: {
+        /** Reactive signal containing the list of services */
+        services: Signal<services.Service[]>;
+        /** Reactive signal containing pagination metadata */
+        pagingMetadata: Signal<ServicesListServiceConfig["pagingMetadata"]>;
+        /** Reactive signal indicating if services are currently being loaded */
+        isLoading: Signal<boolean>;
+        /** Reactive signal containing any error message, or null if no error*/
+        error: Signal<string | null>;
+        /** Reactive signal containing the current sort configuration */
+        sort: Signal<{
+            fieldName: string;
+            order: "ASC" | "DESC";
+        }[]>;
+        /** Reactive signal containing the current filter configuration */
+        filters: Signal<Record<string, any>>;
+        /** Function to update sort configuration */
+        setSort: (sort: {
+            fieldName: string;
+            order: "ASC" | "DESC";
+        }[]) => void;
+        /** Function to update filter configuration */
+        setFilter: (filter: Record<string, any>) => void;
+        /** Function to reset filter configuration */
+        resetFilter: () => void;
+        /** Reactive signal indicating if any filters are currently applied */
+        isFiltered: () => ReadOnlySignal<boolean>;
+        /** Function to load more services */
+        loadMore: (count: number) => void;
+        /** Reactive signal indicating if there are more services to load */
+        hasMoreServices: ReadOnlySignal<boolean>;
+    };
+    __config: ServicesListServiceConfig;
+    isServiceDefinition?: boolean;
+} & {
+    /** Reactive signal containing the list of services */
+    services: Signal<services.Service[]>;
+    /** Reactive signal containing pagination metadata */
+    pagingMetadata: Signal<ServicesListServiceConfig["pagingMetadata"]>;
+    /** Reactive signal indicating if services are currently being loaded */
+    isLoading: Signal<boolean>;
+    /** Reactive signal containing any error message, or null if no error*/
+    error: Signal<string | null>;
+    /** Reactive signal containing the current sort configuration */
+    sort: Signal<{
+        fieldName: string;
+        order: "ASC" | "DESC";
+    }[]>;
+    /** Reactive signal containing the current filter configuration */
+    filters: Signal<Record<string, any>>;
+    /** Function to update sort configuration */
+    setSort: (sort: {
+        fieldName: string;
+        order: "ASC" | "DESC";
+    }[]) => void;
+    /** Function to update filter configuration */
+    setFilter: (filter: Record<string, any>) => void;
+    /** Function to reset filter configuration */
+    resetFilter: () => void;
+    /** Reactive signal indicating if any filters are currently applied */
+    isFiltered: () => ReadOnlySignal<boolean>;
+    /** Function to load more services */
+    loadMore: (count: number) => void;
+    /** Reactive signal indicating if there are more services to load */
+    hasMoreServices: ReadOnlySignal<boolean>;
+}, ServicesListServiceConfig>;
+/**
+ * Loads services list service configuration from the Wix Bookings API for SSR initialization.
+ * This function is designed to be used during Server-Side Rendering (SSR) to preload
+ * a list of services based on search criteria.
+ */
+export declare function loadServicesListServiceConfig(searchOptions?: ServicesListServiceConfig['searchOptions']): Promise<ServicesListServiceConfig>;

package/dist/services/services-list-service.js

@@ -0,0 +1,168 @@
+import { defineService, implementService } from '@wix/services-definitions';
+import { SignalsServiceDefinition, } from '@wix/services-definitions/core-services/signals';
+import { services } from '@wix/bookings';
+export const DEFAULT_QUERY_LIMIT = 100;
+/**
+ * Fetches services using the Wix Bookings API.
+ * This function handles pagination and returns both services and metadata.
+ *
+ * @param searchOptions - The search options for querying services
+ * @returns Promise that resolves to the search result
+ */
+const fetchServices = async (searchOptions = {}) => {
+    try {
+        let query = services.queryServices();
+        // Apply pagination
+        if (searchOptions.cursorPaging?.limit) {
+            query = query.limit(searchOptions.cursorPaging.limit);
+        }
+        // Apply sorting
+        if (searchOptions.sort?.length) {
+            const { order, fieldName } = searchOptions.sort[0];
+            if (order === 'ASC') {
+                query = query.ascending(fieldName);
+            }
+            else {
+                query = query.descending(fieldName);
+            }
+        }
+        const result = await query.find();
+        return result;
+    }
+    catch (error) {
+        console.error('Error fetching services:', error);
+        throw error;
+    }
+};
+/**
+ * Service definition for the Services List service.
+ * This defines the reactive API contract for managing a list of services with search, pagination, and filtering capabilities.
+ *
+ * @constant
+ */
+export const ServicesListServiceDefinition = defineService('services-list');
+/**
+ * Implementation of the Services List service that manages reactive services data.
+ * This service provides signals for services data, search options, pagination,
+ * loading state, and error handling.
+ */
+export const ServicesListService = implementService.withConfig()(ServicesListServiceDefinition, ({ getService, config }) => {
+    let firstRun = true;
+    const signalsService = getService(SignalsServiceDefinition);
+    const servicesSignal = signalsService.signal(config.services);
+    const pagingMetadataSignal = signalsService.signal(config.pagingMetadata || { count: 0 });
+    const isLoadingSignal = signalsService.signal(false);
+    const errorSignal = signalsService.signal(null);
+    const sortSignal = signalsService.signal(config.searchOptions?.sort || []);
+    const filtersSignal = signalsService.signal(config.searchOptions?.filter || {});
+    if (typeof window !== 'undefined') {
+        signalsService.effect(async () => {
+            // Read signals to establish dependencies
+            const sort = sortSignal.get();
+            const filters = filtersSignal.get();
+            if (firstRun) {
+                firstRun = false;
+                return;
+            }
+            try {
+                isLoadingSignal.set(true);
+                const result = await fetchServices({
+                    cursorPaging: { limit: DEFAULT_QUERY_LIMIT },
+                    sort,
+                    filter: filters,
+                });
+                servicesSignal.set(result.items);
+                pagingMetadataSignal.set({
+                    count: result.totalCount || 0,
+                    cursors: {
+                        next: result.next,
+                        prev: result.prev,
+                    },
+                    hasNext: result.hasNext(),
+                });
+            }
+            catch (error) {
+                errorSignal.set(error instanceof Error ? error.message : 'Unknown error');
+            }
+            finally {
+                isLoadingSignal.set(false);
+            }
+        });
+    }
+    firstRun = false;
+    const loadMoreServices = async () => {
+        try {
+            isLoadingSignal.set(true);
+            const result = await pagingMetadataSignal?.peek()?.cursors?.next?.();
+            servicesSignal.set([
+                ...servicesSignal.peek(),
+                ...(result?.items ?? []),
+            ]);
+            pagingMetadataSignal.set({
+                count: result?.totalCount || 0,
+                cursors: {
+                    next: result?.next,
+                    prev: result?.prev,
+                },
+                hasNext: result?.hasNext(),
+            });
+        }
+        catch (error) {
+            errorSignal.set(error instanceof Error ? error.message : 'Unknown error');
+        }
+        finally {
+            isLoadingSignal.set(false);
+        }
+    };
+    return {
+        services: servicesSignal,
+        pagingMetadata: pagingMetadataSignal,
+        isLoading: isLoadingSignal,
+        error: errorSignal,
+        sort: sortSignal,
+        filters: filtersSignal,
+        setSort: (sort) => {
+            sortSignal.set(sort);
+        },
+        setFilter: (filter) => {
+            filtersSignal.set(filter);
+        },
+        resetFilter: () => {
+            filtersSignal.set({});
+        },
+        isFiltered: () => {
+            return signalsService.computed(() => {
+                const filters = filtersSignal.peek();
+                return Object.keys(filters).length > 0;
+            });
+        },
+        loadMore: loadMoreServices,
+        hasMoreServices: signalsService.computed(() => pagingMetadataSignal.get()?.hasNext ?? false),
+    };
+});
+/**
+ * Loads services list service configuration from the Wix Bookings API for SSR initialization.
+ * This function is designed to be used during Server-Side Rendering (SSR) to preload
+ * a list of services based on search criteria.
+ */
+export async function loadServicesListServiceConfig(searchOptions) {
+    try {
+        const result = await fetchServices(searchOptions);
+        return {
+            services: result.items ?? [],
+            searchOptions,
+            pagingMetadata: {
+                count: result.totalCount ?? 0,
+                cursors: {
+                    next: result.next,
+                    prev: result.prev,
+                },
+                hasNext: result.hasNext(),
+            },
+        };
+    }
+    catch (error) {
+        console.error('Error loading services configuration:', error);
+        throw error;
+    }
+}