@reactionary/source 0.0.30 → 0.0.31

package/CLAUDE.md

@@ -0,0 +1,11 @@
+# Verification commands
+- `npx nx affected:build` builds the projects affected by current changes.
+- `npx nx affected:lint` lints and verifies the projects affected by current changes.
+
+# Code style
+- Use ES modules (import/export) syntax, not CommonJS (require).
+- Keep things strongly typed. Do not use `as any` or similar unchecked type casts.
+
+# Workflow
+- Be sure to ensure that changes lint and build.
+- Avoid introducing changes that would be breaking for any client consumer of the library without asking for clearance.

package/core/src/cache/cache-evaluation.interface.ts

@@ -0,0 +1,19 @@
+/**
+ * Cache evaluation result that determines how and if a query should be cached
+ */
+export interface CacheEvaluation {
+  /**
+   * The cache key to use for storing/retrieving the value
+   */
+  key: string;
+  
+  /**
+   * How long to cache the value in seconds
+   */
+  cacheDurationInSeconds: number;
+  
+  /**
+   * Whether this query result can be cached
+   */
+  canCache: boolean;
+}

package/core/src/cache/cache.interface.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+
+/**
+ * Generic cache interface that can be implemented by different cache backends
+ * (Redis, memory, file-based, etc.)
+ */
+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>;
+
+  /**
+   * 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[]>;
+
+  /**
+   * Clears all cache entries or entries matching a pattern
+   */
+  clear(pattern?: string): Promise<void>;
+
+  /**
+   * Gets basic cache statistics (implementation dependent)
+   */
+  getStats(): Promise<{ hits: number; misses: number; size: number }>;
+}

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

@@ -0,0 +1,42 @@
+import { Cache } from './cache.interface';
+import z from 'zod';
+
+/**
+ * No-op cache implementation that never stores or returns data.
+ * Useful for testing or when caching should be disabled.
+ */
+export class NoOpCache implements Cache {
+  public async get<T>(_key: string, _schema: z.ZodType<T>): Promise<T | null> {
+    // Always return null - never a cache hit
+    return null;
+  }
+
+  public async put(_key: string, _value: unknown, _ttlSeconds?: number): Promise<void> {
+    // No-op - silently ignore cache write requests
+    return;
+  }
+
+  public async del(_keys: string | string[]): Promise<void> {
+    // No-op - silently ignore delete requests
+    return;
+  }
+
+  public async keys(_pattern: string): Promise<string[]> {
+    // Always return empty array
+    return [];
+  }
+
+  public async clear(_pattern?: string): Promise<void> {
+    // No-op - silently ignore clear requests
+    return;
+  }
+
+  public async getStats(): Promise<{ hits: number; misses: number; size: number }> {
+    // Always return zeros
+    return {
+      hits: 0,
+      misses: 0,
+      size: 0
+    };
+  }
+}

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

@@ -1,41 +1,74 @@
 import { Redis } from '@upstash/redis';
-import { CachingStrategy } from './caching-strategy';
-import { BaseQuery } from '../schemas/queries/base.query';
-import { Session } from '../schemas/session.schema';
-import { BaseModel } from '../schemas/models/base.model';
+import { Cache } from './cache.interface';
 import z from 'zod';
 
-export class RedisCache {
-  protected strategy: CachingStrategy;
+export class RedisCache implements Cache {
   protected redis: Redis;
 
-  constructor(strategy: CachingStrategy) {
-    this.strategy = strategy;
+  constructor() {
     this.redis = Redis.fromEnv();
   }
 
-  public async get<T extends BaseModel>(query: BaseQuery, session: Session, schema: z.ZodType<T>): Promise<T | null> {
-    let result = null;
+  public async get<T>(key: string, schema: z.ZodType<T>): Promise<T | null> {
+    if (!key) {
+      return null;
+    }
     
-    const cacheInformation = this.strategy.get(query, session);
+    const unvalidated = await this.redis.get(key);
+    const parsed = schema.safeParse(unvalidated);
+
+    if (parsed.success) {
+      return parsed.data;
+    }
     
-    if (cacheInformation.canCache && cacheInformation.key) {
-      const unvalidated = await this.redis.get(cacheInformation.key);
-      const parsed = schema.safeParse(unvalidated);
+    return null;
+  }
 
-      if (parsed.success) {
-        result = parsed.data;
-      }
+  public async put(key: string, value: unknown, ttlSeconds?: number): Promise<void> {
+    if (!key) {
+      return;
     }
+
+    const options = ttlSeconds ? { ex: ttlSeconds } : undefined;
+    await this.redis.set(key, value, options);
+  }
+
+  public async del(keys: string | string[]): Promise<void> {
+    const keyArray = Array.isArray(keys) ? keys : [keys];
     
-    return result;
+    for (const key of keyArray) {
+      if (key.includes('*')) {
+        // Handle wildcard patterns
+        const matchingKeys = await this.redis.keys(key);
+        if (matchingKeys.length > 0) {
+          await this.redis.del(...matchingKeys);
+        }
+      } else {
+        // Delete specific key
+        await this.redis.del(key);
+      }
+    }
   }
 
-  public put(query: BaseQuery, session: Session, value: unknown): void {
-    const cacheInformation = this.strategy.get(query, session);
+  public async keys(pattern: string): Promise<string[]> {
+    return await this.redis.keys(pattern);
+  }
 
-    if (cacheInformation.canCache && cacheInformation.key) {
-      this.redis.set(cacheInformation.key, value, { ex: cacheInformation.cacheDurationInSeconds });
+  public async clear(pattern?: string): Promise<void> {
+    const searchPattern = pattern || '*';
+    const keys = await this.redis.keys(searchPattern);
+    if (keys.length > 0) {
+      await this.redis.del(...keys);
     }
   }
+
+  public async getStats(): Promise<{ hits: number; misses: number; size: number }> {
+    // Basic cache statistics (could be enhanced with actual Redis metrics)
+    const keys = await this.redis.keys('*');
+    return {
+      hits: 0, // Would need to track this separately
+      misses: 0, // Would need to track this separately  
+      size: keys.length
+    };
+  }
 }

package/core/src/client/client.ts

@@ -5,6 +5,8 @@ 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 { RedisCache } from "../cache/redis-cache";
 
 export interface Client {
     product: ProductProvider,
@@ -17,12 +19,23 @@ export interface Client {
     inventory: InventoryProvider
 }
 
-export function buildClient<T extends Partial<Client>>(providers: Array<T>): Required<T> {
+export interface BuildClientOptions {
+    cache?: Cache;
+}
+
+export function buildClient<T extends Partial<Client>>(
+    providerFactories: Array<(cache: Cache) => T>,
+    options: BuildClientOptions = {}
+): Required<T> {
     let client = { } as Required<T>;
 
+    // Create shared cache instance
+    const sharedCache = options.cache || new RedisCache();
+
     const mergedAnalytics = [];
 
-    for (const provider of providers) {
+    for (const factory of providerFactories) {
+        const provider = factory(sharedCache);
         client = {
             ...client,
             ...provider
@@ -34,6 +47,17 @@ export function buildClient<T extends Partial<Client>>(providers: Array<T>): Req
     }
 
     client.analytics = mergedAnalytics;
+    
+    // Add cache to complete the client
+    const completeClient = {
+        ...client,
+        cache: sharedCache
+    } as Required<T>;
+
+    return completeClient;
+}
 
-    return client satisfies T;
+// Convenience function to create a shared cache instance
+export function createCache(): Cache {
+    return new RedisCache();
 }

package/core/src/index.ts

@@ -1,5 +1,7 @@
-export * from './cache/caching-strategy';
+export * from './cache/cache.interface';
+export * from './cache/cache-evaluation.interface';
 export * from './cache/redis-cache';
+export * from './cache/noop-cache';
 
 export * from './client/client';
 

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

@@ -2,9 +2,32 @@ import { AnalyticsEvent } from '../schemas/models/analytics.model';
 import { AnalyticsMutation } from '../schemas/mutations/analytics.mutation';
 import { AnalyticsQuery } from '../schemas/queries/analytics.query';
 import { BaseProvider } from './base.provider';
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import { Session } from '../schemas/session.schema';
+import * as crypto from 'crypto';
 
 export abstract class AnalyticsProvider<
   T extends AnalyticsEvent = AnalyticsEvent,
   Q extends AnalyticsQuery = AnalyticsQuery,
   M extends AnalyticsMutation = AnalyticsMutation
-> extends BaseProvider<T, Q, M> {}
+> extends BaseProvider<T, Q, M> {
+  
+  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
+    const providerName = this.constructor.name.toLowerCase();
+    
+    // Hash analytics query parameters
+    const relevantFields = {
+      type: typeof query === 'object' && query !== null && 'type' in query ? (query as any).type : undefined,
+      dateRange: typeof query === 'object' && query !== null && 'dateRange' in query ? (query as any).dateRange : undefined,
+      filters: typeof query === 'object' && query !== null && 'filters' in query ? (query as any).filters : undefined
+    };
+    const analyticsHash = crypto.createHash('md5').update(JSON.stringify(relevantFields)).digest('hex').substring(0, 12);
+    const key = `${providerName}:analytics:${analyticsHash}`;
+    
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
+}

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

@@ -4,6 +4,9 @@ import { BaseQuery } from '../schemas/queries/base.query';
 import { BaseMutation } from '../schemas/mutations/base.mutation';
 import { BaseModel } from '../schemas/models/base.model';
 import { createProviderInstrumentation } from '@reactionary/otel';
+import { Cache } from '../cache/cache.interface';
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import * as crypto from 'crypto';
 
 /**
  * Base capability provider, responsible for mutations (changes) and queries (fetches)
@@ -14,10 +17,17 @@ export abstract class BaseProvider<
   Q extends BaseQuery = BaseQuery,
   M extends BaseMutation = BaseMutation
 > {
-  private instrumentation: ReturnType<typeof createProviderInstrumentation>;
+  protected instrumentation: ReturnType<typeof createProviderInstrumentation>;
+  protected cache: Cache;
   
-  constructor(public readonly schema: z.ZodType<T>, public readonly querySchema: z.ZodType<Q, Q>, public readonly mutationSchema: z.ZodType<M, M>) {
+  constructor(
+    public readonly schema: z.ZodType<T>, 
+    public readonly querySchema: z.ZodType<Q, Q>, 
+    public readonly mutationSchema: z.ZodType<M, M>,
+    cache: Cache
+  ) {
     this.instrumentation = createProviderInstrumentation(this.constructor.name);
+    this.cache = cache;
   }
 
   /**
@@ -46,13 +56,60 @@ export abstract class BaseProvider<
       'query',
       async (span) => {
         span.setAttribute('provider.query.count', queries.length);
-        const results = await this.fetch(queries, session);
+        
+        let cacheHits = 0;
+        let cacheMisses = 0;
+        const results: T[] = [];
 
-        for (const result of results) {
-          this.assert(result);
+        // Process each query individually for cache efficiency
+        for (const query of queries) {
+          let result: T | null = null;
+          
+          // Get cache evaluation from provider
+          const cacheInfo = this.getCacheEvaluation(query, session);
+          
+          // Try cache first if caching is enabled
+          if (cacheInfo.canCache && cacheInfo.key) {
+            try {
+              result = await this.cache.get(cacheInfo.key, this.schema);
+              if (result) {
+                cacheHits++;
+                span.setAttribute('provider.cache.hit', true);
+              }
+            } catch (error) {
+              // Cache error shouldn't break the query - log and continue
+              console.warn(`Cache get error for ${this.constructor.name}:`, error);
+            }
+          }
+          
+          // If not in cache, fetch from source
+          if (!result) {
+            const singleResult = await this.fetch([query], session);
+            result = singleResult[0];
+            cacheMisses++;
+            
+            // Store in cache if caching is enabled
+            if (result && cacheInfo.canCache && cacheInfo.key) {
+              try {
+                await this.cache.put(cacheInfo.key, result, cacheInfo.cacheDurationInSeconds);
+              } catch (error) {
+                // Cache put error shouldn't break the query - log and continue
+                console.warn(`Cache put error for ${this.constructor.name}:`, error);
+              }
+            }
+          }
+          
+          if (result) {
+            this.assert(result);
+            results.push(result);
+          }
         }
 
         span.setAttribute('provider.result.count', results.length);
+        span.setAttribute('provider.cache.hits', cacheHits);
+        span.setAttribute('provider.cache.misses', cacheMisses);
+        span.setAttribute('provider.cache.hit_ratio', cacheHits / (cacheHits + cacheMisses));
+        
         return results;
       },
       { queryCount: queries.length }
@@ -68,8 +125,9 @@ export abstract class BaseProvider<
       'mutate',
       async (span) => {
         span.setAttribute('provider.mutation.count', mutations.length);
+        
+        // Perform the mutation
         const result = await this.process(mutations, session);
-
         this.assert(result);
 
         return result;
@@ -92,4 +150,24 @@ export abstract class BaseProvider<
     mutations: M[],
     session: Session
   ): Promise<T>;
+
+  /**
+   * Provider-specific cache evaluation logic.
+   * Returns information about how this query should be cached.
+   * Override this method to enable caching with custom keys and TTL.
+   * Default implementation returns no caching.
+   */
+  protected getCacheEvaluation(query: Q, session: Session): CacheEvaluation {
+    // Default implementation: generate a cache key but don't cache
+    const providerName = this.constructor.name.toLowerCase();
+    const userId = session.identity?.id || 'anonymous';
+    const queryHash = crypto.createHash('md5').update(JSON.stringify(query)).digest('hex').substring(0, 12);
+    const key = `${providerName}:${userId}:${queryHash}`;
+    
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
 }

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

@@ -2,9 +2,26 @@ import { CartQuery } from "../schemas/queries/cart.query";
 import { CartMutation } from "../schemas/mutations/cart.mutation";
 import { BaseProvider } from "./base.provider";
 import { Cart } from "../schemas/models/cart.model";
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import { Session } from '../schemas/session.schema';
+import * as crypto from 'crypto';
 
 export abstract class CartProvider<
   T extends Cart = Cart,
   Q extends CartQuery = CartQuery,
   M extends CartMutation = CartMutation
-> extends BaseProvider<T, Q, M> {}
+> extends BaseProvider<T, Q, M> {
+  
+  protected override getCacheEvaluation(query: Q, session: Session): CacheEvaluation {
+    const providerName = this.constructor.name.toLowerCase();
+    const userId = session.identity?.id || 'anonymous';
+    const queryHash = crypto.createHash('md5').update(JSON.stringify(query)).digest('hex').substring(0, 12);
+    const key = `${providerName}:cart:${userId}:${queryHash}`;
+    
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
+}

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

@@ -2,9 +2,26 @@ import { Identity } from "../schemas/models/identity.model";
 import { IdentityQuery } from "../schemas/queries/identity.query";
 import { IdentityMutation } from "../schemas/mutations/identity.mutation";
 import { BaseProvider } from "./base.provider";
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import { Session } from '../schemas/session.schema';
 
 export abstract class IdentityProvider<
   T extends Identity = Identity,
   Q extends IdentityQuery = IdentityQuery,
   M extends IdentityMutation = IdentityMutation
-> extends BaseProvider<T, Q, M> {}
+> extends BaseProvider<T, Q, M> {
+  
+  protected override getCacheEvaluation(_query: Q, session: Session): CacheEvaluation {
+    const providerName = this.constructor.name.toLowerCase();
+    const userId = session.identity?.id;
+    const key = userId 
+      ? `${providerName}:identity:${userId}`
+      : `${providerName}:identity:anonymous`;
+    
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
+}

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

@@ -1,11 +1,24 @@
-import z from 'zod';
 import { Inventory } from '../schemas/models/inventory.model';
 import { InventoryQuery } from '../schemas/queries/inventory.query';
 import { InventoryMutation } from '../schemas/mutations/inventory.mutation';
 import { BaseProvider } from './base.provider';
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import { Session } from '../schemas/session.schema';
 
 export abstract class InventoryProvider<
   T extends Inventory = Inventory,
   Q extends InventoryQuery = InventoryQuery,
   M extends InventoryMutation = InventoryMutation
-> extends BaseProvider<T, Q, M> {}
+> extends BaseProvider<T, Q, M> {
+  
+  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
+    const providerName = this.constructor.name.toLowerCase();
+    const key = `${providerName}:inventory:${query.sku}`;
+    
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
+}

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

@@ -2,9 +2,26 @@ import { Price } from '../schemas/models/price.model';
 import { PriceMutation } from '../schemas/mutations/price.mutation';
 import { PriceQuery } from '../schemas/queries/price.query';
 import { BaseProvider } from './base.provider';
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import { Session } from '../schemas/session.schema';
+import * as crypto from 'crypto';
 
 export abstract class PriceProvider<
   T extends Price = Price,
   Q extends PriceQuery = PriceQuery,
   M extends PriceMutation = PriceMutation
-> extends BaseProvider<T, Q, M> {}
+> extends BaseProvider<T, Q, M> {
+  
+  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
+    const providerName = this.constructor.name.toLowerCase();
+    // Hash complex SKU objects (price queries with currency, customer group, etc.)
+    const skuHash = crypto.createHash('md5').update(JSON.stringify(query.sku)).digest('hex').substring(0, 12);
+    const key = `${providerName}:price:${skuHash}`;
+    
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
+}

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

@@ -1,11 +1,34 @@
 import { Product } from '../schemas/models/product.model';
 import { ProductMutation } from '../schemas/mutations/product.mutation';
-import { ProductQuery } from '../schemas/queries/product.query';
+import { ProductQuery, ProductQueryById, ProductQueryBySlug } from '../schemas/queries/product.query';
 import { BaseProvider } from './base.provider';
+import { Session } from '../schemas/session.schema';
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import * as crypto from 'crypto';
 
 export abstract class ProductProvider<
   T extends Product = Product,
   Q extends ProductQuery = ProductQuery,
   M extends ProductMutation = ProductMutation
 > extends BaseProvider<T, Q, M> {
+  
+  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
+    const providerName = this.constructor.name.toLowerCase();
+    
+    let key: string;
+    if (query.query === 'slug') {
+      key = `${providerName}:product:slug:${(query as ProductQueryBySlug).slug}`;
+    } else if (query.query === 'id') {
+      key = `${providerName}:product:id:${(query as ProductQueryById).id}`;
+    } else {
+      const queryHash = crypto.createHash('md5').update(JSON.stringify(query)).digest('hex').substring(0, 12);
+      key = `${providerName}:product:${queryHash}`;
+    }
+    
+    return {
+      key,
+      cacheDurationInSeconds: 300, // Products are moderately stable - 5 minutes
+      canCache: true
+    };
+  }
 }

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

@@ -2,11 +2,28 @@ import { SearchResult } from '../schemas/models/search.model';
 import { SearchQuery } from '../schemas/queries/search.query';
 import { SearchMutation } from '../schemas/mutations/search.mutation';
 import { BaseProvider } from './base.provider';
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import { Session } from '../schemas/session.schema';
+import * as crypto from 'crypto';
 
 export abstract class SearchProvider<
   T extends SearchResult = SearchResult,
   Q extends SearchQuery = SearchQuery,
   M extends SearchMutation = SearchMutation
-> extends BaseProvider<T, Q, M> {}
+> extends BaseProvider<T, Q, M> {
+  
+  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
+    const providerName = this.constructor.name.toLowerCase();
+    // Hash search parameters (term, filters, pagination, etc.)
+    const searchHash = crypto.createHash('md5').update(JSON.stringify(query.search)).digest('hex').substring(0, 12);
+    const key = `${providerName}:search:${searchHash}`;
+    
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
+}
 
 

package/core/src/schemas/mutations/product.mutation.ts

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { BaseMutationSchema } from './base.mutation';
 
 export const ProductMutationSchema = z.union([]);
 

package/examples/node/src/providers/custom-algolia-product.provider.ts

@@ -3,8 +3,8 @@ import { CustomProduct, CustomProductSchema } from '../schemas/custom-product.sc
 import { ProductMutationSchema, ProductQuerySchema } from '@reactionary/core';
 
 export class CustomAlgoliaProductProvider extends AlgoliaProductProvider<CustomProduct> {    
-    constructor(config: AlgoliaConfiguration) {
-        super(config, CustomProductSchema, ProductQuerySchema, ProductMutationSchema);
+    constructor(config: AlgoliaConfiguration, cache: any) {
+        super(config, CustomProductSchema, ProductQuerySchema, ProductMutationSchema, cache);
       }
     
     public parse(data: any): CustomProduct {

package/examples/trpc-node/src/router-instance.ts

@@ -1,4 +1,4 @@
-import { buildClient } from "@reactionary/core";
+import { buildClient, NoOpCache } from "@reactionary/core";
 import { withAlgoliaCapabilities } from "@reactionary/provider-algolia";
 import { withCommercetoolsCapabilities } from "@reactionary/provider-commercetools";
 import { withFakeCapabilities } from "@reactionary/provider-fake";
@@ -45,7 +45,9 @@ export const client = buildClient([
     },
     { analytics: true }
   ),
-]);
+], {
+  cache: new NoOpCache()
+});
 
 export const mergedRouter = createTRPCRouter(client);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/source",
-  "version": "0.0.30",
+  "version": "0.0.31",
   "license": "MIT",
   "private": false,
   "dependencies": {

package/providers/algolia/src/core/initialize.ts

@@ -1,4 +1,4 @@
-import { Client, ProductMutationSchema, ProductQuerySchema, ProductSchema, SearchMutationSchema, SearchQuerySchema } from "@reactionary/core";
+import { Client, ProductMutationSchema, ProductQuerySchema, ProductSchema, SearchMutationSchema, SearchQuerySchema, Cache } from "@reactionary/core";
 import { AlgoliaProductProvider } from "../providers/product.provider";
 import { AlgoliaSearchProvider } from "../providers/search.provider";
 import { AlgoliaCapabilities } from "../schema/capabilities.schema";
@@ -6,15 +6,17 @@ import { AlgoliaConfiguration } from "../schema/configuration.schema";
 import { AlgoliaSearchResultSchema } from "../schema/search.schema";
 
 export function withAlgoliaCapabilities(configuration: AlgoliaConfiguration, capabilities: AlgoliaCapabilities) {
-    const client: Partial<Client> = {};
+    return (cache: Cache) => {
+        const client: Partial<Client> = {};
 
-    if (capabilities.product) {
-        client.product = new AlgoliaProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema);
-    }
+        if (capabilities.product) {
+            client.product = new AlgoliaProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema, cache);
+        }
 
-    if (capabilities.search) {
-        client.search = new AlgoliaSearchProvider(configuration, AlgoliaSearchResultSchema, SearchQuerySchema, SearchMutationSchema);
-    }
+        if (capabilities.search) {
+            client.search = new AlgoliaSearchProvider(configuration, AlgoliaSearchResultSchema, SearchQuerySchema, SearchMutationSchema, cache);
+        }
 
-    return client;
+        return client;
+    };
 }

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

@@ -9,8 +9,8 @@ export class AlgoliaProductProvider<
 > extends ProductProvider<T, Q, M> {
   protected config: AlgoliaConfiguration;
 
-  constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>, cache: any) {
+    super(schema, querySchema, mutationSchema, cache);
 
     this.config = config;
   }

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

@@ -19,8 +19,8 @@ export class AlgoliaSearchProvider<
 > extends SearchProvider<T, Q, M> {
   protected config: AlgoliaConfiguration;
 
-  constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>, cache: any) {
+    super(schema, querySchema, mutationSchema, cache);
 
     this.config = config;
   }

package/providers/commercetools/src/core/initialize.ts

@@ -1,4 +1,4 @@
-import { CartMutationSchema, CartQuerySchema, CartSchema, Client, IdentityMutationSchema, IdentityQuerySchema, IdentitySchema, InventoryQuerySchema, InventorySchema, PriceMutationSchema, PriceQuerySchema, PriceSchema, ProductMutationSchema, ProductQuerySchema, ProductSchema, SearchMutationSchema, SearchQuerySchema, SearchResultSchema } from "@reactionary/core";
+import { CartMutationSchema, CartQuerySchema, CartSchema, Client, IdentityMutationSchema, IdentityQuerySchema, IdentitySchema, InventoryQuerySchema, InventorySchema, PriceMutationSchema, PriceQuerySchema, PriceSchema, ProductMutationSchema, ProductQuerySchema, ProductSchema, SearchMutationSchema, SearchQuerySchema, SearchResultSchema, Cache } from "@reactionary/core";
 import { CommercetoolsCapabilities } from "../schema/capabilities.schema";
 import { CommercetoolsSearchProvider } from "../providers/search.provider";
 import { CommercetoolsProductProvider } from '../providers/product.provider';
@@ -9,32 +9,37 @@ import { CommercetoolsInventoryProvider } from "../providers/inventory.provider"
 import { CommercetoolsPriceProvider } from "../providers/price.provider";
 import { InventoryMutationSchema } from "core/src/schemas/mutations/inventory.mutation";
 
-export function withCommercetoolsCapabilities(configuration: CommercetoolsConfiguration, capabilities: CommercetoolsCapabilities) {
-    const client: Partial<Client> = {};
+export function withCommercetoolsCapabilities(
+    configuration: CommercetoolsConfiguration, 
+    capabilities: CommercetoolsCapabilities
+) {
+    return (cache: Cache) => {
+        const client: Partial<Client> = {};
 
-    if (capabilities.product) {
-        client.product = new CommercetoolsProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema);
-    }
+        if (capabilities.product) {
+            client.product = new CommercetoolsProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema, cache);
+        }
 
-    if (capabilities.search) {
-        client.search = new CommercetoolsSearchProvider(configuration, SearchResultSchema, SearchQuerySchema, SearchMutationSchema);
-    }
+        if (capabilities.search) {
+            client.search = new CommercetoolsSearchProvider(configuration, SearchResultSchema, SearchQuerySchema, SearchMutationSchema, cache);
+        }
 
-    if (capabilities.identity) {
-        client.identity = new CommercetoolsIdentityProvider(configuration, IdentitySchema, IdentityQuerySchema, IdentityMutationSchema);
-    }
+        if (capabilities.identity) {
+            client.identity = new CommercetoolsIdentityProvider(configuration, IdentitySchema, IdentityQuerySchema, IdentityMutationSchema, cache);
+        }
 
-    if (capabilities.cart) {
-        client.cart = new CommercetoolsCartProvider(configuration, CartSchema, CartQuerySchema, CartMutationSchema);
-    }
+        if (capabilities.cart) {
+            client.cart = new CommercetoolsCartProvider(configuration, CartSchema, CartQuerySchema, CartMutationSchema, cache);
+        }
 
-    if (capabilities.inventory) {
-        client.inventory = new CommercetoolsInventoryProvider(configuration, InventorySchema, InventoryQuerySchema, InventoryMutationSchema);
-    }
+        if (capabilities.inventory) {
+            client.inventory = new CommercetoolsInventoryProvider(configuration, InventorySchema, InventoryQuerySchema, InventoryMutationSchema, cache);
+        }
 
-    if (capabilities.price) {
-        client.price = new CommercetoolsPriceProvider(configuration, PriceSchema, PriceQuerySchema, PriceMutationSchema);
-    }
+        if (capabilities.price) {
+            client.price = new CommercetoolsPriceProvider(configuration, PriceSchema, PriceQuerySchema, PriceMutationSchema, cache);
+        }
 
-    return client;
+        return client;
+    };
 }

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

@@ -25,9 +25,10 @@ export class CommercetoolsCartProvider<
     config: CommercetoolsConfiguration,
     schema: z.ZodType<T>,
     querySchema: z.ZodType<Q, Q>,
-    mutationSchema: z.ZodType<M, M>
+    mutationSchema: z.ZodType<M, M>,
+    cache: any
   ) {
-    super(schema, querySchema, mutationSchema);
+    super(schema, querySchema, mutationSchema, cache);
 
     this.config = config;
   }

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

@@ -21,9 +21,10 @@ export class CommercetoolsIdentityProvider<
     config: CommercetoolsConfiguration,
     schema: z.ZodType<T>,
     querySchema: z.ZodType<Q, Q>,
-    mutationSchema: z.ZodType<M, M>
+    mutationSchema: z.ZodType<M, M>,
+    cache: any
   ) {
-    super(schema, querySchema, mutationSchema);
+    super(schema, querySchema, mutationSchema, cache);
 
     this.config = config;
   }

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

@@ -1,9 +1,7 @@
 import {
-  BaseCachingStrategy,
   Inventory,
   InventoryProvider,
   InventoryQuery,
-  RedisCache,
   Session,
 } from '@reactionary/core';
 import z from 'zod';
@@ -17,32 +15,25 @@ export class CommercetoolsInventoryProvider<
   M extends InventoryMutation = InventoryMutation
 > extends InventoryProvider<T, Q, M> {
   protected config: CommercetoolsConfiguration;
-  protected cache = new RedisCache(new BaseCachingStrategy());
 
   constructor(
     config: CommercetoolsConfiguration,
     schema: z.ZodType<T>,
     querySchema: z.ZodType<Q, Q>,
-    mutationSchema: z.ZodType<M, M>
+    mutationSchema: z.ZodType<M, M>,
+    cache: any
   ) {
-    super(schema, querySchema, mutationSchema);
+    super(schema, querySchema, mutationSchema, cache);
 
     this.config = config;
   }
 
   protected override async fetch(queries: Q[], session: Session): Promise<T[]> {
+    // Base class now handles caching automatically
     const results = [];
 
     for (const query of queries) {
-      let result = await this.cache.get(query, session, this.schema);
-      console.log('from cache: ', result);
-
-      if (!result) {
-        result = await this.get(query, session);
-
-        this.cache.put(query, session, result);
-      }
-
+      const result = await this.get(query, session);
       results.push(result);
     }
 

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

@@ -1,4 +1,4 @@
-import { BaseCachingStrategy, BaseMutation, Price, PriceProvider, PriceQuery, RedisCache, Session } from '@reactionary/core';
+import { BaseMutation, Price, PriceProvider, PriceQuery, Session } from '@reactionary/core';
 import z from 'zod';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { CommercetoolsClient } from '../core/client';
@@ -11,8 +11,8 @@ export class CommercetoolsPriceProvider<
 > extends PriceProvider<T, Q, M> {
   protected config: CommercetoolsConfiguration;
 
-  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>, cache: any) {
+    super(schema, querySchema, mutationSchema, cache);
 
     this.config = config;
   }

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

@@ -18,8 +18,8 @@ export class CommercetoolsProductProvider<
 > extends ProductProvider<T, Q, M> {
   protected config: CommercetoolsConfiguration;
 
-  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>, cache: any) {
+    super(schema, querySchema, mutationSchema, cache);
 
     this.config = config;
   }

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

@@ -18,8 +18,8 @@ export class CommercetoolsSearchProvider<
 > extends SearchProvider<T, Q, M> {
   protected config: CommercetoolsConfiguration;
 
-  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>, cache: any) {
+    super(schema, querySchema, mutationSchema, cache);
 
     this.config = config;
   }

package/providers/fake/src/core/initialize.ts

@@ -1,4 +1,4 @@
-import { Client, IdentityMutationSchema, IdentityQuerySchema, IdentitySchema, ProductMutationSchema, ProductQuerySchema, ProductSchema, SearchMutationSchema, SearchQuerySchema, SearchResultSchema } from "@reactionary/core";
+import { Client, IdentityMutationSchema, IdentityQuerySchema, IdentitySchema, ProductMutationSchema, ProductQuerySchema, ProductSchema, SearchMutationSchema, SearchQuerySchema, SearchResultSchema, Cache } from "@reactionary/core";
 import { FakeProductProvider } from "../providers/product.provider";
 import { FakeSearchProvider } from "../providers/search.provider";
 import { FakeConfiguration } from "../schema/configuration.schema";
@@ -6,19 +6,21 @@ import { FakeCapabilities } from "../schema/capabilities.schema";
 import { FakeIdentityProvider } from "../providers/identity.provider";
 
 export function withFakeCapabilities(configuration: FakeConfiguration, capabilities: FakeCapabilities) {
-    const client = {} as Partial<Client>;
+    return (cache: Cache) => {
+        const client = {} as Partial<Client>;
 
-    if (capabilities.product) {
-        client.product = new FakeProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema);
-    }
+        if (capabilities.product) {
+            client.product = new FakeProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema, cache);
+        }
 
-    if (capabilities.search) {
-        client.search = new FakeSearchProvider(configuration, SearchResultSchema, SearchQuerySchema, SearchMutationSchema);
-    }
+        if (capabilities.search) {
+            client.search = new FakeSearchProvider(configuration, SearchResultSchema, SearchQuerySchema, SearchMutationSchema, cache);
+        }
 
-    if (capabilities.identity) {
-        client.identity = new FakeIdentityProvider(configuration, IdentitySchema, IdentityQuerySchema, IdentityMutationSchema);
-    }
+        if (capabilities.identity) {
+            client.identity = new FakeIdentityProvider(configuration, IdentitySchema, IdentityQuerySchema, IdentityMutationSchema, cache);
+        }
 
-    return client;
+        return client;
+    };
 }

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

@@ -21,9 +21,10 @@ export class FakeIdentityProvider<
     config: FakeConfiguration,
     schema: z.ZodType<T>,
     querySchema: z.ZodType<Q, Q>,
-    mutationSchema: z.ZodType<M, M>
+    mutationSchema: z.ZodType<M, M>,
+    cache: any
   ) {
-    super(schema, querySchema, mutationSchema);
+    super(schema, querySchema, mutationSchema, cache);
 
     this.config = config;
   }

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

@@ -17,8 +17,8 @@ export class FakeProductProvider<
 > extends ProductProvider<T, Q, M> {
   protected config: FakeConfiguration;
 
-  constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>, cache: any) {
+    super(schema, querySchema, mutationSchema, cache);
 
     this.config = config;
   }

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

@@ -20,8 +20,8 @@ export class FakeSearchProvider<
 > extends SearchProvider<T, Q, M> {
   protected config: FakeConfiguration;
 
-  constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>, cache: any) {
+    super(schema, querySchema, mutationSchema, cache);
 
     this.config = config;
   }

package/providers/posthog/src/core/initialize.ts

@@ -1,9 +1,11 @@
-import { Client } from "@reactionary/core";
+import { Client, Cache } from "@reactionary/core";
 import { PosthogConfiguration } from "../schema/configuration.schema";
 import { PosthogCapabilities } from "../schema/capabilities.schema";
 
-export function withPosthogCapabilities(configuration: PosthogConfiguration, capabilities: PosthogCapabilities) {
-    const client: Partial<Client> = {};
+export function withPosthogCapabilities(_configuration: PosthogConfiguration, _capabilities: PosthogCapabilities) {
+    return (_cache: Cache) => {
+        const client: Partial<Client> = {};
 
-    return client;
+        return client;
+    };
 }

package/core/src/cache/caching-strategy.ts

@@ -1,25 +0,0 @@
-import { BaseQuery } from "../schemas/queries/base.query";
-import { InventoryQuery } from "../schemas/queries/inventory.query";
-import { Session } from "../schemas/session.schema";
-
-export interface CachingStrategyEvaluation {
-    key: string;
-    cacheDurationInSeconds: number;
-    canCache: boolean;
-}
-
-export interface CachingStrategy {
-    get(query: BaseQuery, session: Session): CachingStrategyEvaluation;
-}
-
-export class BaseCachingStrategy implements CachingStrategy {
-    public get(query: BaseQuery, session: Session): CachingStrategyEvaluation {
-        const q = query as InventoryQuery;
-
-        return {
-            key: q.sku,
-            cacheDurationInSeconds: 300,
-            canCache: true
-        }
-    }
-}