@reactionary/source 0.6.1 → 0.6.3

package/{providers/commercetools/src/providers/product-list.provider.ts → packages/commercetools/src/capabilities/product-list.capability.ts}

@@ -1,6 +1,12 @@
 import type { MyShoppingListAddLineItemAction, MyShoppingListDraft, MyShoppingListUpdate, MyShoppingListUpdateAction, ShoppingList, ShoppingListLineItem } from '@commercetools/platform-sdk';
 import type {
   Cache,
+  ProductListFactory,
+  ProductListFactoryItemOutput,
+  ProductListFactoryItemPaginatedOutput,
+  ProductListFactoryListOutput,
+  ProductListFactoryListPaginatedOutput,
+  ProductListFactoryWithOutput,
   NotFoundError,
   ProductList,
   ProductListIdentifier,
@@ -8,12 +14,10 @@ import type {
   ProductListItemMutationCreate,
   ProductListItemMutationDelete,
   ProductListItemMutationUpdate,
-  ProductListItemPaginatedResult,
   ProductListItemsQuery,
   ProductListMutationCreate,
   ProductListMutationDelete,
   ProductListMutationUpdate,
-  ProductListPaginatedResult,
   ProductListQuery,
   ProductListQueryById,
   ProductListType,
@@ -33,7 +37,7 @@ import {
   ProductListMutationDeleteSchema,
   ProductListMutationUpdateSchema,
   ProductListPaginatedResultsSchema,
-  ProductListProvider,
+  ProductListCapability,
   ProductListQueryByIdSchema,
   ProductListQuerySchema,
   ProductListSchema,
@@ -42,20 +46,31 @@ import {
 } from '@reactionary/core';
 import type { CommercetoolsAPI } from '../core/client.js';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-
-export class CommercetoolsProductListProvider extends ProductListProvider {
+import type { CommercetoolsProductListFactory } from '../factories/product-list/product-list.factory.js';
+
+export class CommercetoolsProductListCapability<
+  TFactory extends ProductListFactory = CommercetoolsProductListFactory,
+> extends ProductListCapability<
+  ProductListFactoryListOutput<TFactory>,
+  ProductListFactoryItemOutput<TFactory>,
+  ProductListFactoryListPaginatedOutput<TFactory>,
+  ProductListFactoryItemPaginatedOutput<TFactory>
+> {
   protected config: CommercetoolsConfiguration;
   protected commercetools: CommercetoolsAPI;
+  protected factory: ProductListFactoryWithOutput<TFactory>;
 
   constructor(
     config: CommercetoolsConfiguration,
     cache: Cache,
     context: RequestContext,
-    commercetools: CommercetoolsAPI
+    commercetools: CommercetoolsAPI,
+    factory: ProductListFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
 
   protected async getClient() {
@@ -71,7 +86,7 @@ export class CommercetoolsProductListProvider extends ProductListProvider {
     inputSchema: ProductListQueryByIdSchema,
     outputSchema: ProductListSchema
   })
-  public override async getById(payload: ProductListQueryById): Promise<Result<ProductList>> {
+  public override async getById(payload: ProductListQueryById): Promise<Result<ProductListFactoryListOutput<TFactory>>> {
     try {
       const client = await this.getClient();
       const response = await client.shoppingLists()
@@ -79,7 +94,7 @@ export class CommercetoolsProductListProvider extends ProductListProvider {
         .get()
         .execute();
 
-      return success(this.parseSingle(response.body));
+      return success(this.factory.parseProductList(this.context, this.parseSingle(response.body)));
     } catch(err: any) {
       if (err.statusCode === 404) {
         return error<NotFoundError>({
@@ -101,17 +116,17 @@ export class CommercetoolsProductListProvider extends ProductListProvider {
     inputSchema: ProductListQuerySchema,
     outputSchema: ProductListPaginatedResultsSchema
   })
-  public override async queryLists(payload: ProductListQuery): Promise<Result<ProductListPaginatedResult>> {
+  public override async queryLists(payload: ProductListQuery): Promise<Result<ProductListFactoryListPaginatedOutput<TFactory>>> {
 
     if (this.context.session.identityContext?.identity?.type !== 'Registered') {
-      return success({
+      return success(this.factory.parseProductListPaginatedResult(this.context, {
         items: [],
         pageNumber: 1,
         pageSize: payload.search.paginationOptions.pageSize,
         totalCount: 0,
         totalPages: 0,
         identifier: payload.search,
-      });
+      }));
     }
 
     const client = await this.getClient();
@@ -125,14 +140,14 @@ export class CommercetoolsProductListProvider extends ProductListProvider {
       }
     }).execute();
 
-    return success({
+    return success(this.factory.parseProductListPaginatedResult(this.context, {
       items: response.body.results.map(list => this.parseSingle(list)),
       pageNumber: payload.search.paginationOptions.pageNumber,
       pageSize: payload.search.paginationOptions.pageSize,
       totalCount: response.body.total || 0,
       totalPages: Math.ceil((response.body.total || 0) / payload.search.paginationOptions.pageSize),
       identifier: payload.search,
-    });
+    }));
 
   }
 
@@ -141,7 +156,7 @@ export class CommercetoolsProductListProvider extends ProductListProvider {
     inputSchema: ProductListMutationCreateSchema,
     outputSchema: ProductListSchema
   })
-  public override async addList(mutation: ProductListMutationCreate): Promise<Result<ProductList>> {
+  public override async addList(mutation: ProductListMutationCreate): Promise<Result<ProductListFactoryListOutput<TFactory>>> {
     const client = await this.getClient();
     const localeString = this.getLocaleString();
 
@@ -174,7 +189,7 @@ export class CommercetoolsProductListProvider extends ProductListProvider {
       body: draft
     }).execute();
 
-    return success(this.parseSingle(response.body));
+    return success(this.factory.parseProductList(this.context, this.parseSingle(response.body)));
   }
 
   @Reactionary({
@@ -182,7 +197,7 @@ export class CommercetoolsProductListProvider extends ProductListProvider {
     inputSchema: ProductListMutationUpdateSchema,
     outputSchema: ProductListSchema
   })
-  public override async updateList(mutation: ProductListMutationUpdate): Promise<Result<ProductList>> {
+  public override async updateList(mutation: ProductListMutationUpdate): Promise<Result<ProductListFactoryListOutput<TFactory>>> {
     const client = await this.getClient();
     const actions: MyShoppingListUpdateAction[] = [];
     const localeString = this.getLocaleString()
@@ -234,7 +249,7 @@ export class CommercetoolsProductListProvider extends ProductListProvider {
       .post({ body: update })
       .execute();
 
-    return success(this.parseSingle(response.body));
+    return success(this.factory.parseProductList(this.context, this.parseSingle(response.body)));
   }
 
   @Reactionary({
@@ -270,7 +285,7 @@ export class CommercetoolsProductListProvider extends ProductListProvider {
     inputSchema: ProductListItemQuerySchema,
     outputSchema: ProductListItemPaginatedResultsSchema
   })
-  public override async queryListItems(query: ProductListItemsQuery): Promise<Result<ProductListItemPaginatedResult>> {
+  public override async queryListItems(query: ProductListItemsQuery): Promise<Result<ProductListFactoryItemPaginatedOutput<TFactory>>> {
     const client = await this.getClient();
 
     const response = await client.shoppingLists()
@@ -282,14 +297,14 @@ export class CommercetoolsProductListProvider extends ProductListProvider {
 
     const items = response.body.lineItems.map(lineItem => this.parseProductListItem(query.search.list, lineItem ));
 
-    return success({
+    return success(this.factory.parseProductListItemPaginatedResult(this.context, {
       items: items.slice((query.search.paginationOptions.pageNumber - 1) * query.search.paginationOptions.pageSize, query.search.paginationOptions.pageNumber * query.search.paginationOptions.pageSize),
       identifier: query.search,
       pageNumber: query.search.paginationOptions.pageNumber,
       pageSize: query.search.paginationOptions.pageSize,
       totalCount: items.length,
       totalPages: Math.ceil(items.length / query.search.paginationOptions.pageSize),
-    });
+    }));
   }
 
   @Reactionary({
@@ -297,7 +312,7 @@ export class CommercetoolsProductListProvider extends ProductListProvider {
     inputSchema: ProductListItemMutationCreateSchema,
     outputSchema: ProductListItemSchema
   })
-  public override async addItem(mutation: ProductListItemMutationCreate): Promise<Result<ProductListItem>> {
+  public override async addItem(mutation: ProductListItemMutationCreate): Promise<Result<ProductListFactoryItemOutput<TFactory>>> {
     const client = await this.getClient();
 
     const lineItemDraft: MyShoppingListAddLineItemAction = {
@@ -331,7 +346,7 @@ export class CommercetoolsProductListProvider extends ProductListProvider {
         throw new Error('The added line item is not the last item in the list, cannot reliably determine the identifier of the added item');
       }
 
-    return success(this.parseProductListItem(mutation.list, lastItem  ));
+    return success(this.factory.parseProductListItem(this.context, this.parseProductListItem(mutation.list, lastItem)));
   }
 
   @Reactionary({
@@ -363,7 +378,7 @@ export class CommercetoolsProductListProvider extends ProductListProvider {
     inputSchema: ProductListItemMutationUpdateSchema,
     outputSchema: ProductListItemSchema
   })
-  public override async updateItem(mutation: ProductListItemMutationUpdate): Promise<Result<ProductListItem>> {
+  public override async updateItem(mutation: ProductListItemMutationUpdate): Promise<Result<ProductListFactoryItemOutput<TFactory>>> {
     const client = await this.getClient();
 
     const actions: MyShoppingListUpdateAction[] = [];
@@ -408,7 +423,7 @@ export class CommercetoolsProductListProvider extends ProductListProvider {
       throw new Error('Failed to find the updated line item in response');
     }
 
-    return success(this.parseProductListItem(mutation.listItem.list, updatedLineItem));
+    return success(this.factory.parseProductListItem(this.context, this.parseProductListItem(mutation.listItem.list, updatedLineItem)));
   }
 
   /**

package/{providers/commercetools/src/providers/product-reviews.provider.ts → packages/commercetools/src/capabilities/product-reviews.capability.ts}

@@ -1,5 +1,10 @@
 import {
-  ProductReviewsProvider,
+  type ProductReviewsFactory,
+  type ProductReviewsFactoryRatingOutput,
+  type ProductReviewsFactoryReviewOutput,
+  type ProductReviewsFactoryReviewPaginatedOutput,
+  type ProductReviewsFactoryWithOutput,
+  ProductReviewsCapability,
   Reactionary,
   success,
   error,
@@ -8,9 +13,8 @@ import {
   ProductReviewPaginatedResultSchema,
 } from '@reactionary/core';
 import type {
-  ProductReview,
   ProductRatingSummary,
-  ProductReviewPaginatedResult,
+  ProductReview,
   ProductReviewsListQuery,
   ProductReviewsGetRatingSummaryQuery,
   ProductReviewMutationSubmit,
@@ -23,20 +27,30 @@ import type {
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { CommercetoolsAPI } from '../core/client.js';
 import type { Review as CTReview } from '@commercetools/platform-sdk';
+import type { CommercetoolsProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
 
-export class CommercetoolsProductReviewsProvider extends ProductReviewsProvider {
+export class CommercetoolsProductReviewsCapability<
+  TFactory extends ProductReviewsFactory = CommercetoolsProductReviewsFactory,
+> extends ProductReviewsCapability<
+  ProductReviewsFactoryRatingOutput<TFactory>,
+  ProductReviewsFactoryReviewPaginatedOutput<TFactory>,
+  ProductReviewsFactoryReviewOutput<TFactory>
+> {
   protected config: CommercetoolsConfiguration;
   protected commercetools: CommercetoolsAPI;
+  protected factory: ProductReviewsFactoryWithOutput<TFactory>;
 
   constructor(
     config: CommercetoolsConfiguration,
     cache: Cache,
     context: RequestContext,
-    commercetools: CommercetoolsAPI
+    commercetools: CommercetoolsAPI,
+    factory: ProductReviewsFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
 
   protected async getClient() {
@@ -58,7 +72,7 @@ export class CommercetoolsProductReviewsProvider extends ProductReviewsProvider
   })
   public override async getRatingSummary(
     query: ProductReviewsGetRatingSummaryQuery
-  ): Promise<Result<ProductRatingSummary>> {
+  ): Promise<Result<ProductReviewsFactoryRatingOutput<TFactory>>> {
     const client = await this.getClient();
 
     // Get all reviews for the product to calculate summary
@@ -80,6 +94,7 @@ export class CommercetoolsProductReviewsProvider extends ProductReviewsProvider
         },
         averageRating: 0,
         totalRatings: 0,
+        ratingDistribution: undefined,
       }
 
       if (response.body.reviewRatingStatistics) {
@@ -93,9 +108,14 @@ export class CommercetoolsProductReviewsProvider extends ProductReviewsProvider
           '5': response.body.reviewRatingStatistics.ratingsDistribution['5'] ?? 0,
         };
       }
-      return success(summary);
+      return success(this.factory.parseRatingSummary(this.context, summary));
     } else {
-      return success(this.createEmptyProductRatingSummary({ product: query.product }));
+      return success(
+        this.factory.parseRatingSummary(
+          this.context,
+          this.createEmptyProductRatingSummary({ product: query.product }),
+        ),
+      );
     }
   }
 
@@ -108,7 +128,7 @@ export class CommercetoolsProductReviewsProvider extends ProductReviewsProvider
   })
   public override async findReviews(
     query: ProductReviewsListQuery
-  ): Promise<Result<ProductReviewPaginatedResult>> {
+  ): Promise<Result<ProductReviewsFactoryReviewPaginatedOutput<TFactory>>> {
     const client = await this.getClient();
 
     const pageNumber = query.paginationOptions?.pageNumber ?? 1;
@@ -124,13 +144,13 @@ export class CommercetoolsProductReviewsProvider extends ProductReviewsProvider
     });
 
     if (!product || !product.body) {
-      return success({
+      return success(this.factory.parseReviewPaginatedResult(this.context, {
         items: [],
         totalCount: 0,
         pageSize,
         pageNumber,
         totalPages: 0,
-      })
+      }));
     }
 
     // Build where clause
@@ -175,7 +195,7 @@ export class CommercetoolsProductReviewsProvider extends ProductReviewsProvider
     const reviews = response.body.results.map((review) =>
       this.parseSingle(review, query.product.key)
     );
-    const returnedResult: ProductReviewPaginatedResult = {
+    const returnedResult = {
       items: reviews,
       totalCount: response.body.total || reviews.length,
       pageSize,
@@ -183,7 +203,7 @@ export class CommercetoolsProductReviewsProvider extends ProductReviewsProvider
       totalPages: Math.ceil((response.body.total || reviews.length) / Math.max(pageSize, 1)),
     };
 
-    return success(returnedResult);
+    return success(this.factory.parseReviewPaginatedResult(this.context, returnedResult));
   }
 
   @Reactionary({
@@ -195,7 +215,7 @@ export class CommercetoolsProductReviewsProvider extends ProductReviewsProvider
   })
   public override async submitReview(
     mutation: ProductReviewMutationSubmit
-  ): Promise<Result<ProductReview>> {
+  ): Promise<Result<ProductReviewsFactoryReviewOutput<TFactory>>> {
 
 
     if (!(this.context.session.identityContext.identity.type === 'Registered')) {
@@ -227,7 +247,7 @@ export class CommercetoolsProductReviewsProvider extends ProductReviewsProvider
 
     const review = this.parseSingle(response.body, mutation.product.key);
 
-    return success(review);
+    return success(this.factory.parseReview(this.context, review));
   }
 
   protected parseSingle(review: CTReview, productKey: string): ProductReview {

package/{providers/commercetools/src/providers/product-search.provider.ts → packages/commercetools/src/capabilities/product-search.capability.ts}

@@ -1,43 +1,24 @@
 import type {
-  ProductSearchFacetResult as CTProductSearchFacetResult,
-  ProductSearchFacetResultBucket as CTProductSearchFacetResultBucket,
-  ProductVariant as CTProductVariant,
-  ProductPagedSearchResponse,
-  ProductProjection,
   ProductSearchFacetExpression,
 } from '@commercetools/platform-sdk';
 import type {
   Cache,
   FacetIdentifier,
   FacetValueIdentifier,
-  ProductOptionIdentifier,
+  ProductSearchFactory,
+  ProductSearchFactoryOutput,
+  ProductSearchFactoryWithOutput,
   ProductSearchQueryByTerm,
   ProductSearchQueryCreateNavigationFilter,
-  ProductSearchResult,
-  ProductSearchResultFacet,
-  ProductSearchResultFacetValue,
-  ProductSearchResultItem,
-  ProductSearchResultItemVariant,
-  ProductVariantIdentifier,
-  ProductVariantOption,
   RequestContext,
   Result,
-  SearchIdentifier,
 } from '@reactionary/core';
 import {
-  FacetIdentifierSchema,
   FacetValueIdentifierSchema,
-  ImageSchema,
-  ProductOptionIdentifierSchema,
-  ProductSearchProvider,
+  ProductSearchCapability,
   ProductSearchQueryByTermSchema,
   ProductSearchQueryCreateNavigationFilterSchema,
-  ProductSearchResultFacetSchema,
-  ProductSearchResultFacetValueSchema,
-  ProductSearchResultItemVariantSchema,
   ProductSearchResultSchema,
-  ProductVariantIdentifierSchema,
-  ProductVariantOptionSchema,
   Reactionary,
   success,
 } from '@reactionary/core';
@@ -46,23 +27,29 @@ import type { CommercetoolsConfiguration } from '../schema/configuration.schema.
 import createDebug from 'debug';
 import type { CommercetoolsAPI } from '../core/client.js';
 import { CommercetoolsCategoryLookupSchema, CommercetoolsResolveCategoryQueryByKeySchema, type CommercetoolsCategoryLookup, type CommercetoolsResolveCategoryQueryById, type CommercetoolsResolveCategoryQueryByKey } from '../schema/commercetools.schema.js';
+import type { CommercetoolsProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 
 const debug = createDebug('reactionary:commercetools:search');
 
-export class CommercetoolsSearchProvider extends ProductSearchProvider {
+export class CommercetoolsProductSearchCapability<
+  TFactory extends ProductSearchFactory = CommercetoolsProductSearchFactory,
+> extends ProductSearchCapability<ProductSearchFactoryOutput<TFactory>> {
   protected config: CommercetoolsConfiguration;
   protected commercetools: CommercetoolsAPI;
+  protected factory: ProductSearchFactoryWithOutput<TFactory>;
 
   constructor(
     config: CommercetoolsConfiguration,
     cache: Cache,
     context: RequestContext,
-    commercetools: CommercetoolsAPI
+    commercetools: CommercetoolsAPI,
+    factory: ProductSearchFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
 
   protected async getClient() {
@@ -275,7 +262,7 @@ export class CommercetoolsSearchProvider extends ProductSearchProvider {
   })
   public override async queryByTerm(
     payload: ProductSearchQueryByTerm
-  ): Promise<Result<ProductSearchResult>> {
+  ): Promise<Result<ProductSearchFactoryOutput<TFactory>>> {
     const client = await this.getClient();
 
     const facetsToReturn = await this.getFacetsToReturn(payload);
@@ -327,10 +314,11 @@ export class CommercetoolsSearchProvider extends ProductSearchProvider {
       .execute();
 
     const responseBody = response.body;
-    const result = this.parsePaginatedResult(
+    const result = this.factory.parseSearchResult(
+      this.context,
       responseBody,
-      payload
-    ) as ProductSearchResult;
+      payload,
+    );
 
 
     // ok, we have to patch up the categories facet to have the category keys instead of ids
@@ -358,7 +346,7 @@ export class CommercetoolsSearchProvider extends ProductSearchProvider {
     return success(result);
   }
 
-  protected async patchCategoryFacetValues(result: ProductSearchResult) {
+  protected async patchCategoryFacetValues(result: ProductSearchFactoryOutput<TFactory>) {
     const categoryFacet = result.facets.find(
       (f) => f.identifier.key === 'categories'
     );
@@ -384,145 +372,4 @@ export class CommercetoolsSearchProvider extends ProductSearchProvider {
   }
 
 
-  protected parseSingle(body: ProductProjection) {
-    const identifier = { key: body.id };
-    const name = body.name[this.context.languageContext.locale] || body.id;
-    const slug = body.slug?.[this.context.languageContext.locale] || body.id;
-    const variants = [body.masterVariant, ...body.variants].map((variant) =>
-      this.parseVariant(variant, body)
-    );
-
-    const product = {
-      identifier,
-      name,
-      slug,
-      variants,
-    } satisfies ProductSearchResultItem;
-
-    return product;
-  }
-
-  protected parsePaginatedResult(
-    body: ProductPagedSearchResponse,
-    query: ProductSearchQueryByTerm
-  ) {
-    const identifier = {
-      ...query.search,
-    } satisfies SearchIdentifier;
-
-    const products: ProductSearchResultItem[] = body.results.map((p) =>
-      this.parseSingle(p.productProjection!)
-    );
-    const facets: ProductSearchResultFacet[] = [];
-
-    for (const facet of body.facets) {
-      const facetIdentifier = FacetIdentifierSchema.parse({
-        key: facet.name,
-      } satisfies Partial<FacetIdentifier>);
-
-      const candidateFacet = this.parseFacet(facetIdentifier, facet);
-      if (candidateFacet.values.length > 0) {
-        facets.push(candidateFacet);
-      }
-    }
-
-    const result = {
-      identifier,
-      pageNumber: (Math.ceil(body.offset / body.limit) || 0) + 1,
-      pageSize: body.limit,
-      totalCount: body.total || 0,
-      totalPages: Math.ceil((body.total || 0) / body.limit || 0) + 1,
-      items: products,
-      facets,
-    } satisfies ProductSearchResult;
-
-    return result;
-  }
-
-  /**
-   * See version 0.0.81 for ProductProjection based facet parsing
-   * @param facetIdentifier
-   * @param facetValue
-   * @returns
-   */
-  protected parseFacet(
-    facetIdentifier: FacetIdentifier,
-    facet: CTProductSearchFacetResult
-  ): ProductSearchResultFacet {
-    const result: ProductSearchResultFacet =
-      ProductSearchResultFacetSchema.parse({
-        identifier: facetIdentifier,
-        name: facet.name,
-        values: [],
-      });
-
-    const distinctFacet = facet as CTProductSearchFacetResultBucket;
-    if (distinctFacet) {
-      distinctFacet.buckets.forEach((bucket) => {
-        const facetValueIdentifier = FacetValueIdentifierSchema.parse({
-          facet: facetIdentifier,
-          key: bucket.key,
-        } satisfies Partial<FacetValueIdentifier>);
-
-        result.values.push(
-          this.parseFacetValue(facetValueIdentifier, bucket.key, bucket.count)
-        );
-      });
-    }
-
-    return result;
-  }
-
-  protected parseFacetValue(
-    facetValueIdentifier: FacetValueIdentifier,
-    label: string,
-    count: number
-  ): ProductSearchResultFacetValue {
-
-    return ProductSearchResultFacetValueSchema.parse({
-      identifier: facetValueIdentifier,
-      name: label,
-      count: count,
-      active: false,
-    } satisfies Partial<ProductSearchResultFacetValue>);
-  }
-
-  protected parseVariant(
-    variant: CTProductVariant,
-    product: ProductProjection
-  ): ProductSearchResultItemVariant {
-    const sourceImage = variant.images?.[0];
-
-    const img = ImageSchema.parse({
-      sourceUrl: sourceImage?.url || '',
-      height: sourceImage?.dimensions.h || undefined,
-      width: sourceImage?.dimensions.w || undefined,
-      altText:
-        sourceImage?.label ||
-        product.name[this.context.languageContext.locale] ||
-        undefined,
-    });
-
-    const mappedOptions =
-      variant.attributes
-        ?.filter((x) => x.name === 'Color')
-        .map((opt) =>
-          ProductVariantOptionSchema.parse({
-            identifier: ProductOptionIdentifierSchema.parse({
-              key: opt.name,
-            } satisfies Partial<ProductOptionIdentifier>),
-            name: opt.value || '',
-          } satisfies Partial<ProductVariantOption>)
-        ) || [];
-
-    const mappedOption = mappedOptions?.[0];
-
-    return ProductSearchResultItemVariantSchema.parse({
-      variant: ProductVariantIdentifierSchema.parse({
-        sku: variant.sku || '',
-      } satisfies ProductVariantIdentifier),
-      image: img,
-      options: mappedOption,
-    } satisfies Partial<ProductSearchResultItemVariant>);
-  }
 }