@reactionary/source 0.0.30 → 0.0.32

package/trpc/src/integration.spec.ts

@@ -0,0 +1,216 @@
+import { buildClient, NoOpCache, SessionSchema } from '@reactionary/core';
+import { withFakeCapabilities } from '@reactionary/provider-fake';
+import { createTRPCServerRouter, createTRPCContext, type TRPCRouterFromClient } from './server';
+import { createTRPCClient, type TRPCClientFromRouter } from './client';
+import type { TransparentClient } from './types';
+import { createTRPCProxyClient, httpBatchLink } from '@trpc/client';
+import { createHTTPHandler } from '@trpc/server/adapters/standalone';
+import * as http from 'http';
+
+/**
+ * Integration test that actually starts an HTTP server and makes real network calls
+ * This is the real test that verifies the TRPC transparent transport works end-to-end
+ */
+
+// Polyfill fetch for Node.js
+global.fetch = global.fetch || require('node-fetch');
+
+// Create the server-side client
+const serverClient = buildClient(
+  [
+    withFakeCapabilities(
+      {
+        jitter: { mean: 0, deviation: 0 },
+      },
+      { search: true, product: true, identity: false }
+    ),
+  ],
+  { cache: new NoOpCache() }
+);
+
+// Create TRPC router from the client (do this at module level for type inference)
+const router = createTRPCServerRouter(serverClient);
+type AppRouter = typeof router;
+
+describe('TRPC Integration Test - Real HTTP Server', () => {
+  let server: http.Server;
+  let serverPort: number;
+  let trpcProxyClient: ReturnType<typeof createTRPCProxyClient<AppRouter>>;
+  let transparentClient: TransparentClient<typeof serverClient>;
+
+  beforeAll(async () => {
+
+    // Create TRPC HTTP handler
+    const handler = createHTTPHandler({
+      router,
+      createContext: createTRPCContext,
+    });
+
+    // Start HTTP server with TRPC handler
+    server = http.createServer(handler);
+
+    // Find available port
+    serverPort = 3001;
+    await new Promise<void>((resolve, reject) => {
+      const tryPort = (port: number) => {
+        server.listen(port, (err?: Error) => {
+          if (err) {
+            if (port < 3010) {
+              tryPort(port + 1);
+            } else {
+              reject(err);
+            }
+          } else {
+            serverPort = port;
+            resolve();
+          }
+        });
+      };
+      tryPort(serverPort);
+    });
+
+    // Create real TRPC proxy client (no transformer for testing)
+    trpcProxyClient = createTRPCProxyClient<AppRouter>({
+      links: [
+        httpBatchLink({
+          url: `http://localhost:${serverPort}`,
+        }),
+      ],
+    });
+
+    // Create transparent client using the real implementation - now properly typed!
+    transparentClient = createTRPCClient<typeof serverClient>(trpcProxyClient);
+  });
+
+  afterAll(async () => {
+    if (server) {
+      await new Promise<void>((resolve) => {
+        server.close(() => resolve());
+      });
+    }
+  });
+
+  const session = SessionSchema.parse({
+    id: '1234567890',
+  });
+
+  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)  
+      const directResult = await serverClient.product.getBySlug(
+        { slug },
+        session
+      );
+
+      // Results should have the same structure
+      expect(trpcResult).toBeDefined();
+      expect(trpcResult.slug).toBe(slug);
+      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
+      );
+
+      const directResult = await serverClient.product.getById(
+        { id: productId },
+        session
+      );
+
+      expect(trpcResult).toBeDefined();
+      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);
+    });
+  });
+
+  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: {
+            term: searchTerm,
+            page: 0,
+            pageSize: 10,
+            facets: []
+          }
+        },
+        session
+      );
+
+      const directResult = await serverClient.search.queryByTerm(
+        {
+          search: {
+            term: searchTerm,
+            page: 0,
+            pageSize: 10,
+            facets: []
+          }
+        },
+        session
+      );
+
+      expect(trpcResult).toBeDefined();
+      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);
+    });
+  });
+
+  describe('Network Error Handling', () => {
+    it('should handle HTTP errors gracefully', async () => {
+      // This should work normally first
+      const result = await transparentClient.product.getById(
+        { id: 'test-error-handling' },
+        session
+      );
+      expect(result).toBeDefined();
+    });
+  });
+
+  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(
+          { id: testId },
+          session
+        ),
+        serverClient.product.getById({ id: testId }, session)
+      ]);
+
+      // Results should be structurally equivalent
+      expect(trpcResult.identifier.key).toBe(directResult.identifier.key);
+      expect(trpcResult.name).toBe(directResult.name);
+      expect(trpcResult.slug).toBe(directResult.slug);
+      expect(trpcResult.description).toBe(directResult.description);
+    });
+  });
+});

package/trpc/src/server.ts

@@ -0,0 +1,123 @@
+import { initTRPC } from '@trpc/server';
+import { Client, Session } from '@reactionary/core';
+import superjson from 'superjson';
+import { z } from 'zod';
+import { createTRPCTracing } from '@reactionary/otel';
+import { 
+  introspectClient, 
+  MethodInfo
+} from './types';
+
+// Initialize TRPC with context containing session (no transformer for testing)
+const t = initTRPC.context<{ session?: Session }>().create();
+
+export const router = t.router;
+export const mergeRouters = t.mergeRouters;
+
+// Apply tracing middleware
+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]) {
+      acc[method.providerName] = [];
+    }
+    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);
+}
+
+/**
+ * Create a TRPC procedure for a specific provider method
+ */
+function createProcedureForMethod(methodInfo: MethodInfo) {
+  // Create input schema - we use a flexible schema since we want to preserve
+  // 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
+  });
+  
+  const procedureWithInput = baseProcedure.input(inputSchema);
+  
+  if (methodInfo.isQuery) {
+    return procedureWithInput.query(async ({ input, ctx }) => {
+      const session = input.session || ctx.session;
+      
+      // Call the original provider method
+      if (session) {
+        return await methodInfo.method(input.payload, session);
+      } else {
+        // Some methods might not require session
+        return await methodInfo.method(input.payload);
+      }
+    });
+  } else if (methodInfo.isMutation) {
+    return procedureWithInput.mutation(async ({ input, ctx }) => {
+      const session = input.session || ctx.session;
+      
+      // Call the original provider method
+      if (session) {
+        return await methodInfo.method(input.payload, session);
+      } else {
+        // Some methods might not require session
+        return await methodInfo.method(input.payload);
+      }
+    });
+  } else {
+    throw new Error(`Method ${methodInfo.name} is neither query nor mutation`);
+  }
+}
+
+/**
+ * Type helper to extract the router type from a client
+ * This enables full type safety on the client side
+ */
+export type TRPCRouterFromClient<T extends Partial<Client>> = ReturnType<typeof createTRPCServerRouter<T>>;
+
+/**
+ * Context creator for TRPC server
+ * Override this to provide session from your authentication system
+ */
+export function createTRPCContext(_opts: { req?: any; res?: any }) {
+  // Default implementation - you should override this based on your auth system
+  return {
+    session: undefined as Session | undefined,
+  };
+}
+
+// Create publicProcedure here to avoid circular imports
+export const publicProcedure = baseProcedure;

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

@@ -0,0 +1,160 @@
+import { buildClient, NoOpCache, SessionSchema } from '@reactionary/core';
+import { withFakeCapabilities } from '@reactionary/provider-fake';
+import { createTRPCServerRouter, introspectClient } from './index';
+
+/**
+ * Test suite for TRPC transparent client functionality
+ * This tests the core introspection and router generation without HTTP setup
+ */
+
+// Jest test framework is now available
+
+// Create the server-side client using the same pattern as examples/node
+const serverClient = buildClient(
+  [
+    withFakeCapabilities(
+      {
+        jitter: {
+          mean: 0,
+          deviation: 0,
+        },
+      },
+      { search: true, product: true, identity: false }
+    ),
+  ],
+  {
+    cache: new NoOpCache(),
+  }
+);
+
+// Create TRPC router from the client
+const router = createTRPCServerRouter(serverClient);
+
+describe('TRPC Transparent Client Core Functionality', () => {
+
+  const session = SessionSchema.parse({
+    id: '1234567890',
+  });
+
+  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);
+      expect(getBySlugMethod!.isMutation).toBe(false);
+
+      // 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);
+
+      // Note: Only testing enabled providers (product and search)
+    });
+  });
+
+  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();
+    });
+
+    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');
+    });
+  });
+
+  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  
+      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
+    });
+  });
+
+  describe('Direct Client Functionality', () => {
+    it('should have working product provider', async () => {
+      const result = await serverClient.product.getBySlug(
+        { slug: 'test-product' },
+        session
+      );
+      
+      expect(result).toBeDefined();
+      expect(result.slug).toBe('test-product');
+      expect(result.name).toBeDefined();
+      expect(result.description).toBeDefined();
+    });
+
+    it('should have working search provider', async () => {
+      const result = await serverClient.search.queryByTerm(
+        {
+          search: {
+            term: 'test search',
+            page: 0,
+            pageSize: 10,
+            facets: []
+          }
+        },
+        session
+      );
+      
+      expect(result).toBeDefined();
+      expect(result.products).toBeDefined();
+      expect(result.facets).toBeDefined();
+    });
+
+    // Only testing enabled providers (product and search)
+  });
+
+  describe('Type System Validation', () => {
+    it('should maintain provider interface structure', () => {
+      // 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');
+      expect(typeof serverClient.search.queryByTerm).toBe('function');
+    });
+  });
+});
+
+// Export for potential use in other tests
+export { serverClient, router };

package/trpc/src/types.ts

@@ -0,0 +1,142 @@
+import { 
+  BaseProvider, 
+  Client, 
+  Session
+} from '@reactionary/core';
+
+/**
+ * Extract method names from a provider that match TRPC patterns
+ */
+export type ProviderMethods<T> = T extends BaseProvider 
+  ? {
+      [K in keyof T]: T[K] extends (...args: any[]) => any 
+        ? K extends `get${string}` | `query${string}` | 'add' | 'remove' | 'changeQuantity' | 'login' | 'logout' | 'getSelf'
+          ? K 
+          : never
+        : never
+    }[keyof T]
+  : never;
+
+/**
+ * Extract method signature from a provider method
+ */
+export type ProviderMethodSignature<T, K extends keyof T> = 
+  T[K] extends (...args: infer Args) => infer Return 
+    ? (...args: Args) => Return
+    : never;
+
+/**
+ * Map all methods of all providers in a client
+ */
+export type ClientMethodMap<T extends Partial<Client>> = {
+  [K in keyof T]: T[K] extends BaseProvider 
+    ? {
+        [M in ProviderMethods<T[K]>]: ProviderMethodSignature<T[K], M>
+      }
+    : never;
+};
+
+
+/**
+ * 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 
+    ? {
+        [M in ProviderMethods<T[K]>]: ProviderMethodSignature<T[K], M>
+      }
+    : never;
+};
+
+/**
+ * Extract method information for TRPC procedure creation
+ */
+export interface MethodInfo {
+  name: string;
+  providerName: string;
+  isQuery: boolean;
+  isMutation: boolean;
+  method: (...args: any[]) => any;
+}
+
+
+/**
+ * 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') || 
+         methodName.startsWith('query') ||
+         methodName === 'getSelf';
+}
+
+export function isMutationMethod(methodName: string): boolean {
+  return !isQueryMethod(methodName) && (
+    methodName === 'add' ||
+    methodName === 'remove' ||
+    methodName === 'changeQuantity' ||
+    methodName === 'login' ||
+    methodName === 'logout'
+  );
+}
+
+/**
+ * Introspect a client instance to extract all provider methods matching naming patterns
+ */
+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
+      for (const key of Object.getOwnPropertyNames(Object.getPrototypeOf(provider))) {
+        const method = (provider as any)[key];
+        if (typeof method === 'function' && key !== 'constructor') {
+          if (isQueryMethod(key) || isMutationMethod(key)) {
+            methods.push({
+              name: key,
+              providerName,
+              isQuery: isQueryMethod(key),
+              isMutation: isMutationMethod(key),
+              method: method.bind(provider)
+            });
+          }
+        }
+      }
+    }
+  }
+  
+  return methods;
+}
+
+/**
+ * Type for TRPC procedure input - includes payload and session
+ */
+export interface TRPCMethodInput<TPayload = any> {
+  payload: TPayload;
+  session?: Session;
+}
+
+/**
+ * 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 
+  ? P
+  : never;
+
+/**
+ * Helper to extract return type from a provider method
+ */
+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
+  ? (input: TRPCMethodInput<P>) => R
+  : T extends (payload: infer P) => infer R
+  ? (input: TRPCMethodInput<P>) => R  
+  : never;

package/trpc/tsconfig.json

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

package/trpc/tsconfig.lib.json

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

package/trpc/tsconfig.spec.json

@@ -0,0 +1,15 @@
+{
+  "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/**/*.d.ts"
+  ]
+}

package/tsconfig.base.json

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