@funduck/connectrpc-fastify 1.0.0 → 1.0.1

package/src/middlewares.ts

@@ -1,71 +0,0 @@
-import { FastifyInstance } from 'fastify';
-import { convertMiddlewareToHook, logger } from './helpers';
-import { MiddlewareConfigUnion } from './interfaces';
-import { MiddlewareStore } from './stores';
-
-export async function initMiddlewares(
-  server: FastifyInstance,
-  middlewareConfigs: MiddlewareConfigUnion[],
-) {
-  for (const config of middlewareConfigs) {
-    // Convert method names to set with PascalCase
-    const methods = new Set(
-      (config.methods || []).map((m) => m[0].toUpperCase() + m.slice(1)),
-    );
-
-    // Get the middleware instance from the store
-    const middlewareInstance = MiddlewareStore.getInstance(config.use);
-
-    if (!middlewareInstance) {
-      logger.warn(
-        `Middleware ${config.use.name} not found in store. Did you forget to add MiddlewareStore.registerInstance(this) in the constructor? Or did you forget to instantiate the middleware?`,
-      );
-      continue;
-    }
-
-    if (typeof middlewareInstance.use === 'function') {
-      const hook = convertMiddlewareToHook(middlewareInstance);
-
-      // Create a filtered hook that checks service and method
-      const filteredHook = async (request: any, reply: any) => {
-        const url = request.url as string;
-
-        // Parse the URL to get service and method
-        // Format: /package.ServiceName/MethodName
-        const match = url.match(/^\/([^/]+)\/([^/]+)$/);
-
-        if (!match) {
-          // Not a ConnectRPC route, skip
-          return;
-        }
-
-        const [, serviceName, methodName] = match;
-
-        // Check if middleware should apply to this service
-        if (config.on && config.on.typeName !== serviceName) {
-          return;
-        }
-
-        // Check if middleware should apply to this method
-        if (methods.size && !methods.has(methodName)) {
-          return;
-        }
-
-        // Apply the middleware
-        await hook(request, reply);
-      };
-
-      server.addHook('onRequest', filteredHook);
-
-      const serviceInfo = config.on
-        ? ` to service ${config.on.typeName}`
-        : ' to all services';
-      const methodInfo = config.methods
-        ? ` methods [${config.methods.join(', ')}]`
-        : ' all methods';
-      logger.log(
-        `Applied middleware: ${config.use.name}${serviceInfo}${methodInfo}`,
-      );
-    }
-  }
-}

package/src/stores.ts

@@ -1,180 +0,0 @@
-import { GenService, GenServiceMethods } from '@bufbuild/protobuf/codegenv2';
-import { Guard, Middleware, Service, Type } from './interfaces';
-
-class ControllersStoreClass {
-  private controllers = new Map<
-    Type<any>,
-    {
-      instance: any;
-      service: GenService<any>;
-    }
-  >();
-
-  values() {
-    return Array.from(this.controllers.entries()).map(([target, data]) => ({
-      target,
-      ...data,
-    }));
-  }
-
-  registerInstance<T extends GenServiceMethods>(
-    self: Service<GenService<T>>,
-    service: GenService<T>,
-    {
-      allowMultipleInstances = false,
-    }: {
-      allowMultipleInstances?: boolean;
-    } = {},
-  ) {
-    const controllerClass = self.constructor as Type<any>;
-    if (!allowMultipleInstances && this.controllers.has(controllerClass)) {
-      throw new Error(
-        `Controller ${controllerClass.name} is already registered! This may happen if you export controller as provider and also register it in some Nest module.`,
-      );
-    }
-    this.controllers.set(controllerClass, {
-      instance: self,
-      service,
-    });
-  }
-}
-
-export const ControllersStore = new ControllersStoreClass();
-
-/**
- * Store for middleware classes and their instances
- */
-class MiddlewareStoreClass {
-  private middlewares = new Map<Type<Middleware>, Middleware>();
-
-  /**
-   * Register a middleware instance from its constructor
-   */
-  registerInstance(
-    self: Middleware,
-    {
-      allowMultipleInstances = false,
-    }: {
-      allowMultipleInstances?: boolean;
-    } = {},
-  ) {
-    const middlewareClass = self.constructor as Type<Middleware>;
-    if (!allowMultipleInstances && this.middlewares.has(middlewareClass)) {
-      throw new Error(
-        `Middleware ${middlewareClass.name} is already registered! This may happen if you export middleware as provider and also register it in some Nest module.`,
-      );
-    }
-    this.middlewares.set(middlewareClass, self);
-  }
-
-  /**
-   * Get a middleware instance by its class
-   */
-  getInstance(middlewareClass: Type<Middleware>): Middleware | null {
-    return this.middlewares.get(middlewareClass) || null;
-  }
-}
-
-export const MiddlewareStore = new MiddlewareStoreClass();
-
-/**
- * Store for route metadata - maps URL paths to controller class and method info
- */
-class RouteMetadataStoreClass {
-  private routes = new Map<
-    string,
-    {
-      controllerClass: Type<any>;
-      controllerMethod: Function;
-      controllerMethodName: string;
-      instance: any;
-      serviceName: string;
-      methodName: string;
-    }
-  >();
-
-  /**
-   * Register route metadata for a specific service method
-   * @param serviceName - The full service name (e.g., "connectrpc.eliza.v1.ElizaService")
-   * @param methodName - The method name in PascalCase (e.g., "Say")
-   * @param controllerClass - The controller class
-   * @param controllerMethod - The bound controller method
-   * @param controllerMethodName - The name of the controller method
-   * @param instance - The controller instance
-   */
-  registerRoute(
-    serviceName: string,
-    methodName: string,
-    controllerClass: Type<any>,
-    controllerMethod: Function,
-    controllerMethodName: string,
-    instance: any,
-  ) {
-    const routeKey = `/${serviceName}/${methodName}`;
-    this.routes.set(routeKey, {
-      controllerClass,
-      controllerMethod,
-      controllerMethodName,
-      instance,
-      serviceName,
-      methodName,
-    });
-  }
-
-  /**
-   * Get route metadata by URL path
-   */
-  getRouteMetadata(urlPath: string) {
-    return this.routes.get(urlPath) || null;
-  }
-
-  /**
-   * Get all registered routes
-   */
-  getAllRoutes() {
-    return Array.from(this.routes.entries());
-  }
-}
-
-export const RouteMetadataStore = new RouteMetadataStoreClass();
-
-/**
- * Store for guard classes and their instances
- */
-class GuardsStoreClass {
-  private guards = new Map<Type<Guard>, Guard>();
-
-  /**
-   * Register a guard instance from its constructor
-   */
-  registerInstance(
-    self: Guard,
-    {
-      allowMultipleInstances = false,
-    }: { allowMultipleInstances?: boolean } = {},
-  ) {
-    const guardClass = self.constructor as Type<Guard>;
-    if (!allowMultipleInstances && this.guards.has(guardClass)) {
-      throw new Error(
-        `Guard ${guardClass.name} is already registered! This may happen if you export guard as provider and also register it in some Nest module.`,
-      );
-    }
-    this.guards.set(guardClass, self);
-  }
-
-  /**
-   * Get a guard instance by its class
-   */
-  getInstance(guardClass: Type<Guard>): Guard | null {
-    return this.guards.get(guardClass) || null;
-  }
-
-  /**
-   * Get all registered guards
-   */
-  getAllGuards(): Guard[] {
-    return Array.from(this.guards.values());
-  }
-}
-
-export const GuardsStore = new GuardsStoreClass();

package/src/types.ts

@@ -1,24 +0,0 @@
-import { OptionalKeysOf, Primitive, RequiredKeysOf } from 'type-fest';
-
-export type OmitFieldsDeep<T, K extends keyof any> = T extends Primitive | Date
-  ? T
-  : T extends Array<any>
-    ? {
-        [P in keyof T]?: OmitFieldsDeep<T[P], K>;
-      }
-    : T extends object
-      ? {
-          [P in Exclude<RequiredKeysOf<T>, K>]: OmitFieldsDeep<T[P], K>;
-        } & {
-          [P in Exclude<OptionalKeysOf<T>, K>]?: OmitFieldsDeep<T[P], K>;
-        }
-      : T;
-
-/**
- * Used to simplify types by omitting ConnectRPC specific fields like `$typeName` and `$unknown`
- * The fields are omitted deeply in nested structures.
- */
-export type OmitConnectrpcFields<T> = OmitFieldsDeep<
-  T,
-  '$typeName' | '$unknown'
->;

package/test/buf.gen.yaml

@@ -1,7 +0,0 @@
-version: v2
-plugins:
-  - local: protoc-gen-es
-    out: gen
-    # Also generate any imported dependencies
-    include_imports: true
-    opt: target=ts

package/test/buf.lock

@@ -1,6 +0,0 @@
-# Generated by buf. DO NOT EDIT.
-version: v2
-deps:
-  - name: buf.build/bufbuild/protovalidate
-    commit: 2a1774d888024a9b93ce7eb4b59f6a83
-    digest: b5:6b7f9bc919b65e5b79d7b726ffc03d6f815a412d6b792970fa6f065cae162107bd0a9d47272c8ab1a2c9514e87b13d3fbf71df614374d62d2183afb64be2d30a

package/test/buf.yaml

@@ -1,12 +0,0 @@
-# For details on buf.yaml configuration, visit https://buf.build/docs/configuration/v2/buf-yaml
-version: v2
-lint:
-  use:
-    - BASIC
-breaking:
-  use:
-    - FILE
-modules:
-  - path: proto
-deps:
-  - buf.build/bufbuild/protovalidate

package/test/controller.ts

@@ -1,73 +0,0 @@
-import { ConnectRPC, OmitConnectrpcFields, Service } from '../src/index';
-import type {
-  SayRequest,
-  SayResponse,
-  SayResponses,
-} from './gen/connectrpc/eliza/v1/eliza_pb';
-import { ElizaService } from './gen/connectrpc/eliza/v1/eliza_pb';
-
-export class ElizaController implements Service<typeof ElizaService> {
-  constructor() {
-    ConnectRPC.registerController(this, ElizaService);
-  }
-
-  /**
-   * Unary RPC: Say
-   * Client sends one request, server sends one response
-   *
-   * For demonstration, this method is decorated with @SkipAuthGuard to bypass authentication.
-   */
-  async say(
-    request: SayRequest,
-
-    // You can leave out the return type, it will be inferred from the interface
-  ) {
-    console.log(`Controller received request Say`);
-    return {
-      sentence: `You said: ${request.sentence}`,
-    };
-  }
-
-  /**
-   * Client Streaming RPC: SayMany
-   * Client sends multiple requests, server sends one response with all collected
-   */
-  async sayMany(
-    request: AsyncIterable<SayRequest>,
-
-    // You can specify the return type if you want, but you always need to use OmitConnectrpcFields<> because ConnectRPC adds extra fields internally
-  ): Promise<OmitConnectrpcFields<SayResponses>> {
-    console.log(`Controller received request SayMany`);
-
-    const responses: OmitConnectrpcFields<SayResponse>[] = [];
-
-    for await (const req of request) {
-      responses.push({
-        sentence: `You said: ${req.sentence}`,
-      });
-    }
-
-    return {
-      responses,
-    };
-  }
-
-  /**
-   * Server Streaming RPC: ListenMany
-   * Client sends one request, server sends multiple responses
-   */
-  async *listenMany(request: SayRequest) {
-    console.log(`Controller received request ListenMany`);
-
-    const words = request.sentence.split(' ');
-
-    for (const word of words) {
-      // Simulate some processing delay
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      yield {
-        sentence: `Echo: ${word}`,
-      };
-    }
-  }
-}

package/test/e2e-demo.ts

@@ -1,252 +0,0 @@
-import { create } from '@bufbuild/protobuf';
-import { createClient } from '@connectrpc/connect';
-import { createConnectTransport } from '@connectrpc/connect-node';
-import {
-  ElizaService,
-  SayRequestSchema,
-} from './gen/connectrpc/eliza/v1/eliza_pb';
-import { TestGuard1 } from './guards';
-import {
-  TestMiddleware1,
-  TestMiddleware2,
-  TestMiddleware3,
-} from './middlewares';
-import { bootstrap } from './server';
-
-const transport = createConnectTransport({
-  baseUrl: 'http://localhost:3000',
-  httpVersion: '1.1',
-});
-
-export const client = createClient(ElizaService, transport);
-
-const mockAuthorizationToken = 'Bearer mock-token-123';
-
-let testMiddlewareCalled = {
-  1: false,
-  2: false,
-  3: false,
-};
-function prepareMiddlewares() {
-  testMiddlewareCalled[1] = false;
-  testMiddlewareCalled[2] = false;
-  testMiddlewareCalled[3] = false;
-
-  TestMiddleware1.callback = (req, res) => {
-    console.log(`Middleware 1 called for request: ${req.url}`);
-    testMiddlewareCalled[1] = true;
-    return null;
-  };
-  TestMiddleware2.callback = (req, res) => {
-    console.log(`Middleware 2 called for request: ${req.url}`);
-    testMiddlewareCalled[2] = true;
-    return null;
-  };
-  TestMiddleware3.callback = (req, res) => {
-    console.log(`Middleware 3 called for request: ${req.url}`);
-    testMiddlewareCalled[3] = true;
-    return null;
-  };
-}
-
-let testGuardCalled = {
-  1: false,
-};
-function prepareGuards() {
-  testGuardCalled[1] = false;
-  TestGuard1.callback = (context) => {
-    console.log(
-      `Guard 1 called for request:`,
-      context.switchToHttp().getRequest().url,
-    );
-    testGuardCalled[1] = true;
-    return true;
-  };
-}
-
-async function testUnary() {
-  console.log('\n=== Testing Unary RPC: Say ===');
-  const sentence = 'Hello ConnectRPC!';
-  console.log(`Request: "${sentence}"`);
-
-  try {
-    prepareMiddlewares();
-    prepareGuards();
-
-    const response = await client.say(
-      { sentence },
-      {
-        headers: {
-          Authorization: mockAuthorizationToken,
-          'x-request-id': 'unary-test-001',
-        },
-      },
-    );
-    console.log(`Response: "${response.sentence}"`);
-
-    // Check that all middlewares were called
-    if (
-      !testMiddlewareCalled[1] ||
-      !testMiddlewareCalled[2] ||
-      !testMiddlewareCalled[3]
-    ) {
-      throw new Error(
-        `Not all middlewares were called: ${JSON.stringify(
-          testMiddlewareCalled,
-        )}`,
-      );
-    }
-
-    // Check that the guard was called
-    if (!testGuardCalled[1]) {
-      throw new Error('Guard 1 was not called');
-    }
-
-    console.log('✅ Unary RPC test passed\n');
-    return true;
-  } catch (error) {
-    console.error('❌ Error calling Say:', error);
-    return false;
-  }
-}
-
-async function testClientStreaming() {
-  console.log('=== Testing Client Streaming RPC: SayMany ===');
-  const sentences = ['First message', 'Second message', 'Third message'];
-  console.log('Sending multiple requests:', sentences);
-
-  try {
-    prepareMiddlewares();
-    prepareGuards();
-
-    // Create an async generator to send multiple requests
-    async function* generateRequests() {
-      for (const sentence of sentences) {
-        console.log(`  Sending: "${sentence}"`);
-        yield create(SayRequestSchema, { sentence });
-      }
-    }
-
-    const response = await client.sayMany(generateRequests(), {
-      headers: {
-        Authorization: mockAuthorizationToken,
-        'x-request-id': 'client-streaming-test-001',
-      },
-    });
-    console.log(`Received ${response.responses.length} responses:`);
-    response.responses.forEach((resp, idx) => {
-      console.log(`  [${idx + 1}] ${resp.sentence}`);
-    });
-
-    // Check that all middlewares were called
-    if (!testMiddlewareCalled[1] || !testMiddlewareCalled[2]) {
-      throw new Error(
-        `Not all middlewares were called: ${JSON.stringify(
-          testMiddlewareCalled,
-        )}`,
-      );
-    }
-    if (testMiddlewareCalled[3]) {
-      throw new Error(
-        `Middleware 3 should not have been called for SayMany: ${JSON.stringify(
-          testMiddlewareCalled,
-        )}`,
-      );
-    }
-
-    // Check that the guard was called
-    if (!testGuardCalled[1]) {
-      throw new Error('Guard 1 was not called');
-    }
-
-    console.log('✅ Client Streaming RPC test passed\n');
-    return true;
-  } catch (error) {
-    console.error('❌ Error calling SayMany:', error);
-    return false;
-  }
-}
-
-async function testServerStreaming() {
-  console.log('=== Testing Server Streaming RPC: ListenMany ===');
-  const sentence = 'Hello Streaming World';
-  console.log(`Request: "${sentence}"`);
-  console.log('Receiving streamed responses:');
-
-  try {
-    prepareMiddlewares();
-    prepareGuards();
-
-    let count = 0;
-    for await (const response of client.listenMany(
-      { sentence },
-      {
-        headers: {
-          Authorization: mockAuthorizationToken,
-          'x-request-id': 'server-streaming-test-001',
-        },
-      },
-    )) {
-      count++;
-      console.log(`  [${count}] ${response.sentence}`);
-    }
-
-    // Check that all middlewares were called
-    if (!testMiddlewareCalled[1] || !testMiddlewareCalled[2]) {
-      throw new Error(
-        `Not all middlewares were called: ${JSON.stringify(
-          testMiddlewareCalled,
-        )}`,
-      );
-    }
-    if (testMiddlewareCalled[3]) {
-      throw new Error(
-        `Middleware 3 should not have been called for SayMany: ${JSON.stringify(
-          testMiddlewareCalled,
-        )}`,
-      );
-    }
-    // Check that the guard was called
-    if (!testGuardCalled[1]) {
-      throw new Error('Guard 1 was not called');
-    }
-
-    console.log(
-      `✅ Server Streaming RPC test passed (received ${count} responses)\n`,
-    );
-    return true;
-  } catch (error) {
-    console.error('❌ Error calling ListenMany:', error);
-    return false;
-  }
-}
-
-async function runAllTests() {
-  console.log('🚀 Starting ConnectRPC Tests\n');
-
-  // Bootstrap the server
-  await bootstrap();
-
-  // Give the server a moment to start
-  await new Promise((resolve) => setTimeout(resolve, 500));
-
-  // Run all tests
-  const results = [
-    await testUnary(),
-    await testClientStreaming(),
-    await testServerStreaming(),
-  ];
-
-  // Check results
-  const allPassed = results.every((result) => result === true);
-
-  if (allPassed) {
-    console.log('🎉 All tests passed!');
-    process.exit(0);
-  } else {
-    console.log('❌ Some tests failed');
-    process.exit(1);
-  }
-}
-
-runAllTests();