@reactionary/source 0.0.51 → 0.2.15

package/trpc/src/integration.spec.ts

@@ -1,223 +0,0 @@
-import { ClientBuilder, NoOpCache } from '@reactionary/core';
-import { withFakeCapabilities } from '@reactionary/provider-fake';
-import { createTRPCServerRouter, createTRPCContext } from './server';
-import { createTRPCClient } 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';
-import { createInitialRequestContext } from '@reactionary/core';
-
-/**
- * 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 = new ClientBuilder()
-    .withCapability(
-      withFakeCapabilities(
-        {
-          jitter: {
-            mean: 0,
-            deviation: 0,
-          },
-          seeds: {
-            category: 1,
-            product: 1,
-            search: 1
-          }
-        },
-        { search: true, product: true, identity: false }
-      )
-    )
-    .withCache(new NoOpCache())
-    .build();
-
-// Create TRPC router from the client (do this at module level for type inference)
-const router = createTRPCServerRouter(serverClient);
-type AppRouter = typeof router;
-
-xdescribe('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 reqCtx = createInitialRequestContext();
-
-  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 },
-        reqCtx
-      );
-
-      // Get result from server client (direct call)
-      const directResult = await serverClient.product.getBySlug(
-        { slug },
-        reqCtx
-      );
-
-      // 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 },
-        reqCtx
-      );
-
-      const directResult = await serverClient.product.getById(
-        { id: productId },
-        reqCtx
-      );
-
-      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: []
-          }
-        },
-        reqCtx
-      );
-
-      const directResult = await serverClient.search.queryByTerm(
-        {
-          search: {
-            term: searchTerm,
-            page: 0,
-            pageSize: 10,
-            facets: []
-          }
-        },
-        reqCtx
-      );
-
-      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' },
-        reqCtx
-      );
-      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 },
-          reqCtx
-        ),
-        serverClient.product.getById({ id: testId }, reqCtx)
-      ]);
-
-      // 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

@@ -1,125 +0,0 @@
-import { initTRPC } from '@trpc/server';
-import type { Client, RequestContext, Session } from '@reactionary/core';
-import superjson from 'superjson';
-import { z } from 'zod';
-import { createTRPCTracing } from '@reactionary/otel';
-import type {
-  MethodInfo
-} from './types';
-import {
-  introspectClient
-} from './types';
-
-// Initialize TRPC with context containing session (no transformer for testing)
-const t = initTRPC.context<{ reqCtx?: RequestContext }>().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
-    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 reqCtx = input.reqCtx || ctx.reqCtx;
-
-      // Call the original provider method
-      if (reqCtx) {
-        return await methodInfo.method(input.payload, reqCtx);
-      } else {
-        // Some methods might not require session
-        return await methodInfo.method(input.payload);
-      }
-    });
-  } else if (methodInfo.isMutation) {
-    return procedureWithInput.mutation(async ({ input, ctx }) => {
-      const reqCtx = input.reqCtx || ctx.reqCtx;
-
-      // Call the original provider method
-      if (reqCtx) {
-        return await methodInfo.method(input.payload, reqCtx);
-      } 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 {
-    reqCtx: undefined as RequestContext | undefined,
-  };
-}
-
-// Create publicProcedure here to avoid circular imports
-export const publicProcedure = baseProcedure;

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

@@ -1,161 +0,0 @@
-import { ClientBuilder, createInitialRequestContext, NoOpCache } 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 = new ClientBuilder()
-    .withCapability(
-      withFakeCapabilities(
-        {
-          jitter: {
-            mean: 0,
-            deviation: 0,
-          },
-          seeds: {
-            category: 1,
-            product: 1,
-            search: 1
-          }
-        },
-        { search: true, product: true, identity: false }
-      )
-    )
-    .withCache(new NoOpCache())
-    .build();
-
-// Create TRPC router from the client
-const router = createTRPCServerRouter(serverClient);
-
-xdescribe('TRPC Transparent Client Core Functionality', () => {
-
-  const reqCtx = createInitialRequestContext();
-
-  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' },
-        reqCtx
-      );
-
-      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: []
-          }
-        },
-        reqCtx
-      );
-
-      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

@@ -1,144 +0,0 @@
-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
-  ? {
-      [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, 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
-  : never;
-
-/**
- * Create a TRPC-compatible method signature from a provider method
- */
-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;

package/trpc/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "extends": "../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "commonjs"
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/trpc/tsconfig.spec.json

@@ -1,15 +0,0 @@
-{
-  "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"
-  ]
-}