@reactionary/source 0.0.41 → 0.0.48

package/trpc/src/client.ts

@@ -1,4 +1,5 @@
-import { Client, Session } from '@reactionary/core';
+import type { Client, RequestContext} from '@reactionary/core';
+import { Session } from '@reactionary/core';
 import type { TransparentClient } from './types';
 
 /**
@@ -6,72 +7,72 @@ import type { TransparentClient } from './types';
  */
 export interface TRPCClientOptions {
   /** Default session to use if not provided in method calls */
-  defaultSession?: Session;
-  /** Whether to automatically provide session from defaultSession */
-  autoSession?: boolean;
+  defaultRequestContext?: RequestContext
+  /** Whether to automatically provide request context from defaultRequestContext\ */
+  autoRequestContext?: boolean;
 }
 
 /**
  * Create a type-safe client proxy that uses the original client's type interface
  * while routing all calls through TRPC
- * 
+ *
  * @example
  * ```typescript
  * import { createTRPCProxyClient } from '@trpc/client';
  * import { createTRPCClient } from '@reactionary/trpc/client';
- * 
+ *
  * const trpc = createTRPCProxyClient<AppRouter>({
  *   url: 'http://localhost:3000',
  * });
- * 
+ *
  * // Pass the original client type as the generic parameter
  * const client = createTRPCClient<typeof serverClient>(trpc, {
  *   defaultSession: mySession,
  *   autoSession: true
  * });
- * 
+ *
  * // Fully typed using the original client interface!
- * const product = await client.product.getById({ id: '123' }, session);
+ * const product = await client.product.getById({ id: '123' }, reqCtx);
  * ```
  */
 export function createTRPCClient<TOriginalClient extends Partial<Client>>(
   trpcClient: any,
   options: TRPCClientOptions = {}
 ): TransparentClient<TOriginalClient> {
-  const { defaultSession, autoSession = false } = options;
-  
+  const { defaultRequestContext, autoRequestContext = false } = options;
+
   return new Proxy({} as TransparentClient<TOriginalClient>, {
     get(target, providerName: string | symbol) {
       if (typeof providerName !== 'string') {
         return undefined;
       }
-      
+
       // Return a typed proxy for the provider that intercepts method calls
       return new Proxy({}, {
         get(providerTarget, methodName: string | symbol) {
           if (typeof methodName !== 'string') {
             return undefined;
           }
-          
+
           // Only expose methods that are marked with TRPC decorators
           // This eliminates the need to filter TRPC-specific properties
-          return async (payload: any, sessionArg?: Session) => {
-            // Determine session to use
-            let session = sessionArg;
-            if (!session && autoSession && defaultSession) {
-              session = defaultSession;
+          return async (payload: any, reqCtxArg?: RequestContext) => {
+            // Determine request context to use
+            let reqCtx = reqCtxArg;
+            if (!reqCtx && autoRequestContext && defaultRequestContext) {
+              reqCtx = defaultRequestContext;
             }
-            
+
             // Prepare input for TRPC call
             const input = {
               payload,
-              session
+              reqCtx
             };
-            
-            // Access TRPC provider and method lazily 
+
+            // Access TRPC provider and method lazily
             const trpcProvider = trpcClient[providerName];
             const trpcMethod = trpcProvider[methodName];
-            
+
             // Use decorator metadata to determine if this is a query or mutation
             // Note: We can't directly check the original provider here since we only have
             // the TRPC client, so we'll fall back to the router's procedure type detection
@@ -93,20 +94,20 @@ export function createTRPCClient<TOriginalClient extends Partial<Client>>(
  * Session provider interface for dependency injection
  */
 export interface SessionProvider {
-  getSession(): Promise<Session> | Session;
+  getRequestContext(): Promise<RequestContext> | RequestContext;
 }
 
 /**
  * Create a TRPC client with session provider for automatic session management
- * 
+ *
  * @example
  * ```typescript
  * const sessionProvider: SessionProvider = {
  *   getSession: () => getCurrentUserSession()
  * };
- * 
- * const client = createTRPCClientWithSessionProvider(trpc, sessionProvider);
- * 
+ *
+ * const client = createTRPCClientWithSessionProvider(trpc, reqCtxProvider);
+ *
  * // Session is automatically provided, fully typed
  * const product = await client.product.getById({ id: '123' });
  * ```
@@ -120,29 +121,29 @@ export function createTRPCClientWithSessionProvider<TOriginalClient extends Part
       if (typeof providerName !== 'string') {
         return undefined;
       }
-      
+
       return new Proxy({}, {
         get(providerTarget, methodName: string | symbol) {
           if (typeof methodName !== 'string') {
             return undefined;
           }
-          
-          return async (payload: any, sessionArg?: Session) => {
+
+          return async (payload: any, reqCtxArg?: RequestContext) => {
             // If no session provided, get from provider
-            let session = sessionArg;
-            if (!session) {
-              session = await sessionProvider.getSession();
+            let reqCtx = reqCtxArg;
+            if (!reqCtx) {
+              reqCtx = await sessionProvider.getRequestContext();
             }
-            
+
             const input = {
               payload,
-              session
+              reqCtx
             };
-            
+
             // Access TRPC provider and method lazily
             const trpcProvider = trpcClient[providerName];
             const trpcMethod = trpcProvider[methodName];
-            
+
             // Use TRPC client's procedure type detection
             if (trpcMethod?.query) {
               return await trpcMethod.query(input);
@@ -161,14 +162,14 @@ export function createTRPCClientWithSessionProvider<TOriginalClient extends Part
 /**
  * Type alias for creating typed TRPC clients
  * Use the original client type, not the router type
- * 
+ *
  * @example
  * ```typescript
  * type MyClient = typeof serverClient;
- * 
+ *
  * function useClient(): MyClient {
  *   return createTRPCClient<MyClient>(trpcProxyClient);
  * }
  * ```
  */
-export type TRPCClientFromRouter<TOriginalClient> = TOriginalClient;
+export type TRPCClientFromRouter<TOriginalClient> = TOriginalClient;

package/trpc/src/index.ts

@@ -7,7 +7,7 @@ export {
   type TRPCRouterFromClient
 } from './server';
 
-// Re-export client utilities  
+// Re-export client utilities
 export {
   createTRPCClient,
   createTRPCClientWithSessionProvider,
@@ -29,10 +29,11 @@ export {
 
 // Legacy exports for backward compatibility
 import { initTRPC } from '@trpc/server';
-import { Client, Session } from '@reactionary/core';
+import type { Client, RequestContext} from '@reactionary/core';
+import { Session } from '@reactionary/core';
 import { createTRPCTracing } from '@reactionary/otel';
 
-const t = initTRPC.context<{ client: Client; session: Session }>().create({});
+const t = initTRPC.context<{ client: Client; reqCtx: RequestContext }>().create({});
 
 // Always apply tracing middleware - exporters controlled via OTEL env vars
 const basePublicProcedure = t.procedure;

package/trpc/src/integration.spec.ts

@@ -6,7 +6,7 @@ import type { TransparentClient } from './types';
 import { createTRPCProxyClient, httpBatchLink } from '@trpc/client';
 import { createHTTPHandler } from '@trpc/server/adapters/standalone';
 import * as http from 'http';
-import { createAnonymousTestSession } from './test-utils';
+import { createInitialRequestContext } from '@reactionary/core';
 
 /**
  * Integration test that actually starts an HTTP server and makes real network calls
@@ -99,7 +99,7 @@ xdescribe('TRPC Integration Test - Real HTTP Server', () => {
     }
   });
 
-  const session = createAnonymousTestSession();
+  const reqCtx = createInitialRequestContext();
 
   describe('Product Provider via HTTP', () => {
     it('should fetch product by slug through real HTTP calls', async () => {
@@ -108,13 +108,13 @@ xdescribe('TRPC Integration Test - Real HTTP Server', () => {
       // Get result from transparent client (through HTTP/TRPC)
       const trpcResult = await transparentClient.product.getBySlug(
         { slug },
-        session
+        reqCtx
       );
 
       // Get result from server client (direct call)
       const directResult = await serverClient.product.getBySlug(
         { slug },
-        session
+        reqCtx
       );
 
       // Results should have the same structure
@@ -133,12 +133,12 @@ xdescribe('TRPC Integration Test - Real HTTP Server', () => {
 
       const trpcResult = await transparentClient.product.getById(
         { id: productId },
-        session
+        reqCtx
       );
 
       const directResult = await serverClient.product.getById(
         { id: productId },
-        session
+        reqCtx
       );
 
       expect(trpcResult).toBeDefined();
@@ -164,7 +164,7 @@ xdescribe('TRPC Integration Test - Real HTTP Server', () => {
             facets: []
           }
         },
-        session
+        reqCtx
       );
 
       const directResult = await serverClient.search.queryByTerm(
@@ -176,7 +176,7 @@ xdescribe('TRPC Integration Test - Real HTTP Server', () => {
             facets: []
           }
         },
-        session
+        reqCtx
       );
 
       expect(trpcResult).toBeDefined();
@@ -194,7 +194,7 @@ xdescribe('TRPC Integration Test - Real HTTP Server', () => {
       // This should work normally first
       const result = await transparentClient.product.getById(
         { id: 'test-error-handling' },
-        session
+        reqCtx
       );
       expect(result).toBeDefined();
     });
@@ -208,9 +208,9 @@ xdescribe('TRPC Integration Test - Real HTTP Server', () => {
       const [trpcResult, directResult] = await Promise.all([
         transparentClient.product.getById(
           { id: testId },
-          session
+          reqCtx
         ),
-        serverClient.product.getById({ id: testId }, session)
+        serverClient.product.getById({ id: testId }, reqCtx)
       ]);
 
       // Results should be structurally equivalent

package/trpc/src/server.ts

@@ -1,15 +1,17 @@
 import { initTRPC } from '@trpc/server';
-import { Client, Session } from '@reactionary/core';
+import type { Client, RequestContext, Session } from '@reactionary/core';
 import superjson from 'superjson';
 import { z } from 'zod';
 import { createTRPCTracing } from '@reactionary/otel';
-import { 
-  introspectClient, 
+import type {
   MethodInfo
 } from './types';
+import {
+  introspectClient
+} from './types';
 
 // Initialize TRPC with context containing session (no transformer for testing)
-const t = initTRPC.context<{ session?: Session }>().create();
+const t = initTRPC.context<{ reqCtx?: RequestContext }>().create();
 
 export const router = t.router;
 export const mergeRouters = t.mergeRouters;
@@ -21,19 +23,19 @@ const baseProcedure = t.procedure.use(createTRPCTracing());
  * Create a TRPC router from a built client instance
  * This function introspects the client and automatically creates TRPC procedures
  * for all provider methods while maintaining type safety
- * 
+ *
  * @example
  * ```typescript
  * const client = buildClient([
  *   withFakeCapabilities(config, { product: true, search: true })
  * ]);
- * 
+ *
  * const router = createTRPCServerRouter(client);
  * ```
  */
 export function createTRPCServerRouter<T extends Partial<Client>>(client: T) {
   const methods = introspectClient(client);
-  
+
   // Group methods by provider
   const providerMethods = methods.reduce((acc, method) => {
     if (!acc[method.providerName]) {
@@ -42,21 +44,21 @@ export function createTRPCServerRouter<T extends Partial<Client>>(client: T) {
     acc[method.providerName].push(method);
     return acc;
   }, {} as Record<string, MethodInfo[]>);
-  
+
   // Build router structure
   const routes: Record<string, any> = {};
-  
+
   for (const [providerName, providerMethodsList] of Object.entries(providerMethods)) {
     const providerRoutes: Record<string, any> = {};
-    
+
     for (const methodInfo of providerMethodsList) {
       const procedure = createProcedureForMethod(methodInfo);
       providerRoutes[methodInfo.name] = procedure;
     }
-    
+
     routes[providerName] = t.router(providerRoutes);
   }
-  
+
   return t.router(routes);
 }
 
@@ -68,18 +70,18 @@ function createProcedureForMethod(methodInfo: MethodInfo) {
   // the original method signatures without requiring schema definitions
   const inputSchema = z.object({
     payload: z.any(), // The actual payload from the provider method
-    session: z.any().optional(), // Session is optional in input since it might come from context
+    reqCtx: z.any().optional(), // Session is optional in input since it might come from context
   });
-  
+
   const procedureWithInput = baseProcedure.input(inputSchema);
-  
+
   if (methodInfo.isQuery) {
     return procedureWithInput.query(async ({ input, ctx }) => {
-      const session = input.session || ctx.session;
-      
+      const reqCtx = input.reqCtx || ctx.reqCtx;
+
       // Call the original provider method
-      if (session) {
-        return await methodInfo.method(input.payload, session);
+      if (reqCtx) {
+        return await methodInfo.method(input.payload, reqCtx);
       } else {
         // Some methods might not require session
         return await methodInfo.method(input.payload);
@@ -87,11 +89,11 @@ function createProcedureForMethod(methodInfo: MethodInfo) {
     });
   } else if (methodInfo.isMutation) {
     return procedureWithInput.mutation(async ({ input, ctx }) => {
-      const session = input.session || ctx.session;
-      
+      const reqCtx = input.reqCtx || ctx.reqCtx;
+
       // Call the original provider method
-      if (session) {
-        return await methodInfo.method(input.payload, session);
+      if (reqCtx) {
+        return await methodInfo.method(input.payload, reqCtx);
       } else {
         // Some methods might not require session
         return await methodInfo.method(input.payload);
@@ -120,4 +122,4 @@ export function createTRPCContext(_opts: { req?: any; res?: any }) {
 }
 
 // Create publicProcedure here to avoid circular imports
-export const publicProcedure = baseProcedure;
+export const publicProcedure = baseProcedure;

package/trpc/src/test-utils.ts

@@ -1,4 +1,4 @@
-import { Session } from '@reactionary/core';
+import type { Session } from '@reactionary/core';
 
 export function createAnonymousTestSession(): Session {
   return {
@@ -9,10 +9,15 @@ export function createAnonymousTestSession(): Session {
         cache: { hit: false, key: '' },
         placeholder: false,
       },
-      id: '',
+      id: { userId: 'anonymous' },
       token: undefined,
       issued: new Date(),
-      expiry: new Date(new Date().getTime() + 3600 * 1000), // 1 hour from now
+      expiry: new Date(new Date().getTime() + 3600 * 1000),
+      logonId: "",
+      createdAt: "",
+      updatedAt: "",
+      keyring: [],
+      currentService: undefined
     },
     languageContext: {
       locale: 'en-US',
@@ -23,4 +28,4 @@ export function createAnonymousTestSession(): Session {
       key: 'the-good-store',
     },
   };
-}
+}

package/trpc/src/types.ts

@@ -1,17 +1,19 @@
-import { 
-  BaseProvider, 
-  Client, 
-  Session
+import type {
+  Client,
+  RequestContext,
+  Session} from '@reactionary/core';
+import {
+  BaseProvider
 } from '@reactionary/core';
 
 /**
  * Extract method names from a provider that match TRPC patterns
  */
-export type ProviderMethods<T> = T extends BaseProvider 
+export type ProviderMethods<T> = T extends BaseProvider
   ? {
-      [K in keyof T]: T[K] extends (...args: any[]) => any 
+      [K in keyof T]: T[K] extends (...args: any[]) => any
         ? K extends `get${string}` | `query${string}` | 'add' | 'remove' | 'changeQuantity' | 'login' | 'logout' | 'getSelf'
-          ? K 
+          ? K
           : never
         : never
     }[keyof T]
@@ -20,8 +22,8 @@ export type ProviderMethods<T> = T extends BaseProvider
 /**
  * Extract method signature from a provider method
  */
-export type ProviderMethodSignature<T, K extends keyof T> = 
-  T[K] extends (...args: infer Args) => infer Return 
+export type ProviderMethodSignature<T, K extends keyof T> =
+  T[K] extends (...args: infer Args) => infer Return
     ? (...args: Args) => Return
     : never;
 
@@ -29,7 +31,7 @@ export type ProviderMethodSignature<T, K extends keyof T> =
  * Map all methods of all providers in a client
  */
 export type ClientMethodMap<T extends Partial<Client>> = {
-  [K in keyof T]: T[K] extends BaseProvider 
+  [K in keyof T]: T[K] extends BaseProvider
     ? {
         [M in ProviderMethods<T[K]>]: ProviderMethodSignature<T[K], M>
       }
@@ -41,7 +43,7 @@ export type ClientMethodMap<T extends Partial<Client>> = {
  * Create transparent client that only includes methods matching TRPC patterns
  */
 export type TransparentClient<T extends Partial<Client>> = {
-  [K in keyof T]: T[K] extends BaseProvider 
+  [K in keyof T]: T[K] extends BaseProvider
     ? {
         [M in ProviderMethods<T[K]>]: ProviderMethodSignature<T[K], M>
       }
@@ -64,7 +66,7 @@ export interface MethodInfo {
  * Utility to determine if a method is a query or mutation based on naming convention
  */
 export function isQueryMethod(methodName: string): boolean {
-  return methodName.startsWith('get') || 
+  return methodName.startsWith('get') ||
          methodName.startsWith('query') ||
          methodName === 'getSelf';
 }
@@ -84,7 +86,7 @@ export function isMutationMethod(methodName: string): boolean {
  */
 export function introspectClient<T extends Partial<Client>>(client: T): MethodInfo[] {
   const methods: MethodInfo[] = [];
-  
+
   for (const [providerName, provider] of Object.entries(client)) {
     if (provider instanceof BaseProvider) {
       // Get all methods that match our naming patterns
@@ -104,7 +106,7 @@ export function introspectClient<T extends Partial<Client>>(client: T): MethodIn
       }
     }
   }
-  
+
   return methods;
 }
 
@@ -119,24 +121,24 @@ export interface TRPCMethodInput<TPayload = any> {
 /**
  * Helper to extract payload type from a provider method
  */
-export type ExtractPayloadType<T> = T extends (payload: infer P, session: Session) => any 
-  ? P 
-  : T extends (payload: infer P) => any 
+export type ExtractPayloadType<T> = T extends (payload: infer P, reqCtx: RequestContext) => any
+  ? P
+  : T extends (payload: infer P) => any
   ? P
   : never;
 
 /**
  * Helper to extract return type from a provider method
  */
-export type ExtractReturnType<T> = T extends (...args: any[]) => infer R 
-  ? R 
+export type ExtractReturnType<T> = T extends (...args: any[]) => infer R
+  ? R
   : never;
 
 /**
  * Create a TRPC-compatible method signature from a provider method
  */
-export type TRPCMethodSignature<T> = T extends (payload: infer P, session: Session) => infer R
+export type TRPCMethodSignature<T> = T extends (payload: infer P, reqCtx: RequestContext) => infer R
   ? (input: TRPCMethodInput<P>) => R
   : T extends (payload: infer P) => infer R
-  ? (input: TRPCMethodInput<P>) => R  
-  : never;
+  ? (input: TRPCMethodInput<P>) => R
+  : never;

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

@@ -1,19 +0,0 @@
-/**
- * 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/examples/node/src/test-utils.ts

@@ -1,26 +0,0 @@
-import { Session } from '@reactionary/core';
-
-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',
-    },
-  };
-}