@reactionary/source 0.0.30 → 0.0.32

package/providers/fake/src/providers/product.provider.ts

@@ -1,73 +1,77 @@
 import {
-  BaseMutation,
   Product,
-  ProductMutation,
   ProductProvider,
-  ProductQuery,
+  ProductQueryById,
+  ProductQueryBySlug,
   Session,
+  Cache as ReactinaryCache,
 } from '@reactionary/core';
 import z from 'zod';
 import { FakeConfiguration } from '../schema/configuration.schema';
 import { base, en, Faker } from '@faker-js/faker';
+import { traced } from '@reactionary/otel';
 
 export class FakeProductProvider<
-  T extends Product = Product,
-  Q extends ProductQuery = ProductQuery,
-  M extends ProductMutation = ProductMutation
-> extends ProductProvider<T, Q, M> {
+  T extends Product = Product
+> extends ProductProvider<T> {
   protected config: FakeConfiguration;
 
-  constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: ReactinaryCache) {
+    super(schema, cache);
 
     this.config = config;
   }
 
-  protected override async fetch(queries: Q[], session: Session): Promise<T[]> {
-    const results = new Array<T>();
+  @traced()
+  public override async getById(
+    payload: ProductQueryById,
+    _session: Session
+  ): Promise<T> {
+    return this.parseSingle(payload);
+  }
 
-    for (const query of queries) {
-      const generator = new Faker({
-        seed: 42,
-        locale: [en, base],
-      });
+  public override async getBySlug(
+    payload: ProductQueryBySlug,
+    _session: Session
+  ): Promise<T> {
+    return this.parseSingle(payload);
+  }
 
-      const key = (query.id as string) || generator.commerce.isbn();
-      const slug = (query.slug as string) || generator.lorem.slug();
+  protected override parseSingle(body: ProductQueryById | ProductQueryBySlug): T {
+    const generator = new Faker({
+      seed: 42,
+      locale: [en, base],
+    });
 
-      const product: Product = {
-        identifier: {
-          key: key,
-        },
-        name: generator.commerce.productName(),
-        slug: slug,
-        attributes: [],
-        description: generator.commerce.productDescription(),
-        image: generator.image.urlPicsumPhotos({
-          width: 600,
-          height: 600,
-        }),
-        images: [],
-        meta: {
-          cache: {
-            hit: false,
-            key: key,
-          },
-          placeholder: false
-        },
-        skus: [],
-      };
+    const key = body.slug || body.id;
 
-      results.push(product as T);
-    }
+    // Create a model instance based on the schema
+    const model = this.newModel();
 
-    return results;
-  }
+    // Merge the generated data into the model
+    Object.assign(model, {
+      identifier: {
+        key: key,
+      },
+      name: generator.commerce.productName(),
+      slug: key,
+      attributes: [],
+      description: generator.commerce.productDescription(),
+      image: generator.image.urlPicsumPhotos({
+        width: 600,
+        height: 600,
+      }),
+      images: [],
+      meta: {
+        cache: {
+          hit: false,
+          key: key,
+        },
+        placeholder: false,
+      },
+      skus: [],
+    });
 
-  protected override process(
-    mutation: BaseMutation[],
-    session: Session
-  ): Promise<T> {
-    throw new Error('Method not implemented.');
+    return this.assert(model);
   }
 }

package/providers/fake/src/providers/search.provider.ts

@@ -1,12 +1,11 @@
 import {
-  SearchIdentifier,
-  SearchMutation,
   SearchProvider,
-  SearchQuery,
+  SearchQueryByTerm,
   SearchResult,
   SearchResultFacet,
   SearchResultProduct,
   Session,
+  Cache as ReactinaryCache,
 } from '@reactionary/core';
 import z from 'zod';
 import { FakeConfiguration } from '../schema/configuration.schema';
@@ -14,41 +13,24 @@ import { Faker, en, base } from '@faker-js/faker';
 import { jitter } from '../utilities/jitter';
 
 export class FakeSearchProvider<
-  T extends SearchResult = SearchResult,
-  Q extends SearchQuery = SearchQuery,
-  M extends SearchMutation = SearchMutation
-> extends SearchProvider<T, Q, M> {
+  T extends SearchResult = SearchResult
+> extends SearchProvider<T> {
   protected config: FakeConfiguration;
 
-  constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: ReactinaryCache) {
+    super(schema, cache);
 
     this.config = config;
   }
 
-  protected override async fetch(queries: Q[], session: Session): Promise<T[]> {
-    const results = [];
-
-    for (const query of queries) {
-      const result = await this.get(query.search);
-
-      results.push(result);
-    }
-
-    return results;
-  }
-
-  protected override process(mutations: M[], session: Session): Promise<T> {
-    throw new Error('Method not implemented.');
-  }
-
-  public async get(identifier: SearchIdentifier): Promise<T> {
+  public override async queryByTerm(
+    payload: SearchQueryByTerm,
+    _session: Session
+  ): Promise<SearchResult> {
     await jitter(this.config.jitter.mean, this.config.jitter.deviation);
 
-    return this.parse({}, identifier);
-  }
+    const query = payload.search;
 
-  public parse(data: unknown, query: SearchIdentifier): T {
     const querySpecificity =
       20 - query.term.length - query.page - query.facets.length;
     const totalProducts = 10 * querySpecificity;
@@ -77,7 +59,7 @@ export class FakeSearchProvider<
           height: 300,
           width: 300,
           grayscale: true,
-          blur: 8
+          blur: 8,
         }),
         name: productGenerator.commerce.productName(),
         slug: productGenerator.lorem.slug(),
@@ -131,10 +113,10 @@ export class FakeSearchProvider<
       meta: {
         cache: {
           hit: false,
-          key: ''
+          key: '',
         },
-        placeholder: false
-      }
+        placeholder: false,
+      },
     } satisfies SearchResult;
 
     return this.schema.parse(result);

package/providers/posthog/src/core/initialize.ts

@@ -1,9 +1,11 @@
-import { Client } from "@reactionary/core";
+import { Client, Cache } from "@reactionary/core";
 import { PosthogConfiguration } from "../schema/configuration.schema";
 import { PosthogCapabilities } from "../schema/capabilities.schema";
 
-export function withPosthogCapabilities(configuration: PosthogConfiguration, capabilities: PosthogCapabilities) {
-    const client: Partial<Client> = {};
+export function withPosthogCapabilities(_configuration: PosthogConfiguration, _capabilities: PosthogCapabilities) {
+    return (_cache: Cache) => {
+        const client: Partial<Client> = {};
 
-    return client;
+        return client;
+    };
 }

package/trpc/__mocks__/superjson.js

@@ -0,0 +1,25 @@
+// 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/jest.config.ts

@@ -0,0 +1,14 @@
+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

@@ -9,6 +9,7 @@
     "@reactionary/core": "0.0.1",
     "@reactionary/otel": "0.0.1",
     "superjson": "^2.2.2",
-    "zod": "4.0.0-beta.20250430T185432"
+    "zod": "4.0.0-beta.20250430T185432",
+    "@trpc/client": "^11.1.2"
   }
 }

package/trpc/src/client.ts

@@ -0,0 +1,176 @@
+import { Client, Session, isTRPCQuery, isTRPCMutation, isTRPCMethod } from '@reactionary/core';
+import type { TransparentClient } from './types';
+import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import type { TRPCClientError } from '@trpc/client';
+
+/**
+ * Configuration options for TRPC client creation
+ */
+export interface TRPCClientOptions {
+  /** Default session to use if not provided in method calls */
+  defaultSession?: Session;
+  /** Whether to automatically provide session from defaultSession */
+  autoSession?: 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' }, session);
+ * ```
+ */
+export function createTRPCClient<TOriginalClient extends Partial<Client>>(
+  trpcClient: any,
+  options: TRPCClientOptions = {}
+): TransparentClient<TOriginalClient> {
+  const { defaultSession, autoSession = 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, sessionArg?: Session) => {
+            // Determine session to use
+            let session = sessionArg;
+            if (!session && autoSession && defaultSession) {
+              session = defaultSession;
+            }
+            
+            // Prepare input for TRPC call
+            const input = {
+              payload,
+              session
+            };
+            
+            // 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 {
+  getSession(): Promise<Session> | Session;
+}
+
+/**
+ * Create a TRPC client with session provider for automatic session management
+ * 
+ * @example
+ * ```typescript
+ * const sessionProvider: SessionProvider = {
+ *   getSession: () => getCurrentUserSession()
+ * };
+ * 
+ * const client = createTRPCClientWithSessionProvider(trpc, sessionProvider);
+ * 
+ * // 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, sessionArg?: Session) => {
+            // If no session provided, get from provider
+            let session = sessionArg;
+            if (!session) {
+              session = await sessionProvider.getSession();
+            }
+            
+            const input = {
+              payload,
+              session
+            };
+            
+            // 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,70 +1,43 @@
+// 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 {
-  Client,
-  Session,
-} from '@reactionary/core';
-import superjson from 'superjson';
-import { z } from 'zod';
-import { BaseProvider } from '@reactionary/core';
-import { TRPCQueryProcedure, TRPCMutationProcedure } from '@trpc/server';
+import { Client, Session } from '@reactionary/core';
 import { createTRPCTracing } from '@reactionary/otel';
 
-const t = initTRPC.context<{ client: Client; session: Session }>().create({
-  transformer: superjson,
-});
-
-export const router = t.router;
-export const mergeRouters = t.mergeRouters;
+const t = initTRPC.context<{ client: Client; session: Session }>().create({});
 
 // Always apply tracing middleware - exporters controlled via OTEL env vars
 const basePublicProcedure = t.procedure;
 export const publicProcedure = basePublicProcedure.use(createTRPCTracing());
 
-export function createTRPCRouter<T extends Client = Client>(client: T) {
-  type BaseProviderKeys<T> = {
-    [K in keyof T]: T[K] extends BaseProvider ? K : never;
-  }[keyof T];
-
-  type ReactionaryRouter = {
-    [Property in BaseProviderKeys<Client>]: TRPCQueryProcedure<{
-      input: Array<z.infer<T[Property]['querySchema']>>;
-      output: Array<z.infer<Awaited<T[Property]['schema']>>>;
-      meta: any;
-    }>;
-  } & {
-    [Property in BaseProviderKeys<Client> as `${Property}Mutation`]: TRPCMutationProcedure<{
-      input: Array<z.infer<T[Property]['mutationSchema']>>;
-      output: z.infer<Awaited<T[Property]['schema']>>;
-      meta: any;
-    }>;
-  };
-
-  const routes: Record<string, any> = {};
-  // Always enable tracing - exporters are controlled via env vars
-  const procedure = basePublicProcedure.use(createTRPCTracing());
-
-  for (const key in client) {
-    const provider = client[key];
-
-    if (provider instanceof BaseProvider) {
-      const queryKey = key as keyof ReactionaryRouter;
-      const mutationKey = key + 'Mutation' as keyof ReactionaryRouter;
-
-      routes[queryKey] = procedure
-        .input(provider.querySchema.array())
-        .output(provider.schema.array())
-        .query(async (opts) => {
-          return provider.query(opts.input, opts.ctx.session);
-        });
-
-      routes[mutationKey] = procedure
-        .input(provider.mutationSchema.array())
-        .output(provider.schema)
-        .mutation(async (opts) => {
-          return provider.mutate(opts.input, opts.ctx.session);
-        });
-    }
-  }
-
-  return router<ReactionaryRouter>(routes as ReactionaryRouter);
-}
+// Legacy function - deprecated, use createTRPCServerRouter instead
+import { createTRPCServerRouter } from './server';
+export const createTRPCRouter = createTRPCServerRouter;