@reactionary/source 0.0.37 → 0.0.39

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

@@ -0,0 +1,134 @@
+import 'dotenv/config'
+
+
+import { CategorySchema, NoOpCache, ProductSchema, Session } from '@reactionary/core';
+
+import { getTracer, shutdownOtel } from '@reactionary/otel';
+import { FakeCategoryProvider } from '../providers';
+import { createAnonymousTestSession, getFakerTestConfiguration } from './test-utils';
+describe('Faker Category Provider', () => {
+  let provider: FakeCategoryProvider;
+  let session: Session;
+
+
+
+  beforeAll( () => {
+    provider = new FakeCategoryProvider(getFakerTestConfiguration(), CategorySchema, new NoOpCache());
+  });
+
+  beforeEach( () => {
+    session = createAnonymousTestSession()
+  })
+
+  it('should be able to get top-categories', async () => {
+    const result = await provider.findTopCategories({ paginationOptions: { pageSize: 10, pageNumber: 1 }}, session);
+
+    expect(result.items.length).toBeGreaterThan(0);
+    expect(result.items[0].identifier.key).toBe('grocery');
+    expect(result.items[0].name).toBe('Grocery');
+
+    expect(result.items[1].identifier.key).toBe('sports');
+    expect(result.items[1].name).toBe('Sports');
+  });
+
+  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);
+
+    expect(result.items.length).toBeGreaterThan(0);
+    expect(result.items[0].identifier.key).toBe('grocery-0');
+    expect(result.items[0].name).toBe('Grocery-0');
+
+    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);
+
+    expect(result.items.length).toBeGreaterThan(0);
+    expect(result.items[0].identifier.key).toBe('grocery-0');
+    expect(result.items[0].name).toBe('Grocery-0');
+    expect(result.totalCount).toBeGreaterThan(1);
+    expect(result.totalPages).toEqual(result.totalCount);
+    expect(result.pageSize).toBe(1);
+    expect(result.pageNumber).toBe(1);
+
+    result = await provider.findChildCategories({ parentId: { key: 'grocery' }, paginationOptions: { pageSize: 1, pageNumber: 2 }}, session);
+
+    expect(result.items.length).toBeGreaterThan(0);
+    expect(result.items[0].identifier.key).toBe('grocery-1');
+    expect(result.items[0].name).toBe('Grocery-1');
+    expect(result.totalCount).toBeGreaterThan(1);
+    expect(result.totalPages).toEqual(result.totalCount);
+    expect(result.pageSize).toBe(1);
+    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);
+
+    expect(result.length).toBeGreaterThan(2);
+    expect(result[0].identifier.key).toBe('grocery');
+    expect(result[0].name).toBe('Grocery');
+    expect(result[0].slug).toBe('grocery-slug');
+
+    expect(result[1].identifier.key).toBe('grocery-0');
+    expect(result[1].name).toBe('Grocery-0');
+    expect(result[1].slug).toBe('grocery-0-slug');
+
+    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);
+    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.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);
+    expect(result).toBeNull();
+  });
+
+
+
+  it('should be able to get a category by id', async () => {
+    const result = await provider.getById({ id: { key: 'grocery'}}, session);
+
+    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.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);
+    expect(result.identifier.key).toBe('non-existent-category');
+    expect(result.meta.placeholder).toBe(true);
+
+  });
+
+
+});

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

@@ -0,0 +1,80 @@
+import 'dotenv/config';
+
+
+import { NoOpCache, PriceSchema, Session } from '@reactionary/core';
+import { createAnonymousTestSession, getFakerTestConfiguration } from './test-utils';
+
+import { FakePriceProvider } from '../providers/price.provider';
+
+const testData = {
+  skuWithoutTiers: 'SGB-01',
+  skuWithTiers: 'GMCT-01-with-tiers'
+}
+
+
+describe('Fake Price Provider', () => {
+  let provider: FakePriceProvider;
+  let session: Session;
+
+
+
+  beforeAll( () => {
+    provider = new FakePriceProvider(getFakerTestConfiguration(), PriceSchema, new NoOpCache());
+  });
+
+  beforeEach( () => {
+    session = createAnonymousTestSession()
+  })
+
+  it('should be able to get prices for a product without tiers', async () => {
+    const result = await provider.getBySKU({ sku: { key: testData.skuWithoutTiers }}, session);
+
+    expect(result).toBeTruthy();
+    if (result) {
+      expect(result.identifier.sku.key).toBe(testData.skuWithoutTiers);
+      expect(result.unitPrice.value).toBeGreaterThan(0);
+      expect(result.unitPrice.currency).toBe('USD');
+      expect(result.tieredPrices.length).toBe(0);
+    }
+  });
+
+  it('should be able to get prices for a product with tiers', async () => {
+    const result = await provider.getBySKU({ sku: { key: testData.skuWithTiers }}, session);
+
+    expect(result).toBeTruthy();
+    if (result) {
+      expect(result.identifier.sku.key).toBe(testData.skuWithTiers);
+      expect(result.unitPrice.value).toBeGreaterThan(0);
+      expect(result.unitPrice.currency).toBe('USD');
+      expect(result.tieredPrices.length).toBeGreaterThan(0);
+
+      expect(result.tieredPrices[0].minimumQuantity).toBeGreaterThan(0);
+      expect(result.tieredPrices[0].price.value).toBeLessThanOrEqual(result.unitPrice.value);
+      expect(result.tieredPrices[0].price.currency).toBe('USD');
+
+    }
+  });
+
+  it('should return a placeholder price for an unknown SKU', async () => {
+    const result = await provider.getBySKU({ sku: { key: 'unknown-sku' }}, session);
+
+    expect(result).toBeTruthy();
+    if (result) {
+      expect(result.identifier.sku.key).toBe('unknown-sku');
+      expect(result.unitPrice.value).toBe(-1);
+      expect(result.unitPrice.currency).toBe('USD');
+      expect(result.tieredPrices.length).toBe(0);
+      expect(result.meta?.placeholder).toBe(true);
+    }
+  });
+
+  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)));
+
+    expect(results).toHaveLength(skus.length);
+    expect(results[0].identifier.sku.key).toBe(testData.skuWithTiers);
+    expect(results[1].identifier.sku.key).toBe(testData.skuWithoutTiers);
+    expect(results[2].identifier.sku.key).toBe('unknown-sku');
+  });
+});

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

@@ -0,0 +1,42 @@
+import { Session } from "@reactionary/core";
+import { FakeConfiguration } from "../schema/configuration.schema";
+
+export function getFakerTestConfiguration(): FakeConfiguration {
+  return {
+    jitter: {
+      mean: 0,
+      deviation: 0,
+    },
+    seeds: {
+      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/fake/tsconfig.json

@@ -15,6 +15,10 @@
   "references": [
     {
       "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
     }
+
   ]
 }

package/providers/fake/tsconfig.lib.json

@@ -5,5 +5,7 @@
     "declaration": true,
     "types": ["node"]
   },
-  "include": ["src/**/*.ts"]
+  "include": ["src/**/*.ts"],
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts", "src/**/test-utils.ts"]
+
 }

package/providers/fake/tsconfig.spec.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "moduleResolution": "node10",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "jest.config.ts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/test-utils.ts",
+    "src/**/*.d.ts"
+  ]
+}

package/trpc/package.json

@@ -9,7 +9,6 @@
     "@reactionary/core": "0.0.1",
     "@reactionary/otel": "0.0.1",
     "superjson": "^2.2.2",
-    "zod": "4.0.0-beta.20250430T185432",
-    "@trpc/client": "^11.1.2"
+    "zod": "4.0.0-beta.20250430T185432"
   }
 }

package/trpc/src/client.ts

@@ -1,7 +1,5 @@
-import { Client, Session, isTRPCQuery, isTRPCMutation, isTRPCMethod } from '@reactionary/core';
+import { Client, Session } from '@reactionary/core';
 import type { TransparentClient } from './types';
-import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
-import type { TRPCClientError } from '@trpc/client';
 
 /**
  * Configuration options for TRPC client creation

package/trpc/src/integration.spec.ts

@@ -21,8 +21,14 @@ const serverClient = buildClient(
     withFakeCapabilities(
       {
         jitter: { mean: 0, deviation: 0 },
+        seeds: {
+          product: 12345,
+          category: 12345,
+          cart: 12345,
+          search: 0
+        },
       },
-      { search: true, product: true, identity: false }
+      { search: true, product: true, identity: false, cart: true }
     ),
   ],
   { cache: new NoOpCache() }
@@ -97,14 +103,14 @@ describe('TRPC Integration Test - Real HTTP Server', () => {
   describe('Product Provider via HTTP', () => {
     it('should fetch product by slug through real HTTP calls', async () => {
       const slug = 'integration-test-product';
-      
+
       // Get result from transparent client (through HTTP/TRPC)
       const trpcResult = await transparentClient.product.getBySlug(
         { slug },
         session
       );
 
-      // Get result from server client (direct call)  
+      // Get result from server client (direct call)
       const directResult = await serverClient.product.getBySlug(
         { slug },
         session
@@ -116,14 +122,14 @@ describe('TRPC Integration Test - Real HTTP Server', () => {
       expect(trpcResult.name).toBeDefined();
       expect(trpcResult.description).toBeDefined();
       expect(trpcResult.image).toBeDefined();
-      
+
       // Both should have the same slug (faker uses seed for consistency)
       expect(trpcResult.slug).toBe(directResult.slug);
     });
 
     it('should fetch product by id through real HTTP calls', async () => {
       const productId = 'integration-test-id';
-      
+
       const trpcResult = await transparentClient.product.getById(
         { id: productId },
         session
@@ -138,7 +144,7 @@ describe('TRPC Integration Test - Real HTTP Server', () => {
       expect(trpcResult.identifier.key).toBe(productId);
       expect(trpcResult.name).toBeDefined();
       expect(trpcResult.description).toBeDefined();
-      
+
       // Should match direct call
       expect(trpcResult.identifier?.key).toBe(directResult.identifier?.key);
     });
@@ -147,7 +153,7 @@ describe('TRPC Integration Test - Real HTTP Server', () => {
   describe('Search Provider via HTTP', () => {
     it('should perform search through real HTTP calls', async () => {
       const searchTerm = 'integration test search';
-      
+
       const trpcResult = await transparentClient.search.queryByTerm(
         {
           search: {
@@ -176,7 +182,7 @@ describe('TRPC Integration Test - Real HTTP Server', () => {
       expect(trpcResult.products).toBeDefined();
       expect(Array.isArray(trpcResult.products)).toBe(true);
       expect(trpcResult.facets).toBeDefined();
-      
+
       // Should match direct call structure
       expect(trpcResult.products.length).toBe(directResult.products.length);
     });
@@ -196,7 +202,7 @@ describe('TRPC Integration Test - Real HTTP Server', () => {
   describe('API Equivalence', () => {
     it('should produce identical results for TRPC vs direct calls', async () => {
       const testId = 'equivalence-test';
-      
+
       // Make same call through both paths
       const [trpcResult, directResult] = await Promise.all([
         transparentClient.product.getById(
@@ -213,4 +219,4 @@ describe('TRPC Integration Test - Real HTTP Server', () => {
       expect(trpcResult.description).toBe(directResult.description);
     });
   });
-});
+});

package/trpc/src/transparent-client.spec.ts

@@ -18,8 +18,14 @@ const serverClient = buildClient(
           mean: 0,
           deviation: 0,
         },
+        seeds: {
+          product: 12345,
+          category: 12345,
+          cart: 12345,
+          search: 0
+        },
       },
-      { search: true, product: true, identity: false }
+      { search: true, product: true, identity: false, cart: true }
     ),
   ],
   {
@@ -39,13 +45,13 @@ describe('TRPC Transparent Client Core Functionality', () => {
   describe('Client Introspection', () => {
     it('should correctly introspect client methods', () => {
       const methods = introspectClient(serverClient);
-      
+
       expect(methods.length).toBeGreaterThan(0);
-      
+
       // Should find product methods
       const productMethods = methods.filter(m => m.providerName === 'product');
       expect(productMethods.length).toBeGreaterThan(0);
-      
+
       const getBySlugMethod = productMethods.find(m => m.name === 'getBySlug');
       expect(getBySlugMethod).toBeDefined();
       expect(getBySlugMethod!.isQuery).toBe(true);
@@ -54,7 +60,7 @@ describe('TRPC Transparent Client Core Functionality', () => {
       // Should find search methods
       const searchMethods = methods.filter(m => m.providerName === 'search');
       expect(searchMethods.length).toBeGreaterThan(0);
-      
+
       const queryByTermMethod = searchMethods.find(m => m.name === 'queryByTerm');
       expect(queryByTermMethod).toBeDefined();
       expect(queryByTermMethod!.isQuery).toBe(true);
@@ -66,7 +72,7 @@ describe('TRPC Transparent Client Core Functionality', () => {
   describe('Router Generation', () => {
     it('should create TRPC router from client', () => {
       expect(router).toBeDefined();
-      
+
       // Router should be an object (TRPC router)
       expect(typeof router).toBe('object');
       expect(router).toBeDefined();
@@ -75,7 +81,7 @@ describe('TRPC Transparent Client Core Functionality', () => {
     it('should handle provider methods correctly', () => {
       const methods = introspectClient(serverClient);
       const providerNames = [...new Set(methods.map(m => m.providerName))];
-      
+
       // Should have enabled providers
       expect(providerNames).toContain('product');
       expect(providerNames).toContain('search');
@@ -85,24 +91,24 @@ describe('TRPC Transparent Client Core Functionality', () => {
   describe('Method Classification', () => {
     it('should correctly classify query methods', () => {
       const methods = introspectClient(serverClient);
-      
+
       const queryMethods = methods.filter(m => m.isQuery);
       const queryMethodNames = queryMethods.map(m => m.name);
-      
+
       // Should include get* methods from enabled providers
       expect(queryMethodNames).toContain('getById');
       expect(queryMethodNames).toContain('getBySlug');
-      
-      // Should include query* methods  
+
+      // Should include query* methods
       expect(queryMethodNames).toContain('queryByTerm');
     });
 
     it('should correctly classify mutation methods', () => {
       const methods = introspectClient(serverClient);
-      
+
       const mutationMethods = methods.filter(m => m.isMutation);
       const mutationMethodNames = mutationMethods.map(m => m.name);
-      
+
       // With current setup, only search and product are enabled
       // No mutations expected from these providers
     });
@@ -114,7 +120,7 @@ describe('TRPC Transparent Client Core Functionality', () => {
         { slug: 'test-product' },
         session
       );
-      
+
       expect(result).toBeDefined();
       expect(result.slug).toBe('test-product');
       expect(result.name).toBeDefined();
@@ -133,7 +139,7 @@ describe('TRPC Transparent Client Core Functionality', () => {
         },
         session
       );
-      
+
       expect(result).toBeDefined();
       expect(result.products).toBeDefined();
       expect(result.facets).toBeDefined();
@@ -147,7 +153,7 @@ describe('TRPC Transparent Client Core Functionality', () => {
       // Verify the client has expected enabled provider structure
       expect(serverClient.product).toBeDefined();
       expect(serverClient.search).toBeDefined();
-      
+
       // Verify methods exist
       expect(typeof serverClient.product.getById).toBe('function');
       expect(typeof serverClient.product.getBySlug).toBe('function');
@@ -157,4 +163,4 @@ describe('TRPC Transparent Client Core Functionality', () => {
 });
 
 // Export for potential use in other tests
-export { serverClient, router };
+export { serverClient, router };

package/tsconfig.base.json

@@ -5,6 +5,8 @@
     "sourceMap": true,
     "declaration": false,
     "moduleResolution": "node",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
     "importHelpers": true,
     "target": "es2015",
     "module": "esnext",

package/core/src/decorators/trpc.decorators.ts

@@ -1,144 +0,0 @@
-import 'reflect-metadata';
-
-/**
- * Metadata keys for TRPC method decorators
- */
-export const TRPC_QUERY_METADATA_KEY = Symbol('trpc:query');
-export const TRPC_MUTATION_METADATA_KEY = Symbol('trpc:mutation');
-
-
-
-/**
- * Options for TRPC method decorators
- */
-export interface TRPCMethodOptions {
-  /** Custom name for the TRPC procedure (defaults to method name) */
-  name?: string;
-  /** Description for documentation purposes */
-  description?: string;
-}
-
-/**
- * Decorator to mark a provider method as a TRPC query procedure
- * Query procedures are read-only operations (GET-like)
- * 
- * @example
- * ```typescript
- * class ProductProvider extends BaseProvider {
- *   @trpcQuery()
- *   async getById(payload: ProductQueryById, session: Session): Promise<Product> {
- *     // implementation
- *   }
- * 
- *   @trpcQuery({ name: 'findBySlug', description: 'Find product by URL slug' })
- *   async getBySlug(payload: ProductQueryBySlug, session: Session): Promise<Product> {
- *     // implementation
- *   }
- * }
- * ```
- */
-export function trpcQuery(options: TRPCMethodOptions = {}): MethodDecorator {
-  return function (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) {
-    // Store metadata about this method being a TRPC query
-    const metadata = {
-      methodName: String(propertyKey),
-      isQuery: true,
-      isMutation: false,
-      options
-    };
-
-    // Store on the prototype so it's inherited
-    Reflect.defineMetadata(TRPC_QUERY_METADATA_KEY, metadata, target, propertyKey);
-    
-    // Also store a list of all TRPC methods on the class
-    const existingMethods = Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, target.constructor) || [];
-    existingMethods.push({ propertyKey, metadata });
-    Reflect.defineMetadata(TRPC_QUERY_METADATA_KEY, existingMethods, target.constructor);
-  };
-}
-
-/**
- * Decorator to mark a provider method as a TRPC mutation procedure
- * Mutation procedures are write operations that modify state (POST/PUT/DELETE-like)
- * 
- * @example
- * ```typescript
- * class CartProvider extends BaseProvider {
- *   @trpcMutation()
- *   async add(payload: CartAddMutation, session: Session): Promise<Cart> {
- *     // implementation
- *   }
- * 
- *   @trpcMutation({ name: 'removeItem' })
- *   async remove(payload: CartRemoveMutation, session: Session): Promise<Cart> {
- *     // implementation  
- *   }
- * }
- * ```
- */
-export function trpcMutation(options: TRPCMethodOptions = {}): MethodDecorator {
-  return function (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) {
-    // Store metadata about this method being a TRPC mutation
-    const metadata = {
-      methodName: String(propertyKey),
-      isQuery: false,
-      isMutation: true,
-      options
-    };
-
-    // Store on the prototype so it's inherited
-    Reflect.defineMetadata(TRPC_MUTATION_METADATA_KEY, metadata, target, propertyKey);
-    
-    // Also store a list of all TRPC methods on the class
-    const existingMethods = Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, target.constructor) || [];
-    existingMethods.push({ propertyKey, metadata });
-    Reflect.defineMetadata(TRPC_MUTATION_METADATA_KEY, existingMethods, target.constructor);
-  };
-}
-
-/**
- * Get all TRPC query methods from a class or instance
- */
-export function getTRPCQueryMethods(target: any): Array<{ propertyKey: string | symbol; metadata: any }> {
-  const constructor = typeof target === 'function' ? target : target.constructor;
-  return Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, constructor) || [];
-}
-
-/**
- * Get all TRPC mutation methods from a class or instance
- */
-export function getTRPCMutationMethods(target: any): Array<{ propertyKey: string | symbol; metadata: any }> {
-  const constructor = typeof target === 'function' ? target : target.constructor;
-  return Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, constructor) || [];
-}
-
-/**
- * Get all TRPC methods (both queries and mutations) from a class or instance
- */
-export function getAllTRPCMethods(target: any): Array<{ propertyKey: string | symbol; metadata: any }> {
-  return [
-    ...getTRPCQueryMethods(target),
-    ...getTRPCMutationMethods(target)
-  ];
-}
-
-/**
- * Check if a method is marked as a TRPC query
- */
-export function isTRPCQuery(target: any, methodName: string | symbol): boolean {
-  return !!Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, target, methodName);
-}
-
-/**
- * Check if a method is marked as a TRPC mutation
- */
-export function isTRPCMutation(target: any, methodName: string | symbol): boolean {
-  return !!Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, target, methodName);
-}
-
-/**
- * Check if a method is marked for TRPC exposure (query or mutation)
- */
-export function isTRPCMethod(target: any, methodName: string | symbol): boolean {
-  return isTRPCQuery(target, methodName) || isTRPCMutation(target, methodName);
-}