@hazeljs/grpc 0.2.0-alpha.1

package/dist/grpc.client.types.d.ts

@@ -0,0 +1,66 @@
+import type { ProtoLoaderOptions } from './grpc.types';
+import type { ChannelCredentials } from '@grpc/grpc-js';
+/**
+ * Service instance shape returned by Discovery (matches @hazeljs/discovery ServiceInstance)
+ */
+export interface GrpcServiceInstanceLike {
+    host: string;
+    port: number;
+    protocol?: 'http' | 'https' | 'grpc';
+}
+/**
+ * Discovery client interface for optional Discovery integration.
+ * Matches @hazeljs/discovery DiscoveryClient API.
+ */
+export interface GrpcDiscoveryClientLike {
+    getInstance(serviceName: string, strategy?: string, filter?: {
+        zone?: string;
+        tags?: string[];
+        metadata?: Record<string, unknown>;
+        status?: unknown;
+    }): Promise<GrpcServiceInstanceLike | null>;
+}
+/**
+ * Discovery configuration for GrpcClientService.
+ * Used when resolving gRPC service URLs via service discovery.
+ */
+export interface GrpcClientDiscoveryConfig {
+    /** Discovery client instance (from @hazeljs/discovery) */
+    client: GrpcDiscoveryClientLike;
+    /** Service name to resolve (e.g. 'product-service') */
+    serviceName: string;
+    /** Load balancing strategy. @default 'round-robin' */
+    loadBalancingStrategy?: string;
+    /** Optional filter for service instances (e.g. filter by protocol: 'grpc') */
+    filter?: {
+        zone?: string;
+        tags?: string[];
+        metadata?: Record<string, unknown>;
+        status?: unknown;
+    };
+}
+/**
+ * gRPC client configuration options
+ */
+export interface GrpcClientOptions {
+    /** Path to .proto file(s). Can be a single path or array of paths. */
+    protoPath: string | string[];
+    /** Package name as defined in the .proto file (e.g. 'hero', 'catalog') */
+    package: string;
+    /** Default URL for gRPC services when not using Discovery (e.g. 'localhost:50051') */
+    defaultUrl?: string;
+    /** Options passed to @grpc/proto-loader */
+    loader?: ProtoLoaderOptions;
+    /** Channel credentials (default: createInsecure) */
+    credentials?: ChannelCredentials;
+    /** Optional Discovery config for dynamic service resolution */
+    discovery?: GrpcClientDiscoveryConfig;
+}
+/**
+ * Extended options for GrpcClientModule.forRoot
+ */
+export interface GrpcClientModuleConfig extends GrpcClientOptions {
+    /** Whether this is a global module. @default true */
+    isGlobal?: boolean;
+}
+//# sourceMappingURL=grpc.client.types.d.ts.map

package/dist/grpc.client.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpc.client.types.d.ts","sourceRoot":"","sources":["../src/grpc.client.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;CACtC;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,WAAW,CACT,WAAW,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE;QACP,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACnC,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB,GACA,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAAC;CAC5C;AAED;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,0DAA0D;IAC1D,MAAM,EAAE,uBAAuB,CAAC;IAChC,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,8EAA8E;IAC9E,MAAM,CAAC,EAAE;QACP,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACnC,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,sEAAsE;IACtE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC7B,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAC;IAChB,sFAAsF;IACtF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B,oDAAoD;IACpD,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,+DAA+D;IAC/D,SAAS,CAAC,EAAE,yBAAyB,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D,qDAAqD;IACrD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB"}

package/dist/grpc.client.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/grpc.module.d.ts

@@ -0,0 +1,73 @@
+import { GrpcServer } from './grpc.server';
+import type { GrpcModuleConfig, GrpcModuleOptions } from './grpc.types';
+/**
+ * gRPC module for HazelJS
+ * Provides gRPC server support with decorator-based RPC handlers
+ *
+ * @example
+ * ```typescript
+ * // app.module.ts
+ * @HazelModule({
+ *   imports: [
+ *     GrpcModule.forRoot({
+ *       protoPath: join(__dirname, 'hero.proto'),
+ *       package: 'hero',
+ *       url: '0.0.0.0:50051',
+ *     })
+ *   ],
+ *   providers: [HeroGrpcController],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export declare class GrpcModule {
+    /**
+     * Configure gRPC module with options
+     */
+    static forRoot(options: GrpcModuleConfig): {
+        module: typeof GrpcModule;
+        providers: Array<{
+            provide: typeof GrpcServer;
+            useFactory: () => GrpcServer;
+        }>;
+        exports: Array<typeof GrpcServer>;
+        global: boolean;
+    };
+    /**
+     * Configure gRPC module asynchronously
+     */
+    static forRootAsync(options: {
+        useFactory: (...args: unknown[]) => Promise<GrpcModuleOptions> | GrpcModuleOptions;
+        inject?: unknown[];
+    }): {
+        module: typeof GrpcModule;
+        providers: Array<{
+            provide: string | typeof GrpcServer;
+            useFactory: unknown;
+            inject?: unknown[];
+        }>;
+        exports: Array<typeof GrpcServer>;
+        global: boolean;
+    };
+    /**
+     * Register gRPC handlers from a provider instance (with @GrpcMethod decorators)
+     *
+     * @example
+     * ```typescript
+     * const heroController = container.resolve(HeroGrpcController);
+     * GrpcModule.registerHandlersFromProvider(heroController);
+     * ```
+     */
+    static registerHandlersFromProvider(provider: object): void;
+    /**
+     * Register gRPC handlers from multiple provider classes
+     * Resolves each from the container and registers their @GrpcMethod handlers
+     *
+     * @example
+     * ```typescript
+     * GrpcModule.registerHandlersFromProviders([HeroGrpcController, UserGrpcController]);
+     * ```
+     */
+    static registerHandlersFromProviders(providerClasses: (new (...args: unknown[]) => object)[]): void;
+}
+//# sourceMappingURL=grpc.module.d.ts.map

package/dist/grpc.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpc.module.d.ts","sourceRoot":"","sources":["../src/grpc.module.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAExE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAIa,UAAU;IACrB;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,gBAAgB,GAAG;QACzC,MAAM,EAAE,OAAO,UAAU,CAAC;QAC1B,SAAS,EAAE,KAAK,CAAC;YACf,OAAO,EAAE,OAAO,UAAU,CAAC;YAC3B,UAAU,EAAE,MAAM,UAAU,CAAC;SAC9B,CAAC,CAAC;QACH,OAAO,EAAE,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;QAClC,MAAM,EAAE,OAAO,CAAC;KACjB;IAsBD;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE;QAC3B,UAAU,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,iBAAiB,CAAC,GAAG,iBAAiB,CAAC;QACnF,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;KACpB,GAAG;QACF,MAAM,EAAE,OAAO,UAAU,CAAC;QAC1B,SAAS,EAAE,KAAK,CAAC;YACf,OAAO,EAAE,MAAM,GAAG,OAAO,UAAU,CAAC;YACpC,UAAU,EAAE,OAAO,CAAC;YACpB,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;SACpB,CAAC,CAAC;QACH,OAAO,EAAE,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;QAClC,MAAM,EAAE,OAAO,CAAC;KACjB;IAwBD;;;;;;;;OAQG;IACH,MAAM,CAAC,4BAA4B,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAgB3D;;;;;;;;OAQG;IACH,MAAM,CAAC,6BAA6B,CAClC,eAAe,EAAE,CAAC,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC,EAAE,GACtD,IAAI;CAWR"}

package/dist/grpc.module.js

@@ -0,0 +1,134 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var GrpcModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcModule = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = require("@hazeljs/core");
+const core_3 = __importDefault(require("@hazeljs/core"));
+const grpc_server_1 = require("./grpc.server");
+/**
+ * gRPC module for HazelJS
+ * Provides gRPC server support with decorator-based RPC handlers
+ *
+ * @example
+ * ```typescript
+ * // app.module.ts
+ * @HazelModule({
+ *   imports: [
+ *     GrpcModule.forRoot({
+ *       protoPath: join(__dirname, 'hero.proto'),
+ *       package: 'hero',
+ *       url: '0.0.0.0:50051',
+ *     })
+ *   ],
+ *   providers: [HeroGrpcController],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+let GrpcModule = GrpcModule_1 = class GrpcModule {
+    /**
+     * Configure gRPC module with options
+     */
+    static forRoot(options) {
+        const { isGlobal = true, ...grpcOptions } = options;
+        core_3.default.info('Configuring gRPC module...');
+        const grpcServerProvider = {
+            provide: grpc_server_1.GrpcServer,
+            useFactory: () => {
+                const server = new grpc_server_1.GrpcServer();
+                server.configure(grpcOptions);
+                return server;
+            },
+        };
+        return {
+            module: GrpcModule_1,
+            providers: [grpcServerProvider],
+            exports: [grpc_server_1.GrpcServer],
+            global: isGlobal,
+        };
+    }
+    /**
+     * Configure gRPC module asynchronously
+     */
+    static forRootAsync(options) {
+        return {
+            module: GrpcModule_1,
+            providers: [
+                {
+                    provide: 'GRPC_OPTIONS',
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                },
+                {
+                    provide: grpc_server_1.GrpcServer,
+                    useFactory: (grpcOptions) => {
+                        const server = new grpc_server_1.GrpcServer();
+                        server.configure(grpcOptions);
+                        return server;
+                    },
+                    inject: ['GRPC_OPTIONS'],
+                },
+            ],
+            exports: [grpc_server_1.GrpcServer],
+            global: true,
+        };
+    }
+    /**
+     * Register gRPC handlers from a provider instance (with @GrpcMethod decorators)
+     *
+     * @example
+     * ```typescript
+     * const heroController = container.resolve(HeroGrpcController);
+     * GrpcModule.registerHandlersFromProvider(heroController);
+     * ```
+     */
+    static registerHandlersFromProvider(provider) {
+        try {
+            const container = core_2.Container.getInstance();
+            const grpcServer = container.resolve(grpc_server_1.GrpcServer);
+            if (!grpcServer) {
+                core_3.default.warn('GrpcServer not found in DI container');
+                return;
+            }
+            grpcServer.registerHandlersFromProvider(provider);
+        }
+        catch (error) {
+            core_3.default.error('Error registering gRPC handlers from provider:', error);
+        }
+    }
+    /**
+     * Register gRPC handlers from multiple provider classes
+     * Resolves each from the container and registers their @GrpcMethod handlers
+     *
+     * @example
+     * ```typescript
+     * GrpcModule.registerHandlersFromProviders([HeroGrpcController, UserGrpcController]);
+     * ```
+     */
+    static registerHandlersFromProviders(providerClasses) {
+        const container = core_2.Container.getInstance();
+        const grpcServer = container.resolve(grpc_server_1.GrpcServer);
+        if (!grpcServer) {
+            core_3.default.warn('GrpcServer not found in DI container');
+            return;
+        }
+        grpcServer.registerHandlersFromProviders(providerClasses);
+    }
+};
+exports.GrpcModule = GrpcModule;
+exports.GrpcModule = GrpcModule = GrpcModule_1 = __decorate([
+    (0, core_1.HazelModule)({
+        providers: [],
+        exports: [],
+    })
+], GrpcModule);

package/dist/grpc.module.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=grpc.module.test.d.ts.map

package/dist/grpc.module.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpc.module.test.d.ts","sourceRoot":"","sources":["../src/grpc.module.test.ts"],"names":[],"mappings":""}

package/dist/grpc.module.test.js

@@ -0,0 +1,208 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@hazeljs/core");
+const grpc_module_1 = require("./grpc.module");
+const grpc_server_1 = require("./grpc.server");
+const grpc_method_decorator_1 = require("./decorators/grpc-method.decorator");
+const path_1 = __importDefault(require("path"));
+describe('GrpcModule', () => {
+    let container;
+    const originalGetInstance = core_1.Container.getInstance;
+    beforeEach(() => {
+        container = core_1.Container.createTestInstance();
+        core_1.Container.getInstance = jest.fn(() => container);
+    });
+    afterEach(() => {
+        core_1.Container.getInstance = originalGetInstance;
+    });
+    describe('forRoot', () => {
+        it('should return module config with providers and exports', () => {
+            const protoPath = path_1.default.join(__dirname, '__fixtures__', 'hero.proto');
+            const config = grpc_module_1.GrpcModule.forRoot({
+                protoPath,
+                package: 'hero',
+            });
+            expect(config.module).toBe(grpc_module_1.GrpcModule);
+            expect(config.providers).toHaveLength(1);
+            expect(config.providers[0].provide).toBe(grpc_server_1.GrpcServer);
+            expect(config.providers[0].useFactory).toBeDefined();
+            expect(config.exports).toContain(grpc_server_1.GrpcServer);
+            expect(config.global).toBe(true);
+        });
+        it('should use isGlobal option', () => {
+            const protoPath = path_1.default.join(__dirname, '__fixtures__', 'hero.proto');
+            const config = grpc_module_1.GrpcModule.forRoot({
+                protoPath,
+                package: 'hero',
+                isGlobal: false,
+            });
+            expect(config.global).toBe(false);
+        });
+        it('should default isGlobal to true when not provided', () => {
+            const protoPath = path_1.default.join(__dirname, '__fixtures__', 'hero.proto');
+            const config = grpc_module_1.GrpcModule.forRoot({
+                protoPath,
+                package: 'hero',
+            });
+            expect(config.global).toBe(true);
+        });
+        it('should create configured GrpcServer via factory', () => {
+            const protoPath = path_1.default.join(__dirname, '__fixtures__', 'hero.proto');
+            const config = grpc_module_1.GrpcModule.forRoot({
+                protoPath,
+                package: 'hero',
+                url: '0.0.0.0:50052',
+            });
+            const factory = config.providers[0].useFactory;
+            const server = factory();
+            expect(server).toBeInstanceOf(grpc_server_1.GrpcServer);
+            expect(server.getServer()).toBeNull();
+        });
+    });
+    describe('forRootAsync', () => {
+        it('should return module config with async providers', () => {
+            const protoPath = path_1.default.join(__dirname, '__fixtures__', 'hero.proto');
+            const config = grpc_module_1.GrpcModule.forRootAsync({
+                useFactory: () => ({ protoPath, package: 'hero' }),
+            });
+            expect(config.module).toBe(grpc_module_1.GrpcModule);
+            expect(config.providers).toHaveLength(2);
+            expect(config.providers[0].provide).toBe('GRPC_OPTIONS');
+            expect(config.providers[1].provide).toBe(grpc_server_1.GrpcServer);
+            expect(config.global).toBe(true);
+        });
+        it('should support inject option', () => {
+            const config = grpc_module_1.GrpcModule.forRootAsync({
+                useFactory: () => ({ protoPath: 'test.proto', package: 'test' }),
+                inject: ['ConfigService'],
+            });
+            expect(config.providers[0]).toHaveProperty('inject', ['ConfigService']);
+        });
+        it('should create GrpcServer with async options', async () => {
+            const protoPath = path_1.default.join(__dirname, '__fixtures__', 'hero.proto');
+            const config = grpc_module_1.GrpcModule.forRootAsync({
+                useFactory: async () => ({ protoPath, package: 'hero' }),
+            });
+            const optionsFactory = config.providers[0].useFactory;
+            const options = await optionsFactory();
+            const serverFactory = config.providers[1].useFactory;
+            const server = serverFactory(options);
+            expect(server).toBeInstanceOf(grpc_server_1.GrpcServer);
+        });
+    });
+    describe('registerHandlersFromProvider', () => {
+        it('should register gRPC handlers from provider with @GrpcMethod', () => {
+            const protoPath = path_1.default.join(__dirname, '__fixtures__', 'hero.proto');
+            const grpcServer = new grpc_server_1.GrpcServer();
+            grpcServer.configure({ protoPath, package: 'hero' });
+            container.register(grpc_server_1.GrpcServer, grpcServer);
+            class TestController {
+                findOne(data) {
+                    return { id: data.id, name: 'Hero' };
+                }
+            }
+            __decorate([
+                (0, grpc_method_decorator_1.GrpcMethod)('HeroService', 'FindOne'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object]),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "findOne", null);
+            const controller = new TestController();
+            grpc_module_1.GrpcModule.registerHandlersFromProvider(controller);
+            expect(grpcServer.getServer()).toBeNull();
+        });
+        it('should handle GrpcServer not in container', () => {
+            const emptyContainer = core_1.Container.createTestInstance();
+            emptyContainer.register(grpc_server_1.GrpcServer, undefined);
+            core_1.Container.getInstance = jest.fn(() => emptyContainer);
+            class TestController {
+                findOne() {
+                    return { id: 1, name: 'Hero' };
+                }
+            }
+            __decorate([
+                (0, grpc_method_decorator_1.GrpcMethod)('HeroService', 'FindOne'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "findOne", null);
+            expect(() => {
+                grpc_module_1.GrpcModule.registerHandlersFromProvider(new TestController());
+            }).not.toThrow();
+        });
+        it('should handle errors during registration gracefully', () => {
+            core_1.Container.getInstance = jest.fn(() => {
+                throw new Error('Container error');
+            });
+            class TestController {
+                findOne() {
+                    return { id: 1, name: 'Hero' };
+                }
+            }
+            __decorate([
+                (0, grpc_method_decorator_1.GrpcMethod)('HeroService', 'FindOne'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "findOne", null);
+            expect(() => {
+                grpc_module_1.GrpcModule.registerHandlersFromProvider(new TestController());
+            }).not.toThrow();
+        });
+    });
+    describe('registerHandlersFromProviders', () => {
+        it('should register handlers from multiple provider classes', () => {
+            const protoPath = path_1.default.join(__dirname, '__fixtures__', 'hero.proto');
+            const grpcServer = new grpc_server_1.GrpcServer();
+            grpcServer.configure({ protoPath, package: 'hero' });
+            container.register(grpc_server_1.GrpcServer, grpcServer);
+            class HeroController {
+                findOne(data) {
+                    return { id: data.id, name: 'Hero' };
+                }
+            }
+            __decorate([
+                (0, grpc_method_decorator_1.GrpcMethod)('HeroService', 'FindOne'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object]),
+                __metadata("design:returntype", void 0)
+            ], HeroController.prototype, "findOne", null);
+            const heroInstance = new HeroController();
+            container.register(HeroController, heroInstance);
+            grpc_module_1.GrpcModule.registerHandlersFromProviders([HeroController]);
+            expect(grpcServer.getServer()).toBeNull();
+        });
+        it('should handle GrpcServer not in container', () => {
+            const emptyContainer = core_1.Container.createTestInstance();
+            emptyContainer.register(grpc_server_1.GrpcServer, undefined);
+            core_1.Container.getInstance = jest.fn(() => emptyContainer);
+            class TestController {
+                findOne() {
+                    return { id: 1, name: 'Hero' };
+                }
+            }
+            __decorate([
+                (0, grpc_method_decorator_1.GrpcMethod)('HeroService', 'FindOne'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "findOne", null);
+            container.register(TestController, new TestController());
+            expect(() => {
+                grpc_module_1.GrpcModule.registerHandlersFromProviders([TestController]);
+            }).not.toThrow();
+        });
+    });
+});

package/dist/grpc.server.d.ts

@@ -0,0 +1,37 @@
+import * as grpc from '@grpc/grpc-js';
+import type { GrpcModuleOptions } from './grpc.types';
+/**
+ * gRPC Server service - manages gRPC server lifecycle and RPC handler registration
+ */
+export declare class GrpcServer {
+    private server;
+    private packageDefinition;
+    private protoDescriptor;
+    private options;
+    private handlerMap;
+    /**
+     * Configure the server with proto path and options
+     */
+    configure(options: GrpcModuleOptions): void;
+    /**
+     * Register RPC handlers from a provider instance (with @GrpcMethod decorators)
+     */
+    registerHandlersFromProvider(provider: object): void;
+    /**
+     * Register handlers from multiple provider classes (resolved from DI container)
+     */
+    registerHandlersFromProviders(providerClasses: (new (...args: unknown[]) => object)[]): void;
+    /**
+     * Start the gRPC server and bind to the configured URL
+     */
+    start(): Promise<void>;
+    /**
+     * Shutdown the gRPC server gracefully
+     */
+    close(): Promise<void>;
+    /**
+     * Get the underlying gRPC Server instance (for advanced use)
+     */
+    getServer(): grpc.Server | null;
+}
+//# sourceMappingURL=grpc.server.d.ts.map

package/dist/grpc.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpc.server.d.ts","sourceRoot":"","sources":["../src/grpc.server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,IAAI,MAAM,eAAe,CAAC;AAItC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAStD;;GAEG;AACH,qBACa,UAAU;IACrB,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,iBAAiB,CAAkC;IAC3D,OAAO,CAAC,eAAe,CAAwC;IAC/D,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,UAAU,CACN;IAEZ;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAuB3C;;OAEG;IACH,4BAA4B,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IA2BpD;;OAEG;IACH,6BAA6B,CAAC,eAAe,EAAE,CAAC,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC,EAAE,GAAG,IAAI;IAY5F;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAoE5B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB5B;;OAEG;IACH,SAAS,IAAI,IAAI,CAAC,MAAM,GAAG,IAAI;CAGhC"}