@reactionary/medusa 0.6.3

package/capabilities/checkout.capability.js

@@ -0,0 +1,533 @@
+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 {
+  AddressIdentifierSchema,
+  CheckoutMutationAddPaymentInstructionSchema,
+  CheckoutMutationFinalizeCheckoutSchema,
+  CheckoutMutationInitiateCheckoutSchema,
+  CheckoutMutationRemovePaymentInstructionSchema,
+  CheckoutMutationSetShippingAddressSchema,
+  CheckoutMutationSetShippingInstructionSchema,
+  CheckoutCapability,
+  CheckoutQueryByIdSchema,
+  CheckoutQueryForAvailablePaymentMethodsSchema,
+  CheckoutQueryForAvailableShippingMethodsSchema,
+  CheckoutSchema,
+  MonetaryAmountSchema,
+  PaymentMethodSchema,
+  Reactionary,
+  ShippingMethodIdentifierSchema,
+  ShippingMethodSchema,
+  success,
+  error
+} from "@reactionary/core";
+import createDebug from "debug";
+import * as z from "zod";
+import { handleProviderError, parseMedusaCostBreakdown, parseMedusaItemPrice } from "../utils/medusa-helpers.js";
+import {
+} from "../schema/medusa.schema.js";
+const debug = createDebug("reactionary:medusa:checkout");
+class CheckoutNotReadyForFinalizationError extends Error {
+  constructor(checkoutIdentifier) {
+    super(
+      "Checkout is not ready for finalization. Ensure all required fields are set and valid. " + (checkoutIdentifier ? `Checkout ID: ${JSON.stringify(checkoutIdentifier)}` : "")
+    );
+    this.checkoutIdentifier = checkoutIdentifier;
+    this.name = "CheckoutNotReadyForFinalizationError";
+  }
+}
+class MedusaCheckoutCapability extends CheckoutCapability {
+  constructor(config, cache, context, medusaApi, factory) {
+    super(cache, context);
+    this.medusaApi = medusaApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  config;
+  factory;
+  /**
+   * This controls which fields are always included when fetching a cart
+   * You can override this in a subclass to add more fields as needed.
+   *
+   * example: this.includedFields = [includedFields, '+discounts.*'].join(',');
+   */
+  includedFields = ["+items.*"].join(",");
+  initiateCheckoutForCartPayload(payload) {
+    return {
+      billing_address: payload.billingAddress ? this.mapAddressToStoreAddress(payload.billingAddress) : void 0,
+      shipping_address: payload.billingAddress ? this.mapAddressToStoreAddress(payload.billingAddress) : void 0,
+      email: payload.notificationEmail,
+      metadata: {
+        sms_notification: payload.notificationPhone
+      }
+    };
+  }
+  async initiateCheckoutForCart(payload) {
+    const client = await this.medusaApi.getClient();
+    if (debug.enabled) {
+      debug(
+        `Initiating checkout for cart with key: ${payload.cart.identifier.key}`
+      );
+    }
+    const response = await client.store.cart.update(
+      payload.cart.identifier.key,
+      this.initiateCheckoutForCartPayload(payload),
+      {
+        fields: this.includedFields
+      }
+    );
+    return success(this.parseSingle(response.cart));
+  }
+  async getById(payload) {
+    const client = await this.medusaApi.getClient();
+    const response = await client.store.cart.retrieve(payload.identifier.key, {
+      fields: this.includedFields
+    });
+    return success(this.parseSingle(response.cart));
+  }
+  setShippingAddressPayload(payload) {
+    return {
+      shipping_address: this.mapAddressToStoreAddress(payload.shippingAddress)
+    };
+  }
+  async setShippingAddress(payload) {
+    const client = await this.medusaApi.getClient();
+    const response = await client.store.cart.update(
+      payload.checkout.key,
+      this.setShippingAddressPayload(payload),
+      {
+        fields: this.includedFields
+      }
+    );
+    return success(this.parseSingle(response.cart));
+  }
+  getAvailableShippingMethodsPayload(payload) {
+    return {
+      cart_id: payload.checkout.key
+    };
+  }
+  async getAvailableShippingMethods(payload) {
+    const client = await this.medusaApi.getClient();
+    if (debug.enabled) {
+      debug(
+        `Fetching available shipping methods for checkout with key: ${payload.checkout.key}`
+      );
+    }
+    const shippingMethodResponse = await client.store.fulfillment.listCartOptions(
+      this.getAvailableShippingMethodsPayload(payload)
+    );
+    const shippingMethods = [];
+    for (const sm of shippingMethodResponse.shipping_options) {
+      shippingMethods.push(
+        ShippingMethodSchema.parse({
+          identifier: ShippingMethodIdentifierSchema.parse({ key: sm.id }),
+          name: sm.name,
+          description: sm.type.description || "",
+          price: MonetaryAmountSchema.parse({
+            value: sm.calculated_price.calculated_amount || 0,
+            currency: sm.calculated_price.currency_code?.toUpperCase()
+          }),
+          deliveryTime: ""
+        })
+      );
+    }
+    if (debug.enabled) {
+      debug(
+        `Found ${shippingMethods.length} shipping methods for checkout with key: ${payload.checkout.key}`,
+        shippingMethods
+      );
+    }
+    return success(
+      shippingMethods.map((x) => this.factory.parseShippingMethod(this.context, x))
+    );
+  }
+  getAvailablePaymentMethodsPayload(payload, regionId) {
+    return {
+      region_id: regionId
+    };
+  }
+  async getAvailablePaymentMethods(payload) {
+    const client = await this.medusaApi.getClient();
+    if (debug.enabled) {
+      debug(
+        `Fetching available payment methods for checkout with key: ${payload.checkout.key}`
+      );
+    }
+    const checkout = await client.store.cart.retrieve(payload.checkout.key);
+    const paymentMethodResponse = await client.store.payment.listPaymentProviders(
+      this.getAvailablePaymentMethodsPayload(
+        payload,
+        checkout.cart.region_id || (await this.medusaApi.getActiveRegion()).id
+      )
+    );
+    const paymentMethods = [];
+    for (const pm of paymentMethodResponse.payment_providers) {
+      paymentMethods.push(
+        {
+          identifier: {
+            method: pm.id,
+            name: pm.id,
+            paymentProcessor: pm.id
+          },
+          logo: void 0,
+          description: pm.id,
+          isPunchOut: true
+        }
+      );
+    }
+    if (debug.enabled) {
+      debug(
+        `Found ${paymentMethods.length} payment methods for checkout with key: ${payload.checkout.key}`,
+        paymentMethods
+      );
+    }
+    return success(
+      paymentMethods.map((x) => this.factory.parsePaymentMethod(this.context, x))
+    );
+  }
+  addPaymentInstructionPayload(payload) {
+    return {
+      provider_id: payload.paymentInstruction.paymentMethod.method,
+      data: payload.paymentInstruction.protocolData.reduce((acc, curr) => {
+        acc[curr.key] = curr.value;
+        return acc;
+      }, {})
+    };
+  }
+  async addPaymentInstruction(payload) {
+    const client = await this.medusaApi.getClient();
+    if (debug.enabled) {
+      debug(
+        `Adding payment instruction ${payload.paymentInstruction.paymentMethod.name} to checkout with key: ${payload.checkout.key}`
+      );
+    }
+    try {
+      const cartResponse = await client.store.cart.retrieve(
+        payload.checkout.key
+      );
+      const paymentSessionResponse = await client.store.payment.initiatePaymentSession(cartResponse.cart, this.addPaymentInstructionPayload(payload));
+      const updatedCartResponse = await client.store.cart.retrieve(
+        payload.checkout.key,
+        {
+          fields: this.includedFields
+        }
+      );
+      return success(this.parseSingle(updatedCartResponse.cart));
+    } catch (error2) {
+      debug("Failed to add payment instruction: {0}", [error2]);
+      throw new Error(
+        `Failed to add payment instruction: ${error2 instanceof Error ? error2.message : "Unknown error"}`
+      );
+    }
+  }
+  removePaymentInstruction(payload) {
+    throw new Error("Method not implemented.");
+  }
+  setShippingInstructionPayload(payload) {
+    return {
+      option_id: payload.shippingInstruction.shippingMethod.key,
+      data: {
+        consent_for_unattended_delivery: payload.shippingInstruction.consentForUnattendedDelivery + "",
+        instructions: payload.shippingInstruction.instructions || ""
+      }
+    };
+  }
+  async setShippingInstruction(payload) {
+    const client = await this.medusaApi.getClient();
+    const medusaId = payload.checkout;
+    try {
+      if (payload.shippingInstruction.shippingMethod) {
+        await client.store.cart.addShippingMethod(medusaId.key, this.setShippingInstructionPayload(payload));
+      }
+      await client.store.cart.update(medusaId.key, {
+        metadata: {
+          consent_for_unattended_delivery: payload.shippingInstruction.consentForUnattendedDelivery + "",
+          instructions: payload.shippingInstruction.instructions || "",
+          pickup_point: payload.shippingInstruction.pickupPoint || ""
+        }
+      });
+      const response = await client.store.cart.retrieve(medusaId.key, {
+        fields: this.includedFields
+      });
+      if (response.cart) {
+        return success(this.parseSingle(response.cart));
+      }
+      throw new Error("Failed to set shipping method");
+    } catch (error2) {
+      handleProviderError("set shipping method", error2);
+    }
+  }
+  async finalizeCheckout(payload) {
+    const checkout = await this.getById({ identifier: payload.checkout });
+    if (!checkout.success || !checkout.value.readyForFinalization) {
+      throw new CheckoutNotReadyForFinalizationError(payload.checkout);
+    }
+    const client = await this.medusaApi.getClient();
+    const medusaId = payload.checkout;
+    const response = await client.store.cart.complete(medusaId.key);
+    if (response.type === "order") {
+      await client.store.cart.update(medusaId.key, {
+        metadata: {
+          order_id: response.order.id,
+          order_display_id: response.order?.display_id ? 0 : ""
+        }
+      });
+      const refreshedCheckout = await this.getById({
+        identifier: payload.checkout
+      });
+      if (!refreshedCheckout.success) {
+        throw new Error(`Unable to reload checkout ${payload.checkout.key} after completion`);
+      }
+      return success(refreshedCheckout.value);
+    }
+    throw new Error("Something failed during order creation");
+  }
+  /**
+   * Extension point to map an Address to a Store Address
+   * @param address
+   * @returns
+   */
+  mapAddressToStoreAddress(address) {
+    return {
+      first_name: address.firstName,
+      last_name: address.lastName,
+      address_1: address.streetAddress,
+      address_2: address.streetNumber || "",
+      city: address.city,
+      postal_code: address.postalCode,
+      country_code: address.countryCode?.toLowerCase()
+    };
+  }
+  /**
+   * Extension point to control the parsing of an address from a store cart address
+   * @param storeAddress
+   * @returns
+   */
+  composeAddressFromStoreAddress(storeAddress) {
+    return {
+      identifier: AddressIdentifierSchema.parse({
+        nickName: storeAddress.id
+      }),
+      firstName: storeAddress.first_name || "",
+      lastName: storeAddress.last_name || "",
+      streetAddress: storeAddress.address_1 || "",
+      streetNumber: storeAddress.address_2 || "",
+      city: storeAddress.city || "",
+      postalCode: storeAddress.postal_code || "",
+      countryCode: storeAddress.country_code || "",
+      region: ""
+    };
+  }
+  /**
+   * Extension point to control the parsing of a single cart item price
+   * @param remoteItem
+   * @param currency
+   * @returns
+   */
+  parseItemPrice(remoteItem, currency) {
+    return parseMedusaItemPrice(remoteItem, currency);
+  }
+  /**
+   * Extension point to control the parsing of the cost breakdown of a cart
+   * @param remote
+   * @returns
+   */
+  parseCostBreakdown(remote) {
+    return parseMedusaCostBreakdown(remote);
+  }
+  /**
+   * Extension point to control the parsing of a single checkout item
+   * @param remoteItem
+   * @param currency
+   * @returns
+   */
+  parseCheckoutItem(remoteItem, currency) {
+    const unitPrice = remoteItem.unit_price || 0;
+    const totalPrice = unitPrice * remoteItem.quantity || 0;
+    const discountTotal = remoteItem.discount_total || 0;
+    const item = {
+      identifier: {
+        key: remoteItem.id
+      },
+      variant: {
+        sku: remoteItem.variant_sku || ""
+      },
+      quantity: remoteItem.quantity || 1,
+      price: this.parseItemPrice(remoteItem, currency)
+    };
+    return item;
+  }
+  /**
+   * Extension point to control the parsing of the Checkout object
+   * @param remote
+   * @returns
+   */
+  parseSingle(remote) {
+    const identifier = {
+      key: remote.id
+      //        region_id: remote.region_id,
+    };
+    const name = "" + (remote.metadata?.["name"] || "");
+    const description = "" + (remote.metadata?.["description"] || "");
+    const price = this.parseCostBreakdown(remote);
+    const items = new Array();
+    for (const remoteItem of remote.items || []) {
+      items.push(this.parseCheckoutItem(remoteItem, price.grandTotal.currency));
+    }
+    const billingAddress = remote.billing_address ? this.composeAddressFromStoreAddress(remote.billing_address) : void 0;
+    const shippingAddress = remote.shipping_address ? this.composeAddressFromStoreAddress(remote.shipping_address) : void 0;
+    const backupUnattendedDelivery = remote.metadata?.["consent_for_unattended_delivery"] !== void 0 ? remote.metadata?.["consent_for_unattended_delivery"] === "true" : void 0;
+    const backupInstructions = remote.metadata?.["instructions"] !== void 0 ? remote.metadata?.["instructions"] + "" : void 0;
+    const backupPickupPoint = remote.metadata?.["pickup_point"] !== void 0 ? remote.metadata?.["pickup_point"] + "" : void 0;
+    let shippingInstruction;
+    remote.shipping_methods?.forEach((sm) => {
+      let pickupPoint = "";
+      let instructions = "";
+      let consentForUnattendedDelivery = false;
+      if (sm.data) {
+        pickupPoint = sm.data["pickup_point"] + "" || "";
+        instructions = sm.data["instructions"] + "" || "";
+        consentForUnattendedDelivery = sm.data["consent_for_unattended_delivery"] === "true";
+      }
+      if (!pickupPoint) {
+        pickupPoint = backupPickupPoint || "";
+      }
+      if (!instructions) {
+        instructions = backupInstructions || "";
+      }
+      if (!consentForUnattendedDelivery) {
+        consentForUnattendedDelivery = backupUnattendedDelivery || false;
+      }
+      shippingInstruction = {
+        shippingMethod: { key: sm.shipping_option_id },
+        consentForUnattendedDelivery,
+        instructions,
+        pickupPoint
+      };
+    });
+    const paymentInstructions = new Array();
+    for (const remotePayment of remote.payment_collection?.payment_sessions || []) {
+      if (remotePayment.status === "canceled" || remotePayment.status === "error") {
+        console.warn(
+          `Skipping payment session ${remotePayment.id} with status ${remotePayment.status}`
+        );
+        continue;
+      }
+      const paymentMethodIdentifier = {
+        method: remotePayment.provider_id,
+        name: remotePayment.provider_id,
+        paymentProcessor: remotePayment.provider_id
+      };
+      paymentInstructions.push(
+        {
+          identifier: {
+            key: remotePayment.id
+          },
+          amount: {
+            value: remotePayment.amount,
+            currency: remotePayment.currency_code?.toUpperCase()
+          },
+          paymentMethod: paymentMethodIdentifier,
+          protocolData: remotePayment.data ? Object.entries(remotePayment.data).map(([key, value]) => ({
+            key,
+            value: String(value)
+          })) : [],
+          status: "pending"
+        }
+      );
+    }
+    const originalCartReference = {
+      key: remote.id,
+      region: remote.region_id
+    };
+    let resultingOrder = void 0;
+    if (remote.metadata?.["order_id"]) {
+      resultingOrder = {
+        key: remote.metadata?.["order_id"] + "" || "",
+        display_id: Number(remote.metadata?.["order_display_id"] + "" || "0")
+      };
+    }
+    const result = {
+      identifier,
+      name,
+      description,
+      price,
+      items,
+      originalCartReference,
+      paymentInstructions,
+      readyForFinalization: false,
+      billingAddress,
+      resultingOrder,
+      shippingAddress,
+      shippingInstruction
+    };
+    return this.factory.parseCheckout(this.context, result);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationInitiateCheckoutSchema,
+    outputSchema: CheckoutSchema
+  })
+], MedusaCheckoutCapability.prototype, "initiateCheckoutForCart", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutQueryByIdSchema,
+    outputSchema: CheckoutSchema.nullable()
+  })
+], MedusaCheckoutCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationSetShippingAddressSchema,
+    outputSchema: CheckoutSchema
+  })
+], MedusaCheckoutCapability.prototype, "setShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutQueryForAvailableShippingMethodsSchema,
+    outputSchema: z.array(ShippingMethodSchema)
+  })
+], MedusaCheckoutCapability.prototype, "getAvailableShippingMethods", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutQueryForAvailablePaymentMethodsSchema,
+    outputSchema: z.array(PaymentMethodSchema)
+  })
+], MedusaCheckoutCapability.prototype, "getAvailablePaymentMethods", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationAddPaymentInstructionSchema,
+    outputSchema: CheckoutSchema
+  })
+], MedusaCheckoutCapability.prototype, "addPaymentInstruction", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationRemovePaymentInstructionSchema,
+    outputSchema: CheckoutSchema
+  })
+], MedusaCheckoutCapability.prototype, "removePaymentInstruction", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationSetShippingInstructionSchema,
+    outputSchema: CheckoutSchema
+  })
+], MedusaCheckoutCapability.prototype, "setShippingInstruction", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CheckoutMutationFinalizeCheckoutSchema,
+    outputSchema: CheckoutSchema
+  })
+], MedusaCheckoutCapability.prototype, "finalizeCheckout", 1);
+export {
+  CheckoutNotReadyForFinalizationError,
+  MedusaCheckoutCapability
+};

package/capabilities/identity.capability.js

@@ -0,0 +1,128 @@
+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:medusa:identity");
+class MedusaIdentityCapability extends IdentityCapability {
+  config;
+  medusaApi;
+  constructor(config, cache, context, medusaApi) {
+    super(cache, context);
+    this.config = config;
+    this.medusaApi = medusaApi;
+  }
+  createAnonymousIdentity() {
+    return {
+      type: "Anonymous"
+    };
+  }
+  async getSelf(_payload) {
+    try {
+      const medusaClient = await this.medusaApi.getClient();
+      const token = await medusaClient.client.getToken();
+      if (!token) {
+        debug("No active session token found, returning anonymous identity");
+        const identity2 = this.createAnonymousIdentity();
+        this.updateIdentityContext(identity2);
+        return success(identity2);
+      }
+      const customerResponse = await medusaClient.store.customer.retrieve();
+      if (customerResponse.customer) {
+        debug("Customer authenticated:", customerResponse.customer.email);
+        const identity2 = {
+          id: {
+            userId: customerResponse.customer.id
+          },
+          type: "Registered"
+        };
+        this.updateIdentityContext(identity2);
+        return success(identity2);
+      }
+      const identity = this.createAnonymousIdentity();
+      this.updateIdentityContext(identity);
+      return success(identity);
+    } catch (error) {
+      debug("getSelf failed, returning anonymous identity:", error);
+      const identity = this.createAnonymousIdentity();
+      this.updateIdentityContext(identity);
+      return success(identity);
+    }
+  }
+  async login(payload) {
+    debug("Attempting login for user:", payload.username);
+    const identity = await this.medusaApi.login(
+      payload.username,
+      payload.password,
+      this.context
+    );
+    this.updateIdentityContext(identity);
+    return success(identity);
+  }
+  async logout(_payload) {
+    debug("Logging out user");
+    const identity = await this.medusaApi.logout(this.context);
+    this.updateIdentityContext(identity);
+    return success(identity);
+  }
+  async register(payload) {
+    debug("Registering new user:", payload.username);
+    const nameParts = payload.username.split(".");
+    const firstName = nameParts[0] || "User";
+    const lastName = nameParts.slice(1).join(" ") || "Account";
+    const identity = await this.medusaApi.register(
+      payload.username,
+      // Using username as email
+      payload.password,
+      firstName,
+      lastName,
+      this.context
+    );
+    this.updateIdentityContext(identity);
+    return success(identity);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityQuerySelfSchema,
+    outputSchema: IdentitySchema
+  })
+], MedusaIdentityCapability.prototype, "getSelf", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationLoginSchema,
+    outputSchema: IdentitySchema
+  })
+], MedusaIdentityCapability.prototype, "login", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationLogoutSchema,
+    outputSchema: IdentitySchema
+  })
+], MedusaIdentityCapability.prototype, "logout", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationRegisterSchema,
+    outputSchema: IdentitySchema
+  })
+], MedusaIdentityCapability.prototype, "register", 1);
+export {
+  MedusaIdentityCapability
+};