@reactionary/source 0.3.18 → 0.6.2

package/providers/commercetools/src/providers/product-search.provider.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,
   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 CommercetoolsSearchProvider<
+  TFactory extends ProductSearchFactory = CommercetoolsProductSearchFactory,
+> extends ProductSearchProvider<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>);
-  }
 }

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

@@ -1,9 +1,4 @@
 import {
-  ImageSchema,
-  ProductAttributeIdentifierSchema,
-  ProductAttributeSchema,
-  ProductAttributeValueIdentifierSchema,
-  ProductAttributeValueSchema,
   ProductProvider,
   ProductQueryByIdSchema,
   ProductQueryBySKUSchema,
@@ -12,48 +7,34 @@ import {
   Reactionary,
   success,
   error,
+  type ProductFactory,
+  type ProductFactoryOutput,
+  type ProductFactoryWithOutput,
 } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type {
-  ProductProjection,
-  ProductVariant as CTProductVariant,
-  Attribute as CTAttribute,
-} from '@commercetools/platform-sdk';
-import type {
-  Product,
-  ProductVariant,
   ProductQueryById,
   ProductQueryBySKU,
   ProductQueryBySlug,
-  ProductVariantIdentifier,
   RequestContext,
-  ProductAttribute,
-  ProductAttributeIdentifier,
-  ProductAttributeValue,
-  ProductAttributeValueIdentifier,
-  ProductIdentifier,
-  ProductVariantOption,
-  ProductOptionIdentifier,
   Result,
 } from '@reactionary/core';
-import type { Cache, Image } from '@reactionary/core';
+import type { Cache } from '@reactionary/core';
 import type { CommercetoolsAPI } from '../core/client.js';
 import type { NotFoundError } from '@reactionary/core';
+import type { CommercetoolsProductFactory } from '../factories/product/product.factory.js';
 
-export class CommercetoolsProductProvider extends ProductProvider {
-  protected config: CommercetoolsConfiguration;
-  protected commercetools: CommercetoolsAPI;
-
+export class CommercetoolsProductProvider<
+  TFactory extends ProductFactory = CommercetoolsProductFactory
+> extends ProductProvider<ProductFactoryOutput<TFactory>> {
   constructor(
-    config: CommercetoolsConfiguration,
     cache: Cache,
     context: RequestContext,
-    commercetools: CommercetoolsAPI
+    protected config: CommercetoolsConfiguration,
+    protected commercetools: CommercetoolsAPI,
+    protected factory: ProductFactoryWithOutput<TFactory>
   ) {
     super(cache, context);
-
-    this.config = config;
-    this.commercetools = commercetools;
   }
 
   protected async getClient() {
@@ -73,13 +54,14 @@ export class CommercetoolsProductProvider extends ProductProvider {
   })
   public override async getById(
     payload: ProductQueryById
-  ): Promise<Result<Product>> {
+  ): Promise<Result<ProductFactoryOutput<TFactory>>> {
     const client = await this.getClient();
     const remote = await client
       .withKey({ key: payload.identifier.key })
       .get()
       .execute();
-    const value = this.parseSingle(remote.body);
+
+    const value = this.factory.parseProduct(this.context, remote.body);
 
     return success(value);
   }
@@ -94,7 +76,7 @@ export class CommercetoolsProductProvider extends ProductProvider {
   })
   public override async getBySlug(
     payload: ProductQueryBySlug
-  ): Promise<Result<Product, NotFoundError>> {
+  ): Promise<Result<ProductFactoryOutput<TFactory>, NotFoundError>> {
     const client = await this.getClient();
 
     const remote = await client
@@ -113,7 +95,7 @@ export class CommercetoolsProductProvider extends ProductProvider {
         identifier: payload.slug,
       });
     }
-    const result = this.parseSingle(remote.body.results[0]);
+    const result = this.factory.parseProduct(this.context, remote.body.results[0]);
 
     return success(result);
   }
@@ -128,7 +110,7 @@ export class CommercetoolsProductProvider extends ProductProvider {
   })
   public override async getBySKU(
     payload: ProductQueryBySKU
-  ): Promise<Result<Product>> {
+  ): Promise<Result<ProductFactoryOutput<TFactory>>> {
     const client = await this.getClient();
 
     const remote = await client
@@ -142,171 +124,10 @@ export class CommercetoolsProductProvider extends ProductProvider {
       })
       .execute();
 
-    const result = this.parseSingle(remote.body.results[0]);
+    // PAIN: the lack of knowing the non-generic type signature of the factory (the scopedown to CT Product Provider)
+    // this is due to the Typescript construct for ProductFactoryOutput<TFactory>
+    const result = this.factory.parseProduct(this.context, remote.body.results[0]);
 
     return success(result);
   }
-
-  protected parseSingle(data: ProductProjection): Product {
-    const identifier = { key: data.key || data.id } satisfies ProductIdentifier;
-    const name = data.name[this.context.languageContext.locale];
-    const slug = data.slug[this.context.languageContext.locale];
-
-    let description = '';
-    if (data.description) {
-      description = data.description[this.context.languageContext.locale];
-    }
-
-    const variantLevelAttributes =
-      data.masterVariant.attributes?.map((x) => this.parseAttribute(x)) || [];
-
-
-    const specialAttributes = [
-      'reactionaryaccessories',
-      'reactionaryspareparts',
-      'reactionaryreplacements'
-    ]
-
-    const productLevelAttributes =
-      data.attributes.filter(x => !specialAttributes.includes(x.name)).map((x) => this.parseAttribute(x)) || [];
-
-    const sharedAttributes = [
-      ...productLevelAttributes,
-      ...variantLevelAttributes,
-    ];
-    const mainVariant = this.parseVariant(data.masterVariant, data);
-
-    const otherVariants = [];
-    for (const variant of data.variants || []) {
-      if (variant.id !== data.masterVariant.id) {
-        otherVariants.push(this.parseVariant(variant, data));
-      }
-    }
-
-    const result = {
-      identifier,
-      name,
-      slug,
-      description,
-      sharedAttributes,
-      mainVariant,
-      brand: '',
-      longDescription: '',
-      manufacturer: '',
-      options: [],
-      parentCategories: [],
-      published: true,
-      variants: otherVariants,
-    } satisfies Product;
-
-    return result;
-  }
-
-  /**
-   * Return true, if the attribute is a defining attribute (ie an option)
-   * @param attr a variant attribute
-   * @returns true if the attribute is an option
-   */
-  protected isVariantAttributeAnOption(attr: CTAttribute): boolean {
-    // for now, the assumption is that any variant attribute is a defining attribute (ie an option)
-    // ideally this should be verified with the product type.
-    return true;
-  }
-
-  protected parseVariant(
-    variant: CTProductVariant,
-    product: ProductProjection
-  ): ProductVariant {
-    const identifier = {
-      sku: variant.sku!,
-    } satisfies ProductVariantIdentifier;
-
-    const images = [
-      ...(variant.images || []).map((img) =>
-        ImageSchema.parse({
-          sourceUrl: img.url,
-          altText: img.label || '',
-          width: img.dimensions?.w,
-          height: img.dimensions?.h,
-        } satisfies Image)
-      ),
-    ];
-
-    const options =
-      (variant.attributes ?? [])
-        .filter((attr) => this.isVariantAttributeAnOption(attr))
-        .map((attr) => {
-          const attrVal = this.parseAttributeValue(attr);
-          const optionIdentifier: ProductOptionIdentifier = {
-            key: attr.name,
-          };
-          const option: ProductVariantOption = {
-            identifier: optionIdentifier,
-            name: attr.name,
-            value: {
-              identifier: {
-                key: attrVal.value,
-                option: optionIdentifier,
-              },
-              label: attrVal.label,
-            },
-          };
-          return option;
-        }) || [];
-
-    const result = {
-      identifier,
-      images,
-      barcode: '',
-      ean: '',
-      gtin: '',
-      name: product.name[this.context.languageContext.locale],
-      options,
-      upc: '',
-    } satisfies ProductVariant;
-
-    return result;
-  }
-
-  protected parseAttribute(attr: CTAttribute): ProductAttribute {
-    const result = ProductAttributeSchema.parse({
-      identifier: ProductAttributeIdentifierSchema.parse({
-        key: attr.name,
-      } satisfies Partial<ProductAttributeIdentifier>),
-      group: '',
-      name: attr.name,
-      values: [this.parseAttributeValue(attr)],
-    } satisfies Partial<ProductAttribute>);
-
-    return result;
-  }
-
-  protected parseAttributeValue(attr: CTAttribute): ProductAttributeValue {
-    let attrValue = '';
-    if (attr.value && Array.isArray(attr.value)) {
-      attrValue = attr.value[0];
-    }
-
-    if (attr.value && typeof attr.value === 'object') {
-      if (this.context.languageContext.locale in attr.value) {
-        attrValue = attr.value[this.context.languageContext.locale];
-      } else {
-        attrValue = '-';
-      }
-    }
-
-    if (typeof attr.value === 'string') {
-      attrValue = attr.value;
-    }
-
-    const attrVal = ProductAttributeValueSchema.parse({
-      identifier: ProductAttributeValueIdentifierSchema.parse({
-        key: attrValue,
-      } satisfies Partial<ProductAttributeValueIdentifier>),
-      value: String(attrValue),
-      label: String(attrValue),
-    } satisfies Partial<ProductAttributeValue>);
-
-    return attrVal;
-  }
 }