@reactionary/provider-medusa 0.2.1 → 0.2.3

package/core/initialize.js

@@ -1,14 +1,17 @@
 import { MedusaCartProvider } from "../providers/cart.provider.js";
+import { MedusaCategoryProvider } from "../providers/category.provider.js";
+import { MedusaCheckoutProvider } from "../providers/checkout.provider.js";
 import { MedusaIdentityProvider } from "../providers/identity.provider.js";
 import { MedusaInventoryProvider } from "../providers/inventory.provider.js";
+import { MedusaOrderSearchProvider } from "../providers/order-search.provider.js";
+import { MedusaOrderProvider } from "../providers/order.provider.js";
 import { MedusaPriceProvider } from "../providers/price.provider.js";
-import { MedusaCapabilitiesSchema } from "../schema/capabilities.schema.js";
-import { MedusaConfigurationSchema } from "../schema/configuration.schema.js";
 import { MedusaSearchProvider } from "../providers/product-search.provider.js";
 import { MedusaProductProvider } from "../providers/product.provider.js";
+import { MedusaProfileProvider } from "../providers/profile.provider.js";
+import { MedusaCapabilitiesSchema } from "../schema/capabilities.schema.js";
+import { MedusaConfigurationSchema } from "../schema/configuration.schema.js";
 import { MedusaClient } from "./client.js";
-import { MedusaCategoryProvider } from "../providers/category.provider.js";
-import { MedusaCheckoutProvider } from "../providers/checkout.provider.js";
 function withMedusaCapabilities(configuration, capabilities) {
   return (cache, context) => {
     const client = {};
@@ -39,6 +42,15 @@ function withMedusaCapabilities(configuration, capabilities) {
     if (caps.identity) {
       client.identity = new MedusaIdentityProvider(configuration, cache, context, medusaClient);
     }
+    if (caps.profile) {
+      client.profile = new MedusaProfileProvider(configuration, cache, context, medusaClient);
+    }
+    if (caps.order) {
+      client.order = new MedusaOrderProvider(configuration, cache, context, medusaClient);
+    }
+    if (caps.orderSearch) {
+      client.orderSearch = new MedusaOrderSearchProvider(configuration, cache, context, medusaClient);
+    }
     return client;
   };
 }

package/index.js

@@ -6,5 +6,8 @@ export * from "./core/client.js";
 export * from "./providers/cart.provider.js";
 export * from "./providers/identity.provider.js";
 export * from "./providers/inventory.provider.js";
+export * from "./providers/order.provider.js";
+export * from "./providers/order-search.provider.js";
 export * from "./providers/price.provider.js";
 export * from "./providers/product-search.provider.js";
+export * from "./providers/profile.provider.js";

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@reactionary/provider-medusa",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "type": "module",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
     "zod": "4.1.9",
-    "@reactionary/core": "0.2.1",
+    "@reactionary/core": "0.2.3",
     "@medusajs/js-sdk": "^2.0.0",
     "debug": "^4.3.4",
     "@medusajs/types": "^2.11.0",

package/providers/order-search.provider.js

@@ -0,0 +1,157 @@
+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,
+  OrderSearchProvider,
+  OrderSearchQueryByTermSchema,
+  OrderSearchResultSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+const debug = createDebug("reactionary:medusa:order-search");
+class MedusaOrderSearchProvider extends OrderSearchProvider {
+  constructor(config, cache, context, client) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+  }
+  async queryByTerm(payload) {
+    debug("queryByTerm", payload);
+    const medusa = await this.client.getClient();
+    if (payload.search.term) {
+      debug("Searching orders by term is not supported in Medusa");
+    }
+    if (payload.search.partNumber) {
+      debug("Searching orders by part number is not supported in Medusa");
+    }
+    if (payload.search.startDate) {
+      debug("Searching orders by start date is not supported in Medusa");
+    }
+    if (payload.search.endDate) {
+      debug("Searching orders by end date is not supported in Medusa");
+    }
+    if (payload.search.userId) {
+      debug("Searching orders by customer ID is not supported in Medusa");
+    }
+    const statusFilter = (payload.search.orderStatus ?? []).map((status) => {
+      let retStatus = "draft";
+      if (status === "AwaitingPayment") {
+        retStatus = "draft";
+      }
+      if (status === "ReleasedToFulfillment") {
+        retStatus = "pending";
+      }
+      if (status === "Shipped") {
+        retStatus = "completed";
+      }
+      if (status === "Cancelled") {
+        retStatus = "canceled";
+      }
+      return retStatus;
+    });
+    const response = await medusa.store.order.list({
+      status: statusFilter,
+      limit: payload.search.paginationOptions.pageSize,
+      offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize
+    });
+    const result = this.parsePaginatedResult(response, payload);
+    if (debug.enabled) {
+      debug(
+        `Search for term "${payload.search.term}" returned ${response.orders.length} orders (page ${payload.search.paginationOptions.pageNumber} of ${result.totalPages})`
+      );
+    }
+    return success(result);
+  }
+  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: ""
+    };
+  }
+  parseSingle(body) {
+    const identifier = { key: body.id };
+    const userId = {
+      userId: body.customer_id || ""
+    };
+    const customerName = `${body.billing_address?.first_name} ${body.billing_address?.last_name}`;
+    const shippingAddress = this.composeAddressFromStoreAddress(body.shipping_address);
+    const orderDate = new Date(body.created_at).toISOString();
+    let orderStatus = "AwaitingPayment";
+    if (body.status === "draft") {
+      orderStatus = "AwaitingPayment";
+    }
+    if (body.status === "pending") {
+      orderStatus = "ReleasedToFulfillment";
+    }
+    if (body.status === "completed") {
+      orderStatus = "Shipped";
+    }
+    if (body.status === "canceled") {
+      orderStatus = "Cancelled";
+    }
+    let inventoryStatus = "NotAllocated";
+    if (body.fulfillment_status === "fulfilled") {
+      inventoryStatus = "Allocated";
+    }
+    const totalAmount = {
+      currency: body.currency_code.toUpperCase(),
+      value: body.total ? body.total : 0
+    };
+    const order = {
+      identifier,
+      userId,
+      customerName,
+      shippingAddress,
+      orderDate,
+      orderStatus,
+      inventoryStatus,
+      totalAmount
+    };
+    return order;
+  }
+  parsePaginatedResult(body, query) {
+    const identifier = {
+      ...query.search
+    };
+    const orders = body.orders.map((o) => {
+      return this.parseSingle(o);
+    });
+    const result = {
+      identifier,
+      pageNumber: (Math.ceil(body.offset / body.limit) || 0) + 1,
+      pageSize: body.limit,
+      totalCount: body.count,
+      totalPages: Math.ceil(body.count / body.limit || 0) + 1,
+      items: orders
+    };
+    return result;
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: OrderSearchQueryByTermSchema,
+    outputSchema: OrderSearchResultSchema
+  })
+], MedusaOrderSearchProvider.prototype, "queryByTerm", 1);
+export {
+  MedusaOrderSearchProvider
+};

package/providers/order.provider.js

@@ -0,0 +1,175 @@
+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 {
+  OrderProvider,
+  OrderQueryByIdSchema,
+  OrderSchema,
+  Reactionary,
+  success,
+  error,
+  ProductVariantIdentifierSchema
+} from "@reactionary/core";
+import createDebug from "debug";
+import { handleProviderError } from "../utils/medusa-helpers.js";
+import { parseMedusaItemPrice, parseMedusaCostBreakdown } from "../utils/medusa-helpers.js";
+const debug = createDebug("reactionary:medusa:order");
+class MedusaOrderProvider extends OrderProvider {
+  constructor(config, cache, context, client) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+  }
+  async getById(payload) {
+    debug("getById", payload);
+    const medusa = await this.client.getClient();
+    try {
+      const response = await medusa.store.order.retrieve(payload.order.key);
+      const order = this.parseSingle(response.order);
+      return success(order);
+    } catch (err) {
+      return handleProviderError("order", err);
+    }
+  }
+  /**
+   * 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 cart item
+   * @param remoteItem
+   * @param currency
+   * @returns
+   */
+  parseOrderItem(remoteItem, currency) {
+    const item = {
+      identifier: {
+        key: remoteItem.id
+      },
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: remoteItem.variant_sku || ""
+      }),
+      quantity: remoteItem.quantity || 1,
+      price: this.parseItemPrice(remoteItem, currency),
+      inventoryStatus: "Allocated"
+    };
+    return item;
+  }
+  parsePaymentInstruction(remotePayment, order) {
+    const paymentMethodIdentifier = {
+      method: remotePayment.payment_providers?.[0]?.id || "unknown",
+      name: remotePayment.payment_providers?.[0]?.id || "unknown",
+      paymentProcessor: remotePayment.payment_providers?.[0]?.id || "unknown"
+    };
+    let status = "pending";
+    switch (remotePayment.status) {
+      case "not_paid":
+        status = "pending";
+        break;
+      case "awaiting":
+        status = "pending";
+        break;
+      case "authorized":
+        status = "authorized";
+        break;
+      case "partially_authorized":
+        status = "pending";
+        break;
+      case "canceled":
+        status = "canceled";
+        break;
+      case "failed":
+        status = "canceled";
+        break;
+      case "completed":
+        status = "capture";
+        break;
+    }
+    const paymentData = remotePayment.payments?.[0].data || {};
+    const pi = {
+      identifier: {
+        key: remotePayment.id
+      },
+      amount: {
+        value: remotePayment.amount,
+        currency: remotePayment.currency_code?.toUpperCase()
+      },
+      paymentMethod: paymentMethodIdentifier,
+      protocolData: paymentData ? Object.entries(paymentData).map(([key, value]) => ({
+        key,
+        value: String(value)
+      })) : [],
+      status
+    };
+    return pi;
+  }
+  parseSingle(body) {
+    const identifier = { key: body.id };
+    const userId = {
+      userId: body.customer_id || ""
+    };
+    const items = (body.items || []).map((item) => {
+      return this.parseOrderItem(item, body.currency_code.toUpperCase());
+    });
+    const price = this.parseCostBreakdown(body);
+    let orderStatus = "AwaitingPayment";
+    if (body.status === "draft") {
+      orderStatus = "AwaitingPayment";
+    }
+    if (body.status === "pending") {
+      orderStatus = "ReleasedToFulfillment";
+    }
+    if (body.status === "completed") {
+      orderStatus = "Shipped";
+    }
+    if (body.status === "canceled") {
+      orderStatus = "Cancelled";
+    }
+    let inventoryStatus = "NotAllocated";
+    if (body.fulfillment_status === "fulfilled") {
+      inventoryStatus = "Allocated";
+    }
+    const paymentInstructions = body.payment_collections?.map((pc) => {
+      return this.parsePaymentInstruction(pc, body);
+    }) || [];
+    return {
+      identifier,
+      userId,
+      items,
+      price,
+      orderStatus,
+      inventoryStatus,
+      paymentInstructions
+    };
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: OrderQueryByIdSchema,
+    outputSchema: OrderSchema
+  })
+], MedusaOrderProvider.prototype, "getById", 1);
+export {
+  MedusaOrderProvider
+};

package/providers/profile.provider.js

@@ -0,0 +1,323 @@
+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 {
+  ProfileProvider,
+  Reactionary,
+  ProfileSchema,
+  ProfileMutationUpdateSchema,
+  ProfileMutationAddShippingAddressSchema,
+  ProfileMutationUpdateShippingAddressSchema,
+  ProfileMutationRemoveShippingAddressSchema,
+  ProfileMutationMakeShippingAddressDefaultSchema,
+  ProfileMutationSetBillingAddressSchema,
+  success,
+  ProfileQueryByIdSchema,
+  error
+} from "@reactionary/core";
+import createDebug from "debug";
+const debug = createDebug("reactionary:medusa:profile");
+class MedusaProfileProvider extends ProfileProvider {
+  constructor(config, cache, context, client) {
+    super(cache, context);
+    this.includedFields = ["+metadata.*"];
+    this.config = config;
+    this.client = client;
+  }
+  async getById(payload) {
+    debug("getById", payload);
+    const client = await this.client.getClient();
+    const customerResponse = await client.store.customer.retrieve({ fields: this.includedFields.join(",") });
+    if (!customerResponse.customer) {
+      return error({
+        identifier: payload.identifier,
+        type: "NotFound"
+      });
+    }
+    const model = this.parseSingle(customerResponse.customer);
+    return success(model);
+  }
+  async update(payload) {
+    debug("update", payload);
+    const client = await this.client.getClient();
+    const customerResponse = await client.store.customer.retrieve({ fields: this.includedFields.join(",") });
+    if (!customerResponse.customer) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const customer = customerResponse.customer;
+    const updatedResponse = await client.store.customer.update({
+      phone: payload.phone ?? customer.phone
+    }, { fields: this.includedFields.join(",") });
+    const model = this.parseSingle(updatedResponse.customer);
+    return success(model);
+  }
+  async addShippingAddress(payload) {
+    debug("addShippingAddress", payload);
+    const client = await this.client.getClient();
+    const medusaAddress = this.createMedusaAddress(payload.address);
+    const customer = await client.store.customer.retrieve({ fields: this.includedFields.join(",") });
+    if (!customer.customer) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const existingAddress = customer.customer.addresses.find((addr) => addr.address_name === payload.address.identifier.nickName);
+    if (existingAddress) {
+      return error({
+        type: "InvalidInput",
+        error: {
+          message: "Address with the same nickname already exists"
+        }
+      });
+    }
+    const response = await client.store.customer.createAddress(medusaAddress, { fields: this.includedFields.join(",") });
+    if (!response.customer) {
+      return error({
+        type: "InvalidInput",
+        error: {
+          message: "Failed to add shipping address"
+        }
+      });
+    }
+    const model = this.parseSingle(response.customer);
+    return success(model);
+  }
+  async updateShippingAddress(payload) {
+    debug("updateShippingAddress", payload);
+    const client = await this.client.getClient();
+    const customer = await client.store.customer.retrieve({ fields: this.includedFields.join(",") });
+    if (!customer.customer) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const medusaAddress = this.createMedusaAddress(payload.address);
+    const existingAddress = customer.customer.addresses.find((addr) => addr.address_name === payload.address.identifier.nickName);
+    if (!existingAddress) {
+      return error({
+        type: "NotFound",
+        identifier: payload.address.identifier
+      });
+    }
+    const response = await client.store.customer.updateAddress(existingAddress.id, medusaAddress, { fields: this.includedFields.join(",") });
+    if (!response.customer) {
+      return error({
+        type: "InvalidInput",
+        error: {
+          message: "Failed to add shipping address"
+        }
+      });
+    }
+    const model = this.parseSingle(response.customer);
+    return success(model);
+  }
+  async removeShippingAddress(payload) {
+    debug("removeShippingAddress", payload);
+    const client = await this.client.getClient();
+    const customer = await client.store.customer.retrieve({ fields: this.includedFields.join(",") });
+    if (!customer.customer) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const existingAddress = customer.customer.addresses.find((addr) => addr.address_name === payload.addressIdentifier.nickName);
+    if (!existingAddress) {
+      return error({
+        type: "NotFound",
+        identifier: payload.addressIdentifier
+      });
+    }
+    const response = await client.store.customer.deleteAddress(existingAddress.id, { fields: this.includedFields.join(",") });
+    if (!response.deleted) {
+      return error({
+        type: "InvalidInput",
+        error: {
+          message: "Failed to delete shipping address"
+        }
+      });
+    }
+    const customerAfterDelete = await client.store.customer.retrieve({ fields: this.includedFields.join(",") });
+    const model = this.parseSingle(customerAfterDelete.customer);
+    return success(model);
+  }
+  async makeShippingAddressDefault(payload) {
+    debug("makeShippingAddressDefault", payload);
+    const client = await this.client.getClient();
+    const customer = await client.store.customer.retrieve({ fields: this.includedFields.join(",") });
+    if (!customer.customer) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const existingAddress = customer.customer.addresses.find((addr) => addr.address_name === payload.addressIdentifier.nickName);
+    if (!existingAddress) {
+      return error({
+        type: "NotFound",
+        identifier: payload.addressIdentifier
+      });
+    }
+    const response = await client.store.customer.updateAddress(
+      existingAddress.id,
+      {
+        is_default_shipping: true
+      },
+      { fields: this.includedFields.join(",") }
+    );
+    const model = this.parseSingle(response.customer);
+    return success(model);
+  }
+  async setBillingAddress(payload) {
+    debug("setBillingAddress", payload);
+    const client = await this.client.getClient();
+    const customerResponse = await client.store.customer.retrieve({ fields: this.includedFields.join(",") });
+    if (!customerResponse.customer) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    let customer = customerResponse.customer;
+    const existingAddressWithNickname = customer.addresses.find((addr) => addr.address_name === payload.address.identifier.nickName);
+    if (existingAddressWithNickname && !existingAddressWithNickname.is_default_billing) {
+      return error({
+        type: "InvalidInput",
+        error: {
+          message: "Another address with the same nickname already exists"
+        }
+      });
+    }
+    const newAddr = this.createMedusaAddress(payload.address);
+    newAddr.is_default_billing = true;
+    const existingBillingAddress = customer.addresses.find((addr) => addr.is_default_billing);
+    if (existingBillingAddress) {
+      const updateAddressResponse = await client.store.customer.updateAddress(existingBillingAddress.id, newAddr, { fields: this.includedFields.join(",") });
+      customer = updateAddressResponse.customer;
+    } else {
+      const createAddressResponse = await client.store.customer.createAddress(newAddr, { fields: this.includedFields.join(",") });
+      customer = createAddressResponse.customer;
+    }
+    const model = this.parseSingle(customer);
+    return success(model);
+  }
+  createMedusaAddress(address) {
+    return {
+      address_name: address.identifier.nickName,
+      first_name: address.firstName,
+      last_name: address.lastName,
+      address_1: address.streetAddress,
+      address_2: address.streetNumber,
+      city: address.city,
+      province: address.region,
+      postal_code: address.postalCode,
+      country_code: address.countryCode
+    };
+  }
+  parseAddress(address) {
+    return {
+      identifier: {
+        nickName: address.address_name || ""
+      },
+      firstName: address.first_name || "",
+      lastName: address.last_name || "",
+      streetAddress: address.address_1 || "",
+      streetNumber: address.address_2 || "",
+      city: address.city || "",
+      region: address.province || "",
+      postalCode: address.postal_code || "",
+      countryCode: address.country_code || ""
+    };
+  }
+  parseSingle(customer) {
+    const email = customer.email;
+    const emailVerified = customer.metadata?.["email_verified"] === "true";
+    const phone = customer.phone || "";
+    const phoneVerified = customer.metadata?.["phone_verified"] === "true";
+    const addresses = customer.addresses || [];
+    let billingAddress = void 0;
+    let shippingAddress = void 0;
+    const existingBillingAddress = customer.addresses.find((addr) => addr.is_default_billing);
+    if (existingBillingAddress) {
+      billingAddress = this.parseAddress(existingBillingAddress);
+    }
+    const existingShippingAddress = customer.addresses.find((addr) => addr.is_default_shipping);
+    if (existingShippingAddress) {
+      shippingAddress = this.parseAddress(existingShippingAddress);
+    }
+    const alternateShippingAddresses = [];
+    alternateShippingAddresses.push(...addresses.filter((x) => !(x.is_default_billing || x.is_default_shipping)).map((addr) => this.parseAddress(addr)));
+    return {
+      identifier: {
+        userId: customer.id
+      },
+      email,
+      emailVerified,
+      phone,
+      phoneVerified,
+      billingAddress,
+      shippingAddress,
+      alternateShippingAddresses,
+      createdAt: new Date(customer.created_at || "").toISOString(),
+      updatedAt: new Date(customer.updated_at || "").toISOString()
+    };
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileQueryByIdSchema,
+    outputSchema: ProfileSchema
+  })
+], MedusaProfileProvider.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationUpdateSchema,
+    outputSchema: ProfileSchema
+  })
+], MedusaProfileProvider.prototype, "update", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationAddShippingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], MedusaProfileProvider.prototype, "addShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationUpdateShippingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], MedusaProfileProvider.prototype, "updateShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationRemoveShippingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], MedusaProfileProvider.prototype, "removeShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationMakeShippingAddressDefaultSchema,
+    outputSchema: ProfileSchema
+  })
+], MedusaProfileProvider.prototype, "makeShippingAddressDefault", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationSetBillingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], MedusaProfileProvider.prototype, "setBillingAddress", 1);
+export {
+  MedusaProfileProvider
+};

package/schema/capabilities.schema.js

@@ -6,8 +6,11 @@ const MedusaCapabilitiesSchema = CapabilitiesSchema.pick({
   category: true,
   product: true,
   price: true,
+  order: true,
+  orderSearch: true,
   inventory: true,
-  identity: true
+  identity: true,
+  profile: true
 }).partial();
 export {
   MedusaCapabilitiesSchema

package/src/index.d.ts

@@ -6,5 +6,8 @@ export * from './core/client.js';
 export * from './providers/cart.provider.js';
 export * from './providers/identity.provider.js';
 export * from './providers/inventory.provider.js';
+export * from './providers/order.provider.js';
+export * from './providers/order-search.provider.js';
 export * from './providers/price.provider.js';
 export * from './providers/product-search.provider.js';
+export * from './providers/profile.provider.js';

package/src/providers/order-search.provider.d.ts

@@ -0,0 +1,91 @@
+import type { RequestContext, Cache, OrderSearchQueryByTerm, OrderSearchResult, Result, OrderStatus, Address } from '@reactionary/core';
+import { OrderSearchProvider } from '@reactionary/core';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaClient } from '../core/client.js';
+import type { StoreOrder, StoreOrderAddress, StoreOrderListResponse } from '@medusajs/types';
+export declare class MedusaOrderSearchProvider extends OrderSearchProvider {
+    protected config: MedusaConfiguration;
+    protected client: MedusaClient;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, client: MedusaClient);
+    queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>>;
+    protected composeAddressFromStoreAddress(storeAddress: StoreOrderAddress): Address;
+    protected parseSingle(body: StoreOrder): {
+        identifier: {
+            key: string;
+        };
+        userId: {
+            userId: string;
+        };
+        customerName: string;
+        shippingAddress: {
+            identifier: {
+                nickName: string;
+            };
+            firstName: string;
+            lastName: string;
+            streetAddress: string;
+            streetNumber: string;
+            city: string;
+            region: string;
+            postalCode: string;
+            countryCode: string;
+        };
+        orderDate: string;
+        orderStatus: OrderStatus;
+        inventoryStatus: "NotAllocated" | "Allocated";
+        totalAmount: {
+            value: number;
+            currency: "AED" | "AFN" | "ALL" | "AMD" | "ANG" | "AOA" | "ARS" | "AUD" | "AWG" | "AZN" | "BAM" | "BBD" | "BDT" | "BGN" | "BHD" | "BIF" | "BMD" | "BND" | "BOB" | "BOV" | "BRL" | "BSD" | "BTN" | "BWP" | "BYN" | "BZD" | "CAD" | "CDF" | "CHE" | "CHF" | "CHW" | "CLF" | "CLP" | "CNY" | "COP" | "COU" | "CRC" | "CUC" | "CUP" | "CVE" | "CZK" | "DJF" | "DKK" | "DOP" | "DZD" | "EGP" | "ERN" | "ETB" | "EUR" | "FJD" | "FKP" | "GBP" | "GEL" | "GHS" | "GIP" | "GMD" | "GNF" | "GTQ" | "GYD" | "HKD" | "HNL" | "HRK" | "HTG" | "HUF" | "IDR" | "ILS" | "INR" | "IQD" | "IRR" | "ISK" | "JMD" | "JOD" | "JPY" | "KES" | "KGS" | "KHR" | "KMF" | "KPW" | "KRW" | "KWD" | "KYD" | "KZT" | "LAK" | "LBP" | "LKR" | "LRD" | "LSL" | "LYD" | "MAD" | "MDL" | "MGA" | "MKD" | "MMK" | "MNT" | "MOP" | "MRU" | "MUR" | "MVR" | "MWK" | "MXN" | "MXV" | "MYR" | "MZN" | "NAD" | "NGN" | "NIO" | "NOK" | "NPR" | "NZD" | "OMR" | "PAB" | "PEN" | "PGK" | "PHP" | "PKR" | "PLN" | "PYG" | "QAR" | "RON" | "RSD" | "RUB" | "RWF" | "SAR" | "SBD" | "SCR" | "SDG" | "SEK" | "SGD" | "SHP" | "SLE" | "SLL" | "SOS" | "SRD" | "SSP" | "STN" | "SYP" | "SZL" | "THB" | "TJS" | "TMT" | "TND" | "TOP" | "TRY" | "TTD" | "TVD" | "TWD" | "TZS" | "UAH" | "UGX" | "USD" | "USN" | "UYI" | "UYU" | "UYW" | "UZS" | "VED" | "VES" | "VND" | "VUV" | "WST" | "XAF" | "XAG" | "XAU" | "XBA" | "XBB" | "XBC" | "XBD" | "XCD" | "XDR" | "XOF" | "XPD" | "XPF" | "XPT" | "XSU" | "XTS" | "XUA" | "XXX" | "YER" | "ZAR" | "ZMW" | "ZWL";
+        };
+    };
+    protected parsePaginatedResult(body: StoreOrderListResponse, query: OrderSearchQueryByTerm): {
+        identifier: {
+            term: string;
+            filters: string[];
+            paginationOptions: {
+                pageNumber: number;
+                pageSize: number;
+            };
+            partNumber?: string[] | undefined;
+            orderStatus?: ("AwaitingPayment" | "ReleasedToFulfillment" | "Shipped" | "Cancelled")[] | undefined;
+            userId?: {
+                userId: string;
+            } | undefined;
+            startDate?: string | undefined;
+            endDate?: string | undefined;
+        };
+        pageNumber: number;
+        pageSize: number;
+        totalCount: number;
+        totalPages: number;
+        items: {
+            identifier: {
+                key: string;
+            };
+            userId: {
+                userId: string;
+            };
+            customerName: string;
+            orderDate: string;
+            orderStatus: "AwaitingPayment" | "ReleasedToFulfillment" | "Shipped" | "Cancelled";
+            inventoryStatus: "NotAllocated" | "Allocated" | "Backordered" | "Preordered";
+            totalAmount: {
+                value: number;
+                currency: "AED" | "AFN" | "ALL" | "AMD" | "ANG" | "AOA" | "ARS" | "AUD" | "AWG" | "AZN" | "BAM" | "BBD" | "BDT" | "BGN" | "BHD" | "BIF" | "BMD" | "BND" | "BOB" | "BOV" | "BRL" | "BSD" | "BTN" | "BWP" | "BYN" | "BZD" | "CAD" | "CDF" | "CHE" | "CHF" | "CHW" | "CLF" | "CLP" | "CNY" | "COP" | "COU" | "CRC" | "CUC" | "CUP" | "CVE" | "CZK" | "DJF" | "DKK" | "DOP" | "DZD" | "EGP" | "ERN" | "ETB" | "EUR" | "FJD" | "FKP" | "GBP" | "GEL" | "GHS" | "GIP" | "GMD" | "GNF" | "GTQ" | "GYD" | "HKD" | "HNL" | "HRK" | "HTG" | "HUF" | "IDR" | "ILS" | "INR" | "IQD" | "IRR" | "ISK" | "JMD" | "JOD" | "JPY" | "KES" | "KGS" | "KHR" | "KMF" | "KPW" | "KRW" | "KWD" | "KYD" | "KZT" | "LAK" | "LBP" | "LKR" | "LRD" | "LSL" | "LYD" | "MAD" | "MDL" | "MGA" | "MKD" | "MMK" | "MNT" | "MOP" | "MRU" | "MUR" | "MVR" | "MWK" | "MXN" | "MXV" | "MYR" | "MZN" | "NAD" | "NGN" | "NIO" | "NOK" | "NPR" | "NZD" | "OMR" | "PAB" | "PEN" | "PGK" | "PHP" | "PKR" | "PLN" | "PYG" | "QAR" | "RON" | "RSD" | "RUB" | "RWF" | "SAR" | "SBD" | "SCR" | "SDG" | "SEK" | "SGD" | "SHP" | "SLE" | "SLL" | "SOS" | "SRD" | "SSP" | "STN" | "SYP" | "SZL" | "THB" | "TJS" | "TMT" | "TND" | "TOP" | "TRY" | "TTD" | "TVD" | "TWD" | "TZS" | "UAH" | "UGX" | "USD" | "USN" | "UYI" | "UYU" | "UYW" | "UZS" | "VED" | "VES" | "VND" | "VUV" | "WST" | "XAF" | "XAG" | "XAU" | "XBA" | "XBB" | "XBC" | "XBD" | "XCD" | "XDR" | "XOF" | "XPD" | "XPF" | "XPT" | "XSU" | "XTS" | "XUA" | "XXX" | "YER" | "ZAR" | "ZMW" | "ZWL";
+            };
+            shippingAddress?: {
+                identifier: {
+                    nickName: string;
+                };
+                firstName: string;
+                lastName: string;
+                streetAddress: string;
+                streetNumber: string;
+                city: string;
+                region: string;
+                postalCode: string;
+                countryCode: string;
+            } | undefined;
+        }[];
+    };
+}

package/src/providers/order.provider.d.ts

@@ -0,0 +1,51 @@
+import type { Cache, Order, OrderQueryById, RequestContext, Result, NotFoundError, CostBreakDown, Currency, OrderItem, ItemCostBreakdown } from '@reactionary/core';
+import { OrderProvider } from '@reactionary/core';
+import type { MedusaClient } from '../core/client.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { StoreOrder, StoreOrderLineItem, StorePaymentCollection } from '@medusajs/types';
+export declare class MedusaOrderProvider extends OrderProvider {
+    protected config: MedusaConfiguration;
+    protected client: MedusaClient;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, client: MedusaClient);
+    getById(payload: OrderQueryById): Promise<Result<Order, NotFoundError>>;
+    /**
+     * Extension point to control the parsing of a single cart item price
+     * @param remoteItem
+     * @param currency
+     * @returns
+     */
+    protected parseItemPrice(remoteItem: StoreOrderLineItem, currency: Currency): ItemCostBreakdown;
+    /**
+     * Extension point to control the parsing of the cost breakdown of a cart
+     * @param remote
+     * @returns
+     */
+    protected parseCostBreakdown(remote: StoreOrder): CostBreakDown;
+    /**
+     * Extension point to control the parsing of a single cart item
+     * @param remoteItem
+     * @param currency
+     * @returns
+     */
+    protected parseOrderItem(remoteItem: StoreOrderLineItem, currency: Currency): OrderItem;
+    protected parsePaymentInstruction(remotePayment: StorePaymentCollection, order: StoreOrder): {
+        identifier: {
+            key: string;
+        };
+        amount: {
+            value: number;
+            currency: Currency;
+        };
+        paymentMethod: {
+            method: string;
+            name: string;
+            paymentProcessor: string;
+        };
+        protocolData: {
+            key: string;
+            value: string;
+        }[];
+        status: "pending" | "authorized" | "canceled" | "capture";
+    };
+    protected parseSingle(body: StoreOrder): Order;
+}

package/src/providers/profile.provider.d.ts

@@ -0,0 +1,30 @@
+import { type Profile, type ProfileMutationAddShippingAddress, type ProfileMutationMakeShippingAddressDefault, type ProfileMutationRemoveShippingAddress, type ProfileMutationSetBillingAddress, type ProfileMutationUpdate, type ProfileMutationUpdateShippingAddress, type ProfileQuerySelf as ProfileQueryById, type RequestContext, type Cache, type Result, type NotFoundError, ProfileProvider, type Address } from '@reactionary/core';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaClient } from '../core/client.js';
+import type { StoreCreateCustomerAddress, StoreCustomer, StoreCustomerAddress } from '@medusajs/types';
+/**
+ * Medusa Profile Provider
+ *
+ * Implements profile management using Medusa's customer APIs.
+ *
+ * TODO:
+ * - handle email and phone verification status properly using metadata or other means.
+ * - handle guest user scenarios (if applicable).
+ * - improve error handling and edge cases.
+ */
+export declare class MedusaProfileProvider extends ProfileProvider {
+    protected config: MedusaConfiguration;
+    protected client: MedusaClient;
+    protected includedFields: string[];
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, client: MedusaClient);
+    getById(payload: ProfileQueryById): Promise<Result<Profile, NotFoundError>>;
+    update(payload: ProfileMutationUpdate): Promise<Result<Profile, NotFoundError>>;
+    addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<Profile, NotFoundError>>;
+    updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<Profile, NotFoundError>>;
+    removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<Profile, NotFoundError>>;
+    makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<Profile, NotFoundError>>;
+    setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<Profile, NotFoundError>>;
+    protected createMedusaAddress(address: Address): StoreCreateCustomerAddress;
+    protected parseAddress(address: StoreCustomerAddress): Address;
+    protected parseSingle(customer: StoreCustomer): Profile;
+}

package/src/schema/capabilities.schema.d.ts

@@ -4,9 +4,12 @@ export declare const MedusaCapabilitiesSchema: z.ZodObject<{
     product: z.ZodOptional<z.ZodBoolean>;
     cart: z.ZodOptional<z.ZodBoolean>;
     checkout: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodBoolean>;
     identity: z.ZodOptional<z.ZodBoolean>;
     inventory: z.ZodOptional<z.ZodBoolean>;
     category: z.ZodOptional<z.ZodBoolean>;
+    profile: z.ZodOptional<z.ZodBoolean>;
     productSearch: z.ZodOptional<z.ZodBoolean>;
+    orderSearch: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;
 export type MedusaCapabilities = z.infer<typeof MedusaCapabilitiesSchema>;

package/src/utils/medusa-helpers.d.ts

@@ -1,9 +1,9 @@
-import type { StoreCart } from '@medusajs/types';
+import type { StoreCart, StoreOrder } from '@medusajs/types';
 import type { CostBreakDown, Currency } from '@reactionary/core';
 /**
  * Parses cost breakdown from Medusa StoreCart
  */
-export declare function parseMedusaCostBreakdown(remote: StoreCart): CostBreakDown;
+export declare function parseMedusaCostBreakdown(remote: StoreCart | StoreOrder): CostBreakDown;
 /**
  * Parses item price structure from Medusa line item
  */