@reactionary/source 0.0.51 → 0.0.52

package/otel/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "extends": "../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "importHelpers": true,
-    "noImplicitOverride": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "noPropertyAccessFromIndexSignature": true
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/otel/tsconfig.lib.json

@@ -1,23 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": [
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx"
-  ]
-}

package/otel/tsconfig.spec.json

@@ -1,28 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../dist/out-tsc",
-    "types": [
-      "vitest/globals",
-      "vitest/importMeta",
-      "vite/client",
-      "node",
-      "vitest"
-    ]
-  },
-  "include": [
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx",
-    "src/**/*.d.ts"
-  ]
-}

package/otel/vite.config.ts

@@ -1,24 +0,0 @@
-import { defineConfig } from 'vite';
-import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
-import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
-
-export default defineConfig(() => ({
-  root: __dirname,
-  cacheDir: '../node_modules/.vite/otel',
-  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
-  // Uncomment this if you are using workers.
-  // worker: {
-  //  plugins: [ nxViteTsPaths() ],
-  // },
-  test: {
-    watch: false,
-    globals: true,
-    environment: 'node',
-    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
-    reporters: ['default'],
-    coverage: {
-      reportsDirectory: '../coverage/otel',
-      provider: 'v8' as const,
-    },
-  },
-}));

package/trpc/README.md

@@ -1,7 +0,0 @@
-# trpc
-
-This library was generated with [Nx](https://nx.dev).
-
-## Building
-
-Run `nx build trpc` to build the library.

package/trpc/__mocks__/superjson.js

@@ -1,25 +0,0 @@
-// Mock superjson for Jest testing
-module.exports = {
-  default: {
-    stringify: JSON.stringify,
-    parse: JSON.parse,
-    serialize: (obj) => ({ json: obj, meta: undefined }),
-    deserialize: (data) => data.json,
-    output: {
-      serialize: (obj) => ({ json: obj, meta: undefined })
-    },
-    input: {
-      deserialize: (data) => data.json
-    }
-  },
-  stringify: JSON.stringify,
-  parse: JSON.parse,
-  serialize: (obj) => ({ json: obj, meta: undefined }),
-  deserialize: (data) => data.json,
-  output: {
-    serialize: (obj) => ({ json: obj, meta: undefined })
-  },
-  input: {
-    deserialize: (data) => data.json
-  }
-};

package/trpc/eslint.config.mjs

@@ -1,19 +0,0 @@
-import baseConfig from '../eslint.config.mjs';
-
-export default [
-  ...baseConfig,
-  {
-    files: ['**/*.json'],
-    rules: {
-      '@nx/dependency-checks': [
-        'error',
-        {
-          ignoredFiles: ['{projectRoot}/eslint.config.{js,cjs,mjs}'],
-        },
-      ],
-    },
-    languageOptions: {
-      parser: await import('jsonc-eslint-parser'),
-    },
-  },
-];

package/trpc/jest.config.ts

@@ -1,14 +0,0 @@
-export default {
-  displayName: 'trpc',
-  preset: '../jest.preset.js',
-  testEnvironment: 'node',
-  testTimeout: 15000,
-  transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  moduleNameMapper: {
-    '^superjson$': '<rootDir>/__mocks__/superjson.js',
-  },
-  coverageDirectory: '../coverage/trpc',
-};

package/trpc/package.json

@@ -1,14 +0,0 @@
-{
-  "name": "@reactionary/trpc",
-  "version": "0.0.1",
-  "type": "commonjs",
-  "main": "./src/index.js",
-  "types": "./src/index.d.ts",
-  "dependencies": {
-    "@trpc/server": "^11.1.2",
-    "@reactionary/core": "0.0.1",
-    "@reactionary/otel": "0.0.1",
-    "superjson": "^2.2.2",
-    "zod": "4.1.9"
-  }
-}

package/trpc/project.json

@@ -1,31 +0,0 @@
-{
-  "name": "trpc",
-  "$schema": "../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "trpc/src",
-  "projectType": "library",
-  "release": {
-    "version": {
-      "manifestRootsToUpdate": ["dist/{projectRoot}"],
-      "currentVersionResolver": "git-tag",
-      "fallbackCurrentVersionResolver": "disk"
-    }
-  },
-  "tags": [],
-  "targets": {
-    "build": {
-      "executor": "@nx/esbuild:esbuild",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "outputPath": "dist/trpc",
-        "main": "trpc/src/index.ts",
-        "tsConfig": "trpc/tsconfig.lib.json",
-        "format": ["esm"]
-      }
-    },
-    "nx-release-publish": {
-      "options": {
-        "packageRoot": "dist/{projectRoot}"
-      }
-    }
-  }
-}

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);
-    });
-  });
-});