@reactionary/provider-commercetools 0.3.18 → 0.6.2

package/core/capability-descriptors.js

@@ -0,0 +1,274 @@
+import {
+  CartIdentifierSchema,
+  CartSchema,
+  CategoryPaginatedResultSchema,
+  CategorySchema,
+  CheckoutSchema,
+  IdentitySchema,
+  InventorySchema,
+  OrderSearchResultSchema,
+  OrderSchema,
+  PaymentMethodSchema,
+  ProductAssociationSchema,
+  ProductListItemPaginatedResultsSchema,
+  ProductListItemSchema,
+  ProductListPaginatedResultsSchema,
+  ProductListSchema,
+  ProductRatingSummarySchema,
+  ProductReviewPaginatedResultSchema,
+  ProductReviewSchema,
+  ProductSchema,
+  ProductSearchResultSchema,
+  ProfileSchema,
+  PriceSchema,
+  ShippingMethodSchema,
+  StoreSchema
+} from "@reactionary/core";
+import {
+} from "../schema/capabilities.schema.js";
+import { CommercetoolsCartFactory } from "../factories/cart/cart.factory.js";
+import { CommercetoolsCategoryFactory } from "../factories/category/category.factory.js";
+import { CommercetoolsCheckoutFactory } from "../factories/checkout/checkout.factory.js";
+import { CommercetoolsIdentityFactory } from "../factories/identity/identity.factory.js";
+import { CommercetoolsInventoryFactory } from "../factories/inventory/inventory.factory.js";
+import { CommercetoolsOrderFactory } from "../factories/order/order.factory.js";
+import { CommercetoolsOrderSearchFactory } from "../factories/order-search/order-search.factory.js";
+import { CommercetoolsPriceFactory } from "../factories/price/price.factory.js";
+import { CommercetoolsProductAssociationsFactory } from "../factories/product-associations/product-associations.factory.js";
+import { CommercetoolsProductListFactory } from "../factories/product-list/product-list.factory.js";
+import { CommercetoolsProductFactory } from "../factories/product/product.factory.js";
+import { CommercetoolsProductReviewsFactory } from "../factories/product-reviews/product-reviews.factory.js";
+import { CommercetoolsProductSearchFactory } from "../factories/product-search/product-search.factory.js";
+import { CommercetoolsProfileFactory } from "../factories/profile/profile.factory.js";
+import { CommercetoolsStoreFactory } from "../factories/store/store.factory.js";
+import { CommercetoolsCartProvider } from "../providers/cart.provider.js";
+import { CommercetoolsCategoryProvider } from "../providers/category.provider.js";
+import { CommercetoolsCheckoutProvider } from "../providers/checkout.provider.js";
+import { CommercetoolsIdentityProvider } from "../providers/identity.provider.js";
+import { CommercetoolsInventoryProvider } from "../providers/inventory.provider.js";
+import { CommercetoolsOrderProvider } from "../providers/order.provider.js";
+import { CommercetoolsOrderSearchProvider } from "../providers/order-search.provider.js";
+import { CommercetoolsPriceProvider } from "../providers/price.provider.js";
+import { CommercetoolsProductAssociationsProvider } from "../providers/product-associations.provider.js";
+import { CommercetoolsProductListProvider } from "../providers/product-list.provider.js";
+import { CommercetoolsProductProvider } from "../providers/product.provider.js";
+import { CommercetoolsProductReviewsProvider } from "../providers/product-reviews.provider.js";
+import { CommercetoolsSearchProvider } from "../providers/product-search.provider.js";
+import { CommercetoolsProfileProvider } from "../providers/profile.provider.js";
+import { CommercetoolsStoreProvider } from "../providers/store.provider.js";
+const capabilityKeys = [
+  "product",
+  "profile",
+  "productSearch",
+  "productAssociations",
+  "productList",
+  "productReviews",
+  "identity",
+  "cart",
+  "inventory",
+  "price",
+  "category",
+  "checkout",
+  "store",
+  "order",
+  "orderSearch"
+];
+const capabilityDescriptors = {
+  product: {
+    isEnabled: (caps) => caps.product?.enabled,
+    getOverride: (caps) => caps.product,
+    createDefaultFactory: () => new CommercetoolsProductFactory(ProductSchema),
+    createDefaultProvider: (args) => new CommercetoolsProductProvider(
+      args.cache,
+      args.context,
+      args.config,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  profile: {
+    isEnabled: (caps) => caps.profile?.enabled,
+    getOverride: (caps) => caps.profile,
+    createDefaultFactory: () => new CommercetoolsProfileFactory(ProfileSchema),
+    createDefaultProvider: (args) => new CommercetoolsProfileProvider(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  productSearch: {
+    isEnabled: (caps) => caps.productSearch?.enabled,
+    getOverride: (caps) => caps.productSearch,
+    createDefaultFactory: () => new CommercetoolsProductSearchFactory(ProductSearchResultSchema),
+    createDefaultProvider: (args) => new CommercetoolsSearchProvider(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  productAssociations: {
+    isEnabled: (caps) => caps.productAssociations?.enabled,
+    getOverride: (caps) => caps.productAssociations,
+    createDefaultFactory: () => new CommercetoolsProductAssociationsFactory(ProductAssociationSchema),
+    createDefaultProvider: (args) => new CommercetoolsProductAssociationsProvider(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  productList: {
+    isEnabled: (caps) => caps.productList?.enabled,
+    getOverride: (caps) => caps.productList,
+    createDefaultFactory: () => new CommercetoolsProductListFactory(
+      ProductListSchema,
+      ProductListItemSchema,
+      ProductListPaginatedResultsSchema,
+      ProductListItemPaginatedResultsSchema
+    ),
+    createDefaultProvider: (args) => new CommercetoolsProductListProvider(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  productReviews: {
+    isEnabled: (caps) => caps.productReviews?.enabled,
+    getOverride: (caps) => caps.productReviews,
+    createDefaultFactory: () => new CommercetoolsProductReviewsFactory(
+      ProductRatingSummarySchema,
+      ProductReviewSchema,
+      ProductReviewPaginatedResultSchema
+    ),
+    createDefaultProvider: (args) => new CommercetoolsProductReviewsProvider(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  identity: {
+    isEnabled: (caps) => caps.identity?.enabled,
+    getOverride: (caps) => caps.identity,
+    createDefaultFactory: () => new CommercetoolsIdentityFactory(IdentitySchema),
+    createDefaultProvider: (args) => new CommercetoolsIdentityProvider(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  cart: {
+    isEnabled: (caps) => caps.cart?.enabled,
+    getOverride: (caps) => caps.cart,
+    createDefaultFactory: () => new CommercetoolsCartFactory(CartSchema, CartIdentifierSchema),
+    createDefaultProvider: (args) => new CommercetoolsCartProvider(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  inventory: {
+    isEnabled: (caps) => caps.inventory?.enabled,
+    getOverride: (caps) => caps.inventory,
+    createDefaultFactory: () => new CommercetoolsInventoryFactory(InventorySchema),
+    createDefaultProvider: (args) => new CommercetoolsInventoryProvider(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  price: {
+    isEnabled: (caps) => caps.price?.enabled,
+    getOverride: (caps) => caps.price,
+    createDefaultFactory: () => new CommercetoolsPriceFactory(PriceSchema),
+    createDefaultProvider: (args) => new CommercetoolsPriceProvider(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  category: {
+    isEnabled: (caps) => caps.category?.enabled,
+    getOverride: (caps) => caps.category,
+    createDefaultFactory: () => new CommercetoolsCategoryFactory(CategorySchema, CategoryPaginatedResultSchema),
+    createDefaultProvider: (args) => new CommercetoolsCategoryProvider(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  checkout: {
+    isEnabled: (caps) => caps.checkout?.enabled,
+    getOverride: (caps) => caps.checkout,
+    createDefaultFactory: () => new CommercetoolsCheckoutFactory(
+      CheckoutSchema,
+      ShippingMethodSchema,
+      PaymentMethodSchema
+    ),
+    createDefaultProvider: (args) => new CommercetoolsCheckoutProvider(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  store: {
+    isEnabled: (caps) => caps.store?.enabled,
+    getOverride: (caps) => caps.store,
+    createDefaultFactory: () => new CommercetoolsStoreFactory(StoreSchema),
+    createDefaultProvider: (args) => new CommercetoolsStoreProvider(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  order: {
+    isEnabled: (caps) => caps.order?.enabled,
+    getOverride: (caps) => caps.order,
+    createDefaultFactory: () => new CommercetoolsOrderFactory(OrderSchema),
+    createDefaultProvider: (args) => new CommercetoolsOrderProvider(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  orderSearch: {
+    isEnabled: (caps) => caps.orderSearch?.enabled,
+    getOverride: (caps) => caps.orderSearch,
+    createDefaultFactory: () => new CommercetoolsOrderSearchFactory(OrderSearchResultSchema),
+    createDefaultProvider: (args) => new CommercetoolsOrderSearchProvider(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  }
+};
+export {
+  capabilityDescriptors,
+  capabilityKeys
+};

package/core/initialize.js

@@ -1,151 +1,42 @@
 import {
   CommercetoolsCapabilitiesSchema
 } from "../schema/capabilities.schema.js";
-import { CommercetoolsSearchProvider } from "../providers/product-search.provider.js";
-import { CommercetoolsProductProvider } from "../providers/product.provider.js";
 import {
   CommercetoolsConfigurationSchema
 } from "../schema/configuration.schema.js";
-import { CommercetoolsIdentityProvider } from "../providers/identity.provider.js";
-import { CommercetoolsCartProvider } from "../providers/cart.provider.js";
-import { CommercetoolsInventoryProvider } from "../providers/inventory.provider.js";
-import { CommercetoolsPriceProvider } from "../providers/price.provider.js";
-import { CommercetoolsCategoryProvider } from "../providers/category.provider.js";
-import {
-  CommercetoolsCheckoutProvider,
-  CommercetoolsOrderProvider,
-  CommercetoolsOrderSearchProvider,
-  CommercetoolsProfileProvider,
-  CommercetoolsStoreProvider,
-  CommercetoolsProductReviewsProvider,
-  CommercetoolsProductAssociationsProvider,
-  CommercetoolsProductListProvider
-} from "../providers/index.js";
 import { CommercetoolsAPI } from "./client.js";
+import {
+  capabilityDescriptors,
+  capabilityKeys
+} from "./capability-descriptors.js";
+import {
+  resolveCapabilityProvider
+} from "./initialize.types.js";
 function withCommercetoolsCapabilities(configuration, capabilities) {
   return (cache, context) => {
     const client = {};
     const config = CommercetoolsConfigurationSchema.parse(configuration);
     const caps = CommercetoolsCapabilitiesSchema.parse(capabilities);
     const commercetoolsApi = new CommercetoolsAPI(config, context);
-    if (caps.product) {
-      client.product = new CommercetoolsProductProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.profile) {
-      client.profile = new CommercetoolsProfileProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.productSearch) {
-      client.productSearch = new CommercetoolsSearchProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.productAssociations) {
-      client.productAssociations = new CommercetoolsProductAssociationsProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.productList) {
-      client.productList = new CommercetoolsProductListProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.productReviews) {
-      client.productReviews = new CommercetoolsProductReviewsProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.identity) {
-      client.identity = new CommercetoolsIdentityProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.cart) {
-      client.cart = new CommercetoolsCartProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.inventory) {
-      client.inventory = new CommercetoolsInventoryProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.price) {
-      client.price = new CommercetoolsPriceProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.category) {
-      client.category = new CommercetoolsCategoryProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.checkout) {
-      client.checkout = new CommercetoolsCheckoutProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.store) {
-      client.store = new CommercetoolsStoreProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.order) {
-      client.store = new CommercetoolsOrderProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.orderSearch) {
-      client.orderSearch = new CommercetoolsOrderSearchProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
+    const buildProviderArgs = (factory) => ({
+      cache,
+      context,
+      config,
+      commercetoolsApi,
+      factory
+    });
+    for (const key of capabilityKeys) {
+      const descriptor = capabilityDescriptors[key];
+      if (!descriptor.isEnabled(caps)) {
+        continue;
+      }
+      client[key] = resolveCapabilityProvider(
+        descriptor.getOverride(capabilities),
+        {
+          factory: descriptor.createDefaultFactory(),
+          provider: descriptor.createDefaultProvider
+        },
+        buildProviderArgs
       );
     }
     return client;

package/core/initialize.types.js

@@ -0,0 +1,8 @@
+function resolveCapabilityProvider(capability, defaults, buildProviderArgs) {
+  const factory = capability?.factory ?? defaults.factory;
+  const provider = capability?.provider ?? defaults.provider;
+  return provider(buildProviderArgs(factory));
+}
+export {
+  resolveCapabilityProvider
+};

package/factories/cart/cart.factory.js

@@ -0,0 +1,108 @@
+import {
+  CartItemSchema
+} from "@reactionary/core";
+class CommercetoolsCartFactory {
+  constructor(cartSchema, cartIdentifierSchema) {
+    this.cartSchema = cartSchema;
+    this.cartIdentifierSchema = cartIdentifierSchema;
+  }
+  parseCartIdentifier(_context, data) {
+    return this.cartIdentifierSchema.parse({
+      key: data.key || ""
+    });
+  }
+  parseCart(context, data) {
+    const identifier = this.parseCartIdentifier(context, {
+      key: data.id
+    });
+    const grandTotal = data.totalPrice.centAmount || 0;
+    const shippingTotal = data.shippingInfo?.price.centAmount || 0;
+    const productTotal = grandTotal - shippingTotal;
+    const taxTotal = data.taxedPrice?.totalTax?.centAmount || 0;
+    const discountTotal = data.discountOnTotalPrice?.discountedAmount.centAmount || 0;
+    const surchargeTotal = 0;
+    const currency = data.totalPrice.currencyCode;
+    const price = {
+      totalTax: {
+        value: taxTotal / 100,
+        currency
+      },
+      totalDiscount: {
+        value: discountTotal / 100,
+        currency
+      },
+      totalSurcharge: {
+        value: surchargeTotal / 100,
+        currency
+      },
+      totalShipping: {
+        value: shippingTotal / 100,
+        currency
+      },
+      totalProductPrice: {
+        value: productTotal / 100,
+        currency
+      },
+      grandTotal: {
+        value: grandTotal / 100,
+        currency
+      }
+    };
+    const items = [];
+    for (const lineItem of data.lineItems) {
+      items.push(this.parseCartItem(lineItem));
+    }
+    const result = {
+      identifier,
+      userId: {
+        userId: "???"
+      },
+      name: data.custom?.fields["name"] || "",
+      description: data.custom?.fields["description"] || "",
+      price,
+      items,
+      appliedPromotions: []
+    };
+    return this.cartSchema.parse(result);
+  }
+  parseCartItem(lineItem) {
+    const unitPrice = lineItem.price.value.centAmount;
+    const totalPrice = lineItem.totalPrice.centAmount || 0;
+    const totalDiscount = lineItem.price.discounted?.value.centAmount || 0;
+    const unitDiscount = totalDiscount / lineItem.quantity;
+    const currency = lineItem.price.value.currencyCode.toUpperCase();
+    return CartItemSchema.parse({
+      identifier: {
+        key: lineItem.id
+      },
+      product: {
+        key: lineItem.productId
+      },
+      variant: {
+        sku: lineItem.variant.sku || ""
+      },
+      quantity: lineItem.quantity,
+      price: {
+        unitPrice: {
+          value: unitPrice / 100,
+          currency
+        },
+        unitDiscount: {
+          value: unitDiscount / 100,
+          currency
+        },
+        totalPrice: {
+          value: totalPrice / 100,
+          currency
+        },
+        totalDiscount: {
+          value: totalDiscount / 100,
+          currency
+        }
+      }
+    });
+  }
+}
+export {
+  CommercetoolsCartFactory
+};

package/factories/category/category.factory.js

@@ -0,0 +1,38 @@
+import {
+} from "@reactionary/core";
+class CommercetoolsCategoryFactory {
+  constructor(categorySchema, categoryPaginatedResultSchema) {
+    this.categorySchema = categorySchema;
+    this.categoryPaginatedResultSchema = categoryPaginatedResultSchema;
+  }
+  parseCategory(context, data) {
+    const identifier = { key: data.key || "" };
+    const result = {
+      identifier,
+      name: data.name[context.languageContext.locale] || "No Name",
+      slug: data.slug ? data.slug[context.languageContext.locale] || "" : "",
+      text: data.description ? data.description[context.languageContext.locale] || "" : "",
+      parentCategory: data.parent && data.parent.obj && data.parent.obj?.key ? { key: data.parent.obj.key } : void 0,
+      images: (data.assets || []).filter((asset) => asset.sources.length > 0).filter((asset) => asset.sources[0].contentType?.startsWith("image/")).map((asset) => ({
+        sourceUrl: asset.sources[0].uri,
+        altText: asset.description?.[context.languageContext.locale] || asset.name[context.languageContext.locale] || "",
+        height: asset.sources[0].dimensions?.h || 0,
+        width: asset.sources[0].dimensions?.w || 0
+      }))
+    };
+    return this.categorySchema.parse(result);
+  }
+  parseCategoryPaginatedResult(context, data) {
+    const result = {
+      pageNumber: Math.floor(data.offset / data.count) + 1,
+      pageSize: data.count,
+      totalCount: data.total || 0,
+      totalPages: Math.ceil((data.total ?? 0) / data.count),
+      items: data.results.map((category) => this.parseCategory(context, category))
+    };
+    return this.categoryPaginatedResultSchema.parse(result);
+  }
+}
+export {
+  CommercetoolsCategoryFactory
+};

package/factories/checkout/checkout-initializer-overrides.example.js

@@ -0,0 +1,67 @@
+import {
+  CheckoutSchema,
+  PaymentMethodSchema,
+  ShippingMethodSchema,
+  unwrapValue
+} from "@reactionary/core";
+import { withCommercetoolsCapabilities } from "../../core/initialize.js";
+import { CommercetoolsCheckoutProvider } from "../../providers/checkout.provider.js";
+import { assertNotAny, assertType } from "../product/utils.example.js";
+import { CommercetoolsCheckoutFactory } from "./checkout.factory.js";
+import * as z from "zod";
+const cache = {};
+const context = {};
+const config = {};
+const ExtendedCheckoutSchema = CheckoutSchema.safeExtend({
+  extendedValue: z.string().default("")
+});
+class ExtendedCommercetoolsCheckoutFactory extends CommercetoolsCheckoutFactory {
+  constructor() {
+    super(ExtendedCheckoutSchema, ShippingMethodSchema, PaymentMethodSchema);
+  }
+  parseCheckout(context2, data) {
+    const base = super.parseCheckout(context2, data);
+    return {
+      ...base,
+      extendedValue: "from-factory"
+    };
+  }
+}
+class ExtendedCommercetoolsCheckoutProvider extends CommercetoolsCheckoutProvider {
+  async getByIdOrThrow(payload) {
+    const result = await this.getById(payload);
+    return unwrapValue(result);
+  }
+}
+const extendedFactory = new ExtendedCommercetoolsCheckoutFactory();
+const capabilityFactory = withCommercetoolsCapabilities(config, {
+  checkout: {
+    enabled: true,
+    factory: extendedFactory,
+    provider: ({ cache: cache2, context: context2, config: config2, commercetoolsApi }) => new ExtendedCommercetoolsCheckoutProvider(
+      config2,
+      cache2,
+      context2,
+      commercetoolsApi,
+      extendedFactory
+    )
+  }
+});
+const client = capabilityFactory(cache, context);
+client.checkout.getById({
+  identifier: { key: "checkout-1" }
+}).then((result) => {
+  assertNotAny(result);
+  if (result.success) {
+    assertNotAny(result.value);
+    assertNotAny(result.value.extendedValue);
+    assertType(result.value.extendedValue);
+  }
+});
+client.checkout.getByIdOrThrow({
+  identifier: { key: "checkout-2" }
+}).then((checkout) => {
+  assertNotAny(checkout);
+  assertNotAny(checkout.extendedValue);
+  assertType(checkout.extendedValue);
+});