@reactionary/source 0.3.18 → 0.6.2

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

@@ -0,0 +1,76 @@
+import type { Price as CTPrice, ProductVariant as CTProductVariant } from '@commercetools/platform-sdk';
+import type {
+  PriceSchema} from '@reactionary/core';
+import {
+  type AnyPriceSchema,
+  type Currency,
+  type MonetaryAmount,
+  type Price,
+  type PriceFactory,
+  type PriceIdentifier,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsPriceFactory<
+  TPriceSchema extends AnyPriceSchema = typeof PriceSchema,
+> implements PriceFactory<TPriceSchema>
+{
+  public readonly priceSchema: TPriceSchema;
+
+  constructor(priceSchema: TPriceSchema) {
+    this.priceSchema = priceSchema;
+  }
+
+  public parsePrice(
+    context: RequestContext,
+    data: CTProductVariant,
+    options = { includeDiscounts: false },
+  ): z.output<TPriceSchema> {
+    const price = data.price as CTPrice | undefined;
+
+    if (!price) {
+      return this.priceSchema.parse({
+        identifier: {
+          variant: {
+            sku: data.sku || '',
+          },
+        },
+        onSale: false,
+        tieredPrices: [],
+        unitPrice: {
+          value: -1,
+          currency: context.languageContext.currencyCode,
+        },
+      } satisfies Price);
+    }
+
+    let unitPrice = {
+      value: price.value.centAmount / 100,
+      currency: price.value.currencyCode as Currency,
+    } satisfies MonetaryAmount;
+
+    if (options.includeDiscounts) {
+      const discountedPrice = price.discounted?.value || price.value;
+      unitPrice = {
+        value: discountedPrice.centAmount / 100,
+        currency: price.value.currencyCode as Currency,
+      } satisfies MonetaryAmount;
+    }
+
+    const identifier = {
+      variant: {
+        sku: data.sku || '',
+      },
+    } satisfies PriceIdentifier;
+
+    const result = {
+      identifier,
+      onSale: options.includeDiscounts && !!price.discounted,
+      tieredPrices: [],
+      unitPrice,
+    } satisfies Price;
+
+    return this.priceSchema.parse(result);
+  }
+}

package/providers/commercetools/src/factories/product/product-factory-baseline.example.ts

@@ -0,0 +1,14 @@
+import { ProductSchema } from "@reactionary/core";
+import { CommercetoolsProductFactory } from "./product.factory.js";
+import { assertNotAny, assertType } from "./utils.example.js";
+
+const context = {} as any;
+
+const baseFactory = new CommercetoolsProductFactory(ProductSchema);
+const baseProduct = baseFactory.parseProduct(context, {} as any);
+
+assertNotAny(baseProduct);
+assertNotAny(baseProduct.name);
+assertType<string>(baseProduct.name);
+// @ts-expect-error base schema does not include extendedValue
+assertType<string>(baseProduct.extendedValue);

package/providers/commercetools/src/factories/product/product-factory-schema-and-parse-extension.example.ts

@@ -0,0 +1,35 @@
+import { ProductSchema } from "@reactionary/core";
+import type { RequestContext } from "@reactionary/core";
+import type { ProductProjection } from "@commercetools/platform-sdk";
+import { CommercetoolsProductFactory } from "./product.factory.js";
+import * as z from "zod";
+import { assertNotAny, assertType } from "./utils.example.js";
+
+const context = {} as any;
+
+const ExtendedProductSchema = ProductSchema.safeExtend({
+  extendedValue: z.string(),
+});
+
+class ExtendedCommercetoolsProductFactory extends CommercetoolsProductFactory<typeof ExtendedProductSchema> {
+  constructor() {
+    super(ExtendedProductSchema);
+  }
+
+  public override parseProduct(context: RequestContext, data: ProductProjection) {
+    const base = super.parseProduct(context, data);
+
+    // PAIN: Needing the satisfies here - possibly unavoidable
+    return {
+      ...base,
+      extendedValue: "from-parse",
+    } satisfies z.output<typeof ExtendedProductSchema>;
+  }
+}
+
+const extendedFactory = new ExtendedCommercetoolsProductFactory();
+const extendedProduct = extendedFactory.parseProduct(context, {} as any);
+
+assertNotAny(extendedProduct);
+assertNotAny(extendedProduct.extendedValue);
+assertType<string>(extendedProduct.extendedValue);

package/providers/commercetools/src/factories/product/product-factory-schema-extension.example.ts

@@ -0,0 +1,23 @@
+import { ProductSchema } from "@reactionary/core";
+import { CommercetoolsProductFactory } from "./product.factory.js";
+import * as z from "zod";
+import { assertNotAny, assertType } from "./utils.example.js";
+
+const context = {} as any;
+
+const ExtendedProductSchema = ProductSchema.safeExtend({
+  extendedValue: z.string(),
+});
+
+class ExtendedCommercetoolsProductFactory extends CommercetoolsProductFactory<typeof ExtendedProductSchema> {
+  constructor() {
+    super(ExtendedProductSchema);
+  }
+}
+
+const extendedFactory = new ExtendedCommercetoolsProductFactory();
+const extendedProduct = extendedFactory.parseProduct(context, {} as any);
+
+assertNotAny(extendedProduct);
+assertNotAny(extendedProduct.extendedValue);
+assertType<string>(extendedProduct.extendedValue);

package/providers/commercetools/src/factories/product/product-initializer-factory-extension.example.ts

@@ -0,0 +1,41 @@
+import { ProductSchema } from "@reactionary/core";
+import { CommercetoolsProductFactory } from "./product.factory.js";
+import { withCommercetoolsCapabilities } from "../../core/initialize.js";
+import * as z from "zod";
+import { assertNotAny, assertType } from "./utils.example.js";
+
+const cache = {} as any;
+const context = {} as any;
+const config = {} as any;
+
+const ExtendedProductSchema = ProductSchema.safeExtend({
+  extendedValue: z.string(),
+});
+
+class ExtendedCommercetoolsProductFactory extends CommercetoolsProductFactory<typeof ExtendedProductSchema> {
+  constructor() {
+    super(ExtendedProductSchema);
+  }
+}
+
+const capabilityFactory = withCommercetoolsCapabilities(config, {
+  product: {
+    enabled: true,
+    factory: new ExtendedCommercetoolsProductFactory(),
+  },
+});
+
+const client = capabilityFactory(cache, context);
+
+client.product
+  .getById({
+    identifier: { key: "p-1" },
+  })
+  .then((x) => {
+    assertNotAny(x);
+    if (x.success) {
+      assertNotAny(x.value);
+      assertNotAny(x.value.extendedValue);
+      assertType<string>(x.value.extendedValue);
+    }
+  });

package/providers/commercetools/src/factories/product/product-provider-custom-method-only.example.ts

@@ -0,0 +1,47 @@
+import { ProductSchema } from "@reactionary/core";
+import type { ProductFactoryOutput, Result } from "@reactionary/core";
+import { CommercetoolsProductFactory } from "./product.factory.js";
+import { CommercetoolsProductProvider } from "../../providers/product.provider.js";
+import { withCommercetoolsCapabilities } from "../../core/initialize.js";
+import { assertNotAny, assertType } from "./utils.example.js";
+
+const cache = {} as any;
+const context = {} as any;
+const config = {} as any;
+const api = {} as any;
+
+class ExtendedCommercetoolsProductProvider extends CommercetoolsProductProvider<CommercetoolsProductFactory> {
+  public async getByCustomIdentifier(
+    identifier: string
+  ): Promise<Result<ProductFactoryOutput<CommercetoolsProductFactory>>> {
+    return this.getById({
+      identifier: { key: identifier },
+    });
+  }
+}
+
+const withExtendedProviderFactory = withCommercetoolsCapabilities(config, {
+  product: {
+    enabled: true,
+    factory: new CommercetoolsProductFactory(ProductSchema),
+    provider: ({ cache, context, config, commercetoolsApi }) =>
+      new ExtendedCommercetoolsProductProvider(
+        cache,
+        context,
+        config,
+        commercetoolsApi,
+        new CommercetoolsProductFactory(ProductSchema)
+      ),
+  },
+});
+
+const client = withExtendedProviderFactory(cache, context);
+
+client.product.getByCustomIdentifier("p-2").then((x) => {
+  assertNotAny(x);
+  if (x.success) {
+    assertNotAny(x.value);
+    assertNotAny(x.value.name);
+    assertType<string>(x.value.name);
+  }
+});

package/providers/commercetools/src/factories/product/product-provider-schema-signature-extension.example.ts

@@ -0,0 +1,61 @@
+import { ProductQueryByIdSchema, ProductSchema } from "@reactionary/core";
+import type {
+  ProductFactoryOutput,
+  ProductQueryById as BaseProductQueryById,
+  Result,
+} from "@reactionary/core";
+import { CommercetoolsProductFactory } from "./product.factory.js";
+import { CommercetoolsProductProvider } from "../../providers/product.provider.js";
+import * as z from "zod";
+import { assertNotAny, assertType } from "./utils.example.js";
+
+const cache = {} as any;
+const context = {} as any;
+const config = {} as any;
+const api = {} as any;
+
+const ExtendedProductSchema = ProductSchema.safeExtend({
+  extendedValue: z.string(),
+});
+
+class ExtendedCommercetoolsProductFactory extends CommercetoolsProductFactory<typeof ExtendedProductSchema> {
+  constructor() {
+    super(ExtendedProductSchema);
+  }
+}
+
+const ExtendedProductQueryByIdSchema = ProductQueryByIdSchema.extend({
+  auditTrail: z.boolean(),
+});
+type ExtendedProductQueryById = z.infer<typeof ExtendedProductQueryByIdSchema>;
+
+class ExtendedCommercetoolsProductProvider extends CommercetoolsProductProvider<ExtendedCommercetoolsProductFactory> {
+  public override async getById(
+    payload: ExtendedProductQueryById
+  ) {
+    const basePayload: BaseProductQueryById = {
+      identifier: payload.identifier,
+    };
+    return super.getById(basePayload);
+  }
+}
+
+const extendedProvider = new ExtendedCommercetoolsProductProvider(
+  cache,
+  context,
+  config,
+  api,
+  new ExtendedCommercetoolsProductFactory()
+);
+
+extendedProvider.getById({
+  identifier: { key: "p-1" },
+  auditTrail: true
+}).then((x) => {
+  assertNotAny(x);
+  if (x.success) {
+    assertNotAny(x.value);
+    assertNotAny(x.value.extendedValue);
+    assertType<string>(x.value.extendedValue);
+  }
+});

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