@reactionary/magento 0.0.1 → 0.10.19

package/core/client.js

@@ -1,11 +1,27 @@
+import {
+  CREATE_PRODUCT_REVIEW_MUTATION,
+  PRODUCT_RATING_SUMMARY_QUERY,
+  PRODUCT_REVIEWS_QUERY,
+  PRODUCT_REVIEW_RATINGS_METADATA_QUERY
+} from "./product-reviews.graphql.js";
 import createDebug from "debug";
 const debug = createDebug("reactionary:magento");
 const SESSION_KEY = "MAGENTO_PROVIDER";
+function ensureMagentoPasswordPolicy(password) {
+  let suffix = "";
+  if (!/[A-Z]/.test(password)) suffix += "A";
+  if (!/[a-z]/.test(password)) suffix += "a";
+  if (!/[0-9]/.test(password)) suffix += "1";
+  if (!/[^A-Za-z0-9]/.test(password)) suffix += "!";
+  return `${password}${suffix}`;
+}
 class RequestContextTokenStore {
   constructor(context, keyPrefix = "__x") {
     this.context = context;
     this.keyPrefix = keyPrefix;
   }
+  context;
+  keyPrefix;
   ensureNamespace() {
     if (this.context.session[SESSION_KEY] === void 0) {
       this.context.session[SESSION_KEY] = {};
@@ -34,13 +50,16 @@ class MagentoRest {
     this.getAuthHeader = getAuthHeader;
     this.apiUrl = `${this.baseUrl}/rest/${this.storeCode}`;
   }
+  baseUrl;
+  storeCode;
+  getAuthHeader;
   apiUrl;
   normalizeUrl(path) {
     const base = this.apiUrl.replace(/\/+$/, "");
     const p = path.startsWith("/") ? path : `/${path}`;
     return `${base}${p}`;
   }
-  async request(method, path, body) {
+  async request(method, path, body, options) {
     const url = this.normalizeUrl(path);
     const headers = {
       "Content-Type": "application/json",
@@ -51,6 +70,9 @@ class MagentoRest {
       headers,
       body: body === void 0 ? void 0 : JSON.stringify(body)
     });
+    if (res.status === 404 && options?.allowNotFound) {
+      return void 0;
+    }
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new Error(
@@ -65,17 +87,74 @@ ${text}`
     return await res.text();
   }
 }
+class MagentoGraphQL {
+  constructor(endpoint, storeCode, getAuthHeader) {
+    this.endpoint = endpoint;
+    this.storeCode = storeCode;
+    this.getAuthHeader = getAuthHeader;
+  }
+  endpoint;
+  storeCode;
+  getAuthHeader;
+  async request(document, variables) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...await this.getAuthHeader()
+    };
+    if (this.storeCode) {
+      headers["Store"] = this.storeCode;
+    }
+    const res = await fetch(this.endpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query: document, variables })
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(
+        `Magento GraphQL request failed: ${this.endpoint} \u2192 ${res.status}
+${text}`
+      );
+    }
+    const payload = await res.json();
+    if (payload.errors && payload.errors.length > 0) {
+      throw new Error(
+        `Magento GraphQL request failed: ${payload.errors.map((e) => e.message).join("; ")}`
+      );
+    }
+    if (payload.data === void 0 || payload.data === null) {
+      throw new Error("Magento GraphQL response contained no data.");
+    }
+    return payload.data;
+  }
+}
 class Magento {
-  constructor(rest, tokenStore) {
+  constructor(rest, tokenStore, authRest, adminRest, graphql) {
     this.rest = rest;
     this.tokenStore = tokenStore;
+    this.graphql = graphql;
+    this.authRest = authRest ?? rest;
+    this.adminRest = adminRest ?? rest;
+  }
+  rest;
+  tokenStore;
+  graphql;
+  authRest;
+  adminRest;
+  get gql() {
+    if (!this.graphql) {
+      throw new Error(
+        "Magento GraphQL transport is not configured on this client."
+      );
+    }
+    return this.graphql;
   }
   auth = {
     login: async (email, password) => {
-      const token = await this.rest.request(
+      const token = await this.authRest.request(
         "POST",
         "/V1/integration/customer/token",
-        { username: email, password }
+        { username: email, password: ensureMagentoPasswordPolicy(password) }
       );
       const normalized = typeof token === "string" ? token.replace(/^"|"$/g, "") : String(token);
       await this.tokenStore.setItem("customerToken", normalized);
@@ -88,10 +167,16 @@ class Magento {
   store = {
     customer: {
       register: async (customer, password) => {
-        return this.rest.request("POST", "/V1/customers", { customer, password });
+        return this.authRest.request("POST", "/V1/customers", {
+          customer,
+          password: password === void 0 ? void 0 : ensureMagentoPasswordPolicy(password)
+        });
       },
       me: async () => {
-        return this.rest.request("GET", "/V1/customers/me");
+        return this.authRest.request("GET", "/V1/customers/me");
+      },
+      update: async (customer) => {
+        return this.authRest.request("PUT", "/V1/customers/me", { customer });
       }
     },
     product: {
@@ -106,6 +191,37 @@ class Magento {
           "GET",
           `/V1/products?${params.toString()}`
         );
+      },
+      getLinks: async (sku, linkType) => {
+        return this.rest.request(
+          "GET",
+          `/V1/products/${encodeURIComponent(sku)}/links/${encodeURIComponent(linkType)}`
+        );
+      }
+    },
+    productReviews: {
+      getSummary: async (sku) => {
+        return this.gql.request(
+          PRODUCT_RATING_SUMMARY_QUERY,
+          { sku }
+        );
+      },
+      list: async (sku, pageSize, currentPage) => {
+        return this.gql.request(
+          PRODUCT_REVIEWS_QUERY,
+          { sku, pageSize, currentPage }
+        );
+      },
+      getRatingsMetadata: async () => {
+        return this.gql.request(
+          PRODUCT_REVIEW_RATINGS_METADATA_QUERY
+        );
+      },
+      create: async (input) => {
+        return this.gql.request(
+          CREATE_PRODUCT_REVIEW_MUTATION,
+          { input }
+        );
       }
     },
     category: {
@@ -113,12 +229,12 @@ class Magento {
         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()}`);
+        const params = new URLSearchParams();
+        params.set("searchCriteria[filterGroups][0][filters][0][field]", "external_id");
+        params.set("searchCriteria[filterGroups][0][filters][0][value]", externalId);
+        params.set("searchCriteria[filterGroups][0][filters][0][condition_type]", "eq");
+        params.set("searchCriteria[pageSize]", "1");
+        const response = await this.rest.request("GET", `/V1/categories/list?${params.toString()}`);
         return response.items?.[0] || null;
       },
       list: async (params) => {
@@ -133,6 +249,53 @@ class Magento {
         return this.rest.request("GET", `/V1/inventory/source-items?${params.toString()}`);
       }
     },
+    order: {
+      list: async (params) => {
+        return this.adminRest.request("GET", `/V1/orders?${params.toString()}`);
+      },
+      get: async (id) => {
+        return this.adminRest.request(
+          "GET",
+          `/V1/orders/${encodeURIComponent(id)}`,
+          void 0,
+          { allowNotFound: true }
+        );
+      }
+    },
+    checkout: {
+      estimateShippingMethods: async (cartId, address, customerToken) => {
+        const body = { address };
+        if (customerToken) {
+          return this.rest.request("POST", "/V1/carts/mine/estimate-shipping-methods", body);
+        }
+        return this.rest.request("POST", `/V1/guest-carts/${cartId}/estimate-shipping-methods`, body);
+      },
+      getPaymentMethods: async (cartId, customerToken) => {
+        if (customerToken) {
+          return this.rest.request("GET", "/V1/carts/mine/payment-methods");
+        }
+        return this.rest.request("GET", `/V1/guest-carts/${cartId}/payment-methods`);
+      },
+      setShippingInformation: async (cartId, payload, customerToken) => {
+        if (customerToken) {
+          return this.rest.request("POST", "/V1/carts/mine/shipping-information", payload);
+        }
+        return this.rest.request("POST", `/V1/guest-carts/${cartId}/shipping-information`, payload);
+      },
+      setBillingAddress: async (cartId, address, customerToken) => {
+        const body = { address };
+        if (customerToken) {
+          return this.rest.request("POST", "/V1/carts/mine/billing-address", body);
+        }
+        return this.rest.request("POST", `/V1/guest-carts/${cartId}/billing-address`, body);
+      },
+      placeOrder: async (cartId, payload, customerToken) => {
+        if (customerToken) {
+          return this.rest.request("POST", "/V1/carts/mine/payment-information", payload);
+        }
+        return this.rest.request("POST", `/V1/guest-carts/${cartId}/payment-information`, payload);
+      }
+    },
     cart: {
       create: async (customerToken) => {
         if (customerToken) {
@@ -197,20 +360,37 @@ class Magento {
     }
   };
 }
+function resolveGraphQLEndpoint(config) {
+  if (config.graphqlUrl) {
+    return config.graphqlUrl;
+  }
+  return `${config.baseUrl.replace(/\/+$/, "")}/graphql`;
+}
 class MagentoAdminClient {
   rest;
   client;
   constructor(config, context) {
-    this.rest = new MagentoRest(config.baseUrl, config.storeCode, async () => {
+    const authHeader = async () => {
       const headers = {};
       const token = config.adminApiKey ?? "";
-      if (token)
-        headers["Authorization"] = `Bearer ${token}`;
+      if (token) headers["Authorization"] = `Bearer ${token}`;
       return headers;
-    });
-    this.client = new Magento(this.rest, new RequestContextTokenStore(context));
-    if (debug.enabled)
-      debug("MagentoAdminClient created");
+    };
+    this.rest = new MagentoRest(config.baseUrl, config.storeCode, authHeader);
+    const authRest = new MagentoRest(config.baseUrl, config.authStoreCode, authHeader);
+    const graphql = new MagentoGraphQL(
+      resolveGraphQLEndpoint(config),
+      config.storeCode,
+      authHeader
+    );
+    this.client = new Magento(
+      this.rest,
+      new RequestContextTokenStore(context),
+      authRest,
+      void 0,
+      graphql
+    );
+    if (debug.enabled) debug("MagentoAdminClient created");
   }
   async getClient() {
     return this.client;
@@ -221,7 +401,7 @@ class MagentoClient {
     this.config = config;
     this.tokenStore = new RequestContextTokenStore(context);
     this.client = void 0;
-    this.rest = new MagentoRest(this.config.baseUrl, this.config.storeCode, async () => {
+    const authHeader = async () => {
       const headers = {};
       const customerToken = await this.tokenStore.getItem("customerToken");
       if (customerToken) {
@@ -233,17 +413,40 @@ class MagentoClient {
         headers["Authorization"] = `Bearer ${adminToken}`;
       }
       return headers;
+    };
+    this.rest = new MagentoRest(this.config.baseUrl, this.config.storeCode, authHeader);
+    this.authRest = new MagentoRest(this.config.baseUrl, this.config.authStoreCode, authHeader);
+    this.adminRest = new MagentoRest(this.config.baseUrl, this.config.storeCode, async () => {
+      const headers = {};
+      if (this.config.adminApiKey) {
+        headers["Authorization"] = `Bearer ${this.config.adminApiKey}`;
+      }
+      return headers;
     });
-    if (debug.enabled)
-      debug("MagentoClient created");
+    this.graphql = new MagentoGraphQL(
+      resolveGraphQLEndpoint(this.config),
+      this.config.storeCode,
+      authHeader
+    );
+    if (debug.enabled) debug("MagentoClient created");
   }
+  config;
   tokenStore;
   rest;
+  authRest;
+  adminRest;
+  graphql;
   client;
   async getClient() {
     if (!this.client) {
       this.client = Promise.resolve(
-        new Magento(this.rest, this.tokenStore)
+        new Magento(
+          this.rest,
+          this.tokenStore,
+          this.authRest,
+          this.adminRest,
+          this.graphql
+        )
       );
     }
     return this.client;
@@ -260,10 +463,35 @@ class MagentoClient {
     const client = await this.getClient();
     return client.store.customer.me();
   }
+  async getCustomerToken() {
+    return this.tokenStore.getItem("customerToken");
+  }
+  async getActiveCartId() {
+    return this.tokenStore.getItem("activeCartId");
+  }
+  async setActiveCartId(cartId) {
+    return this.tokenStore.setItem("activeCartId", cartId);
+  }
+  async clearActiveCartId() {
+    return this.tokenStore.removeItem("activeCartId");
+  }
   async register(customer, password) {
     const client = await this.getClient();
     return client.store.customer.register(customer, password);
   }
+  async updateMe(customer) {
+    const client = await this.getClient();
+    return client.store.customer.update(customer);
+  }
+  async searchOrders(params) {
+    const client = await this.getClient();
+    return client.store.order.list(params);
+  }
+  /** Returns undefined (not a thrown error) when Magento returns a 404 — no order with this entity_id. */
+  async getOrderById(id) {
+    const client = await this.getClient();
+    return client.store.order.get(id);
+  }
   async getProductBySKU(sku) {
     const client = await this.getClient();
     return client.store.product.getBySKU(sku);
@@ -271,6 +499,40 @@ class MagentoClient {
   async resolveProductForSKU(sku) {
     return this.getProductBySKU(sku);
   }
+  async searchProducts(params) {
+    const client = await this.getClient();
+    return client.store.product.search(params);
+  }
+  async getProductLinks(sku, linkType) {
+    const client = await this.getClient();
+    return client.store.product.getLinks(sku, linkType);
+  }
+  /** Returns null when no product matches the SKU in the current store scope. */
+  async getProductReviewSummary(sku) {
+    const client = await this.getClient();
+    const result = await client.store.productReviews.getSummary(sku);
+    return result.products?.items?.[0] ?? null;
+  }
+  /** Returns null when no product matches the SKU in the current store scope. */
+  async getProductReviews(sku, pageSize, currentPage) {
+    const client = await this.getClient();
+    const result = await client.store.productReviews.list(
+      sku,
+      pageSize,
+      currentPage
+    );
+    return result.products?.items?.[0] ?? null;
+  }
+  async getProductReviewRatingsMetadata() {
+    const client = await this.getClient();
+    const result = await client.store.productReviews.getRatingsMetadata();
+    return result.productReviewRatingsMetadata?.items ?? [];
+  }
+  async createProductReview(input) {
+    const client = await this.getClient();
+    const result = await client.store.productReviews.create(input);
+    return result.createProductReview?.review ?? null;
+  }
   async createCart() {
     const client = await this.getClient();
     const customerToken = await this.tokenStore.getItem("customerToken");
@@ -311,11 +573,49 @@ class MagentoClient {
     const customerToken = await this.tokenStore.getItem("customerToken");
     return client.store.cart.removeCoupon(cartId, customerToken);
   }
+  async estimateShippingMethods(cartId, address) {
+    const client = await this.getClient();
+    const customerToken = await this.tokenStore.getItem("customerToken");
+    return client.store.checkout.estimateShippingMethods(cartId, address, customerToken);
+  }
+  async getPaymentMethods(cartId) {
+    const client = await this.getClient();
+    const customerToken = await this.tokenStore.getItem("customerToken");
+    return client.store.checkout.getPaymentMethods(cartId, customerToken);
+  }
+  async setShippingInformation(cartId, payload) {
+    const client = await this.getClient();
+    const customerToken = await this.tokenStore.getItem("customerToken");
+    return client.store.checkout.setShippingInformation(cartId, payload, customerToken);
+  }
+  async setCheckoutBillingAddress(cartId, address) {
+    const client = await this.getClient();
+    const customerToken = await this.tokenStore.getItem("customerToken");
+    return client.store.checkout.setBillingAddress(cartId, address, customerToken);
+  }
+  async placeOrder(cartId, payload) {
+    const client = await this.getClient();
+    const customerToken = await this.tokenStore.getItem("customerToken");
+    return client.store.checkout.placeOrder(cartId, payload, customerToken);
+  }
+  async getCheckoutState(cartKey) {
+    const raw = await this.tokenStore.getItem(`checkoutState:${cartKey}`);
+    if (!raw) {
+      return {};
+    }
+    return JSON.parse(raw);
+  }
+  async setCheckoutState(cartKey, state) {
+    await this.tokenStore.setItem(`checkoutState:${cartKey}`, JSON.stringify(state));
+  }
 }
 export {
   Magento,
   MagentoAdminClient,
   MagentoClient,
+  MagentoGraphQL,
   RequestContextTokenStore,
-  SESSION_KEY
+  SESSION_KEY,
+  ensureMagentoPasswordPolicy,
+  resolveGraphQLEndpoint
 };

package/core/initialize.js

@@ -7,7 +7,17 @@ import {
   InventorySchema,
   PriceSchema,
   ProductSchema,
-  ProductSearchResultSchema
+  ProductSearchResultSchema,
+  ProfileSchema,
+  OrderSearchResultSchema,
+  OrderSchema,
+  CheckoutSchema,
+  ShippingMethodSchema,
+  PaymentMethodSchema,
+  ProductAssociationSchema,
+  ProductRatingSummarySchema,
+  ProductReviewSchema,
+  ProductReviewPaginatedResultSchema
 } from "@reactionary/core";
 import { MagentoCartCapability } from "../capabilities/cart.capability.js";
 import { MagentoCategoryCapability } from "../capabilities/category.capability.js";
@@ -16,6 +26,13 @@ import { MagentoInventoryCapability } from "../capabilities/inventory.capability
 import { MagentoPriceCapability } from "../capabilities/price.capability.js";
 import { MagentoProductSearchCapability } from "../capabilities/product-search.capability.js";
 import { MagentoProductCapability } from "../capabilities/product.capability.js";
+import { MagentoProfileCapability } from "../capabilities/profile.capability.js";
+import { MagentoOrderSearchCapability } from "../capabilities/order-search.capability.js";
+import { MagentoOrderCapability } from "../capabilities/order.capability.js";
+import { MagentoCheckoutCapability } from "../capabilities/checkout.capability.js";
+import { MagentoProductAssociationsCapability } from "../capabilities/product-associations.capability.js";
+import { MagentoProductRecommendationsCapability } from "../capabilities/product-recommendations.capability.js";
+import { MagentoProductReviewsCapability } from "../capabilities/product-reviews.capability.js";
 import {
   MagentoCapabilitiesSchema
 } from "../schema/capabilities.schema.js";
@@ -29,7 +46,13 @@ import {
   MagentoInventoryFactory,
   MagentoPriceFactory,
   MagentoProductFactory,
-  MagentoProductSearchFactory
+  MagentoProductSearchFactory,
+  MagentoProfileFactory,
+  MagentoOrderSearchFactory,
+  MagentoOrderFactory,
+  MagentoCheckoutFactory,
+  MagentoProductAssociationsFactory,
+  MagentoProductReviewsFactory
 } from "../factories/index.js";
 import {
   resolveCapabilityWithFactory,
@@ -168,6 +191,131 @@ function withMagentoCapabilities(configuration, capabilities) {
         }
       );
     }
+    if (caps.profile?.enabled) {
+      client.profile = resolveCapabilityWithFactory(
+        capabilities.profile,
+        {
+          factory: new MagentoProfileFactory(ProfileSchema),
+          capability: (args) => new MagentoProfileCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.magentoApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.orderSearch?.enabled) {
+      client.orderSearch = resolveCapabilityWithFactory(
+        capabilities.orderSearch,
+        {
+          factory: new MagentoOrderSearchFactory(OrderSearchResultSchema),
+          capability: (args) => new MagentoOrderSearchCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.magentoApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.order?.enabled) {
+      client.order = resolveCapabilityWithFactory(
+        capabilities.order,
+        {
+          factory: new MagentoOrderFactory(OrderSchema),
+          capability: (args) => new MagentoOrderCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.magentoApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.checkout?.enabled) {
+      client.checkout = resolveCapabilityWithFactory(
+        capabilities.checkout,
+        {
+          factory: new MagentoCheckoutFactory(
+            CheckoutSchema,
+            ShippingMethodSchema,
+            PaymentMethodSchema,
+            config
+          ),
+          capability: (args) => new MagentoCheckoutCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.magentoApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.productAssociations?.enabled) {
+      client.productAssociations = resolveCapabilityWithFactory(
+        capabilities.productAssociations,
+        {
+          factory: new MagentoProductAssociationsFactory(
+            ProductAssociationSchema,
+            config
+          ),
+          capability: (args) => new MagentoProductAssociationsCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.magentoApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.productRecommendations?.enabled) {
+      client.productRecommendations = resolveDirectCapability(
+        capabilities.productRecommendations,
+        (args) => new MagentoProductRecommendationsCapability(
+          args.config,
+          args.cache,
+          args.context,
+          args.magentoApi
+        ),
+        {
+          cache,
+          context,
+          config,
+          magentoApi
+        }
+      );
+    }
+    if (caps.productReviews?.enabled) {
+      client.productReviews = resolveCapabilityWithFactory(
+        capabilities.productReviews,
+        {
+          factory: new MagentoProductReviewsFactory(
+            ProductRatingSummarySchema,
+            ProductReviewSchema,
+            ProductReviewPaginatedResultSchema
+          ),
+          capability: (args) => new MagentoProductReviewsCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.magentoApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
     return client;
   };
 }