@reactionary/commercetools 0.6.3

package/factories/product/product.factory.js

@@ -0,0 +1,151 @@
+import {
+  ImageSchema,
+  ProductAttributeIdentifierSchema,
+  ProductAttributeSchema,
+  ProductAttributeValueIdentifierSchema,
+  ProductAttributeValueSchema
+} from "@reactionary/core";
+class CommercetoolsProductFactory {
+  productSchema;
+  // 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) {
+    this.productSchema = productSchema;
+  }
+  parseProduct(context, data) {
+    const identifier = { key: data.key || data.id };
+    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
+    };
+    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
+   */
+  isVariantAttributeAnOption(attr) {
+    return true;
+  }
+  parseVariant(context, variant, product) {
+    const identifier = {
+      sku: variant.sku
+    };
+    const images = [
+      ...(variant.images || []).map(
+        (img) => ImageSchema.parse({
+          sourceUrl: img.url,
+          altText: img.label || "",
+          width: img.dimensions?.w,
+          height: img.dimensions?.h
+        })
+      )
+    ];
+    const options = (variant.attributes ?? []).filter((attr) => this.isVariantAttributeAnOption(attr)).map((attr) => {
+      const attrVal = this.parseAttributeValue(context, attr);
+      const optionIdentifier = {
+        key: attr.name
+      };
+      const option = {
+        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: ""
+    };
+    return result;
+  }
+  parseAttribute(context, attr) {
+    const result = ProductAttributeSchema.parse({
+      identifier: ProductAttributeIdentifierSchema.parse({
+        key: attr.name
+      }),
+      group: "",
+      name: attr.name,
+      values: [this.parseAttributeValue(context, attr)]
+    });
+    return result;
+  }
+  parseAttributeValue(context, attr) {
+    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
+      }),
+      value: String(attrValue),
+      label: String(attrValue)
+    });
+    return attrVal;
+  }
+}
+export {
+  CommercetoolsProductFactory
+};

package/factories/product/utils.example.js

@@ -0,0 +1,8 @@
+const assertType = (_value) => {
+};
+const assertNotAny = (_value) => {
+};
+export {
+  assertNotAny,
+  assertType
+};

package/factories/product-associations/product-associations.factory.js

@@ -0,0 +1,63 @@
+import {
+  ImageSchema,
+  ProductOptionIdentifierSchema,
+  ProductSearchResultItemVariantSchema,
+  ProductVariantIdentifierSchema,
+  ProductVariantOptionSchema
+} from "@reactionary/core";
+class CommercetoolsProductAssociationsFactory {
+  productAssociationSchema;
+  constructor(productAssociationSchema) {
+    this.productAssociationSchema = productAssociationSchema;
+  }
+  parseAssociation(context, data) {
+    const product = this.parseSearchResultItem(context, data.product);
+    const result = {
+      associationIdentifier: {
+        key: `${data.sourceProductKey}-${data.relation}-${product.identifier.key}`
+      },
+      associationReturnType: "productSearchResultItem",
+      product
+    };
+    return this.productAssociationSchema.parse(result);
+  }
+  parseSearchResultItem(context, data) {
+    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
+    };
+  }
+  parseVariant(context, variant, product) {
+    const sourceImage = variant.images?.[0];
+    const image = ImageSchema.parse({
+      sourceUrl: sourceImage?.url || "",
+      height: sourceImage?.dimensions.h || void 0,
+      width: sourceImage?.dimensions.w || void 0,
+      altText: sourceImage?.label || product.name[context.languageContext.locale] || void 0
+    });
+    const mappedOptions = variant.attributes?.filter((attribute) => attribute.name === "Color").map(
+      (option) => ProductVariantOptionSchema.parse({
+        identifier: ProductOptionIdentifierSchema.parse({
+          key: option.name
+        }),
+        name: option.value || ""
+      })
+    ) || [];
+    const mappedOption = mappedOptions?.[0];
+    return ProductSearchResultItemVariantSchema.parse({
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: variant.sku || ""
+      }),
+      image,
+      options: mappedOption
+    });
+  }
+}
+export {
+  CommercetoolsProductAssociationsFactory
+};

package/factories/product-list/product-list.factory.js

@@ -0,0 +1,65 @@
+import {
+} from "@reactionary/core";
+class CommercetoolsProductListFactory {
+  productListSchema;
+  productListItemSchema;
+  productListPaginatedSchema;
+  productListItemPaginatedSchema;
+  constructor(productListSchema, productListItemSchema, productListPaginatedSchema, productListItemPaginatedSchema) {
+    this.productListSchema = productListSchema;
+    this.productListItemSchema = productListItemSchema;
+    this.productListPaginatedSchema = productListPaginatedSchema;
+    this.productListItemPaginatedSchema = productListItemPaginatedSchema;
+  }
+  parseProductList(_context, data) {
+    return this.productListSchema.parse(data);
+  }
+  parseProductListItem(_context, data) {
+    return this.productListItemSchema.parse(data);
+  }
+  parseProductListPaginatedResult(_context, data) {
+    return this.productListPaginatedSchema.parse(data);
+  }
+  parseProductListItemPaginatedResult(_context, data) {
+    return this.productListItemPaginatedSchema.parse(data);
+  }
+  parseListFromCommercetools(list) {
+    const listType = list.custom?.fields["listType"] || "favorite";
+    const image = list.custom?.fields["imageUrl"];
+    const published = list.custom?.fields["published"] && true;
+    const publishDateValue = list.custom?.fields["publishedDate"];
+    const publishDate = publishDateValue ? new Date(publishDateValue).toISOString() : void 0;
+    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"
+      }
+    });
+  }
+  parseListItemFromCommercetools(listIdentifier, lineItem) {
+    return this.productListItemSchema.parse({
+      identifier: {
+        list: listIdentifier,
+        key: lineItem.id
+      },
+      variant: {
+        sku: lineItem.variant?.sku || ""
+      },
+      quantity: lineItem.quantity,
+      notes: lineItem.custom?.fields["notes"] || "",
+      order: lineItem.custom?.fields["order"] || 1
+    });
+  }
+}
+export {
+  CommercetoolsProductListFactory
+};

package/factories/product-reviews/product-reviews.factory.js

@@ -0,0 +1,42 @@
+import {
+} from "@reactionary/core";
+class CommercetoolsProductReviewsFactory {
+  ratingSummarySchema;
+  reviewSchema;
+  reviewPaginatedSchema;
+  constructor(ratingSummarySchema, reviewSchema, reviewPaginatedSchema) {
+    this.ratingSummarySchema = ratingSummarySchema;
+    this.reviewSchema = reviewSchema;
+    this.reviewPaginatedSchema = reviewPaginatedSchema;
+  }
+  parseRatingSummary(_context, data) {
+    return this.ratingSummarySchema.parse(data);
+  }
+  parseReview(_context, data) {
+    return this.reviewSchema.parse(data);
+  }
+  parseReviewPaginatedResult(_context, data) {
+    return this.reviewPaginatedSchema.parse(data);
+  }
+  parseReviewFromCommercetools(_context, review, productKey) {
+    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
+    });
+  }
+}
+export {
+  CommercetoolsProductReviewsFactory
+};

package/factories/product-search/product-search.factory.js

@@ -0,0 +1,114 @@
+import {
+  FacetIdentifierSchema,
+  FacetValueIdentifierSchema,
+  ImageSchema,
+  ProductOptionIdentifierSchema,
+  ProductSearchResultFacetSchema,
+  ProductSearchResultFacetValueSchema,
+  ProductSearchResultItemVariantSchema,
+  ProductVariantIdentifierSchema,
+  ProductVariantOptionSchema
+} from "@reactionary/core";
+class CommercetoolsProductSearchFactory {
+  productSearchResultSchema;
+  constructor(productSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+  parseSearchResult(context, data, query) {
+    const identifier = {
+      ...query.search
+    };
+    const items = data.results.map(
+      (product) => this.parseSingle(context, product.productProjection)
+    );
+    const facets = [];
+    for (const facet of data.facets) {
+      const facetIdentifier = FacetIdentifierSchema.parse({
+        key: facet.name
+      });
+      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
+    };
+    return this.productSearchResultSchema.parse(result);
+  }
+  parseSingle(context, data) {
+    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
+    };
+    return result;
+  }
+  parseFacet(facetIdentifier, facet) {
+    const result = ProductSearchResultFacetSchema.parse({
+      identifier: facetIdentifier,
+      name: facet.name,
+      values: []
+    });
+    const distinctFacet = facet;
+    for (const bucket of distinctFacet.buckets || []) {
+      const facetValueIdentifier = FacetValueIdentifierSchema.parse({
+        facet: facetIdentifier,
+        key: bucket.key
+      });
+      result.values.push(
+        this.parseFacetValue(facetValueIdentifier, bucket.key, bucket.count)
+      );
+    }
+    return result;
+  }
+  parseFacetValue(facetValueIdentifier, label, count) {
+    return ProductSearchResultFacetValueSchema.parse({
+      identifier: facetValueIdentifier,
+      name: label,
+      count,
+      active: false
+    });
+  }
+  parseVariant(context, variant, product) {
+    const sourceImage = variant.images?.[0];
+    const image = ImageSchema.parse({
+      sourceUrl: sourceImage?.url || "",
+      height: sourceImage?.dimensions.h || void 0,
+      width: sourceImage?.dimensions.w || void 0,
+      altText: sourceImage?.label || product.name[context.languageContext.locale] || void 0
+    });
+    const mappedOptions = variant.attributes?.filter((attribute) => attribute.name === "Color").map(
+      (option) => ProductVariantOptionSchema.parse({
+        identifier: ProductOptionIdentifierSchema.parse({
+          key: option.name
+        }),
+        name: option.value || ""
+      })
+    ) || [];
+    const mappedOption = mappedOptions?.[0];
+    return ProductSearchResultItemVariantSchema.parse({
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: variant.sku || ""
+      }),
+      image,
+      options: mappedOption
+    });
+  }
+}
+export {
+  CommercetoolsProductSearchFactory
+};

package/factories/profile/profile.factory.js

@@ -0,0 +1,62 @@
+import {
+} from "@reactionary/core";
+class CommercetoolsProfileFactory {
+  profileSchema;
+  constructor(profileSchema) {
+    this.profileSchema = profileSchema;
+  }
+  parseProfile(_context, data) {
+    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 = void 0;
+    }
+    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) : void 0;
+    const shippingAddress = defaultShipping ? this.parseAddress(defaultShipping) : void 0;
+    const result = {
+      identifier: {
+        userId: data.id
+      },
+      email,
+      emailVerified,
+      alternateShippingAddresses,
+      billingAddress,
+      shippingAddress,
+      createdAt: data.createdAt,
+      phone,
+      phoneVerified: false,
+      updatedAt: data.lastModifiedAt
+    };
+    return this.profileSchema.parse(result);
+  }
+  parseAddress(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
+    };
+  }
+  isIncompleteAddress(address) {
+    if (!address) {
+      return false;
+    }
+    return !address.firstName && !address.lastName && !address.streetName && !address.streetNumber && !address.city;
+  }
+}
+export {
+  CommercetoolsProfileFactory
+};

package/factories/store/store.factory.js

@@ -0,0 +1,29 @@
+import {
+} from "@reactionary/core";
+class CommercetoolsStoreFactory {
+  storeSchema;
+  constructor(storeSchema) {
+    this.storeSchema = storeSchema;
+  }
+  parseStore(_context, data) {
+    let name = "";
+    if (data.name && data.name["la"]) {
+      name = data.name["la"];
+    }
+    const identifier = {
+      key: data.key || ""
+    };
+    const fulfillmentCenter = {
+      key: data.key || ""
+    };
+    const result = {
+      identifier,
+      fulfillmentCenter,
+      name
+    };
+    return this.storeSchema.parse(result);
+  }
+}
+export {
+  CommercetoolsStoreFactory
+};

package/index.js

@@ -0,0 +1,28 @@
+export * from "./core/client.js";
+export * from "./core/initialize.js";
+export * from "./capabilities/cart.capability.js";
+export * from "./capabilities/identity.capability.js";
+export * from "./capabilities/inventory.capability.js";
+export * from "./capabilities/order-search.capability.js";
+export * from "./capabilities/price.capability.js";
+export * from "./capabilities/product-associations.capability.js";
+export * from "./capabilities/product.capability.js";
+export * from "./capabilities/product-reviews.capability.js";
+export * from "./capabilities/product-search.capability.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";

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@reactionary/commercetools",
+  "version": "0.6.3",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "vitest": "^4.0.9",
+    "@nx/vite": "22.4.5",
+    "@reactionary/core": "0.6.3",
+    "zod": "4.1.9",
+    "@commercetools/ts-client": "^4.9.1",
+    "@commercetools/platform-sdk": "^8.25.0",
+    "debug": "^4.4.3"
+  },
+  "sideEffects": false
+}

package/schema/capabilities.schema.js

@@ -0,0 +1,46 @@
+import { CapabilitiesSchema } from "@reactionary/core";
+import * as z from "zod";
+const EnabledCapabilitySchema = z.looseObject({
+  enabled: z.boolean()
+});
+const OverridableCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  capability: z.unknown().optional()
+});
+const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
+  product: true,
+  productSearch: true,
+  productAssociations: true,
+  productReviews: true,
+  productList: true,
+  identity: true,
+  cart: true,
+  checkout: true,
+  order: true,
+  orderSearch: true,
+  inventory: true,
+  price: true,
+  category: true,
+  store: true,
+  profile: true
+}).extend({
+  productSearch: EnabledCapabilitySchema.optional(),
+  productAssociations: EnabledCapabilitySchema.optional(),
+  productReviews: EnabledCapabilitySchema.optional(),
+  productList: EnabledCapabilitySchema.optional(),
+  identity: EnabledCapabilitySchema.optional(),
+  cart: EnabledCapabilitySchema.optional(),
+  order: EnabledCapabilitySchema.optional(),
+  orderSearch: EnabledCapabilitySchema.optional(),
+  inventory: EnabledCapabilitySchema.optional(),
+  price: EnabledCapabilitySchema.optional(),
+  category: EnabledCapabilitySchema.optional(),
+  store: EnabledCapabilitySchema.optional(),
+  profile: EnabledCapabilitySchema.optional(),
+  product: OverridableCapabilitySchema.optional(),
+  checkout: OverridableCapabilitySchema.optional()
+}).partial();
+export {
+  CommercetoolsCapabilitiesSchema
+};

package/schema/commercetools.schema.js

@@ -0,0 +1,30 @@
+import { BaseModelSchema, CartIdentifierSchema, CategoryIdentifierSchema, CheckoutIdentifierSchema, OrderIdentifierSchema } from "@reactionary/core";
+import * as z from "zod";
+const CommercetoolsCartIdentifierSchema = CartIdentifierSchema.extend({
+  version: z.number().default(0)
+});
+const CommercetoolsOrderIdentifierSchema = OrderIdentifierSchema.extend({
+  version: z.number().default(0)
+});
+const CommercetoolsCheckoutIdentifierSchema = CheckoutIdentifierSchema.extend({
+  version: z.number().default(0)
+});
+const CommercetoolsResolveCategoryQueryByKeySchema = z.object({
+  key: z.string().meta({ description: "The key of the category to resolve." })
+});
+const CommercetoolsResolveCategoryQueryByIdSchema = z.object({
+  id: z.string().meta({ description: "The ID of the category to resolve." })
+});
+const CommercetoolsCategoryLookupSchema = BaseModelSchema.extend({
+  id: z.string(),
+  key: z.string().optional(),
+  name: z.record(z.string(), z.string())
+});
+export {
+  CommercetoolsCartIdentifierSchema,
+  CommercetoolsCategoryLookupSchema,
+  CommercetoolsCheckoutIdentifierSchema,
+  CommercetoolsOrderIdentifierSchema,
+  CommercetoolsResolveCategoryQueryByIdSchema,
+  CommercetoolsResolveCategoryQueryByKeySchema
+};

package/schema/configuration.schema.js

@@ -0,0 +1,19 @@
+import * as z from "zod";
+import { PaymentMethodSchema } from "@reactionary/core";
+const CommercetoolsConfigurationSchema = z.looseObject({
+  projectKey: z.string(),
+  authUrl: z.string(),
+  apiUrl: z.string(),
+  clientId: z.string(),
+  clientSecret: z.string(),
+  scopes: z.array(z.string()).default(() => []),
+  adminClientId: z.string().optional(),
+  adminClientSecret: z.string().optional(),
+  paymentMethods: PaymentMethodSchema.array().optional().default(() => []),
+  facetFieldsForSearch: z.array(z.string()).default(() => []),
+  listPriceChannelKey: z.string().optional(),
+  customerPriceChannelKey: z.string().optional()
+});
+export {
+  CommercetoolsConfigurationSchema
+};