@reactionary/source 0.0.41 → 0.0.48

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

@@ -1,15 +1,15 @@
 import {
-  Product,
+  type Product,
+  type ProductQueryById,
+  type ProductQueryBySlug,
+  type RequestContext,
+  type Cache as ReactinaryCache,
   ProductProvider,
-  ProductQueryById,
-  ProductQueryBySlug,
-  Session,
-  Cache as ReactinaryCache,
+  Reactionary,
 } from '@reactionary/core';
-import z from 'zod';
-import { FakeConfiguration } from '../schema/configuration.schema';
+import type z from 'zod';
+import type { FakeConfiguration } from '../schema/configuration.schema';
 import { base, en, Faker } from '@faker-js/faker';
-import { traced } from '@reactionary/otel';
 
 export class FakeProductProvider<
   T extends Product = Product
@@ -22,16 +22,19 @@ export class FakeProductProvider<
     this.config = config;
   }
 
+  @Reactionary({})
   public override async getById(
     payload: ProductQueryById,
-    _session: Session
+    _reqCtx: RequestContext
   ): Promise<T> {
     return this.parseSingle(payload);
   }
 
+  // FIXME: Should we have a get-by-sku here? Since thats whats coming back on cart items...
+
   public override async getBySlug(
     payload: ProductQueryBySlug,
-    _session: Session
+    _reqCtx: RequestContext
   ): Promise<T> {
     return this.parseSingle(payload);
   }

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

@@ -1,13 +1,15 @@
 import {
-  SearchProvider,
+  SearchProvider
+} from '@reactionary/core';
+import type {
   SearchResult,
   SearchResultFacet,
   SearchResultProduct,
   Cache as ReactionaryCache,
 } from '@reactionary/core';
-import type { SearchQueryByTerm, Session } from '@reactionary/core';
-import z from 'zod';
-import { FakeConfiguration } from '../schema/configuration.schema';
+import type { RequestContext, SearchQueryByTerm } from '@reactionary/core';
+import type z from 'zod';
+import type { FakeConfiguration } from '../schema/configuration.schema';
 import { Faker, en, base } from '@faker-js/faker';
 import { jitter } from '../utilities/jitter';
 import { traced } from '@reactionary/otel';
@@ -26,7 +28,7 @@ export class FakeSearchProvider<
   @traced()
   public override async queryByTerm(
     payload: SearchQueryByTerm,
-    _session: Session
+    _reqCtx: RequestContext
   ): Promise<SearchResult> {
     await jitter(this.config.jitter.mean, this.config.jitter.deviation);
 

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

@@ -0,0 +1,47 @@
+import type {
+  Inventory,
+  Cache,
+  RequestContext,
+  StoreQueryByProximity,
+  Store,
+} from '@reactionary/core';
+import { InventoryProvider, StoreProvider } from '@reactionary/core';
+import type z from 'zod';
+import type { FakeConfiguration } from '../schema/configuration.schema';
+import { base, en, Faker } from '@faker-js/faker';
+
+export class FakeStoreProvider<
+  T extends Store = Store
+> extends StoreProvider<T> {
+  protected config: FakeConfiguration;
+
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache) {
+    super(schema, cache);
+
+    this.config = config;
+  }
+
+  public override async queryByProximity(
+    payload: StoreQueryByProximity,
+    reqCtx: RequestContext
+  ): Promise<T[]> {
+    const generator = new Faker({
+      seed: 42,
+      locale: [en, base],
+    });
+
+    const results = [];
+
+    for (let i = 0; i < payload.limit; i++) {
+        const model = this.newModel();
+
+        model.name = generator.company.name();
+        model.identifier.key = '' + i;
+        model.fulfillmentCenter.key = '' + i;
+
+        results.push(model);
+    }
+
+    return results;
+  }
+}

package/providers/fake/src/schema/capabilities.schema.ts

@@ -1,5 +1,5 @@
 import { CapabilitiesSchema } from "@reactionary/core";
-import { z } from 'zod';
+import type { z } from 'zod';
 
 export const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
     product: true,
@@ -7,6 +7,9 @@ export const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
     identity: true,
     category: true,
     cart: true,
+    inventory: true,
+    store: true,
+    price: true,
 }).partial();
 
 export type FakeCapabilities = z.infer<typeof FakeCapabilitiesSchema>;

package/providers/fake/src/test/cart.provider.spec.ts

@@ -1,6 +1,7 @@
 import 'dotenv/config';
-import { CartSchema, CategorySchema, IdentitySchema, NoOpCache, ProductSchema, Session } from '@reactionary/core';
-import { createAnonymousTestSession, getFakerTestConfiguration } from './test-utils';
+import type { RequestContext} from '@reactionary/core';
+import { CartSchema, IdentitySchema, NoOpCache, createInitialRequestContext } from '@reactionary/core';
+import { getFakerTestConfiguration } from './test-utils';
 import { FakeCartProvider } from '../providers/cart.provider';
 import { FakeIdentityProvider } from '../providers';
 
@@ -13,7 +14,7 @@ const testData = {
 describe('Fake Cart Provider', () => {
   let provider: FakeCartProvider;
   let identityProvider: FakeIdentityProvider;
-  let session: Session;
+  let reqCtx: RequestContext;
 
   beforeAll( () => {
     provider = new FakeCartProvider(getFakerTestConfiguration(), CartSchema, new NoOpCache());
@@ -21,14 +22,14 @@ describe('Fake Cart Provider', () => {
   });
 
   beforeEach( () => {
-    session = createAnonymousTestSession()
+    reqCtx = createInitialRequestContext()
   });
 
   describe('anonymous sessions', () => {
     it('should be able to get an empty cart', async () => {
       const cart = await provider.getById({
         cart: { key: '' },
-      }, session);
+      }, reqCtx);
 
       expect(cart.identifier.key).toBeFalsy();
       expect(cart.items.length).toBe(0);
@@ -39,22 +40,22 @@ describe('Fake Cart Provider', () => {
     it('should be able to add an item to a cart', async () => {
       const cart = await provider.add({
           cart: { key: '' },
-          product: {
+          sku: {
             key: testData.skuWithoutTiers,
           },
           quantity: 1
-      }, session);
+      }, reqCtx);
 
       expect(cart.identifier.key).toBeDefined();
       expect(cart.items.length).toBe(1);
-      expect(cart.items[0].product.key).toBe(testData.skuWithoutTiers);
+      expect(cart.items[0].sku.key).toBe(testData.skuWithoutTiers);
       expect(cart.items[0].quantity).toBe(1);
 
       expect(cart.items[0].price.totalPrice.value).toBeGreaterThan(0);
-      expect(cart.items[0].price.totalPrice.currency).toBe(session.languageContext.currencyCode);
+      expect(cart.items[0].price.totalPrice.currency).toBe(reqCtx.languageContext.currencyCode);
 
       expect(cart.price.grandTotal.value).toBeGreaterThan(0);
-      expect(cart.price.grandTotal.currency).toBe(session.languageContext.currencyCode);
+      expect(cart.price.grandTotal.currency).toBe(reqCtx.languageContext.currencyCode);
 
       expect(cart.price.grandTotal.value).toBe(cart.items[0].price.totalPrice.value);
 
@@ -68,23 +69,22 @@ describe('Fake Cart Provider', () => {
 
       const cart = await provider.add({
           cart: { key: '' },
-          product: {
+          sku: {
             key: testData.skuWithoutTiers,
           },
           quantity: 1
-      }, session);
+      }, reqCtx);
 
       const updatedCart = await provider.changeQuantity({
         cart: cart.identifier,
         item: cart.items[0].identifier,
         quantity: 3
-      }, session);
+      }, reqCtx);
 
       expect(updatedCart.identifier.key).toBe(cart.identifier.key);
       expect(updatedCart.items.length).toBe(1);
-      expect(updatedCart.items[0].product.key).toBe(testData.skuWithoutTiers);
+      expect(updatedCart.items[0].sku.key).toBe(testData.skuWithoutTiers);
       expect(updatedCart.items[0].quantity).toBe(3);
-
       expect(updatedCart.items[0].price.totalPrice.value).toBe(cart.items[0].price.totalPrice.value * 3);
       expect(updatedCart.items[0].price.unitPrice.value).toBe(cart.items[0].price.unitPrice.value);
 
@@ -95,16 +95,16 @@ describe('Fake Cart Provider', () => {
 
       const cart = await provider.add({
           cart: { key: '' },
-          product: {
+          sku: {
             key: testData.skuWithoutTiers,
           },
           quantity: 1
-      }, session);
+      }, reqCtx);
 
       const updatedCart = await provider.remove({
         cart: cart.identifier,
         item: cart.items[0].identifier,
-      }, session);
+      }, reqCtx);
       expect(updatedCart.identifier.key).toBe(cart.identifier.key);
       expect(updatedCart.items.length).toBe(0);
     });

package/providers/fake/src/test/category.provider.spec.ts

@@ -1,25 +1,29 @@
-import 'dotenv/config'
-
-
-import { CategorySchema, NoOpCache, Session } from '@reactionary/core';
+import 'dotenv/config';
+import type { RequestContext } from '@reactionary/core';
+import { CategorySchema, MemoryCache , createInitialRequestContext,} from '@reactionary/core';
 import { FakeCategoryProvider } from '../providers';
-import { createAnonymousTestSession, getFakerTestConfiguration } from './test-utils';
+import { getFakerTestConfiguration } from './test-utils';
+
 describe('Faker Category Provider', () => {
   let provider: FakeCategoryProvider;
-  let session: Session;
-
-
-
-  beforeAll( () => {
-    provider = new FakeCategoryProvider(getFakerTestConfiguration(), CategorySchema, new NoOpCache());
+  let reqCtx: RequestContext;
+  const cache = new MemoryCache();
+
+  beforeAll(() => {
+    provider = new FakeCategoryProvider(
+      getFakerTestConfiguration(),
+      CategorySchema,
+      cache
+    );
   });
 
   beforeEach( () => {
-    session = createAnonymousTestSession()
+    reqCtx = createInitialRequestContext();
+    cache.clear();
   })
 
   it('should be able to get top-categories', async () => {
-    const result = await provider.findTopCategories({ paginationOptions: { pageSize: 10, pageNumber: 1 }}, session);
+    const result = await provider.findTopCategories({ paginationOptions: { pageSize: 10, pageNumber: 1 }}, reqCtx);
 
     expect(result.items.length).toBeGreaterThan(0);
     expect(result.items[0].identifier.key).toBe('grocery');
@@ -30,7 +34,7 @@ describe('Faker Category Provider', () => {
   });
 
   it('should be able to get child categories for a category', async () => {
-    const result = await provider.findChildCategories({ parentId: { key: 'grocery' }, paginationOptions: { pageSize: 10, pageNumber: 1 }}, session);
+    const result = await provider.findChildCategories({ parentId: { key: 'grocery' }, paginationOptions: { pageSize: 10, pageNumber: 1 }}, reqCtx);
 
     expect(result.items.length).toBeGreaterThan(0);
     expect(result.items[0].identifier.key).toBe('grocery-0');
@@ -38,12 +42,10 @@ describe('Faker Category Provider', () => {
 
     expect(result.items[1].identifier.key).toBe('grocery-1');
     expect(result.items[1].name).toBe('Grocery-1');
-
   });
 
-
   it('should be able to get child categories for a category, paged', async () => {
-    let result = await provider.findChildCategories({ parentId: { key: 'grocery' }, paginationOptions: { pageSize: 1, pageNumber: 1 }}, session);
+    let result = await provider.findChildCategories({ parentId: { key: 'grocery' }, paginationOptions: { pageSize: 1, pageNumber: 1 }}, reqCtx);
 
     expect(result.items.length).toBeGreaterThan(0);
     expect(result.items[0].identifier.key).toBe('grocery-0');
@@ -53,7 +55,7 @@ describe('Faker Category Provider', () => {
     expect(result.pageSize).toBe(1);
     expect(result.pageNumber).toBe(1);
 
-    result = await provider.findChildCategories({ parentId: { key: 'grocery' }, paginationOptions: { pageSize: 1, pageNumber: 2 }}, session);
+    result = await provider.findChildCategories({ parentId: { key: 'grocery' }, paginationOptions: { pageSize: 1, pageNumber: 2 }}, reqCtx);
 
     expect(result.items.length).toBeGreaterThan(0);
     expect(result.items[0].identifier.key).toBe('grocery-1');
@@ -64,9 +66,8 @@ describe('Faker Category Provider', () => {
     expect(result.pageNumber).toBe(2);
   });
 
-
   it('can load all breadcrumbs for a category', async () => {
-    const result = await provider.getBreadcrumbPathToCategory({ id: { key: 'grocery-0-0' } }, session);
+    const result = await provider.getBreadcrumbPathToCategory({ id: { key: 'grocery-0-0' } }, reqCtx);
 
     expect(result.length).toBeGreaterThan(2);
     expect(result[0].identifier.key).toBe('grocery');
@@ -80,53 +81,70 @@ describe('Faker Category Provider', () => {
     expect(result[2].identifier.key).toBe('grocery-0-0');
     expect(result[2].name).toBe('Grocery-0-0');
     expect(result[2].slug).toBe('grocery-0-0-slug');
-
   });
 
-
   it('should be able to get a category by slug', async () => {
-    const result = await provider.getBySlug({ slug: 'grocery-slug' }, session);
+    const result = await provider.getBySlug({ slug: 'grocery-slug' }, reqCtx);
     expect(result).toBeTruthy();
     if (result) {
       expect(result.identifier.key).toBe('grocery');
       expect(result.name).toBe('Grocery');
       expect(result.slug).toBe('grocery-slug');
       expect(result.parentCategory).toBeUndefined();
-      expect(result.text).not.toBe("");
+      expect(result.text).not.toBe('');
       expect(result.meta.placeholder).toBe(false);
     }
   });
 
   it('returns null if looking for slug that does not exist', async () => {
-    const result = await provider.getBySlug({ slug: 'non-existent-slug' }, session);
+    const result = await provider.getBySlug({ slug: 'non-existent-slug' }, reqCtx);
     expect(result).toBeNull();
   });
 
-
-
   it('should be able to get a category by id', async () => {
-    const result = await provider.getById({ id: { key: 'grocery'}}, session);
+    const result = await provider.getById({ id: { key: 'grocery'}}, reqCtx);
 
     expect(result.identifier.key).toBe('grocery');
     expect(result.name).toBe('Grocery');
     expect(result.slug).toBe('grocery-slug');
     expect(result.parentCategory).toBeUndefined();
 
-    expect(result.text).not.toBe("");
+    expect(result.text).not.toBe('');
     expect(result.meta.placeholder).toBe(false);
-
   });
 
-
-
-
-
   it('returns a placeholder if you search for a category that does not exist', async () => {
-    const result = await provider.getById({ id: { key: 'non-existent-category'}}, session);
+    const result = await provider.getById({ id: { key: 'non-existent-category'}}, reqCtx);
     expect(result.identifier.key).toBe('non-existent-category');
     expect(result.meta.placeholder).toBe(true);
-
   });
 
-
+  describe('caching', () => {
+    // TODO: These should probably be elsewhere, since they are really testing the caches and the decorator together.
+    // Perhaps as an integration test
+
+    it('should cache the results for byId', async () => {
+      const first = await provider.getById({ id: { key: 'grocery' } }, reqCtx);
+      expect(first.meta.cache.hit).toBe(false);
+
+      const second = await provider.getById(
+        { id: { key: 'grocery' } },
+        reqCtx
+      );
+      expect(second.meta.cache.hit).toBe(true);
+    });
+
+    it('can clear a cache entry by dependency id', async () => {
+      const first = await provider.getById({ id: { key: 'grocery' } }, reqCtx);
+
+      const dependencyIds = provider.generateDependencyIdsForModel(first);
+      await cache.invalidate(dependencyIds);
+
+      const second = await provider.getById(
+        { id: { key: 'grocery' } },
+        reqCtx
+      );
+      expect(second.meta.cache.hit).toBe(false);
+    });
+  });
 });

package/providers/fake/src/test/price.provider.spec.ts

@@ -1,9 +1,7 @@
 import 'dotenv/config';
-
-
-import { NoOpCache, PriceSchema, Session } from '@reactionary/core';
-import { createAnonymousTestSession, getFakerTestConfiguration } from './test-utils';
-
+import type { RequestContext} from '@reactionary/core';
+import { NoOpCache, PriceSchema, createInitialRequestContext } from '@reactionary/core';
+import { getFakerTestConfiguration } from './test-utils';
 import { FakePriceProvider } from '../providers/price.provider';
 
 const testData = {
@@ -11,23 +9,20 @@ const testData = {
   skuWithTiers: 'GMCT-01-with-tiers'
 }
 
-
 describe('Fake Price Provider', () => {
   let provider: FakePriceProvider;
-  let session: Session;
-
-
+  let reqCtx: RequestContext;
 
   beforeAll( () => {
     provider = new FakePriceProvider(getFakerTestConfiguration(), PriceSchema, new NoOpCache());
   });
 
   beforeEach( () => {
-    session = createAnonymousTestSession()
+    reqCtx = createInitialRequestContext()
   })
 
   it('should be able to get prices for a product without tiers', async () => {
-    const result = await provider.getBySKU({ sku: { key: testData.skuWithoutTiers }}, session);
+    const result = await provider.getBySKU({ sku: { key: testData.skuWithoutTiers }}, reqCtx);
 
     expect(result).toBeTruthy();
     if (result) {
@@ -39,7 +34,7 @@ describe('Fake Price Provider', () => {
   });
 
   it('should be able to get prices for a product with tiers', async () => {
-    const result = await provider.getBySKU({ sku: { key: testData.skuWithTiers }}, session);
+    const result = await provider.getBySKU({ sku: { key: testData.skuWithTiers }}, reqCtx);
 
     expect(result).toBeTruthy();
     if (result) {
@@ -56,7 +51,7 @@ describe('Fake Price Provider', () => {
   });
 
   it('should return a placeholder price for an unknown SKU', async () => {
-    const result = await provider.getBySKU({ sku: { key: 'unknown-sku' }}, session);
+    const result = await provider.getBySKU({ sku: { key: 'unknown-sku' }}, reqCtx);
 
     expect(result).toBeTruthy();
     if (result) {
@@ -70,7 +65,7 @@ describe('Fake Price Provider', () => {
 
   it('can look up multiple prices at once', async () => {
     const skus = [testData.skuWithTiers, testData.skuWithoutTiers, 'unknown-sku'];
-    const results = await Promise.all(skus.map( sku => provider.getBySKU({ sku: { key: sku }}, session)));
+    const results = await Promise.all(skus.map( sku => provider.getBySKU({ sku: { key: sku }}, reqCtx)));
 
     expect(results).toHaveLength(skus.length);
     expect(results[0].identifier.sku.key).toBe(testData.skuWithTiers);

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

@@ -0,0 +1,27 @@
+import 'dotenv/config';
+
+import type { Session } from '@reactionary/core';
+import { MemoryCache, ProductSchema } from '@reactionary/core';
+import { createAnonymousTestSession, getFakerTestConfiguration } from './test-utils';
+import { FakeProductProvider } from '../providers';
+
+describe('Fake Product Provider', () => {
+  let provider: FakeProductProvider;
+  let session: Session;
+
+  beforeAll(async () => {
+    provider = new FakeProductProvider(getFakerTestConfiguration(), ProductSchema, new MemoryCache());
+  });
+
+  beforeEach( () => {
+    session = createAnonymousTestSession()
+  })
+
+  it('should cache repeat product lookups by id', async () => {
+    const first = await provider.getById({ id: '1234' }, session);
+    expect(first.meta.cache.hit).toBe(false);
+
+    const second = await provider.getById({ id: '1234' }, session);
+    expect(second.meta.cache.hit).toBe(true);
+  });
+});

package/providers/fake/src/test/test-utils.ts

@@ -1,5 +1,4 @@
-import { Session } from "@reactionary/core";
-import { FakeConfiguration } from "../schema/configuration.schema";
+import type { FakeConfiguration } from '../schema/configuration.schema';
 
 export function getFakerTestConfiguration(): FakeConfiguration {
   return {
@@ -11,32 +10,7 @@ export function getFakerTestConfiguration(): FakeConfiguration {
       product: 1,
       search: 1,
       category: 1,
-    }
-  }
-}
-
-
-export function createAnonymousTestSession(): Session {
-  return {
-    id: 'test-session-id',
-    identity: {
-      type: 'Anonymous',
-      meta: {
-        cache: { hit: false, key: '' },
-        placeholder: false,
-      },
-      id: '',
-      token: undefined,
-      issued: new Date(),
-      expiry: new Date(new Date().getTime() + 3600 * 1000), // 1 hour from now
-    },
-    languageContext: {
-      locale: 'en-US',
-      currencyCode: 'USD',
-      countryCode: 'US',
-    },
-    storeIdentifier: {
-      key: 'the-good-store',
     },
   };
 }
+

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

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

package/providers/posthog/src/schema/capabilities.schema.ts

@@ -1,5 +1,5 @@
 import { CapabilitiesSchema } from "@reactionary/core";
-import { z } from 'zod';
+import type { z } from 'zod';
 
 export const PosthogCapabilitiesSchema = CapabilitiesSchema.pick({
     analytics: true