@reactionary/source 0.3.18 → 0.6.2

package/providers/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/providers/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);
+  }
+}

package/providers/commercetools/src/factories/product-search/product-search.factory.ts

@@ -0,0 +1,182 @@
+import type {
+  ProductPagedSearchResponse,
+  ProductProjection,
+  ProductSearchFacetResult as CTProductSearchFacetResult,
+  ProductSearchFacetResultBucket as CTProductSearchFacetResultBucket,
+  ProductVariant as CTProductVariant,
+} from '@commercetools/platform-sdk';
+import type {
+  ProductSearchResultSchema} from '@reactionary/core';
+import {
+  FacetIdentifierSchema,
+  FacetValueIdentifierSchema,
+  ImageSchema,
+  ProductOptionIdentifierSchema,
+  ProductSearchResultFacetSchema,
+  ProductSearchResultFacetValueSchema,
+  ProductSearchResultItemVariantSchema,
+  ProductVariantIdentifierSchema,
+  ProductVariantOptionSchema,
+  type AnyProductSearchResultSchema,
+  type FacetIdentifier,
+  type FacetValueIdentifier,
+  type ProductOptionIdentifier,
+  type ProductSearchFactory,
+  type ProductSearchQueryByTerm,
+  type ProductSearchResult,
+  type ProductSearchResultFacet,
+  type ProductSearchResultFacetValue,
+  type ProductSearchResultItem,
+  type ProductSearchResultItemVariant,
+  type ProductVariantIdentifier,
+  type ProductVariantOption,
+  type RequestContext,
+  type SearchIdentifier,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsProductSearchFactory<
+  TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof ProductSearchResultSchema,
+> implements ProductSearchFactory<TProductSearchResultSchema>
+{
+  public readonly productSearchResultSchema: TProductSearchResultSchema;
+
+  constructor(productSearchResultSchema: TProductSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+
+  public parseSearchResult(
+    context: RequestContext,
+    data: ProductPagedSearchResponse,
+    query: ProductSearchQueryByTerm,
+  ): z.output<TProductSearchResultSchema> {
+    const identifier = {
+      ...query.search,
+    } satisfies SearchIdentifier;
+
+    const items: ProductSearchResultItem[] = data.results.map((product) =>
+      this.parseSingle(context, product.productProjection!),
+    );
+    const facets: ProductSearchResultFacet[] = [];
+
+    for (const facet of data.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(data.offset / data.limit) || 0) + 1,
+      pageSize: data.limit,
+      totalCount: data.total || 0,
+      totalPages: Math.ceil((data.total || 0) / data.limit || 0) + 1,
+      items,
+      facets,
+    } satisfies ProductSearchResult;
+
+    return this.productSearchResultSchema.parse(result);
+  }
+
+  protected parseSingle(
+    context: RequestContext,
+    data: ProductProjection,
+  ): ProductSearchResultItem {
+    const identifier = { key: data.id };
+    const name = data.name[context.languageContext.locale] || data.id;
+    const slug = data.slug?.[context.languageContext.locale] || data.id;
+    const variants = [data.masterVariant, ...data.variants].map((variant) =>
+      this.parseVariant(context, variant, data),
+    );
+
+    const result = {
+      identifier,
+      name,
+      slug,
+      variants,
+    } satisfies ProductSearchResultItem;
+
+    return result;
+  }
+
+  protected parseFacet(
+    facetIdentifier: FacetIdentifier,
+    facet: CTProductSearchFacetResult,
+  ): ProductSearchResultFacet {
+    const result: ProductSearchResultFacet = ProductSearchResultFacetSchema.parse({
+      identifier: facetIdentifier,
+      name: facet.name,
+      values: [],
+    });
+
+    const distinctFacet = facet as CTProductSearchFacetResultBucket;
+    for (const bucket of distinctFacet.buckets || []) {
+      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,
+      active: false,
+    } satisfies Partial<ProductSearchResultFacetValue>);
+  }
+
+  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/providers/commercetools/src/factories/profile/profile.factory.ts

@@ -0,0 +1,94 @@
+import type { Address as CTAddress, Customer } from '@commercetools/platform-sdk';
+import type {
+  ProfileSchema} from '@reactionary/core';
+import {
+  type Address,
+  type AnyProfileSchema,
+  type Profile,
+  type ProfileFactory,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsProfileFactory<
+  TProfileSchema extends AnyProfileSchema = typeof ProfileSchema,
+> implements ProfileFactory<TProfileSchema>
+{
+  public readonly profileSchema: TProfileSchema;
+
+  constructor(profileSchema: TProfileSchema) {
+    this.profileSchema = profileSchema;
+  }
+
+  public parseProfile(
+    _context: RequestContext,
+    data: Customer,
+  ): z.output<TProfileSchema> {
+    const email = data.email;
+    const emailVerified = data.isEmailVerified;
+    let defaultBilling = data.addresses.find((address) => address.id === data.defaultBillingAddressId);
+    const phone = defaultBilling?.phone ?? '';
+
+    if (this.isIncompleteAddress(defaultBilling)) {
+      defaultBilling = undefined;
+    }
+
+    const defaultShipping = data.addresses.find(
+      (address) => address.id === data.defaultShippingAddressId,
+    );
+
+    const alternateShippingAddresses = data.addresses
+      .filter((address) => address.id !== data.defaultBillingAddressId)
+      .filter((address) => address.id !== data.defaultShippingAddressId)
+      .map((address) => this.parseAddress(address));
+
+    const billingAddress = defaultBilling ? this.parseAddress(defaultBilling) : undefined;
+    const shippingAddress = defaultShipping ? this.parseAddress(defaultShipping) : undefined;
+
+    const result = {
+      identifier: {
+        userId: data.id,
+      },
+      email,
+      emailVerified,
+      alternateShippingAddresses,
+      billingAddress,
+      shippingAddress,
+      createdAt: data.createdAt,
+      phone,
+      phoneVerified: false,
+      updatedAt: data.lastModifiedAt,
+    } satisfies Profile;
+
+    return this.profileSchema.parse(result);
+  }
+
+  protected parseAddress(address: CTAddress): Address {
+    return {
+      identifier: {
+        nickName: address.key || '',
+      },
+      firstName: address.firstName || '',
+      lastName: address.lastName || '',
+      streetAddress: address.streetName || '',
+      streetNumber: address.streetNumber || '',
+      city: address.city || '',
+      region: address.region || '',
+      postalCode: address.postalCode || '',
+      countryCode: address.country,
+    } satisfies Address;
+  }
+
+  protected isIncompleteAddress(address: CTAddress | undefined): boolean {
+    if (!address) {
+      return false;
+    }
+    return (
+      !address.firstName &&
+      !address.lastName &&
+      !address.streetName &&
+      !address.streetNumber &&
+      !address.city
+    );
+  }
+}

package/providers/commercetools/src/factories/store/store.factory.ts

@@ -0,0 +1,49 @@
+import type { Channel } from '@commercetools/platform-sdk';
+import type {
+  StoreSchema} from '@reactionary/core';
+import {
+  type AnyStoreSchema,
+  type FulfillmentCenterIdentifier,
+  type RequestContext,
+  type Store,
+  type StoreFactory,
+  type StoreIdentifier,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsStoreFactory<
+  TStoreSchema extends AnyStoreSchema = typeof StoreSchema,
+> implements StoreFactory<TStoreSchema>
+{
+  public readonly storeSchema: TStoreSchema;
+
+  constructor(storeSchema: TStoreSchema) {
+    this.storeSchema = storeSchema;
+  }
+
+  public parseStore(
+    _context: RequestContext,
+    data: Channel,
+  ): z.output<TStoreSchema> {
+    let name = '';
+    if (data.name && data.name['la']) {
+      name = data.name['la'];
+    }
+
+    const identifier = {
+      key: data.key || '',
+    } satisfies StoreIdentifier;
+
+    const fulfillmentCenter = {
+      key: data.key || '',
+    } satisfies FulfillmentCenterIdentifier;
+
+    const result = {
+      identifier,
+      fulfillmentCenter,
+      name,
+    } satisfies Store;
+
+    return this.storeSchema.parse(result);
+  }
+}

package/providers/commercetools/src/index.ts

@@ -10,6 +10,21 @@ export * from './providers/product-associations.provider.js';
 export * from './providers/product.provider.js';
 export * from './providers/product-reviews.provider.js';
 export * from './providers/product-search.provider.js';
+export * from './factories/product/product.factory.js';
+export * from './factories/checkout/checkout.factory.js';
+export * from './factories/product-search/product-search.factory.js';
+export * from './factories/inventory/inventory.factory.js';
+export * from './factories/price/price.factory.js';
+export * from './factories/store/store.factory.js';
+export * from './factories/order/order.factory.js';
+export * from './factories/category/category.factory.js';
+export * from './factories/cart/cart.factory.js';
+export * from './factories/profile/profile.factory.js';
+export * from './factories/order-search/order-search.factory.js';
+export * from './factories/product-associations/product-associations.factory.js';
+export * from './factories/product-reviews/product-reviews.factory.js';
+export * from './factories/product-list/product-list.factory.js';
+export * from './factories/identity/identity.factory.js';
 
 export * from './schema/capabilities.schema.js';
 export * from './schema/configuration.schema.js';