// We'll build this step by step:
// 1. **Configuration**: Create a central Configuration instance with our storefront API credentials.
// 2. **API Client Instantiation**: Create a dedicated client for the Storefront Products API.
// 3. **Parameter Preparation**: Define the filter, page size, and other parameters for our query.
// 4. **API Call**: Use the client to call the `storefrontGetProducts` method.

// Essential imports for Storefront Catalog operations.
// We import the Configuration class and the specific API client we need.
import { Configuration } from "@kibocommerce/rest-sdk";
import { ProductSearchApi } from "@kibocommerce/rest-sdk/clients/CatalogStorefront/apis/ProductSearchApi.js";

// Configuration setup for storefront. Note the absence of a sharedSecret.
// Your Application Key (also known as App ID) is used instead.
const configuration = new Configuration({
  tenantId: process.env.KIBO_TENANT_ID,
  siteId: process.env.KIBO_SITE_ID,
  clientId: process.env.KIBO_CLIENT_ID,
  sharedSecret: process.env.KIBO_SHARED_SECRET,
  authHost: process.env.KIBO_AUTH_HOST || "https://home.mozu.com",
});

// This example fetches the first 12 products from a specific category (ID: 4).
async function getCategoryProducts(categoryId: number) {
  const productSearchClient = new ProductSearchApi(configuration);

  try {
    console.log(`Fetching first 12 products for category ID: ${categoryId}...`);

    // storefrontSearch lets you query and filter product results
    const result = await productSearchClient.storefrontSearch({
      filter: `categoryId eq ${categoryId}`,
      pageSize: 12,
      startIndex: 0,
    });

    console.log(`Fetched ${result.items?.length || 0} products.`);
    console.log(`Total products available: ${result.totalCount}`);

    // Display product names
    result.items?.forEach((p, i) => {
      console.log(`${i + 1}. ${p.content?.productName}`);
    });

    return result;
  } catch (error) {
    console.error("API Error:", JSON.stringify(error, null, 2));
    throw error;
  }
}

// Step 3: Execute
getCategoryProducts(2);

// Wrong - Never expose your clientId and sharedSecret in a front-end application.
const config = new Configuration({ clientId: '...', sharedSecret: '...' });

// Correct - Use your public appKey for all storefront API calls.
const config = new Configuration({ appKey: '...' });

// Wrong - This only gets the first page of results (the default pageSize).
// If there are more products, the shopper will never see them.
const result = await client.storefrontGetProducts({ filter: 'categoryId eq 4' });

// Correct - Always use pageSize and startIndex to control which products you are displaying.
const result = await client.storefrontGetProducts({
    filter: 'categoryId eq 4',
    pageSize: 24, // The number of items you want per page
    startIndex: 48 // The starting index (e.g., for page 3, startIndex would be 48)
});

import { Configuration } from "@kibocommerce/rest-sdk";
import { ProductsApi, ProductSearchResult } from "@kibocommerce/rest-sdk/clients/Commerce";

// Use the same storefront configuration from the previous example
const configuration = new Configuration({ /* ... your credentials ... */ });

async function performFacetedSearch(query: string, categoryCode?: string) {
  const productSearchClient = new ProductSearchApi(configuration);

  // Define which fields to use as facets
  const facetFields = "categoryCode"; // use correct field names defined in catalog

  // Build a filter dynamically
  let facetTemplate = "";
  if (categoryCode) {
    facetTemplate = `categoryCode:"${categoryCode}"`;
  }

  try {
    console.log(`Searching for "${query}" with filter "${facetTemplate || "none"}"...`);

    // The core search call
    const result = await productSearchClient.storefrontSearch({
      query,
      facet: facetFields,
      facetTemplate,
      pageSize: 12,
      startIndex: 0,
    });

    console.log(`Found ${result.totalCount} products.`);
    console.log("Available Facets:");
    console.log(JSON.stringify(result.facets, null, 2));

    // Show a few sample product names
    result.items?.slice(0, 5).forEach((item, i) => {
      console.log(`${i + 1}. ${item.content?.productName}`);
    });

    return result;
  } catch (error) {
    console.error("Search Error:", JSON.stringify(error, null, 2));
    throw error;
  }
}

// Step 3: Execute
performFacetedSearch("", "11111");

import { Configuration } from "@kibocommerce/rest-sdk";
import { CategoriesApi, CategoryCollection } from "@kibocommerce/rest-sdk/clients/CatalogAdministration";

async function getNavigationMenu() {
  const categoryClient = new CategoriesApi(configuration);
  try {
    console.log("Fetching category tree...");
    const categoryTree = await categoryClient.storefrontGetCategoryTree({
      includeAttributes: false, // optional
    });

    console.log(`Found ${categoryTree.items?.length || 0} top-level categories.`);
    console.log(JSON.stringify(categoryTree.items, null, 2));
  } catch (error) {
    console.error("Error fetching category tree:", error);
  }
}

getNavigationMenu();

import { Configuration } from "@kibocommerce/rest-sdk";
import { ProductsApi, ProductSearchResult } from "@kibocommerce/rest-sdk/clients/Commerce";

async function searchAndSort(query: string, sortBy: string = "price asc") {
  const searchClient = new ProductSearchApi(configuration);

  try {
    console.log(`Searching for "${query}" sorted by "${sortBy}"...`);

    const searchResult = await searchClient.storefrontSearch({
      query,
      sortBy,
      pageSize: 12,
    });

    console.log(`Found ${searchResult.totalCount} results.\n`);
    console.log(
      searchResult.items?.map((p) => ({
        code: p.productCode,
        name: p.content?.productName,
        price: p.price?.price,
      }))
    );

    return searchResult;
  } catch (error) {
    console.error("Search Error:", JSON.stringify(error, null, 2));
    throw error;
  }
}

searchAndSort("Apple"); // Default sort: price asc

import { Configuration } from "@kibocommerce/rest-sdk";
import { ProductSearchApi, SearchSuggestionResult } from "@kibocommerce/rest-sdk/clients/Commerce";

const productSearchApi = new ProductSearchApi(configuration);

export async function searchAndSort(query: string) {
  try {
    const response = await productSearchApi.storefrontSuggest({
      query, // ← dynamic input
      groups: "products,categories",
      pageSize: 10,
    });

    console.log("Search Suggestions:", response);
    return response;
  } catch (err) {
    console.error("Error fetching suggestions:", err);
  }
}

searchAndSort("Samsung");

// Actual error structure from Kibo API
interface KiboApiError {
  message: string;         // Error description
  correlationId: string;   // For support tracking
  // ... other properties may be present
}