@reactionary/core 0.0.42 → 0.0.51

package/schemas/models/order.model.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { CartIdentifierSchema, CartItemIdentifierSchema, IdentityIdentifierSchema, SKUIdentifierSchema } from "../models/identifiers.model";
+import { BaseModelSchema } from "./base.model";
+import { AddressSchema } from "./profile.model";
+import { ShippingMethodSchema } from "./shipping-method.model";
+import { CostBreakDownSchema, ItemCostBreakdownSchema } from "./cost.model";
+import { PaymentInstructionSchema } from "./payment.model";
+const OrderStatusSchema = z.enum(["AwaitingPayment", "ReleasedToFulfillment", "Shipped", "Cancelled"]).default("AwaitingPayment").describe("The current status of the order.");
+const OrderInventoryStatusSchema = z.enum(["NotAllocated", "Allocated", "Backordered", "Preordered"]).default("Allocated").describe("The inventory release status of the order.");
+const OrderItemSchema = z.looseObject({
+  identifier: CartItemIdentifierSchema.default(() => CartItemIdentifierSchema.parse({})),
+  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
+  quantity: z.number().default(0),
+  price: ItemCostBreakdownSchema.default(() => ItemCostBreakdownSchema.parse({})),
+  inventoryStatus: OrderInventoryStatusSchema.default("Allocated").describe("The inventory release status of the order item.")
+});
+const OrderSchema = BaseModelSchema.extend({
+  identifier: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({})),
+  userId: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
+  items: z.array(OrderItemSchema).default(() => []),
+  price: CostBreakDownSchema.default(() => CostBreakDownSchema.parse({})),
+  name: z.string().default(""),
+  description: z.string().default(""),
+  shippingAddress: AddressSchema.optional(),
+  billingAddress: AddressSchema.optional(),
+  shippingMethod: ShippingMethodSchema.optional(),
+  orderStatus: OrderStatusSchema.default("AwaitingPayment"),
+  inventoryStatus: OrderInventoryStatusSchema.default("Allocated"),
+  paymentInstructions: z.array(PaymentInstructionSchema).default(() => []),
+  cartReference: CartIdentifierSchema.optional().describe("Reference to the cart from which this order was created.")
+});
+export {
+  OrderInventoryStatusSchema,
+  OrderItemSchema,
+  OrderSchema,
+  OrderStatusSchema
+};

package/schemas/models/payment.model.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { BaseModelSchema, ImageSchema } from "./base.model";
-import { CartIdentifierSchema, PaymentInstructionIdentifierSchema, PaymentMethodIdentifierSchema } from "./identifiers.model";
+import { PaymentInstructionIdentifierSchema, PaymentMethodIdentifierSchema } from "./identifiers.model";
 import { MonetaryAmountSchema } from "./price.model";
 const PaymentStatusSchema = z.enum(["pending", "authorized", "canceled", "capture", "partial_capture", "refunded", "partial_refund"]);
 const PaymentProtocolDataSchema = z.looseObject({
@@ -20,16 +20,7 @@ const PaymentInstructionSchema = BaseModelSchema.extend({
   protocolData: z.array(PaymentProtocolDataSchema).default(() => []).describe("Additional protocol-specific data for processing the payment."),
   status: PaymentStatusSchema.default("pending")
 });
-const CartPaymentInstructionSchema = PaymentInstructionSchema.extend({
-  cart: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({}))
-});
-const OrderPaymentInstructionSchema = PaymentInstructionSchema.extend({
-  order: z.string().default("")
-  // OrderIdentifierSchema
-});
 export {
-  CartPaymentInstructionSchema,
-  OrderPaymentInstructionSchema,
   PaymentInstructionSchema,
   PaymentMethodSchema,
   PaymentProtocolDataSchema,

package/schemas/models/product.model.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
-import { ProductIdentifierSchema } from "./identifiers.model";
+import { ProductIdentifierSchema, SKUIdentifierSchema } from "./identifiers.model";
 import { BaseModelSchema } from "./base.model";
 const SKUSchema = z.looseObject({
-  identifier: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({}))
+  identifier: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({}))
+  /*    name: z.string().default(''),
+      slug: z.string().default(''),
+      image: ImageSchema.default(() => ImageSchema.parse({})), */
 });
 const ProductAttributeSchema = z.looseObject({
   id: z.string(),

package/schemas/models/profile.model.js

@@ -1,6 +1,7 @@
 import z from "zod";
 import { AddressIdentifierSchema, IdentityIdentifierSchema } from "./identifiers.model";
-const AddressSchema = z.looseObject({
+import { BaseModelSchema } from "./base.model";
+const AddressSchema = BaseModelSchema.extend({
   identifier: AddressIdentifierSchema.default(() => AddressIdentifierSchema.parse({})),
   firstName: z.string().default(""),
   lastName: z.string().default(""),
@@ -11,7 +12,7 @@ const AddressSchema = z.looseObject({
   postalCode: z.string().default(""),
   countryCode: z.string().default("US")
 });
-const ProfileSchema = z.looseObject({
+const ProfileSchema = BaseModelSchema.extend({
   identifier: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
   email: z.string().email().default(""),
   phone: z.string().default(""),

package/schemas/models/shipping-method.model.js

@@ -1,15 +1,37 @@
 import z from "zod";
-import { ShippingMethodIdentifier } from "./identifiers.model";
+import { ShippingMethodIdentifierSchema } from "./identifiers.model";
 import { MonetaryAmountSchema } from "./price.model";
-import { ImageSchema } from "./base.model";
+import { BaseModelSchema, ImageSchema } from "./base.model";
+import { AddressSchema } from "./profile.model";
+const PickupPointSchema = z.looseObject({
+  identifier: z.object({
+    key: z.string().default("").nonoptional()
+  }).default(() => ({ key: "" })),
+  name: z.string().default(""),
+  description: z.string().default(""),
+  address: AddressSchema.default(() => AddressSchema.parse({})),
+  openingHours: z.string().default("").optional().describe('The opening hours of the pickup point, if applicable. This could be a string like "Mon-Fri 9am-5pm".'),
+  contactPhone: z.string().default("").optional().describe("The contact phone number for the pickup point, if applicable."),
+  contactEmail: z.string().default("").optional().describe("The contact email for the pickup point, if applicable."),
+  instructions: z.string().default("").optional().describe("Any special instructions for picking up from this point.")
+});
 const ShippingMethodSchema = z.looseObject({
-  identifier: ShippingMethodIdentifier.default(() => ShippingMethodIdentifier.parse({})),
+  identifier: ShippingMethodIdentifierSchema.default(() => ShippingMethodIdentifierSchema.parse({})),
   name: z.string().default(""),
   description: z.string().default(""),
   logo: ImageSchema.optional(),
   price: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})),
-  deliveryTime: z.string().default("")
+  deliveryTime: z.string().default(""),
+  carrier: z.string().default("").optional()
+});
+const ShippingInstructionSchema = BaseModelSchema.extend({
+  shippingMethod: ShippingMethodIdentifierSchema.default(() => ShippingMethodIdentifierSchema.parse({})),
+  pickupPoint: z.string().default("").describe("An optional pickup point for the shipping method. This could be a physical store, a locker, or similar. If not set, it means home delivery to the shipping address."),
+  instructions: z.string().default("").describe("Optional instructions for the shipping. This could be delivery instructions, or similar."),
+  consentForUnattendedDelivery: z.boolean().default(false).describe("Indicates if the customer has given consent for unattended delivery, if applicable.")
 });
 export {
+  PickupPointSchema,
+  ShippingInstructionSchema,
   ShippingMethodSchema
 };

package/schemas/models/store.model.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import { BaseModelSchema } from "./base.model";
+import { FulfillmentCenterIdentifierSchema, StoreIdentifierSchema } from "./identifiers.model";
+const StoreSchema = BaseModelSchema.extend({
+  identifier: StoreIdentifierSchema.default(() => StoreIdentifierSchema.parse({})),
+  name: z.string().default(""),
+  fulfillmentCenter: FulfillmentCenterIdentifierSchema.default(() => FulfillmentCenterIdentifierSchema.parse({}))
+});
+export {
+  StoreSchema
+};

package/schemas/mutations/cart.mutation.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { BaseMutationSchema } from "./base.mutation";
-import { CartIdentifierSchema, CartItemIdentifierSchema, PaymentMethodIdentifierSchema, ShippingMethodIdentifier, SKUIdentifierSchema } from "../models/identifiers.model";
+import { CartIdentifierSchema, CartItemIdentifierSchema, PaymentMethodIdentifierSchema, ShippingMethodIdentifierSchema, SKUIdentifierSchema } from "../models/identifiers.model";
 import { AddressSchema } from "../models/profile.model";
 import { CurrencySchema } from "../models/currency.model";
 import { MonetaryAmountSchema } from "../models/price.model";
@@ -23,7 +23,7 @@ const CartMutationDeleteCartSchema = BaseMutationSchema.extend({
 });
 const CartMutationSetShippingInfoSchema = BaseMutationSchema.extend({
   cart: CartIdentifierSchema.required(),
-  shippingMethod: ShippingMethodIdentifier.optional(),
+  shippingMethod: ShippingMethodIdentifierSchema.optional(),
   shippingAddress: AddressSchema.optional()
 });
 const CartMutationSetBillingAddressSchema = BaseMutationSchema.extend({

package/schemas/mutations/checkout.mutation.js

@@ -0,0 +1,36 @@
+import z from "zod";
+import { CartIdentifierSchema, AddressSchema, PaymentInstructionIdentifierSchema, PaymentInstructionSchema, ShippingInstructionSchema } from "../models";
+import { BaseMutationSchema } from "./base.mutation";
+const CheckoutMutationInitiateCheckoutSchema = BaseMutationSchema.extend({
+  cart: CartIdentifierSchema.required(),
+  billingAddress: AddressSchema.omit({ identifier: true }).optional(),
+  notificationEmail: z.string().optional(),
+  notificationPhone: z.string().optional()
+});
+const CheckoutMutationSetShippingAddressSchema = BaseMutationSchema.extend({
+  checkout: CartIdentifierSchema.required(),
+  shippingAddress: AddressSchema.omit({ identifier: true }).required()
+});
+const CheckoutMutationFinalizeCheckoutSchema = BaseMutationSchema.extend({
+  checkout: CartIdentifierSchema.required()
+});
+const CheckoutMutationAddPaymentInstruction = BaseMutationSchema.extend({
+  paymentInstruction: PaymentInstructionSchema.omit({ meta: true, status: true, identifier: true }).required(),
+  checkout: CartIdentifierSchema.required()
+});
+const CheckoutMutationRemovePaymentInstruction = BaseMutationSchema.extend({
+  paymentInstruction: PaymentInstructionIdentifierSchema.required(),
+  checkout: CartIdentifierSchema.required()
+});
+const CheckoutMutationSetShippingInstruction = BaseMutationSchema.extend({
+  shippingInstruction: ShippingInstructionSchema.omit({ meta: true, status: true, identifier: true }).required(),
+  checkout: CartIdentifierSchema.required()
+});
+export {
+  CheckoutMutationAddPaymentInstruction,
+  CheckoutMutationFinalizeCheckoutSchema,
+  CheckoutMutationInitiateCheckoutSchema,
+  CheckoutMutationRemovePaymentInstruction,
+  CheckoutMutationSetShippingAddressSchema,
+  CheckoutMutationSetShippingInstruction
+};

package/schemas/mutations/identity.mutation.js

@@ -5,7 +5,12 @@ const IdentityMutationLoginSchema = BaseMutationSchema.extend({
   password: z.string()
 });
 const IdentityMutationLogoutSchema = BaseMutationSchema.extend({});
+const IdentityMutationRegisterSchema = BaseMutationSchema.extend({
+  username: z.string(),
+  password: z.string()
+});
 export {
   IdentityMutationLoginSchema,
-  IdentityMutationLogoutSchema
+  IdentityMutationLogoutSchema,
+  IdentityMutationRegisterSchema
 };

package/schemas/mutations/index.js

@@ -1,9 +1,10 @@
 export * from "./analytics.mutation";
 export * from "./base.mutation";
-export * from "./cart-payment.mutation";
 export * from "./cart.mutation";
 export * from "./identity.mutation";
 export * from "./inventory.mutation";
 export * from "./price.mutation";
 export * from "./product.mutation";
+export * from "./profile.mutation";
 export * from "./search.mutation";
+export * from "./checkout.mutation";

package/schemas/mutations/profile.mutation.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import { BaseMutationSchema } from "./base.mutation";
+const ProfileMutationUpdateSchema = BaseMutationSchema.extend({
+  email: z.email().default("base@example.com"),
+  phone: z.string().default("")
+});
+export {
+  ProfileMutationUpdateSchema
+};

package/schemas/queries/checkout.query.js

@@ -0,0 +1,16 @@
+import { BaseQuerySchema } from "./base.query";
+import { CheckoutIdentifierSchema } from "../models/identifiers.model";
+const CheckoutQueryByIdSchema = BaseQuerySchema.extend({
+  identifier: CheckoutIdentifierSchema.required()
+});
+const CheckoutQueryForAvailableShippingMethodsSchema = BaseQuerySchema.extend({
+  checkout: CheckoutIdentifierSchema.required()
+});
+const CheckoutQueryForAvailablePaymentMethodsSchema = BaseQuerySchema.extend({
+  checkout: CheckoutIdentifierSchema.required()
+});
+export {
+  CheckoutQueryByIdSchema,
+  CheckoutQueryForAvailablePaymentMethodsSchema,
+  CheckoutQueryForAvailableShippingMethodsSchema
+};

package/schemas/queries/index.js

@@ -1,10 +1,13 @@
 export * from "./analytics.query";
 export * from "./base.query";
-export * from "./cart-payment.query";
 export * from "./cart.query";
 export * from "./category.query";
 export * from "./identity.query";
 export * from "./inventory.query";
 export * from "./price.query";
 export * from "./product.query";
+export * from "./profile.query";
 export * from "./search.query";
+export * from "./store.query";
+export * from "./order.query";
+export * from "./checkout.query";

package/schemas/queries/inventory.query.js

@@ -1,11 +1,9 @@
-import { z } from "zod";
 import { BaseQuerySchema } from "./base.query";
-import { ProductIdentifierSchema } from "../models/identifiers.model";
+import { FulfillmentCenterIdentifierSchema, ProductIdentifierSchema } from "../models/identifiers.model";
 const InventoryQueryBySKUSchema = BaseQuerySchema.extend({
-  query: z.literal("sku"),
-  sku: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({}))
+  sku: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})).nonoptional(),
+  fulfilmentCenter: FulfillmentCenterIdentifierSchema.default(() => FulfillmentCenterIdentifierSchema.parse({})).nonoptional()
 });
-;
 export {
   InventoryQueryBySKUSchema
 };

package/schemas/queries/order.query.js

@@ -0,0 +1,8 @@
+import { BaseQuerySchema } from "./base.query";
+import { OrderIdentifierSchema } from "../models/identifiers.model";
+const OrderQueryByIdSchema = BaseQuerySchema.extend({
+  order: OrderIdentifierSchema.required()
+});
+export {
+  OrderQueryByIdSchema
+};

package/schemas/queries/product.query.js

@@ -1,12 +1,17 @@
 import { z } from "zod";
 import { BaseQuerySchema } from "./base.query";
+import { SKUIdentifierSchema } from "../models";
 const ProductQueryBySlugSchema = BaseQuerySchema.extend({
   slug: z.string()
 });
 const ProductQueryByIdSchema = BaseQuerySchema.extend({
   id: z.string()
 });
+const ProductQueryBySKUSchema = BaseQuerySchema.extend({
+  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({}))
+});
 export {
   ProductQueryByIdSchema,
+  ProductQueryBySKUSchema,
   ProductQueryBySlugSchema
 };

package/schemas/queries/profile.query.js

@@ -0,0 +1,5 @@
+import { BaseQuerySchema } from "./base.query";
+const ProfileQuerySelfSchema = BaseQuerySchema.extend({});
+export {
+  ProfileQuerySelfSchema
+};

package/schemas/queries/store.query.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import { BaseQuerySchema } from "./base.query";
+const StoreQueryByProximitySchema = BaseQuerySchema.extend({
+  longitude: z.number().default(0),
+  latitude: z.number().default(0),
+  distance: z.number().default(0),
+  limit: z.number().default(10)
+});
+export {
+  StoreQueryByProximitySchema
+};

package/schemas/session.schema.js

@@ -4,16 +4,30 @@ import { WebStoreIdentifierSchema } from "./models/identifiers.model";
 import { CurrencySchema } from "./models/currency.model";
 const LanguageContextSchema = z.looseObject({
   locale: z.string().default("en-US"),
-  currencyCode: CurrencySchema.default(() => CurrencySchema.parse({})),
-  countryCode: z.string().default("US")
+  currencyCode: CurrencySchema.default(() => CurrencySchema.parse({}))
 });
-const SessionSchema = z.looseObject({
-  id: z.string(),
-  identity: IdentitySchema.default(() => IdentitySchema.parse({})),
-  languageContext: LanguageContextSchema.default(() => LanguageContextSchema.parse({})),
-  storeIdentifier: WebStoreIdentifierSchema.default(() => WebStoreIdentifierSchema.parse({}))
+const SessionSchema = z.record(z.string(), z.any());
+const TaxJurisdictionSchema = z.object({
+  countryCode: z.string().default("US"),
+  stateCode: z.string().default(""),
+  countyCode: z.string().default(""),
+  cityCode: z.string().default("")
+});
+const RequestContextSchema = z.looseObject({
+  identity: IdentitySchema.default(() => IdentitySchema.parse({})).describe("Read/Write. The identity of the current user. Caller is responsible for persisting any changes to the identity"),
+  session: SessionSchema.default(() => SessionSchema.parse({})).describe("Read/Write session storage. Caller is responsible for persisting any changes. Providers will prefix own values"),
+  languageContext: LanguageContextSchema.default(() => LanguageContextSchema.parse({})).describe("ReadOnly. The language and locale context for the current request."),
+  storeIdentifier: WebStoreIdentifierSchema.default(() => WebStoreIdentifierSchema.parse({})).describe("ReadOnly. The identifier of the current web store making the request."),
+  taxJurisdiction: TaxJurisdictionSchema.default(() => TaxJurisdictionSchema.parse({})).describe("ReadOnly. The tax jurisdiction for the current request, typically derived from the store location or carts billing address"),
+  correlationId: z.string().default("").describe("A unique identifier for the request, can be used for tracing and logging purposes."),
+  isBot: z.boolean().default(false).describe("Indicates if the request is made by a bot or crawler."),
+  clientIp: z.string().default("").describe("The IP address of the client making the request, if available. Mostly for logging purposes"),
+  userAgent: z.string().default("").describe("The user agent string of the client making the request, if available."),
+  referrer: z.string().default("").describe("The referrer URL, if available.")
 });
 export {
   LanguageContextSchema,
-  SessionSchema
+  RequestContextSchema,
+  SessionSchema,
+  TaxJurisdictionSchema
 };

package/src/cache/cache.interface.d.ts

@@ -1,4 +1,9 @@
-import { z } from 'zod';
+import type { z } from 'zod';
+import type { BaseModel } from '../schemas/models';
+export interface CacheEntryOptions {
+    ttlSeconds: number;
+    dependencyIds: Array<string>;
+}
 /**
  * Generic cache interface that can be implemented by different cache backends
  * (Redis, memory, file-based, etc.)
@@ -7,30 +12,18 @@ export interface Cache {
     /**
      * Retrieves a value from cache and validates it against the provided schema
      */
-    get<T>(key: string, schema: z.ZodType<T>): Promise<T | null>;
+    get<T extends BaseModel>(key: string, schema: z.ZodType<T>): Promise<T | null>;
     /**
      * Stores a value in cache with optional expiration time
      */
-    put(key: string, value: unknown, ttlSeconds?: number): Promise<void>;
-    /**
-     * Removes one or more keys from cache
-     * Supports wildcard patterns (implementation dependent)
-     */
-    del(keys: string | string[]): Promise<void>;
-    /**
-     * Finds all keys matching a pattern (implementation dependent)
-     */
-    keys(pattern: string): Promise<string[]>;
+    put(key: string, value: unknown, options: CacheEntryOptions): Promise<void>;
     /**
-     * Clears all cache entries or entries matching a pattern
+     * Removes entries from the cache based on a set of dependency
+     * ids
      */
-    clear(pattern?: string): Promise<void>;
+    invalidate(dependencyIds: Array<string>): Promise<void>;
     /**
-     * Gets basic cache statistics (implementation dependent)
+     * Removes all entries from cache, wiping it completely
      */
-    getStats(): Promise<{
-        hits: number;
-        misses: number;
-        size: number;
-    }>;
+    clear(): Promise<void>;
 }

package/src/cache/memory-cache.d.ts

@@ -0,0 +1,18 @@
+import type { BaseModel } from '../schemas/models';
+import type { Cache, CacheEntryOptions } from './cache.interface';
+import type z from 'zod';
+/**
+ * Memory version of the cache. Primarily useful for local development.
+ * This is NOT suited for production use.
+ */
+export declare class MemoryCache implements Cache {
+    protected entries: {
+        key: string;
+        value: unknown;
+        options: CacheEntryOptions;
+    }[];
+    get<T extends BaseModel>(key: string, schema: z.ZodType<T>): Promise<T | null>;
+    put(key: string, value: unknown, options: CacheEntryOptions): Promise<void>;
+    invalidate(dependencyIds: Array<string>): Promise<void>;
+    clear(): Promise<void>;
+}

package/src/cache/noop-cache.d.ts

@@ -1,18 +1,12 @@
-import { Cache } from './cache.interface';
-import z from 'zod';
+import type { Cache, CacheEntryOptions } from './cache.interface';
+import type z from 'zod';
 /**
  * No-op cache implementation that never stores or returns data.
  * Useful for testing or when caching should be disabled.
  */
 export declare class NoOpCache implements Cache {
     get<T>(_key: string, _schema: z.ZodType<T>): Promise<T | null>;
-    put(_key: string, _value: unknown, _ttlSeconds?: number): Promise<void>;
-    del(_keys: string | string[]): Promise<void>;
-    keys(_pattern: string): Promise<string[]>;
-    clear(_pattern?: string): Promise<void>;
-    getStats(): Promise<{
-        hits: number;
-        misses: number;
-        size: number;
-    }>;
+    put(_key: string, _value: unknown, options: CacheEntryOptions): Promise<void>;
+    invalidate(dependencyIds: Array<string>): Promise<void>;
+    clear(): Promise<void>;
 }

package/src/cache/redis-cache.d.ts

@@ -1,17 +1,11 @@
 import { Redis } from '@upstash/redis';
-import { Cache } from './cache.interface';
-import z from 'zod';
+import type { Cache, CacheEntryOptions } from './cache.interface';
+import type z from 'zod';
 export declare class RedisCache implements Cache {
     protected redis: Redis;
     constructor();
     get<T>(key: string, schema: z.ZodType<T>): Promise<T | null>;
-    put(key: string, value: unknown, ttlSeconds?: number): Promise<void>;
-    del(keys: string | string[]): Promise<void>;
-    keys(pattern: string): Promise<string[]>;
-    clear(pattern?: string): Promise<void>;
-    getStats(): Promise<{
-        hits: number;
-        misses: number;
-        size: number;
-    }>;
+    put(key: string, value: unknown, options: CacheEntryOptions): Promise<void>;
+    invalidate(dependencyIds: Array<string>): Promise<void>;
+    clear(): Promise<void>;
 }

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

@@ -1,5 +1,5 @@
-import { Cache } from "../cache/cache.interface";
-import { Client } from "./client";
+import type { Cache } from "../cache/cache.interface";
+import type { Client } from "./client";
 type CapabilityFactory<T> = (cache: Cache) => T;
 type MergeCapabilities<Acc, New> = Omit<Acc, keyof New> & New;
 export declare class ClientBuilder<TClient = object> {

package/src/client/client.d.ts

@@ -1,20 +1,20 @@
-import { AnalyticsProvider } from "../providers/analytics.provider";
-import { ProductProvider } from "../providers/product.provider";
-import { SearchProvider } from "../providers/search.provider";
-import { IdentityProvider } from '../providers/identity.provider';
-import { CartProvider } from "../providers/cart.provider";
-import { PriceProvider } from "../providers/price.provider";
-import { InventoryProvider } from "../providers/inventory.provider";
-import { Cache } from "../cache/cache.interface";
-import { CategoryProvider } from "../providers/category.provider";
-import { CartPaymentProvider } from "../providers";
+import type { AnalyticsProvider } from "../providers/analytics.provider";
+import type { ProductProvider } from "../providers/product.provider";
+import type { SearchProvider } from "../providers/search.provider";
+import type { IdentityProvider } from '../providers/identity.provider';
+import type { CartProvider } from "../providers/cart.provider";
+import type { PriceProvider } from "../providers/price.provider";
+import type { InventoryProvider } from "../providers/inventory.provider";
+import type { Cache } from "../cache/cache.interface";
+import type { CategoryProvider } from "../providers/category.provider";
+import type { CheckoutProvider } from "../providers";
 export interface Client {
     product: ProductProvider;
     search: SearchProvider;
     identity: IdentityProvider;
     cache: Cache;
     cart: CartProvider;
-    cartPayment: CartPaymentProvider;
+    checkout: CheckoutProvider;
     analytics: Array<AnalyticsProvider>;
     price: PriceProvider;
     inventory: InventoryProvider;

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

@@ -1 +1,34 @@
-export declare function Reactionary(options: unknown): MethodDecorator;
+import type { BaseProvider } from '../providers';
+/**
+ * The options associated with annotating a provider function and marking
+ * it as a reactionary entrypoint to be called
+ */
+export declare class ReactionaryDecoratorOptions {
+    /**
+     * Whether or not the query is eligible for caching. Queries that depend
+     * heavily on personalization, for example, are likely to be a poor fit
+     * for caching.
+     */
+    cache: boolean;
+    /**
+     * Whether or not the cache entry should be variable based on the locale
+     * of the context in which it is querried.
+     */
+    localeDependentCaching: boolean;
+    /**
+     * Whether or not the cache entry should be variable based on the currency
+     * of the context in which it is querried.
+     */
+    currencyDependentCaching: boolean;
+    /**
+     * The number of seconds which a cache entry should be considered valid for the
+     * given query.
+     */
+    cacheTimeToLiveInSeconds: number;
+}
+/**
+ * Decorator for provider 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.
+ */
+export declare function Reactionary(options: Partial<ReactionaryDecoratorOptions>): (target: BaseProvider, propertyKey: string | symbol, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/src/index.d.ts

@@ -1,6 +1,6 @@
 export * from './cache/cache.interface';
-export * from './cache/cache-evaluation.interface';
 export * from './cache/redis-cache';
+export * from './cache/memory-cache';
 export * from './cache/noop-cache';
 export * from './client/client';
 export * from './client/client-builder';
@@ -11,3 +11,4 @@ export * from './schemas/session.schema';
 export * from './schemas/models/';
 export * from './schemas/mutations/';
 export * from './schemas/queries';
+export * from './initialization';

package/src/initialization.d.ts

@@ -0,0 +1,2 @@
+import type { RequestContext } from "./schemas/session.schema";
+export declare function createInitialRequestContext(): RequestContext;

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

@@ -1,4 +1,4 @@
-import { AnalyticsEvent } from '../schemas/models/analytics.model';
+import type { AnalyticsEvent } from '../schemas/models/analytics.model';
 import { BaseProvider } from './base.provider';
 export declare abstract class AnalyticsProvider<T extends AnalyticsEvent = AnalyticsEvent> extends BaseProvider<T> {
     protected getResourceName(): string;