@reactionary/medusa 0.10.53 → 0.10.54

package/capabilities/checkout.capability.js

@@ -30,6 +30,7 @@ import {
 } from "@reactionary/core";
 import createDebug from "debug";
 import * as z from "zod";
+import { MedusaAdminAPI } from "../core/client.js";
 import {
 } from "../schema/medusa.schema.js";
 import { handleProviderError, isNotFoundFetchError } from "../utils/medusa-helpers.js";
@@ -61,6 +62,16 @@ class MedusaCheckoutCapability extends CheckoutCapability {
    * example: this.includedFields = [includedFields, '+discounts.*'].join(',');
    */
   includedFields = ["+items.*", "+order.id", "+order.display_id", "+order.custom_display_id"].join(",");
+  /**
+   * This controls which fields are requested for the cart's shipping options.
+   * You can override this in a subclass to add more fields as needed.
+   *
+   * The service zone's fulfillment set tells us whether an option is in-store
+   * pickup (BOPIS) or a delivery, and the option metadata lets medusa-side
+   * providers push additional data that is mapped to the shipping method's
+   * protocolData.
+   */
+  shippingOptionFields = ["*service_zone.fulfillment_set", "+metadata"].join(",");
   initiateCheckoutForCartPayload(payload) {
     return {
       billing_address: payload.billingAddress ? this.mapAddressToStoreAddress(payload.billingAddress) : void 0,
@@ -93,7 +104,9 @@ class MedusaCheckoutCapability extends CheckoutCapability {
       const response = await client.store.cart.retrieve(payload.identifier.key, {
         fields: this.includedFields
       });
-      return success(this.factory.parseCheckout(this.context, response.cart));
+      return success(
+        this.hydrateResultingOrder(this.factory.parseCheckout(this.context, response.cart))
+      );
     } catch (err) {
       if (isNotFoundFetchError(err)) {
         return error({
@@ -122,7 +135,8 @@ class MedusaCheckoutCapability extends CheckoutCapability {
   }
   getAvailableShippingMethodsPayload(payload) {
     return {
-      cart_id: payload.checkout.key
+      cart_id: payload.checkout.key,
+      fields: this.shippingOptionFields
     };
   }
   /**
@@ -270,6 +284,50 @@ class MedusaCheckoutCapability extends CheckoutCapability {
       }
     };
   }
+  /**
+   * Serializes the client-set shipping protocol data as a JSON object string
+   * for persistence in the cart metadata, or undefined when none is set.
+   */
+  serializeShippingProtocolData(protocolData) {
+    if (!protocolData || protocolData.length === 0) {
+      return void 0;
+    }
+    return JSON.stringify(
+      Object.fromEntries(protocolData.map((entry) => [entry.key, entry.value]))
+    );
+  }
+  /**
+   * Resolves the shipping address to use for in-store pickup (BOPIS): the
+   * address of the selected store, so the order ships to the store. Returns
+   * undefined when the store or its address is unknown, leaving the cart's
+   * shipping address untouched.
+   */
+  async resolveStorePickupAddress(store) {
+    try {
+      const adminClient = await new MedusaAdminAPI(this.config, this.context).getClient();
+      const response = await adminClient.admin.stockLocation.retrieve(store.key, {
+        fields: "*address"
+      });
+      const address = response.stock_location?.address;
+      if (!address) {
+        return void 0;
+      }
+      return {
+        firstName: "",
+        lastName: response.stock_location.name,
+        streetAddress: address.address_1 || "",
+        streetNumber: address.address_2 || "",
+        city: address.city || "",
+        postalCode: address.postal_code || "",
+        countryCode: address.country_code || ""
+      };
+    } catch (err) {
+      if (debug.enabled) {
+        debug(`Unable to resolve address for pickup store ${store.key}`, err);
+      }
+      return void 0;
+    }
+  }
   async setShippingInstruction(payload) {
     const client = await this.medusaApi.getClient();
     const medusaId = payload.checkout;
@@ -277,13 +335,22 @@ class MedusaCheckoutCapability extends CheckoutCapability {
       if (payload.shippingInstruction.shippingMethod) {
         await client.store.cart.addShippingMethod(medusaId.key, this.setShippingInstructionPayload(payload));
       }
-      await client.store.cart.update(medusaId.key, {
+      const cartUpdate = {
         metadata: {
           consent_for_unattended_delivery: payload.shippingInstruction.consentForUnattendedDelivery + "",
           instructions: payload.shippingInstruction.instructions || "",
-          pickup_point: payload.shippingInstruction.pickupPoint || ""
+          pickup_point: payload.shippingInstruction.pickupPoint || "",
+          pickup_store: payload.shippingInstruction.store?.key || "",
+          shipping_protocol_data: this.serializeShippingProtocolData(payload.shippingInstruction.protocolData) || ""
         }
-      });
+      };
+      if (payload.shippingInstruction.store?.key) {
+        const storeAddress = await this.resolveStorePickupAddress(payload.shippingInstruction.store);
+        if (storeAddress) {
+          cartUpdate.shipping_address = this.mapAddressToStoreAddress(storeAddress);
+        }
+      }
+      await client.store.cart.update(medusaId.key, cartUpdate);
       const response = await client.store.cart.retrieve(medusaId.key, {
         fields: this.includedFields
       });
@@ -306,14 +373,24 @@ class MedusaCheckoutCapability extends CheckoutCapability {
     if (!checkout.value.resultingOrder) {
       const client = await this.medusaApi.getClient();
       const medusaId = payload.checkout;
+      await client.store.cart.update(medusaId.key, {
+        metadata: {
+          cart_id: medusaId.key
+        }
+      });
       const response = await client.store.cart.complete(medusaId.key);
       if (response.type === "order") {
+        const resultingOrder = this.parseCompletedOrderIdentifier(response.order);
+        this.rememberFinalizedOrder(medusaId.key, resultingOrder);
         checkout = await this.getById({
           identifier: payload.checkout
         });
         if (!checkout.success) {
           throw new Error(`Unable to reload checkout ${payload.checkout.key} after completion`);
         }
+        if (!checkout.value.resultingOrder) {
+          checkout = success({ ...checkout.value, resultingOrder });
+        }
       } else {
         throw new Error(`Failed to finalize checkout ${payload.checkout.key}. Expected order, got ${response.type}`);
       }
@@ -333,6 +410,48 @@ class MedusaCheckoutCapability extends CheckoutCapability {
     }
     return success(checkout.value);
   }
+  /**
+   * Builds the order identifier from a completed-cart response's order,
+   * following the same display-id precedence as the checkout factory
+   * (custom_display_id over display_id).
+   */
+  parseCompletedOrderIdentifier(order) {
+    const rawDisplayId = order.custom_display_id ?? order.display_id;
+    const displayId = rawDisplayId != null ? Number(`${rawDisplayId}`) : void 0;
+    return {
+      key: order.id,
+      display_id: displayId != null && Number.isFinite(displayId) ? displayId : void 0
+    };
+  }
+  /**
+   * Remembers which order a finalized cart produced, so later checkout reads
+   * in the same session can report the resulting order even when the Medusa
+   * store cart endpoint does not expose the cart->order relation.
+   */
+  rememberFinalizedOrder(cartKey, order) {
+    const sessionData = this.medusaApi.getSessionData();
+    this.medusaApi.setSessionData({
+      finalizedOrders: {
+        ...sessionData.finalizedOrders || {},
+        [cartKey]: order
+      }
+    });
+  }
+  /**
+   * Fills in a missing resultingOrder from the session's finalized-orders map.
+   * Checkouts that already carry a resulting order (older Medusa versions
+   * still hydrate the +order.* fields) are returned unchanged.
+   */
+  hydrateResultingOrder(checkout) {
+    if (checkout.resultingOrder) {
+      return checkout;
+    }
+    const remembered = this.medusaApi.getSessionData().finalizedOrders?.[checkout.identifier.key];
+    if (!remembered) {
+      return checkout;
+    }
+    return { ...checkout, resultingOrder: remembered };
+  }
   /**
    * Extension point to map an Address to a Store Address
    * @param address

package/capabilities/store.capability.js

@@ -0,0 +1,166 @@
+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 {
+  Reactionary,
+  StoreCapability,
+  StorePaginatedResultSchema,
+  StoreQueryByIdSchema,
+  StoreQueryByProximitySchema,
+  StoreQueryForListSchema,
+  StoreSchema,
+  error,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+import * as z from "zod";
+import { MedusaAdminAPI } from "../core/client.js";
+import { haversineDistanceKm } from "../utils/geo.js";
+const debug = createDebug("reactionary:medusa:store");
+class MedusaStoreCapability extends StoreCapability {
+  constructor(config, cache, context, medusaApi, factory) {
+    super(cache, context);
+    this.medusaApi = medusaApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  medusaApi;
+  config;
+  factory;
+  /**
+   * The fields requested for stock locations. Override in a subclass if a
+   * project needs more relations.
+   */
+  stockLocationFields = "*address,*fulfillment_sets";
+  /**
+   * Whether a stock location is a store customers can pick up orders from,
+   * i.e. it has a fulfillment set of type "pickup".
+   */
+  isPickupLocation(location) {
+    return (location.fulfillment_sets || []).some((set) => set.type === "pickup");
+  }
+  /**
+   * Fetches all stock locations that are pickup stores. Medusa installations
+   * have a small, bounded number of stock locations, so fetching them all and
+   * filtering client-side is acceptable.
+   */
+  async fetchPickupLocations() {
+    const adminClient = await new MedusaAdminAPI(this.config, this.context).getClient();
+    const pageSize = 200;
+    let offset = 0;
+    const locations = [];
+    for (; ; ) {
+      const response = await adminClient.admin.stockLocation.list({
+        fields: this.stockLocationFields,
+        limit: pageSize,
+        offset
+      });
+      locations.push(...response.stock_locations || []);
+      offset += pageSize;
+      if (offset >= response.count || (response.stock_locations || []).length === 0) {
+        break;
+      }
+    }
+    return locations.filter((location) => this.isPickupLocation(location));
+  }
+  async list(payload) {
+    const pickupLocations = await this.fetchPickupLocations();
+    if (debug.enabled) {
+      debug(`Found ${pickupLocations.length} pickup stock locations`);
+    }
+    const { pageNumber, pageSize } = payload.paginationOptions;
+    const startIndex = (pageNumber - 1) * pageSize;
+    const pagedLocations = pickupLocations.slice(startIndex, startIndex + pageSize);
+    return success({
+      pageNumber,
+      pageSize,
+      totalCount: pickupLocations.length,
+      totalPages: Math.ceil(pickupLocations.length / pageSize),
+      items: pagedLocations.map(
+        (location) => this.factory.parseStore(this.context, location)
+      )
+    });
+  }
+  async getById(payload) {
+    const adminClient = await new MedusaAdminAPI(this.config, this.context).getClient();
+    try {
+      const response = await adminClient.admin.stockLocation.retrieve(payload.identifier.key, {
+        fields: this.stockLocationFields
+      });
+      if (!response.stock_location || !this.isPickupLocation(response.stock_location)) {
+        return error({ type: "NotFound", identifier: payload.identifier });
+      }
+      return success(this.factory.parseStore(this.context, response.stock_location));
+    } catch (err) {
+      if (debug.enabled) {
+        debug(`Error fetching stock location ${payload.identifier.key}`, err);
+      }
+      return error({ type: "NotFound", identifier: payload.identifier });
+    }
+  }
+  /**
+   * Extension point resolving a stock location's geo coordinates. Medusa
+   * stock locations carry no first-class coordinates, so by default they are
+   * read from the location metadata keys `latitude` and `longitude`. Returns
+   * undefined when the location has no usable coordinates.
+   */
+  parseLocationCoordinates(location) {
+    const latitude = Number(location.metadata?.["latitude"]);
+    const longitude = Number(location.metadata?.["longitude"]);
+    if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+      return void 0;
+    }
+    return { latitude, longitude };
+  }
+  async queryByProximity(payload) {
+    const pickupLocations = await this.fetchPickupLocations();
+    const withinDistance = [];
+    for (const location of pickupLocations) {
+      const coordinates = this.parseLocationCoordinates(location);
+      if (!coordinates) {
+        continue;
+      }
+      const distance = haversineDistanceKm(
+        payload.latitude,
+        payload.longitude,
+        coordinates.latitude,
+        coordinates.longitude
+      );
+      if (distance <= payload.distance) {
+        withinDistance.push({ location, distance });
+      }
+    }
+    withinDistance.sort((a, b) => a.distance - b.distance);
+    return success(
+      withinDistance.slice(0, payload.limit).map((entry) => this.factory.parseStore(this.context, entry.location))
+    );
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: StoreQueryForListSchema,
+    outputSchema: StorePaginatedResultSchema
+  })
+], MedusaStoreCapability.prototype, "list", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: StoreQueryByIdSchema,
+    outputSchema: StoreSchema
+  })
+], MedusaStoreCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: StoreQueryByProximitySchema,
+    outputSchema: z.array(StoreSchema)
+  })
+], MedusaStoreCapability.prototype, "queryByProximity", 1);
+export {
+  MedusaStoreCapability
+};

package/core/initialize.js

@@ -23,7 +23,8 @@ import {
   ProductSearchResultSchema,
   ProfileSchema,
   PersonalizationProfileSchema,
-  ShippingMethodSchema
+  ShippingMethodSchema,
+  StoreSchema
 } from "@reactionary/core";
 import { MedusaCartCapability } from "../capabilities/cart.capability.js";
 import { MedusaCategoryCapability } from "../capabilities/category.capability.js";
@@ -43,6 +44,7 @@ import { MedusaProductCapability } from "../capabilities/product.capability.js";
 import { MedusaProductAssociationsCapability } from "../capabilities/product-associations.capability.js";
 import { MedusaProfileCapability } from "../capabilities/profile.capability.js";
 import { MedusaPersonalizationProfileCapability } from "../capabilities/personalization-profile.capability.js";
+import { MedusaStoreCapability } from "../capabilities/store.capability.js";
 import {
   MedusaCapabilitiesSchema
 } from "../schema/capabilities.schema.js";
@@ -66,7 +68,8 @@ import {
   MedusaProductFactory,
   MedusaProductSearchFactory,
   MedusaProfileFactory,
-  MedusaPersonalizationProfileFactory
+  MedusaPersonalizationProfileFactory,
+  MedusaStoreFactory
 } from "../factories/index.js";
 import {
   resolveCapabilityWithFactory,
@@ -374,6 +377,22 @@ function withMedusaCapabilities(configuration, capabilities) {
         buildCapabilityArgs
       );
     }
+    if (caps.store?.enabled) {
+      client.store = resolveCapabilityWithFactory(
+        capabilities.store,
+        {
+          factory: new MedusaStoreFactory(StoreSchema),
+          capability: (args) => new MedusaStoreCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
     if (caps.personalizationProfile?.enabled) {
       client.personalizationProfile = resolveCapabilityWithFactory(
         capabilities.personalizationProfile,

package/factories/checkout/checkout.factory.js

@@ -105,15 +105,23 @@ class MedusaCheckoutFactory {
     const backupUnattendedDelivery = data.metadata?.["consent_for_unattended_delivery"] !== void 0 ? data.metadata?.["consent_for_unattended_delivery"] === "true" : void 0;
     const backupInstructions = data.metadata?.["instructions"] != null ? String(data.metadata["instructions"]) : void 0;
     const backupPickupPoint = data.metadata?.["pickup_point"] != null ? String(data.metadata["pickup_point"]) : void 0;
+    const backupPickupStore = data.metadata?.["pickup_store"] != null && data.metadata["pickup_store"] !== "" ? String(data.metadata["pickup_store"]) : void 0;
+    const backupShippingProtocolData = this.parseShippingProtocolData(
+      data.metadata?.["shipping_protocol_data"]
+    );
     let shippingInstruction;
     data.shipping_methods?.forEach((sm) => {
       let pickupPoint = "";
       let instructions = "";
       let consentForUnattendedDelivery = false;
+      let pickupStore;
+      let protocolData;
       if (sm.data) {
         pickupPoint = sm.data["pickup_point"] != null ? String(sm.data["pickup_point"]) : "";
         instructions = sm.data["instructions"] != null ? String(sm.data["instructions"]) : "";
         consentForUnattendedDelivery = sm.data["consent_for_unattended_delivery"] === "true";
+        pickupStore = sm.data["pickup_store"] != null && sm.data["pickup_store"] !== "" ? String(sm.data["pickup_store"]) : void 0;
+        protocolData = this.parseShippingProtocolData(sm.data["shipping_protocol_data"]);
       }
       if (!pickupPoint) {
         pickupPoint = backupPickupPoint || "";
@@ -124,11 +132,19 @@ class MedusaCheckoutFactory {
       if (!consentForUnattendedDelivery) {
         consentForUnattendedDelivery = backupUnattendedDelivery || false;
       }
+      if (!pickupStore) {
+        pickupStore = backupPickupStore;
+      }
+      if (!protocolData) {
+        protocolData = backupShippingProtocolData;
+      }
       shippingInstruction = {
-        shippingMethod: { key: sm.shipping_option_id },
+        shippingMethod: { key: sm.shipping_option_id || "" },
         consentForUnattendedDelivery,
         instructions,
-        pickupPoint
+        pickupPoint,
+        store: pickupStore ? { key: pickupStore } : void 0,
+        protocolData
       };
     });
     const paymentInstructions = new Array();
@@ -192,10 +208,71 @@ class MedusaCheckoutFactory {
         value: data.calculated_price.calculated_amount || 0,
         currency: data.calculated_price.currency_code?.toUpperCase() || _context.languageContext.currencyCode
       }),
-      deliveryTime: ""
+      deliveryTime: "",
+      fulfillmentType: this.parseFulfillmentType(_context, data),
+      protocolData: this.parseShippingMethodProtocolData(_context, data)
     };
     return this.shippingMethodSchema.parse(sm);
   }
+  /**
+   * Extension point to control how a Medusa shipping option maps to the core
+   * fulfillment type. A shipping option belonging to a fulfillment set of type
+   * "pickup" is in-store pickup (BOPIS); everything else is a delivery.
+   */
+  parseFulfillmentType(_context, data) {
+    return data.service_zone?.fulfillment_set?.type === "pickup" ? "pickup" : "delivery";
+  }
+  /**
+   * Extension point mapping a Medusa shipping option's metadata to the
+   * shipping method's protocolData, so medusa-side providers can push
+   * additional data (e.g. available pickup time slots) that reaches the
+   * client. String and JSON-object values are kept as-is, other primitives
+   * are stringified, and arrays/null entries are skipped.
+   */
+  parseShippingMethodProtocolData(_context, data) {
+    if (!data.metadata) {
+      return void 0;
+    }
+    const entries = [];
+    for (const [key, value] of Object.entries(data.metadata)) {
+      if (typeof value === "string") {
+        entries.push({ key, value });
+      } else if (typeof value === "number" || typeof value === "boolean") {
+        entries.push({ key, value: String(value) });
+      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        entries.push({ key, value });
+      }
+    }
+    return entries.length > 0 ? entries : void 0;
+  }
+  /**
+   * Parses shipping protocol data persisted as a JSON object string (keys
+   * mapping to string or JSON-object values) back into protocol data entries.
+   * Returns undefined when nothing (valid) is stored, keeping the field absent
+   * for carts that never set it.
+   */
+  parseShippingProtocolData(raw) {
+    if (typeof raw !== "string" || raw.length === 0) {
+      return void 0;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return void 0;
+      }
+      const entries = [];
+      for (const [key, value] of Object.entries(parsed)) {
+        if (typeof value === "string") {
+          entries.push({ key, value });
+        } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+          entries.push({ key, value });
+        }
+      }
+      return entries.length > 0 ? entries : void 0;
+    } catch {
+      return void 0;
+    }
+  }
   parsePaymentInstruction(_context, remotePayment, checkout) {
     const mainSession = (remotePayment.payment_sessions || []).find(
       (session) => session.status !== "canceled" && session.status !== "error"

package/factories/index.js

@@ -15,3 +15,4 @@ export * from "./product-associations/product-associations.factory.js";
 export * from "./product-search/product-search.factory.js";
 export * from "./profile/profile.factory.js";
 export * from "./personalization-profile/personalization-profile.factory.js";
+export * from "./store/store.factory.js";

package/factories/store/store.factory.js

@@ -0,0 +1,49 @@
+import { AddressIdentifierSchema } from "@reactionary/core";
+class MedusaStoreFactory {
+  storeSchema;
+  constructor(storeSchema) {
+    this.storeSchema = storeSchema;
+  }
+  /**
+   * Extension point to control the parsing of the stock location address
+   * into the store's address.
+   */
+  parseAddress(_context, data) {
+    if (!data.address) {
+      return void 0;
+    }
+    return {
+      identifier: AddressIdentifierSchema.parse({
+        nickName: data.address.id
+      }),
+      firstName: "",
+      lastName: data.address.company || data.name,
+      streetAddress: data.address.address_1 || "",
+      streetNumber: data.address.address_2 || "",
+      city: data.address.city || "",
+      region: data.address.province || "",
+      postalCode: data.address.postal_code || "",
+      countryCode: data.address.country_code || ""
+    };
+  }
+  parseStore(context, data) {
+    const identifier = {
+      key: data.id
+    };
+    const fulfillmentCenter = {
+      key: data.name
+    };
+    const openingHours = data.metadata?.["opening_hours"] != null ? String(data.metadata["opening_hours"]) : void 0;
+    const result = {
+      identifier,
+      name: data.name,
+      fulfillmentCenter,
+      address: this.parseAddress(context, data),
+      openingHours
+    };
+    return this.storeSchema.parse(result);
+  }
+}
+export {
+  MedusaStoreFactory
+};

package/index.js

@@ -23,3 +23,4 @@ export * from "./capabilities/category.capability.js";
 export * from "./capabilities/checkout.capability.js";
 export * from "./capabilities/product.capability.js";
 export * from "./capabilities/personalization-profile.capability.js";
+export * from "./capabilities/store.capability.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/medusa",
-  "version": "0.10.53",
+  "version": "0.10.54",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",
@@ -10,7 +10,7 @@
   },
   "dependencies": {
     "@medusajs/js-sdk": "^2.13.3",
-    "@reactionary/core": "0.10.53",
+    "@reactionary/core": "0.10.54",
     "debug": "^4.4.3",
     "@medusajs/types": "^2.13.3",
     "zod": "4.1.9"

package/schema/capabilities.schema.js

@@ -24,7 +24,8 @@ const MedusaCapabilitiesSchema = CapabilitiesSchema.pick({
   profile: true,
   productAssociations: true,
   personalizationProfile: true,
-  company: true
+  company: true,
+  store: true
 }).extend({
   product: OverridableCapabilitySchema.optional(),
   productSearch: OverridableCapabilitySchema.optional(),
@@ -43,7 +44,8 @@ const MedusaCapabilitiesSchema = CapabilitiesSchema.pick({
   profile: OverridableCapabilitySchema.optional(),
   productAssociations: OverridableCapabilitySchema.optional(),
   productRecommendations: DirectCapabilitySchema.optional(),
-  personalizationProfile: OverridableCapabilitySchema.optional()
+  personalizationProfile: OverridableCapabilitySchema.optional(),
+  store: OverridableCapabilitySchema.optional()
 }).partial();
 export {
   MedusaCapabilitiesSchema

package/schema/medusa.schema.js

@@ -20,7 +20,8 @@ const MedusaSessionSchema = z.looseObject({
   token: z.string().optional(),
   expires: z.string().optional(),
   allRegions: z.array(MedusaRegionSchema).optional(),
-  selectedRegion: MedusaRegionSchema.optional()
+  selectedRegion: MedusaRegionSchema.optional(),
+  finalizedOrders: z.record(z.string(), MedusaOrderIdentifierSchema).optional().meta({ description: "Orders created by finalizing a checkout in this session, keyed by the originating cart id. Lets checkout reads report the resulting order when the Medusa store cart endpoint does not expose the cart-to-order relation." })
 });
 export {
   MedusaCachedPluginListSchema,

package/src/capabilities/checkout.capability.d.ts

@@ -1,9 +1,10 @@
-import type { StoreAddCartShippingMethods, StoreCalculatedPrice, StoreInitializePaymentSession, StoreUpdateCart } from '@medusajs/types';
-import type { Address, Cache, CheckoutFactory, CheckoutFactoryCheckoutOutput, CheckoutFactoryPaymentMethodOutput, CheckoutFactoryShippingMethodOutput, CheckoutFactoryWithOutput, CheckoutIdentifier, CheckoutMutationAddPaymentInstruction, CheckoutMutationFinalizeCheckout, CheckoutMutationInitiateCheckout, CheckoutMutationRemovePaymentInstruction, CheckoutMutationSetShippingAddress, CheckoutMutationSetShippingInstruction, CheckoutQueryById, CheckoutQueryForAvailablePaymentMethods, CheckoutQueryForAvailableShippingMethods, NotFoundError, RequestContext, Result } from '@reactionary/core';
+import type { StoreAddCartShippingMethods, StoreCalculatedPrice, StoreInitializePaymentSession, StoreOrder, StoreUpdateCart } from '@medusajs/types';
+import type { Address, Cache, CheckoutFactory, CheckoutFactoryCheckoutOutput, CheckoutFactoryPaymentMethodOutput, CheckoutFactoryShippingMethodOutput, CheckoutFactoryWithOutput, CheckoutIdentifier, CheckoutMutationAddPaymentInstruction, CheckoutMutationFinalizeCheckout, CheckoutMutationInitiateCheckout, CheckoutMutationRemovePaymentInstruction, CheckoutMutationSetShippingAddress, CheckoutMutationSetShippingInstruction, CheckoutQueryById, CheckoutQueryForAvailablePaymentMethods, CheckoutQueryForAvailableShippingMethods, NotFoundError, RequestContext, Result, ShippingProtocolData, StoreIdentifier } from '@reactionary/core';
 import { CheckoutCapability } from '@reactionary/core';
-import type { MedusaAPI } from '../core/client.js';
+import { type MedusaAPI } from '../core/client.js';
 import type { MedusaCheckoutFactory } from '../factories/checkout/checkout.factory.js';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import { type MedusaOrderIdentifier } from '../schema/medusa.schema.js';
 export declare class CheckoutNotReadyForFinalizationError extends Error {
     checkoutIdentifier: CheckoutIdentifier;
     constructor(checkoutIdentifier: CheckoutIdentifier);
@@ -19,6 +20,16 @@ export declare class MedusaCheckoutCapability<TFactory extends CheckoutFactory =
      * example: this.includedFields = [includedFields, '+discounts.*'].join(',');
      */
     protected includedFields: string;
+    /**
+     * This controls which fields are requested for the cart's shipping options.
+     * You can override this in a subclass to add more fields as needed.
+     *
+     * The service zone's fulfillment set tells us whether an option is in-store
+     * pickup (BOPIS) or a delivery, and the option metadata lets medusa-side
+     * providers push additional data that is mapped to the shipping method's
+     * protocolData.
+     */
+    protected shippingOptionFields: string;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: CheckoutFactoryWithOutput<TFactory>);
     protected initiateCheckoutForCartPayload(payload: CheckoutMutationInitiateCheckout): StoreUpdateCart;
     initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
@@ -27,6 +38,7 @@ export declare class MedusaCheckoutCapability<TFactory extends CheckoutFactory =
     setShippingAddress(payload: CheckoutMutationSetShippingAddress): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
     protected getAvailableShippingMethodsPayload(payload: CheckoutQueryForAvailableShippingMethods): {
         cart_id: string;
+        fields: string;
     };
     /**
      * Whether a Medusa shipping option's calculated price is usable, i.e. has an
@@ -48,8 +60,40 @@ export declare class MedusaCheckoutCapability<TFactory extends CheckoutFactory =
     addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
     removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
     protected setShippingInstructionPayload(payload: CheckoutMutationSetShippingInstruction): StoreAddCartShippingMethods;
+    /**
+     * Serializes the client-set shipping protocol data as a JSON object string
+     * for persistence in the cart metadata, or undefined when none is set.
+     */
+    protected serializeShippingProtocolData(protocolData: ShippingProtocolData[] | undefined): string | undefined;
+    /**
+     * Resolves the shipping address to use for in-store pickup (BOPIS): the
+     * address of the selected store, so the order ships to the store. Returns
+     * undefined when the store or its address is unknown, leaving the cart's
+     * shipping address untouched.
+     */
+    protected resolveStorePickupAddress(store: StoreIdentifier): Promise<Partial<Address> | undefined>;
     setShippingInstruction(payload: CheckoutMutationSetShippingInstruction): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
     finalizeCheckout(payload: CheckoutMutationFinalizeCheckout): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    /**
+     * Builds the order identifier from a completed-cart response's order,
+     * following the same display-id precedence as the checkout factory
+     * (custom_display_id over display_id).
+     */
+    protected parseCompletedOrderIdentifier(order: StoreOrder & {
+        custom_display_id?: string | number;
+    }): MedusaOrderIdentifier;
+    /**
+     * Remembers which order a finalized cart produced, so later checkout reads
+     * in the same session can report the resulting order even when the Medusa
+     * store cart endpoint does not expose the cart->order relation.
+     */
+    protected rememberFinalizedOrder(cartKey: string, order: MedusaOrderIdentifier): void;
+    /**
+     * Fills in a missing resultingOrder from the session's finalized-orders map.
+     * Checkouts that already carry a resulting order (older Medusa versions
+     * still hydrate the +order.* fields) are returned unchanged.
+     */
+    protected hydrateResultingOrder(checkout: CheckoutFactoryCheckoutOutput<TFactory>): CheckoutFactoryCheckoutOutput<TFactory>;
     /**
      * Extension point to map an Address to a Store Address
      * @param address

package/src/capabilities/store.capability.d.ts

@@ -0,0 +1,45 @@
+import type { AdminStockLocation } from '@medusajs/types';
+import type { Cache, NotFoundError, RequestContext, Result, StoreFactory, StoreFactoryOutput, StoreFactoryWithOutput, StorePaginatedResult, StoreQueryById, StoreQueryByProximity, StoreQueryForList } from '@reactionary/core';
+import { StoreCapability } from '@reactionary/core';
+import { type MedusaAPI } from '../core/client.js';
+import type { MedusaStoreFactory } from '../factories/store/store.factory.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+/**
+ * Exposes Medusa stock locations that have a fulfillment set of type "pickup"
+ * as the brand's own stores, for in-store pickup (BOPIS).
+ */
+export declare class MedusaStoreCapability<TFactory extends StoreFactory = MedusaStoreFactory> extends StoreCapability<StoreFactoryOutput<TFactory>> {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected factory: StoreFactoryWithOutput<TFactory>;
+    /**
+     * The fields requested for stock locations. Override in a subclass if a
+     * project needs more relations.
+     */
+    protected stockLocationFields: string;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: StoreFactoryWithOutput<TFactory>);
+    /**
+     * Whether a stock location is a store customers can pick up orders from,
+     * i.e. it has a fulfillment set of type "pickup".
+     */
+    protected isPickupLocation(location: AdminStockLocation): boolean;
+    /**
+     * Fetches all stock locations that are pickup stores. Medusa installations
+     * have a small, bounded number of stock locations, so fetching them all and
+     * filtering client-side is acceptable.
+     */
+    protected fetchPickupLocations(): Promise<AdminStockLocation[]>;
+    list(payload: StoreQueryForList): Promise<Result<StorePaginatedResult>>;
+    getById(payload: StoreQueryById): Promise<Result<StoreFactoryOutput<TFactory>, NotFoundError>>;
+    /**
+     * Extension point resolving a stock location's geo coordinates. Medusa
+     * stock locations carry no first-class coordinates, so by default they are
+     * read from the location metadata keys `latitude` and `longitude`. Returns
+     * undefined when the location has no usable coordinates.
+     */
+    protected parseLocationCoordinates(location: AdminStockLocation): {
+        latitude: number;
+        longitude: number;
+    } | undefined;
+    queryByProximity(payload: StoreQueryByProximity): Promise<Result<Array<StoreFactoryOutput<TFactory>>>>;
+}

package/src/core/initialize.types.d.ts

@@ -1,4 +1,4 @@
-import type { CartFactory, CategoryFactory, CheckoutFactory, ClientFromCapabilities, CompanyFactory, CompanyRegistrationFactory, EmployeeFactory, EmployeeInvitationFactory, InventoryFactory, PersonalizationProfileFactory, OrderFactory, OrderSearchFactory, PriceFactory, ProductAssociationsFactory, ProductFactory, ProductSearchFactory, ProfileFactory } from '@reactionary/core';
+import type { CartFactory, CategoryFactory, CheckoutFactory, ClientFromCapabilities, CompanyFactory, CompanyRegistrationFactory, EmployeeFactory, EmployeeInvitationFactory, InventoryFactory, PersonalizationProfileFactory, OrderFactory, OrderSearchFactory, PriceFactory, ProductAssociationsFactory, ProductFactory, ProductSearchFactory, ProfileFactory, StoreFactory } from '@reactionary/core';
 import type { MedusaCapabilities } from '../schema/capabilities.schema.js';
 import type { MedusaCartFactory } from '../factories/cart/cart.factory.js';
 import type { MedusaCategoryFactory } from '../factories/category/category.factory.js';
@@ -15,6 +15,7 @@ import type { MedusaProductAssociationsFactory } from '../factories/product-asso
 import type { MedusaProductFactory } from '../factories/product/product.factory.js';
 import type { MedusaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 import type { MedusaProfileFactory } from '../factories/profile/profile.factory.js';
+import type { MedusaStoreFactory } from '../factories/store/store.factory.js';
 import type { MedusaPersonalizationProfileFactory } from '../factories/personalization-profile/personalization-profile.factory.js';
 import type { MedusaCartCapability } from '../capabilities/cart.capability.js';
 import type { MedusaCategoryCapability } from '../capabilities/category.capability.js';
@@ -31,10 +32,11 @@ import type { MedusaProductAssociationsCapability } from '../capabilities/produc
 import type { MedusaProductCapability } from '../capabilities/product.capability.js';
 import type { MedusaProductSearchCapability } from '../capabilities/product-search.capability.js';
 import type { MedusaProfileCapability } from '../capabilities/profile.capability.js';
+import type { MedusaStoreCapability } from '../capabilities/store.capability.js';
 import type { MedusaPersonalizationProfileCapability } from '../capabilities/personalization-profile.capability.js';
 import type { MedusaProductRecommendationsCapability } from '../capabilities/product-recommendations.capability.js';
 import type { MedusaIdentityCapability } from '../capabilities/identity.capability.js';
-type OverridableCapabilityKey = 'product' | 'productSearch' | 'cart' | 'checkout' | 'category' | 'price' | 'order' | 'orderSearch' | 'inventory' | 'profile' | 'productAssociations' | 'personalizationProfile' | 'employee' | 'employeeInvitation' | 'company' | 'companyRegistration';
+type OverridableCapabilityKey = 'product' | 'productSearch' | 'cart' | 'checkout' | 'category' | 'price' | 'order' | 'orderSearch' | 'inventory' | 'profile' | 'productAssociations' | 'personalizationProfile' | 'employee' | 'employeeInvitation' | 'company' | 'companyRegistration' | 'store';
 type EnabledCapability<TCapability> = TCapability extends {
     enabled: true;
 } ? true : false;
@@ -69,6 +71,7 @@ type FactoryContractMap = {
     employeeInvitation: EmployeeInvitationFactory;
     company: CompanyFactory;
     companyRegistration: CompanyRegistrationFactory;
+    store: StoreFactory;
 };
 type DefaultFactoryMap = {
     product: MedusaProductFactory;
@@ -87,6 +90,7 @@ type DefaultFactoryMap = {
     employeeInvitation: MedusaEmployeeInvitationFactory;
     company: MedusaCompanyFactory;
     companyRegistration: MedusaCompanyRegistrationFactory;
+    store: MedusaStoreFactory;
 };
 type ResolvedFactoryMap<T extends MedusaCapabilities> = {
     [K in OverridableCapabilityKey]: ExtractCapabilityFactory<T[K], FactoryContractMap[K], DefaultFactoryMap[K]>;
@@ -108,6 +112,7 @@ type DefaultCapabilityMap<T extends MedusaCapabilities> = {
     employeeInvitation: MedusaEmployeeInvitationCapability<ResolvedFactoryMap<T>['employeeInvitation']>;
     company: MedusaCompanyCapability<ResolvedFactoryMap<T>['company']>;
     companyRegistration: MedusaCompanyRegistrationCapability<ResolvedFactoryMap<T>['companyRegistration']>;
+    store: MedusaStoreCapability<ResolvedFactoryMap<T>['store']>;
     identity: MedusaIdentityCapability;
     productRecommendations: MedusaProductRecommendationsCapability;
 };

package/src/factories/checkout/checkout.factory.d.ts

@@ -1,7 +1,15 @@
 import type { StorePaymentCollection } from '@medusajs/types';
 import { type StoreCart, type StoreCartAddress, type StoreCartLineItem, type StoreCartShippingOptionWithServiceZone, type StorePaymentProvider } from '@medusajs/types';
-import { type Address, type AnyCheckoutSchema, type AnyPaymentMethodSchema, type AnyShippingMethodSchema, type CheckoutFactory, type CheckoutItem, type CheckoutSchema, type CostBreakDown, type Currency, type ItemCostBreakdown, type PaymentInstruction, type PaymentMethodIdentifier, type PaymentMethodSchema, type RequestContext, type ShippingInstruction, type ShippingMethodSchema } from '@reactionary/core';
+import { type Address, type AnyCheckoutSchema, type AnyPaymentMethodSchema, type AnyShippingMethodSchema, type CheckoutFactory, type CheckoutItem, type CheckoutSchema, type CostBreakDown, type Currency, type ItemCostBreakdown, type PaymentInstruction, type PaymentMethodIdentifier, type PaymentMethodSchema, type RequestContext, type ShippingFulfillmentType, type ShippingInstruction, type ShippingMethodSchema, type ShippingProtocolData } from '@reactionary/core';
 import type * as z from 'zod';
+/**
+ * A cart shipping option with the optional metadata relation, which the
+ * Medusa HTTP types do not declare on the store-level shipping option even
+ * though it can be requested via the fields parameter.
+ */
+export type MedusaShippingOptionWithMetadata = StoreCartShippingOptionWithServiceZone & {
+    metadata?: Record<string, unknown> | null;
+};
 export declare class MedusaCheckoutFactory<TCheckoutSchema extends AnyCheckoutSchema = typeof CheckoutSchema, TShippingMethodSchema extends AnyShippingMethodSchema = typeof ShippingMethodSchema, TPaymentMethodSchema extends AnyPaymentMethodSchema = typeof PaymentMethodSchema> implements CheckoutFactory<TCheckoutSchema, TShippingMethodSchema, TPaymentMethodSchema> {
     readonly checkoutSchema: TCheckoutSchema;
     readonly shippingMethodSchema: TShippingMethodSchema;
@@ -36,7 +44,28 @@ export declare class MedusaCheckoutFactory<TCheckoutSchema extends AnyCheckoutSc
     protected isReadyForFinalization(price: CostBreakDown, paymentInstructions: PaymentInstruction[], billingAddress?: Address, shippingAddress?: Address, shippingInstruction?: ShippingInstruction): boolean;
     protected isCart(data: StoreCart): data is StoreCart;
     parseCheckout(context: RequestContext, data: StoreCart): z.output<TCheckoutSchema>;
-    parseShippingMethod(_context: RequestContext, data: StoreCartShippingOptionWithServiceZone): z.output<TShippingMethodSchema>;
+    parseShippingMethod(_context: RequestContext, data: MedusaShippingOptionWithMetadata): z.output<TShippingMethodSchema>;
+    /**
+     * Extension point to control how a Medusa shipping option maps to the core
+     * fulfillment type. A shipping option belonging to a fulfillment set of type
+     * "pickup" is in-store pickup (BOPIS); everything else is a delivery.
+     */
+    protected parseFulfillmentType(_context: RequestContext, data: MedusaShippingOptionWithMetadata): ShippingFulfillmentType;
+    /**
+     * Extension point mapping a Medusa shipping option's metadata to the
+     * shipping method's protocolData, so medusa-side providers can push
+     * additional data (e.g. available pickup time slots) that reaches the
+     * client. String and JSON-object values are kept as-is, other primitives
+     * are stringified, and arrays/null entries are skipped.
+     */
+    protected parseShippingMethodProtocolData(_context: RequestContext, data: MedusaShippingOptionWithMetadata): ShippingProtocolData[] | undefined;
+    /**
+     * Parses shipping protocol data persisted as a JSON object string (keys
+     * mapping to string or JSON-object values) back into protocol data entries.
+     * Returns undefined when nothing (valid) is stored, keeping the field absent
+     * for carts that never set it.
+     */
+    protected parseShippingProtocolData(raw: unknown): ShippingProtocolData[] | undefined;
     protected parsePaymentInstruction(_context: RequestContext, remotePayment: StorePaymentCollection, checkout: StoreCart): {
         identifier: {
             key: string;

package/src/factories/index.d.ts

@@ -15,3 +15,4 @@ export * from './product-associations/product-associations.factory.js';
 export * from './product-search/product-search.factory.js';
 export * from './profile/profile.factory.js';
 export * from './personalization-profile/personalization-profile.factory.js';
+export * from './store/store.factory.js';

package/src/factories/store/store.factory.d.ts

@@ -0,0 +1,13 @@
+import type { AdminStockLocation } from '@medusajs/types';
+import type { Address, AnyStoreSchema, RequestContext, StoreFactory, StoreSchema } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class MedusaStoreFactory<TStoreSchema extends AnyStoreSchema = typeof StoreSchema> implements StoreFactory<TStoreSchema> {
+    readonly storeSchema: TStoreSchema;
+    constructor(storeSchema: TStoreSchema);
+    /**
+     * Extension point to control the parsing of the stock location address
+     * into the store's address.
+     */
+    protected parseAddress(_context: RequestContext, data: AdminStockLocation): Address | undefined;
+    parseStore(context: RequestContext, data: AdminStockLocation): z.output<TStoreSchema>;
+}

package/src/index.d.ts

@@ -23,3 +23,4 @@ export * from './capabilities/category.capability.js';
 export * from './capabilities/checkout.capability.js';
 export * from './capabilities/product.capability.js';
 export * from './capabilities/personalization-profile.capability.js';
+export * from './capabilities/store.capability.js';

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

@@ -1,4 +1,4 @@
-import type { CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, CompanyFactory, CompanyFactoryWithOutput, CompanyCapability, CompanyRegistrationFactory, CompanyRegistrationFactoryWithOutput, CompanyRegistrationCapability, EmployeeFactory, EmployeeFactoryWithOutput, EmployeeCapability, EmployeeInvitationFactory, EmployeeInvitationFactoryWithOutput, EmployeeInvitationCapability, IdentityCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, PersonalizationProfileFactory, PersonalizationProfileFactoryWithOutput, PersonalizationProfileCapability, OrderFactory, OrderFactoryWithOutput, OrderCapability, OrderSearchFactory, OrderSearchFactoryWithOutput, OrderSearchCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductAssociationsFactory, ProductAssociationsFactoryWithOutput, ProductAssociationsCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductRecommendationsCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability, ProfileFactory, ProfileFactoryWithOutput, ProfileCapability, RequestContext, Cache } from '@reactionary/core';
+import type { CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, CompanyFactory, CompanyFactoryWithOutput, CompanyCapability, CompanyRegistrationFactory, CompanyRegistrationFactoryWithOutput, CompanyRegistrationCapability, EmployeeFactory, EmployeeFactoryWithOutput, EmployeeCapability, EmployeeInvitationFactory, EmployeeInvitationFactoryWithOutput, EmployeeInvitationCapability, IdentityCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, PersonalizationProfileFactory, PersonalizationProfileFactoryWithOutput, PersonalizationProfileCapability, OrderFactory, OrderFactoryWithOutput, OrderCapability, OrderSearchFactory, OrderSearchFactoryWithOutput, OrderSearchCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductAssociationsFactory, ProductAssociationsFactoryWithOutput, ProductAssociationsCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductRecommendationsCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability, ProfileFactory, ProfileFactoryWithOutput, ProfileCapability, StoreFactory, StoreFactoryWithOutput, StoreCapability, RequestContext, Cache } from '@reactionary/core';
 import type { MedusaConfiguration } from './configuration.schema.js';
 import type { MedusaAPI } from '../core/client.js';
 import * as z from 'zod';
@@ -91,6 +91,11 @@ export declare const MedusaCapabilitiesSchema: z.ZodObject<{
         factory: z.ZodOptional<z.ZodUnknown>;
         capability: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$loose>>>;
+    store: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
 }, z.core.$loose>;
 export interface MedusaCapabilityFactoryArgs {
     cache: Cache;
@@ -128,7 +133,8 @@ export type MedusaProfileCapabilityConfig = MedusaCapabilityConfig<ProfileFactor
 export type MedusaProductAssociationsCapabilityConfig = MedusaCapabilityConfig<ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>, ProductAssociationsCapability>;
 export type MedusaPersonalizationProfileCapabilityConfig = MedusaCapabilityConfig<PersonalizationProfileFactoryWithOutput<PersonalizationProfileFactory>, PersonalizationProfileCapability>;
 export type MedusaProductRecommendationsCapabilityConfig = MedusaDirectCapabilityConfig<ProductRecommendationsCapability>;
-export type MedusaCapabilities<TProductFactory extends ProductFactory = ProductFactory, TProductCapability extends ProductCapability = ProductCapability, TProductSearchFactory extends ProductSearchFactory = ProductSearchFactory, TProductSearchCapability extends ProductSearchCapability = ProductSearchCapability, TCartFactory extends CartFactory = CartFactory, TCartCapability extends CartCapability = CartCapability, TCheckoutFactory extends CheckoutFactory = CheckoutFactory, TCheckoutCapability extends CheckoutCapability = CheckoutCapability, TCategoryFactory extends CategoryFactory = CategoryFactory, TCategoryCapability extends CategoryCapability = CategoryCapability, TPriceFactory extends PriceFactory = PriceFactory, TPriceCapability extends PriceCapability = PriceCapability, TOrderFactory extends OrderFactory = OrderFactory, TOrderCapability extends OrderCapability = OrderCapability, TOrderSearchFactory extends OrderSearchFactory = OrderSearchFactory, TOrderSearchCapability extends OrderSearchCapability = OrderSearchCapability, TInventoryFactory extends InventoryFactory = InventoryFactory, TInventoryCapability extends InventoryCapability = InventoryCapability, TIdentityCapability extends IdentityCapability = IdentityCapability, TProfileFactory extends ProfileFactory = ProfileFactory, TProfileCapability extends ProfileCapability = ProfileCapability, TProductAssociationsFactory extends ProductAssociationsFactory = ProductAssociationsFactory, TProductAssociationsCapability extends ProductAssociationsCapability = ProductAssociationsCapability, TProductRecommendationsCapability extends ProductRecommendationsCapability = ProductRecommendationsCapability, TPersonalizationProfileFactory extends PersonalizationProfileFactory = PersonalizationProfileFactory, TPersonalizationProfileCapability extends PersonalizationProfileCapability = PersonalizationProfileCapability, TEmployeeFactory extends EmployeeFactory = EmployeeFactory, TEmployeeCapability extends EmployeeCapability = EmployeeCapability, TEmployeeInvitationFactory extends EmployeeInvitationFactory = EmployeeInvitationFactory, TEmployeeInvitationCapability extends EmployeeInvitationCapability = EmployeeInvitationCapability, TCompanyFactory extends CompanyFactory = CompanyFactory, TCompanyCapability extends CompanyCapability = CompanyCapability, TCompanyRegistrationFactory extends CompanyRegistrationFactory = CompanyRegistrationFactory, TCompanyRegistrationCapability extends CompanyRegistrationCapability = CompanyRegistrationCapability> = {
+export type MedusaStoreCapabilityConfig = MedusaCapabilityConfig<StoreFactoryWithOutput<StoreFactory>, StoreCapability>;
+export type MedusaCapabilities<TProductFactory extends ProductFactory = ProductFactory, TProductCapability extends ProductCapability = ProductCapability, TProductSearchFactory extends ProductSearchFactory = ProductSearchFactory, TProductSearchCapability extends ProductSearchCapability = ProductSearchCapability, TCartFactory extends CartFactory = CartFactory, TCartCapability extends CartCapability = CartCapability, TCheckoutFactory extends CheckoutFactory = CheckoutFactory, TCheckoutCapability extends CheckoutCapability = CheckoutCapability, TCategoryFactory extends CategoryFactory = CategoryFactory, TCategoryCapability extends CategoryCapability = CategoryCapability, TPriceFactory extends PriceFactory = PriceFactory, TPriceCapability extends PriceCapability = PriceCapability, TOrderFactory extends OrderFactory = OrderFactory, TOrderCapability extends OrderCapability = OrderCapability, TOrderSearchFactory extends OrderSearchFactory = OrderSearchFactory, TOrderSearchCapability extends OrderSearchCapability = OrderSearchCapability, TInventoryFactory extends InventoryFactory = InventoryFactory, TInventoryCapability extends InventoryCapability = InventoryCapability, TIdentityCapability extends IdentityCapability = IdentityCapability, TProfileFactory extends ProfileFactory = ProfileFactory, TProfileCapability extends ProfileCapability = ProfileCapability, TProductAssociationsFactory extends ProductAssociationsFactory = ProductAssociationsFactory, TProductAssociationsCapability extends ProductAssociationsCapability = ProductAssociationsCapability, TProductRecommendationsCapability extends ProductRecommendationsCapability = ProductRecommendationsCapability, TPersonalizationProfileFactory extends PersonalizationProfileFactory = PersonalizationProfileFactory, TPersonalizationProfileCapability extends PersonalizationProfileCapability = PersonalizationProfileCapability, TEmployeeFactory extends EmployeeFactory = EmployeeFactory, TEmployeeCapability extends EmployeeCapability = EmployeeCapability, TEmployeeInvitationFactory extends EmployeeInvitationFactory = EmployeeInvitationFactory, TEmployeeInvitationCapability extends EmployeeInvitationCapability = EmployeeInvitationCapability, TCompanyFactory extends CompanyFactory = CompanyFactory, TCompanyCapability extends CompanyCapability = CompanyCapability, TCompanyRegistrationFactory extends CompanyRegistrationFactory = CompanyRegistrationFactory, TCompanyRegistrationCapability extends CompanyRegistrationCapability = CompanyRegistrationCapability, TStoreFactory extends StoreFactory = StoreFactory, TStoreCapability extends StoreCapability = StoreCapability> = {
     product?: MedusaCapabilityConfig<ProductFactoryWithOutput<TProductFactory>, TProductCapability>;
     productSearch?: MedusaCapabilityConfig<ProductSearchFactoryWithOutput<TProductSearchFactory>, TProductSearchCapability>;
     cart?: MedusaCapabilityConfig<CartFactoryWithOutput<TCartFactory>, TCartCapability>;
@@ -147,5 +153,6 @@ export type MedusaCapabilities<TProductFactory extends ProductFactory = ProductF
     productAssociations?: MedusaCapabilityConfig<ProductAssociationsFactoryWithOutput<TProductAssociationsFactory>, TProductAssociationsCapability>;
     productRecommendations?: MedusaDirectCapabilityConfig<TProductRecommendationsCapability>;
     personalizationProfile?: MedusaCapabilityConfig<PersonalizationProfileFactoryWithOutput<TPersonalizationProfileFactory>, TPersonalizationProfileCapability>;
+    store?: MedusaCapabilityConfig<StoreFactoryWithOutput<TStoreFactory>, TStoreCapability>;
 };
 export type ParsedMedusaCapabilities = z.infer<typeof MedusaCapabilitiesSchema>;

package/src/schema/medusa.schema.d.ts

@@ -41,6 +41,10 @@ export declare const MedusaSessionSchema: z.ZodObject<{
         name: z.ZodString;
         currency_code: z.ZodString;
     }, z.core.$loose>>;
+    finalizedOrders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        key: z.ZodString;
+        display_id: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>>;
 }, z.core.$loose>;
 export type MedusaCartIdentifier = InferType<typeof MedusaCartIdentifierSchema>;
 export type MedusaOrderIdentifier = z.infer<typeof MedusaOrderIdentifierSchema>;

package/src/utils/geo.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Great-circle distance between two coordinates in kilometers, using the
+ * haversine formula.
+ */
+export declare function haversineDistanceKm(latitude1: number, longitude1: number, latitude2: number, longitude2: number): number;

package/utils/geo.js

@@ -0,0 +1,11 @@
+const EARTH_RADIUS_KM = 6371;
+function haversineDistanceKm(latitude1, longitude1, latitude2, longitude2) {
+  const toRadians = (degrees) => degrees * Math.PI / 180;
+  const deltaLatitude = toRadians(latitude2 - latitude1);
+  const deltaLongitude = toRadians(longitude2 - longitude1);
+  const a = Math.sin(deltaLatitude / 2) ** 2 + Math.cos(toRadians(latitude1)) * Math.cos(toRadians(latitude2)) * Math.sin(deltaLongitude / 2) ** 2;
+  return 2 * EARTH_RADIUS_KM * Math.asin(Math.sqrt(a));
+}
+export {
+  haversineDistanceKm
+};