@hazeljs/grpc 0.2.0-beta.38 → 0.2.0-beta.41

package/README.md

@@ -5,7 +5,8 @@
 RPC server support with decorator-based handlers. Built on [@grpc/grpc-js](https://www.npmjs.com/package/@grpc/grpc-js) and [@grpc/proto-loader](https://www.npmjs.com/package/@grpc/proto-loader).
 
 [![npm version](https://img.shields.io/npm/v/@hazeljs/grpc.svg)](https://www.npmjs.com/package/@hazeljs/grpc)
-[![License: Apache-2.0](https://img.shields.io/npm/l/@hazeljs/grpc.svg)](https://www.apache.org/licenses/LICENSE-2.0)
+[![npm downloads](https://img.shields.io/npm/dm/@hazeljs/grpc)](https://www.npmjs.com/package/@hazeljs/grpc)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
 
 ## Features
 

package/dist/decorators/grpc-method.decorator.test.d.ts

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

package/dist/decorators/grpc-method.decorator.test.d.ts.map

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

package/dist/decorators/grpc-method.decorator.test.js

@@ -0,0 +1,130 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const grpc_method_decorator_1 = require("./grpc-method.decorator");
+describe('GrpcMethod decorator', () => {
+    it('should define GRPC_METHOD_METADATA_KEY', () => {
+        expect(typeof grpc_method_decorator_1.GRPC_METHOD_METADATA_KEY).toBe('symbol');
+    });
+    it('should add metadata for service and method', () => {
+        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 metadata = (0, grpc_method_decorator_1.getGrpcMethodMetadata)(new TestController());
+        expect(metadata).toHaveLength(1);
+        expect(metadata[0].service).toBe('HeroService');
+        expect(metadata[0].method).toBe('FindOne');
+        expect(metadata[0].methodName).toBe('findOne');
+    });
+    it('should default method name to property key when not provided', () => {
+        class TestController {
+            findOne(_data) {
+                return { id: 1, 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);
+        const metadata = (0, grpc_method_decorator_1.getGrpcMethodMetadata)(new TestController());
+        expect(metadata[0].method).toBe('findOne');
+        expect(metadata[0].methodName).toBe('findOne');
+    });
+    it('should add metadata for multiple methods on same class', () => {
+        class TestController {
+            findOne(_data) {
+                return { id: 1, name: 'Hero' };
+            }
+            findAll(_data) {
+                return [];
+            }
+        }
+        __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);
+        __decorate([
+            (0, grpc_method_decorator_1.GrpcMethod)('HeroService', 'FindAll'),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", void 0)
+        ], TestController.prototype, "findAll", null);
+        const metadata = (0, grpc_method_decorator_1.getGrpcMethodMetadata)(new TestController());
+        expect(metadata).toHaveLength(2);
+        expect(metadata[0].service).toBe('HeroService');
+        expect(metadata[0].method).toBe('FindOne');
+        expect(metadata[1].service).toBe('HeroService');
+        expect(metadata[1].method).toBe('FindAll');
+    });
+    it('should support different services on same class', () => {
+        class TestController {
+            findHero(_data) {
+                return { id: 1, name: 'Hero' };
+            }
+            getUser(_data) {
+                return { id: '1', name: 'User' };
+            }
+        }
+        __decorate([
+            (0, grpc_method_decorator_1.GrpcMethod)('HeroService', 'FindOne'),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", void 0)
+        ], TestController.prototype, "findHero", null);
+        __decorate([
+            (0, grpc_method_decorator_1.GrpcMethod)('UserService', 'GetUser'),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", void 0)
+        ], TestController.prototype, "getUser", null);
+        const metadata = (0, grpc_method_decorator_1.getGrpcMethodMetadata)(new TestController());
+        expect(metadata).toHaveLength(2);
+        expect(metadata[0].service).toBe('HeroService');
+        expect(metadata[1].service).toBe('UserService');
+    });
+});
+describe('getGrpcMethodMetadata', () => {
+    it('should return empty array for class without @GrpcMethod decorators', () => {
+        class PlainClass {
+        }
+        const metadata = (0, grpc_method_decorator_1.getGrpcMethodMetadata)(new PlainClass());
+        expect(metadata).toEqual([]);
+    });
+    it('should return metadata from class constructor', () => {
+        class TestController {
+            testMethod() { }
+        }
+        __decorate([
+            (0, grpc_method_decorator_1.GrpcMethod)('TestService', 'TestMethod'),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestController.prototype, "testMethod", null);
+        const instance = new TestController();
+        const metadata = (0, grpc_method_decorator_1.getGrpcMethodMetadata)(instance);
+        expect(metadata).toHaveLength(1);
+        expect(metadata[0].service).toBe('TestService');
+        expect(metadata[0].method).toBe('TestMethod');
+    });
+});

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

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

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

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

package/dist/grpc.client.module.test.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const grpc_client_module_1 = require("./grpc.client.module");
+const grpc_client_1 = require("./grpc.client");
+describe('GrpcClientModule', () => {
+    const protoPath = path_1.default.join(__dirname, '__fixtures__', 'hero.proto');
+    describe('forRoot', () => {
+        it('should return module config with providers and exports', () => {
+            const config = grpc_client_module_1.GrpcClientModule.forRoot({
+                protoPath,
+                package: 'hero',
+                defaultUrl: 'localhost:50051',
+            });
+            expect(config.module).toBe(grpc_client_module_1.GrpcClientModule);
+            expect(config.providers).toHaveLength(1);
+            expect(config.providers[0].provide).toBe(grpc_client_1.GrpcClientService);
+            expect(config.providers[0].useFactory).toBeDefined();
+            expect(config.exports).toContain(grpc_client_1.GrpcClientService);
+            expect(config.global).toBe(true);
+        });
+        it('should use isGlobal option', () => {
+            const config = grpc_client_module_1.GrpcClientModule.forRoot({
+                protoPath,
+                package: 'hero',
+                defaultUrl: 'localhost:50051',
+                isGlobal: false,
+            });
+            expect(config.global).toBe(false);
+        });
+        it('should default isGlobal to true when not provided', () => {
+            const config = grpc_client_module_1.GrpcClientModule.forRoot({
+                protoPath,
+                package: 'hero',
+                defaultUrl: 'localhost:50051',
+            });
+            expect(config.global).toBe(true);
+        });
+        it('should create configured GrpcClientService via factory', () => {
+            const config = grpc_client_module_1.GrpcClientModule.forRoot({
+                protoPath,
+                package: 'hero',
+                defaultUrl: 'localhost:50051',
+            });
+            const factory = config.providers[0].useFactory;
+            const client = factory();
+            expect(client).toBeInstanceOf(grpc_client_1.GrpcClientService);
+        });
+    });
+    describe('forRootAsync', () => {
+        it('should return module config with async providers', () => {
+            const config = grpc_client_module_1.GrpcClientModule.forRootAsync({
+                useFactory: () => ({ protoPath, package: 'hero', defaultUrl: 'localhost:50051' }),
+            });
+            expect(config.module).toBe(grpc_client_module_1.GrpcClientModule);
+            expect(config.providers).toHaveLength(2);
+            expect(config.providers[0].provide).toBe('GRPC_CLIENT_OPTIONS');
+            expect(config.providers[1].provide).toBe(grpc_client_1.GrpcClientService);
+            expect(config.global).toBe(true);
+        });
+        it('should support inject option', () => {
+            const config = grpc_client_module_1.GrpcClientModule.forRootAsync({
+                useFactory: () => ({
+                    protoPath: 'test.proto',
+                    package: 'test',
+                    defaultUrl: 'localhost:50051',
+                }),
+                inject: ['ConfigService'],
+            });
+            expect(config.providers[0]).toHaveProperty('inject', ['ConfigService']);
+        });
+        it('should create GrpcClientService with async options', async () => {
+            const config = grpc_client_module_1.GrpcClientModule.forRootAsync({
+                useFactory: async () => ({ protoPath, package: 'hero', defaultUrl: 'localhost:50051' }),
+            });
+            const optionsFactory = config.providers[0].useFactory;
+            const options = await optionsFactory();
+            const clientFactory = config.providers[1].useFactory;
+            const client = clientFactory(options);
+            expect(client).toBeInstanceOf(grpc_client_1.GrpcClientService);
+        });
+    });
+});

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

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

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

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

package/dist/grpc.client.test.js

@@ -0,0 +1,216 @@
+"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 __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 });
+/// <reference types="jest" />
+require("reflect-metadata");
+const path_1 = __importDefault(require("path"));
+const grpc = __importStar(require("@grpc/grpc-js"));
+const grpc_client_1 = require("./grpc.client");
+const mockStub = {
+    FindOne: jest.fn(),
+};
+jest.mock('@grpc/grpc-js', () => {
+    const actual = jest.requireActual('@grpc/grpc-js');
+    return {
+        ...actual,
+        loadPackageDefinition: jest.fn((_pkgDef) => {
+            return {
+                hero: {
+                    HeroService: jest.fn().mockImplementation(() => mockStub),
+                },
+            };
+        }),
+    };
+});
+describe('GrpcClientService', () => {
+    let client;
+    const protoPath = path_1.default.join(__dirname, '__fixtures__', 'hero.proto');
+    beforeEach(() => {
+        client = new grpc_client_1.GrpcClientService();
+        jest.clearAllMocks();
+    });
+    describe('configure', () => {
+        it('should load proto and set options', () => {
+            client.configure({
+                protoPath,
+                package: 'hero',
+                defaultUrl: 'localhost:50051',
+            });
+            expect(grpc.loadPackageDefinition).toHaveBeenCalled();
+        });
+        it('should accept array of proto paths', () => {
+            client.configure({
+                protoPath: [protoPath],
+                package: 'hero',
+                defaultUrl: 'localhost:50051',
+            });
+            expect(grpc.loadPackageDefinition).toHaveBeenCalled();
+        });
+    });
+    describe('getClient', () => {
+        it('should throw when not configured', () => {
+            expect(() => client.getClient('HeroService')).toThrow('GrpcClientService not configured. Use GrpcClientModule.forRoot() first.');
+        });
+        it('should return stub for configured service', () => {
+            client.configure({
+                protoPath,
+                package: 'hero',
+                defaultUrl: 'localhost:50051',
+            });
+            const stub = client.getClient('HeroService');
+            expect(stub).toBeDefined();
+            expect(stub.FindOne).toBeDefined();
+        });
+        it('should use defaultUrl when url not passed', () => {
+            client.configure({
+                protoPath,
+                package: 'hero',
+                defaultUrl: 'localhost:50052',
+            });
+            const stub = client.getClient('HeroService');
+            expect(stub).toBe(mockStub);
+        });
+        it('should use passed url when provided', () => {
+            client.configure({
+                protoPath,
+                package: 'hero',
+                defaultUrl: 'localhost:50051',
+            });
+            const stub = client.getClient('HeroService', 'localhost:50053');
+            expect(stub).toBe(mockStub);
+        });
+        it('should throw when package not found in proto', () => {
+            grpc.loadPackageDefinition.mockReturnValueOnce({});
+            client.configure({
+                protoPath,
+                package: 'nonexistent',
+                defaultUrl: 'localhost:50051',
+            });
+            expect(() => client.getClient('HeroService')).toThrow('Package "nonexistent" not found in proto descriptor');
+        });
+        it('should throw when service not found in package', () => {
+            grpc.loadPackageDefinition.mockReturnValueOnce({
+                hero: {},
+            });
+            client.configure({
+                protoPath,
+                package: 'hero',
+                defaultUrl: 'localhost:50051',
+            });
+            expect(() => client.getClient('NonExistentService')).toThrow('Service "NonExistentService" not found in package "hero"');
+        });
+        it('should throw when no defaultUrl and url not passed', () => {
+            client.configure({
+                protoPath,
+                package: 'hero',
+            });
+            expect(() => client.getClient('HeroService')).toThrow('No URL provided. Pass url to getClient() or set defaultUrl in GrpcClientModule.forRoot()');
+        });
+        it('should cache stubs per service and url', () => {
+            client.configure({
+                protoPath,
+                package: 'hero',
+                defaultUrl: 'localhost:50051',
+            });
+            const stub1 = client.getClient('HeroService');
+            const stub2 = client.getClient('HeroService');
+            expect(stub1).toBe(stub2);
+        });
+    });
+    describe('getClientAsync', () => {
+        it('should resolve with stub when using defaultUrl', async () => {
+            client.configure({
+                protoPath,
+                package: 'hero',
+                defaultUrl: 'localhost:50051',
+            });
+            const stub = await client.getClientAsync('HeroService');
+            expect(stub).toBeDefined();
+            expect(stub.FindOne).toBeDefined();
+        });
+        it('should resolve with stub when url passed', async () => {
+            client.configure({
+                protoPath,
+                package: 'hero',
+                defaultUrl: 'localhost:50051',
+            });
+            const stub = await client.getClientAsync('HeroService', 'localhost:50052');
+            expect(stub).toBe(mockStub);
+        });
+        it('should use Discovery when configured', async () => {
+            const mockInstance = { host: '127.0.0.1', port: 50051 };
+            client.configure({
+                protoPath,
+                package: 'hero',
+                discovery: {
+                    client: {
+                        getInstance: jest.fn().mockResolvedValue(mockInstance),
+                    },
+                    serviceName: 'hero-service',
+                },
+            });
+            const stub = await client.getClientAsync('HeroService');
+            expect(stub).toBe(mockStub);
+        });
+        it('should throw when Discovery returns null', async () => {
+            client.configure({
+                protoPath,
+                package: 'hero',
+                discovery: {
+                    client: {
+                        getInstance: jest.fn().mockResolvedValue(null),
+                    },
+                    serviceName: 'hero-service',
+                },
+            });
+            await expect(client.getClientAsync('HeroService')).rejects.toThrow('Discovery: no gRPC instance found for service "hero-service"');
+        });
+    });
+    describe('close', () => {
+        it('should clear state', () => {
+            client.configure({
+                protoPath,
+                package: 'hero',
+                defaultUrl: 'localhost:50051',
+            });
+            client.getClient('HeroService');
+            client.close();
+            expect(() => client.getClient('HeroService')).toThrow('GrpcClientService not configured');
+        });
+    });
+});

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.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();
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/grpc",
-  "version": "0.2.0-beta.38",
+  "version": "0.2.0-beta.41",
   "description": "gRPC module for HazelJS framework - RPC server and client support with decorators",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,6 +19,7 @@
     "@grpc/proto-loader": "^0.7.13"
   },
   "devDependencies": {
+    "@types/jest": "^29.5.14",
     "@types/node": "^20.17.50",
     "@typescript-eslint/eslint-plugin": "^8.18.2",
     "@typescript-eslint/parser": "^8.18.2",
@@ -52,5 +53,5 @@
     "url": "https://github.com/hazeljs/hazel-js/issues"
   },
   "homepage": "https://hazeljs.com",
-  "gitHead": "ba1d66ecacc4943a08f85e3f9c077e53224838ff"
+  "gitHead": "b50699eaa4847a8cfe9c346d7e4464b4af7f3120"
 }