@reactionary/magento 0.0.1

package/README.md

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

package/capabilities/cart.capability.js

@@ -0,0 +1,293 @@
+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 {
+  CartCapability,
+  CartIdentifierSchema,
+  CartMutationApplyCouponSchema,
+  CartMutationChangeCurrencySchema,
+  CartMutationCreateCartSchema,
+  CartMutationDeleteCartSchema,
+  CartMutationItemAddSchema,
+  CartMutationItemQuantityChangeSchema,
+  CartMutationItemRemoveSchema,
+  CartMutationRemoveCouponSchema,
+  CartMutationRenameCartSchema,
+  CartPaginatedSearchResultSchema,
+  CartQueryByIdSchema,
+  CartQueryListSchema,
+  CartSchema,
+  Reactionary,
+  success,
+  error
+} from "@reactionary/core";
+import createDebug from "debug";
+import { MagentoCartIdentifierSchema } from "../schema/magento.schema.js";
+const debug = createDebug("reactionary:magento:cart");
+class MagentoCartCapability extends CartCapability {
+  constructor(config, cache, context, magentoApi, factory) {
+    super(cache, context);
+    this.magentoApi = magentoApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  config;
+  factory;
+  async getById(payload) {
+    try {
+      const magentoId = payload.cart;
+      const cartResponse = await this.getCartWithTotals(magentoId.key);
+      if (cartResponse) {
+        return success(this.factory.parseCart(this.context, { ...cartResponse, _requestedId: magentoId.key }));
+      }
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
+    } catch (err) {
+      debug("Failed to get cart by ID:", err);
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
+    }
+  }
+  async add(payload) {
+    try {
+      let cartIdentifier = payload.cart;
+      if (!cartIdentifier) {
+        const activeCart = await this.getActiveCartId();
+        if (activeCart.success) {
+          cartIdentifier = activeCart.value;
+        } else {
+          cartIdentifier = await this.createNewCart();
+        }
+      }
+      const magentoId = cartIdentifier;
+      const item = {
+        sku: payload.variant.sku,
+        qty: payload.quantity
+      };
+      await this.magentoApi.addItemToCart(magentoId.key, item);
+      const cartResponse = await this.getCartWithTotals(magentoId.key);
+      return success(this.factory.parseCart(this.context, { ...cartResponse, _requestedId: magentoId.key }));
+    } catch (err) {
+      debug("Failed to add item to cart:", err);
+      throw err;
+    }
+  }
+  async remove(payload) {
+    try {
+      const magentoId = payload.cart;
+      await this.magentoApi.removeCartItem(magentoId.key, Number(payload.item.key));
+      const cartResponse = await this.getCartWithTotals(magentoId.key);
+      return success(this.factory.parseCart(this.context, { ...cartResponse, _requestedId: magentoId.key }));
+    } catch (err) {
+      debug("Failed to remove item from cart:", err);
+      throw err;
+    }
+  }
+  async changeQuantity(payload) {
+    try {
+      const magentoId = payload.cart;
+      const item = {
+        item_id: Number(payload.item.key),
+        qty: payload.quantity
+      };
+      await this.magentoApi.updateCartItem(magentoId.key, Number(payload.item.key), item);
+      const cartResponse = await this.getCartWithTotals(magentoId.key);
+      return success(this.factory.parseCart(this.context, { ...cartResponse, _requestedId: magentoId.key }));
+    } catch (err) {
+      debug("Failed to change quantity:", err);
+      throw err;
+    }
+  }
+  async getActiveCartId() {
+    try {
+      const tokenStore = this.magentoApi.tokenStore;
+      const activeCartId = await tokenStore.getItem("activeCartId");
+      if (activeCartId) {
+        return success(
+          MagentoCartIdentifierSchema.parse({
+            key: activeCartId
+          })
+        );
+      }
+      return error({
+        type: "NotFound",
+        identifier: void 0
+      });
+    } catch {
+      return error({
+        type: "NotFound",
+        identifier: void 0
+      });
+    }
+  }
+  async deleteCart(_payload) {
+    const tokenStore = this.magentoApi.tokenStore;
+    await tokenStore.removeItem("activeCartId");
+    return success(void 0);
+  }
+  async applyCouponCode(payload) {
+    try {
+      const magentoId = payload.cart;
+      await this.magentoApi.applyCoupon(magentoId.key, payload.couponCode);
+      const cartResponse = await this.getCartWithTotals(magentoId.key);
+      return success(this.factory.parseCart(this.context, { ...cartResponse, _requestedId: magentoId.key }));
+    } catch (err) {
+      debug("Failed to apply coupon:", err);
+      throw err;
+    }
+  }
+  async removeCouponCode(payload) {
+    try {
+      const magentoId = payload.cart;
+      await this.magentoApi.removeCoupon(magentoId.key);
+      const cartResponse = await this.getCartWithTotals(magentoId.key);
+      return success(this.factory.parseCart(this.context, { ...cartResponse, _requestedId: magentoId.key }));
+    } catch (err) {
+      debug("Failed to remove coupon:", err);
+      throw err;
+    }
+  }
+  async changeCurrency(_payload) {
+    throw new Error("Currency change not implemented for Magento");
+  }
+  async listCarts(_payload) {
+    const tokenStore = this.magentoApi.tokenStore;
+    const activeCartId = await tokenStore.getItem("activeCartId");
+    if (activeCartId) {
+      const cartWithTotals = await this.getCartWithTotals(activeCartId);
+      return success(this.factory.parseCartPaginatedSearchResult(this.context, {
+        items: [cartWithTotals],
+        totalCount: 1
+      }, _payload));
+    } else {
+      return success(this.factory.parseCartPaginatedSearchResult(this.context, {
+        items: [],
+        totalCount: 0
+      }, _payload));
+    }
+  }
+  async createCart(_payload) {
+    const identifier = await this.createNewCart();
+    const cartResponse = await this.getCartWithTotals(identifier.key);
+    return success(this.factory.parseCart(this.context, { ...cartResponse, _requestedId: identifier.key }));
+  }
+  async renameCart(_payload) {
+    throw new Error("renameCart not implemented for Magento");
+  }
+  async createNewCart() {
+    const cartId = await this.magentoApi.createCart();
+    const identifier = MagentoCartIdentifierSchema.parse({
+      key: cartId.replace(/^"|"$/g, "")
+    });
+    const tokenStore = this.magentoApi.tokenStore;
+    await tokenStore.setItem("activeCartId", identifier.key);
+    return identifier;
+  }
+  async getCartWithTotals(cartId) {
+    try {
+      const [cartResponse, totalsResponse] = await Promise.all([
+        this.magentoApi.getCart(cartId),
+        this.magentoApi.getCartTotals(cartId)
+      ]);
+      return {
+        ...cartResponse,
+        ...totalsResponse,
+        items: (cartResponse.items || []).map((item) => {
+          const totalItem = (totalsResponse.items || []).find(
+            (t) => t["item_id"] === item["item_id"]
+          );
+          return { ...item, ...totalItem };
+        })
+      };
+    } catch (err) {
+      debug("Failed to get cart with totals:", err);
+      return this.magentoApi.getCart(cartId);
+    }
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CartQueryByIdSchema,
+    outputSchema: CartSchema
+  })
+], MagentoCartCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemAddSchema,
+    outputSchema: CartSchema
+  })
+], MagentoCartCapability.prototype, "add", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemRemoveSchema,
+    outputSchema: CartSchema
+  })
+], MagentoCartCapability.prototype, "remove", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemQuantityChangeSchema,
+    outputSchema: CartSchema
+  })
+], MagentoCartCapability.prototype, "changeQuantity", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: CartIdentifierSchema
+  })
+], MagentoCartCapability.prototype, "getActiveCartId", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationDeleteCartSchema,
+    outputSchema: CartSchema
+  })
+], MagentoCartCapability.prototype, "deleteCart", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationApplyCouponSchema,
+    outputSchema: CartSchema
+  })
+], MagentoCartCapability.prototype, "applyCouponCode", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationRemoveCouponSchema,
+    outputSchema: CartSchema
+  })
+], MagentoCartCapability.prototype, "removeCouponCode", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationChangeCurrencySchema,
+    outputSchema: CartSchema
+  })
+], MagentoCartCapability.prototype, "changeCurrency", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartQueryListSchema,
+    outputSchema: CartPaginatedSearchResultSchema
+  })
+], MagentoCartCapability.prototype, "listCarts", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationCreateCartSchema,
+    outputSchema: CartSchema
+  })
+], MagentoCartCapability.prototype, "createCart", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationRenameCartSchema,
+    outputSchema: CartSchema
+  })
+], MagentoCartCapability.prototype, "renameCart", 1);
+export {
+  MagentoCartCapability
+};

package/capabilities/category.capability.js

@@ -0,0 +1,254 @@
+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 {
+  CategoryCapability,
+  CategoryPaginatedResultSchema,
+  CategoryQueryByIdSchema,
+  CategoryQueryBySlugSchema,
+  CategoryQueryForBreadcrumbSchema,
+  CategoryQueryForChildCategoriesSchema,
+  CategoryQueryForTopCategoriesSchema,
+  CategorySchema,
+  error,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import * as z from "zod";
+import createDebug from "debug";
+const debug = createDebug("reactionary:magento:category");
+class MagentoCategoryCapability extends CategoryCapability {
+  constructor(config, cache, context, magentoApi, factory) {
+    super(cache, context);
+    this.magentoApi = magentoApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  config;
+  factory;
+  async getById(payload) {
+    const client = await this.magentoApi.getClient();
+    try {
+      const response = await client.store.category.getByExternalId(payload.id.key);
+      if (!response) {
+        return error({
+          type: "NotFound",
+          identifier: payload
+        });
+      }
+      return success(await this.factory.parseCategory(this.context, await this.cleanupParentPointersForCategory(response.items[0])));
+    } catch (e) {
+      debug("Error getting category by id", e);
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
+    }
+  }
+  async getBySlug(payload) {
+    const client = await this.magentoApi.getClient();
+    const params = new URLSearchParams();
+    params.set("searchCriteria[filterGroups][0][filters][0][field]", "url_key");
+    params.set("searchCriteria[filterGroups][0][filters][0][value]", payload.slug);
+    params.set("searchCriteria[filterGroups][0][filters][0][condition_type]", "eq");
+    params.set("searchCriteria[pageSize]", "1");
+    try {
+      const response = await client.store.category.list(params);
+      if (!response.items || response.items.length === 0) {
+        return error({
+          type: "NotFound",
+          identifier: payload
+        });
+      }
+      return success(
+        await this.factory.parseCategory(this.context, await this.cleanupParentPointersForCategory(response.items[0]))
+      );
+    } catch (e) {
+      debug("Error getting category by slug", e);
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
+    }
+  }
+  async getBreadcrumbPathToCategory(payload) {
+    const client = await this.magentoApi.getClient();
+    try {
+      const category = await client.store.category.getByExternalId(payload.id.key);
+      if (!category) {
+        return error({
+          type: "NotFound",
+          identifier: payload.id
+        });
+      }
+      const pathIds = (category.path || "").split("/").filter(Boolean);
+      if (pathIds.length === 0) {
+        return success([await this.factory.parseCategory(this.context, await this.cleanupParentPointersForCategory(category))]);
+      }
+      const params = new URLSearchParams();
+      params.set("searchCriteria[filterGroups][0][filters][0][field]", "entity_id");
+      params.set("searchCriteria[filterGroups][0][filters][0][value]", pathIds.join(","));
+      params.set("searchCriteria[filterGroups][0][filters][0][condition_type]", "in");
+      const response = await client.store.category.list(params);
+      const items = response.items || [];
+      const results = [];
+      for (const id of pathIds) {
+        const found = items.find((c) => String(c["id"]) === String(id));
+        if (found) {
+          results.push(await this.factory.parseCategory(this.context, await this.cleanupParentPointersForCategory(found)));
+        }
+      }
+      return success(results);
+    } catch (e) {
+      debug("Error getting breadcrumb path", e);
+      throw new Error("Category not found or error fetching path: " + payload.id.key);
+    }
+  }
+  async findChildCategories(payload) {
+    const client = await this.magentoApi.getClient();
+    const parentId = await this.translateCategoryKeyToMagentoId(client, payload.parentId.key);
+    if (!parentId) {
+      return error({
+        type: "NotFound",
+        identifier: payload.parentId
+      });
+    }
+    const pageSize = payload.paginationOptions.pageSize;
+    const currentPage = payload.paginationOptions.pageNumber;
+    const params = new URLSearchParams();
+    params.set("searchCriteria[filterGroups][0][filters][0][field]", "parent_id");
+    params.set("searchCriteria[filterGroups][0][filters][0][value]", parentId);
+    params.set("searchCriteria[filterGroups][0][filters][0][condition_type]", "eq");
+    params.set("searchCriteria[filterGroups][1][filters][0][field]", "is_active");
+    params.set("searchCriteria[filterGroups][1][filters][0][value]", "1");
+    params.set("searchCriteria[filterGroups][1][filters][0][condition_type]", "eq");
+    params.set("searchCriteria[pageSize]", String(pageSize));
+    params.set("searchCriteria[currentPage]", String(currentPage));
+    const response = await this.cleanupParentPointersForPaginatedResult(await client.store.category.list(params));
+    return success(
+      this.factory.parseCategoryPaginatedResult(this.context, {
+        ...response,
+        pageSize,
+        currentPage
+      })
+    );
+  }
+  async findTopCategories(payload) {
+    const client = await this.magentoApi.getClient();
+    const pageSize = payload.paginationOptions.pageSize;
+    const currentPage = payload.paginationOptions.pageNumber;
+    const params = new URLSearchParams();
+    params.set("searchCriteria[filterGroups][0][filters][0][field]", "parent_id");
+    params.set("searchCriteria[filterGroups][0][filters][0][value]", this.config.rootCategoryId);
+    params.set("searchCriteria[filterGroups][0][filters][0][condition_type]", "eq");
+    params.set("searchCriteria[filterGroups][1][filters][0][field]", "is_active");
+    params.set("searchCriteria[filterGroups][1][filters][0][value]", "1");
+    params.set("searchCriteria[filterGroups][1][filters][0][condition_type]", "eq");
+    params.set("searchCriteria[pageSize]", String(pageSize));
+    params.set("searchCriteria[currentPage]", String(currentPage));
+    const response = await this.cleanupParentPointersForPaginatedResult(await client.store.category.list(params));
+    return success(
+      this.factory.parseCategoryPaginatedResult(this.context, {
+        ...response,
+        pageSize,
+        currentPage
+      })
+    );
+  }
+  async cacheCategoryKeyToIdMapping(key, id) {
+    await this.cache.put(`category_key_to_id:${key}`, id, {
+      ttlSeconds: 60 * 60,
+      // cache for 1 hour
+      dependencyIds: [`category_key:${key}`]
+    });
+    await this.cache.put(`category_id_to_key:${id}`, key, {
+      ttlSeconds: 60 * 60,
+      // cache for 1 hour
+      dependencyIds: [`category_id:${id}`]
+    });
+  }
+  async translateCategoryKeyToMagentoId(client, key) {
+    const cachedValue = await this.cache.get(`category_key_to_id:${key}`, z.string());
+    if (cachedValue) {
+      return cachedValue;
+    }
+    const response = await client.store.category.getByExternalId(key);
+    if (!response) {
+      return null;
+    }
+    const magentoId = String(response.items[0].id);
+    await this.cacheCategoryKeyToIdMapping(key, magentoId);
+    return magentoId;
+  }
+  async translateMagentoIdToCategoryKey(magentoId) {
+    const categoryCacheKey = await this.cache.get(`category_id_to_key:${magentoId}`, z.string());
+    if (categoryCacheKey) {
+      return categoryCacheKey;
+    }
+    const client = await this.magentoApi.getClient();
+    const response = await client.store.category.getById(magentoId);
+    const keyAttr = response.custom_attributes?.find((a) => a.attribute_code === "external_id");
+    const key = String(keyAttr?.value || "-");
+    await this.cacheCategoryKeyToIdMapping(key, magentoId);
+    return key;
+  }
+  async cleanupParentPointersForCategory(category) {
+    if (String(category.parent_id) === this.config.rootCategoryId) {
+      category.parent_id = 0;
+    } else {
+      const parentKey = await this.translateMagentoIdToCategoryKey(String(category.parent_id));
+      if (parentKey) {
+        category.parent_id = Number(parentKey);
+        await this.cacheCategoryKeyToIdMapping(parentKey, String(category.parent_id));
+      }
+    }
+    return category;
+  }
+  async cleanupParentPointersForPaginatedResult(paginatedResult) {
+    for (const category of paginatedResult.items) {
+      await this.cleanupParentPointersForCategory(category);
+    }
+    return paginatedResult;
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryByIdSchema,
+    outputSchema: CategorySchema
+  })
+], MagentoCategoryCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryBySlugSchema,
+    outputSchema: CategorySchema.nullable()
+  })
+], MagentoCategoryCapability.prototype, "getBySlug", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryForBreadcrumbSchema,
+    outputSchema: z.array(CategorySchema)
+  })
+], MagentoCategoryCapability.prototype, "getBreadcrumbPathToCategory", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryForChildCategoriesSchema,
+    outputSchema: CategoryPaginatedResultSchema
+  })
+], MagentoCategoryCapability.prototype, "findChildCategories", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryForTopCategoriesSchema,
+    outputSchema: CategoryPaginatedResultSchema
+  })
+], MagentoCategoryCapability.prototype, "findTopCategories", 1);
+export {
+  MagentoCategoryCapability
+};

package/capabilities/identity.capability.js

@@ -0,0 +1,107 @@
+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,
+  IdentityMutationLogoutSchema,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+const debug = createDebug("reactionary:magento:identity");
+class MagentoIdentityCapability extends IdentityCapability {
+  constructor(config, cache, context, magentoApi) {
+    super(cache, context);
+    this.magentoApi = magentoApi;
+    this.config = config;
+  }
+  config;
+  createAnonymousIdentity() {
+    return {
+      type: "Anonymous"
+    };
+  }
+  async getSelf(_payload) {
+    try {
+      const client = await this.magentoApi.getClient();
+      const me = await client.store.customer.me();
+      const identity = {
+        id: {
+          userId: String(me.id)
+        },
+        type: "Registered"
+      };
+      this.updateIdentityContext(identity);
+      return success(identity);
+    } catch (err) {
+      debug("getSelf failed, returning anonymous identity:", err);
+      const identity = this.createAnonymousIdentity();
+      this.updateIdentityContext(identity);
+      return success(identity);
+    }
+  }
+  async login(payload) {
+    debug("Attempting login for user:", payload.username);
+    await this.magentoApi.login(payload.username, payload.password);
+    return this.getSelf({});
+  }
+  async logout(_payload) {
+    debug("Logging out user");
+    await this.magentoApi.logout();
+    const identity = this.createAnonymousIdentity();
+    this.updateIdentityContext(identity);
+    return success(identity);
+  }
+  async register(payload) {
+    debug("Registering new user:", payload.username);
+    const customer = {
+      email: payload.username,
+      firstname: payload["firstname"] || "User",
+      lastname: payload["lastname"] || "Account"
+    };
+    await this.magentoApi.register(customer, payload.password);
+    return this.login({
+      username: payload.username,
+      password: payload.password
+    });
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityQuerySelfSchema,
+    outputSchema: IdentitySchema
+  })
+], MagentoIdentityCapability.prototype, "getSelf", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationLoginSchema,
+    outputSchema: IdentitySchema
+  })
+], MagentoIdentityCapability.prototype, "login", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationLogoutSchema,
+    outputSchema: IdentitySchema
+  })
+], MagentoIdentityCapability.prototype, "logout", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationRegisterSchema,
+    outputSchema: IdentitySchema
+  })
+], MagentoIdentityCapability.prototype, "register", 1);
+export {
+  MagentoIdentityCapability
+};