@funduck/connectrpc-fastify 1.0.0 → 1.0.1

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@funduck/connectrpc-fastify",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "author": "Oleg Milekhin <qlfunduck@gmail.com>",
   "description": "Wrapper for official @connectrpc/connect and fastify. Simplifies configuration, type safe binding to controller, simplifies use of middlewares and guards.",
-  "main": "dist/index.js",
+  "main": "dist/src/index.js",
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "npx rimraf dist; tsc -p tsconfig.build.json",
     "compile-proto": "cd test && npx buf dep update; npx buf lint; npx buf generate",
-    "demo-test": "cd test && DEBUG=true npx tsx e2e-demo.ts",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "cd test && DEBUG=true npx tsx e2e-demo.ts"
   },
   "license": "MIT",
   "dependencies": {

package/.editorconfig

@@ -1,12 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-
-[Makefile]
-indent_style = tab
-
-[*.{ts,js,json,yml,yaml}]
-indent_style = space
-indent_size = 2
-trim_trailing_whitespace = true

package/.prettierrc

@@ -1,7 +0,0 @@
-{
-  "singleQuote": true,
-  "trailingComma": "all",
-  "plugins": [
-    "prettier-plugin-organize-imports"
-  ]
-}

package/pnpm-workspace.yaml

@@ -1,2 +0,0 @@
-ignoredBuiltDependencies:
-  - '@bufbuild/buf'

package/publish.sh

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-npm publish --tag beta --access public

package/src/connectrpc.ts

@@ -1,87 +0,0 @@
-import { GenService, GenServiceMethods } from '@bufbuild/protobuf/codegenv2';
-import { FastifyInstance } from 'fastify';
-import { registerFastifyPlugin } from './fastify-plugin';
-import { initGuards } from './guards';
-import { setLogger } from './helpers';
-import {
-  Guard,
-  Logger,
-  Middleware,
-  MiddlewareConfigUnion,
-  Service,
-} from './interfaces';
-import { initMiddlewares } from './middlewares';
-import { ControllersStore, GuardsStore, MiddlewareStore } from './stores';
-
-class ConnectRPCClass {
-  setLogger(customLogger: Logger) {
-    setLogger(customLogger);
-  }
-
-  registerMiddleware(
-    self: Middleware,
-    options?: {
-      allowMultipleInstances?: boolean;
-    },
-  ) {
-    MiddlewareStore.registerInstance(self, options);
-  }
-
-  /**
-   * @param self - instance of controller
-   * @param service - generated service that is implemented by controller
-   */
-  registerController<T extends GenServiceMethods>(
-    self: Service<GenService<T>>,
-    service: GenService<T>,
-    options?: {
-      allowMultipleInstances?: boolean;
-    },
-  ) {
-    ControllersStore.registerInstance(self, service, options);
-  }
-
-  registerGuard(
-    self: Guard,
-    options?: {
-      allowMultipleInstances?: boolean;
-    },
-  ) {
-    GuardsStore.registerInstance(self, options);
-  }
-
-  registerFastifyPlugin(server: FastifyInstance) {
-    return registerFastifyPlugin(server);
-  }
-
-  private _middlewaresInitialized = false;
-
-  initMiddlewares(
-    server: FastifyInstance,
-    middlewareConfigs: MiddlewareConfigUnion[],
-  ) {
-    if (this._middlewaresInitialized) {
-      throw new Error('Middlewares have already been initialized!');
-    }
-    if (this._guardsInitialized) {
-      throw new Error('Middlewares must be initialized before guards!');
-    }
-    this._middlewaresInitialized = true;
-    return initMiddlewares(server, middlewareConfigs);
-  }
-
-  private _guardsInitialized = false;
-
-  initGuards(server: FastifyInstance) {
-    if (this._guardsInitialized) {
-      throw new Error('Guards have already been initialized!');
-    }
-    this._guardsInitialized = true;
-    return initGuards(server);
-  }
-}
-
-/**
- * Main ConnectRPC class to manage registration of controllers and middlewares
- */
-export const ConnectRPC = new ConnectRPCClass();

package/src/execution-context.ts

@@ -1,45 +0,0 @@
-import { FastifyReply, FastifyRequest } from 'fastify';
-import { ExecutionContext, Type } from './interfaces';
-
-export class ManualExecutionContext implements ExecutionContext {
-  constructor(
-    readonly request: FastifyRequest['raw'],
-    readonly response: FastifyReply['raw'],
-    readonly next: <T = any>() => T,
-    readonly args: any[],
-    readonly constructorRef: Type<any> | null = null,
-    readonly handler: Function | null = null,
-  ) {}
-
-  getClass<T = any>(): Type<T> {
-    return this.constructorRef!;
-  }
-
-  getHandler(): Function {
-    return this.handler!;
-  }
-
-  getArgs<T extends Array<any> = any[]>(): T {
-    return this.args as T;
-  }
-
-  getArgByIndex<T = any>(index: number): T {
-    return this.args[index] as T;
-  }
-
-  switchToHttp() {
-    return Object.assign(this, {
-      getRequest: () => this.request,
-      getResponse: () => this.response,
-      getNext: () => this.next,
-    });
-  }
-
-  switchToRpc() {
-    throw new Error('Context switching to RPC is not supported.');
-  }
-
-  switchToWs() {
-    throw new Error('Context switching to WebSockets is not supported.');
-  }
-}

package/src/fastify-plugin.ts

@@ -1,99 +0,0 @@
-import { GenService } from '@bufbuild/protobuf/codegenv2';
-import { ConnectRouter } from '@connectrpc/connect';
-import { fastifyConnectPlugin } from '@connectrpc/connect-fastify';
-import { Compression } from '@connectrpc/connect/protocol';
-import { FastifyInstance } from 'fastify';
-import { getGuards } from './guards';
-import { discoverMethodMappings, logger } from './helpers';
-import { ControllersStore, RouteMetadataStore } from './stores';
-
-export async function registerFastifyPlugin(
-  server: FastifyInstance,
-  options: {
-    acceptCompression?: Compression[];
-  } = {},
-) {
-  // Create implementations from controller instances
-  const implementations = new Map<GenService<any>, any>();
-
-  for (const { instance, service } of ControllersStore.values()) {
-    const guards = getGuards(instance);
-    if (guards.length > 0) {
-      logger.log(
-        `Found ${guards.length} guards on controller ${instance.constructor.name}`,
-      );
-    }
-
-    const methodMappings = discoverMethodMappings(instance.__proto__, service);
-
-    // Create the implementation object
-    const implementation: any = {};
-
-    // Bind each method from the service
-    for (const methodDesc of service.methods) {
-      const { name } = methodDesc;
-      const methodName = name[0].toLowerCase() + name.slice(1);
-
-      // Check if there's a mapped controller method
-      const controllerMethodName = methodMappings[name];
-
-      if (controllerMethodName) {
-        const controllerMethod = instance[controllerMethodName];
-
-        if (controllerMethod) {
-          // Bind the method with proper 'this' context
-          const bindedMethod = controllerMethod.bind(instance);
-          implementation[methodName] = (...args: any[]) => {
-            return bindedMethod(...args);
-          };
-
-          // Store route metadata for guards and interceptors
-          RouteMetadataStore.registerRoute(
-            service.typeName,
-            name, // PascalCase method name (e.g., "Say")
-            instance.constructor,
-            controllerMethod,
-            controllerMethodName,
-            instance,
-          );
-
-          logger.log(
-            `Binding ${instance.constructor.name}.${controllerMethodName} to ${service.typeName}.${name}`,
-          );
-        } else {
-          logger.warn(
-            `Method ${controllerMethodName} not found in ${instance.constructor.name}`,
-          );
-        }
-      }
-    }
-
-    implementations.set(service, implementation);
-  }
-
-  const routes = (router: ConnectRouter) => {
-    for (const [service, implementation] of implementations.entries()) {
-      router.service(service, implementation);
-      logger.log(`Registered {/${service.typeName}} route`);
-    }
-  };
-
-  if (routes.length === 0) {
-    logger.warn('No controllers found to register');
-    return;
-  }
-
-  await server.register(fastifyConnectPlugin, {
-    // For now we enable only Connect protocol by default and disable others.
-    // grpc: this.options.grpc ?? false,
-    // grpcWeb: this.options.grpcWeb ?? false,
-    // connect: this.options.connect ?? true,
-    grpc: false,
-    grpcWeb: false,
-    connect: true,
-    acceptCompression: options.acceptCompression ?? [],
-    routes: routes,
-  });
-
-  logger.log('Ready');
-}

package/src/guards.ts

@@ -1,130 +0,0 @@
-import { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
-import { ManualExecutionContext } from './execution-context';
-import { logger } from './helpers';
-import { ExecutionContext, Guard } from './interfaces';
-import { GuardsStore, RouteMetadataStore } from './stores';
-
-export class ManualGuardExecutor {
-  async executeGuard(
-    guard: Guard,
-    context: ExecutionContext,
-  ): Promise<boolean> {
-    const result = guard.canActivate(context);
-
-    // Handle synchronous boolean result
-    if (typeof result === 'boolean') {
-      return result;
-    }
-
-    // Handle Promise result
-    return await result;
-  }
-
-  async executeGuards(
-    guards: Guard[],
-    context: ExecutionContext,
-  ): Promise<boolean> {
-    for (const guard of guards) {
-      const canActivate = await this.executeGuard(guard, context);
-      if (!canActivate) {
-        return false;
-      }
-    }
-    return true;
-  }
-}
-
-export function getGuards(controller: any): Guard[] {
-  // Return all registered guards
-  // In a more sophisticated implementation, you could filter guards
-  // based on decorators on the controller or method
-  return GuardsStore.getAllGuards();
-}
-
-/**
- * Initialize guards middleware - this should be called after all other middlewares are registered
- */
-export async function initGuards(server: FastifyInstance) {
-  const guardExecutor = new ManualGuardExecutor();
-
-  // Add a hook that runs after all other middlewares
-  server.addHook(
-    'preHandler',
-    async (request: FastifyRequest, reply: FastifyReply) => {
-      const url = request.url;
-
-      // Parse the URL to get the route
-      // Format: /package.ServiceName/MethodName
-      const match = url.match(/^\/([^/]+)\/([^/]+)$/);
-
-      if (!match) {
-        // Not a ConnectRPC route, skip guard execution
-        return;
-      }
-
-      // Get route metadata
-      const routeMetadata = RouteMetadataStore.getRouteMetadata(url);
-
-      if (!routeMetadata) {
-        // No metadata found for this route
-        logger.warn(`No route metadata found for ${url}`);
-        return;
-      }
-
-      const {
-        controllerClass,
-        controllerMethod,
-        controllerMethodName,
-        instance,
-      } = routeMetadata;
-
-      // Get guards for the controller
-      const guards = getGuards(instance);
-
-      if (guards.length === 0) {
-        // No guards to execute
-        return;
-      }
-
-      // Create execution context
-      // Note: For ConnectRPC, we don't have the actual request arguments yet at this point
-      // They will be deserialized later by the ConnectRPC handler
-      const executionContext = new ManualExecutionContext(
-        request.raw,
-        reply.raw,
-        (() => undefined) as <T = any>() => T,
-        [], // args will be populated later if needed
-        controllerClass,
-        controllerMethod,
-      );
-
-      // Execute guards
-      try {
-        const canActivate = await guardExecutor.executeGuards(
-          guards,
-          executionContext,
-        );
-
-        if (!canActivate) {
-          // Guard rejected the request
-          reply.code(403).send({
-            code: 'permission_denied',
-            message: 'Forbidden',
-          });
-          throw new Error('Guard rejected the request');
-        }
-      } catch (error) {
-        // If guard throws an error, reject the request
-        if (!reply.sent) {
-          reply.code(403).send({
-            code: 'permission_denied',
-            message: error instanceof Error ? error.message : 'Forbidden',
-          });
-        }
-        throw error;
-      }
-    },
-  );
-
-  logger.log('Guards middleware initialized');
-}

package/src/helpers.ts

@@ -1,92 +0,0 @@
-import { GenService } from '@bufbuild/protobuf/codegenv2';
-import { FastifyReply, FastifyRequest } from 'fastify';
-import { Logger } from './interfaces';
-
-/**
- * Automatically discover method mappings by matching service methods to controller methods
- */
-export function discoverMethodMappings(
-  prototype,
-  service: GenService<any>,
-): Record<string, string> {
-  const methodMappings: Record<string, string> = {};
-
-  // service.methods is an array of method descriptors
-  const serviceMethods = Array.isArray(service.methods) ? service.methods : [];
-
-  // Get all controller methods
-  const controllerMethods = Object.getOwnPropertyNames(prototype).filter(
-    (name) => name !== 'constructor' && typeof prototype[name] === 'function',
-  );
-
-  // Check each service method
-  for (const methodDesc of serviceMethods) {
-    const serviceMethodName = methodDesc.name; // e.g., "Say" - this is what connectrpc module uses as key
-    const localName = methodDesc.localName; // e.g., "say" (camelCase version)
-
-    // Try to find a matching controller method
-    // First try exact match with localName (camelCase), then try case-insensitive
-    let controllerMethodName = controllerMethods.find(
-      (name) => name === localName,
-    );
-
-    if (!controllerMethodName) {
-      controllerMethodName = controllerMethods.find(
-        (name) => name.toLowerCase() === serviceMethodName.toLowerCase(),
-      );
-    }
-
-    if (controllerMethodName) {
-      // Map using the service method name (e.g., "Say") because that's what the module looks for
-      methodMappings[serviceMethodName] = controllerMethodName;
-    }
-  }
-
-  return methodMappings;
-}
-
-/**
- * Helper to convert NestJS middleware to Fastify hook
- */
-export function convertMiddlewareToHook(
-  middlewareInstance: any,
-): (request: FastifyRequest, reply: FastifyReply) => Promise<void> {
-  return async (request: FastifyRequest, reply: FastifyReply) => {
-    return new Promise<void>((resolve, reject) => {
-      try {
-        // NestJS middleware expects raw req/res
-        middlewareInstance.use(request.raw, reply.raw, (err?: any) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve();
-          }
-        });
-      } catch (error) {
-        reject(error);
-      }
-    });
-  };
-}
-
-export let logger: Logger = {
-  log: (...args: any[]) => {
-    console.info(...args);
-  },
-  error: (...args: any[]) => {
-    console.error(...args);
-  },
-  warn: (...args: any[]) => {
-    console.warn(...args);
-  },
-  debug: (...args: any[]) => {
-    console.debug(...args);
-  },
-  verbose: (...args: any[]) => {
-    console.log(...args);
-  },
-};
-
-export function setLogger(customLogger: Logger) {
-  logger = customLogger;
-}

package/src/index.ts

@@ -1,21 +0,0 @@
-export function printMsg() {
-  console.log('Thanks for using connectrpc-fastify!');
-}
-
-export { ConnectRPC } from './connectrpc';
-
-export { middlewareConfig } from './interfaces';
-
-export type {
-  ExecutionContext,
-  Guard,
-  Logger,
-  Middleware,
-  MiddlewareConfig,
-  MiddlewareConfigUnion,
-  Service,
-} from './interfaces';
-
-export { initGuards } from './guards';
-
-export type { OmitConnectrpcFields } from './types';

package/src/interfaces.ts

@@ -1,175 +0,0 @@
-import type { GenMessage, GenService } from '@bufbuild/protobuf/codegenv2';
-import { FastifyReply, FastifyRequest } from 'fastify';
-import { OmitConnectrpcFields } from './types';
-
-export interface Logger {
-  log: (...args: any[]) => void;
-  error: (...args: any[]) => void;
-  warn: (...args: any[]) => void;
-  debug: (...args: any[]) => void;
-  verbose: (...args: any[]) => void;
-}
-
-export interface Middleware {
-  use(
-    req: FastifyRequest['raw'],
-    res: FastifyReply['raw'],
-    next: (err?: any) => void,
-  ): void;
-}
-
-export interface Type<T = any> extends Function {
-  new (...args: any[]): T;
-}
-
-/**
- * Extract the input type from a method schema
- */
-type ExtractInput<T> = T extends { input: GenMessage<infer M> } ? M : never;
-
-/**
- * Extract the output type from a method schema
- */
-type ExtractOutput<T> = T extends { output: GenMessage<infer M> } ? M : never;
-
-/**
- * Convert a service method to a controller method signature
- */
-type ServiceMethod<T> = T extends { methodKind: 'unary' }
-  ? (
-      request: ExtractInput<T>,
-    ) => Promise<OmitConnectrpcFields<ExtractOutput<T>>>
-  : T extends { methodKind: 'server_streaming' }
-    ? (
-        request: ExtractInput<T>,
-      ) => AsyncIterable<OmitConnectrpcFields<ExtractOutput<T>>>
-    : T extends { methodKind: 'client_streaming' }
-      ? (
-          request: AsyncIterable<ExtractInput<T>>,
-        ) => Promise<OmitConnectrpcFields<ExtractOutput<T>>>
-      : T extends { methodKind: 'bidi_streaming' }
-        ? (
-            request: AsyncIterable<ExtractInput<T>>,
-          ) => AsyncIterable<OmitConnectrpcFields<ExtractOutput<T>>>
-        : never;
-
-/**
- * Generic interface that maps a ConnectRPC service to controller methods
- *
- * Controllers can implement any subset of the service methods.
- * TypeScript will enforce correct signatures for implemented methods.
- *
- * Usage:
- * ```typescript
- * export class ElizaController implements Service<typeof ElizaService> {
- *   constructor() {
- *     ConnectRPC.registerController(this, ElizaService);
- *   }
- *
- *   async say(request: SayRequest): Promise<SayResponse> {
- *     // implementation
- *   }
- *   // Other methods are optional
- * }
- * ```
- */
-export type Service<T> =
-  T extends GenService<infer Methods>
-    ? {
-        [K in keyof Methods]?: ServiceMethod<Methods[K]>;
-      }
-    : never;
-
-export type ServiceMethodNames<T> =
-  T extends GenService<infer Methods>
-    ? {
-        [K in keyof Methods]: K;
-      }[keyof Methods]
-    : never;
-
-/**
- * Middleware configuration for ConnectRPC routes - without service specified
- */
-export type MiddlewareConfigGlobal = {
-  /**
-   * The middleware class to apply (must be decorated with @Middleware())
-   */
-  use: Type<Middleware>;
-
-  /**
-   * Middleware applies to all services and all methods
-   */
-  on?: never;
-  methods?: never;
-};
-
-/**
- * Middleware configuration for ConnectRPC routes - with service specified
- */
-export type MiddlewareConfig<T extends GenService<any>> = {
-  /**
-   * The middleware class to apply (must be decorated with @Middleware())
-   */
-  use: Type<Middleware>;
-
-  /**
-   * The service to apply middleware to
-   */
-  on: T;
-
-  /**
-   * Optional: Specific method names to apply middleware to.
-   * If omitted, middleware applies to all methods of the service.
-   * Method names should match the protobuf method names (e.g., 'say', 'sayMany')
-   */
-  methods?: Array<ServiceMethodNames<T>>;
-};
-
-/**
- * Middleware configuration for ConnectRPC routes
- */
-export type MiddlewareConfigUnion =
-  | MiddlewareConfigGlobal
-  | MiddlewareConfig<any>;
-
-/**
- * Helper function to create a type-safe middleware configuration
- * This ensures proper type inference for method names based on the service
- */
-export function middlewareConfig<T extends GenService<any>>(
-  use: Type<Middleware>,
-  on?: T,
-  methods?: Array<ServiceMethodNames<T>>,
-): MiddlewareConfigUnion {
-  return {
-    use,
-    on,
-    methods,
-  };
-}
-
-export interface ExecutionContext {
-  getClass<T = any>(): Type<T>;
-
-  getHandler(): Function;
-
-  getArgs<T extends Array<any> = any[]>(): T;
-
-  getArgByIndex<T = any>(index: number): T;
-
-  switchToHttp(): {
-    getRequest(): FastifyRequest['raw'];
-    getResponse(): FastifyReply['raw'];
-    getNext<T = any>(): () => T;
-  };
-
-  // Adding these two only for compatibility with NestJS ExecutionContext
-  // Implementations will throw error
-  switchToRpc(): any;
-
-  switchToWs(): any;
-}
-
-export interface Guard {
-  canActivate(context: ExecutionContext): boolean | Promise<boolean>;
-}