@reactionary/hcl 0.9.7 → 0.9.11

package/capabilities/checkout.capability.js

@@ -0,0 +1,337 @@
+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 {
+  CheckoutCapability,
+  CheckoutMutationAddPaymentInstructionSchema,
+  CheckoutMutationFinalizeCheckoutSchema,
+  CheckoutMutationInitiateCheckoutSchema,
+  CheckoutMutationRemovePaymentInstructionSchema,
+  CheckoutMutationSetShippingAddressSchema,
+  CheckoutMutationSetShippingInstructionSchema,
+  CheckoutQueryByIdSchema,
+  CheckoutQueryForAvailablePaymentMethodsSchema,
+  CheckoutQueryForAvailableShippingMethodsSchema,
+  CheckoutSchema,
+  PaymentMethodSchema,
+  ShippingMethodSchema,
+  Reactionary,
+  error,
+  success
+} from "@reactionary/core";
+import { HclCartNotFoundError } from "../core/client.js";
+import createDebug from "debug";
+const debug = createDebug("reactionary:hcl:checkout");
+class HclCheckoutCapability extends CheckoutCapability {
+  config;
+  client;
+  factory;
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  cartUrl() {
+    return `${this.client.transactionBaseUrl}/cart/@self`;
+  }
+  /** Fetch the raw WCS cart response. Throws HclCartNotFoundError on 404. */
+  async fetchWcsCart() {
+    const data = await this.client.callGet(
+      this.cartUrl(),
+      void 0,
+      { allowUndefined: true }
+    );
+    if (!data)
+      throw new HclCartNotFoundError();
+    return data;
+  }
+  /** Fetch and parse the active cart as a Checkout. */
+  async fetchCheckout(extra) {
+    const data = await this.fetchWcsCart();
+    return this.factory.parseCheckout(this.context, { ...data, ...extra });
+  }
+  paymentMethodsUrl() {
+    return `${this.client.transactionBaseUrl}/cart/@self/payment_instruction/eligible_payment_info`;
+  }
+  addPaymentInstructionUrl() {
+    return `${this.client.transactionBaseUrl}/cart/@self/payment_instruction`;
+  }
+  deletePaymentInstructionUrl(piId) {
+    return `${this.client.transactionBaseUrl}/cart/@self/payment_instruction/${encodeURIComponent(piId)}`;
+  }
+  shippingModesUrl() {
+    return `${this.client.transactionBaseUrl}/cart/@self/shipping_info`;
+  }
+  shippingModesParams() {
+    const params = new URLSearchParams();
+    params.set("profileName", "IBM_usableShippingMode");
+    return params;
+  }
+  shippingInfoUrl() {
+    return `${this.client.transactionBaseUrl}/cart/@self/shipping_info`;
+  }
+  setShippingInfoPayload(body) {
+    return {
+      ...body,
+      x_calculateOrder: "1",
+      x_calculationUsage: "-1,-2,-3,-4,-5,-6,-7"
+    };
+  }
+  setShippingAddressForItemsPayload(orderItemIds, addr) {
+    return {
+      x_calculateOrder: "1",
+      x_calculationUsage: "-1,-2,-3,-4,-5,-6,-7",
+      orderItem: orderItemIds.map((orderItemId) => ({
+        orderItemId,
+        x_addr: addr
+      }))
+    };
+  }
+  precheckoutUrl() {
+    return `${this.client.transactionBaseUrl}/cart/@self/precheckout`;
+  }
+  submitCheckoutUrl() {
+    return `${this.client.transactionBaseUrl}/cart/@self/checkout`;
+  }
+  async initiateCheckoutForCart(payload) {
+    debug("initiateCheckoutForCart orderId=%s", payload.cart.identifier.key);
+    if (payload.notificationEmail) {
+      this.context.session["hcl.notificationEmail"] = payload.notificationEmail;
+    }
+    if (payload.billingAddress) {
+      const addr = payload.billingAddress;
+      const methodsResp = await this.client.callGet(
+        this.paymentMethodsUrl(),
+        void 0,
+        { allowUndefined: true }
+      ) ?? { usablePaymentInformation: [] };
+      const firstMethod = methodsResp.usablePaymentInformation?.[0];
+      if (firstMethod) {
+        const cartData = await this.fetchWcsCart();
+        for (const pi of cartData.paymentInstruction ?? []) {
+          await this.client.callDelete(
+            this.deletePaymentInstructionUrl(pi.piId),
+            {
+              ignore404: true
+            }
+          );
+        }
+        await this.client.callPost(
+          this.addPaymentInstructionUrl(),
+          {
+            payMethodId: firstMethod.paymentMethodName,
+            billto_firstName: addr.firstName,
+            billto_lastName: addr.lastName,
+            billto_address1: `${addr.streetAddress} ${addr.streetNumber}`.trim(),
+            billto_city: addr.city,
+            billto_state: addr.region,
+            billto_zipCode: addr.postalCode,
+            billto_country: addr.countryCode,
+            billto_phone1: payload.notificationPhone,
+            billto_email1: payload.notificationEmail
+          }
+        );
+      }
+    }
+    return success(await this.fetchCheckout());
+  }
+  async getById(_payload) {
+    debug("getById");
+    try {
+      return success(await this.fetchCheckout());
+    } catch (err) {
+      if (err instanceof HclCartNotFoundError) {
+        return error({ type: "NotFound", identifier: "" });
+      }
+      throw err;
+    }
+  }
+  async setShippingAddress(payload) {
+    debug("setShippingAddress");
+    const cartData = await this.fetchWcsCart();
+    const orderItemIds = (cartData.orderItem ?? []).map((i) => i.orderItemId);
+    const addr = payload.shippingAddress;
+    await this.client.callPut(
+      this.shippingInfoUrl(),
+      this.setShippingAddressForItemsPayload(orderItemIds, {
+        firstName: addr.firstName,
+        lastName: addr.lastName,
+        address1: `${addr.streetAddress} ${addr.streetNumber}`.trim(),
+        city: addr.city,
+        state: addr.region,
+        zipCode: addr.postalCode,
+        country: addr.countryCode
+      })
+    );
+    return success(await this.fetchCheckout());
+  }
+  async getAvailableShippingMethods(_payload) {
+    debug("getAvailableShippingMethods");
+    const response = await this.client.callGet(
+      this.shippingModesUrl(),
+      this.shippingModesParams()
+    );
+    let modes;
+    if (response.usableShippingMode && response.usableShippingMode.length > 0) {
+      modes = response.usableShippingMode.map(
+        (mode) => this.factory.parseShippingMethod(this.context, mode)
+      );
+    } else {
+      const seen = /* @__PURE__ */ new Set();
+      modes = [];
+      for (const item of response.orderItem ?? []) {
+        if (item.shipModeId && !seen.has(item.shipModeId)) {
+          seen.add(item.shipModeId);
+          modes.push(
+            this.factory.parseShippingMethod(this.context, {
+              shipModeId: item.shipModeId,
+              carrier: item.carrier ?? "",
+              shipModeCode: item.shipModeCode ?? "",
+              shipModeDescription: item.shipModeDescription ?? item.description ?? item.shipModeCode ?? ""
+            })
+          );
+        }
+      }
+    }
+    return success(modes);
+  }
+  async getAvailablePaymentMethods(_payload) {
+    debug("getAvailablePaymentMethods");
+    const response = await this.client.callGet(
+      this.paymentMethodsUrl(),
+      void 0,
+      { allowUndefined: true }
+    ) ?? { usablePaymentInformation: [] };
+    const methods = (response.usablePaymentInformation ?? []).map(
+      (method) => this.factory.parsePaymentMethod(this.context, method)
+    );
+    return success(methods);
+  }
+  async addPaymentInstruction(payload) {
+    debug(
+      "addPaymentInstruction payMethodId=%s",
+      payload.paymentInstruction.paymentMethod.method
+    );
+    await this.client.callPost(
+      this.addPaymentInstructionUrl(),
+      {
+        payMethodId: payload.paymentInstruction.paymentMethod.method,
+        piAmount: payload.paymentInstruction.amount ? String(payload.paymentInstruction.amount.value) : void 0,
+        protocolData: payload.paymentInstruction.protocolData.map((pd) => ({
+          name: pd.key,
+          value: pd.value
+        }))
+      }
+    );
+    return success(await this.fetchCheckout());
+  }
+  async removePaymentInstruction(payload) {
+    debug("removePaymentInstruction piId=%s", payload.paymentInstruction.key);
+    await this.client.callDelete(
+      this.deletePaymentInstructionUrl(payload.paymentInstruction.key),
+      {
+        ignore404: true
+      }
+    );
+    return success(await this.fetchCheckout());
+  }
+  async setShippingInstruction(payload) {
+    debug(
+      "setShippingInstruction shipModeId=%s",
+      payload.shippingInstruction.shippingMethod.key
+    );
+    const cartData = await this.fetchWcsCart();
+    const orderItemIds = (cartData.orderItem ?? []).map((i) => i.orderItemId);
+    await this.client.callPut(
+      this.shippingInfoUrl(),
+      this.setShippingInfoPayload({
+        shipModeId: payload.shippingInstruction.shippingMethod.key,
+        orderItemId: orderItemIds
+      })
+    );
+    return success(await this.fetchCheckout());
+  }
+  async finalizeCheckout(_payload) {
+    debug("finalizeCheckout");
+    const cartBefore = await this.fetchWcsCart();
+    await this.client.callPut(
+      this.precheckoutUrl(),
+      {}
+    );
+    const result = await this.client.callPost(
+      this.submitCheckoutUrl(),
+      {}
+    );
+    const checkout = this.factory.parseCheckout(this.context, {
+      ...cartBefore,
+      resultingOrderKey: result.orderId
+    });
+    return success(checkout);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationInitiateCheckoutSchema,
+    outputSchema: CheckoutSchema
+  })
+], HclCheckoutCapability.prototype, "initiateCheckoutForCart", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutQueryByIdSchema,
+    outputSchema: CheckoutSchema
+  })
+], HclCheckoutCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationSetShippingAddressSchema,
+    outputSchema: CheckoutSchema
+  })
+], HclCheckoutCapability.prototype, "setShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutQueryForAvailableShippingMethodsSchema,
+    outputSchema: ShippingMethodSchema.array()
+  })
+], HclCheckoutCapability.prototype, "getAvailableShippingMethods", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutQueryForAvailablePaymentMethodsSchema,
+    outputSchema: PaymentMethodSchema.array()
+  })
+], HclCheckoutCapability.prototype, "getAvailablePaymentMethods", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationAddPaymentInstructionSchema,
+    outputSchema: CheckoutSchema
+  })
+], HclCheckoutCapability.prototype, "addPaymentInstruction", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationRemovePaymentInstructionSchema,
+    outputSchema: CheckoutSchema
+  })
+], HclCheckoutCapability.prototype, "removePaymentInstruction", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationSetShippingInstructionSchema,
+    outputSchema: CheckoutSchema
+  })
+], HclCheckoutCapability.prototype, "setShippingInstruction", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationFinalizeCheckoutSchema,
+    outputSchema: CheckoutSchema
+  })
+], HclCheckoutCapability.prototype, "finalizeCheckout", 1);
+export {
+  HclCheckoutCapability
+};

package/capabilities/identity.capability.js

@@ -0,0 +1,214 @@
+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 {
+  IdentityMutationLoginSchema,
+  IdentityMutationLogoutSchema,
+  IdentityMutationRegisterSchema,
+  IdentityQuerySelfSchema,
+  IdentityCapability,
+  IdentitySchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import {
+  SESSION_KEY_WC_TOKEN,
+  SESSION_KEY_WC_TRUSTED_TOKEN,
+  SESSION_KEY_USER_ID,
+  SESSION_KEY_IDENTITY_TYPE,
+  SESSION_KEY_PERSONALIZATION_ID
+} from "../core/session-keys.js";
+import createDebug from "debug";
+const debug = createDebug("reactionary:hcl:identity");
+class HclIdentityCapability extends IdentityCapability {
+  config;
+  client;
+  factory;
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  async getSelf(_payload) {
+    const wcToken = this.context.session[SESSION_KEY_WC_TOKEN];
+    if (!wcToken) {
+      debug("No WCS session token \u2014 returning anonymous identity");
+      if (!this.context.session[SESSION_KEY_PERSONALIZATION_ID]) {
+        this.context.session[SESSION_KEY_PERSONALIZATION_ID] = crypto.randomUUID().replace(/-/g, "").slice(0, 30);
+      }
+      const parsed2 = this.factory.parseIdentity(this.context, {
+        type: "Anonymous"
+      });
+      this.updateIdentityContext(parsed2);
+      return success(parsed2);
+    }
+    const identityType = this.context.session[SESSION_KEY_IDENTITY_TYPE];
+    const userId = this.context.session[SESSION_KEY_USER_ID];
+    if (identityType === "registered" && userId) {
+      debug("Registered session found for userId %s", userId);
+      const parsed2 = this.factory.parseIdentity(this.context, {
+        type: "Registered",
+        id: { userId }
+      });
+      this.updateIdentityContext(parsed2);
+      return success(parsed2);
+    }
+    if (identityType === "guest" && userId) {
+      debug("Guest session found for userId %s", userId);
+      const parsed2 = this.factory.parseIdentity(this.context, {
+        type: "Guest",
+        id: { userId }
+      });
+      this.updateIdentityContext(parsed2);
+      return success(parsed2);
+    }
+    debug("WCS token present but identity type unknown \u2014 returning anonymous");
+    const parsed = this.factory.parseIdentity(this.context, {
+      type: "Anonymous"
+    });
+    this.updateIdentityContext(parsed);
+    return success(parsed);
+  }
+  async login(payload) {
+    debug("Attempting login for user: %s", payload.username);
+    const response = await this.client.callPost(
+      this.loginIdentityUrl(),
+      this.loginIdentityPayload(payload.username, payload.password)
+    );
+    this.storeSessionTokens(
+      response.WCToken,
+      response.WCTrustedToken,
+      response.userId,
+      "registered",
+      response.personalizationID
+    );
+    const loginParsed = this.factory.parseIdentity(this.context, {
+      type: "Registered",
+      id: { userId: response.userId }
+    });
+    this.updateIdentityContext(loginParsed);
+    return success(loginParsed);
+  }
+  async logout(_payload) {
+    debug("Logging out current session");
+    const wcToken = this.context.session[SESSION_KEY_WC_TOKEN];
+    const userId = this.context.session[SESSION_KEY_USER_ID];
+    if (wcToken && userId) {
+      try {
+        await this.client.callDelete(this.deleteLoginIdentityUrl(userId), {
+          ignore404: true
+        });
+      } catch (err) {
+        debug("Server-side logout failed (non-fatal): %o", err);
+      }
+    }
+    this.clearSessionTokens();
+    const logoutParsed = this.factory.parseIdentity(this.context, {
+      type: "Anonymous"
+    });
+    this.updateIdentityContext(logoutParsed);
+    return success(logoutParsed);
+  }
+  async register(payload) {
+    debug("Registering new user: %s", payload.username);
+    const guest = await this.client.callPost(
+      this.createGuestIdentityUrl()
+    );
+    this.storeSessionTokens(
+      guest.WCToken,
+      guest.WCTrustedToken,
+      guest.userId,
+      "guest",
+      guest.personalizationID
+    );
+    const registered = await this.client.callPut(
+      this.registerPersonUrl(),
+      this.registerPersonPayload(payload.username, payload.password)
+    );
+    this.storeSessionTokens(
+      registered.WCToken,
+      registered.WCTrustedToken,
+      registered.userId,
+      "registered",
+      registered.personalizationID
+    );
+    const registerParsed = this.factory.parseIdentity(this.context, {
+      type: "Registered",
+      id: { userId: registered.userId }
+    });
+    this.updateIdentityContext(registerParsed);
+    return success(registerParsed);
+  }
+  storeSessionTokens(wcToken, wcTrustedToken, userId, identityType, personalizationID) {
+    this.context.session[SESSION_KEY_WC_TOKEN] = wcToken;
+    this.context.session[SESSION_KEY_WC_TRUSTED_TOKEN] = wcTrustedToken;
+    this.context.session[SESSION_KEY_USER_ID] = userId;
+    this.context.session[SESSION_KEY_IDENTITY_TYPE] = identityType;
+    if (personalizationID) {
+      this.context.session[SESSION_KEY_PERSONALIZATION_ID] = personalizationID;
+    } else {
+      delete this.context.session[SESSION_KEY_PERSONALIZATION_ID];
+    }
+  }
+  clearSessionTokens() {
+    delete this.context.session[SESSION_KEY_WC_TOKEN];
+    delete this.context.session[SESSION_KEY_WC_TRUSTED_TOKEN];
+    delete this.context.session[SESSION_KEY_USER_ID];
+    delete this.context.session[SESSION_KEY_IDENTITY_TYPE];
+    delete this.context.session[SESSION_KEY_PERSONALIZATION_ID];
+  }
+  loginIdentityUrl() {
+    return `${this.client.transactionBaseUrl}/loginidentity`;
+  }
+  loginIdentityPayload(logonId, logonPassword) {
+    return { logonId, logonPassword };
+  }
+  deleteLoginIdentityUrl(userId) {
+    return `${this.client.transactionBaseUrl}/loginidentity/${encodeURIComponent(userId)}`;
+  }
+  createGuestIdentityUrl() {
+    return `${this.client.transactionBaseUrl}/guestidentity`;
+  }
+  registerPersonUrl() {
+    return `${this.client.transactionBaseUrl}/person/@self`;
+  }
+  registerPersonPayload(logonId, logonPassword) {
+    return { logonId, logonPassword, logonPasswordVerify: logonPassword };
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityQuerySelfSchema,
+    outputSchema: IdentitySchema
+  })
+], HclIdentityCapability.prototype, "getSelf", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationLoginSchema,
+    outputSchema: IdentitySchema
+  })
+], HclIdentityCapability.prototype, "login", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationLogoutSchema,
+    outputSchema: IdentitySchema
+  })
+], HclIdentityCapability.prototype, "logout", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationRegisterSchema,
+    outputSchema: IdentitySchema
+  })
+], HclIdentityCapability.prototype, "register", 1);
+export {
+  HclIdentityCapability
+};

package/capabilities/inventory.capability.js

@@ -0,0 +1,75 @@
+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,
+  error,
+  success
+} from "@reactionary/core";
+class HclInventoryCapability extends InventoryCapability {
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  async getBySKU(payload) {
+    const { sku } = payload.variant;
+    const centreKey = payload.fulfilmentCenter.key;
+    const response = await this.client.callGet(
+      this.getBySKUUrl(payload),
+      this.getBySKUPayload(payload)
+    );
+    const items = response.InventoryAvailability ?? [];
+    let item = items.find(
+      (i) => centreKey ? i.physicalStoreName === centreKey : !i.physicalStoreId
+    );
+    if (!item && items.length > 0) {
+      item = items[0];
+    }
+    if (!item) {
+      const notFound = {
+        type: "NotFound",
+        identifier: { variant: { sku }, fulfillmentCenter: { key: centreKey } }
+      };
+      return error(notFound);
+    }
+    return success(
+      this.factory.parseInventory(this.context, {
+        item,
+        sku,
+        fulfilmentCenterKey: centreKey
+      })
+    );
+  }
+  getBySKUUrl(payload) {
+    return `${this.client.transactionBaseUrl}/inventoryavailability/byPartNumber/${encodeURIComponent(payload.variant.sku)}`;
+  }
+  getBySKUPayload(payload) {
+    const params = new URLSearchParams();
+    const centreKey = payload.fulfilmentCenter.key;
+    if (centreKey)
+      params.set("physicalStoreName", centreKey);
+    return params;
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: InventoryQueryBySKUSchema,
+    outputSchema: InventorySchema
+  })
+], HclInventoryCapability.prototype, "getBySKU", 1);
+export {
+  HclInventoryCapability
+};