@funduck/connectrpc-fastify 1.0.7 → 1.0.8

package/dist/connectrpc.d.ts

@@ -0,0 +1,29 @@
+import { GenService, GenServiceMethods } from '@bufbuild/protobuf/codegenv2';
+import { FastifyInstance } from 'fastify';
+import { Guard, Logger, Middleware, MiddlewareConfigUnion, Service } from './interfaces';
+declare class ConnectRPCClass {
+    setLogger(customLogger: Logger): void;
+    registerMiddleware(self: Middleware, options?: {
+        allowMultipleInstances?: boolean;
+    }): void;
+    /**
+     * @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;
+    }): void;
+    registerGuard(self: Guard, options?: {
+        allowMultipleInstances?: boolean;
+    }): void;
+    registerFastifyPlugin(server: FastifyInstance): Promise<void>;
+    private _middlewaresInitialized;
+    initMiddlewares(server: FastifyInstance, middlewareConfigs: MiddlewareConfigUnion[]): Promise<void>;
+    private _guardsInitialized;
+    initGuards(server: FastifyInstance): Promise<void>;
+}
+/**
+ * Main ConnectRPC class to manage registration of controllers and middlewares
+ */
+export declare const ConnectRPC: ConnectRPCClass;
+export {};

package/dist/execution-context.d.ts

@@ -0,0 +1,22 @@
+import { FastifyReply, FastifyRequest } from 'fastify';
+import { ExecutionContext, Type } from './interfaces';
+export declare class ManualExecutionContext implements ExecutionContext {
+    readonly request: FastifyRequest['raw'];
+    readonly response: FastifyReply['raw'];
+    readonly next: <T = any>() => T;
+    readonly args: any[];
+    readonly constructorRef: Type<any> | null;
+    readonly handler: Function | null;
+    constructor(request: FastifyRequest['raw'], response: FastifyReply['raw'], next: <T = any>() => T, args: any[], constructorRef?: Type<any> | null, handler?: Function | null);
+    getClass<T = any>(): Type<T>;
+    getHandler(): Function;
+    getArgs<T extends Array<any> = any[]>(): T;
+    getArgByIndex<T = any>(index: number): T;
+    switchToHttp(): this & {
+        getRequest: () => import("node:http").IncomingMessage;
+        getResponse: () => import("node:http").ServerResponse<import("node:http").IncomingMessage>;
+        getNext: () => <T = any>() => T;
+    };
+    switchToRpc(): void;
+    switchToWs(): void;
+}

package/dist/fastify-plugin.d.ts

@@ -0,0 +1,5 @@
+import { Compression } from '@connectrpc/connect/protocol';
+import { FastifyInstance } from 'fastify';
+export declare function registerFastifyPlugin(server: FastifyInstance, options?: {
+    acceptCompression?: Compression[];
+}): Promise<void>;

package/dist/guards.d.ts

@@ -0,0 +1,11 @@
+import { FastifyInstance } from 'fastify';
+import { ExecutionContext, Guard } from './interfaces';
+export declare class ManualGuardExecutor {
+    executeGuard(guard: Guard, context: ExecutionContext): Promise<boolean>;
+    executeGuards(guards: Guard[], context: ExecutionContext): Promise<boolean>;
+}
+export declare function getGuards(controller: any): Guard[];
+/**
+ * Initialize guards middleware - this should be called after all other middlewares are registered
+ */
+export declare function initGuards(server: FastifyInstance): Promise<void>;

package/dist/helpers.d.ts

@@ -0,0 +1,13 @@
+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 declare function discoverMethodMappings(prototype: any, service: GenService<any>): Record<string, string>;
+/**
+ * Helper to convert NestJS middleware to Fastify hook
+ */
+export declare function convertMiddlewareToHook(middlewareInstance: any): (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+export declare let logger: Logger;
+export declare function setLogger(customLogger: Logger): void;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export declare function printMsg(): void;
+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/dist/interfaces.d.ts

@@ -0,0 +1,125 @@
+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 declare function middlewareConfig<T extends GenService<any>>(use: Type<Middleware>, on?: T, methods?: Array<ServiceMethodNames<T>>): MiddlewareConfigUnion;
+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;
+    };
+    switchToRpc(): any;
+    switchToWs(): any;
+}
+export interface Guard {
+    canActivate(context: ExecutionContext): boolean | Promise<boolean>;
+}
+export {};

package/dist/middlewares.d.ts

@@ -0,0 +1,3 @@
+import { FastifyInstance } from 'fastify';
+import { MiddlewareConfigUnion } from './interfaces';
+export declare function initMiddlewares(server: FastifyInstance, middlewareConfigs: MiddlewareConfigUnion[]): Promise<void>;

package/dist/stores.d.ts

@@ -0,0 +1,92 @@
+import { GenService, GenServiceMethods } from '@bufbuild/protobuf/codegenv2';
+import { Guard, Middleware, Service, Type } from './interfaces';
+declare class ControllersStoreClass {
+    private controllers;
+    values(): {
+        instance: any;
+        service: GenService<any>;
+        target: Type<any>;
+    }[];
+    registerInstance<T extends GenServiceMethods>(self: Service<GenService<T>>, service: GenService<T>, { allowMultipleInstances, }?: {
+        allowMultipleInstances?: boolean;
+    }): void;
+}
+export declare const ControllersStore: ControllersStoreClass;
+/**
+ * Store for middleware classes and their instances
+ */
+declare class MiddlewareStoreClass {
+    private middlewares;
+    /**
+     * Register a middleware instance from its constructor
+     */
+    registerInstance(self: Middleware, { allowMultipleInstances, }?: {
+        allowMultipleInstances?: boolean;
+    }): void;
+    /**
+     * Get a middleware instance by its class
+     */
+    getInstance(middlewareClass: Type<Middleware>): Middleware | null;
+}
+export declare const MiddlewareStore: MiddlewareStoreClass;
+/**
+ * Store for route metadata - maps URL paths to controller class and method info
+ */
+declare class RouteMetadataStoreClass {
+    private routes;
+    /**
+     * 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): void;
+    /**
+     * Get route metadata by URL path
+     */
+    getRouteMetadata(urlPath: string): {
+        controllerClass: Type<any>;
+        controllerMethod: Function;
+        controllerMethodName: string;
+        instance: any;
+        serviceName: string;
+        methodName: string;
+    } | null;
+    /**
+     * Get all registered routes
+     */
+    getAllRoutes(): [string, {
+        controllerClass: Type<any>;
+        controllerMethod: Function;
+        controllerMethodName: string;
+        instance: any;
+        serviceName: string;
+        methodName: string;
+    }][];
+}
+export declare const RouteMetadataStore: RouteMetadataStoreClass;
+/**
+ * Store for guard classes and their instances
+ */
+declare class GuardsStoreClass {
+    private guards;
+    /**
+     * Register a guard instance from its constructor
+     */
+    registerInstance(self: Guard, { allowMultipleInstances, }?: {
+        allowMultipleInstances?: boolean;
+    }): void;
+    /**
+     * Get a guard instance by its class
+     */
+    getInstance(guardClass: Type<Guard>): Guard | null;
+    /**
+     * Get all registered guards
+     */
+    getAllGuards(): Guard[];
+}
+export declare const GuardsStore: GuardsStoreClass;
+export {};

package/dist/types.d.ts

@@ -0,0 +1,13 @@
+import type { 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funduck/connectrpc-fastify",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "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/src/index.js",