@reactionary/source 0.0.48 → 0.0.52

package/trpc/src/client.ts

@@ -1,175 +0,0 @@
-import type { Client, RequestContext} from '@reactionary/core';
-import { Session } from '@reactionary/core';
-import type { TransparentClient } from './types';
-
-/**
- * Configuration options for TRPC client creation
- */
-export interface TRPCClientOptions {
-  /** Default session to use if not provided in method calls */
-  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' }, reqCtx);
- * ```
- */
-export function createTRPCClient<TOriginalClient extends Partial<Client>>(
-  trpcClient: any,
-  options: TRPCClientOptions = {}
-): TransparentClient<TOriginalClient> {
-  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, reqCtxArg?: RequestContext) => {
-            // Determine request context to use
-            let reqCtx = reqCtxArg;
-            if (!reqCtx && autoRequestContext && defaultRequestContext) {
-              reqCtx = defaultRequestContext;
-            }
-
-            // Prepare input for TRPC call
-            const input = {
-              payload,
-              reqCtx
-            };
-
-            // 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
-            if (trpcMethod?.query) {
-              return await trpcMethod.query(input);
-            } else if (trpcMethod?.mutate) {
-              return await trpcMethod.mutate(input);
-            } else {
-              throw new Error(`Method ${String(providerName)}.${String(methodName)} not found on TRPC client`);
-            }
-          };
-        }
-      });
-    }
-  });
-}
-
-/**
- * Session provider interface for dependency injection
- */
-export interface SessionProvider {
-  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, reqCtxProvider);
- *
- * // Session is automatically provided, fully typed
- * const product = await client.product.getById({ id: '123' });
- * ```
- */
-export function createTRPCClientWithSessionProvider<TOriginalClient extends Partial<Client>>(
-  trpcClient: any,
-  sessionProvider: SessionProvider
-): TransparentClient<TOriginalClient> {
-  return new Proxy({} as TransparentClient<TOriginalClient>, {
-    get(target, providerName: string | symbol) {
-      if (typeof providerName !== 'string') {
-        return undefined;
-      }
-
-      return new Proxy({}, {
-        get(providerTarget, methodName: string | symbol) {
-          if (typeof methodName !== 'string') {
-            return undefined;
-          }
-
-          return async (payload: any, reqCtxArg?: RequestContext) => {
-            // If no session provided, get from provider
-            let reqCtx = reqCtxArg;
-            if (!reqCtx) {
-              reqCtx = await sessionProvider.getRequestContext();
-            }
-
-            const input = {
-              payload,
-              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);
-            } else if (trpcMethod?.mutate) {
-              return await trpcMethod.mutate(input);
-            } else {
-              throw new Error(`Method ${String(providerName)}.${String(methodName)} not found on TRPC client`);
-            }
-          };
-        }
-      });
-    }
-  });
-}
-
-/**
- * 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;

package/trpc/src/index.ts

@@ -1,44 +0,0 @@
-// Re-export server utilities
-export {
-  createTRPCServerRouter,
-  createTRPCContext,
-  router,
-  mergeRouters,
-  type TRPCRouterFromClient
-} from './server';
-
-// Re-export client utilities
-export {
-  createTRPCClient,
-  createTRPCClientWithSessionProvider,
-  type TRPCClientOptions,
-  type SessionProvider,
-  type TRPCClientFromRouter
-} from './client';
-
-// Re-export type utilities
-export {
-  type ClientMethodMap,
-  type MethodInfo,
-  type TRPCMethodInput,
-  type TransparentClient,
-  introspectClient,
-  isQueryMethod,
-  isMutationMethod
-} from './types';
-
-// Legacy exports for backward compatibility
-import { initTRPC } from '@trpc/server';
-import type { Client, RequestContext} from '@reactionary/core';
-import { Session } from '@reactionary/core';
-import { createTRPCTracing } from '@reactionary/otel';
-
-const t = initTRPC.context<{ client: Client; reqCtx: RequestContext }>().create({});
-
-// Always apply tracing middleware - exporters controlled via OTEL env vars
-const basePublicProcedure = t.procedure;
-export const publicProcedure = basePublicProcedure.use(createTRPCTracing());
-
-// Legacy function - deprecated, use createTRPCServerRouter instead
-import { createTRPCServerRouter } from './server';
-export const createTRPCRouter = createTRPCServerRouter;

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 {
-    session: undefined as Session | undefined,
-  };
-}
-
-// Create publicProcedure here to avoid circular imports
-export const publicProcedure = baseProcedure;

package/trpc/src/test-utils.ts

@@ -1,31 +0,0 @@
-import type { Session } from '@reactionary/core';
-
-export function createAnonymousTestSession(): Session {
-  return {
-    id: 'test-session-id',
-    identity: {
-      type: 'Anonymous',
-      meta: {
-        cache: { hit: false, key: '' },
-        placeholder: false,
-      },
-      id: { userId: 'anonymous' },
-      token: undefined,
-      issued: new Date(),
-      expiry: new Date(new Date().getTime() + 3600 * 1000),
-      logonId: "",
-      createdAt: "",
-      updatedAt: "",
-      keyring: [],
-      currentService: undefined
-    },
-    languageContext: {
-      locale: 'en-US',
-      currencyCode: 'USD',
-      countryCode: 'US',
-    },
-    storeIdentifier: {
-      key: 'the-good-store',
-    },
-  };
-}