@reactionary/source 0.0.41 → 0.0.48

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

@@ -1,22 +1,22 @@
-import { z } from 'zod';
-import { BaseModel, createPaginatedResponseSchema } from '../schemas/models/base.model';
-import { Cache } from '../cache/cache.interface';
-import { Session } from '../schemas/session.schema';
-import { IdentifierType } from '../schemas/models/identifiers.model';
+import type { z } from 'zod';
+import type {
+  BaseModel} from '../schemas/models/base.model';
+import {
+  createPaginatedResponseSchema,
+} from '../schemas/models/base.model';
+import type { Cache } from '../cache/cache.interface';
+import type { RequestContext, Session } from '../schemas/session.schema';
+import type { IdentifierType } from '../schemas/models/identifiers.model';
+import { hasher } from "node-object-hash";
 
 /**
  * Base capability provider, responsible for mutations (changes) and queries (fetches)
  * for a given business object domain.
  */
-export abstract class BaseProvider<
-  T extends BaseModel = BaseModel
-> {
+export abstract class BaseProvider<T extends BaseModel = BaseModel> {
   protected cache: Cache;
 
-  constructor(
-    public readonly schema: z.ZodType<T>,
-    cache: Cache
-  ) {
+  constructor(public readonly schema: z.ZodType<T>, cache: Cache) {
     this.cache = cache;
   }
 
@@ -39,37 +39,73 @@ export abstract class BaseProvider<
    * Handler for parsing a response from a remote provider and converting it
    * into the typed domain model.
    */
-  protected parseSingle(_body: unknown, session: Session): T {
+  protected parseSingle(_body: unknown, reqCtx: RequestContext): T {
     const model = this.newModel();
 
     return this.assert(model);
   }
 
 
-  protected parsePaginatedResult(_body: unknown, session: Session): z.infer<ReturnType<typeof createPaginatedResponseSchema<typeof this.schema>>> {
+  protected parsePaginatedResult(_body: unknown, reqCtx: RequestContext): z.infer<ReturnType<typeof createPaginatedResponseSchema<typeof this.schema>>> {
     return createPaginatedResponseSchema(this.schema).parse({});
   }
+  
+  public generateDependencyIdsForModel(model: unknown): Array<string> {
+    // TODO: Messy because we can't guarantee that a model has an identifier (type-wise)
+   const identifier = (model as any)?.identifier;
 
-  protected generateCacheKeyPaginatedResult(resultSetName: string, res:  ReturnType<typeof this.parsePaginatedResult>, session: Session): string {
+   if (!identifier) {
+    return [];
+   }
+
+   const h = hasher({ sort: true, coerce: false });
+   const hash = h.hash(identifier);
+
+   return [hash];
+  }
+
+  protected generateCacheKeyForQuery(scope: string, query: object): string {
+    const h = hasher({ sort: true, coerce: false });
+
+    const queryHash = h.hash(query);
+
+    // TODO: This really should include the internationalization parts as well (locale, currency, etc), or at least provide the option
+    // for specifying in the decorator whether they do (eg categories don't really seem to depend on currency...)
+
+    return `${scope}:${queryHash}`;
+  }
+
+  protected generateCacheKeyPaginatedResult(
+    resultSetName: string,
+    res: ReturnType<typeof this.parsePaginatedResult>,
+    reqCtx: RequestContext
+  ): string {
     const type = this.getResourceName();
-    const langPart = session.languageContext.locale;
-    const currencyPart = session.languageContext.currencyCode || 'default';
-    const storePart = session.storeIdentifier?.key || 'default';
+    const langPart = reqCtx.languageContext.locale;
+    const currencyPart = reqCtx.languageContext.currencyCode || 'default';
+    const storePart = reqCtx.storeIdentifier?.key || 'default';
     return `${type}-${resultSetName}-paginated|pageNumber:${res.pageNumber}|pageSize:${res.pageSize}|store:${storePart}|lang:${langPart}|currency:${currencyPart}`;
   }
 
-
-  protected generateCacheKeySingle(identifier: IdentifierType, session: Session): string {
+  protected generateCacheKeySingle(
+    identifier: IdentifierType,
+    reqCtx: RequestContext
+  ): string {
     const type = this.getResourceName();
-    const idPart = Object.entries(identifier).map(([k, v]) => `${k}:${(v as any).key}`).join('#');
-    const langPart = session.languageContext.locale;
-    const currencyPart = session.languageContext.currencyCode || 'default';
-    const storePart = session.storeIdentifier?.key || 'default';
+
+    const idPart = Object.entries(identifier)
+      .map(([k, v]) => `${k}:${v}`)
+      .join('#');
+
+    const langPart = reqCtx.languageContext.locale;
+    const currencyPart = reqCtx.languageContext.currencyCode || 'default';
+    const storePart = reqCtx.storeIdentifier?.key || 'default';
+
     return `${type}-${idPart}|store:${storePart}|lang:${langPart}|currency:${currencyPart}`;
   }
 
   /**
    * Returns the abstract resource name provided by the remote system.
    */
-  protected abstract getResourceName(): string ;
+  protected abstract getResourceName(): string;
 }

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

@@ -0,0 +1,57 @@
+import type { CartPaymentInstruction } from '../schemas/models/payment.model';
+import type { CartPaymentMutationAddPayment, CartPaymentMutationCancelPayment } from '../schemas/mutations/cart-payment.mutation';
+import type { CartPaymentQueryByCart } from '../schemas/queries/cart-payment.query';
+import type { RequestContext} from '../schemas/session.schema';
+import { Session } from '../schemas/session.schema';
+import { BaseProvider } from './base.provider';
+
+export abstract class CartPaymentProvider<
+  T extends CartPaymentInstruction = CartPaymentInstruction
+> extends BaseProvider<T> {
+
+
+
+  /**
+   * Returns all payment instructions associated with a given cart, optionally filtered by status
+   *
+   * Usecase: Fetch all registered payment instructions to show on checkout page, in case you support multiple payments in your storefront,
+   * and need to show how far the user has come in the payment process. Also useful if user reloads page, or goes back to site or otherwise breaks the flow.
+   *
+   * Only returns payment instructions in status 'pending' or 'authorized'
+   * @param cartIdentifier
+   * @param session
+   */
+  public abstract getByCartIdentifier(payload: CartPaymentQueryByCart, reqCtx: RequestContext): Promise<T[]>;
+
+
+  /**
+   * Calls payment provider to set up a new payment intent. Returns whatever is needed to continue the payment process, e.g. a client secret for Stripe, or a redirect URL for PayPal.
+   *
+   * Usecase: User has filled out checkout form, and is ready to pay. You call this to get the payment process started.
+   *
+   * Note: The payment provider MAY change the cart during the payment process, so be sure to reload the cart object after this call.
+   *
+   * @param payload
+   * @param session
+   */
+  public abstract initiatePaymentForCart(payload: CartPaymentMutationAddPayment, reqCtx: RequestContext): Promise<T>;
+
+
+
+  /**
+   * Cancel a payment instruction. This will typically void the payment intent in the payment provider, and set the status of the payment instruction to 'canceled'.
+   *
+   * Usecase: User has decided to cancel the payment, e.g. by going back in the checkout process, or by closing the browser window. You call this to clean up the payment instruction.
+   *
+   * Note: The payment provider MAY change the cart during the cancellation process, so be sure to reload the cart object after this call.
+   *
+   * @param payload
+   * @param session
+   * @returns
+   */
+  public abstract cancelPaymentInstruction(payload: CartPaymentMutationCancelPayment, reqCtx: RequestContext): Promise<T>;
+
+  protected override getResourceName(): string {
+    return 'cart-payment-instruction';
+  }
+}

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

@@ -1,17 +1,140 @@
 import { BaseProvider } from "./base.provider";
-import { Cart } from "../schemas/models/cart.model";
-import { CartQueryById } from "../schemas/queries/cart.query";
-import { Session } from "../schemas/session.schema";
-import { CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove } from "../schemas/mutations/cart.mutation";
+import type { Cart } from "../schemas/models/cart.model";
+import type { CartQueryById } from "../schemas/queries/cart.query";
+import type { RequestContext } from "../schemas/session.schema";
+import type { CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationCheckout, CartMutationDeleteCart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartMutationRemoveCoupon, CartMutationSetBillingAddress, CartMutationSetShippingInfo } from "../schemas/mutations/cart.mutation";
+import type { CartIdentifier, OrderIdentifier } from "../schemas/models/identifiers.model";
 
 export abstract class CartProvider<
   T extends Cart = Cart
 > extends BaseProvider<T> {
-  public abstract getById(payload: CartQueryById, session: Session): Promise<T>;
-  public abstract add(payload: CartMutationItemAdd, session: Session): Promise<T>;
-  public abstract remove(payload: CartMutationItemRemove, session: Session): Promise<T>;
-  public abstract changeQuantity(payload: CartMutationItemQuantityChange, session: Session): Promise<T>;
 
+  /**
+   * Get cart by ID.
+   *
+   * Usecase: Unclear, until we support multiple carts per user.
+   * @param payload
+   * @param session
+   */
+  public abstract getById(payload: CartQueryById, reqCtx: RequestContext): Promise<T>;
+
+
+  /**
+   * Get the active cart id for the user.
+   *
+   * 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>;
+
+
+  /**
+   * Add item to cart. If no cart exists, create a new one. Returns the updated and recalculated cart.
+   * Does not automatically consolidate items, so if you want to have second add of same item to increase quantity,
+   * you need to handle that in your logic or on the server.
+   *
+   * Usecase: Add item to cart, create cart if none exists.
+   * @param payload
+   * @param session
+   */
+  public abstract add(payload: CartMutationItemAdd, reqCtx: RequestContext): Promise<T>;
+
+  /**
+   * Remove item from cart. If the cart is empty after removal, delete the cart. Returns the updated and recalculated cart.
+   *
+   * Usecase: Remove item from cart, delete cart if empty.
+   * @param payload
+   * @param session
+   */
+  public abstract remove(payload: CartMutationItemRemove, reqCtx: RequestContext): Promise<T>;
+
+  /**
+   * Change quantity of item in cart. If the cart is empty after change, delete the cart. Returns the updated and recalculated cart.
+   * Changing quantity to 0 is not allowed. Use the remove call instead. This is done to avoid accidental removal of item.
+   * Calls with quantity 0 will just be ignored.
+   *
+   * Usecase: Change quantity of item in cart,  like in a minicart, or in the full cart view.
+   * @param payload
+   * @param session
+   */
+  public abstract changeQuantity(payload: CartMutationItemQuantityChange, reqCtx: RequestContext): Promise<T>;
+
+
+  /**
+   * Deletes the entire cart.
+   *
+   * Usecase: User wants to empty the cart or something is wrong with the current cart, and you want to clear it out and start fresh.
+   * @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>;
+
+  /**
+   * Applies a coupon code to the cart. Returns the updated and recalculated cart.
+   *
+   * Usecase: User applies a coupon code during checkout.
+   * @param payload
+   * @param session
+   */
+  public abstract applyCouponCode(payload: CartMutationApplyCoupon, reqCtx: RequestContext): Promise<T>;
+
+
+  /**
+   * Removes a coupon code from the cart. Returns the updated and recalculated cart.
+   *
+   * Usecase: User removes a coupon code during checkout.
+   * @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>;
+
+  /**
+   * Changes the currency of the cart.
+   *
+   * Usecase: User wants to change the currency for his session. This will change the currency of the cart, and recalculate prices.
+   * @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;
+  }
 
   protected override getResourceName(): string {
     return 'cart';

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

@@ -1,10 +1,10 @@
 
 
 import { PaginationOptions } from "../schemas/models/base.model";
-import { Category } from "../schemas/models/category.model";
+import type { Category } from "../schemas/models/category.model";
 import { CategoryIdentifier } from "../schemas/models/identifiers.model";
-import { CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories } from "../schemas/queries/category.query";
-
+import type { CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories } from "../schemas/queries/category.query";
+import type { RequestContext} from "../schemas/session.schema";
 import { Session } from "../schemas/session.schema";
 import { BaseProvider } from "./base.provider";
 
@@ -32,11 +32,11 @@ export abstract class CategoryProvider<
    * For now, the result will be en empty category, but we should probably throw an error instead.
    *
    * Use case: You have received a list of category ids from a recommendation engine, and you need to show a tile of this.
-   * Future optimization: getByIds(ids: CategoryIdentifier[], session: Session): Promise<T[]>
+   * Future optimization: getByIds(ids: CategoryIdentifier[], reqCtx: RequestContext): Promise<T[]>
    * @param id
    * @param session
    */
-  public abstract getById(payload: CategoryQueryById, session: Session): Promise<T>;
+  public abstract getById(payload: CategoryQueryById, reqCtx: RequestContext): Promise<T>;
 
   /**
    * Gets a single category by its seo slug
@@ -45,7 +45,7 @@ export abstract class CategoryProvider<
    * @param slug the slug
    * @param session
    */
-  public abstract getBySlug(payload: CategoryQueryBySlug, session: Session): Promise<T | null>;
+  public abstract getBySlug(payload: CategoryQueryBySlug, reqCtx: RequestContext): Promise<T | null>;
 
 
   /**
@@ -56,7 +56,7 @@ export abstract class CategoryProvider<
    * @param id
    * @param session
    */
-  public abstract getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, session: Session): Promise<T[]>;
+  public abstract getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, reqCtx: RequestContext): Promise<T[]>;
 
   // 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
@@ -71,7 +71,7 @@ export abstract class CategoryProvider<
    * @param id The ID of the parent category.
    * @param session The session information.
    */
-  public abstract findChildCategories(payload: CategoryQueryForChildCategories, session: Session): Promise< ReturnType<typeof this.parsePaginatedResult>>;
+  public abstract findChildCategories(payload: CategoryQueryForChildCategories, reqCtx: RequestContext): Promise< ReturnType<typeof this.parsePaginatedResult>>;
 
   /**
    * Returns all top categories, i.e. categories without a parent.
@@ -80,7 +80,7 @@ export abstract class CategoryProvider<
    * @param paginationOptions
    * @param session
    */
-  public abstract findTopCategories( payload: CategoryQueryForTopCategories, session: Session): Promise<ReturnType<typeof this.parsePaginatedResult>>;
+  public abstract findTopCategories( payload: CategoryQueryForTopCategories, reqCtx: RequestContext): Promise<ReturnType<typeof this.parsePaginatedResult>>;
 
 
   protected override getResourceName(): string {

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

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

package/core/src/providers/index.ts

@@ -0,0 +1,12 @@
+export * from './analytics.provider';
+export * from './base.provider';
+export * from './cart-payment.provider';
+export * from './cart.provider';
+export * from './category.provider';
+export * from './identity.provider';
+export * from './inventory.provider';
+export * from './price.provider';
+export * from './product.provider';
+export * from './profile.provider';
+export * from './search.provider';
+export * from './store.provider';

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

@@ -1,12 +1,12 @@
-import { Inventory } from '../schemas/models/inventory.model';
-import { InventoryQuery } from '../schemas/queries/inventory.query';
-import { Session } from '../schemas/session.schema';
+import type { Inventory } from '../schemas/models/inventory.model';
+import type { InventoryQueryBySKU } from '../schemas/queries/inventory.query';
+import type { RequestContext } from '../schemas/session.schema';
 import { BaseProvider } from './base.provider';
 
 export abstract class InventoryProvider<
   T extends Inventory = Inventory
 > extends BaseProvider<T> {
-  public abstract getBySKU(payload: InventoryQuery, session: Session): Promise<T>;
+  public abstract getBySKU(payload: InventoryQueryBySKU, reqCtx: RequestContext): Promise<T>;
 
   protected override getResourceName(): string {
     return 'inventory';

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

@@ -1,7 +1,7 @@
-import { Currency } from '../schemas/models/currency.model';
-import { Price } from '../schemas/models/price.model';
-import { PriceQueryBySku } from '../schemas/queries/price.query';
-import { Session } from '../schemas/session.schema';
+import type { Currency } from '../schemas/models/currency.model';
+import type { Price } from '../schemas/models/price.model';
+import type { PriceQueryBySku } from '../schemas/queries/price.query';
+import type { RequestContext } from '../schemas/session.schema';
 import { BaseProvider } from './base.provider';
 
 export abstract class PriceProvider<
@@ -19,7 +19,7 @@ export abstract class PriceProvider<
    * @param payload The SKU to query
    * @param session The session information
    */
-  public abstract getBySKU(payload: PriceQueryBySku, session: Session): Promise<T>;
+  public abstract getBySKU(payload: PriceQueryBySku, reqCtx: RequestContext): Promise<T>;
 
 
   /**
@@ -29,7 +29,7 @@ export abstract class PriceProvider<
    * @param payload The SKUs to query
    * @param session The session information
    */
-  public abstract getBySKUs(payload: PriceQueryBySku[], session: Session): Promise<T[]>;
+  public abstract getBySKUs(payload: PriceQueryBySku[], reqCtx: RequestContext): Promise<T[]>;
 
 
   /**
@@ -40,7 +40,7 @@ export abstract class PriceProvider<
    * @param currency
    * @returns
    */
-  protected getEmptyPriceResult(sku: string, currency: Currency): T {
+  protected createEmptyPriceResult(sku: string, currency: Currency): T {
     const base = this.newModel();
     base.identifier = {
       sku: { key: sku }

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

@@ -1,14 +1,26 @@
-import { Product } from '../schemas/models/product.model';
+import type { Product } from '../schemas/models/product.model';
 import { BaseProvider } from './base.provider';
-import { Session } from '../schemas/session.schema';
-import { ProductQueryById, ProductQueryBySlug } from '../schemas/queries/product.query';
+import type { RequestContext } from '../schemas/session.schema';
+import type { ProductQueryById, ProductQueryBySlug } from '../schemas/queries/product.query';
 
 export abstract class ProductProvider<
   T extends Product = Product
 > extends BaseProvider<T> {
-  public abstract getById(payload: ProductQueryById, session: Session): Promise<T>;
-  public abstract getBySlug(payload: ProductQueryBySlug, session: Session): Promise<T>;
+  public abstract getById(payload: ProductQueryById, reqCtx: RequestContext): Promise<T>;
+  public abstract getBySlug(payload: ProductQueryBySlug, reqCtx: RequestContext): Promise<T | null>;
 
+
+  protected createEmptyProduct(id: string): T {
+    const product = this.newModel();
+    product.identifier = { key: id };
+    product.meta.placeholder = true;
+    return product;
+  }
+
+  /**
+   * The resource name, used for caching and logging.
+   * @returns
+   */
   protected override getResourceName(): string {
     return 'product';
   }

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

@@ -0,0 +1,22 @@
+import type { Profile } from '../schemas/models';
+import type { ProfileMutationUpdate } from '../schemas/mutations';
+import type { ProfileQuerySelf } from '../schemas/queries';
+import type { RequestContext } from '../schemas/session.schema';
+import { BaseProvider } from './base.provider';
+
+export abstract class ProfileProvider<
+  T extends Profile = Profile
+> extends BaseProvider<T> {
+  public abstract getSelf(
+    payload: ProfileQuerySelf,
+    reqCtx: RequestContext
+  ): Promise<T>;
+  public abstract update(
+    payload: ProfileMutationUpdate,
+    reqCtx: RequestContext
+  ): Promise<T>;
+
+  protected override getResourceName(): string {
+    return 'profile';
+  }
+}

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

@@ -1,12 +1,12 @@
-import { SearchResult } from '../schemas/models/search.model';
-import { SearchQueryByTerm } from '../schemas/queries/search.query';
-import { Session } from '../schemas/session.schema';
+import type { SearchResult } from '../schemas/models/search.model';
+import type { SearchQueryByTerm } from '../schemas/queries/search.query';
+import type { RequestContext } from '../schemas/session.schema';
 import { BaseProvider } from './base.provider';
 
 export abstract class SearchProvider<
   T extends SearchResult = SearchResult
 > extends BaseProvider<T> {
-  public abstract queryByTerm(payload: SearchQueryByTerm, session: Session): Promise<SearchResult>;
+  public abstract queryByTerm(payload: SearchQueryByTerm, reqCtx: RequestContext): Promise<SearchResult>;
 
 
   protected override getResourceName(): string {

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

@@ -0,0 +1,14 @@
+import type { Store } from '../schemas/models/store.model';
+import type { StoreQueryByProximity } from '../schemas/queries';
+import type { RequestContext } from '../schemas/session.schema';
+import { BaseProvider } from './base.provider';
+
+export abstract class StoreProvider<
+  T extends Store = Store
+> extends BaseProvider<T> {
+  public abstract queryByProximity(payload: StoreQueryByProximity, reqCtx: RequestContext): Promise<Array<T>>;
+
+  protected override getResourceName(): string {
+    return 'store';
+  }
+}

package/core/src/schemas/capabilities.schema.ts

@@ -6,9 +6,11 @@ export const CapabilitiesSchema = z.looseObject({
     analytics: z.boolean(),
     identity: z.boolean(),
     cart: z.boolean(),
+    cartPayment: z.boolean(),
     inventory: z.boolean(),
     price: z.boolean(),
-    category: z.boolean()
+    category: z.boolean(),
+    store: z.boolean()
 });
 
 export type Capabilities = z.infer<typeof CapabilitiesSchema>;

package/core/src/schemas/models/analytics.model.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import type { z } from 'zod';
 import { BaseModelSchema } from './base.model';
 
 export const AnalyticsEventSchema = BaseModelSchema.extend({

package/core/src/schemas/models/cart.model.ts

@@ -1,7 +1,9 @@
 import { z } from 'zod';
-import { CartIdentifierSchema, CartItemIdentifierSchema, ProductIdentifierSchema } from '../models/identifiers.model';
+import { CartIdentifierSchema, CartItemIdentifierSchema, IdentityIdentifierSchema, ProductIdentifierSchema, SKUIdentifierSchema } from '../models/identifiers.model';
 import { BaseModelSchema } from './base.model';
 import { MonetaryAmountSchema } from './price.model';
+import { AddressSchema } from './profile.model';
+import { ShippingMethodSchema } from './shipping-method.model';
 
 export const CostBreakDownSchema = z.looseObject({
     totalTax: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The amount of tax paid on the cart. This may include VAT, GST, sales tax, etc.'),
@@ -11,7 +13,6 @@ export const CostBreakDownSchema = z.looseObject({
     totalProductPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The total price of products in the cart.'),
     grandTotal: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The total price for the cart including all taxes, discounts, and shipping.'),
 });
-export type CostBreakDown = z.infer<typeof CostBreakDownSchema>;
 
 export const ItemCostBreakdownSchema = z.looseObject({
     unitPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The price per single unit of the item.'),
@@ -20,22 +21,34 @@ export const ItemCostBreakdownSchema = z.looseObject({
     totalDiscount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The total discount applied to all units of the item.'),
 });
 
-export type ItemCostBreakdown = z.infer<typeof ItemCostBreakdownSchema>;
 
 export const CartItemSchema = z.looseObject({
     identifier: CartItemIdentifierSchema.default(() => CartItemIdentifierSchema.parse({})),
     product: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
+    sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
     quantity: z.number().default(0),
     price: ItemCostBreakdownSchema.default(() => ItemCostBreakdownSchema.parse({})),
 });
 
 export const CartSchema = BaseModelSchema.extend({
     identifier: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({})),
+
+    userId: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
+
     items: z.array(CartItemSchema).default(() => []),
     price: CostBreakDownSchema.default(() => CostBreakDownSchema.parse({})),
     name: z.string().default(''),
     description: z.string().default(''),
+
+
+    shippingAddress: AddressSchema.optional(),
+    billingAddress: AddressSchema.optional(),
+    shippingMethod: ShippingMethodSchema.optional(),
 });
 
+
+
+export type CostBreakDown = z.infer<typeof CostBreakDownSchema>;
+export type ItemCostBreakdown = z.infer<typeof ItemCostBreakdownSchema>;
 export type CartItem = z.infer<typeof CartItemSchema>;
 export type Cart = z.infer<typeof CartSchema>;