@reactionary/source 0.6.1 → 0.6.3

package/packages/commercetools/src/factories/product/product.factory.ts

@@ -0,0 +1,220 @@
+import {
+  ImageSchema,
+  ProductAttributeIdentifierSchema,
+  ProductAttributeSchema,
+  ProductAttributeValueIdentifierSchema,
+  ProductAttributeValueSchema,
+  type AnyProductSchema,
+  type Product,
+  type ProductFactory,
+  type ProductIdentifier,
+  type ProductVariant,
+  type ProductVariantIdentifier,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+import type {
+  ProductProjection,
+  ProductVariant as CTProductVariant,
+  Attribute as CTAttribute,
+} from '@commercetools/platform-sdk';
+import type {
+  Image,
+  ProductAttribute,
+  ProductAttributeIdentifier,
+  ProductAttributeValue,
+  ProductAttributeValueIdentifier,
+  ProductOptionIdentifier,
+  ProductVariantOption,
+
+  ProductSchema} from '@reactionary/core';
+
+export class CommercetoolsProductFactory<
+  TProductSchema extends AnyProductSchema = typeof ProductSchema,
+> implements ProductFactory<TProductSchema>
+{
+  public readonly productSchema: TProductSchema;
+
+  // PAIN: not being able to assign a default for productSchema (productSchema: TProductSchema = ProductSchema)
+  // because it will invalidate TS' conservative instantiation-point generics
+  // PAIN: consider whether we can pass in request context here
+  constructor(productSchema: TProductSchema) {
+    this.productSchema = productSchema;
+  }
+
+  public parseProduct(
+    context: RequestContext,
+    data: ProductProjection,
+  ): z.output<TProductSchema> {
+    const identifier = { key: data.key || data.id } satisfies ProductIdentifier;
+    const name = data.name[context.languageContext.locale];
+    const slug = data.slug[context.languageContext.locale];
+
+    let description = '';
+    if (data.description) {
+      description = data.description[context.languageContext.locale];
+    }
+
+    const variantLevelAttributes =
+      data.masterVariant.attributes?.map((x) =>
+        this.parseAttribute(context, x),
+      ) || [];
+
+    const specialAttributes = [
+      'reactionaryaccessories',
+      'reactionaryspareparts',
+      'reactionaryreplacements',
+    ];
+
+    const productLevelAttributes =
+      data.attributes
+        .filter((x) => !specialAttributes.includes(x.name))
+        .map((x) => this.parseAttribute(context, x)) || [];
+
+    const sharedAttributes = [
+      ...productLevelAttributes,
+      ...variantLevelAttributes,
+    ];
+    const mainVariant = this.parseVariant(context, data.masterVariant, data);
+
+    const otherVariants = [];
+    for (const variant of data.variants || []) {
+      if (variant.id !== data.masterVariant.id) {
+        otherVariants.push(this.parseVariant(context, variant, data));
+      }
+    }
+
+    const result = {
+      identifier,
+      name,
+      slug,
+      description,
+      sharedAttributes,
+      mainVariant,
+      brand: '',
+      longDescription: '',
+      manufacturer: '',
+      options: [],
+      parentCategories: [],
+      published: true,
+      variants: otherVariants,
+    } satisfies Product;
+
+    // PAIN: having to actually do the parse here to guarantee that the generics are satisfied.
+    // probably fair, given that this relationship can't be expressed in TS otherwise...
+    // unless we were willing to accept ownership of the responsibility and do an 'as T'
+    return this.productSchema.parse(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(
+    context: RequestContext,
+    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(context, 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[context.languageContext.locale],
+      options,
+      upc: '',
+    } satisfies ProductVariant;
+
+    return result;
+  }
+
+  protected parseAttribute(
+    context: RequestContext,
+    attr: CTAttribute,
+  ): ProductAttribute {
+    const result = ProductAttributeSchema.parse({
+      identifier: ProductAttributeIdentifierSchema.parse({
+        key: attr.name,
+      } satisfies Partial<ProductAttributeIdentifier>),
+      group: '',
+      name: attr.name,
+      values: [this.parseAttributeValue(context, attr)],
+    } satisfies Partial<ProductAttribute>);
+
+    return result;
+  }
+
+  protected parseAttributeValue(context: RequestContext, attr: CTAttribute): ProductAttributeValue {
+    let attrValue = '';
+    if (attr.value && Array.isArray(attr.value)) {
+      attrValue = attr.value[0];
+    }
+
+    if (attr.value && typeof attr.value === 'object') {
+      if (context.languageContext.locale in attr.value) {
+        attrValue = attr.value[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;
+  }
+}

package/packages/commercetools/src/factories/product/utils.example.ts

@@ -0,0 +1,9 @@
+export const assertType = <T>(_value: T) => {
+  void _value;
+};
+
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+
+export const assertNotAny = <T>(_value: IsAny<T> extends true ? never : T) => {
+  void _value;
+};

package/packages/commercetools/src/factories/product-associations/product-associations.factory.ts

@@ -0,0 +1,103 @@
+import type { ProductProjection, ProductVariant as CTProductVariant } from '@commercetools/platform-sdk';
+import type {
+  ProductAssociationSchema} from '@reactionary/core';
+import {
+  ImageSchema,
+  ProductOptionIdentifierSchema,
+  ProductSearchResultItemVariantSchema,
+  ProductVariantIdentifierSchema,
+  ProductVariantOptionSchema,
+  type AnyProductAssociationSchema,
+  type ProductAssociation,
+  type ProductAssociationsFactory,
+  type ProductOptionIdentifier,
+  type ProductSearchResultItem,
+  type ProductSearchResultItemVariant,
+  type ProductVariantIdentifier,
+  type ProductVariantOption,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsProductAssociationsFactory<
+  TProductAssociationSchema extends AnyProductAssociationSchema = typeof ProductAssociationSchema,
+> implements ProductAssociationsFactory<TProductAssociationSchema>
+{
+  public readonly productAssociationSchema: TProductAssociationSchema;
+
+  constructor(productAssociationSchema: TProductAssociationSchema) {
+    this.productAssociationSchema = productAssociationSchema;
+  }
+
+  public parseAssociation(
+    context: RequestContext,
+    data: {
+      sourceProductKey: string;
+      relation: 'accessory' | 'sparepart' | 'replacement';
+      product: ProductProjection;
+    },
+  ): z.output<TProductAssociationSchema> {
+    const product = this.parseSearchResultItem(context, data.product);
+    const result = {
+      associationIdentifier: {
+        key: `${data.sourceProductKey}-${data.relation}-${product.identifier.key}`,
+      },
+      associationReturnType: 'productSearchResultItem',
+      product,
+    } satisfies ProductAssociation;
+
+    return this.productAssociationSchema.parse(result);
+  }
+
+  protected parseSearchResultItem(
+    context: RequestContext,
+    data: ProductProjection,
+  ): ProductSearchResultItem {
+    const variants = [data.masterVariant, ...data.variants].map((variant) =>
+      this.parseVariant(context, variant, data),
+    );
+
+    return {
+      identifier: { key: data.id },
+      name: data.name[context.languageContext.locale] || data.id,
+      slug: data.slug?.[context.languageContext.locale] || data.id,
+      variants,
+    } satisfies ProductSearchResultItem;
+  }
+
+  protected parseVariant(
+    context: RequestContext,
+    variant: CTProductVariant,
+    product: ProductProjection,
+  ): ProductSearchResultItemVariant {
+    const sourceImage = variant.images?.[0];
+    const image = ImageSchema.parse({
+      sourceUrl: sourceImage?.url || '',
+      height: sourceImage?.dimensions.h || undefined,
+      width: sourceImage?.dimensions.w || undefined,
+      altText: sourceImage?.label || product.name[context.languageContext.locale] || undefined,
+    });
+
+    const mappedOptions =
+      variant.attributes
+        ?.filter((attribute) => attribute.name === 'Color')
+        .map((option) =>
+          ProductVariantOptionSchema.parse({
+            identifier: ProductOptionIdentifierSchema.parse({
+              key: option.name,
+            } satisfies Partial<ProductOptionIdentifier>),
+            name: option.value || '',
+          } satisfies Partial<ProductVariantOption>),
+        ) || [];
+
+    const mappedOption = mappedOptions?.[0];
+
+    return ProductSearchResultItemVariantSchema.parse({
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: variant.sku || '',
+      } satisfies ProductVariantIdentifier),
+      image,
+      options: mappedOption,
+    } satisfies Partial<ProductSearchResultItemVariant>);
+  }
+}

package/packages/commercetools/src/factories/product-list/product-list.factory.ts

@@ -0,0 +1,122 @@
+import type { ShoppingList, ShoppingListLineItem } from '@commercetools/platform-sdk';
+import type {
+  ProductListItemPaginatedResultsSchema,
+  ProductListItemSchema,
+  ProductListPaginatedResultsSchema,
+  ProductListSchema} from '@reactionary/core';
+import {
+  type AnyProductListItemPaginatedSchema,
+  type AnyProductListItemSchema,
+  type AnyProductListPaginatedSchema,
+  type AnyProductListSchema,
+  type ProductList,
+  type ProductListFactory,
+  type ProductListIdentifier,
+  type ProductListItem,
+  type ProductListItemPaginatedResult,
+  type ProductListPaginatedResult,
+  type ProductListType,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsProductListFactory<
+  TProductListSchema extends AnyProductListSchema = typeof ProductListSchema,
+  TProductListItemSchema extends AnyProductListItemSchema = typeof ProductListItemSchema,
+  TProductListPaginatedSchema extends AnyProductListPaginatedSchema = typeof ProductListPaginatedResultsSchema,
+  TProductListItemPaginatedSchema extends AnyProductListItemPaginatedSchema = typeof ProductListItemPaginatedResultsSchema,
+> implements
+    ProductListFactory<
+      TProductListSchema,
+      TProductListItemSchema,
+      TProductListPaginatedSchema,
+      TProductListItemPaginatedSchema
+    >
+{
+  public readonly productListSchema: TProductListSchema;
+  public readonly productListItemSchema: TProductListItemSchema;
+  public readonly productListPaginatedSchema: TProductListPaginatedSchema;
+  public readonly productListItemPaginatedSchema: TProductListItemPaginatedSchema;
+
+  constructor(
+    productListSchema: TProductListSchema,
+    productListItemSchema: TProductListItemSchema,
+    productListPaginatedSchema: TProductListPaginatedSchema,
+    productListItemPaginatedSchema: TProductListItemPaginatedSchema,
+  ) {
+    this.productListSchema = productListSchema;
+    this.productListItemSchema = productListItemSchema;
+    this.productListPaginatedSchema = productListPaginatedSchema;
+    this.productListItemPaginatedSchema = productListItemPaginatedSchema;
+  }
+
+  public parseProductList(
+    _context: RequestContext,
+    data: ProductList,
+  ): z.output<TProductListSchema> {
+    return this.productListSchema.parse(data);
+  }
+
+  public parseProductListItem(
+    _context: RequestContext,
+    data: ProductListItem,
+  ): z.output<TProductListItemSchema> {
+    return this.productListItemSchema.parse(data);
+  }
+
+  public parseProductListPaginatedResult(
+    _context: RequestContext,
+    data: ProductListPaginatedResult,
+  ): z.output<TProductListPaginatedSchema> {
+    return this.productListPaginatedSchema.parse(data);
+  }
+
+  public parseProductListItemPaginatedResult(
+    _context: RequestContext,
+    data: ProductListItemPaginatedResult,
+  ): z.output<TProductListItemPaginatedSchema> {
+    return this.productListItemPaginatedSchema.parse(data);
+  }
+
+  public parseListFromCommercetools(list: ShoppingList): z.output<TProductListSchema> {
+    const listType = (list.custom?.fields['listType'] as ProductListType) || 'favorite';
+    const image = list.custom?.fields['imageUrl'] as string | undefined;
+    const published = (list.custom?.fields['published'] as boolean) && true;
+    const publishDateValue = list.custom?.fields['publishedDate'] as string | undefined;
+    const publishDate = publishDateValue ? new Date(publishDateValue).toISOString() : undefined;
+
+    return this.productListSchema.parse({
+      identifier: {
+        listType,
+        key: list.id,
+      },
+      type: listType,
+      name: list.name['en'] || 'Unnamed List',
+      description: list.description?.['en'] || '',
+      published,
+      publishDate,
+      image: {
+        sourceUrl: image || '',
+        altText: list.name['en'] || 'List Image',
+      },
+    } satisfies ProductList);
+  }
+
+  public parseListItemFromCommercetools(
+    listIdentifier: ProductListIdentifier,
+    lineItem: ShoppingListLineItem,
+  ): z.output<TProductListItemSchema> {
+    return this.productListItemSchema.parse({
+      identifier: {
+        list: listIdentifier,
+        key: lineItem.id,
+      },
+      variant: {
+        sku: lineItem.variant?.sku || '',
+      },
+      quantity: lineItem.quantity,
+      notes: (lineItem.custom?.fields['notes'] as string) || '',
+      order: (lineItem.custom?.fields['order'] as number) || 1,
+    } satisfies ProductListItem);
+  }
+}

package/packages/commercetools/src/factories/product-reviews/product-reviews.factory.ts

@@ -0,0 +1,81 @@
+import type { Review as CTReview } from '@commercetools/platform-sdk';
+import type {
+  ProductRatingSummarySchema,
+  ProductReviewPaginatedResultSchema,
+  ProductReviewSchema} from '@reactionary/core';
+import {
+  type AnyProductRatingSummarySchema,
+  type AnyProductReviewPaginatedSchema,
+  type AnyProductReviewSchema,
+  type ProductRatingSummary,
+  type ProductReview,
+  type ProductReviewPaginatedResult,
+  type ProductReviewsFactory,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsProductReviewsFactory<
+  TRatingSummarySchema extends AnyProductRatingSummarySchema = typeof ProductRatingSummarySchema,
+  TReviewSchema extends AnyProductReviewSchema = typeof ProductReviewSchema,
+  TReviewPaginatedSchema extends AnyProductReviewPaginatedSchema = typeof ProductReviewPaginatedResultSchema,
+> implements ProductReviewsFactory<TRatingSummarySchema, TReviewSchema, TReviewPaginatedSchema>
+{
+  public readonly ratingSummarySchema: TRatingSummarySchema;
+  public readonly reviewSchema: TReviewSchema;
+  public readonly reviewPaginatedSchema: TReviewPaginatedSchema;
+
+  constructor(
+    ratingSummarySchema: TRatingSummarySchema,
+    reviewSchema: TReviewSchema,
+    reviewPaginatedSchema: TReviewPaginatedSchema,
+  ) {
+    this.ratingSummarySchema = ratingSummarySchema;
+    this.reviewSchema = reviewSchema;
+    this.reviewPaginatedSchema = reviewPaginatedSchema;
+  }
+
+  public parseRatingSummary(
+    _context: RequestContext,
+    data: ProductRatingSummary,
+  ): z.output<TRatingSummarySchema> {
+    return this.ratingSummarySchema.parse(data);
+  }
+
+  public parseReview(
+    _context: RequestContext,
+    data: ProductReview,
+  ): z.output<TReviewSchema> {
+    return this.reviewSchema.parse(data);
+  }
+
+  public parseReviewPaginatedResult(
+    _context: RequestContext,
+    data: ProductReviewPaginatedResult,
+  ): z.output<TReviewPaginatedSchema> {
+    return this.reviewPaginatedSchema.parse(data);
+  }
+
+  public parseReviewFromCommercetools(
+    _context: RequestContext,
+    review: CTReview,
+    productKey: string,
+  ): z.output<TReviewSchema> {
+    return this.reviewSchema.parse({
+      identifier: {
+        key: review.key || '',
+      },
+      product: {
+        key: productKey,
+      },
+      authorName: review.authorName ?? 'Anonymous',
+      authorId: review.customer?.id,
+      rating: review.rating ?? 0,
+      title: review.title ?? '',
+      content: review.text ?? '',
+      createdAt: review.createdAt,
+      updatedAt: review.lastModifiedAt,
+      verified: !!review.customer,
+    } satisfies ProductReview);
+  }
+}