@reactionary/provider-medusa 0.1.13 → 0.2.2

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

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

package/src/core/client.d.ts

@@ -62,21 +62,7 @@ export declare class MedusaClient {
             userId: string;
         };
         type: "Registered";
-        meta: {
-            cache: {
-                hit: false;
-                key: string;
-            };
-            placeholder: false;
-        };
     } | {
-        meta: {
-            cache: {
-                hit: false;
-                key: string;
-            };
-            placeholder: false;
-        };
         type: "Anonymous";
     }>;
     login(email: string, password: string, reqCtx: RequestContext): Promise<{
@@ -84,32 +70,11 @@ export declare class MedusaClient {
             userId: string;
         };
         type: "Registered";
-        meta: {
-            cache: {
-                hit: false;
-                key: string;
-            };
-            placeholder: false;
-        };
     } | {
-        meta: {
-            cache: {
-                hit: false;
-                key: string;
-            };
-            placeholder: false;
-        };
         type: "Anonymous";
     }>;
     logout(reqCtx: RequestContext): Promise<{
         type: "Anonymous";
-        meta: {
-            cache: {
-                hit: false;
-                key: string;
-            };
-            placeholder: false;
-        };
     }>;
     protected createAuthenticatedClient(reqCtx: RequestContext): Promise<Medusa>;
 }

package/src/index.d.ts

@@ -8,3 +8,4 @@ export * from './providers/identity.provider.js';
 export * from './providers/inventory.provider.js';
 export * from './providers/price.provider.js';
 export * from './providers/product-search.provider.js';
+export * from './providers/profile.provider.js';

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

@@ -1,4 +1,4 @@
-import type { Cache, Cart, CartIdentifier, CartItem, CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartMutationRemoveCoupon, CartQueryById, CostBreakDown, Currency, ItemCostBreakdown, RequestContext } from '@reactionary/core';
+import type { Cache, Cart, CartIdentifier, CartItem, CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartMutationRemoveCoupon, CartQueryById, CostBreakDown, Currency, ItemCostBreakdown, NotFoundError, RequestContext, Result } from '@reactionary/core';
 import { CartProvider } from '@reactionary/core';
 import type { MedusaClient } from '../core/client.js';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
@@ -14,15 +14,15 @@ export declare class MedusaCartProvider extends CartProvider {
      */
     protected includedFields: string;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, client: MedusaClient);
-    getById(payload: CartQueryById): Promise<Cart>;
-    add(payload: CartMutationItemAdd): Promise<Cart>;
-    remove(payload: CartMutationItemRemove): Promise<Cart>;
-    changeQuantity(payload: CartMutationItemQuantityChange): Promise<Cart>;
-    getActiveCartId(): Promise<CartIdentifier>;
-    deleteCart(payload: CartMutationDeleteCart): Promise<Cart>;
-    applyCouponCode(payload: CartMutationApplyCoupon): Promise<Cart>;
-    removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Cart>;
-    changeCurrency(payload: CartMutationChangeCurrency): Promise<Cart>;
+    getById(payload: CartQueryById): Promise<Result<Cart, NotFoundError>>;
+    add(payload: CartMutationItemAdd): Promise<Result<Cart>>;
+    remove(payload: CartMutationItemRemove): Promise<Result<Cart>>;
+    changeQuantity(payload: CartMutationItemQuantityChange): Promise<Result<Cart>>;
+    getActiveCartId(): Promise<Result<CartIdentifier, NotFoundError>>;
+    deleteCart(payload: CartMutationDeleteCart): Promise<Result<void>>;
+    applyCouponCode(payload: CartMutationApplyCoupon): Promise<Result<Cart>>;
+    removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Result<Cart>>;
+    changeCurrency(payload: CartMutationChangeCurrency): Promise<Result<Cart>>;
     protected createCart(currency?: string): Promise<CartIdentifier>;
     protected getClient(): Promise<{
         client: import("@medusajs/js-sdk").Client;

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

@@ -1,28 +1,21 @@
 import type { StoreProductCategory, StoreProductCategoryListResponse } from '@medusajs/types';
 import type { Category, Cache } from '@reactionary/core';
-import { CategoryProvider, type CategoryQueryById, type CategoryQueryBySlug, type CategoryQueryForBreadcrumb, type CategoryQueryForChildCategories, type CategoryQueryForTopCategories, type RequestContext } from '@reactionary/core';
+import { CategoryProvider, type Result, type NotFoundError, type CategoryQueryById, type CategoryQueryBySlug, type CategoryQueryForBreadcrumb, type CategoryQueryForChildCategories, type CategoryQueryForTopCategories, type RequestContext } from '@reactionary/core';
 import type { MedusaClient, MedusaConfiguration } from '../index.js';
 export declare class MedusaCategoryProvider extends CategoryProvider {
     client: MedusaClient;
     protected config: MedusaConfiguration;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, client: MedusaClient);
     protected resolveCategoryIdByExternalId(externalId: string): Promise<StoreProductCategory | null>;
-    getById(payload: CategoryQueryById): Promise<Category>;
-    getBySlug(payload: CategoryQueryBySlug): Promise<Category | null>;
-    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Category[]>;
-    findChildCategories(payload: CategoryQueryForChildCategories): Promise<{
+    getById(payload: CategoryQueryById): Promise<Result<Category, NotFoundError>>;
+    getBySlug(payload: CategoryQueryBySlug): Promise<Result<Category, NotFoundError>>;
+    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<Category[]>>;
+    findChildCategories(payload: CategoryQueryForChildCategories): Promise<import("@reactionary/core").Ok<{
         pageNumber: number;
         pageSize: number;
         totalCount: number;
         totalPages: number;
         items: {
-            meta: {
-                cache: {
-                    hit: boolean;
-                    key: string;
-                };
-                placeholder: boolean;
-            };
             identifier: {
                 key: string;
             };
@@ -39,27 +32,13 @@ export declare class MedusaCategoryProvider extends CategoryProvider {
                 key: string;
             } | undefined;
         }[];
-        meta: {
-            cache: {
-                hit: false;
-                key: string;
-            };
-            placeholder: false;
-        };
-    }>;
-    findTopCategories(payload: CategoryQueryForTopCategories): Promise<{
+    }>>;
+    findTopCategories(payload: CategoryQueryForTopCategories): Promise<import("@reactionary/core").Ok<{
         pageNumber: number;
         pageSize: number;
         totalCount: number;
         totalPages: number;
         items: {
-            meta: {
-                cache: {
-                    hit: boolean;
-                    key: string;
-                };
-                placeholder: boolean;
-            };
             identifier: {
                 key: string;
             };
@@ -76,14 +55,7 @@ export declare class MedusaCategoryProvider extends CategoryProvider {
                 key: string;
             } | undefined;
         }[];
-        meta: {
-            cache: {
-                hit: false;
-                key: string;
-            };
-            placeholder: false;
-        };
-    }>;
+    }>>;
     protected parseSingle(_body: StoreProductCategory): Category;
     protected parsePaginatedResult(body: StoreProductCategoryListResponse): {
         pageNumber: number;
@@ -91,13 +63,6 @@ export declare class MedusaCategoryProvider extends CategoryProvider {
         totalCount: number;
         totalPages: number;
         items: {
-            meta: {
-                cache: {
-                    hit: boolean;
-                    key: string;
-                };
-                placeholder: boolean;
-            };
             identifier: {
                 key: string;
             };
@@ -114,12 +79,5 @@ export declare class MedusaCategoryProvider extends CategoryProvider {
                 key: string;
             } | undefined;
         }[];
-        meta: {
-            cache: {
-                hit: false;
-                key: string;
-            };
-            placeholder: false;
-        };
     };
 }

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

@@ -1,5 +1,5 @@
 import type { StoreCart, StoreCartAddress, StoreCartLineItem } from '@medusajs/types';
-import type { Address, Cache, Checkout, CheckoutIdentifier, CheckoutItem, CheckoutMutationAddPaymentInstruction, CheckoutMutationFinalizeCheckout, CheckoutMutationInitiateCheckout, CheckoutMutationRemovePaymentInstruction, CheckoutMutationSetShippingAddress, CheckoutMutationSetShippingInstruction, CheckoutQueryById, CheckoutQueryForAvailablePaymentMethods, CheckoutQueryForAvailableShippingMethods, CostBreakDown, Currency, ItemCostBreakdown, PaymentMethod, RequestContext, ShippingMethod } from '@reactionary/core';
+import type { Address, Cache, Checkout, CheckoutIdentifier, CheckoutItem, CheckoutMutationAddPaymentInstruction, CheckoutMutationFinalizeCheckout, CheckoutMutationInitiateCheckout, CheckoutMutationRemovePaymentInstruction, CheckoutMutationSetShippingAddress, CheckoutMutationSetShippingInstruction, CheckoutQueryById, CheckoutQueryForAvailablePaymentMethods, CheckoutQueryForAvailableShippingMethods, CostBreakDown, Currency, ItemCostBreakdown, PaymentMethod, RequestContext, ShippingMethod, Result, NotFoundError } from '@reactionary/core';
 import { CheckoutProvider } from '@reactionary/core';
 import type { MedusaClient } from '../core/client.js';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
@@ -18,15 +18,15 @@ export declare class MedusaCheckoutProvider extends CheckoutProvider {
      */
     protected includedFields: string;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, client: MedusaClient);
-    initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout): Promise<Checkout>;
-    getById(payload: CheckoutQueryById): Promise<Checkout | null>;
-    setShippingAddress(payload: CheckoutMutationSetShippingAddress): Promise<Checkout>;
-    getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods): Promise<ShippingMethod[]>;
-    getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods): Promise<PaymentMethod[]>;
-    addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction): Promise<Checkout>;
-    removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction): Promise<Checkout>;
-    setShippingInstruction(payload: CheckoutMutationSetShippingInstruction): Promise<Checkout>;
-    finalizeCheckout(payload: CheckoutMutationFinalizeCheckout): Promise<Checkout>;
+    initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout): Promise<Result<Checkout>>;
+    getById(payload: CheckoutQueryById): Promise<Result<Checkout, NotFoundError>>;
+    setShippingAddress(payload: CheckoutMutationSetShippingAddress): Promise<Result<Checkout>>;
+    getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods): Promise<Result<ShippingMethod[]>>;
+    getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods): Promise<Result<PaymentMethod[]>>;
+    addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction): Promise<Result<Checkout>>;
+    removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction): Promise<Result<Checkout>>;
+    setShippingInstruction(payload: CheckoutMutationSetShippingInstruction): Promise<Result<Checkout>>;
+    finalizeCheckout(payload: CheckoutMutationFinalizeCheckout): Promise<Result<Checkout>>;
     /**
      * Extension point to map an Address to a Store Address
      * @param address

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

@@ -1,4 +1,4 @@
-import { type Identity, type IdentityMutationLogin, type IdentityMutationLogout, type IdentityMutationRegister, type IdentityQuerySelf, type RequestContext, type Cache, IdentityProvider, type AnonymousIdentity } from '@reactionary/core';
+import { type Identity, type IdentityMutationLogin, type IdentityMutationLogout, type IdentityMutationRegister, type IdentityQuerySelf, type RequestContext, type Cache, IdentityProvider, type AnonymousIdentity, type Result } from '@reactionary/core';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 import type { MedusaClient } from '../core/client.js';
 export declare class MedusaIdentityProvider extends IdentityProvider {
@@ -6,8 +6,8 @@ export declare class MedusaIdentityProvider extends IdentityProvider {
     protected client: MedusaClient;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, client: MedusaClient);
     protected createAnonymousIdentity(): AnonymousIdentity;
-    getSelf(_payload: IdentityQuerySelf): Promise<Identity>;
-    login(payload: IdentityMutationLogin): Promise<Identity>;
-    logout(_payload: IdentityMutationLogout): Promise<Identity>;
-    register(payload: IdentityMutationRegister): Promise<Identity>;
+    getSelf(_payload: IdentityQuerySelf): Promise<Result<Identity>>;
+    login(payload: IdentityMutationLogin): Promise<Result<Identity>>;
+    logout(_payload: IdentityMutationLogout): Promise<Result<Identity>>;
+    register(payload: IdentityMutationRegister): Promise<Result<Identity>>;
 }

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

@@ -1,11 +1,11 @@
-import { type Inventory, type InventoryQueryBySKU, type RequestContext, type Cache, InventoryProvider } from '@reactionary/core';
+import { type Inventory, type InventoryQueryBySKU, type RequestContext, type Cache, InventoryProvider, type NotFoundError, type Result } from '@reactionary/core';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 import { type MedusaClient } from '../core/client.js';
 export declare class MedusaInventoryProvider extends InventoryProvider {
     client: MedusaClient;
     protected config: MedusaConfiguration;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, client: MedusaClient);
-    getBySKU(payload: InventoryQueryBySKU): Promise<Inventory>;
+    getBySKU(payload: InventoryQueryBySKU): Promise<Result<Inventory, NotFoundError>>;
     protected parseSingle(_body: unknown): Inventory;
     /**
      * Utility function to create an empty inventory result.

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

@@ -1,13 +1,13 @@
 import type { StoreProductVariant } from '@medusajs/types';
-import { PriceProvider, type Cache, type CustomerPriceQuery, type ListPriceQuery, type Price, type RequestContext } from '@reactionary/core';
+import { PriceProvider, type Cache, type CustomerPriceQuery, type ListPriceQuery, type Price, type RequestContext, type Result } from '@reactionary/core';
 import type { MedusaClient } from '../core/client.js';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 export declare class MedusaPriceProvider extends PriceProvider {
     client: MedusaClient;
     protected config: MedusaConfiguration;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, client: MedusaClient);
-    getListPrice(payload: ListPriceQuery): Promise<Price>;
-    getCustomerPrice(payload: CustomerPriceQuery): Promise<Price>;
+    getListPrice(payload: ListPriceQuery): Promise<Result<Price>>;
+    getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<Price>>;
     protected getBySKU(payload: ListPriceQuery | CustomerPriceQuery): Promise<Price>;
     protected parseSingle(variant: StoreProductVariant): Price;
     protected getResourceName(): string;

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

@@ -1,4 +1,4 @@
-import { ProductSearchProvider, type Cache, type RequestContext, type ProductSearchQueryByTerm, type ProductSearchResult, type ProductSearchResultItem, type ProductSearchResultItemVariant, type FacetIdentifier, type FacetValueIdentifier, type ProductSearchResultFacet, type ProductSearchResultFacetValue, type ProductSearchQueryCreateNavigationFilter } from '@reactionary/core';
+import { ProductSearchProvider, type Cache, type RequestContext, type ProductSearchQueryByTerm, type ProductSearchResult, type ProductSearchResultItem, type ProductSearchResultItemVariant, type FacetIdentifier, type FacetValueIdentifier, type ProductSearchResultFacet, type ProductSearchResultFacetValue, type ProductSearchQueryCreateNavigationFilter, type Result } from '@reactionary/core';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 import type { MedusaClient } from '../core/client.js';
 import type { StoreProduct, StoreProductCategory, StoreProductListResponse, StoreProductVariant } from '@medusajs/types';
@@ -7,7 +7,7 @@ export declare class MedusaSearchProvider extends ProductSearchProvider {
     protected config: MedusaConfiguration;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, client: MedusaClient);
     protected resolveCategoryIdByExternalId(externalId: string): Promise<StoreProductCategory | null>;
-    queryByTerm(payload: ProductSearchQueryByTerm): Promise<ProductSearchResult>;
+    queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchResult>>;
     protected parsePaginatedResult(remote: StoreProductListResponse): {
         identifier: {
             facets: never[];
@@ -18,25 +18,11 @@ export declare class MedusaSearchProvider extends ProductSearchProvider {
             };
             term: string;
         };
-        meta: {
-            cache: {
-                hit: false;
-                key: string;
-            };
-            placeholder: false;
-        };
         pageNumber: number;
         pageSize: number;
         totalCount: number;
         totalPages: number;
         items: {
-            meta: {
-                cache: {
-                    hit: boolean;
-                    key: string;
-                };
-                placeholder: boolean;
-            };
             identifier: {
                 key: string;
             };
@@ -73,7 +59,7 @@ export declare class MedusaSearchProvider extends ProductSearchProvider {
     };
     protected parseSingle(_body: StoreProduct): ProductSearchResultItem;
     protected parseVariant(variant: StoreProductVariant, product: StoreProduct): ProductSearchResultItemVariant;
-    createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<FacetValueIdentifier>;
+    createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>>;
     protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number): ProductSearchResultFacetValue;
     protected parseFacet(facetIdentifier: FacetIdentifier, facetValue: unknown): ProductSearchResultFacet;
 }