@reactionary/core 0.6.1 → 0.6.3

package/src/{providers/product-search.provider.d.ts → capabilities/product-search.capability.d.ts}

@@ -1,10 +1,10 @@
-import type { FacetIdentifier, FacetValueIdentifier, Result } from '../index.js';
-import type { ProductSearchResult, ProductSearchResultFacet, ProductSearchResultFacetValue, ProductSearchResultItemVariant } from '../schemas/models/product-search.model.js';
+import type { FacetValueIdentifier, Result } from '../index.js';
+import type { ProductSearchResult } 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 declare abstract class ProductSearchProvider extends BaseProvider {
+import { BaseCapability } from './base.capability.js';
+export declare abstract class ProductSearchCapability<TProductSearchResult extends ProductSearchResult = ProductSearchResult> extends BaseCapability {
     protected getResourceName(): string;
-    abstract queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchResult>>;
+    abstract queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<TProductSearchResult>>;
     /**
      * 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.
@@ -24,27 +24,4 @@ export declare abstract class ProductSearchProvider extends BaseProvider {
      * @param categoryPath
      */
     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;
 }

package/src/{providers/product.provider.d.ts → capabilities/product.capability.d.ts}

@@ -1,9 +1,9 @@
 import type { Product } from '../schemas/models/product.model.js';
-import { BaseProvider } from './base.provider.js';
+import { BaseCapability } from './base.capability.js';
 import type { ProductQueryById, ProductQueryBySKU, ProductQueryBySlug } from '../schemas/queries/product.query.js';
 import type { Result } from '../schemas/result.js';
 import type { NotFoundError } from '../schemas/index.js';
-export declare abstract class ProductProvider extends BaseProvider {
+export declare abstract class ProductCapability<TProduct extends Product = Product> extends BaseCapability {
     /**
      * Get a product by its ID.
      * @param payload The query payload containing the product ID.
@@ -14,7 +14,7 @@ export declare abstract class ProductProvider extends BaseProvider {
      * Marketing will TYPICALLY recommend products, and in some cases maybe HeroVariants of a product.
      * In that case, you would need to resolve the product to its hero variant first, and then get the SKU from there.
      */
-    abstract getById(payload: ProductQueryById): Promise<Result<Product>>;
+    abstract getById(payload: ProductQueryById): Promise<Result<TProduct>>;
     /**
      * Get a product by its slug.
      * @param payload The query payload containing the product slug.
@@ -22,7 +22,7 @@ export declare abstract class ProductProvider extends BaseProvider {
      *
      * Usecase: You are rendering a product detail page, and you need to fetch the product by its slug.
      */
-    abstract getBySlug(payload: ProductQueryBySlug): Promise<Result<Product, NotFoundError>>;
+    abstract getBySlug(payload: ProductQueryBySlug): Promise<Result<TProduct, NotFoundError>>;
     /**
      * Get a product by its SKU
      * @param payload
@@ -32,8 +32,8 @@ export declare abstract class ProductProvider extends BaseProvider {
      * and you need to fetch the product details for that SKU. You will get the a Product back, with the variant matching the SKU set as heroSku.
      * It might also be used on a quick-order page, or product recommendations from external system.
      */
-    abstract getBySKU(payload: ProductQueryBySKU): Promise<Result<Product>>;
-    protected createEmptyProduct(id: string): Product;
+    abstract getBySKU(payload: ProductQueryBySKU): Promise<Result<TProduct>>;
+    protected createEmptyProduct(id: string): TProduct;
     /**
      * The resource name, used for caching and logging.
      * @returns

package/src/{providers/profile.provider.d.ts → capabilities/profile.capability.d.ts}

@@ -3,15 +3,15 @@ import type { Profile } from '../schemas/models/index.js';
 import type { ProfileMutationAddShippingAddress, ProfileMutationMakeShippingAddressDefault, ProfileMutationRemoveShippingAddress, ProfileMutationSetBillingAddress, ProfileMutationUpdate, ProfileMutationUpdateShippingAddress } from '../schemas/mutations/index.js';
 import type { ProfileQuerySelf as ProfileQueryById } from '../schemas/queries/index.js';
 import type { Result } from '../schemas/result.js';
-import { BaseProvider } from './base.provider.js';
-export declare abstract class ProfileProvider extends BaseProvider {
+import { BaseCapability } from './base.capability.js';
+export declare abstract class ProfileCapability<TProfile extends Profile = Profile> extends BaseCapability {
     /**
      * Returns the profile of the currently authenticated (registered) user.
      *
      * Usecase: Fetch the profile of the logged-in user for display in header, or account settings.
      * @param payload
      */
-    abstract getById(payload: ProfileQueryById): Promise<Result<Profile, NotFoundError>>;
+    abstract getById(payload: ProfileQueryById): Promise<Result<TProfile, NotFoundError>>;
     /**
      * Updates the base profile information of the currently authenticated (registered) user.
      *
@@ -23,7 +23,7 @@ export declare abstract class ProfileProvider extends BaseProvider {
      * Usecase: Update the user's name, email, or phone number.
      * @param payload
      */
-    abstract update(payload: ProfileMutationUpdate): Promise<Result<Profile, NotFoundError>>;
+    abstract update(payload: ProfileMutationUpdate): Promise<Result<TProfile, NotFoundError>>;
     /**
      * Creates a new shipping address for the currently authenticated (registered) user.
      * Does not set it as default automatically.
@@ -32,7 +32,7 @@ export declare abstract class ProfileProvider extends BaseProvider {
      * done at checkout should be considered local to that session, unless the addressbook is empty.
      * @param payload
      */
-    abstract addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<Profile, NotFoundError>>;
+    abstract addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<TProfile, NotFoundError>>;
     /**
      * Updates an existing shipping address for the currently authenticated (registered) user.
      *
@@ -40,7 +40,7 @@ export declare abstract class ProfileProvider extends BaseProvider {
      * done at checkout should be considered local to that session/order, unless the addressbook is empty.
      * @param payload
      */
-    abstract updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<Profile, NotFoundError>>;
+    abstract updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<TProfile, NotFoundError>>;
     /**
      * Removes an existing shipping address for the currently authenticated (registered) user.
      *
@@ -49,14 +49,14 @@ export declare abstract class ProfileProvider extends BaseProvider {
      * Usecase: User deletes a shipping address from their profile.
      * @param payload
      */
-    abstract removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<Profile, NotFoundError>>;
+    abstract removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<TProfile, NotFoundError>>;
     /**
      * Configures an existing shipping address as the default shipping address for the currently authenticated (registered) user.
      *
      * Usecase: User selects a default shipping address in their profile.
      * @param payload
      */
-    abstract makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<Profile, NotFoundError>>;
+    abstract makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<TProfile, NotFoundError>>;
     /**
      * Sets the current/active billing address for the currently authenticated (registered) user.
      *
@@ -66,6 +66,6 @@ export declare abstract class ProfileProvider extends BaseProvider {
      * entity being billed, and as such it makes sense to have a single authoritative billing address.
      * @param payload
      */
-    abstract setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<Profile, NotFoundError>>;
+    abstract setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<TProfile, NotFoundError>>;
     protected getResourceName(): string;
 }

package/src/{providers/store.provider.d.ts → capabilities/store.capability.d.ts}

@@ -1,8 +1,8 @@
 import type { Store } from '../schemas/models/store.model.js';
 import type { StoreQueryByProximity } from '../schemas/queries/index.js';
 import type { Result } from '../schemas/result.js';
-import { BaseProvider } from './base.provider.js';
-export declare abstract class StoreProvider extends BaseProvider {
-    abstract queryByProximity(payload: StoreQueryByProximity): Promise<Result<Array<Store>>>;
+import { BaseCapability } from './base.capability.js';
+export declare abstract class StoreCapability<TStore extends Store = Store> extends BaseCapability {
+    abstract queryByProximity(payload: StoreQueryByProximity): Promise<Result<Array<TStore>>>;
     protected getResourceName(): string;
 }

package/src/client/client-builder.d.ts

@@ -1,17 +1,26 @@
 import type { Cache } from '../cache/cache.interface.js';
 import type { Client } from './client.js';
 import { type RequestContext } from '../schemas/session.schema.js';
-type CapabilityFactory<T> = (cache: Cache, context: RequestContext) => T;
+export interface ClientBuilderFactoryArgs {
+    cache: Cache;
+    context: RequestContext;
+}
+export type CapabilityFactory<T> = ((cache: Cache, context: RequestContext) => T) | ((args: ClientBuilderFactoryArgs) => T);
 type MergeCapabilities<Acc, New> = Omit<Acc, keyof New> & New;
+export type CapabilityCollisionStrategy = 'last-wins' | 'first-wins' | 'throw';
 export declare class ClientBuilder<TClient = Client> {
     private factories;
     private cache;
     private context;
+    private collisionStrategy;
     constructor(context: RequestContext);
     withCapability<TNew extends Partial<Client>>(factory: CapabilityFactory<TNew>): ClientBuilder<MergeCapabilities<TClient, TNew>>;
     withCache(cache: Cache): ClientBuilder<TClient>;
+    withCollisionStrategy(strategy: CapabilityCollisionStrategy): ClientBuilder<TClient>;
     build(): TClient & {
         cache: Cache;
     };
+    private resolveFactory;
+    private mergeCapabilities;
 }
 export {};

package/src/client/client.d.ts

@@ -1,33 +1,33 @@
-import type { ProductProvider } from "../providers/product.provider.js";
-import type { ProductSearchProvider } from "../providers/product-search.provider.js";
-import type { IdentityProvider } from '../providers/identity.provider.js';
-import type { CartProvider } from "../providers/cart.provider.js";
-import type { PriceProvider } from "../providers/price.provider.js";
-import type { InventoryProvider } from "../providers/inventory.provider.js";
+import type { ProductCapability } from "../capabilities/product.capability.js";
+import type { ProductSearchCapability } from "../capabilities/product-search.capability.js";
+import type { IdentityCapability } from '../capabilities/identity.capability.js';
+import type { CartCapability } from "../capabilities/cart.capability.js";
+import type { PriceCapability } from "../capabilities/price.capability.js";
+import type { InventoryCapability } from "../capabilities/inventory.capability.js";
 import type { Cache } from "../cache/cache.interface.js";
-import type { CategoryProvider } from "../providers/category.provider.js";
-import type { AnalyticsProvider, CheckoutProvider, OrderProvider, ProductListProvider, ProfileProvider, StoreProvider } from "../providers/index.js";
-import type { OrderSearchProvider } from "../providers/order-search.provider.js";
-import type { ProductRecommendationsProvider } from "../providers/product-recommendations.provider.js";
-import type { ProductAssociationsProvider } from "../providers/product-associations.provider.js";
-import type { ProductReviewsProvider } from "../providers/product-reviews.provider.js";
+import type { CategoryCapability } from "../capabilities/category.capability.js";
+import type { AnalyticsCapability, CheckoutCapability, OrderCapability, ProductListCapability, ProfileCapability, StoreCapability } from "../capabilities/index.js";
+import type { OrderSearchCapability } from "../capabilities/order-search.capability.js";
+import type { ProductRecommendationsCapability } from "../capabilities/product-recommendations.capability.js";
+import type { ProductAssociationsCapability } from "../capabilities/product-associations.capability.js";
+import type { ProductReviewsCapability } from "../capabilities/product-reviews.capability.js";
 export interface Client {
-    product: ProductProvider;
-    productSearch: ProductSearchProvider;
-    productRecommendations: ProductRecommendationsProvider;
-    productAssociations: ProductAssociationsProvider;
-    productReviews: ProductReviewsProvider;
-    productList: ProductListProvider;
-    identity: IdentityProvider;
+    product: ProductCapability;
+    productSearch: ProductSearchCapability;
+    productRecommendations: ProductRecommendationsCapability;
+    productAssociations: ProductAssociationsCapability;
+    productReviews: ProductReviewsCapability;
+    productList: ProductListCapability;
+    identity: IdentityCapability;
     cache: Cache;
-    cart: CartProvider;
-    checkout: CheckoutProvider;
-    analytics: AnalyticsProvider;
-    price: PriceProvider;
-    inventory: InventoryProvider;
-    category: CategoryProvider;
-    profile: ProfileProvider;
-    store: StoreProvider;
-    order: OrderProvider;
-    orderSearch: OrderSearchProvider;
+    cart: CartCapability;
+    checkout: CheckoutCapability;
+    analytics: AnalyticsCapability;
+    price: PriceCapability;
+    inventory: InventoryCapability;
+    category: CategoryCapability;
+    profile: ProfileCapability;
+    store: StoreCapability;
+    order: OrderCapability;
+    orderSearch: OrderSearchCapability;
 }

package/src/decorators/reactionary.decorator.d.ts

@@ -1,10 +1,10 @@
 import type { Tracer } from '@opentelemetry/api';
 import * as z from 'zod';
-import type { BaseProvider } from '../providers/index.js';
+import type { BaseCapability } from '../capabilities/index.js';
 import { type Result } from '../schemas/result.js';
 export declare function getTracer(): Tracer;
 /**
- * The options associated with annotating a provider function and marking
+ * The options associated with annotating a capability function and marking
  * it as a reactionary entrypoint to be called
  */
 export declare class ReactionaryDecoratorOptions {
@@ -39,11 +39,11 @@ export declare class ReactionaryDecoratorOptions {
     outputSchema: z.ZodType;
 }
 /**
- * Decorator for provider functions to provide functionality such as caching, tracing and type-checked
+ * Decorator for capability functions to provide functionality such as caching, tracing and type-checked
  * assertion through Zod. It should only be used with publically accessible queries or mutations on
- * providers.
+ * capabilities.
  */
-export declare function Reactionary(options: Partial<ReactionaryDecoratorOptions>): (target: BaseProvider, propertyKey: string | symbol, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function Reactionary(options: Partial<ReactionaryDecoratorOptions>): (target: BaseCapability, propertyKey: string | symbol, descriptor: PropertyDescriptor) => PropertyDescriptor;
 /**
  * Utility function to handle input validation.
  */

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

@@ -0,0 +1,18 @@
+import type * as z from 'zod';
+import type { CartSchema } from '../schemas/models/cart.model.js';
+import type { CartIdentifierSchema } from '../schemas/models/identifiers.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyCartSchema = z.ZodType<z.output<typeof CartSchema>>;
+export type AnyCartIdentifierSchema = z.ZodType<z.output<typeof CartIdentifierSchema>>;
+export interface CartFactory<TCartSchema extends AnyCartSchema = AnyCartSchema, TCartIdentifierSchema extends AnyCartIdentifierSchema = AnyCartIdentifierSchema> {
+    cartSchema: TCartSchema;
+    cartIdentifierSchema: TCartIdentifierSchema;
+    parseCart(context: RequestContext, data: unknown): z.output<TCartSchema>;
+    parseCartIdentifier(context: RequestContext, data: unknown): z.output<TCartIdentifierSchema>;
+}
+export type CartFactoryCartOutput<TFactory extends CartFactory> = ReturnType<TFactory['parseCart']>;
+export type CartFactoryIdentifierOutput<TFactory extends CartFactory> = ReturnType<TFactory['parseCartIdentifier']>;
+export type CartFactoryWithOutput<TFactory extends CartFactory> = Omit<TFactory, 'parseCart' | 'parseCartIdentifier'> & {
+    parseCart(context: RequestContext, data: unknown): CartFactoryCartOutput<TFactory>;
+    parseCartIdentifier(context: RequestContext, data: unknown): CartFactoryIdentifierOutput<TFactory>;
+};

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

@@ -0,0 +1,17 @@
+import type * as z from 'zod';
+import type { CategoryPaginatedResultSchema, CategorySchema } from '../schemas/models/category.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyCategorySchema = z.ZodType<z.output<typeof CategorySchema>>;
+export type AnyCategoryPaginatedResultSchema = z.ZodType<z.output<typeof CategoryPaginatedResultSchema>>;
+export interface CategoryFactory<TCategorySchema extends AnyCategorySchema = AnyCategorySchema, TCategoryPaginatedSchema extends AnyCategoryPaginatedResultSchema = AnyCategoryPaginatedResultSchema> {
+    categorySchema: TCategorySchema;
+    categoryPaginatedResultSchema: TCategoryPaginatedSchema;
+    parseCategory(context: RequestContext, data: unknown): z.output<TCategorySchema>;
+    parseCategoryPaginatedResult(context: RequestContext, data: unknown): z.output<TCategoryPaginatedSchema>;
+}
+export type CategoryFactoryCategoryOutput<TFactory extends CategoryFactory> = ReturnType<TFactory['parseCategory']>;
+export type CategoryFactoryPaginatedOutput<TFactory extends CategoryFactory> = ReturnType<TFactory['parseCategoryPaginatedResult']>;
+export type CategoryFactoryWithOutput<TFactory extends CategoryFactory> = Omit<TFactory, 'parseCategory' | 'parseCategoryPaginatedResult'> & {
+    parseCategory(context: RequestContext, data: unknown): CategoryFactoryCategoryOutput<TFactory>;
+    parseCategoryPaginatedResult(context: RequestContext, data: unknown): CategoryFactoryPaginatedOutput<TFactory>;
+};

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

@@ -0,0 +1,24 @@
+import type * as z from 'zod';
+import type { CheckoutSchema } from '../schemas/models/checkout.model.js';
+import type { PaymentMethodSchema } from '../schemas/models/payment.model.js';
+import type { ShippingMethodSchema } from '../schemas/models/shipping-method.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyCheckoutSchema = z.ZodType<z.output<typeof CheckoutSchema>>;
+export type AnyShippingMethodSchema = z.ZodType<z.output<typeof ShippingMethodSchema>>;
+export type AnyPaymentMethodSchema = z.ZodType<z.output<typeof PaymentMethodSchema>>;
+export interface CheckoutFactory<TCheckoutSchema extends AnyCheckoutSchema = AnyCheckoutSchema, TShippingMethodSchema extends AnyShippingMethodSchema = AnyShippingMethodSchema, TPaymentMethodSchema extends AnyPaymentMethodSchema = AnyPaymentMethodSchema> {
+    checkoutSchema: TCheckoutSchema;
+    shippingMethodSchema: TShippingMethodSchema;
+    paymentMethodSchema: TPaymentMethodSchema;
+    parseCheckout(context: RequestContext, data: unknown): z.output<TCheckoutSchema>;
+    parseShippingMethod(context: RequestContext, data: unknown): z.output<TShippingMethodSchema>;
+    parsePaymentMethod(context: RequestContext, data: unknown): z.output<TPaymentMethodSchema>;
+}
+export type CheckoutFactoryCheckoutOutput<TFactory extends CheckoutFactory> = ReturnType<TFactory['parseCheckout']>;
+export type CheckoutFactoryShippingMethodOutput<TFactory extends CheckoutFactory> = ReturnType<TFactory['parseShippingMethod']>;
+export type CheckoutFactoryPaymentMethodOutput<TFactory extends CheckoutFactory> = ReturnType<TFactory['parsePaymentMethod']>;
+export type CheckoutFactoryWithOutput<TFactory extends CheckoutFactory> = Omit<TFactory, 'parseCheckout' | 'parseShippingMethod' | 'parsePaymentMethod'> & {
+    parseCheckout(context: RequestContext, data: unknown): CheckoutFactoryCheckoutOutput<TFactory>;
+    parseShippingMethod(context: RequestContext, data: unknown): CheckoutFactoryShippingMethodOutput<TFactory>;
+    parsePaymentMethod(context: RequestContext, data: unknown): CheckoutFactoryPaymentMethodOutput<TFactory>;
+};

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

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { IdentitySchema } from '../schemas/models/identity.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyIdentitySchema = z.ZodType<z.output<typeof IdentitySchema>>;
+export interface IdentityFactory<TIdentitySchema extends AnyIdentitySchema = AnyIdentitySchema> {
+    identitySchema: TIdentitySchema;
+    parseIdentity(context: RequestContext, data: unknown): z.output<TIdentitySchema>;
+}
+export type IdentityFactoryOutput<TFactory extends IdentityFactory> = ReturnType<TFactory['parseIdentity']>;
+export type IdentityFactoryWithOutput<TFactory extends IdentityFactory> = Omit<TFactory, 'parseIdentity'> & {
+    parseIdentity(context: RequestContext, data: unknown): IdentityFactoryOutput<TFactory>;
+};

package/src/factories/index.d.ts

@@ -0,0 +1,15 @@
+export * from './cart.factory.js';
+export * from './category.factory.js';
+export * from './checkout.factory.js';
+export * from './identity.factory.js';
+export * from './inventory.factory.js';
+export * from './order.factory.js';
+export * from './order-search.factory.js';
+export * from './price.factory.js';
+export * from './product.factory.js';
+export * from './product-associations.factory.js';
+export * from './product-list.factory.js';
+export * from './product-reviews.factory.js';
+export * from './product-search.factory.js';
+export * from './profile.factory.js';
+export * from './store.factory.js';

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

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { InventorySchema } from '../schemas/models/inventory.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyInventorySchema = z.ZodType<z.output<typeof InventorySchema>>;
+export interface InventoryFactory<TInventorySchema extends AnyInventorySchema = AnyInventorySchema> {
+    inventorySchema: TInventorySchema;
+    parseInventory(context: RequestContext, data: unknown): z.output<TInventorySchema>;
+}
+export type InventoryFactoryOutput<TFactory extends InventoryFactory> = ReturnType<TFactory['parseInventory']>;
+export type InventoryFactoryWithOutput<TFactory extends InventoryFactory> = Omit<TFactory, 'parseInventory'> & {
+    parseInventory(context: RequestContext, data: unknown): InventoryFactoryOutput<TFactory>;
+};

package/src/factories/order-search.factory.d.ts

@@ -0,0 +1,13 @@
+import type * as z from 'zod';
+import type { OrderSearchResultSchema } from '../schemas/models/order-search.model.js';
+import type { OrderSearchQueryByTerm } from '../schemas/queries/order-search.query.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyOrderSearchResultSchema = z.ZodType<z.output<typeof OrderSearchResultSchema>>;
+export interface OrderSearchFactory<TOrderSearchResultSchema extends AnyOrderSearchResultSchema = AnyOrderSearchResultSchema> {
+    orderSearchResultSchema: TOrderSearchResultSchema;
+    parseOrderSearchResult(context: RequestContext, data: unknown, query: OrderSearchQueryByTerm): z.output<TOrderSearchResultSchema>;
+}
+export type OrderSearchFactoryOutput<TFactory extends OrderSearchFactory> = ReturnType<TFactory['parseOrderSearchResult']>;
+export type OrderSearchFactoryWithOutput<TFactory extends OrderSearchFactory> = Omit<TFactory, 'parseOrderSearchResult'> & {
+    parseOrderSearchResult(context: RequestContext, data: unknown, query: OrderSearchQueryByTerm): OrderSearchFactoryOutput<TFactory>;
+};

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

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { OrderSchema } from '../schemas/models/order.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyOrderSchema = z.ZodType<z.output<typeof OrderSchema>>;
+export interface OrderFactory<TOrderSchema extends AnyOrderSchema = AnyOrderSchema> {
+    orderSchema: TOrderSchema;
+    parseOrder(context: RequestContext, data: unknown): z.output<TOrderSchema>;
+}
+export type OrderFactoryOutput<TFactory extends OrderFactory> = ReturnType<TFactory['parseOrder']>;
+export type OrderFactoryWithOutput<TFactory extends OrderFactory> = Omit<TFactory, 'parseOrder'> & {
+    parseOrder(context: RequestContext, data: unknown): OrderFactoryOutput<TFactory>;
+};

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

@@ -0,0 +1,16 @@
+import type * as z from 'zod';
+import type { PriceSchema } from '../schemas/models/price.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyPriceSchema = z.ZodType<z.output<typeof PriceSchema>>;
+export interface PriceFactory<TPriceSchema extends AnyPriceSchema = AnyPriceSchema> {
+    priceSchema: TPriceSchema;
+    parsePrice(context: RequestContext, data: unknown, options?: {
+        includeDiscounts: boolean;
+    }): z.output<TPriceSchema>;
+}
+export type PriceFactoryOutput<TFactory extends PriceFactory> = ReturnType<TFactory['parsePrice']>;
+export type PriceFactoryWithOutput<TFactory extends PriceFactory> = Omit<TFactory, 'parsePrice'> & {
+    parsePrice(context: RequestContext, data: unknown, options?: {
+        includeDiscounts: boolean;
+    }): PriceFactoryOutput<TFactory>;
+};

package/src/factories/product-associations.factory.d.ts

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { ProductAssociationSchema } from '../schemas/models/product-associations.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyProductAssociationSchema = z.ZodType<z.output<typeof ProductAssociationSchema>>;
+export interface ProductAssociationsFactory<TProductAssociationSchema extends AnyProductAssociationSchema = AnyProductAssociationSchema> {
+    productAssociationSchema: TProductAssociationSchema;
+    parseAssociation(context: RequestContext, data: unknown): z.output<TProductAssociationSchema>;
+}
+export type ProductAssociationsFactoryOutput<TFactory extends ProductAssociationsFactory> = ReturnType<TFactory['parseAssociation']>;
+export type ProductAssociationsFactoryWithOutput<TFactory extends ProductAssociationsFactory> = Omit<TFactory, 'parseAssociation'> & {
+    parseAssociation(context: RequestContext, data: unknown): ProductAssociationsFactoryOutput<TFactory>;
+};

package/src/factories/product-list.factory.d.ts

@@ -0,0 +1,27 @@
+import type * as z from 'zod';
+import type { ProductListItemPaginatedResultsSchema, ProductListItemSchema, ProductListPaginatedResultsSchema, ProductListSchema } from '../schemas/models/product-list.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyProductListSchema = z.ZodType<z.output<typeof ProductListSchema>>;
+export type AnyProductListItemSchema = z.ZodType<z.output<typeof ProductListItemSchema>>;
+export type AnyProductListPaginatedSchema = z.ZodType<z.output<typeof ProductListPaginatedResultsSchema>>;
+export type AnyProductListItemPaginatedSchema = z.ZodType<z.output<typeof ProductListItemPaginatedResultsSchema>>;
+export interface ProductListFactory<TProductListSchema extends AnyProductListSchema = AnyProductListSchema, TProductListItemSchema extends AnyProductListItemSchema = AnyProductListItemSchema, TProductListPaginatedSchema extends AnyProductListPaginatedSchema = AnyProductListPaginatedSchema, TProductListItemPaginatedSchema extends AnyProductListItemPaginatedSchema = AnyProductListItemPaginatedSchema> {
+    productListSchema: TProductListSchema;
+    productListItemSchema: TProductListItemSchema;
+    productListPaginatedSchema: TProductListPaginatedSchema;
+    productListItemPaginatedSchema: TProductListItemPaginatedSchema;
+    parseProductList(context: RequestContext, data: unknown): z.output<TProductListSchema>;
+    parseProductListItem(context: RequestContext, data: unknown): z.output<TProductListItemSchema>;
+    parseProductListPaginatedResult(context: RequestContext, data: unknown): z.output<TProductListPaginatedSchema>;
+    parseProductListItemPaginatedResult(context: RequestContext, data: unknown): z.output<TProductListItemPaginatedSchema>;
+}
+export type ProductListFactoryListOutput<TFactory extends ProductListFactory> = ReturnType<TFactory['parseProductList']>;
+export type ProductListFactoryItemOutput<TFactory extends ProductListFactory> = ReturnType<TFactory['parseProductListItem']>;
+export type ProductListFactoryListPaginatedOutput<TFactory extends ProductListFactory> = ReturnType<TFactory['parseProductListPaginatedResult']>;
+export type ProductListFactoryItemPaginatedOutput<TFactory extends ProductListFactory> = ReturnType<TFactory['parseProductListItemPaginatedResult']>;
+export type ProductListFactoryWithOutput<TFactory extends ProductListFactory> = Omit<TFactory, 'parseProductList' | 'parseProductListItem' | 'parseProductListPaginatedResult' | 'parseProductListItemPaginatedResult'> & {
+    parseProductList(context: RequestContext, data: unknown): ProductListFactoryListOutput<TFactory>;
+    parseProductListItem(context: RequestContext, data: unknown): ProductListFactoryItemOutput<TFactory>;
+    parseProductListPaginatedResult(context: RequestContext, data: unknown): ProductListFactoryListPaginatedOutput<TFactory>;
+    parseProductListItemPaginatedResult(context: RequestContext, data: unknown): ProductListFactoryItemPaginatedOutput<TFactory>;
+};

package/src/factories/product-reviews.factory.d.ts

@@ -0,0 +1,22 @@
+import type * as z from 'zod';
+import type { ProductRatingSummarySchema, ProductReviewPaginatedResultSchema, ProductReviewSchema } from '../schemas/models/product-reviews.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyProductRatingSummarySchema = z.ZodType<z.output<typeof ProductRatingSummarySchema>>;
+export type AnyProductReviewSchema = z.ZodType<z.output<typeof ProductReviewSchema>>;
+export type AnyProductReviewPaginatedSchema = z.ZodType<z.output<typeof ProductReviewPaginatedResultSchema>>;
+export interface ProductReviewsFactory<TRatingSummarySchema extends AnyProductRatingSummarySchema = AnyProductRatingSummarySchema, TReviewSchema extends AnyProductReviewSchema = AnyProductReviewSchema, TReviewPaginatedSchema extends AnyProductReviewPaginatedSchema = AnyProductReviewPaginatedSchema> {
+    ratingSummarySchema: TRatingSummarySchema;
+    reviewSchema: TReviewSchema;
+    reviewPaginatedSchema: TReviewPaginatedSchema;
+    parseRatingSummary(context: RequestContext, data: unknown): z.output<TRatingSummarySchema>;
+    parseReview(context: RequestContext, data: unknown): z.output<TReviewSchema>;
+    parseReviewPaginatedResult(context: RequestContext, data: unknown): z.output<TReviewPaginatedSchema>;
+}
+export type ProductReviewsFactoryRatingOutput<TFactory extends ProductReviewsFactory> = ReturnType<TFactory['parseRatingSummary']>;
+export type ProductReviewsFactoryReviewOutput<TFactory extends ProductReviewsFactory> = ReturnType<TFactory['parseReview']>;
+export type ProductReviewsFactoryReviewPaginatedOutput<TFactory extends ProductReviewsFactory> = ReturnType<TFactory['parseReviewPaginatedResult']>;
+export type ProductReviewsFactoryWithOutput<TFactory extends ProductReviewsFactory> = Omit<TFactory, 'parseRatingSummary' | 'parseReview' | 'parseReviewPaginatedResult'> & {
+    parseRatingSummary(context: RequestContext, data: unknown): ProductReviewsFactoryRatingOutput<TFactory>;
+    parseReview(context: RequestContext, data: unknown): ProductReviewsFactoryReviewOutput<TFactory>;
+    parseReviewPaginatedResult(context: RequestContext, data: unknown): ProductReviewsFactoryReviewPaginatedOutput<TFactory>;
+};

package/src/factories/product-search.factory.d.ts

@@ -0,0 +1,13 @@
+import type * as z from 'zod';
+import type { ProductSearchResultSchema } from '../schemas/models/product-search.model.js';
+import type { ProductSearchQueryByTerm } from '../schemas/queries/product-search.query.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyProductSearchResultSchema = z.ZodType<z.output<typeof ProductSearchResultSchema>>;
+export interface ProductSearchFactory<TProductSearchResultSchema extends AnyProductSearchResultSchema = AnyProductSearchResultSchema> {
+    productSearchResultSchema: TProductSearchResultSchema;
+    parseSearchResult(context: RequestContext, data: unknown, query: ProductSearchQueryByTerm): z.output<TProductSearchResultSchema>;
+}
+export type ProductSearchFactoryOutput<TFactory extends ProductSearchFactory> = ReturnType<TFactory['parseSearchResult']>;
+export type ProductSearchFactoryWithOutput<TFactory extends ProductSearchFactory> = Omit<TFactory, 'parseSearchResult'> & {
+    parseSearchResult(context: RequestContext, data: unknown, query: ProductSearchQueryByTerm): ProductSearchFactoryOutput<TFactory>;
+};

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

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { ProductSchema } from '../schemas/models/product.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyProductSchema = z.ZodType<z.output<typeof ProductSchema>>;
+export interface ProductFactory<TProductSchema extends AnyProductSchema = AnyProductSchema> {
+    productSchema: TProductSchema;
+    parseProduct(context: RequestContext, data: unknown): z.output<TProductSchema>;
+}
+export type ProductFactoryOutput<TFactory extends ProductFactory> = ReturnType<TFactory['parseProduct']>;
+export type ProductFactoryWithOutput<TFactory extends ProductFactory> = Omit<TFactory, 'parseProduct'> & {
+    parseProduct(context: RequestContext, data: unknown): ProductFactoryOutput<TFactory>;
+};

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

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { ProfileSchema } from '../schemas/models/profile.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyProfileSchema = z.ZodType<z.output<typeof ProfileSchema>>;
+export interface ProfileFactory<TProfileSchema extends AnyProfileSchema = AnyProfileSchema> {
+    profileSchema: TProfileSchema;
+    parseProfile(context: RequestContext, data: unknown): z.output<TProfileSchema>;
+}
+export type ProfileFactoryOutput<TFactory extends ProfileFactory> = ReturnType<TFactory['parseProfile']>;
+export type ProfileFactoryWithOutput<TFactory extends ProfileFactory> = Omit<TFactory, 'parseProfile'> & {
+    parseProfile(context: RequestContext, data: unknown): ProfileFactoryOutput<TFactory>;
+};

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

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { StoreSchema } from '../schemas/models/store.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyStoreSchema = z.ZodType<z.output<typeof StoreSchema>>;
+export interface StoreFactory<TStoreSchema extends AnyStoreSchema = AnyStoreSchema> {
+    storeSchema: TStoreSchema;
+    parseStore(context: RequestContext, data: unknown): z.output<TStoreSchema>;
+}
+export type StoreFactoryOutput<TFactory extends StoreFactory> = ReturnType<TFactory['parseStore']>;
+export type StoreFactoryWithOutput<TFactory extends StoreFactory> = Omit<TFactory, 'parseStore'> & {
+    parseStore(context: RequestContext, data: unknown): StoreFactoryOutput<TFactory>;
+};

package/src/index.d.ts

@@ -1,6 +1,8 @@
 export * from './cache/index.js';
 export * from './client/index.js';
 export * from './decorators/index.js';
-export * from './providers/index.js';
+export * from './factories/index.js';
+export * from './capabilities/index.js';
 export * from './schemas/index.js';
 export * from './initialization.js';
+export type { InferType } from './zod-utils.js';

package/providers/cart.provider.js

@@ -1,9 +0,0 @@
-import { BaseProvider } from "./base.provider.js";
-class CartProvider extends BaseProvider {
-  getResourceName() {
-    return "cart";
-  }
-}
-export {
-  CartProvider
-};

package/providers/category.provider.js

@@ -1,9 +0,0 @@
-import { BaseProvider } from "./base.provider.js";
-class CategoryProvider extends BaseProvider {
-  getResourceName() {
-    return "category";
-  }
-}
-export {
-  CategoryProvider
-};

package/providers/checkout.provider.js

@@ -1,9 +0,0 @@
-import { BaseProvider } from "./base.provider.js";
-class CheckoutProvider extends BaseProvider {
-  getResourceName() {
-    return "checkout";
-  }
-}
-export {
-  CheckoutProvider
-};