@reactionary/source 0.0.48 → 0.0.52

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

@@ -1,162 +0,0 @@
-import { ClientBuilder, NoOpCache } from '@reactionary/core';
-import { withFakeCapabilities } from '@reactionary/provider-fake';
-import { createTRPCServerRouter, introspectClient } from './index';
-import { createAnonymousTestSession } from './test-utils';
-
-/**
- * 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 session = createAnonymousTestSession();
-
-  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

@@ -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.lib.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
-}

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"
-  ]
-}