@reactionary/source 0.0.52 → 0.2.16

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

@@ -1,13 +1,12 @@
-import { BaseProvider } from "./base.provider.js";
+import type { NotFoundError } from "../schemas/index.js";
 import type { Cart } from "../schemas/models/cart.model.js";
+import type { CartIdentifier } from "../schemas/models/identifiers.model.js";
+import type { CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartMutationRemoveCoupon } from "../schemas/mutations/cart.mutation.js";
 import type { CartQueryById } from "../schemas/queries/cart.query.js";
-import type { RequestContext } from "../schemas/session.schema.js";
-import type { CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationCheckout, CartMutationDeleteCart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartMutationRemoveCoupon, CartMutationSetBillingAddress, CartMutationSetShippingInfo } from "../schemas/mutations/cart.mutation.js";
-import type { CartIdentifier, OrderIdentifier } from "../schemas/models/identifiers.model.js";
+import type { Result } from "../schemas/result.js";
+import { BaseProvider } from "./base.provider.js";
 
-export abstract class CartProvider<
-  T extends Cart = Cart
-> extends BaseProvider<T> {
+export abstract class CartProvider extends BaseProvider {
 
   /**
    * Get cart by ID.
@@ -16,7 +15,7 @@ export abstract class CartProvider<
    * @param payload
    * @param session
    */
-  public abstract getById(payload: CartQueryById, reqCtx: RequestContext): Promise<T>;
+  public abstract getById(payload: CartQueryById): Promise<Result<Cart, NotFoundError>>;
 
 
   /**
@@ -25,7 +24,7 @@ export abstract class CartProvider<
    * Usecase: Most common usecase during site load, or after login. You want to get the active cart for the user, so you can display it in the minicart.
    * @param session
    */
-  public abstract getActiveCartId(reqCtx: RequestContext): Promise<CartIdentifier>;
+  public abstract getActiveCartId(): Promise<Result<CartIdentifier, NotFoundError>>;
 
 
   /**
@@ -37,7 +36,7 @@ export abstract class CartProvider<
    * @param payload
    * @param session
    */
-  public abstract add(payload: CartMutationItemAdd, reqCtx: RequestContext): Promise<T>;
+  public abstract add(payload: CartMutationItemAdd): Promise<Result<Cart>>;
 
   /**
    * Remove item from cart. If the cart is empty after removal, delete the cart. Returns the updated and recalculated cart.
@@ -46,7 +45,7 @@ export abstract class CartProvider<
    * @param payload
    * @param session
    */
-  public abstract remove(payload: CartMutationItemRemove, reqCtx: RequestContext): Promise<T>;
+  public abstract remove(payload: CartMutationItemRemove): Promise<Result<Cart>>;
 
   /**
    * Change quantity of item in cart. If the cart is empty after change, delete the cart. Returns the updated and recalculated cart.
@@ -57,7 +56,7 @@ export abstract class CartProvider<
    * @param payload
    * @param session
    */
-  public abstract changeQuantity(payload: CartMutationItemQuantityChange, reqCtx: RequestContext): Promise<T>;
+  public abstract changeQuantity(payload: CartMutationItemQuantityChange): Promise<Result<Cart>>;
 
 
   /**
@@ -67,26 +66,7 @@ export abstract class CartProvider<
    * @param payload
    * @param session
    */
-  public abstract deleteCart(payload: CartMutationDeleteCart, reqCtx: RequestContext): Promise<T>;
-
-  /**
-   * Sets shipping method and address on the cart. Returns the updated and recalculated cart.
-   *
-   * Usecase: User selects shipping method during checkout.
-   * @param payload
-   * @param session
-   */
-  public abstract setShippingInfo(payload: CartMutationSetShippingInfo, reqCtx: RequestContext): Promise<T>;
-
-  /**
-   * Sets billing address on the cart. Returns the updated and recalculated cart.
-   *
-   * Usecase: User enters billing address during checkout.
-   *
-   * @param payload
-   * @param session
-   */
-  public abstract setBillingAddress(payload: CartMutationSetBillingAddress, reqCtx: RequestContext): Promise<T>;
+  public abstract deleteCart(payload: CartMutationDeleteCart): Promise<Result<void>>;
 
   /**
    * Applies a coupon code to the cart. Returns the updated and recalculated cart.
@@ -95,7 +75,7 @@ export abstract class CartProvider<
    * @param payload
    * @param session
    */
-  public abstract applyCouponCode(payload: CartMutationApplyCoupon, reqCtx: RequestContext): Promise<T>;
+  public abstract applyCouponCode(payload: CartMutationApplyCoupon): Promise<Result<Cart>>;
 
 
   /**
@@ -105,18 +85,7 @@ export abstract class CartProvider<
    * @param payload
    * @param session
    */
-  public abstract removeCouponCode(payload: CartMutationRemoveCoupon, reqCtx: RequestContext): Promise<T>;
-
-
-  /**
-   * Checks out the cart. Returns the order identifier of the newly created order.
-   *
-   * Usecase: User proceeds to checkout.
-   *
-   * @param payload
-   * @param session
-   */
-  public abstract checkout(payload: CartMutationCheckout, reqCtx: RequestContext): Promise<OrderIdentifier>;
+  public abstract removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Result<Cart>>;
 
   /**
    * Changes the currency of the cart.
@@ -125,16 +94,7 @@ export abstract class CartProvider<
    * @param newCurrency
    * @param session
    */
-  public abstract changeCurrency(payload: CartMutationChangeCurrency, reqCtx: RequestContext): Promise<T>;
-
-
-
-  protected createEmptyCart(): T {
-    const cart = this.newModel();
-    cart.meta = { placeholder: true, cache: { hit: true, key: 'empty-cart' } };
-    cart.identifier = { key: '' };
-    return cart;
-  }
+  public abstract changeCurrency(payload: CartMutationChangeCurrency): Promise<Result<Cart>>;
 
   protected override getResourceName(): string {
     return 'cart';

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

@@ -1,6 +1,5 @@
-import type { Category } from "../schemas/models/category.model.js";
+import type { Category, CategoryPaginatedResult, NotFoundError, Result } from "../schemas/index.js";
 import type { CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories } from "../schemas/queries/category.query.js";
-import type { RequestContext} from "../schemas/session.schema.js";
 import { BaseProvider } from "./base.provider.js";
 
 
@@ -13,9 +12,7 @@ import { BaseProvider } from "./base.provider.js";
  * We only allow fetching one hierachy level at a time, for now. This is to avoid development patterns of "fetch 5000 categories in one go.."
  *
  */
-export abstract class CategoryProvider<
-  T extends Category = Category
-> extends BaseProvider<T> {
+export abstract class CategoryProvider extends BaseProvider {
   /**
    * Get a single category by its ID. Cannot return null, because HOW did you come across a categories ID that does not exist?
    *
@@ -31,7 +28,7 @@ export abstract class CategoryProvider<
    * @param id
    * @param session
    */
-  public abstract getById(payload: CategoryQueryById, reqCtx: RequestContext): Promise<T>;
+  public abstract getById(payload: CategoryQueryById): Promise<Result<Category, NotFoundError>>;
 
   /**
    * Gets a single category by its seo slug
@@ -40,8 +37,7 @@ export abstract class CategoryProvider<
    * @param slug the slug
    * @param session
    */
-  public abstract getBySlug(payload: CategoryQueryBySlug, reqCtx: RequestContext): Promise<T | null>;
-
+  public abstract getBySlug(payload: CategoryQueryBySlug): Promise<Result<Category, NotFoundError>>;
 
   /**
    * Gets the breadcrumb path to the category, i.e. all parents up to the root.
@@ -51,7 +47,7 @@ export abstract class CategoryProvider<
    * @param id
    * @param session
    */
-  public abstract getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, reqCtx: RequestContext): Promise<T[]>;
+  public abstract getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<Category[]>>;
 
   // hmm, this is not really good enough.... We need a type we can pass in that will allow us to specify the precise return type, but otoh we also need
   // to be able to verify and assert the output type. FIXME
@@ -66,7 +62,7 @@ export abstract class CategoryProvider<
    * @param id The ID of the parent category.
    * @param session The session information.
    */
-  public abstract findChildCategories(payload: CategoryQueryForChildCategories, reqCtx: RequestContext): Promise< ReturnType<typeof this.parsePaginatedResult>>;
+  public abstract findChildCategories(payload: CategoryQueryForChildCategories): Promise<Result<CategoryPaginatedResult>>;
 
   /**
    * Returns all top categories, i.e. categories without a parent.
@@ -75,7 +71,7 @@ export abstract class CategoryProvider<
    * @param paginationOptions
    * @param session
    */
-  public abstract findTopCategories( payload: CategoryQueryForTopCategories, reqCtx: RequestContext): Promise<ReturnType<typeof this.parsePaginatedResult>>;
+  public abstract findTopCategories( payload: CategoryQueryForTopCategories): Promise<Result<CategoryPaginatedResult>>;
 
 
   protected override getResourceName(): string {

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

@@ -1,12 +1,11 @@
 import type { Checkout, PaymentMethod, ShippingMethod } from "../schemas/models/index.js";
-import type { RequestContext } from "../schemas/session.schema.js";
 import { BaseProvider } from "./base.provider.js";
 import type { CheckoutMutationFinalizeCheckout, CheckoutMutationInitiateCheckout, CheckoutMutationSetShippingAddress,  CheckoutMutationAddPaymentInstruction, CheckoutMutationRemovePaymentInstruction, CheckoutMutationSetShippingInstruction } from "../schemas/mutations/checkout.mutation.js";
 import type { CheckoutQueryById, CheckoutQueryForAvailablePaymentMethods, CheckoutQueryForAvailableShippingMethods } from "../schemas/queries/index.js";
+import type { Result } from "../schemas/result.js";
+import type { NotFoundError } from "../schemas/index.js";
 
-export abstract class CheckoutProvider<
-  T extends Checkout = Checkout
-> extends BaseProvider<T> {
+export abstract class CheckoutProvider extends BaseProvider {
 
   /**
    * This starts a new checkout session for the given cart. The checkout might duplicate the cart, or just reference it, depending on implementation, but changes to the cart,
@@ -18,7 +17,7 @@ export abstract class CheckoutProvider<
    * @param billingAddress the billing/shipping address to start with. This affects available shipping methods, and may be required by some payment providers.
    * @param reqCtx
    */
-  public abstract initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout, reqCtx: RequestContext): Promise<T>;
+  public abstract initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout): Promise<Result<Checkout>>;
 
 
   /**
@@ -28,9 +27,7 @@ export abstract class CheckoutProvider<
    * @param payload
    * @param reqCtx
    */
-  public abstract getById(payload:  CheckoutQueryById, reqCtx: RequestContext): Promise<T | null>;
-
-
+  public abstract getById(payload:  CheckoutQueryById): Promise<Result<Checkout, NotFoundError>>;
 
   /**
    * Updates the shipping address for the checkout and recalculates the shipping methods and totals.
@@ -40,7 +37,7 @@ export abstract class CheckoutProvider<
    * NOTE: Unsure this is really needed.
    * @param shippingAddress The updated shipping address. Note: This may also be the billing address, if your store does not differentiate.
    */
-  public abstract setShippingAddress(payload: CheckoutMutationSetShippingAddress, reqCtx: RequestContext): Promise<T>;
+  public abstract setShippingAddress(payload: CheckoutMutationSetShippingAddress): Promise<Result<Checkout>>;
 
   /**
    * Returns all available shipping methods for the given checkout. This will typically depend on the shipping address, and possibly also the items in the checkout.
@@ -50,7 +47,7 @@ export abstract class CheckoutProvider<
    * @param checkoutId The checkout you want to get shipping methods for.
    * @param reqCtx
    */
-  public abstract getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods, reqCtx: RequestContext): Promise<ShippingMethod[]>;
+  public abstract getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods): Promise<Result<ShippingMethod[]>>;
 
   /**
    * Returns all available payment methods for the given checkout. This will typically depend mostly on the billing address and jurisdiction.
@@ -60,7 +57,7 @@ export abstract class CheckoutProvider<
    * @param checkoutId The checkout you want to get payment methods for.
    * @param reqCtx
    */
-  public abstract getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods, reqCtx: RequestContext): Promise<PaymentMethod[]>;
+  public abstract getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods): Promise<Result<PaymentMethod[]>>;
 
 
   /**
@@ -68,7 +65,7 @@ export abstract class CheckoutProvider<
    *
    * Usecase: User has chosen a payment method, and you need to start the payment process.
    */
-  public abstract addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction, reqCtx: RequestContext): Promise<T>;
+  public abstract addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction): Promise<Result<Checkout>>;
 
   /**
    * Removes a payment instruction from the checkout. This will typically void the payment intent in the payment provider, and remove the payment instruction from the checkout.
@@ -76,7 +73,7 @@ export abstract class CheckoutProvider<
    * Usecase: User has decided to change payment method, or has cancelled the payment process.
    * @param paymentInstructionId
    */
-  public abstract removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction, reqCtx: RequestContext): Promise<T>;
+  public abstract removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction): Promise<Result<Checkout>>;
 
 
 
@@ -90,7 +87,7 @@ export abstract class CheckoutProvider<
    * @param shippingMethodId
    * @param pickupPoint
    */
-  public abstract setShippingInstruction(payload: CheckoutMutationSetShippingInstruction, reqCtx: RequestContext): Promise<T>;
+  public abstract setShippingInstruction(payload: CheckoutMutationSetShippingInstruction): Promise<Result<Checkout>>;
 
   /**
    * Finalizes the checkout process. This typically involves creating an order from the checkout and processing payment.
@@ -100,7 +97,12 @@ export abstract class CheckoutProvider<
    * @param payload
    * @param reqCtx
    */
-  public abstract finalizeCheckout(payload: CheckoutMutationFinalizeCheckout, reqCtx: RequestContext): Promise<T>;
+  public abstract finalizeCheckout(payload: CheckoutMutationFinalizeCheckout): Promise<Result<Checkout>>;
+
+
+  public override getResourceName(): string {
+    return 'checkout';
+  }
 }
 
 

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

@@ -1,16 +1,14 @@
 import type { Identity } from "../schemas/models/identity.model.js";
 import type { IdentityMutationLogin, IdentityMutationLogout, IdentityMutationRegister } from "../schemas/mutations/identity.mutation.js";
 import type { IdentityQuerySelf } from "../schemas/queries/identity.query.js";
-import type { RequestContext} from "../schemas/session.schema.js";
+import type { Result } from "../schemas/result.js";
 import { BaseProvider } from "./base.provider.js";
 
-export abstract class IdentityProvider<
-  T extends Identity = Identity,
-> extends BaseProvider<T> {
-  public abstract getSelf(payload: IdentityQuerySelf, reqCtx: RequestContext): Promise<T>;
-  public abstract login(payload: IdentityMutationLogin, reqCtx: RequestContext): Promise<T>;
-  public abstract logout(payload: IdentityMutationLogout, reqCtx: RequestContext): Promise<T>;
-  public abstract register(payload: IdentityMutationRegister, reqCtx: RequestContext): Promise<T>;
+export abstract class IdentityProvider extends BaseProvider {
+  public abstract getSelf(payload: IdentityQuerySelf): Promise<Result<Identity>>;
+  public abstract login(payload: IdentityMutationLogin): Promise<Result<Identity>>;
+  public abstract logout(payload: IdentityMutationLogout): Promise<Result<Identity>>;
+  public abstract register(payload: IdentityMutationRegister): Promise<Result<Identity>>;
 
   protected override getResourceName(): string {
     return 'identity';

package/core/src/providers/index.ts

@@ -8,6 +8,7 @@ export * from './inventory.provider.js';
 export * from './price.provider.js';
 export * from './product.provider.js';
 export * from './profile.provider.js';
-export * from './search.provider.js';
+export * from './product-search.provider.js';
 export * from './store.provider.js';
 export * from './order.provider.js'
+export * from './order-search.provider.js'

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

@@ -1,14 +1,24 @@
+import type { NotFoundError } from '../schemas/index.js';
+import type { InventoryIdentifier } from '../schemas/models/identifiers.model.js';
 import type { Inventory } from '../schemas/models/inventory.model.js';
 import type { InventoryQueryBySKU } from '../schemas/queries/inventory.query.js';
-import type { RequestContext } from '../schemas/session.schema.js';
+import type { Result } from '../schemas/result.js';
 import { BaseProvider } from './base.provider.js';
 
-export abstract class InventoryProvider<
-  T extends Inventory = Inventory
-> extends BaseProvider<T> {
-  public abstract getBySKU(payload: InventoryQueryBySKU, reqCtx: RequestContext): Promise<T>;
+export abstract class InventoryProvider extends BaseProvider {
+  public abstract getBySKU(payload: InventoryQueryBySKU): Promise<Result<Inventory, NotFoundError>>;
 
   protected override getResourceName(): string {
     return 'inventory';
   }
+
+  protected createEmptyInventory(key: InventoryIdentifier): Inventory {
+    const inventory = {
+        identifier: key,
+        quantity: 0,
+        status: 'outOfStock'
+    } satisfies Inventory;
+
+    return inventory;
+  }
 }

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

@@ -0,0 +1,29 @@
+import type { OrderSearchResult } from "../schemas/models/order-search.model.js";
+import type { OrderSearchQueryByTerm } from "../schemas/queries/order-search.query.js";
+import type { Result } from "../schemas/result.js";
+import { BaseProvider } from "./base.provider.js";
+
+/**
+ * This provider handles order search operations. In some situations you may have different providers for order history listing and detail retrieval.
+ * The order search is primarily focused on searching and listing orders based on various criteria, and returns only summary information about each order.
+ *
+ * Usecase: An e-commerce platform wants to provide customers with a way to search through their past orders using filters like date range, order status, or total amount spent.
+ */
+export abstract class OrderSearchProvider extends BaseProvider {
+  protected override getResourceName(): string {
+    return 'order-search';
+  }
+
+  /**
+   * Queries orders based on the provided search criteria.
+   *
+   * Usecase: A customer is in the My Account section, and wants to search for orders placed within the last month that are marked as "shipped".
+   * Usecase: A widget on the frontpage after login, shows the last 5 orders placed by the customer.
+   * @param payload The search criteria for querying orders.
+   */
+  public abstract queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>>;
+
+
+
+
+}

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

@@ -1,12 +1,10 @@
-import { BaseProvider } from "./base.provider.js";
-import type { RequestContext } from "../schemas/session.schema.js";
-import type { Order } from "../schemas/models/index.js";
-import type { OrderQueryById } from "../schemas/queries/index.js";
-
-export abstract class OrderProvider<
-  T extends Order = Order
-> extends BaseProvider<T> {
+import { BaseProvider } from './base.provider.js';
+import type { Order } from '../schemas/models/index.js';
+import type { OrderQueryById } from '../schemas/queries/index.js';
+import type { Result } from '../schemas/result.js';
+import type { NotFoundError } from '../schemas/index.js';
 
+export abstract class OrderProvider extends BaseProvider {
   /**
    * Get order by ID.
    *
@@ -14,12 +12,48 @@ export abstract class OrderProvider<
    * @param payload
    * @param session
    */
-  public abstract getById(payload: OrderQueryById, reqCtx: RequestContext): Promise<T>;
+  public abstract getById(payload: OrderQueryById): Promise<Result<Order, NotFoundError>>;
+
+  protected createEmptyOrder(): Order {
+    const order = {
+      identifier: {
+        key: '',
+      },
+      inventoryStatus: 'NotAllocated',
+      items: [],
+      orderStatus: 'AwaitingPayment',
+      paymentInstructions: [],
+      price: {
+        grandTotal: {
+          value: 0,
+          currency: 'XXX',
+        },
+        totalDiscount: {
+          value: 0,
+          currency: 'XXX',
+        },
+        totalProductPrice: {
+          value: 0,
+          currency: 'XXX',
+        },
+        totalShipping: {
+          value: 0,
+          currency: 'XXX',
+        },
+        totalSurcharge: {
+          value: 0,
+          currency: 'XXX',
+        },
+        totalTax: {
+          value: 0,
+          currency: 'XXX',
+        },
+      },
+      userId: {
+        userId: '',
+      },
+    } satisfies Order;
 
-  protected createEmptyOrder(): T {
-    const order = this.newModel();
-    order.meta = { placeholder: true, cache: { hit: true, key: 'empty-order' } };
-    order.identifier = { key: '' };
     return order;
   }
 
@@ -27,5 +61,3 @@ export abstract class OrderProvider<
     return 'order';
   }
 }
-
-

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

@@ -1,36 +1,31 @@
-import type { Currency } from '../schemas/models/currency.model.js';
-import type { Price } from '../schemas/models/price.model.js';
-import type { PriceQueryBySku } from '../schemas/queries/price.query.js';
-import type { RequestContext } from '../schemas/session.schema.js';
+import type { Price, Result } from '../schemas/index.js';
+import type {
+  CustomerPriceQuery,
+  ListPriceQuery,
+} from '../schemas/queries/price.query.js';
 import { BaseProvider } from './base.provider.js';
 
-export abstract class PriceProvider<
-  T extends Price = Price
-> extends BaseProvider<T> {
-
-
+export abstract class PriceProvider extends BaseProvider {
   /**
-   * Get a price by SKU.
-   *
-   * Note: This does not include any discounts or promotions that may apply.
-   * For B2B scenarios, this will be the base price, and any customer specific pricing
+   * Get a list price price by SKU. This is the most general, undiscounted price and is typically
+   * used as the "before" price in most ecommerce setups.
    *
    * Usecase: You are rendering a product page, and you need to show the price for a SKU.
    * @param payload The SKU to query
    * @param session The session information
    */
-  public abstract getBySKU(payload: PriceQueryBySku, reqCtx: RequestContext): Promise<T>;
-
+  public abstract getListPrice(payload: ListPriceQuery): Promise<Result<Price>>;
 
   /**
-   * Fetch prices for multiple SKUs in one go.
+   * Get a customer-specific price by SKU.
+   *
+   * No
    *
-   * Usecase: You are rendering a product grid, and you need to show prices for multiple SKUs.
-   * @param payload The SKUs to query
+   * Usecase: You are rendering a product page, and you need to show the price for a SKU.
+   * @param payload The SKU to query
    * @param session The session information
    */
-  public abstract getBySKUs(payload: PriceQueryBySku[], reqCtx: RequestContext): Promise<T[]>;
-
+  public abstract getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<Price>>;
 
   /**
    * Utility function to create an empty price result, with a value of -1.
@@ -40,24 +35,23 @@ export abstract class PriceProvider<
    * @param currency
    * @returns
    */
-  protected createEmptyPriceResult(sku: string, currency: Currency): T {
-    const base = this.newModel();
-    base.identifier = {
-      sku: { key: sku }
-    };
-    base.unitPrice = {
-      value: -1,
-      currency: currency,
-    };
-    base.meta = {
-      cache: { hit: false, key: `price-${sku}-${currency}` },
-      placeholder: true
-    };
-    return this.assert(base);
+  protected createEmptyPriceResult(sku: string): Price {
+    const price = {
+      identifier: {
+        variant: {
+          sku,
+        },
+      },
+      tieredPrices: [],
+      unitPrice: {
+        value: -1,
+        currency: this.context.languageContext.currencyCode,
+      }
+    } satisfies Price;
+
+    return price;
   }
 
-
-
   protected override getResourceName(): string {
     return 'price';
   }

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

@@ -0,0 +1,61 @@
+import type { Category, FacetIdentifier, FacetValueIdentifier, Result } from '../index.js';
+import type { ProductSearchResult, ProductSearchResultFacet, ProductSearchResultFacetValue, ProductSearchResultItemVariant } from '../schemas/models/product-search.model.js';
+import type { ProductSearchQueryByTerm, ProductSearchQueryCreateNavigationFilter } from '../schemas/queries/product-search.query.js';
+import { BaseProvider } from './base.provider.js';
+
+export abstract class ProductSearchProvider extends BaseProvider {
+  protected override getResourceName(): string {
+    return 'product-search';
+  }
+
+public abstract queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchResult>>;
+
+
+  /**
+   * Since each platform has it own way of representing categories and their hierarchy, we leave it to the platform to tell us how to get from a
+   * category breadcrumb path to a global category navigation filter that can be applied to product searches.
+   *
+   * So, the CLP pattern would be
+   *
+   * const c: Category = await categoryProvider.getBySlug({ slug: 'some-category' });
+   * const breadcrumbPath: Category[] = await categoryProvider.getBreadcrumbPathToCategory({ id: c.identifier });
+   * const categoryFilter: FacetValueIdentifier = categoryNavigationProvider.createCategoryNavigationFilterBreadcrumbs(breadcrumbPath);
+   * const searchResult: ProductSearchResult = await productSearchProvider.queryByTerm({ term: 'some search', facets: [], categoryFilter: [categoryFilter], ... });
+   *
+   * from here, you would maybe get facets back with subcategories, but those are relative to the current category filter you have applied, so you
+   * do not need any special handling for that.
+   *
+   * Usecase: You are rendering a category page and you want to run a product search to find everything in that category (or below).
+   *
+   * @param categoryPath
+   */
+  public abstract createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>>;
+
+  /**
+   * Parses a facet value from the search response.
+   * @param facetValueIdentifier The identifier for the facet value.
+   * @param label The label for the facet value.
+   * @param count The count for the facet value.
+   */
+  protected abstract parseFacetValue(facetValueIdentifier: FacetValueIdentifier,  label: string, count: number) : ProductSearchResultFacetValue;
+
+  /**
+   * Parses a facet from the search response.
+   * @param facetIdentifier The identifier for the facet.
+   * @param facetValue The value for the facet.
+   *
+   * Usecase: Override this to customize the parsing of facets.
+   */
+  protected abstract parseFacet(facetIdentifier: FacetIdentifier,  facetValue: unknown) : ProductSearchResultFacet;
+
+  /**
+   * Parses a product variant from the search response.
+   * @param variant The variant data from the search response.
+   * @param product The product data from the search response.
+   *
+   * Usecase: Override this to customize the parsing of product variants.
+   */
+  protected abstract parseVariant(variant: unknown, product: unknown): ProductSearchResultItemVariant;
+}
+
+