@reactionary/source 0.6.1 → 0.6.2

package/providers/commercetools/src/providers/product-associations.provider.ts

@@ -1,47 +1,45 @@
 import {
+  type ProductAssociationsFactory,
+  type ProductAssociationsFactoryOutput,
+  type ProductAssociationsFactoryWithOutput,
   ProductAssociationsProvider,
   Reactionary,
-  ImageSchema,
-  ProductVariantOptionSchema,
-  ProductOptionIdentifierSchema,
-  ProductSearchResultItemVariantSchema,
-  ProductVariantIdentifierSchema,
   success,
   error,
 } from '@reactionary/core';
 import type {
-  ProductVariantIdentifier,
   ProductIdentifier,
-  ProductAssociation,
-  ProductSearchResultItem,
-  ProductSearchResultItemVariant,
   ProductAssociationsGetAccessoriesQuery,
   ProductAssociationsGetSparepartsQuery,
   ProductAssociationsGetReplacementsQuery,
   Result,
   RequestContext,
   Cache,
-  ProductOptionIdentifier,
-  ProductVariantOption,
   NotFoundError,
 } from '@reactionary/core';
-import type { ProductProjection, ProductVariant as CTProductVariant } from '@commercetools/platform-sdk';
+import type { ProductProjection } from '@commercetools/platform-sdk';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
 
-export class CommercetoolsProductAssociationsProvider extends ProductAssociationsProvider {
+export class CommercetoolsProductAssociationsProvider<
+  TFactory extends ProductAssociationsFactory = CommercetoolsProductAssociationsFactory,
+> extends ProductAssociationsProvider<ProductAssociationsFactoryOutput<TFactory>> {
   protected config: CommercetoolsConfiguration;
   protected commercetools: CommercetoolsAPI;
+  protected factory: ProductAssociationsFactoryWithOutput<TFactory>;
 
   constructor(
     config: CommercetoolsConfiguration,
     cache: Cache,
     context: RequestContext,
-    commercetools: CommercetoolsAPI
+    commercetools: CommercetoolsAPI,
+    factory: ProductAssociationsFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
 
   protected async getClient() {
@@ -49,7 +47,7 @@ export class CommercetoolsProductAssociationsProvider extends ProductAssociation
     return client.withProjectKey({ projectKey: this.config.projectKey });
   }
 
-  protected async fetchAssociatedProductsFor(productKey: ProductIdentifier, maxNumberOfAssociations: number, attributeName: string): Promise<ProductSearchResultItem[]> {
+  protected async fetchAssociatedProductsFor(productKey: ProductIdentifier, maxNumberOfAssociations: number, attributeName: string): Promise<ProductProjection[]> {
       const client = await this.getClient();
 
       const product = await client
@@ -74,7 +72,7 @@ export class CommercetoolsProductAssociationsProvider extends ProductAssociation
         if (!associationsAttr) {
           return [];
         }
-        const associatedProductSearchItems: ProductSearchResultItem[] = [];
+        const associatedProductSearchItems: ProductProjection[] = [];
 
         // look up each associated product,
         const allAssociatedProductPromises = (associationsAttr.value as string[]).map(async (associatedProductId) => {
@@ -90,34 +88,12 @@ export class CommercetoolsProductAssociationsProvider extends ProductAssociation
         const associatedProductsResults = await Promise.all(allAssociatedProductPromises);
         const validAssociatedProductsResults = associatedProductsResults.filter(result => !!result).slice(0, maxNumberOfAssociations);
         for (const associatedProductResult of validAssociatedProductsResults) {
-          const resultItem = this.parseSingle(associatedProductResult.body);
-          if (resultItem) {
-            associatedProductSearchItems.push(resultItem);
-          }
+          associatedProductSearchItems.push(associatedProductResult.body);
         }
         return associatedProductSearchItems;
     }
 
 
-  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;
-  }
-
-
   @Reactionary({
     cache: true,
     cacheTimeToLiveInSeconds: 300,
@@ -126,17 +102,17 @@ export class CommercetoolsProductAssociationsProvider extends ProductAssociation
   })
   public override async getAccessories(
     query: ProductAssociationsGetAccessoriesQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
 
     const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfAccessories || 4, 'reactionaryaccessories');
 
-    const result: ProductAssociation[] = associatedProducts.map(product => ({
-      associationIdentifier: {
-        key: `${query.forProduct.key}-accessory-${product.identifier.key}`
-      },
-      associationReturnType: 'productSearchResultItem',
-      product,
-    } satisfies ProductAssociation));
+    const result = associatedProducts.map((product) =>
+      this.factory.parseAssociation(this.context, {
+        sourceProductKey: query.forProduct.key,
+        relation: 'accessory',
+        product,
+      }),
+    );
 
     return success(result);
   }
@@ -149,16 +125,16 @@ export class CommercetoolsProductAssociationsProvider extends ProductAssociation
   })
   public override async getSpareparts(
     query: ProductAssociationsGetSparepartsQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
     const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfSpareparts || 4, 'reactionaryspareparts');
 
-    const result: ProductAssociation[] = associatedProducts.map(product => ({
-      associationIdentifier: {
-        key: `${query.forProduct.key}-sparepart-${product.identifier.key}`
-      },
-      associationReturnType: 'productSearchResultItem',
-      product,
-    } satisfies ProductAssociation));
+    const result = associatedProducts.map((product) =>
+      this.factory.parseAssociation(this.context, {
+        sourceProductKey: query.forProduct.key,
+        relation: 'sparepart',
+        product,
+      }),
+    );
 
     return success(result);
   }
@@ -171,59 +147,18 @@ export class CommercetoolsProductAssociationsProvider extends ProductAssociation
   })
   public override async getReplacements(
     query: ProductAssociationsGetReplacementsQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
     const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfReplacements || 4, 'reactionaryreplacements');
 
-    const result: ProductAssociation[] = associatedProducts.map(product => ({
-      associationIdentifier: {
-        key: `${query.forProduct.key}-replacement-${product.identifier.key}`
-      },
-      associationReturnType: 'productSearchResultItem',
-      product,
-    } satisfies ProductAssociation));
+    const result = associatedProducts.map((product) =>
+      this.factory.parseAssociation(this.context, {
+        sourceProductKey: query.forProduct.key,
+        relation: 'replacement',
+        product,
+      }),
+    );
 
     return success(result);
   }
 
-
-
-
-  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>);
-  }
 }

package/providers/commercetools/src/providers/product-list.provider.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,
@@ -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 CommercetoolsProductListProvider<
+  TFactory extends ProductListFactory = CommercetoolsProductListFactory,
+> extends ProductListProvider<
+  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

@@ -1,4 +1,9 @@
 import {
+  type ProductReviewsFactory,
+  type ProductReviewsFactoryRatingOutput,
+  type ProductReviewsFactoryReviewOutput,
+  type ProductReviewsFactoryReviewPaginatedOutput,
+  type ProductReviewsFactoryWithOutput,
   ProductReviewsProvider,
   Reactionary,
   success,
@@ -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 CommercetoolsProductReviewsProvider<
+  TFactory extends ProductReviewsFactory = CommercetoolsProductReviewsFactory,
+> extends ProductReviewsProvider<
+  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 {