@reactionary/commercetools 0.6.3

package/capabilities/checkout.capability.js

@@ -0,0 +1,374 @@
+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 {
+  CheckoutMutationAddPaymentInstructionSchema,
+  CheckoutMutationFinalizeCheckoutSchema,
+  CheckoutMutationInitiateCheckoutSchema,
+  CheckoutMutationRemovePaymentInstructionSchema,
+  CheckoutMutationSetShippingAddressSchema,
+  CheckoutMutationSetShippingInstructionSchema,
+  CheckoutCapability,
+  CheckoutQueryByIdSchema,
+  CheckoutQueryForAvailablePaymentMethodsSchema,
+  CheckoutQueryForAvailableShippingMethodsSchema,
+  CheckoutSchema,
+  PaymentMethodSchema,
+  Reactionary,
+  ShippingMethodSchema,
+  success,
+  error,
+  unwrapValue
+} from "@reactionary/core";
+import * as z from "zod";
+import {} from "../schema/commercetools.schema.js";
+class CheckoutNotReadyForFinalizationError extends Error {
+  constructor(checkoutIdentifier) {
+    super(
+      "Checkout is not ready for finalization. Ensure all required fields are set and valid. " + (checkoutIdentifier ? `Checkout ID: ${JSON.stringify(checkoutIdentifier)}` : "")
+    );
+    this.checkoutIdentifier = checkoutIdentifier;
+    this.name = "CheckoutNotReadyForFinalizationError";
+  }
+}
+class CommercetoolsCheckoutCapability extends CheckoutCapability {
+  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 {
+      payments: client.withProjectKey({ projectKey: this.config.projectKey }).me().payments(),
+      carts: client.withProjectKey({ projectKey: this.config.projectKey }).me().carts(),
+      shippingMethods: client.withProjectKey({ projectKey: this.config.projectKey }).shippingMethods(),
+      orders: client.withProjectKey({ projectKey: this.config.projectKey }).me().orders()
+    };
+  }
+  async initiateCheckoutForCart(payload) {
+    const client = await this.getClient();
+    const cart = await client.carts.withId({ ID: payload.cart.identifier.key }).get().execute();
+    const replicationResponse = await client.carts.replicate().post({
+      body: {
+        reference: {
+          typeId: "cart",
+          id: cart.body.id
+        }
+      }
+    }).execute();
+    const actions = [
+      {
+        action: "setCustomType",
+        type: {
+          typeId: "type",
+          key: "reactionaryCheckout"
+        },
+        fields: {
+          commerceToolsCartId: payload.cart.identifier.key
+        }
+      }
+    ];
+    if (payload.billingAddress) {
+      actions.push({
+        action: "setBillingAddress",
+        address: {
+          country: payload.billingAddress.countryCode,
+          firstName: payload.billingAddress.firstName || "",
+          lastName: payload.billingAddress.lastName || "",
+          streetName: payload.billingAddress.streetAddress || "",
+          streetNumber: payload.billingAddress.streetNumber || "",
+          postalCode: payload.billingAddress.postalCode || "",
+          city: payload.billingAddress.city || "",
+          email: payload.notificationEmail || "",
+          phone: payload.notificationPhone || ""
+        }
+      });
+      actions.push({
+        action: "setShippingAddress",
+        address: {
+          country: payload.billingAddress.countryCode,
+          firstName: payload.billingAddress.firstName || "",
+          lastName: payload.billingAddress.lastName || "",
+          streetName: payload.billingAddress.streetAddress || "",
+          streetNumber: payload.billingAddress.streetNumber || "",
+          postalCode: payload.billingAddress.postalCode || "",
+          city: payload.billingAddress.city || ""
+        }
+      });
+    }
+    const checkoutResponse = await client.carts.withId({ ID: replicationResponse.body.id }).post({
+      body: {
+        version: replicationResponse.body.version || 0,
+        actions: [...actions]
+      }
+    }).execute();
+    return success(this.factory.parseCheckout(this.context, checkoutResponse.body));
+  }
+  async getById(payload) {
+    const client = await this.getClient();
+    const checkoutResponse = await client.carts.withId({ ID: payload.identifier.key }).get({
+      queryArgs: {
+        expand: ["paymentInfo.payments[*]", "shippingInfo.shippingMethod"]
+      }
+    }).execute();
+    const checkout = this.factory.parseCheckout(this.context, checkoutResponse.body);
+    if (checkoutResponse.body.cartState === "Ordered") {
+      const order = await client.orders.get({
+        queryArgs: {
+          where: `cart(id="${checkout.identifier.key}")`
+        }
+      }).execute();
+      checkout.resultingOrder = {
+        key: order.body.results[0].id
+      };
+    }
+    return success(checkout);
+  }
+  async setShippingAddress(payload) {
+    const client = await this.getClient();
+    const version = payload.checkout.version;
+    const checkoutResponse = await client.carts.withId({ ID: payload.checkout.key }).post({
+      body: {
+        version,
+        actions: [
+          {
+            action: "setShippingAddress",
+            address: {
+              country: payload.shippingAddress.countryCode,
+              firstName: payload.shippingAddress.firstName || "",
+              lastName: payload.shippingAddress.lastName || "",
+              streetName: payload.shippingAddress.streetAddress || "",
+              streetNumber: payload.shippingAddress.streetNumber || "",
+              postalCode: payload.shippingAddress.postalCode || "",
+              city: payload.shippingAddress.city || ""
+            }
+          }
+        ]
+      }
+    }).execute();
+    return success(this.factory.parseCheckout(this.context, checkoutResponse.body));
+  }
+  async getAvailableShippingMethods(payload) {
+    const client = await this.getClient();
+    const shippingMethodsResponse = await client.shippingMethods.matchingCart().get({
+      queryArgs: {
+        cartId: payload.checkout.key
+      }
+    }).execute();
+    const result = shippingMethodsResponse.body.results.map(
+      (shippingMethod) => this.factory.parseShippingMethod(this.context, shippingMethod)
+    );
+    return success(result);
+  }
+  async getAvailablePaymentMethods(payload) {
+    const staticMethods = this.getStaticPaymentMethods(payload.checkout);
+    const dynamicMethods = [];
+    const result = [...staticMethods, ...dynamicMethods].map(
+      (paymentMethod) => this.factory.parsePaymentMethod(this.context, paymentMethod)
+    );
+    return success(result);
+  }
+  async addPaymentInstruction(payload) {
+    const client = await this.getClient();
+    const response = await client.payments.post({
+      body: {
+        amountPlanned: {
+          centAmount: Math.round(
+            payload.paymentInstruction.amount.value * 100
+          ),
+          currencyCode: payload.paymentInstruction.amount.currency
+        },
+        paymentMethodInfo: {
+          method: payload.paymentInstruction.paymentMethod.method,
+          name: {
+            [this.context.languageContext.locale]: payload.paymentInstruction.paymentMethod.name
+          },
+          paymentInterface: payload.paymentInstruction.paymentMethod.paymentProcessor
+        },
+        custom: {
+          type: {
+            typeId: "type",
+            key: "reactionaryPaymentCustomFields"
+          },
+          fields: {
+            commerceToolsCartId: payload.checkout.key
+          }
+        }
+      }
+    }).execute();
+    const version = payload.checkout.version;
+    const actions = [
+      {
+        action: "addPayment",
+        payment: {
+          typeId: "payment",
+          id: response.body.id
+        }
+      }
+    ];
+    const result = await this.applyActions(
+      payload.checkout,
+      actions
+    );
+    return success(result);
+  }
+  async removePaymentInstruction(payload) {
+    const client = await this.getClient();
+    const checkout = unwrapValue(await this.getById({ identifier: payload.checkout }));
+    return success(checkout);
+  }
+  async setShippingInstruction(payload) {
+    const actions = [];
+    actions.push({
+      action: "setShippingMethod",
+      shippingMethod: {
+        typeId: "shipping-method",
+        key: payload.shippingInstruction.shippingMethod.key
+      }
+    });
+    actions.push({
+      action: "setCustomField",
+      name: "shippingInstruction",
+      value: payload.shippingInstruction.instructions
+    });
+    actions.push({
+      action: "setCustomField",
+      name: "consentForUnattendedDelivery",
+      value: payload.shippingInstruction.consentForUnattendedDelivery + ""
+    });
+    actions.push({
+      action: "setCustomField",
+      name: "pickupPointId",
+      value: payload.shippingInstruction.pickupPoint
+    });
+    const result = await this.applyActions(
+      payload.checkout,
+      actions
+    );
+    return success(result);
+  }
+  async finalizeCheckout(payload) {
+    const checkout = await this.getById({ identifier: payload.checkout });
+    if (!checkout.success || !checkout.value.readyForFinalization) {
+      throw new CheckoutNotReadyForFinalizationError(payload.checkout);
+    }
+    const client = await this.getClient();
+    const ctId = payload.checkout;
+    await client.orders.post({
+      body: {
+        id: ctId.key,
+        version: ctId.version
+      }
+    }).execute();
+    const result = await this.getById({
+      identifier: payload.checkout
+    });
+    if (!result.success) {
+      throw new Error("Unable to fetch checkout after finalization.");
+    }
+    return success(result.value);
+  }
+  async applyActions(checkout, actions) {
+    const client = await this.getClient();
+    const ctId = checkout;
+    try {
+      const response = await client.carts.withId({ ID: ctId.key }).post({
+        queryArgs: {
+          expand: ["paymentInfo.payments[*]", "shippingInfo.shippingMethod"]
+        },
+        body: {
+          version: ctId.version,
+          actions
+        }
+      }).execute();
+      if (response.error) {
+        console.error(response.error);
+      }
+      const p = this.factory.parseCheckout(this.context, response.body);
+      return p;
+    } catch (e) {
+      console.error("Error applying actions to cart:", e);
+      throw e;
+    }
+  }
+  /**
+   * Extension point, to allow filtering the options, or adding new ones, like invoicing for b2b.
+   *
+   * Usecase: Override this, if you need to change the payment options based on the request context.
+   * @returns
+   */
+  getStaticPaymentMethods(_checkout) {
+    return this.config.paymentMethods || [];
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationInitiateCheckoutSchema,
+    outputSchema: CheckoutSchema
+  })
+], CommercetoolsCheckoutCapability.prototype, "initiateCheckoutForCart", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutQueryByIdSchema,
+    outputSchema: CheckoutSchema.nullable()
+  })
+], CommercetoolsCheckoutCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationSetShippingAddressSchema,
+    outputSchema: CheckoutSchema
+  })
+], CommercetoolsCheckoutCapability.prototype, "setShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutQueryForAvailableShippingMethodsSchema,
+    outputSchema: z.array(ShippingMethodSchema)
+  })
+], CommercetoolsCheckoutCapability.prototype, "getAvailableShippingMethods", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutQueryForAvailablePaymentMethodsSchema,
+    outputSchema: z.array(PaymentMethodSchema)
+  })
+], CommercetoolsCheckoutCapability.prototype, "getAvailablePaymentMethods", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationAddPaymentInstructionSchema,
+    outputSchema: CheckoutSchema
+  })
+], CommercetoolsCheckoutCapability.prototype, "addPaymentInstruction", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationRemovePaymentInstructionSchema,
+    outputSchema: CheckoutSchema
+  })
+], CommercetoolsCheckoutCapability.prototype, "removePaymentInstruction", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationSetShippingInstructionSchema,
+    outputSchema: CheckoutSchema
+  })
+], CommercetoolsCheckoutCapability.prototype, "setShippingInstruction", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationFinalizeCheckoutSchema,
+    outputSchema: CheckoutSchema
+  })
+], CommercetoolsCheckoutCapability.prototype, "finalizeCheckout", 1);
+export {
+  CheckoutNotReadyForFinalizationError,
+  CommercetoolsCheckoutCapability
+};

package/capabilities/identity.capability.js

@@ -0,0 +1,95 @@
+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 {
+  IdentityCapability,
+  Reactionary,
+  IdentityQuerySelfSchema,
+  IdentitySchema,
+  IdentityMutationRegisterSchema,
+  IdentityMutationLoginSchema,
+  success
+} from "@reactionary/core";
+class CommercetoolsIdentityCapability extends IdentityCapability {
+  config;
+  commercetools;
+  factory;
+  constructor(config, cache, context, commercetools, factory) {
+    super(cache, context);
+    this.config = config;
+    this.commercetools = commercetools;
+    this.factory = factory;
+  }
+  async getSelf(payload) {
+    const identity = this.factory.parseIdentity(
+      this.context,
+      await this.commercetools.introspect()
+    );
+    this.updateIdentityContext(identity);
+    return success(identity);
+  }
+  async login(payload) {
+    const identity = this.factory.parseIdentity(
+      this.context,
+      await this.commercetools.login(
+        payload.username,
+        payload.password
+      )
+    );
+    this.updateIdentityContext(identity);
+    return success(identity);
+  }
+  async logout(payload) {
+    const identity = this.factory.parseIdentity(
+      this.context,
+      await this.commercetools.logout()
+    );
+    this.updateIdentityContext(identity);
+    return success(identity);
+  }
+  async register(payload) {
+    const identity = this.factory.parseIdentity(
+      this.context,
+      await this.commercetools.register(
+        payload.username,
+        payload.password
+      )
+    );
+    this.updateIdentityContext(identity);
+    return success(identity);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityQuerySelfSchema,
+    outputSchema: IdentitySchema
+  })
+], CommercetoolsIdentityCapability.prototype, "getSelf", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationLoginSchema,
+    outputSchema: IdentitySchema
+  })
+], CommercetoolsIdentityCapability.prototype, "login", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: IdentitySchema
+  })
+], CommercetoolsIdentityCapability.prototype, "logout", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationRegisterSchema,
+    outputSchema: IdentitySchema
+  })
+], CommercetoolsIdentityCapability.prototype, "register", 1);
+export {
+  CommercetoolsIdentityCapability
+};

package/capabilities/index.js

@@ -0,0 +1,15 @@
+export * from "./cart.capability.js";
+export * from "./category.capability.js";
+export * from "./identity.capability.js";
+export * from "./inventory.capability.js";
+export * from "./order-search.capability.js";
+export * from "./price.capability.js";
+export * from "./product-associations.capability.js";
+export * from "./product-list.capability.js";
+export * from "./product.capability.js";
+export * from "./product-reviews.capability.js";
+export * from "./profile.capability.js";
+export * from "./product-search.capability.js";
+export * from "./store.capability.js";
+export * from "./order.capability.js";
+export * from "./checkout.capability.js";

package/capabilities/inventory.capability.js

@@ -0,0 +1,63 @@
+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 { InventoryCapability, InventoryQueryBySKUSchema, InventorySchema, Reactionary, success, error } from "@reactionary/core";
+class CommercetoolsInventoryCapability extends InventoryCapability {
+  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 getBySKU(payload) {
+    const client = await this.getClient();
+    try {
+      const channelId = await this.commercetools.resolveChannelIdByKey(payload.fulfilmentCenter.key);
+      const remote = await client.inventory().get({
+        queryArgs: {
+          where: "sku=:sku AND supplyChannel(id=:channel)",
+          "var.sku": payload.variant.sku,
+          "var.channel": channelId,
+          expand: "supplyChannel"
+        }
+      }).execute();
+      const result = remote.body.results[0];
+      const model = this.factory.parseInventory(this.context, result);
+      return success(model);
+    } catch (err) {
+      console.error("Error fetching inventory by SKU and Fulfillment Center:", error, payload);
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
+    }
+  }
+}
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false,
+    inputSchema: InventoryQueryBySKUSchema,
+    outputSchema: InventorySchema
+  })
+], CommercetoolsInventoryCapability.prototype, "getBySKU", 1);
+export {
+  CommercetoolsInventoryCapability
+};

package/capabilities/order-search.capability.js

@@ -0,0 +1,106 @@
+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 {
+  OrderSearchCapability,
+  OrderSearchQueryByTermSchema,
+  OrderSearchResultSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+const debug = createDebug("reactionary:commercetools:order-search");
+class CommercetoolsOrderSearchCapability extends OrderSearchCapability {
+  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 }).me().orders();
+  }
+  async queryByTerm(payload) {
+    debug("queryByTerm", payload);
+    const client = await this.getClient();
+    const where = [];
+    if (payload.search) {
+      if (payload.search.term) {
+        debug("Search by term is not implemented yet in CommercetoolsOrderSearchCapability");
+      }
+      if (payload.search.partNumber) {
+        for (const partNumber of payload.search.partNumber) {
+          where.push(`lineItems(variant(sku="${partNumber}"))`);
+        }
+      }
+      if (payload.search.user && payload.search.user.userId) {
+      }
+      if (payload.search.orderStatus) {
+        const orderStatusWhere = payload.search.orderStatus.map((x) => {
+          let mappedStatus = "Open";
+          if (x === "AwaitingPayment") {
+            mappedStatus = `Open`;
+          }
+          if (x === "ReleasedToFulfillment") {
+            mappedStatus = `Confirmed`;
+          }
+          if (x === "Shipped") {
+            mappedStatus = `Complete`;
+          }
+          if (x === "Cancelled") {
+            mappedStatus = `Cancelled`;
+          }
+          return `orderState="${mappedStatus}"`;
+        }).join(" OR ");
+        where.push(orderStatusWhere);
+      }
+      if (payload.search.startDate) {
+        where.push(`createdAt >= "${payload.search.startDate}"`);
+      }
+      if (payload.search.endDate) {
+        where.push(`createdAt <= "${payload.search.endDate}"`);
+      }
+    }
+    const response = await client.get({
+      queryArgs: {
+        where,
+        withTotal: true,
+        limit: payload.search.paginationOptions.pageSize,
+        offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize
+      }
+    }).execute();
+    const responseBody = response.body;
+    const result = this.factory.parseOrderSearchResult(
+      this.context,
+      responseBody,
+      payload
+    );
+    if (debug.enabled) {
+      debug(
+        `Search for term "${payload.search.term}" returned ${responseBody.results.length} orders (page ${payload.search.paginationOptions.pageNumber} of ${result.totalPages})`
+      );
+    }
+    return success(result);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: OrderSearchQueryByTermSchema,
+    outputSchema: OrderSearchResultSchema
+  })
+], CommercetoolsOrderSearchCapability.prototype, "queryByTerm", 1);
+export {
+  CommercetoolsOrderSearchCapability
+};

package/capabilities/order.capability.js

@@ -0,0 +1,48 @@
+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 { OrderCapability, OrderQueryByIdSchema, OrderSchema, Reactionary, success, error } from "@reactionary/core";
+class CommercetoolsOrderCapability extends OrderCapability {
+  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 }).me().orders();
+  }
+  async getById(payload) {
+    const client = await this.getClient();
+    try {
+      const remote = await client.withId({ ID: payload.order.key }).get().execute();
+      return success(this.factory.parseOrder(this.context, remote.body));
+    } catch (e) {
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
+    }
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: OrderQueryByIdSchema,
+    outputSchema: OrderSchema
+  })
+], CommercetoolsOrderCapability.prototype, "getById", 1);
+export {
+  CommercetoolsOrderCapability
+};