@reactionary/magento 0.0.1

package/core/client.js

@@ -0,0 +1,321 @@
+import createDebug from "debug";
+const debug = createDebug("reactionary:magento");
+const SESSION_KEY = "MAGENTO_PROVIDER";
+class RequestContextTokenStore {
+  constructor(context, keyPrefix = "__x") {
+    this.context = context;
+    this.keyPrefix = keyPrefix;
+  }
+  ensureNamespace() {
+    if (this.context.session[SESSION_KEY] === void 0) {
+      this.context.session[SESSION_KEY] = {};
+    }
+  }
+  async getItem(key) {
+    this.ensureNamespace();
+    const session = this.context.session[SESSION_KEY];
+    return session[`${this.keyPrefix}_${key}`] ?? null;
+  }
+  async setItem(key, value) {
+    this.ensureNamespace();
+    const session = this.context.session[SESSION_KEY];
+    session[`${this.keyPrefix}_${key}`] = value;
+  }
+  async removeItem(key) {
+    this.ensureNamespace();
+    const session = this.context.session[SESSION_KEY];
+    delete session[`${this.keyPrefix}_${key}`];
+  }
+}
+class MagentoRest {
+  constructor(baseUrl, storeCode, getAuthHeader) {
+    this.baseUrl = baseUrl;
+    this.storeCode = storeCode;
+    this.getAuthHeader = getAuthHeader;
+    this.apiUrl = `${this.baseUrl}/rest/${this.storeCode}`;
+  }
+  apiUrl;
+  normalizeUrl(path) {
+    const base = this.apiUrl.replace(/\/+$/, "");
+    const p = path.startsWith("/") ? path : `/${path}`;
+    return `${base}${p}`;
+  }
+  async request(method, path, body) {
+    const url = this.normalizeUrl(path);
+    const headers = {
+      "Content-Type": "application/json",
+      ...await this.getAuthHeader()
+    };
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(
+        `Magento request failed: ${method} ${path} \u2192 ${res.status}
+${text}`
+      );
+    }
+    const contentType = res.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      return await res.json();
+    }
+    return await res.text();
+  }
+}
+class Magento {
+  constructor(rest, tokenStore) {
+    this.rest = rest;
+    this.tokenStore = tokenStore;
+  }
+  auth = {
+    login: async (email, password) => {
+      const token = await this.rest.request(
+        "POST",
+        "/V1/integration/customer/token",
+        { username: email, password }
+      );
+      const normalized = typeof token === "string" ? token.replace(/^"|"$/g, "") : String(token);
+      await this.tokenStore.setItem("customerToken", normalized);
+      return normalized;
+    },
+    logout: async () => {
+      await this.tokenStore.removeItem("customerToken");
+    }
+  };
+  store = {
+    customer: {
+      register: async (customer, password) => {
+        return this.rest.request("POST", "/V1/customers", { customer, password });
+      },
+      me: async () => {
+        return this.rest.request("GET", "/V1/customers/me");
+      }
+    },
+    product: {
+      getBySKU: async (sku) => {
+        return this.rest.request(
+          "GET",
+          `/V1/products/${encodeURIComponent(sku)}`
+        );
+      },
+      search: async (params) => {
+        return this.rest.request(
+          "GET",
+          `/V1/products?${params.toString()}`
+        );
+      }
+    },
+    category: {
+      getById: async (categoryId) => {
+        return this.rest.request("GET", `/V1/categories/${encodeURIComponent(categoryId)}`);
+      },
+      getByExternalId: async (externalId) => {
+        const searchParams = new URLSearchParams({
+          "searchCriteria[filterGroups][0][filters][0][field]": "external_id",
+          "searchCriteria[filterGroups][0][filters][0][value]": externalId,
+          "searchCriteria[filterGroups][0][filters][0][condition_type]": "eq"
+        });
+        const response = await this.rest.request("GET", `/V1/categories?${searchParams.toString()}`);
+        return response.items?.[0] || null;
+      },
+      list: async (params) => {
+        return this.rest.request("GET", `/V1/categories/list?${params.toString()}`);
+      }
+    },
+    inventory: {
+      getStockStatus: async (sku) => {
+        return this.rest.request("GET", `/V1/stockStatuses/${encodeURIComponent(sku)}`);
+      },
+      getSourceItems: async (params) => {
+        return this.rest.request("GET", `/V1/inventory/source-items?${params.toString()}`);
+      }
+    },
+    cart: {
+      create: async (customerToken) => {
+        if (customerToken) {
+          const res2 = await this.rest.request("POST", "/V1/carts/mine");
+          return typeof res2 === "string" ? res2.replace(/^"|"$/g, "") : String(res2);
+        }
+        const res = await this.rest.request("POST", "/V1/guest-carts");
+        return res.replace(/^"|"$/g, "");
+      },
+      get: async (cartId, customerToken) => {
+        if (customerToken) {
+          return this.rest.request("GET", "/V1/carts/mine");
+        }
+        return this.rest.request("GET", `/V1/guest-carts/${cartId}`);
+      },
+      getTotals: async (cartId, customerToken) => {
+        if (customerToken) {
+          return this.rest.request("GET", "/V1/carts/mine/totals");
+        }
+        return this.rest.request("GET", `/V1/guest-carts/${cartId}/totals`);
+      },
+      addItem: async (cartId, item, customerToken) => {
+        const id = cartId && !isNaN(Number(cartId)) ? Number(cartId) : cartId;
+        if (customerToken) {
+          return this.rest.request("POST", "/V1/carts/mine/items", {
+            cartItem: { ...item, quote_id: id }
+          });
+        }
+        return this.rest.request("POST", `/V1/guest-carts/${cartId}/items`, {
+          cartItem: { ...item, quote_id: id, quoteId: id }
+        });
+      },
+      updateItem: async (cartId, itemId, item, customerToken) => {
+        const id = cartId && !isNaN(Number(cartId)) ? Number(cartId) : cartId;
+        if (customerToken) {
+          return this.rest.request("PUT", `/V1/carts/mine/items/${itemId}`, {
+            cartItem: { ...item, item_id: itemId, quote_id: id }
+          });
+        }
+        return this.rest.request("PUT", `/V1/guest-carts/${cartId}/items/${itemId}`, {
+          cartItem: { ...item, item_id: itemId, quote_id: id, quoteId: id }
+        });
+      },
+      removeItem: async (cartId, itemId, customerToken) => {
+        if (customerToken) {
+          return this.rest.request("DELETE", `/V1/carts/mine/items/${itemId}`);
+        }
+        return this.rest.request("DELETE", `/V1/guest-carts/${cartId}/items/${itemId}`);
+      },
+      applyCoupon: async (cartId, couponCode, customerToken) => {
+        if (customerToken) {
+          return this.rest.request("PUT", `/V1/carts/mine/coupons/${encodeURIComponent(couponCode)}`);
+        }
+        return this.rest.request("PUT", `/V1/guest-carts/${cartId}/coupons/${encodeURIComponent(couponCode)}`);
+      },
+      removeCoupon: async (cartId, customerToken) => {
+        if (customerToken) {
+          return this.rest.request("DELETE", "/V1/carts/mine/coupons");
+        }
+        return this.rest.request("DELETE", `/V1/guest-carts/${cartId}/coupons`);
+      }
+    }
+  };
+}
+class MagentoAdminClient {
+  rest;
+  client;
+  constructor(config, context) {
+    this.rest = new MagentoRest(config.baseUrl, config.storeCode, async () => {
+      const headers = {};
+      const token = config.adminApiKey ?? "";
+      if (token)
+        headers["Authorization"] = `Bearer ${token}`;
+      return headers;
+    });
+    this.client = new Magento(this.rest, new RequestContextTokenStore(context));
+    if (debug.enabled)
+      debug("MagentoAdminClient created");
+  }
+  async getClient() {
+    return this.client;
+  }
+}
+class MagentoClient {
+  constructor(config, context) {
+    this.config = config;
+    this.tokenStore = new RequestContextTokenStore(context);
+    this.client = void 0;
+    this.rest = new MagentoRest(this.config.baseUrl, this.config.storeCode, async () => {
+      const headers = {};
+      const customerToken = await this.tokenStore.getItem("customerToken");
+      if (customerToken) {
+        headers["Authorization"] = `Bearer ${customerToken}`;
+        return headers;
+      }
+      const adminToken = this.config.adminApiKey;
+      if (adminToken) {
+        headers["Authorization"] = `Bearer ${adminToken}`;
+      }
+      return headers;
+    });
+    if (debug.enabled)
+      debug("MagentoClient created");
+  }
+  tokenStore;
+  rest;
+  client;
+  async getClient() {
+    if (!this.client) {
+      this.client = Promise.resolve(
+        new Magento(this.rest, this.tokenStore)
+      );
+    }
+    return this.client;
+  }
+  async login(email, password) {
+    const client = await this.getClient();
+    return client.auth.login(email, password);
+  }
+  async logout() {
+    const client = await this.getClient();
+    return client.auth.logout();
+  }
+  async getMe() {
+    const client = await this.getClient();
+    return client.store.customer.me();
+  }
+  async register(customer, password) {
+    const client = await this.getClient();
+    return client.store.customer.register(customer, password);
+  }
+  async getProductBySKU(sku) {
+    const client = await this.getClient();
+    return client.store.product.getBySKU(sku);
+  }
+  async resolveProductForSKU(sku) {
+    return this.getProductBySKU(sku);
+  }
+  async createCart() {
+    const client = await this.getClient();
+    const customerToken = await this.tokenStore.getItem("customerToken");
+    return client.store.cart.create(customerToken);
+  }
+  async getCart(cartId) {
+    const client = await this.getClient();
+    const customerToken = await this.tokenStore.getItem("customerToken");
+    return client.store.cart.get(cartId, customerToken);
+  }
+  async getCartTotals(cartId) {
+    const client = await this.getClient();
+    const customerToken = await this.tokenStore.getItem("customerToken");
+    return client.store.cart.getTotals(cartId, customerToken);
+  }
+  async addItemToCart(cartId, item) {
+    const client = await this.getClient();
+    const customerToken = await this.tokenStore.getItem("customerToken");
+    return client.store.cart.addItem(cartId, item, customerToken);
+  }
+  async updateCartItem(cartId, itemId, item) {
+    const client = await this.getClient();
+    const customerToken = await this.tokenStore.getItem("customerToken");
+    return client.store.cart.updateItem(cartId, itemId, item, customerToken);
+  }
+  async removeCartItem(cartId, itemId) {
+    const client = await this.getClient();
+    const customerToken = await this.tokenStore.getItem("customerToken");
+    return client.store.cart.removeItem(cartId, itemId, customerToken);
+  }
+  async applyCoupon(cartId, couponCode) {
+    const client = await this.getClient();
+    const customerToken = await this.tokenStore.getItem("customerToken");
+    return client.store.cart.applyCoupon(cartId, couponCode, customerToken);
+  }
+  async removeCoupon(cartId) {
+    const client = await this.getClient();
+    const customerToken = await this.tokenStore.getItem("customerToken");
+    return client.store.cart.removeCoupon(cartId, customerToken);
+  }
+}
+export {
+  Magento,
+  MagentoAdminClient,
+  MagentoClient,
+  RequestContextTokenStore,
+  SESSION_KEY
+};

package/core/initialize.js

@@ -0,0 +1,176 @@
+import {
+  CartIdentifierSchema,
+  CartPaginatedSearchResultSchema,
+  CartSchema,
+  CategoryPaginatedResultSchema,
+  CategorySchema,
+  InventorySchema,
+  PriceSchema,
+  ProductSchema,
+  ProductSearchResultSchema
+} from "@reactionary/core";
+import { MagentoCartCapability } from "../capabilities/cart.capability.js";
+import { MagentoCategoryCapability } from "../capabilities/category.capability.js";
+import { MagentoIdentityCapability } from "../capabilities/identity.capability.js";
+import { MagentoInventoryCapability } from "../capabilities/inventory.capability.js";
+import { MagentoPriceCapability } from "../capabilities/price.capability.js";
+import { MagentoProductSearchCapability } from "../capabilities/product-search.capability.js";
+import { MagentoProductCapability } from "../capabilities/product.capability.js";
+import {
+  MagentoCapabilitiesSchema
+} from "../schema/capabilities.schema.js";
+import {
+  MagentoConfigurationSchema
+} from "../schema/configuration.schema.js";
+import { MagentoClient } from "./client.js";
+import {
+  MagentoCartFactory,
+  MagentoCategoryFactory,
+  MagentoInventoryFactory,
+  MagentoPriceFactory,
+  MagentoProductFactory,
+  MagentoProductSearchFactory
+} from "../factories/index.js";
+import {
+  resolveCapabilityWithFactory,
+  resolveDirectCapability
+} from "./initialize.types.js";
+function withMagentoCapabilities(configuration, capabilities) {
+  return (cache, context) => {
+    const client = {};
+    const config = MagentoConfigurationSchema.parse(configuration);
+    const caps = MagentoCapabilitiesSchema.parse(capabilities);
+    const magentoApi = new MagentoClient(config, context);
+    const buildCapabilityArgs = (factory) => ({
+      cache,
+      context,
+      config,
+      magentoApi,
+      factory
+    });
+    if (caps.product?.enabled) {
+      client.product = resolveCapabilityWithFactory(
+        capabilities.product,
+        {
+          factory: new MagentoProductFactory(ProductSchema, config),
+          capability: (args) => new MagentoProductCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.magentoApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.productSearch?.enabled) {
+      client.productSearch = resolveCapabilityWithFactory(
+        capabilities.productSearch,
+        {
+          factory: new MagentoProductSearchFactory(ProductSearchResultSchema, config),
+          capability: (args) => new MagentoProductSearchCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.magentoApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.category?.enabled) {
+      client.category = resolveCapabilityWithFactory(
+        capabilities.category,
+        {
+          factory: new MagentoCategoryFactory(
+            CategorySchema,
+            CategoryPaginatedResultSchema
+          ),
+          capability: (args) => new MagentoCategoryCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.magentoApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.cart?.enabled) {
+      client.cart = resolveCapabilityWithFactory(
+        capabilities.cart,
+        {
+          factory: new MagentoCartFactory(
+            CartSchema,
+            CartIdentifierSchema,
+            CartPaginatedSearchResultSchema
+          ),
+          capability: (args) => new MagentoCartCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.magentoApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.price?.enabled) {
+      client.price = resolveCapabilityWithFactory(
+        capabilities.price,
+        {
+          factory: new MagentoPriceFactory(PriceSchema),
+          capability: (args) => new MagentoPriceCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.magentoApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.inventory?.enabled) {
+      client.inventory = resolveCapabilityWithFactory(
+        capabilities.inventory,
+        {
+          factory: new MagentoInventoryFactory(InventorySchema),
+          capability: (args) => new MagentoInventoryCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.magentoApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.identity?.enabled) {
+      client.identity = resolveDirectCapability(
+        capabilities.identity,
+        (args) => new MagentoIdentityCapability(
+          args.config,
+          args.cache,
+          args.context,
+          args.magentoApi
+        ),
+        {
+          cache,
+          context,
+          config,
+          magentoApi
+        }
+      );
+    }
+    return client;
+  };
+}
+export {
+  withMagentoCapabilities
+};

package/core/initialize.types.js

@@ -0,0 +1,13 @@
+function resolveCapabilityWithFactory(capability, defaults, buildCapabilityArgs) {
+  const factory = capability?.factory ?? defaults.factory;
+  const capabilityFactory = capability?.capability ?? defaults.capability;
+  return capabilityFactory(buildCapabilityArgs(factory));
+}
+function resolveDirectCapability(capability, defaultCapability, args) {
+  const capabilityFactory = capability?.capability ?? defaultCapability;
+  return capabilityFactory(args);
+}
+export {
+  resolveCapabilityWithFactory,
+  resolveDirectCapability
+};

package/factories/cart/cart.factory.js

@@ -0,0 +1,135 @@
+import {
+  ProductVariantIdentifierSchema
+} from "@reactionary/core";
+import { MagentoCartIdentifierSchema } from "../../schema/magento.schema.js";
+class MagentoCartFactory {
+  cartSchema;
+  cartIdentifierSchema;
+  cartPaginatedSearchResultSchema;
+  constructor(cartSchema, cartIdentifierSchema, cartPaginatedSearchResultSchema) {
+    this.cartSchema = cartSchema;
+    this.cartIdentifierSchema = cartIdentifierSchema;
+    this.cartPaginatedSearchResultSchema = cartPaginatedSearchResultSchema;
+  }
+  parseCart(_context, data) {
+    const requestedId = data._requestedId;
+    const currency = data.quote_currency_code || "USD";
+    const cost = this.parseCostBreakdown(data, currency);
+    const items = (data.items || []).map((item) => this.parseCartItem(item, currency));
+    let identifierKey = data.masked_id;
+    if (!identifierKey && requestedId && isNaN(Number(requestedId))) {
+      identifierKey = requestedId;
+    }
+    if (!identifierKey) {
+      identifierKey = String(data.id || "");
+    }
+    const result = {
+      identifier: {
+        key: String(identifierKey || "")
+      },
+      user: {
+        userId: String(data.customer?.id || "")
+      },
+      items,
+      price: cost,
+      appliedPromotions: [],
+      name: data.name || "",
+      description: data.description || ""
+    };
+    return this.cartSchema.parse(result);
+  }
+  parseCartIdentifier(_context, data) {
+    const result = MagentoCartIdentifierSchema.parse({
+      key: String(data.id || data.masked_id || "")
+    });
+    return this.cartIdentifierSchema.parse(result);
+  }
+  parseCartPaginatedSearchResult(_context, data, query) {
+    const result = {
+      identifier: query.search,
+      items: data.items.map((item) => this.parseCartSearchResultItem(_context, item)),
+      totalCount: data.totalCount,
+      pageNumber: query.search.paginationOptions.pageNumber,
+      pageSize: query.search.paginationOptions.pageSize,
+      totalPages: Math.ceil(data.totalCount / query.search.paginationOptions.pageSize)
+    };
+    return this.cartPaginatedSearchResultSchema.parse(result);
+  }
+  parseCartSearchResultItem(context, data) {
+    const cart = this.parseCart(context, data);
+    return {
+      identifier: cart.identifier,
+      user: cart.user,
+      numItems: cart.items.length,
+      name: cart.name,
+      lastModifiedDate: data.updated_at ?? ""
+    };
+  }
+  parseCostBreakdown(cart, currency) {
+    return {
+      totalProductPrice: {
+        value: cart.subtotal ?? cart.base_subtotal ?? 0,
+        currency
+      },
+      grandTotal: {
+        value: cart.grand_total ?? cart.base_grand_total ?? 0,
+        currency
+      },
+      totalTax: {
+        value: cart.tax_amount ?? cart.base_tax_amount ?? 0,
+        currency
+      },
+      totalShipping: {
+        value: cart.shipping_amount ?? cart.base_shipping_amount ?? 0,
+        currency
+      },
+      totalDiscount: {
+        value: Math.abs(cart.discount_amount ?? cart.base_discount_amount ?? 0),
+        currency
+      },
+      totalSurcharge: {
+        value: 0,
+        currency
+      }
+    };
+  }
+  parseItemPrice(item, currency) {
+    const qty = item.qty ?? 0;
+    return {
+      unitPrice: {
+        value: item.price ?? 0,
+        currency
+      },
+      unitDiscount: {
+        value: item.discount_amount ? Math.abs(item.discount_amount / (qty || 1)) : 0,
+        currency
+      },
+      totalPrice: {
+        value: item.row_total !== void 0 ? item.row_total : (item.price || 0) * (qty || 0),
+        currency
+      },
+      totalDiscount: {
+        value: Math.abs(item.discount_amount || 0),
+        currency
+      }
+    };
+  }
+  parseCartItem(item, currency) {
+    return {
+      identifier: {
+        key: String(item.item_id)
+      },
+      product: {
+        key: item.sku
+      },
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: item.sku
+      }),
+      quantity: item.qty,
+      price: this.parseItemPrice(item, currency)
+    };
+  }
+}
+export {
+  MagentoCartFactory
+};

package/factories/category/category.factory.js

@@ -0,0 +1,48 @@
+import {
+  CategoryIdentifierSchema
+} from "@reactionary/core";
+class MagentoCategoryFactory {
+  categorySchema;
+  categoryPaginatedResultSchema;
+  constructor(categorySchema, categoryPaginatedResultSchema) {
+    this.categorySchema = categorySchema;
+    this.categoryPaginatedResultSchema = categoryPaginatedResultSchema;
+  }
+  parseCategory(_context, data) {
+    const identifier = CategoryIdentifierSchema.parse({
+      key: String(data.custom_attributes?.find((a) => a.attribute_code === "external_id")?.value || data.id)
+    });
+    const name = data.name || "";
+    const urlKeyAttr = data.custom_attributes?.find((a) => a.attribute_code === "url_key");
+    const slug = urlKeyAttr ? String(urlKeyAttr.value) : "";
+    const textAttr = data.custom_attributes?.find((a) => a.attribute_code === "description");
+    const text = textAttr ? String(textAttr.value) : name;
+    const parentCategoryStr = String(data.parent_id || "");
+    const parentCategory = parentCategoryStr && parentCategoryStr !== "0" ? { key: parentCategoryStr } : void 0;
+    const result = {
+      identifier,
+      name,
+      slug,
+      text,
+      parentCategory,
+      images: []
+    };
+    return this.categorySchema.parse(result);
+  }
+  parseCategoryPaginatedResult(context, data) {
+    const items = (data.items || []).map((c) => this.parseCategory(context, c));
+    const totalCount = data.total_count ?? 0;
+    const totalPages = Math.max(1, Math.ceil(totalCount / data.pageSize));
+    const result = {
+      pageNumber: data.currentPage,
+      pageSize: data.pageSize,
+      totalCount,
+      totalPages,
+      items
+    };
+    return this.categoryPaginatedResultSchema.parse(result);
+  }
+}
+export {
+  MagentoCategoryFactory
+};

package/factories/identity/identity.factory.js

@@ -0,0 +1,12 @@
+class MagentoIdentityFactory {
+  identitySchema;
+  constructor(identitySchema) {
+    this.identitySchema = identitySchema;
+  }
+  parseIdentity(_context, data) {
+    return this.identitySchema.parse(data);
+  }
+}
+export {
+  MagentoIdentityFactory
+};