@reactionary/medusa 0.6.8 → 0.6.10

package/capabilities/cart.capability.js

@@ -10,28 +10,29 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 import {
+  CartCapability,
   CartIdentifierSchema,
   CartMutationApplyCouponSchema,
   CartMutationChangeCurrencySchema,
+  CartMutationCreateCartSchema,
   CartMutationDeleteCartSchema,
   CartMutationItemAddSchema,
   CartMutationItemQuantityChangeSchema,
   CartMutationItemRemoveSchema,
   CartMutationRemoveCouponSchema,
-  CartCapability,
+  CartMutationRenameCartSchema,
+  CartPaginatedSearchResultSchema,
   CartQueryByIdSchema,
+  CartQueryListSchema,
   CartSchema,
   error,
-  ProductVariantIdentifierSchema,
   Reactionary,
   success
 } from "@reactionary/core";
+import {} from "@medusajs/types";
 import createDebug from "debug";
-import { MedusaCartIdentifierSchema } from "../schema/medusa.schema.js";
 import {
-  handleProviderError,
-  parseMedusaCostBreakdown,
-  parseMedusaItemPrice
+  handleProviderError
 } from "../utils/medusa-helpers.js";
 const debug = createDebug("reactionary:medusa:cart");
 class MedusaCartCapability extends CartCapability {
@@ -50,6 +51,29 @@ class MedusaCartCapability extends CartCapability {
    * example: this.includedFields = [includedFields, '+discounts.*'].join(',');
    */
   includedFields = ["+items.*"].join(",");
+  async listCarts(payload) {
+    const client = await this.getClient();
+    const sessionData = this.medusaApi.getSessionData();
+    let cartCollection = payload.search.company ? sessionData.allOwnedCarts?.[payload.search.company.taxIdentifier] : sessionData.allOwnedCarts?.["_me"];
+    const totalCount = cartCollection ? cartCollection.length : 0;
+    if (cartCollection) {
+      cartCollection = cartCollection.slice((payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize, payload.search.paginationOptions.pageNumber * payload.search.paginationOptions.pageSize);
+    } else {
+      cartCollection = [];
+    }
+    const shortFields = ["id", "customerId", "updated_at", "metadata", "items.id"].join(",");
+    const allPromises = cartCollection.map((cartIdentifier) => client.store.cart.retrieve(cartIdentifier.key, { fields: shortFields }));
+    const responses = await Promise.all(allPromises);
+    const carts = responses.map((response) => response.cart).filter((cart) => !!cart);
+    return success(this.factory.parseCartPaginatedSearchResult(
+      this.context,
+      {
+        items: carts,
+        totalCount
+      },
+      payload
+    ));
+  }
   async getById(payload) {
     try {
       const client = await this.getClient();
@@ -69,7 +93,7 @@ class MedusaCartCapability extends CartCapability {
         identifier: payload
       });
     } catch (err) {
-      debug("Failed to get cart by ID:", error);
+      debug("Failed to get cart by ID:", err);
       return error({
         type: "NotFound",
         identifier: payload
@@ -92,9 +116,12 @@ class MedusaCartCapability extends CartCapability {
   async add(payload) {
     try {
       const client = await this.getClient();
-      let cartIdentifier = payload.cart;
+      const cartIdentifier = payload.cart;
       if (!cartIdentifier) {
-        cartIdentifier = await this.createCart();
+        return error({
+          type: "InvalidInput",
+          error: "Cart identifier is required to add item to cart"
+        });
       }
       const medusaId = cartIdentifier;
       if (debug.enabled) {
@@ -126,6 +153,95 @@ class MedusaCartCapability extends CartCapability {
       handleProviderError("add item to cart", error2);
     }
   }
+  async renameCart(payload) {
+    const client = await this.getClient();
+    const medusaId = payload.cart;
+    const cartResponse = await client.store.cart.retrieve(medusaId.key, { fields: ["metadata.*"].join(",") });
+    if (!cartResponse.cart) {
+      return error({
+        type: "NotFound",
+        identifier: payload.cart
+      });
+    }
+    const currentMetadata = cartResponse.cart.metadata || {};
+    const updatedMetadata = {
+      ...currentMetadata,
+      name: payload.newName
+    };
+    const response = await client.store.cart.update(
+      medusaId.key,
+      {
+        metadata: updatedMetadata
+      },
+      {
+        fields: this.includedFields
+      }
+    );
+    if (response.cart) {
+      return success(this.factory.parseCart(this.context, response.cart));
+    }
+    throw new Error("Failed to rename cart");
+  }
+  /**
+   * Extension point to control the payload sent to Medusa when creating a cart. By default, it only includes the currency code, but you can override it to include more fields as needed.
+   * @param currency
+   * @returns
+   */
+  createCartPayload(payload) {
+    return {
+      currency_code: (this.context.languageContext.currencyCode || "EUR").toLowerCase(),
+      locale: this.context.languageContext.locale || "en",
+      metadata: {
+        name: payload.name
+      }
+    };
+  }
+  addCartToOwnedList(cartIdentifier, companyId) {
+    const sessionData = this.medusaApi.getSessionData();
+    const companyIdToUse = companyId ? companyId.taxIdentifier : "_me";
+    if (sessionData.allOwnedCarts) {
+      sessionData.allOwnedCarts[companyIdToUse] = [
+        ...sessionData.allOwnedCarts[companyIdToUse] || [],
+        cartIdentifier
+      ];
+    } else {
+      sessionData.allOwnedCarts = {
+        [companyIdToUse]: [cartIdentifier]
+      };
+    }
+    this.medusaApi.setSessionData(sessionData);
+  }
+  removeCartFromOwnedList(cartIdentifier, company) {
+    const sessionData = this.medusaApi.getSessionData();
+    const companyIdToUse = company ? company.taxIdentifier : "_me";
+    if (sessionData.allOwnedCarts && sessionData.allOwnedCarts[companyIdToUse]) {
+      sessionData.allOwnedCarts[companyIdToUse] = sessionData.allOwnedCarts[companyIdToUse].filter(
+        (c) => c.key !== cartIdentifier.key
+      );
+      this.medusaApi.setSessionData(sessionData);
+    }
+  }
+  async createCart(payload) {
+    try {
+      const client = await this.getClient();
+      const response = await client.store.cart.create(
+        this.createCartPayload(payload),
+        {
+          fields: this.includedFields
+        }
+      );
+      if (response.cart) {
+        this.addCartToOwnedList(this.factory.parseCartIdentifier(this.context, response.cart), payload.company);
+        this.medusaApi.setSessionData({
+          activeCartId: this.factory.parseCartIdentifier(this.context, response.cart)
+        });
+        return success(this.factory.parseCart(this.context, response.cart));
+      }
+      throw new Error("Failed to create cart");
+    } catch (error2) {
+      handleProviderError("create cart", error2);
+    }
+  }
   async remove(payload) {
     try {
       const client = await this.getClient();
@@ -184,16 +300,25 @@ class MedusaCartCapability extends CartCapability {
     try {
       const client = await this.getClient();
       const sessionData = this.medusaApi.getSessionData();
-      const activeCartId = sessionData.activeCartId;
+      let activeCartId = sessionData.activeCartId;
+      if (!activeCartId && sessionData && sessionData.allOwnedCarts) {
+        if (sessionData.allOwnedCarts["_me"]) {
+          activeCartId = sessionData.allOwnedCarts["_me"][0] || void 0;
+        }
+      }
       if (activeCartId) {
-        try {
-          await client.store.cart.retrieve(activeCartId);
-          return success(this.factory.parseCartIdentifier(this.context, {
-            key: activeCartId,
-            region_id: (await this.medusaApi.getActiveRegion()).id
-          }));
-        } catch {
+        const response = await client.store.cart.retrieve(activeCartId.key, { fields: "id,region_id" });
+        if (!response.cart) {
+          delete sessionData.activeCartId;
+          this.medusaApi.setSessionData({
+            activeCartId: void 0
+          });
+          return error({
+            type: "NotFound",
+            identifier: activeCartId
+          });
         }
+        return success(this.factory.parseCartIdentifier(this.context, response.cart));
       }
       return error({
         type: "NotFound",
@@ -320,7 +445,7 @@ class MedusaCartCapability extends CartCapability {
       );
       if (updatedCartResponse.cart) {
         this.medusaApi.setSessionData({
-          activeCartId: updatedCartResponse.cart.id
+          activeCartId: this.factory.parseCartIdentifier(this.context, updatedCartResponse.cart)
         });
         return success(this.factory.parseCart(this.context, updatedCartResponse.cart));
       }
@@ -329,44 +454,17 @@ class MedusaCartCapability extends CartCapability {
       handleProviderError("change currency", error2);
     }
   }
-  /**
-   * Extension point to control the payload sent to Medusa when creating a cart. By default, it only includes the currency code, but you can override it to include more fields as needed.
-   * @param currency
-   * @returns
-   */
-  createCartPayload(currency) {
-    return {
-      currency_code: (currency || this.context.languageContext.currencyCode || "").toLowerCase()
-    };
-  }
-  async createCart(currency) {
-    try {
-      const client = await this.getClient();
-      const response = await client.store.cart.create(
-        this.createCartPayload(currency),
-        {
-          fields: this.includedFields
-        }
-      );
-      if (response.cart) {
-        const cartIdentifier = this.factory.parseCartIdentifier(this.context, {
-          key: response.cart.id,
-          region_id: response.cart.region_id
-        });
-        this.medusaApi.setSessionData({
-          activeCartId: cartIdentifier.key
-        });
-        return cartIdentifier;
-      }
-      throw new Error("Failed to create cart");
-    } catch (error2) {
-      handleProviderError("create cart", error2);
-    }
-  }
   async getClient() {
     return this.medusaApi.getClient();
   }
 }
+__decorateClass([
+  Reactionary({
+    inputSchema: CartQueryListSchema,
+    outputSchema: CartPaginatedSearchResultSchema,
+    cache: false
+  })
+], MedusaCartCapability.prototype, "listCarts", 1);
 __decorateClass([
   Reactionary({
     inputSchema: CartQueryByIdSchema,
@@ -379,6 +477,18 @@ __decorateClass([
     outputSchema: CartSchema
   })
 ], MedusaCartCapability.prototype, "add", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationRenameCartSchema,
+    outputSchema: CartSchema
+  })
+], MedusaCartCapability.prototype, "renameCart", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationCreateCartSchema,
+    outputSchema: CartSchema
+  })
+], MedusaCartCapability.prototype, "createCart", 1);
 __decorateClass([
   Reactionary({
     inputSchema: CartMutationItemRemoveSchema,

package/capabilities/checkout.capability.js

@@ -250,7 +250,7 @@ class MedusaCheckoutCapability extends CheckoutCapability {
     const medusaId = payload.checkout;
     const response = await client.store.cart.complete(medusaId.key);
     if (response.type === "order") {
-      await client.store.cart.update(medusaId.key, {
+      const updatedCart = await client.store.cart.update(medusaId.key, {
         metadata: {
           order_id: response.order.id,
           order_display_id: response.order?.display_id ? response.order.display_id + "" : ""
@@ -259,6 +259,18 @@ class MedusaCheckoutCapability extends CheckoutCapability {
       const refreshedCheckout = await this.getById({
         identifier: payload.checkout
       });
+      const sessionData = this.medusaApi.getSessionData();
+      const cartCollectionKey = "_me";
+      if (sessionData.allOwnedCarts?.[cartCollectionKey]) {
+        const updatedCollection = sessionData.allOwnedCarts[cartCollectionKey].filter((x) => x.key !== updatedCart.cart.id);
+        this.medusaApi.setSessionData({
+          allOwnedCarts: {
+            ...sessionData.allOwnedCarts,
+            [cartCollectionKey]: updatedCollection
+          },
+          activeCartId: updatedCollection.length > 0 ? updatedCollection[0] : void 0
+        });
+      }
       if (!refreshedCheckout.success) {
         throw new Error(`Unable to reload checkout ${payload.checkout.key} after completion`);
       }

package/capabilities/identity.capability.js

@@ -40,6 +40,17 @@ class MedusaIdentityCapability extends IdentityCapability {
       const token = await medusaClient.client.getToken();
       if (!token) {
         debug("No active session token found, returning anonymous identity");
+        if (this.medusaApi.getSessionData().activeCartId) {
+          debug("Active cart found in session without token, treating as guest session");
+          const identity3 = {
+            type: "Guest",
+            id: {
+              userId: "guest"
+            }
+          };
+          this.updateIdentityContext(identity3);
+          return success(identity3);
+        }
         const identity2 = this.createAnonymousIdentity();
         this.updateIdentityContext(identity2);
         return success(identity2);

package/core/client.js

@@ -1,6 +1,7 @@
 import { Admin, Auth, Client, Store } from "@medusajs/js-sdk";
 import {
   AnonymousIdentitySchema,
+  GuestIdentitySchema,
   Reactionary,
   RegisteredIdentitySchema
 } from "@reactionary/core";

package/core/initialize.js

@@ -1,5 +1,6 @@
 import {
   CartIdentifierSchema,
+  CartPaginatedSearchResultSchema,
   CartSchema,
   CategoryPaginatedResultSchema,
   CategorySchema,
@@ -157,7 +158,11 @@ function withMedusaCapabilities(configuration, capabilities) {
       client.cart = resolveCapabilityWithFactory(
         capabilities.cart,
         {
-          factory: new MedusaCartFactory(CartSchema, CartIdentifierSchema),
+          factory: new MedusaCartFactory(
+            CartSchema,
+            CartIdentifierSchema,
+            CartPaginatedSearchResultSchema
+          ),
           capability: (args) => new MedusaCartCapability(
             args.config,
             args.cache,

package/factories/cart/cart.factory.js

@@ -6,9 +6,35 @@ import { parseMedusaCostBreakdown, parseMedusaItemPrice } from "../../utils/medu
 class MedusaCartFactory {
   cartSchema;
   cartIdentifierSchema;
-  constructor(cartSchema, cartIdentifierSchema) {
+  cartPaginatedSearchResultSchema;
+  constructor(cartSchema, cartIdentifierSchema, cartPaginatedSearchResultSchema) {
     this.cartSchema = cartSchema;
     this.cartIdentifierSchema = cartIdentifierSchema;
+    this.cartPaginatedSearchResultSchema = cartPaginatedSearchResultSchema;
+  }
+  parseCartPaginatedSearchResult(_context, data, _query) {
+    const result = {
+      identifier: _query.search,
+      items: data.items.map((item) => this.parseCartSearchResultItem(_context, item)),
+      totalCount: data.totalCount,
+      pageNumber: _query.search.paginationOptions.pageNumber,
+      pageSize: _query.search.paginationOptions.pageSize,
+      totalPages: Math.ceil(data.totalCount / _query.search.paginationOptions.pageSize)
+    };
+    return this.cartPaginatedSearchResultSchema.parse(result);
+  }
+  parseCartSearchResultItem(_context, data) {
+    const result = {
+      identifier: this.parseCartIdentifier(_context, data),
+      numItems: data.items?.length || 0,
+      lastModifiedDate: new Date(data.updated_at).toISOString(),
+      user: {
+        userId: data.customer_id || "???"
+      },
+      company: void 0,
+      name: "" + (data.metadata?.["name"] || "")
+    };
+    return result;
   }
   parseCart(context, data) {
     const identifier = MedusaCartIdentifierSchema.parse({
@@ -52,14 +78,18 @@ class MedusaCartFactory {
       price,
       items,
       appliedPromotions,
-      userId: {
-        userId: "???"
+      user: {
+        userId: data.customer_id || "???"
       }
     };
     return this.cartSchema.parse(result);
   }
   parseCartIdentifier(_context, data) {
-    return this.cartIdentifierSchema.parse(data);
+    const result = {
+      key: data.id,
+      region_id: data.region_id
+    };
+    return this.cartIdentifierSchema.parse(result);
   }
   /**
   * Extension point to control the parsing of a single cart item price

package/factories/checkout/checkout.factory.js

@@ -148,7 +148,7 @@ class MedusaCheckoutFactory {
     }
     const originalCartReference = {
       key: data.id,
-      region: data.region_id
+      region_id: data.region_id
     };
     const pointOfContact = {
       email: data.email || "",

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@reactionary/medusa",
-  "version": "0.6.8",
+  "version": "0.6.10",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",
   "dependencies": {
     "@medusajs/js-sdk": "^2.13.3",
-    "@reactionary/core": "0.6.8",
+    "@reactionary/core": "0.6.10",
     "debug": "^4.4.3",
     "@medusajs/types": "^2.13.3",
     "zod": "4.1.9",

package/schema/medusa.schema.js

@@ -12,7 +12,8 @@ const MedusaRegionSchema = z.looseObject({
   currency_code: z.string()
 });
 const MedusaSessionSchema = z.looseObject({
-  activeCartId: z.string().optional(),
+  activeCartId: MedusaCartIdentifierSchema.optional(),
+  allOwnedCarts: z.record(z.string(), z.array(MedusaCartIdentifierSchema)).optional(),
   token: z.string().optional(),
   expires: z.string().optional(),
   allRegions: z.array(MedusaRegionSchema).optional(),

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

@@ -1,9 +1,10 @@
-import type { Cache, CartFactory, CartFactoryCartOutput, CartFactoryIdentifierOutput, CartFactoryWithOutput, CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartMutationRemoveCoupon, CartQueryById, NotFoundError, RequestContext, Result } from '@reactionary/core';
+import type { Cache, CartFactory, CartFactoryCartOutput, CartFactoryIdentifierOutput, CartFactoryWithOutput, CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationCreateCart, CartMutationDeleteCart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartMutationRemoveCoupon, CartMutationRenameCart, CartPaginatedSearchResult, CartQueryById, CartQueryList, CompanyIdentifier, NotFoundError, RequestContext, Result } from '@reactionary/core';
 import { CartCapability } from '@reactionary/core';
+import { type StoreAddCartLineItem, type StoreCartAddPromotion, type StoreCartRemovePromotion, type StoreCreateCart, type StoreUpdateCart, type StoreUpdateCartLineItem } from '@medusajs/types';
 import type { MedusaAPI } from '../core/client.js';
-import type { MedusaConfiguration } from '../schema/configuration.schema.js';
-import type { StoreAddCartLineItem, StoreCartAddPromotion, StoreCartRemovePromotion, StoreCreateCart, StoreUpdateCart, StoreUpdateCartLineItem } from '@medusajs/types';
 import type { MedusaCartFactory } from '../factories/cart/cart.factory.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaCartIdentifier } from '../schema/medusa.schema.js';
 export declare class MedusaCartCapability<TFactory extends CartFactory = MedusaCartFactory> extends CartCapability<CartFactoryCartOutput<TFactory>, CartFactoryIdentifierOutput<TFactory>> {
     medusaApi: MedusaAPI;
     protected config: MedusaConfiguration;
@@ -16,6 +17,7 @@ export declare class MedusaCartCapability<TFactory extends CartFactory = MedusaC
      */
     protected includedFields: string;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: CartFactoryWithOutput<TFactory>);
+    listCarts(payload: CartQueryList): Promise<Result<CartPaginatedSearchResult>>;
     getById(payload: CartQueryById): Promise<Result<CartFactoryCartOutput<TFactory>, NotFoundError>>;
     /**
      * Extension point for the `add` operation to control the payload sent to Medusa when adding an item to the cart. By default, it only includes the variant ID and quantity, but you can override it to include more fields as needed.
@@ -26,6 +28,16 @@ export declare class MedusaCartCapability<TFactory extends CartFactory = MedusaC
      */
     protected addPayload(payload: CartMutationItemAdd, variantId: string): StoreAddCartLineItem;
     add(payload: CartMutationItemAdd): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    renameCart(payload: CartMutationRenameCart): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    /**
+     * Extension point to control the payload sent to Medusa when creating a cart. By default, it only includes the currency code, but you can override it to include more fields as needed.
+     * @param currency
+     * @returns
+     */
+    protected createCartPayload(payload: CartMutationCreateCart): StoreCreateCart;
+    protected addCartToOwnedList(cartIdentifier: MedusaCartIdentifier, companyId?: CompanyIdentifier): void;
+    protected removeCartFromOwnedList(cartIdentifier: MedusaCartIdentifier, company?: CompanyIdentifier): void;
+    createCart(payload: CartMutationCreateCart): Promise<Result<CartFactoryCartOutput<TFactory>>>;
     remove(payload: CartMutationItemRemove): Promise<Result<CartFactoryCartOutput<TFactory>>>;
     /**
      * Extension point for the `changeQuantity` operation to control the payload sent to Medusa when changing the quantity of an item in the cart. By default, it only includes the new quantity, but you can override it to include more fields as needed.
@@ -58,13 +70,6 @@ export declare class MedusaCartCapability<TFactory extends CartFactory = MedusaC
      */
     protected changeCurrencyPayload(payload: CartMutationChangeCurrency, newRegionId: string): StoreUpdateCart;
     changeCurrency(payload: CartMutationChangeCurrency): Promise<Result<CartFactoryCartOutput<TFactory>>>;
-    /**
-     * Extension point to control the payload sent to Medusa when creating a cart. By default, it only includes the currency code, but you can override it to include more fields as needed.
-     * @param currency
-     * @returns
-     */
-    protected createCartPayload(currency?: string): StoreCreateCart;
-    protected createCart(currency?: string): Promise<CartFactoryIdentifierOutput<TFactory>>;
     protected getClient(): Promise<{
         client: import("@medusajs/js-sdk").Client;
         admin: import("@medusajs/js-sdk").Admin;

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

@@ -1,12 +1,19 @@
 import type { StoreCart, StoreCartLineItem } from '@medusajs/types';
-import { type AnyCartIdentifierSchema, type AnyCartSchema, type CartFactory, type CartIdentifierSchema, type CartItem, type CartSchema, type CostBreakDown, type Currency, type ItemCostBreakdown, type RequestContext } from '@reactionary/core';
+import { type AnyCartIdentifierSchema, type AnyCartPaginatedSearchResult, type AnyCartSchema, type CartFactory, type CartIdentifierSchema, type CartItem, type CartPaginatedSearchResultSchema, type CartQueryList, type CartSchema, type CartSearchResultItem, type CostBreakDown, type Currency, type ItemCostBreakdown, type RequestContext } from '@reactionary/core';
 import type * as z from 'zod';
-export declare class MedusaCartFactory<TCartSchema extends AnyCartSchema = typeof CartSchema, TCartIdentifierSchema extends AnyCartIdentifierSchema = typeof CartIdentifierSchema> implements CartFactory<TCartSchema, TCartIdentifierSchema> {
+export interface ParseMedusaCartPaginatedSearchResultInput {
+    items: StoreCart[];
+    totalCount: number;
+}
+export declare class MedusaCartFactory<TCartSchema extends AnyCartSchema = typeof CartSchema, TCartIdentifierSchema extends AnyCartIdentifierSchema = typeof CartIdentifierSchema, TCartPaginatedSearchResult extends AnyCartPaginatedSearchResult = typeof CartPaginatedSearchResultSchema> implements CartFactory<TCartSchema, TCartIdentifierSchema, TCartPaginatedSearchResult> {
     readonly cartSchema: TCartSchema;
     readonly cartIdentifierSchema: TCartIdentifierSchema;
-    constructor(cartSchema: TCartSchema, cartIdentifierSchema: TCartIdentifierSchema);
+    readonly cartPaginatedSearchResultSchema: TCartPaginatedSearchResult;
+    constructor(cartSchema: TCartSchema, cartIdentifierSchema: TCartIdentifierSchema, cartPaginatedSearchResultSchema: TCartPaginatedSearchResult);
+    parseCartPaginatedSearchResult(_context: RequestContext, data: ParseMedusaCartPaginatedSearchResultInput, _query: CartQueryList): z.output<TCartPaginatedSearchResult>;
+    parseCartSearchResultItem(_context: RequestContext, data: StoreCart): CartSearchResultItem;
     parseCart(context: RequestContext, data: StoreCart): z.output<TCartSchema>;
-    parseCartIdentifier(_context: RequestContext, data: unknown): z.output<TCartIdentifierSchema>;
+    parseCartIdentifier(_context: RequestContext, data: StoreCart): z.output<TCartIdentifierSchema>;
     /**
    * Extension point to control the parsing of a single cart item price
    * @param remoteItem

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

@@ -1,3 +1,4 @@
+import { type InferType } from '@reactionary/core';
 import * as z from 'zod';
 export declare const MedusaCartIdentifierSchema: z.ZodObject<{
     key: z.ZodString;
@@ -13,7 +14,14 @@ export declare const MedusaRegionSchema: z.ZodObject<{
     currency_code: z.ZodString;
 }, z.core.$loose>;
 export declare const MedusaSessionSchema: z.ZodObject<{
-    activeCartId: z.ZodOptional<z.ZodString>;
+    activeCartId: z.ZodOptional<z.ZodObject<{
+        key: z.ZodString;
+        region_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    allOwnedCarts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        region_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>>;
     token: z.ZodOptional<z.ZodString>;
     expires: z.ZodOptional<z.ZodString>;
     allRegions: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -27,7 +35,7 @@ export declare const MedusaSessionSchema: z.ZodObject<{
         currency_code: z.ZodString;
     }, z.core.$loose>>;
 }, z.core.$loose>;
-export type MedusaCartIdentifier = z.infer<typeof MedusaCartIdentifierSchema>;
+export type MedusaCartIdentifier = InferType<typeof MedusaCartIdentifierSchema>;
 export type MedusaOrderIdentifier = z.infer<typeof MedusaOrderIdentifierSchema>;
 export type MedusaSession = z.infer<typeof MedusaSessionSchema>;
 export type MedusaRegion = z.infer<typeof MedusaRegionSchema>;