@reactionary/source 0.0.31 → 0.0.32

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",

package/examples/angular/e2e/example.spec.ts

@@ -1,9 +0,0 @@
-import { test, expect } from '@playwright/test';
-
-test('displays search results', async ({ page }) => {
-  await page.goto('/');
-
-  await page.waitForSelector('article', { state: 'visible' });
-
-  expect(await page.locator('article').count()).toBe(20);
-});

package/examples/angular/eslint.config.mjs

@@ -1,41 +0,0 @@
-import playwright from 'eslint-plugin-playwright';
-import nx from '@nx/eslint-plugin';
-import baseConfig from '../../eslint.config.mjs';
-
-export default [
-  playwright.configs['flat/recommended'],
-  ...baseConfig,
-  ...nx.configs['flat/angular'],
-  ...nx.configs['flat/angular-template'],
-  {
-    files: ['**/*.ts'],
-    rules: {
-      '@angular-eslint/directive-selector': [
-        'error',
-        {
-          type: 'attribute',
-          prefix: 'app',
-          style: 'camelCase',
-        },
-      ],
-      '@angular-eslint/component-selector': [
-        'error',
-        {
-          type: 'element',
-          prefix: 'app',
-          style: 'kebab-case',
-        },
-      ],
-    },
-  },
-  {
-    files: ['**/*.html'],
-    // Override or add rules here
-    rules: {},
-  },
-  {
-    files: ['**/*.ts', '**/*.js'],
-    // Override or add rules here
-    rules: {},
-  },
-];

package/examples/angular/playwright.config.ts

@@ -1,38 +0,0 @@
-import { defineConfig, devices } from '@playwright/test';
-import { nxE2EPreset } from '@nx/playwright/preset';
-import { workspaceRoot } from '@nx/devkit';
-
-// For CI, you may want to set BASE_URL to the deployed application.
-const baseURL = process.env['BASE_URL'] || 'http://localhost:4200';
-
-/**
- * Read environment variables from file.
- * https://github.com/motdotla/dotenv
- */
-// require('dotenv').config();
-
-/**
- * See https://playwright.dev/docs/test-configuration.
- */
-export default defineConfig({
-  ...nxE2EPreset(__filename, { testDir: './e2e' }),
-  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
-  use: {
-    baseURL,
-    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
-    trace: 'on-first-retry',
-  },
-  /* Run your local dev server before starting the tests */
-  webServer: {
-    command: 'npx nx serve examples-angular',
-    url: 'http://localhost:4200',
-    reuseExistingServer: !process.env.CI,
-    cwd: workspaceRoot,
-  },
-  projects: [
-    {
-      name: 'chromium',
-      use: { ...devices['Desktop Chrome'] },
-    },
-  ],
-});

package/examples/angular/project.json

@@ -1,86 +0,0 @@
-{
-  "name": "examples-angular",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "projectType": "application",
-  "prefix": "app",
-  "sourceRoot": "examples/angular/src",
-  "tags": [],
-  "targets": {
-    "build": {
-      "executor": "@angular-devkit/build-angular:application",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "outputPath": "dist/examples/angular",
-        "index": "examples/angular/src/index.html",
-        "browser": "examples/angular/src/main.ts",
-        "polyfills": [],
-        "tsConfig": "examples/angular/tsconfig.app.json",
-        "inlineStyleLanguage": "scss",
-        "assets": [
-          {
-            "glob": "**/*",
-            "input": "examples/angular/public"
-          }
-        ],
-        "styles": ["examples/angular/src/styles.scss"],
-        "scripts": []
-      },
-      "configurations": {
-        "production": {
-          "budgets": [
-            {
-              "type": "initial",
-              "maximumWarning": "500kb",
-              "maximumError": "1mb"
-            },
-            {
-              "type": "anyComponentStyle",
-              "maximumWarning": "4kb",
-              "maximumError": "8kb"
-            }
-          ],
-          "outputHashing": "all"
-        },
-        "development": {
-          "optimization": false,
-          "extractLicenses": false,
-          "sourceMap": true
-        }
-      },
-      "defaultConfiguration": "production"
-    },
-    "serve": {
-      "executor": "@angular-devkit/build-angular:dev-server",
-      "configurations": {
-        "production": {
-          "buildTarget": "examples-angular:build:production"
-        },
-        "development": {
-          "buildTarget": "examples-angular:build:development"
-        }
-      },
-      "defaultConfiguration": "development",
-      "continuous": true,
-      "dependsOn": [
-        { "projects": ["trpc-node"], "target": "serve" }
-      ]
-    },
-    "extract-i18n": {
-      "executor": "@angular-devkit/build-angular:extract-i18n",
-      "options": {
-        "buildTarget": "examples-angular:build"
-      }
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint"
-    },
-    "serve-static": {
-      "executor": "@nx/web:file-server",
-      "options": {
-        "buildTarget": "examples-angular:build",
-        "staticFilePath": "dist/examples/angular/browser",
-        "spa": true
-      }
-    }
-  }
-}

package/examples/angular/src/app/app.component.html

@@ -1,6 +0,0 @@
-<header>
-    <input (keydown)="this.service.term.set(inputTerm.value)" #inputTerm/>
-</header>
-<main>
-    <router-outlet></router-outlet>
-</main>

package/examples/angular/src/app/app.component.scss

@@ -1,22 +0,0 @@
-:host {
-  display: block;
-}
-
-header {
-  padding: 0.5rem;
-
-  input {
-    padding-inline: 1rem;
-    color: rgb(205, 214, 244);
-    background: rgb(88, 91, 112);
-    width: 100%;
-    height: 3rem;
-    border-radius: 0.5rem;
-  }
-}
-
-main {
-  display: block;
-  width: 100%;
-  padding-inline: 0.5rem;
-}

package/examples/angular/src/app/app.component.ts

@@ -1,14 +0,0 @@
-import { Component, inject } from '@angular/core';
-import { RouterModule } from '@angular/router';
-import { SearchService } from './services/search.service';
-import { TRPC } from './services/trpc.client';
-
-@Component({
-  imports: [RouterModule],
-  selector: 'app-root',
-  templateUrl: './app.component.html',
-  styleUrl: './app.component.scss',
-})
-export class AppComponent {
-  protected service = inject(SearchService);
-}

package/examples/angular/src/app/app.config.ts

@@ -1,16 +0,0 @@
-import { ApplicationConfig, provideExperimentalZonelessChangeDetection } from '@angular/core';
-import { NoPreloading, provideRouter, withPreloading, withRouterConfig } from '@angular/router';
-import { appRoutes } from './app.routes';
-
-export const appConfig: ApplicationConfig = {
-  providers: [
-    provideExperimentalZonelessChangeDetection(),
-    provideRouter(
-      appRoutes,
-      withPreloading(NoPreloading),
-      withRouterConfig({
-        onSameUrlNavigation: 'ignore'
-      })
-    )
-  ],
-};

package/examples/angular/src/app/app.routes.ts

@@ -1,25 +0,0 @@
-import { Route } from '@angular/router';
-
-export const appRoutes: Route[] = [
-    {
-        path: 'search',
-        loadComponent: () => import('./search/search.component').then(x => x.SearchComponent)
-    },
-    {
-        path: 'product/:slug',
-        loadComponent: () => import('./product/product.component').then(x => x.ProductComponent)
-    },
-    {
-        path: 'identity',
-        loadComponent: () => import('./identity/identity.component').then(x => x.IdentityComponent)
-    },
-    {
-        path: 'cart',
-        loadComponent: () => import('./cart/cart.component').then(x => x.CartComponent)
-    },
-    {
-        path: '**',
-        pathMatch: 'prefix',
-        redirectTo: 'search'
-    }
-];

package/examples/angular/src/app/cart/cart.component.html

@@ -1,4 +0,0 @@
-<pre>{{ cart() | json }}</pre>
-<button (click)="add()">Add</button>
-<button (click)="adjust()">Adjust</button>
-<button (click)="remove()">Remove</button>

package/examples/angular/src/app/cart/cart.component.scss

@@ -1,14 +0,0 @@
-:host {
-  display: grid;
-  grid-template-columns: 600px;
-  justify-content: center;
-  gap: 0.5rem;
-}
-
-pre {
-  color: white;
-}
-
-input, button {
-  height: 3rem;
-}