@reactionary/commercetools 0.6.3

package/README.md

@@ -0,0 +1,11 @@
+# commercetools
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build commercetools` to build the library.
+
+## Running unit tests
+
+Run `nx test commercetools` to execute the unit tests via [Vitest](https://vitest.dev/).

package/capabilities/cart.capability.js

@@ -0,0 +1,324 @@
+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 {
+  CartIdentifierSchema,
+  CartMutationApplyCouponSchema,
+  CartMutationChangeCurrencySchema,
+  CartMutationDeleteCartSchema,
+  CartMutationItemAddSchema,
+  CartMutationItemQuantityChangeSchema,
+  CartMutationItemRemoveSchema,
+  CartMutationRemoveCouponSchema,
+  CartCapability,
+  CartQueryByIdSchema,
+  CartSchema,
+  Reactionary,
+  success,
+  error,
+  unwrapValue,
+  assertSuccess
+} from "@reactionary/core";
+import { CommercetoolsCartIdentifierSchema } from "../schema/commercetools.schema.js";
+class CommercetoolsCartCapability extends CartCapability {
+  config;
+  commercetools;
+  expandedCartFields = ["discountCodes[*].discountCode"];
+  factory;
+  constructor(config, cache, context, commercetools, factory) {
+    super(cache, context);
+    this.config = config;
+    this.commercetools = commercetools;
+    this.factory = factory;
+  }
+  async getById(payload) {
+    const client = await this.getClient();
+    const ctId = payload.cart;
+    try {
+      const remote = await client.carts.withId({ ID: ctId.key }).get({
+        queryArgs: {
+          expand: this.expandedCartFields
+        }
+      }).execute();
+      return success(this.factory.parseCart(this.context, remote.body));
+    } catch (err) {
+      return error({
+        type: "NotFound",
+        identifier: ctId
+      });
+    }
+  }
+  async add(payload) {
+    let cartIdentifier = payload.cart;
+    if (!cartIdentifier) {
+      cartIdentifier = await this.createCart();
+    }
+    const channelId = await this.commercetools.resolveChannelIdByRole("Primary");
+    const result = await this.applyActions(cartIdentifier, [
+      {
+        action: "addLineItem",
+        quantity: payload.quantity,
+        sku: payload.variant.sku,
+        // FIXME: This should be dynamic, probably as part of the context...
+        distributionChannel: {
+          typeId: "channel",
+          id: channelId
+        }
+      },
+      {
+        action: "recalculate"
+      }
+    ]);
+    return success(result);
+  }
+  async remove(payload) {
+    const result = await this.applyActions(payload.cart, [
+      {
+        action: "removeLineItem",
+        lineItemId: payload.item.key
+      },
+      {
+        action: "recalculate"
+      }
+    ]);
+    return success(result);
+  }
+  async changeQuantity(payload) {
+    if (payload.quantity === 0) {
+      const existing = await this.getById({ cart: payload.cart });
+      assertSuccess(existing);
+      return existing;
+    }
+    const result = await this.applyActions(payload.cart, [
+      {
+        action: "changeLineItemQuantity",
+        lineItemId: payload.item.key,
+        quantity: payload.quantity
+      },
+      {
+        action: "recalculate"
+      }
+    ]);
+    return success(result);
+  }
+  async getActiveCartId() {
+    const client = await this.getClient();
+    try {
+      const carts = await client.activeCart.get().execute();
+      const result = this.factory.parseCartIdentifier(this.context, {
+        key: carts.body.id,
+        version: carts.body.version || 0
+      });
+      return success(result);
+    } catch (e) {
+      return error({
+        type: "NotFound",
+        identifier: {}
+      });
+    }
+  }
+  async deleteCart(payload) {
+    const client = await this.getClient();
+    if (payload.cart.key) {
+      const ctId = payload.cart;
+      await client.carts.withId({ ID: ctId.key }).delete({
+        queryArgs: {
+          version: ctId.version,
+          dataErasure: false
+        }
+      }).execute();
+    }
+    return success(void 0);
+  }
+  async applyCouponCode(payload) {
+    const result = await this.applyActions(payload.cart, [
+      {
+        action: "addDiscountCode",
+        code: payload.couponCode
+      },
+      {
+        action: "recalculate"
+      }
+    ]);
+    return success(result);
+  }
+  async removeCouponCode(payload) {
+    const client = await this.getClient();
+    const currentCart = await client.carts.withId({ ID: payload.cart.key }).get({
+      queryArgs: {
+        expand: this.expandedCartFields
+      }
+    }).execute();
+    const discountCodeReference = currentCart.body.discountCodes?.find(
+      (dc) => dc.discountCode.obj?.code === payload.couponCode
+    )?.discountCode;
+    if (!discountCodeReference) {
+      return success(this.factory.parseCart(this.context, currentCart.body));
+    }
+    const result = await this.applyActions(payload.cart, [
+      {
+        action: "removeDiscountCode",
+        discountCode: {
+          id: discountCodeReference.id,
+          typeId: "discount-code"
+        }
+      },
+      {
+        action: "recalculate"
+      }
+    ]);
+    return success(result);
+  }
+  async changeCurrency(payload) {
+    const client = await this.getClient();
+    const currentCart = await client.carts.withId({ ID: payload.cart.key }).get().execute();
+    const newCart = await client.carts.post({
+      body: {
+        currency: payload.newCurrency,
+        locale: this.context.languageContext.locale
+      }
+    }).execute();
+    const newCartId = CommercetoolsCartIdentifierSchema.parse({
+      key: newCart.body.id,
+      version: newCart.body.version || 0
+    });
+    const cartItemAdds = currentCart.body.lineItems.map(
+      (item) => ({
+        action: "addLineItem",
+        sku: item.variant.sku || "",
+        quantity: item.quantity
+      })
+    );
+    const response = await this.applyActions(newCartId, [
+      ...cartItemAdds,
+      {
+        action: "recalculate"
+      }
+    ]);
+    await client.carts.withId({ ID: payload.cart.key }).delete({
+      queryArgs: {
+        version: currentCart.body.version || 0,
+        dataErasure: false
+      }
+    }).execute();
+    return success(response);
+  }
+  async createCart() {
+    const client = await this.getClient();
+    const response = await client.carts.post({
+      body: {
+        currency: this.context.languageContext.currencyCode || "USD",
+        country: this.context.taxJurisdiction.countryCode || "US",
+        locale: this.context.languageContext.locale
+      },
+      queryArgs: {
+        expand: this.expandedCartFields
+      }
+    }).execute();
+    return this.factory.parseCartIdentifier(this.context, {
+      key: response.body.id,
+      version: response.body.version || 0
+    });
+  }
+  async applyActions(cart, actions) {
+    const client = await this.getClient();
+    const ctId = cart;
+    try {
+      const response = await client.carts.withId({ ID: ctId.key }).post({
+        body: {
+          version: ctId.version,
+          actions
+        },
+        queryArgs: {
+          expand: this.expandedCartFields
+        }
+      }).execute();
+      if (response.error) {
+        console.error(response.error);
+      }
+      return this.factory.parseCart(this.context, response.body);
+    } catch (e) {
+      console.error("Error applying actions to cart:", e);
+      throw e;
+    }
+  }
+  /**
+   * Creates a new Commercetools client, optionally upgrading it from Anonymous mode to Guest mode.
+   * For now, any Query or Mutation will require an upgrade to Guest mode.
+   * In the future, maybe we can delay this upgrade until we actually need it.
+   */
+  async getClient() {
+    const client = await this.commercetools.getClient();
+    const clientWithProject = client.withProjectKey({
+      projectKey: this.config.projectKey
+    });
+    return {
+      carts: clientWithProject.me().carts(),
+      activeCart: clientWithProject.me().activeCart(),
+      orders: clientWithProject.me().orders()
+    };
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CartQueryByIdSchema,
+    outputSchema: CartSchema
+  })
+], CommercetoolsCartCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemAddSchema,
+    outputSchema: CartSchema
+  })
+], CommercetoolsCartCapability.prototype, "add", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemRemoveSchema,
+    outputSchema: CartSchema
+  })
+], CommercetoolsCartCapability.prototype, "remove", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemQuantityChangeSchema,
+    outputSchema: CartSchema
+  })
+], CommercetoolsCartCapability.prototype, "changeQuantity", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: CartIdentifierSchema
+  })
+], CommercetoolsCartCapability.prototype, "getActiveCartId", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationDeleteCartSchema
+  })
+], CommercetoolsCartCapability.prototype, "deleteCart", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationApplyCouponSchema,
+    outputSchema: CartSchema
+  })
+], CommercetoolsCartCapability.prototype, "applyCouponCode", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationRemoveCouponSchema,
+    outputSchema: CartSchema
+  })
+], CommercetoolsCartCapability.prototype, "removeCouponCode", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationChangeCurrencySchema,
+    outputSchema: CartSchema
+  })
+], CommercetoolsCartCapability.prototype, "changeCurrency", 1);
+export {
+  CommercetoolsCartCapability
+};

package/capabilities/category.capability.js

@@ -0,0 +1,198 @@
+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 {
+  CategoryPaginatedResultSchema,
+  CategoryCapability,
+  CategoryQueryByIdSchema,
+  CategoryQueryBySlugSchema,
+  CategoryQueryForBreadcrumbSchema,
+  CategoryQueryForChildCategoriesSchema,
+  CategoryQueryForTopCategoriesSchema,
+  CategorySchema,
+  Reactionary,
+  success,
+  error
+} from "@reactionary/core";
+import * as z from "zod";
+class CommercetoolsCategoryCapability extends CategoryCapability {
+  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 }).categories();
+  }
+  async getById(payload) {
+    const client = await this.getClient();
+    try {
+      const response = await client.withKey({ key: payload.id.key }).get().execute();
+      return success(this.factory.parseCategory(this.context, response.body));
+    } catch (err) {
+      return error({
+        type: "NotFound",
+        identifier: payload.id
+      });
+    }
+  }
+  async getBySlug(payload) {
+    const client = await this.getClient();
+    try {
+      const response = await client.get({
+        queryArgs: {
+          where: `slug(${this.context.languageContext.locale}=:slug)`,
+          "var.slug": payload.slug,
+          storeProjection: this.context.storeIdentifier.key,
+          limit: 1,
+          withTotal: false
+        }
+      }).execute();
+      if (response.body.results.length === 0) {
+        return error({
+          type: "NotFound",
+          identifier: payload.slug
+        });
+      }
+      return success(this.factory.parseCategory(this.context, response.body.results[0]));
+    } catch (err) {
+      console.error(`Error fetching category by slug:`, error);
+      return error({
+        type: "NotFound",
+        identifier: payload.slug
+      });
+    }
+  }
+  async getBreadcrumbPathToCategory(payload) {
+    const client = await this.getClient();
+    const path = [];
+    try {
+      const response = await client.withKey({ key: payload.id.key }).get({
+        queryArgs: {
+          expand: "ancestors[*]"
+        }
+      }).execute();
+      const category = this.factory.parseCategory(this.context, response.body);
+      for (const anc of response.body.ancestors || []) {
+        if (anc.obj) {
+          const parsedAnc = this.factory.parseCategory(this.context, anc.obj);
+          path.push(parsedAnc);
+        }
+      }
+      path.push(category);
+    } catch (error2) {
+      console.error(
+        `Error fetching category path for  ${payload.id.key}:`,
+        error2
+      );
+    }
+    return success(path);
+  }
+  async findChildCategories(payload) {
+    const client = await this.getClient();
+    try {
+      const parentCategory = await client.withKey({ key: payload.parentId.key }).get().execute();
+      const response = await client.get({
+        queryArgs: {
+          where: "parent(id = :parentId)",
+          "var.parentId": parentCategory.body.id,
+          limit: payload.paginationOptions.pageSize,
+          offset: (payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize,
+          sort: "orderHint asc",
+          storeProjection: this.context.storeIdentifier.key
+        }
+      }).execute();
+      const result = this.factory.parseCategoryPaginatedResult(this.context, response.body);
+      return success(result);
+    } catch (error2) {
+      console.error(
+        `Error fetching category path for  ${payload.parentId.key}:`,
+        error2
+      );
+    }
+    const empty = {
+      items: [],
+      pageNumber: payload.paginationOptions.pageNumber,
+      pageSize: payload.paginationOptions.pageSize,
+      totalCount: 0,
+      totalPages: 0
+    };
+    return success(empty);
+  }
+  async findTopCategories(payload) {
+    const client = await this.getClient();
+    try {
+      const response = await client.get({
+        queryArgs: {
+          where: "parent is not defined",
+          limit: payload.paginationOptions.pageSize,
+          offset: (payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize,
+          sort: "orderHint asc",
+          storeProjection: this.context.storeIdentifier.key
+        }
+      }).execute();
+      const result = this.factory.parseCategoryPaginatedResult(this.context, response.body);
+      return success(result);
+    } catch (error2) {
+      console.error(`Error fetching category top categories:`, error2);
+    }
+    const empty = {
+      items: [],
+      pageNumber: payload.paginationOptions.pageNumber,
+      pageSize: payload.paginationOptions.pageSize,
+      totalCount: 0,
+      totalPages: 0
+    };
+    return success(empty);
+  }
+  /**
+   * Handler for parsing a response from a remote capability implementation and converting it
+   * into the typed domain model.
+   */
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryByIdSchema,
+    outputSchema: CategorySchema
+  })
+], CommercetoolsCategoryCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryBySlugSchema,
+    outputSchema: CategorySchema
+  })
+], CommercetoolsCategoryCapability.prototype, "getBySlug", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryForBreadcrumbSchema,
+    outputSchema: z.array(CategorySchema)
+  })
+], CommercetoolsCategoryCapability.prototype, "getBreadcrumbPathToCategory", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryForChildCategoriesSchema,
+    outputSchema: CategoryPaginatedResultSchema
+  })
+], CommercetoolsCategoryCapability.prototype, "findChildCategories", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryForTopCategoriesSchema,
+    outputSchema: CategoryPaginatedResultSchema
+  })
+], CommercetoolsCategoryCapability.prototype, "findTopCategories", 1);
+export {
+  CommercetoolsCategoryCapability
+};