@reactionary/source 0.0.42 → 0.0.48

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

@@ -1,7 +1,8 @@
-import { Category, CategoryProvider, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, Session } from "@reactionary/core";
-import { FakeConfiguration } from "../schema/configuration.schema";
-import { Cache as ReactionaryCache } from "@reactionary/core";
-import z from "zod";
+import type { Category, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, RequestContext} from "@reactionary/core";
+import { CategoryProvider, Session } from "@reactionary/core";
+import type { FakeConfiguration } from "../schema/configuration.schema";
+import type { Cache as ReactionaryCache } from "@reactionary/core";
+import type z from "zod";
 import { Faker, en, base } from '@faker-js/faker';
 export class FakeCategoryProvider<
   T extends Category = Category
@@ -70,19 +71,18 @@ export class FakeCategoryProvider<
     });
   }
 
-
-
-  public override async getById(payload: CategoryQueryById, session: Session): Promise<T> {
+  public override async getById(payload: CategoryQueryById, reqCtx: RequestContext): Promise<T> {
     const category = this.allCategories.get(payload.id.key);
+    
     if(!category) {
       const dummyCategory = this.newModel();
       dummyCategory.meta.placeholder = true;
       dummyCategory.identifier = { key: payload.id.key };
       return dummyCategory;
     }
-    return  category;
+    return category;
   }
-  public override getBySlug(payload: CategoryQueryBySlug, session: Session): Promise<T | null> {
+  public override getBySlug(payload: CategoryQueryBySlug, reqCtx: RequestContext): Promise<T | null> {
     for(const p of this.allCategories.values()) {
       if(p.slug === payload.slug) {
         return Promise.resolve(p as T);
@@ -91,7 +91,7 @@ export class FakeCategoryProvider<
     return Promise.resolve(null);
   }
 
-  public override getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, session: Session): Promise<T[]> {
+  public override getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, reqCtx: RequestContext): Promise<T[]> {
     const path = new Array<T>();
     let category = this.allCategories.get(payload.id.key);
     path.push(category as T);
@@ -104,7 +104,7 @@ export class FakeCategoryProvider<
     return Promise.resolve(path);
   }
 
-  public override async findChildCategories(payload: CategoryQueryForChildCategories, session: Session): Promise<ReturnType<typeof this.parsePaginatedResult>> {
+  public override async findChildCategories(payload: CategoryQueryForChildCategories, reqCtx: RequestContext): Promise<ReturnType<typeof this.parsePaginatedResult>> {
     const children = this.childCategories.get(payload.parentId.key);
     const page = children?.slice((payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize, payload.paginationOptions.pageNumber * payload.paginationOptions.pageSize);
 
@@ -126,7 +126,7 @@ export class FakeCategoryProvider<
 
     return Promise.resolve(res);
   }
-  public override findTopCategories(payload: CategoryQueryForTopCategories, session: Session): Promise<ReturnType<typeof this.parsePaginatedResult>> {
+  public override findTopCategories(payload: CategoryQueryForTopCategories, reqCtx: RequestContext): Promise<ReturnType<typeof this.parsePaginatedResult>> {
     const children = this.topCategories;
     const page = children?.slice((payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize, payload.paginationOptions.pageNumber * payload.paginationOptions.pageSize);
 

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

@@ -1,14 +1,15 @@
 import {
-  Identity,
+  type Identity,
+  type IdentityQuerySelf,
+  type IdentityMutationLogin,
+  type IdentityMutationLogout,
+  type RequestContext,
+  type Cache,
   IdentityProvider,
-  IdentityQuerySelf,
-  IdentityMutationLogin,
-  IdentityMutationLogout,
-  Session,
-  Cache,
+  type IdentityMutationRegister,
 } 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';
 
 export class FakeIdentityProvider<
@@ -25,7 +26,7 @@ export class FakeIdentityProvider<
 
   public override async getSelf(
     _payload: IdentityQuerySelf,
-    _session: Session
+    _reqCtx: RequestContext
   ): Promise<T> {
     if (!this.currentIdentity) {
       const model = this.newModel();
@@ -50,7 +51,7 @@ export class FakeIdentityProvider<
 
   public override async login(
     payload: IdentityMutationLogin,
-    _session: Session
+    _reqCtx: RequestContext
   ): Promise<T> {
     const generator = new Faker({
       seed: 42,
@@ -72,14 +73,14 @@ export class FakeIdentityProvider<
         placeholder: false,
       },
     });
-    
+
     this.currentIdentity = this.assert(model);
     return this.currentIdentity;
   }
 
   public override async logout(
     _payload: IdentityMutationLogout,
-    _session: Session
+    _reqCtx: RequestContext
   ): Promise<T> {
     const model = this.newModel();
     Object.assign(model, {
@@ -95,8 +96,15 @@ export class FakeIdentityProvider<
         placeholder: false,
       },
     });
-    
+
     this.currentIdentity = this.assert(model);
     return this.currentIdentity;
   }
-}
+
+  public override register(
+    payload: IdentityMutationRegister,
+    reqCtx: RequestContext
+  ): Promise<T> {
+    throw new Error('Method not implemented.');
+  }
+}

package/providers/fake/src/providers/index.ts

@@ -6,3 +6,4 @@ export * from './inventory.provider';
 export * from './price.provider';
 export * from './product.provider';
 export * from './search.provider';
+export * from './store.provider';

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

@@ -1,12 +1,14 @@
-import {
+import type {
   Inventory,
-  InventoryProvider,
-  InventoryQuery,
-  Session,
+  RequestContext,
   Cache,
+  InventoryQueryBySKU
+} from '@reactionary/core';
+import {
+  InventoryProvider
 } 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';
 
 export class FakeInventoryProvider<
@@ -21,8 +23,8 @@ export class FakeInventoryProvider<
   }
 
   public override async getBySKU(
-    payload: InventoryQuery,
-    _session: Session
+    payload: InventoryQueryBySKU,
+    _reqCtx: RequestContext
   ): Promise<T> {
     // Generate a simple hash from the SKU string for seeding
     let hash = 0;
@@ -40,10 +42,8 @@ export class FakeInventoryProvider<
     const model = this.newModel();
 
     model.identifier = {
-      sku: { key: skuString},
-      channelId: {
-        key: 'online'
-      },
+      sku: payload.sku,
+      fulfillmentCenter: payload.fulfilmentCenter
     };
     model.sku = skuString;
 
@@ -58,7 +58,7 @@ export class FakeInventoryProvider<
     model.meta = {
         cache: {
           hit: false,
-          key: this.generateCacheKeySingle(model.identifier, _session)
+          key: this.generateCacheKeySingle(model.identifier, _reqCtx)
         },
         placeholder: false,
       };

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

@@ -1,12 +1,12 @@
 import {
-  Price,
+  type Price,
+  type PriceQueryBySku,
+  type RequestContext,
+  type Cache,
   PriceProvider,
-  PriceQueryBySku,
-  Session,
-  Cache,
 } 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';
 
 export class FakePriceProvider<
@@ -20,20 +20,20 @@ export class FakePriceProvider<
     this.config = config;
   }
 
-  public override async getBySKUs(payload: PriceQueryBySku[], session: Session): Promise<T[]> {
+  public override async getBySKUs(payload: PriceQueryBySku[], reqCtx: RequestContext): Promise<T[]> {
 
-    const promises = payload.map(p => this.getBySKU(p, session));
+    const promises = payload.map(p => this.getBySKU(p, reqCtx));
     const result = await Promise.all(promises);
     return result;
   }
 
   public override async getBySKU(
     payload: PriceQueryBySku,
-    _session: Session
+    _reqCtx: RequestContext
   ): Promise<T> {
 
     if (payload.sku.key === 'unknown-sku') {
-      return this.createEmptyPriceResult(payload.sku.key, _session.languageContext.currencyCode);
+      return this.createEmptyPriceResult(payload.sku.key, _reqCtx.languageContext.currencyCode);
     }
 
     // Generate a simple hash from the SKU key string for seeding
@@ -57,7 +57,7 @@ export class FakePriceProvider<
       },
       unitPrice: {
         value: generator.number.int({ min: 300, max: 100000 }) / 100,
-        currency: _session.languageContext.currencyCode,
+        currency: _reqCtx.languageContext.currencyCode,
       },
       meta: {
         cache: {
@@ -78,14 +78,14 @@ export class FakePriceProvider<
           minimumQuantity: generator.number.int({ min: 2, max: 5 }),
           price: {
             value: tier1Price,
-            currency: _session.languageContext.currencyCode,
+            currency: _reqCtx.languageContext.currencyCode,
           }
         },
         {
           minimumQuantity: generator.number.int({ min: 6, max: 10 }),
           price: {
             value: tier2Price,
-            currency: _session.languageContext.currencyCode,
+            currency: _reqCtx.languageContext.currencyCode,
           }
         }
       ];

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,19 +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);
     });