Find and manage existing Shopping Lists

// Example GET request for a shopping list using the 'expand' parameter for variant data.apiRoot
  .shoppingLists()
  .get({
    /**
     * Query arguments to filter and control the shopping list retrieval.
     * @type {object}
     * @property {number} limit - Max number of results to return.
     * @property {string} sort - How to sort the results (e.g., 'id asc').
     * @property {boolean} withTotal - Whether to include the total count in the response.
     * @property {string} where - The predicate string to filter shopping lists.
     */
    queryArgs: {
      /** Limit the result set to 1 shopping list. */
      limit: 1,
      /** Sort results by ID ascending. */
      sort: 'id asc',
      /** Exclude the total count of matching lists from the response. */
      withTotal: false,
      where: `id = "eaf18adc-r61e-4f2c-9d04-b6b8ad51d998"`,
     expand: ['lineItems[*].variant']  // Expand variants within line items

     },
  })
  .execute()
  .then()
  .catch();

// Example GraphQL query fetching a shopping list and expanding variant images.query getShoppingListWithProductImages($shoppingListId: String!) {
 shoppingList(id: $shoppingListId) {
   id
   key
   name(locale: "en")
   lineItems {
     id
     name(locale: "en")
     productId
     quantity
     variant {
       id
       sku
       images {
         url
         label
       }
     }
     productSlug(locale: "en")
   }
   textLineItems {
     name(locale: "en")
     id
     quantity
     description(locale: "en")
   }
   slug(locale: "en")
 }
}

/**
* The GraphQL query string to fetch a shopping list with line item variant images.
* It expects a variable $shoppingListId of type String!.
* @type {string}
*/
const graphqlQuery = `
  query getShoppingListWithProductImages($shoppingListId: String!) {
shoppingList(id: $shoppingListId) {
  id
  key
  name(locale: "en")
  lineItems {
    id
    name(locale: "en")
    productId
    quantity
    variant {
      id
      sku
      images {
        url
        label
      }
    }
    productSlug(locale: "en")
  }
  textLineItems {
    name(locale: "en")
    id
    quantity
    description(locale: "en")
  }
  slug(locale: "en")
}
}


`;


/**
* Define the variables required by the GraphQL query.
* The keys here must match the variable names defined in the query string (without the $).
* @type {object}
*/
const variables = {
shoppingListId: '0a6eaa69-c255-4439-9394-1ea8254a61f0', // <-- ** IMPORTANT: Set the actual Shopping List ID here **
};


// Execute the GraphQL request using apiRoot
apiRoot
.graphql()
.post({
  /**
   * The body of the GraphQL POST request.
   * @type {object}
   * @property {string} query - The GraphQL query document.
   * @property {object} [variables] - An object containing values for variables defined in the query.
   * @property {string} [operationName] - Specifies which operation to run if the query string contains multiple operations.
   */
  body: {
    query: graphqlQuery,
    variables: variables,
    operationName: 'getShoppingListWithProductImages', // Optional, but good practice if query is named
  },
  // headers?: { [key: string]: string | string[] } // Optional: Add custom headers if needed
})
.execute()
// If using stronger types: .execute<ClientResponse<ShoppingListGraphQLResponse>>()
.then((response) => {
  // Successful HTTP request (status 2xx).
  // The actual GraphQL result is in response.body.
  // Note: GraphQL can return errors even with a 200 OK status. Check response.body.errors.

  console.log('GraphQL request executed.');

  if (response.body.errors) {
    // Log any errors returned by the GraphQL endpoint itself
    console.warn('GraphQL query returned errors:');
    console.warn(JSON.stringify(response.body.errors, null, 2));
  }


  if (response.body.data) {
    // Log the data payload if present
    console.log('GraphQL response data:');
    console.log(JSON.stringify(response.body.data, null, 2)); // Pretty print the data
    // Example access: const listName = response.body.data?.shoppingList?.name;
  } else {
    console.log('No data returned in GraphQL response.');
  }
})
.catch((error) => {
  // Handles HTTP-level errors (e.g., network issues, 4xx/5xx status codes)
  // or errors during SDK processing.
  console.error('Error executing GraphQL request:');
  // The 'error' object might contain details like status code, headers, and body
  console.error(JSON.stringify(error, null, 2));
});

// Example snippet of a GraphQL response showing expanded variant data.{
  "data": {
    "shoppingList": {
      "id": "587f9697-07b4-429c-88d8-93eba41807a1",
      "key": "my-shopping-list",
      "name": "My shopping list",
      "lineItems": [
        {
          "id": "316e06a6-6da2-4c72-9045-a197a1609f47",
          "name": "Clutch ”Carol” Liebeskind black",
          "productId": "c61b8923-487c-4900-9a3c-e94e9737df77",
          "quantity": 1,
          "variant": {
            "id": 1,
            "sku": "A0E2000000024AX",
            "images": [
              {
                "url": "https://s3-eu-west-1.amazonaws.com/commercetools-maximilian/products/080721_1_medium.jpg",
                "label": null
              }
            ]
          },
          "productSlug": "liebeskind-clutch-carol-black"
        }
      ],
      "textLineItems": [
        {
          "name": "My shopping list item",
          "id": "0f92302b-e483-4682-8746-9e0b4cb47b95",
          "quantity": 5,
          "description": "This is a good gift idea"
        }
      ],
      "slug": "my-shopping-list"
    }
  }
}

// Example showing the multi-step process: fetch list, extract IDs, fetch product projections.
// --- Configuration ---
const shoppingListIdToFetch = '0a6eaa69-c255-4439-9394-1ea8254a61f0'; // <-- Replace with the actual Shopping List ID

apiRoot
 .shoppingLists()
 .get({
   /**
    * Query arguments to fetch a specific shopping list by its ID.
    */
   queryArgs: {
     /** Limit to 1, as ID is unique. */
     limit: 1,
     /** Sorting is less relevant when fetching by unique ID. */
     // sort: 'id asc',
     /** Exclude total count. */
     withTotal: false,
     /** Filter by the specific Shopping List ID. */
     where: `id = "${shoppingListIdToFetch}"`,
   },
 })
 .execute()
 .then(
   /**
    * Handles the successful response for the shopping list fetch.
    * Then proceeds to fetch product projections for its line items.
    * @param {ClientResponse<ShoppingListPagedQueryResponse>} shoppingListResponse - The API response for the shopping list.
    * @returns {Promise<void>}
    */
   async (
     shoppingListResponse: ClientResponse<ShoppingListPagedQueryResponse>,
   ): Promise<void> => {
     const shoppingList = shoppingListResponse.body.results?.[0];

     if (!shoppingList) {
       console.warn(
         `Shopping list with ID ${shoppingListIdToFetch} not found.`,
       );
       return; // Stop processing if list not found
     }

     console.log(
       `Successfully fetched shopping list: ${shoppingList.id} (Name: ${
         shoppingList.name['en'] ?? 'N/A' // Adjust locale as needed
       })`,
     );

     // Check if there are any product line items
     const productLineItems = shoppingList.lineItems?.filter(
       (item): item is ShoppingListLineItem & { productId: string } =>
         !!item.productId, // Filter out text line items and ensure productId exists
     );

     if (!productLineItems || productLineItems.length === 0) {
       console.log('Shopping list contains no product line items.');
       return; // Stop if no product items
     }

     // --- Fetch Product Projections for Line Items ---

     // 1. Extract unique Product IDs from the line items
     const productIds = Array.from(
       new Set(productLineItems.map((item) => item.productId)),
     );

     console.log(
       `Found ${productIds.length} unique product ID(s) in line items:`,
       productIds,
     );
     console.log('Fetching corresponding product projections...');

     try {
       // 2. Construct the 'where' clause for fetching multiple products by ID
       const productIdsFormatted = productIds.map((id) => `"${id}"`).join(',');
       const productWhereClause = `id in (${productIdsFormatted})`;

       // 3. Make a single request to fetch all relevant product projections
       const productProjectionResponse: ClientResponse<ProductProjectionPagedQueryResponse> =
         await apiRoot
           .productProjections()
           .get({
             queryArgs: {
               /** Fetch only published product data. */
               staged: false,
               /** Filter by the list of product IDs found. */
               where: productWhereClause,
               /** Ensure limit is high enough if many products, or implement pagination */
               limit: productIds.length, // Fetch up to the number of unique IDs
             },
           })
           .execute();

       const fetchedProjections: ProductProjection[] =
         productProjectionResponse.body.results;

       console.log(
         `Successfully fetched ${fetchedProjections.length} product projection(s):`,
       );

       // 4. Log or process the fetched projections
       fetchedProjections.forEach((projection) => {
         console.log(
           `  - Product ID: ${projection.id}, Name: ${
             projection.name['en'] ?? 'N/A' // Adjust locale
           }`,
         );
         // You can now use the 'fetchedProjections' array which contains
         // the details for the products in the shopping list.
         // Example: Match back to line items if needed, display details, etc.
       });

       if (fetchedProjections.length < productIds.length) {
         console.warn(
           'Warning: Not all product IDs from the shopping list resulted in a fetched projection. Some products might be unpublished or deleted.',
         );
       }
     } catch (productError: unknown) {
       console.error(
         'Error fetching product projections for shopping list items:',
         productError,
       );
       // Handle errors during the product fetch phase
     }
   },
 )
 .catch(
   /**
    * Handles errors during the initial shopping list fetch.
    * @param {unknown} error - The error object.
    * @returns {void}
    */
   (error: unknown) => {
     console.error(
       `Error fetching shopping list with ID ${shoppingListIdToFetch}:`,
       error,
     );
     // Handle errors during the initial shopping list fetch
   },
 );