@hazeljs/grpc 0.2.0-alpha.1

package/dist/grpc.server.js

@@ -0,0 +1,208 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcServer = void 0;
+const core_1 = require("@hazeljs/core");
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protoLoader = __importStar(require("@grpc/proto-loader"));
+const core_2 = __importDefault(require("@hazeljs/core"));
+const grpc_method_decorator_1 = require("./decorators/grpc-method.decorator");
+const core_3 = require("@hazeljs/core");
+/**
+ * gRPC Server service - manages gRPC server lifecycle and RPC handler registration
+ */
+let GrpcServer = class GrpcServer {
+    constructor() {
+        this.server = null;
+        this.packageDefinition = null;
+        this.protoDescriptor = null;
+        this.options = null;
+        this.handlerMap = new Map();
+    }
+    /**
+     * Configure the server with proto path and options
+     */
+    configure(options) {
+        this.options = options;
+        const protoPath = Array.isArray(options.protoPath) ? options.protoPath : [options.protoPath];
+        const loaderOptions = {
+            keepCase: true,
+            longs: String,
+            enums: String,
+            defaults: true,
+            oneofs: true,
+            ...(options.loader ?? {}),
+        };
+        this.packageDefinition = protoLoader.loadSync(protoPath, loaderOptions);
+        this.protoDescriptor = grpc.loadPackageDefinition(this.packageDefinition);
+        core_2.default.info('gRPC server configured', {
+            package: options.package,
+            url: options.url ?? '0.0.0.0:50051',
+        });
+    }
+    /**
+     * Register RPC handlers from a provider instance (with @GrpcMethod decorators)
+     */
+    registerHandlersFromProvider(provider) {
+        const metadataList = (0, grpc_method_decorator_1.getGrpcMethodMetadata)(provider);
+        for (const meta of metadataList) {
+            const instance = provider;
+            const callback = instance[meta.methodName];
+            if (typeof callback !== 'function') {
+                core_2.default.warn(`@GrpcMethod: method "${meta.methodName}" not found on ${provider.constructor?.name}`);
+                continue;
+            }
+            const boundCallback = callback.bind(provider);
+            const handler = (data) => boundCallback(data);
+            let serviceMap = this.handlerMap.get(meta.service);
+            if (!serviceMap) {
+                serviceMap = new Map();
+                this.handlerMap.set(meta.service, serviceMap);
+            }
+            serviceMap.set(meta.method, handler);
+            core_2.default.debug(`Registered gRPC handler: ${meta.service}/${meta.method}`);
+        }
+    }
+    /**
+     * Register handlers from multiple provider classes (resolved from DI container)
+     */
+    registerHandlersFromProviders(providerClasses) {
+        const container = core_3.Container.getInstance();
+        for (const Cls of providerClasses) {
+            const instance = container.resolve(Cls);
+            if (instance) {
+                this.registerHandlersFromProvider(instance);
+            }
+            else {
+                core_2.default.warn(`Provider ${Cls.name} not found in DI container`);
+            }
+        }
+    }
+    /**
+     * Start the gRPC server and bind to the configured URL
+     */
+    async start() {
+        if (!this.options || !this.protoDescriptor) {
+            throw new Error('GrpcServer not configured. Call configure() or use GrpcModule.forRoot() first.');
+        }
+        const pkg = this.options.package;
+        const pkgObj = this.protoDescriptor[pkg];
+        if (!pkgObj) {
+            throw new Error(`Package "${pkg}" not found in proto descriptor. Check your proto file and package name.`);
+        }
+        this.server = new grpc.Server();
+        for (const [serviceName, serviceMap] of this.handlerMap) {
+            const serviceDef = pkgObj[serviceName];
+            if (!serviceDef?.service) {
+                core_2.default.warn(`Service "${serviceName}" not found in proto. Skipping.`);
+                continue;
+            }
+            const implementation = {};
+            for (const [methodName, handler] of serviceMap) {
+                implementation[methodName] = (call, callback) => {
+                    const request = call.request;
+                    try {
+                        const result = handler(request);
+                        if (result instanceof Promise) {
+                            result
+                                .then((r) => callback(null, r))
+                                .catch((err) => callback(err, null));
+                        }
+                        else {
+                            callback(null, result);
+                        }
+                    }
+                    catch (err) {
+                        callback(err, null);
+                    }
+                };
+            }
+            this.server.addService(serviceDef.service, implementation);
+            core_2.default.info(`Added gRPC service: ${serviceName}`);
+        }
+        const url = this.options.url ?? '0.0.0.0:50051';
+        return new Promise((resolve, reject) => {
+            this.server.bindAsync(url, grpc.ServerCredentials.createInsecure(), (err) => {
+                if (err) {
+                    core_2.default.error('gRPC server bind failed:', err);
+                    reject(err);
+                    return;
+                }
+                core_2.default.info(`gRPC server listening on ${url}`);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Shutdown the gRPC server gracefully
+     */
+    async close() {
+        if (!this.server)
+            return;
+        return new Promise((resolve) => {
+            this.server.tryShutdown((err) => {
+                if (err) {
+                    core_2.default.warn('gRPC server graceful shutdown failed, forcing:', err);
+                    this.server.forceShutdown();
+                }
+                this.server = null;
+                this.packageDefinition = null;
+                this.protoDescriptor = null;
+                this.handlerMap.clear();
+                core_2.default.info('gRPC server closed');
+                resolve();
+            });
+        });
+    }
+    /**
+     * Get the underlying gRPC Server instance (for advanced use)
+     */
+    getServer() {
+        return this.server;
+    }
+};
+exports.GrpcServer = GrpcServer;
+exports.GrpcServer = GrpcServer = __decorate([
+    (0, core_1.Service)()
+], GrpcServer);

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

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=grpc.server.test.d.ts.map

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

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

package/dist/grpc.server.test.js

@@ -0,0 +1,441 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 });
+require("reflect-metadata");
+const core_1 = require("@hazeljs/core");
+const grpc_server_1 = require("./grpc.server");
+const grpc_method_decorator_1 = require("./decorators/grpc-method.decorator");
+const grpc = __importStar(require("@grpc/grpc-js"));
+const path_1 = __importDefault(require("path"));
+jest.mock('@grpc/grpc-js', () => {
+    const actual = jest.requireActual('@grpc/grpc-js');
+    return {
+        ...actual,
+        Server: jest.fn().mockImplementation(() => {
+            const mockServer = {
+                addService: jest.fn(),
+                bindAsync: jest.fn((_url, _creds, callback) => {
+                    setImmediate(() => callback(null));
+                }),
+                start: jest.fn(),
+                tryShutdown: jest.fn((callback) => {
+                    setImmediate(() => callback(null));
+                }),
+                forceShutdown: jest.fn(),
+            };
+            return mockServer;
+        }),
+    };
+});
+describe('GrpcServer', () => {
+    let container;
+    const protoPath = path_1.default.join(__dirname, '__fixtures__', 'hero.proto');
+    beforeEach(() => {
+        container = core_1.Container.createTestInstance();
+        core_1.Container.getInstance = jest.fn(() => container);
+    });
+    describe('configure', () => {
+        it('should load proto and set options', () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({
+                protoPath,
+                package: 'hero',
+                url: '0.0.0.0:50052',
+            });
+            expect(server.getServer()).toBeNull();
+        });
+        it('should accept array of proto paths', () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({
+                protoPath: [protoPath],
+                package: 'hero',
+            });
+            expect(server.getServer()).toBeNull();
+        });
+        it('should accept loader options', () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({
+                protoPath,
+                package: 'hero',
+                loader: { keepCase: false },
+            });
+            expect(server.getServer()).toBeNull();
+        });
+    });
+    describe('registerHandlersFromProvider', () => {
+        it('should register handler from provider with @GrpcMethod', () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            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);
+            server.registerHandlersFromProvider(new TestController());
+            expect(server.getServer()).toBeNull();
+        });
+        it('should skip when method is not a function', () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            class TestController {
+                findOne(_data) {
+                    return { id: 1, 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();
+            controller.findOne = 'not a function';
+            expect(() => server.registerHandlersFromProvider(controller)).not.toThrow();
+        });
+        it('should handle provider with no @GrpcMethod decorators', () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            class PlainController {
+            }
+            expect(() => server.registerHandlersFromProvider(new PlainController())).not.toThrow();
+        });
+        it('should support default method name from property key', () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            class TestController {
+                findOne(data) {
+                    return { id: data.id, name: 'Hero' };
+                }
+            }
+            __decorate([
+                (0, grpc_method_decorator_1.GrpcMethod)('HeroService'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object]),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "findOne", null);
+            expect(() => server.registerHandlersFromProvider(new TestController())).not.toThrow();
+        });
+    });
+    describe('registerHandlersFromProviders', () => {
+        it('should register handlers from container-resolved providers', () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            container.register(grpc_server_1.GrpcServer, server);
+            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);
+            container.register(HeroController, new HeroController());
+            server.registerHandlersFromProviders([HeroController]);
+            expect(server.getServer()).toBeNull();
+        });
+        it('should skip provider when resolve returns undefined', () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            container.register(grpc_server_1.GrpcServer, server);
+            class HeroController {
+                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)
+            ], HeroController.prototype, "findOne", null);
+            const originalResolve = container.resolve.bind(container);
+            jest.spyOn(container, 'resolve').mockImplementation((token) => {
+                if (token === HeroController)
+                    return undefined;
+                return originalResolve(token);
+            });
+            expect(() => server.registerHandlersFromProviders([HeroController])).not.toThrow();
+        });
+    });
+    describe('start', () => {
+        it('should start server and bind to url', async () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero', url: '0.0.0.0:50051' });
+            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);
+            server.registerHandlersFromProvider(new TestController());
+            await server.start();
+            expect(server.getServer()).not.toBeNull();
+            expect(grpc.Server).toHaveBeenCalled();
+            const mockServer = grpc.Server.mock.results[0]?.value;
+            expect(mockServer.addService).toHaveBeenCalled();
+            expect(mockServer.bindAsync).toHaveBeenCalledWith('0.0.0.0:50051', expect.anything(), expect.any(Function));
+            await server.close();
+        });
+        it('should throw when not configured', async () => {
+            const server = new grpc_server_1.GrpcServer();
+            await expect(server.start()).rejects.toThrow('GrpcServer not configured. Call configure() or use GrpcModule.forRoot() first.');
+        });
+        it('should throw when package not found in proto', async () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'nonexistent_package' });
+            await expect(server.start()).rejects.toThrow('Package "nonexistent_package" not found in proto descriptor');
+        });
+        it('should reject when bindAsync fails', async () => {
+            const ServerMock = grpc.Server;
+            const originalImpl = ServerMock.getMockImplementation();
+            ServerMock.mockImplementationOnce(() => ({
+                addService: jest.fn(),
+                bindAsync: jest.fn((_url, _creds, callback) => {
+                    setImmediate(() => callback(new Error('Bind failed')));
+                }),
+                start: jest.fn(),
+                tryShutdown: jest.fn(),
+                forceShutdown: jest.fn(),
+            }));
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            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);
+            server.registerHandlersFromProvider(new TestController());
+            await expect(server.start()).rejects.toThrow('Bind failed');
+            ServerMock.mockImplementation(originalImpl);
+        });
+        it('should skip service when not found in proto', async () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            class TestController {
+                findOne() {
+                    return { id: 1, name: 'Hero' };
+                }
+            }
+            __decorate([
+                (0, grpc_method_decorator_1.GrpcMethod)('NonExistentService', 'FindOne'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "findOne", null);
+            server.registerHandlersFromProvider(new TestController());
+            await server.start();
+            const mockServer = server.getServer();
+            expect(mockServer.addService).not.toHaveBeenCalled();
+            await server.close();
+        });
+        it('should use default url when not provided', async () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            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);
+            server.registerHandlersFromProvider(new TestController());
+            await server.start();
+            const mockServer = grpc.Server.mock.results[0]?.value;
+            expect(mockServer.bindAsync).toHaveBeenCalledWith('0.0.0.0:50051', expect.anything(), expect.any(Function));
+            await server.close();
+        });
+    });
+    describe('close', () => {
+        it('should shutdown server gracefully', async () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            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);
+            server.registerHandlersFromProvider(new TestController());
+            await server.start();
+            await server.close();
+            expect(server.getServer()).toBeNull();
+        });
+        it('should do nothing when server is not started', async () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            await server.close();
+            expect(server.getServer()).toBeNull();
+        });
+        it('should force shutdown when tryShutdown fails', async () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            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);
+            server.registerHandlersFromProvider(new TestController());
+            await server.start();
+            const mockServer = server.getServer();
+            mockServer.tryShutdown.mockImplementation((callback) => {
+                setImmediate(() => callback(new Error('Shutdown failed')));
+            });
+            await server.close();
+            expect(mockServer.forceShutdown).toHaveBeenCalled();
+        });
+    });
+    describe('handler execution', () => {
+        it('should handle async handler that rejects', async () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            class TestController {
+                async findOne() {
+                    throw new Error('Async error');
+                }
+            }
+            __decorate([
+                (0, grpc_method_decorator_1.GrpcMethod)('HeroService', 'FindOne'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", Promise)
+            ], TestController.prototype, "findOne", null);
+            server.registerHandlersFromProvider(new TestController());
+            await server.start();
+            const mockServer = server.getServer();
+            const implementation = mockServer.addService.mock.calls[0][1];
+            const callback = jest.fn();
+            implementation.FindOne({ request: { id: 1 } }, callback);
+            await new Promise((r) => setImmediate(r));
+            expect(callback).toHaveBeenCalledWith(expect.any(Error), null);
+            await server.close();
+        });
+        it('should handle sync handler that throws', async () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            class TestController {
+                findOne() {
+                    throw new Error('Sync error');
+                }
+            }
+            __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);
+            server.registerHandlersFromProvider(new TestController());
+            await server.start();
+            const mockServer = server.getServer();
+            const implementation = mockServer.addService.mock.calls[0][1];
+            const callback = jest.fn();
+            implementation.FindOne({ request: { id: 1 } }, callback);
+            expect(callback).toHaveBeenCalledWith(expect.any(Error), null);
+            await server.close();
+        });
+    });
+    describe('getServer', () => {
+        it('should return null before start', () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            expect(server.getServer()).toBeNull();
+        });
+        it('should return server instance after start', async () => {
+            const server = new grpc_server_1.GrpcServer();
+            server.configure({ protoPath, package: 'hero' });
+            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);
+            server.registerHandlersFromProvider(new TestController());
+            await server.start();
+            expect(server.getServer()).not.toBeNull();
+            await server.close();
+        });
+    });
+});