Get Product List

interface SearchProductsRequest {
  locale?: string;
  filters?: SearchFilters;
  pageable?: Pageable;
  includeFacets?: boolean;
}

interface SearchFilters {
  currency?: string;
  locale?: string;
  brand?: string[];
  attributes?: string[];
  productTags?: string[];
  suppliers?: string[];
  aggregation?: AggregationType;
  query?: string;
  categoryIds?: string[];
  priceRange?: PriceRange;
}

interface Pageable {
  page?: number;
  size?: number;
  sort?: string[];
}

interface PriceRange {
  min?: number;
  max?: number;
  currency?: string;
}

enum AggregationType {
  PRODUCT = "PRODUCT",
  VARIANT = "VARIANT",
  OFFER = "OFFER",
}

const searchParams: SearchProductsRequest = {
  locale: "en-GB",
  filters: {
    query: "business laptop",
    currency: "EUR",
    brand: ["Dell", "HP"],
    attributes: ["RAM:16GB", "Storage:SSD"],
    productTags: ["business", "professional"],
    suppliers: ["supplier-techpro"],
    aggregation: AggregationType.PRODUCT,
    priceRange: {
      min: 500,
      max: 2000,
      currency: "EUR",
    },
  },
  pageable: {
    page: 0,
    size: 20,
    sort: ["relevance|DESC", "price|ASC"],
  },
  includeFacets: true,
};

const searchResults = await getProductsList(searchParams);

interface SearchProductsResponse {
  success: boolean;
  products: ProductsSearchList;
  facets?: Facets;
  includeFacets: boolean;
}

interface ProductsSearchList {
  content: ProductSearchContent[];
  pageable: Pageable;
  totalElements: number;
  totalPages: number;
  size: number;
  number: number;
  first: boolean;
  last: boolean;
  empty?: boolean;
}

interface Facets {
  attributes: AttributeFacet[];
  suppliers?: SupplierFacet[];
  brands?: BrandFacet[];
  productTags?: ProductTagFacet[];
  customFields?: CustomFieldFacet[];
  priceRange?: PriceRangeFacet;
}

interface AttributeFacet {
  id: string;
  name: string;
  values: AttributeValueFacet[];
}

interface AttributeValueFacet {
  value: string;
  count: number;
  selected: boolean;
}

{
  "success": true,
  "products": {
    "content": [
      {
        "offerPrice": {
          "unitPrice": 1299.99,
          "currency": "EUR",
          "taxIncluded": false
        },
        "offer": {
          "id": "offer-001",
          "externalId": "EXT-OFFER-001",
          "quantityPerItem": 1,
          "stock": 85,
          "currency": "EUR",
          "minOrderQuantity": 1,
          "maxOrderQuantity": 50,
          "leadTimeToShip": 3
        },
        "variant": {
          "id": "variant-001",
          "externalId": "DELL-LAT-7420-16GB",
          "sku": "DELL-LAT-7420-16GB-BLK",
          "name": "Dell Latitude 7420 - 16GB RAM - Black",
          "description": "Premium business laptop with Intel i7 processor",
          "pictureUrls": [
            {
              "url": "https://cdn.example.com/dell-latitude-7420-main.jpg",
              "width": 1200,
              "height": 900
            }
          ],
          "ean": "1234567890125",
          "mpn": "LAT7420-16-BLK"
        },
        "product": {
          "id": "product-001",
          "externalId": "DELL-LATITUDE-7420",
          "sku": "DELL-LAT-7420",
          "name": "Dell Latitude 7420",
          "description": "Premium business laptop series with enhanced security features",
          "brand": "Dell",
          "mainPictureUrl": "https://cdn.example.com/dell-latitude-7420-hero.jpg",
          "tags": [
            {
              "name": "Business",
              "category": "USE_CASE"
            },
            {
              "name": "Professional",
              "category": "TIER"
            }
          ],
          "unit": "piece"
        },
        "attributes": [
          {
            "name": "RAM Size",
            "externalId": "RAM_SIZE",
            "value": "16GB",
            "values": ["16GB"]
          },
          {
            "name": "Storage Type",
            "externalId": "STORAGE_TYPE",
            "value": "SSD",
            "values": ["SSD"]
          },
          {
            "name": "Color",
            "externalId": "COLOR",
            "value": "Black",
            "values": ["Black"]
          }
        ],
        "supplier": {
          "id": "supplier-001",
          "name": "TechPro Distribution",
          "externalId": "TECH-PRO-001"
        }
      }
    ],
    "pageable": {
      "page": 0,
      "size": 20,
      "sort": ["relevance|DESC", "price|ASC"]
    },
    "totalElements": 127,
    "totalPages": 7,
    "size": 20,
    "number": 0,
    "first": true,
    "last": false,
    "empty": false
  },
  "facets": {
    "attributes": [
      {
        "id": "RAM_SIZE",
        "name": "RAM Size",
        "values": [
          {
            "value": "8GB",
            "count": 45,
            "selected": false
          },
          {
            "value": "16GB",
            "count": 67,
            "selected": true
          },
          {
            "value": "32GB",
            "count": 15,
            "selected": false
          }
        ]
      },
      {
        "id": "STORAGE_TYPE",
        "name": "Storage Type",
        "values": [
          {
            "value": "SSD",
            "count": 98,
            "selected": true
          },
          {
            "value": "HDD",
            "count": 29,
            "selected": false
          }
        ]
      }
    ],
    "brands": [
      {
        "name": "Dell",
        "count": 67,
        "selected": true
      },
      {
        "name": "HP",
        "count": 45,
        "selected": true
      },
      {
        "name": "Lenovo",
        "count": 15,
        "selected": false
      }
    ],
    "suppliers": [
      {
        "name": "TechPro Distribution",
        "count": 89,
        "selected": true
      },
      {
        "name": "Business Tech Solutions",
        "count": 38,
        "selected": false
      }
    ],
    "productTags": [
      {
        "id": "business",
        "name": "Business",
        "count": 127,
        "selected": true
      },
      {
        "id": "professional",
        "name": "Professional",
        "count": 94,
        "selected": true
      }
    ],
    "priceRange": {
      "min": 599.99,
      "max": 2899.99,
      "currency": "EUR",
      "distribution": [
        {
          "range": "600-1000",
          "count": 34
        },
        {
          "range": "1000-1500",
          "count": 67
        },
        {
          "range": "1500-2000",
          "count": 23
        },
        {
          "range": "2000+",
          "count": 3
        }
      ]
    }
  },
  "includeFacets": true
}

// Global error handling in composable
const getProductsList = async ({
  locale = defaultLocale,
  filters = defaultFilters,
  pageable = defaultPageable,
  includeFacets = true,
}: SearchProductsRequest) => {
  try {
    // Input validation
    if (filters?.query && filters.query.length > 100) {
      console.warn("Search query too long, truncating");
      filters.query = filters.query.substring(0, 100);
    }

    loading.value = true;

    const { data, status, error } = await useFetch("/api/search/products", {
      params: {
        locale,
        filters: JSON.stringify(filters),
        pageable: JSON.stringify(pageable),
        includeFacets: includeFacets,
      },
      key: `products-${locale}-${JSON.stringify(filters)}-${JSON.stringify(
        pageable
      )}-${includeFacets}`,
    });

    loading.value = status.value === "pending";

    if (error.value) {
      console.error("Error fetching products:", {
        locale,
        filters,
        error: error.value,
      });
      return {
        success: false,
        products: { content: [], totalElements: 0 },
        facets: undefined,
        includeFacets: false,
      } as SearchProductsResponse;
    }

    return (
      data.value ||
      ({
        success: false,
        products: { content: [], totalElements: 0 },
        facets: undefined,
        includeFacets: false,
      } as SearchProductsResponse)
    );
  } catch (error) {
    console.error("Unexpected error in getProductsList:", error);
    return {
      success: false,
      products: { content: [], totalElements: 0 },
      facets: undefined,
      includeFacets: false,
    } as SearchProductsResponse;
  } finally {
    loading.value = false;
  }
};

// Component-level error handling
const performProductSearch = async (searchCriteria: SearchProductsRequest) => {
  try {
    isSearching.value = true;

    const response = await getProductsList(searchCriteria);

    if (!response.success) {
      throw new Error("Search request failed");
    }

    // Process successful response
    searchResults.value = response.products.content;
    totalResults.value = response.products.totalElements;
    currentFacets.value = response.facets;
  } catch (error) {
    console.error("Product search error:", error);

    // User notification
    useToast().add({
      title: "Search Error",
      description: "Unable to perform product search. Please try again.",
      color: "red",
    });

    // Fallback to empty results
    searchResults.value = [];
    totalResults.value = 0;
    currentFacets.value = undefined;
  } finally {
    isSearching.value = false;
  }
};

/**
 * Performs comprehensive product search with filtering and faceted navigation
 *
 * @param params - Search request parameters
 * @param params.locale - Locale for internationalized search
 * @param params.filters - Search filters and criteria
 * @param params.pageable - Pagination configuration
 * @param params.includeFacets - Whether to include faceting data
 * @returns Promise resolving to search results with products and facets
 *
 * @example
 * ```typescript
 * const { getProductsList } = useSearchProduct();
 *
 * const searchResults = await getProductsList({
 *   locale: "en-GB",
 *   filters: {
 *     query: "business laptop",
 *     brand: ["Dell", "HP"],
 *     attributes: ["RAM:16GB"]
 *   },
 *   pageable: { page: 0, size: 20 },
 *   includeFacets: true
 * });
 *
 * if (searchResults.success) {
 *   console.log('Products found:', searchResults.products.totalElements);
 *   console.log('Available facets:', Object.keys(searchResults.facets || {}));
 * }
 * ```
 *
 * @throws {Error} When network request fails or invalid parameters provided
 * @since 1.0.0
 */
const getProductsList = async ({
  locale = defaultLocale,
  filters = defaultFilters,
  pageable = defaultPageable,
  includeFacets = true,
}: SearchProductsRequest): Promise<SearchProductsResponse> => {
  try {
    // Input validation and sanitization
    if (filters?.query && filters.query.length > 200) {
      console.warn("Search query exceeds maximum length, truncating");
      filters.query = filters.query.substring(0, 200);
    }

    // Set loading state
    loading.value = true;

    // Runtime configuration for defaults
    const runtimeConfig = useRuntimeConfig();
    const effectiveLocale = locale || runtimeConfig.public.locale;
    const effectiveCurrency =
      filters?.currency || runtimeConfig.public.currency;

    const { data, status, error } = await useFetch("/api/search/products", {
      params: {
        locale: effectiveLocale,
        filters: JSON.stringify({
          ...defaultFilters,
          ...filters,
          currency: effectiveCurrency,
        }),
        pageable: JSON.stringify({
          ...defaultPageable,
          ...pageable,
        }),
        includeFacets: includeFacets,
      },
      // Generate unique cache key
      key: `products-${effectiveLocale}-${JSON.stringify(
        filters
      )}-${JSON.stringify(pageable)}-${includeFacets}`,
    });

    // Update loading state
    loading.value = status.value === "pending";

    if (error.value) {
      console.error("Error fetching products:", {
        locale: effectiveLocale,
        filters,
        pageable,
        error: error.value,
      });

      return {
        success: false,
        products: {
          content: [],
          totalElements: 0,
          totalPages: 0,
          size: pageable?.size || 20,
          number: pageable?.page || 0,
          first: true,
          last: true,
          empty: true,
        },
        facets: undefined,
        includeFacets: false,
      } as SearchProductsResponse;
    }

    return (
      data.value ||
      ({
        success: false,
        products: { content: [], totalElements: 0 },
        facets: undefined,
        includeFacets: false,
      } as SearchProductsResponse)
    );
  } catch (error) {
    console.error("Unexpected error in getProductsList:", error);

    return {
      success: false,
      products: { content: [], totalElements: 0 },
      facets: undefined,
      includeFacets: false,
    } as SearchProductsResponse;
  } finally {
    loading.value = false;
  }
};