@reactionary/commercetools 0.6.3

package/capabilities/profile.capability.js

@@ -0,0 +1,337 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  ProfileMutationUpdateSchema,
+  ProfileCapability,
+  ProfileSchema,
+  Reactionary,
+  success,
+  error,
+  ProfileMutationSetBillingAddressSchema,
+  ProfileMutationRemoveShippingAddressSchema,
+  ProfileMutationAddShippingAddressSchema
+} from "@reactionary/core";
+class CommercetoolsProfileCapability extends ProfileCapability {
+  config;
+  commercetools;
+  factory;
+  constructor(config, cache, context, commercetools, factory) {
+    super(cache, context);
+    this.config = config;
+    this.commercetools = commercetools;
+    this.factory = factory;
+  }
+  async getClient() {
+    const client = await this.commercetools.getClient();
+    return client.withProjectKey({ projectKey: this.config.projectKey });
+  }
+  async getById(payload) {
+    const client = await this.getClient();
+    const remote = await client.me().get().execute();
+    if (remote.body.id !== payload.identifier.userId) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const model = this.factory.parseProfile(this.context, remote.body);
+    return success(model);
+  }
+  async addShippingAddress(payload) {
+    const client = await this.getClient();
+    const remote = await client.me().get().execute();
+    let customer = remote.body;
+    if (customer.id !== payload.identifier.userId) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const updateResponse = await client.me().post({
+      body: {
+        version: customer.version,
+        actions: [
+          {
+            action: "addAddress",
+            address: this.createCTAddressDraft(payload.address)
+          }
+        ]
+      }
+    }).execute();
+    customer = updateResponse.body;
+    const model = this.factory.parseProfile(this.context, customer);
+    return success(model);
+  }
+  async updateShippingAddress(payload) {
+    const client = await this.getClient();
+    const remote = await client.me().get().execute();
+    let customer = remote.body;
+    if (customer.id !== payload.identifier.userId) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const targetAddress = customer.addresses.find((addr) => addr.key === payload.address.identifier.nickName);
+    if (!targetAddress) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const updateResponse = await client.me().post({
+      body: {
+        version: customer.version,
+        actions: [
+          {
+            action: "changeAddress",
+            addressId: targetAddress.id,
+            address: this.createCTAddressDraft(payload.address)
+          }
+        ]
+      }
+    }).execute();
+    customer = updateResponse.body;
+    const model = this.factory.parseProfile(this.context, customer);
+    return success(model);
+  }
+  async removeShippingAddress(payload) {
+    const client = await this.getClient();
+    const remote = await client.me().get().execute();
+    let customer = remote.body;
+    if (customer.id !== payload.identifier.userId) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const updateActions = [];
+    const addressToRemove = customer.addresses.find((addr) => addr.key === payload.addressIdentifier.nickName);
+    if (addressToRemove) {
+      updateActions.push({
+        action: "removeAddress",
+        addressId: addressToRemove.id
+      });
+    } else {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const needsNewDefaultShippingAddress = addressToRemove && customer.defaultShippingAddressId === addressToRemove.id;
+    if (needsNewDefaultShippingAddress) {
+      const newDefaultAddress = customer.addresses.find((addr) => addr.id !== addressToRemove.id && addr.id !== customer.defaultBillingAddressId);
+      if (newDefaultAddress) {
+        updateActions.push({
+          action: "setDefaultShippingAddress",
+          addressKey: newDefaultAddress.key
+        });
+      }
+    }
+    const updateResponse = await client.me().post({
+      body: {
+        version: customer.version,
+        actions: updateActions
+      }
+    }).execute();
+    customer = updateResponse.body;
+    const model = this.factory.parseProfile(this.context, customer);
+    return success(model);
+  }
+  async makeShippingAddressDefault(payload) {
+    const client = await this.getClient();
+    const remote = await client.me().get().execute();
+    let customer = remote.body;
+    if (customer.id !== payload.identifier.userId) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const addressToMakeDefault = customer.addresses.find((addr) => addr.key === payload.addressIdentifier.nickName);
+    if (!addressToMakeDefault) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    if (addressToMakeDefault.id === customer.defaultBillingAddressId) {
+      return error({
+        type: "InvalidInput",
+        error: "Cannot set shipping address as default billing address"
+      });
+    }
+    const updateResponse = await client.me().post({
+      body: {
+        version: customer.version,
+        actions: [
+          {
+            action: "setDefaultShippingAddress",
+            addressKey: addressToMakeDefault.key
+          }
+        ]
+      }
+    }).execute();
+    customer = updateResponse.body;
+    const model = this.factory.parseProfile(this.context, customer);
+    return success(model);
+  }
+  async setBillingAddress(payload) {
+    const client = await this.getClient();
+    const remote = await client.me().get().execute();
+    let customer = remote.body;
+    if (customer.id !== payload.identifier.userId) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const updateActions = [];
+    const mainAddress = customer.defaultBillingAddressId ? customer.addresses.find((addr) => addr.id === customer.defaultBillingAddressId) : null;
+    if (!mainAddress) {
+      const newAddress = this.createCTAddressDraft(payload.address);
+      updateActions.push({
+        action: "addAddress",
+        address: newAddress
+      });
+      updateActions.push({
+        action: "setDefaultBillingAddress",
+        addressKey: newAddress.key
+      });
+    } else {
+      updateActions.push({
+        action: "changeAddress",
+        addressId: mainAddress.id,
+        address: this.createCTAddressDraft(payload.address)
+      });
+    }
+    if (updateActions.length > 0) {
+      const updateResponse = await client.me().post({
+        body: {
+          version: customer.version,
+          actions: updateActions
+        }
+      }).execute();
+      customer = updateResponse.body;
+    }
+    const model = this.factory.parseProfile(this.context, customer);
+    return success(model);
+  }
+  async update(payload) {
+    const client = await this.getClient();
+    const remote = await client.me().get().execute();
+    let customer = remote.body;
+    if (customer.id !== payload.identifier.userId) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const updateActions = [];
+    if (payload.email !== void 0) {
+      updateActions.push({
+        action: "changeEmail",
+        email: payload.email
+      });
+    }
+    const mainAddress = customer.defaultBillingAddressId ? customer.addresses.find((addr) => addr.id === customer.defaultBillingAddressId) : null;
+    if (!mainAddress) {
+      updateActions.push({
+        action: "addAddress",
+        address: {
+          key: `billing-address-${customer.id}`,
+          email: payload.email || customer.email,
+          phone: payload.phone,
+          country: this.context.taxJurisdiction.countryCode
+        }
+      });
+      updateActions.push({
+        action: "setDefaultBillingAddress",
+        addressKey: `billing-address-${customer.id}`
+      });
+    } else {
+      updateActions.push({
+        action: "changeAddress",
+        addressId: mainAddress.id,
+        address: {
+          ...mainAddress,
+          email: payload.email || customer.email,
+          phone: payload.phone
+        }
+      });
+    }
+    if (updateActions.length > 0) {
+      const updateResponse = await client.me().post({
+        body: {
+          version: customer.version,
+          actions: updateActions
+        }
+      }).execute();
+      customer = updateResponse.body;
+    }
+    const model = this.factory.parseProfile(this.context, customer);
+    return success(model);
+  }
+  createCTAddressDraft(address) {
+    return {
+      key: address.identifier.nickName,
+      firstName: address.firstName,
+      lastName: address.lastName,
+      streetName: address.streetAddress,
+      streetNumber: address.streetNumber,
+      postalCode: address.postalCode,
+      city: address.city,
+      region: address.region,
+      country: address.countryCode || this.context.taxJurisdiction.countryCode
+    };
+  }
+  /**
+  * Checks if an address only contains phone information and lacks essential address fields.
+  * An address is considered incomplete if it exists but has no firstName, lastName, streetName,
+  * streetNumber, or city.
+  * @param address - The address to check, or undefined
+  * @returns true if the address exists but lacks essential fields, false otherwise (including when address is undefined)
+  */
+  isIncompleteAddress(address) {
+    if (!address) {
+      return false;
+    }
+    return !address.firstName && !address.lastName && !address.streetName && !address.streetNumber && !address.city;
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationAddShippingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], CommercetoolsProfileCapability.prototype, "addShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationRemoveShippingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], CommercetoolsProfileCapability.prototype, "removeShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationSetBillingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], CommercetoolsProfileCapability.prototype, "setBillingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationUpdateSchema,
+    outputSchema: ProfileSchema
+  })
+], CommercetoolsProfileCapability.prototype, "update", 1);
+export {
+  CommercetoolsProfileCapability
+};

package/capabilities/store.capability.js

@@ -0,0 +1,51 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import { Reactionary, StoreCapability, StoreQueryByProximitySchema, StoreSchema, success, error } from "@reactionary/core";
+import * as z from "zod";
+class CommercetoolsStoreCapability extends StoreCapability {
+  config;
+  commercetools;
+  factory;
+  constructor(config, cache, context, commercetools, factory) {
+    super(cache, context);
+    this.config = config;
+    this.commercetools = commercetools;
+    this.factory = factory;
+  }
+  async getClient() {
+    const client = await this.commercetools.getClient();
+    return client.withProjectKey({ projectKey: this.config.projectKey });
+  }
+  async queryByProximity(payload) {
+    const client = await this.getClient();
+    const remote = await client.channels().get({
+      queryArgs: {
+        limit: payload.limit,
+        where: `geoLocation within circle(${payload.longitude}, ${payload.latitude}, ${payload.distance * 1e3}) AND roles contains any ("InventorySupply")`
+      }
+    }).execute();
+    const results = [];
+    for (const r of remote.body.results) {
+      results.push(this.factory.parseStore(this.context, r));
+    }
+    return success(results);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: StoreQueryByProximitySchema,
+    outputSchema: z.array(StoreSchema)
+  })
+], CommercetoolsStoreCapability.prototype, "queryByProximity", 1);
+export {
+  CommercetoolsStoreCapability
+};

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 { CommercetoolsCartCapability } from "../capabilities/cart.capability.js";
+import { CommercetoolsCategoryCapability } from "../capabilities/category.capability.js";
+import { CommercetoolsCheckoutCapability } from "../capabilities/checkout.capability.js";
+import { CommercetoolsIdentityCapability } from "../capabilities/identity.capability.js";
+import { CommercetoolsInventoryCapability } from "../capabilities/inventory.capability.js";
+import { CommercetoolsOrderCapability } from "../capabilities/order.capability.js";
+import { CommercetoolsOrderSearchCapability } from "../capabilities/order-search.capability.js";
+import { CommercetoolsPriceCapability } from "../capabilities/price.capability.js";
+import { CommercetoolsProductAssociationsCapability } from "../capabilities/product-associations.capability.js";
+import { CommercetoolsProductListCapability } from "../capabilities/product-list.capability.js";
+import { CommercetoolsProductCapability } from "../capabilities/product.capability.js";
+import { CommercetoolsProductReviewsCapability } from "../capabilities/product-reviews.capability.js";
+import { CommercetoolsProductSearchCapability } from "../capabilities/product-search.capability.js";
+import { CommercetoolsProfileCapability } from "../capabilities/profile.capability.js";
+import { CommercetoolsStoreCapability } from "../capabilities/store.capability.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),
+    createDefaultCapability: (args) => new CommercetoolsProductCapability(
+      args.cache,
+      args.context,
+      args.config,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  profile: {
+    isEnabled: (caps) => caps.profile?.enabled,
+    getOverride: (caps) => caps.profile,
+    createDefaultFactory: () => new CommercetoolsProfileFactory(ProfileSchema),
+    createDefaultCapability: (args) => new CommercetoolsProfileCapability(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  productSearch: {
+    isEnabled: (caps) => caps.productSearch?.enabled,
+    getOverride: (caps) => caps.productSearch,
+    createDefaultFactory: () => new CommercetoolsProductSearchFactory(ProductSearchResultSchema),
+    createDefaultCapability: (args) => new CommercetoolsProductSearchCapability(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  productAssociations: {
+    isEnabled: (caps) => caps.productAssociations?.enabled,
+    getOverride: (caps) => caps.productAssociations,
+    createDefaultFactory: () => new CommercetoolsProductAssociationsFactory(ProductAssociationSchema),
+    createDefaultCapability: (args) => new CommercetoolsProductAssociationsCapability(
+      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
+    ),
+    createDefaultCapability: (args) => new CommercetoolsProductListCapability(
+      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
+    ),
+    createDefaultCapability: (args) => new CommercetoolsProductReviewsCapability(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  identity: {
+    isEnabled: (caps) => caps.identity?.enabled,
+    getOverride: (caps) => caps.identity,
+    createDefaultFactory: () => new CommercetoolsIdentityFactory(IdentitySchema),
+    createDefaultCapability: (args) => new CommercetoolsIdentityCapability(
+      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),
+    createDefaultCapability: (args) => new CommercetoolsCartCapability(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  inventory: {
+    isEnabled: (caps) => caps.inventory?.enabled,
+    getOverride: (caps) => caps.inventory,
+    createDefaultFactory: () => new CommercetoolsInventoryFactory(InventorySchema),
+    createDefaultCapability: (args) => new CommercetoolsInventoryCapability(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  price: {
+    isEnabled: (caps) => caps.price?.enabled,
+    getOverride: (caps) => caps.price,
+    createDefaultFactory: () => new CommercetoolsPriceFactory(PriceSchema),
+    createDefaultCapability: (args) => new CommercetoolsPriceCapability(
+      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),
+    createDefaultCapability: (args) => new CommercetoolsCategoryCapability(
+      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
+    ),
+    createDefaultCapability: (args) => new CommercetoolsCheckoutCapability(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  store: {
+    isEnabled: (caps) => caps.store?.enabled,
+    getOverride: (caps) => caps.store,
+    createDefaultFactory: () => new CommercetoolsStoreFactory(StoreSchema),
+    createDefaultCapability: (args) => new CommercetoolsStoreCapability(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  order: {
+    isEnabled: (caps) => caps.order?.enabled,
+    getOverride: (caps) => caps.order,
+    createDefaultFactory: () => new CommercetoolsOrderFactory(OrderSchema),
+    createDefaultCapability: (args) => new CommercetoolsOrderCapability(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  orderSearch: {
+    isEnabled: (caps) => caps.orderSearch?.enabled,
+    getOverride: (caps) => caps.orderSearch,
+    createDefaultFactory: () => new CommercetoolsOrderSearchFactory(OrderSearchResultSchema),
+    createDefaultCapability: (args) => new CommercetoolsOrderSearchCapability(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  }
+};
+export {
+  capabilityDescriptors,
+  capabilityKeys
+};