@hazeljs/grpc 0.2.0-alpha.1

package/dist/grpc.client.js

@@ -0,0 +1,188 @@
+"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.GrpcClientService = 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"));
+/**
+ * gRPC Client service - creates and caches gRPC client stubs for calling remote gRPC services
+ */
+let GrpcClientService = class GrpcClientService {
+    constructor() {
+        this.packageDefinition = null;
+        this.protoDescriptor = null;
+        this.options = null;
+        this.stubCache = new Map();
+    }
+    /**
+     * Configure the client 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 client configured', {
+            package: options.package,
+            defaultUrl: options.defaultUrl,
+            discovery: !!options.discovery,
+        });
+    }
+    /**
+     * Resolve URL from Discovery when configured
+     */
+    async resolveUrl(serviceName) {
+        const discovery = this.options?.discovery;
+        if (!discovery) {
+            const defaultUrl = this.options?.defaultUrl;
+            if (!defaultUrl) {
+                throw new Error('No URL provided and no defaultUrl configured. Pass url to getClient() or set defaultUrl in GrpcClientModule.forRoot().');
+            }
+            return defaultUrl;
+        }
+        const client = discovery.client;
+        const strategy = discovery.loadBalancingStrategy ?? 'round-robin';
+        const filter = this.buildDiscoveryFilter(discovery);
+        const instance = await client.getInstance(discovery.serviceName, strategy, filter);
+        if (!instance) {
+            throw new Error(`Discovery: no gRPC instance found for service "${discovery.serviceName}"`);
+        }
+        const url = `${instance.host}:${instance.port}`;
+        core_2.default.debug('Resolved gRPC URL from Discovery', { serviceName, url });
+        return url;
+    }
+    /**
+     * Build filter for Discovery.
+     * Passes user filter; for protocol: 'grpc' use metadata: { protocol: 'grpc' }
+     * since ServiceFilter filters by metadata.
+     */
+    buildDiscoveryFilter(discovery) {
+        return discovery.filter ?? {};
+    }
+    /**
+     * Get a gRPC client stub for the given service.
+     * When Discovery is configured and url is omitted, resolves URL from Discovery.
+     * Stubs are cached per (serviceName, url).
+     *
+     * @param serviceName - Service name as defined in proto (e.g. 'ProductService')
+     * @param url - Optional URL (e.g. 'localhost:50051'). Required if not using Discovery and no defaultUrl.
+     * @returns gRPC client stub with RPC methods
+     */
+    getClient(serviceName, url) {
+        if (!this.protoDescriptor || !this.options) {
+            throw new Error('GrpcClientService not configured. Use GrpcClientModule.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.`);
+        }
+        const ServiceConstructor = pkgObj[serviceName];
+        if (!ServiceConstructor) {
+            throw new Error(`Service "${serviceName}" not found in package "${pkg}". Check your proto file.`);
+        }
+        const resolveAndGetStub = (resolvedUrl) => {
+            let urlMap = this.stubCache.get(serviceName);
+            if (!urlMap) {
+                urlMap = new Map();
+                this.stubCache.set(serviceName, urlMap);
+            }
+            let stub = urlMap.get(resolvedUrl);
+            if (!stub) {
+                const credentials = this.options.credentials ?? grpc.credentials.createInsecure();
+                stub = new ServiceConstructor(resolvedUrl, credentials);
+                urlMap.set(resolvedUrl, stub);
+                core_2.default.debug('Created gRPC client stub', { serviceName, url: resolvedUrl });
+            }
+            return stub;
+        };
+        if (url) {
+            return resolveAndGetStub(url);
+        }
+        if (this.options.discovery) {
+            throw new Error('Discovery mode requires async getClientAsync(). Use getClientAsync(serviceName) when Discovery is configured.');
+        }
+        const defaultUrl = this.options.defaultUrl;
+        if (!defaultUrl) {
+            throw new Error('No URL provided. Pass url to getClient() or set defaultUrl in GrpcClientModule.forRoot().');
+        }
+        return resolveAndGetStub(defaultUrl);
+    }
+    /**
+     * Get a gRPC client stub asynchronously.
+     * Use this when Discovery is configured, as URL resolution is async.
+     *
+     * @param serviceName - Service name as defined in proto (e.g. 'ProductService')
+     * @param url - Optional URL. When omitted and Discovery is configured, resolves from Discovery.
+     * @returns Promise resolving to gRPC client stub
+     */
+    async getClientAsync(serviceName, url) {
+        const resolvedUrl = url ?? (await this.resolveUrl(serviceName));
+        return this.getClient(serviceName, resolvedUrl);
+    }
+    /**
+     * Close all cached client channels (for graceful shutdown)
+     */
+    close() {
+        this.stubCache.clear();
+        this.packageDefinition = null;
+        this.protoDescriptor = null;
+        this.options = null;
+        core_2.default.info('gRPC client closed');
+    }
+};
+exports.GrpcClientService = GrpcClientService;
+exports.GrpcClientService = GrpcClientService = __decorate([
+    (0, core_1.Service)()
+], GrpcClientService);

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

@@ -0,0 +1,65 @@
+import { GrpcClientService } from './grpc.client';
+import type { GrpcClientModuleConfig } from './grpc.client.types';
+/**
+ * gRPC Client module for HazelJS
+ * Provides gRPC client support for calling remote gRPC services
+ *
+ * @example
+ * ```typescript
+ * // Static URL
+ * @HazelModule({
+ *   imports: [
+ *     GrpcClientModule.forRoot({
+ *       protoPath: join(__dirname, 'product.proto'),
+ *       package: 'catalog',
+ *       defaultUrl: 'localhost:50051',
+ *     }),
+ *   ],
+ *   providers: [OrderService],
+ * })
+ * export class AppModule {}
+ *
+ * // With Discovery
+ * GrpcClientModule.forRoot({
+ *   protoPath: join(__dirname, 'product.proto'),
+ *   package: 'catalog',
+ *   discovery: {
+ *     client: discoveryClient,
+ *     serviceName: 'product-service',
+ *     loadBalancingStrategy: 'round-robin',
+ *     filter: { metadata: { protocol: 'grpc' } },
+ *   },
+ * });
+ * ```
+ */
+export declare class GrpcClientModule {
+    /**
+     * Configure gRPC client module with options
+     */
+    static forRoot(options: GrpcClientModuleConfig): {
+        module: typeof GrpcClientModule;
+        providers: Array<{
+            provide: typeof GrpcClientService;
+            useFactory: () => GrpcClientService;
+        }>;
+        exports: Array<typeof GrpcClientService>;
+        global: boolean;
+    };
+    /**
+     * Configure gRPC client module asynchronously
+     */
+    static forRootAsync(options: {
+        useFactory: (...args: unknown[]) => Promise<GrpcClientModuleConfig> | GrpcClientModuleConfig;
+        inject?: unknown[];
+    }): {
+        module: typeof GrpcClientModule;
+        providers: Array<{
+            provide: string | typeof GrpcClientService;
+            useFactory: unknown;
+            inject?: unknown[];
+        }>;
+        exports: Array<typeof GrpcClientService>;
+        global: boolean;
+    };
+}
+//# sourceMappingURL=grpc.client.module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grpc.client.module.d.ts","sourceRoot":"","sources":["../src/grpc.client.module.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAIa,gBAAgB;IAC3B;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,sBAAsB,GAAG;QAC/C,MAAM,EAAE,OAAO,gBAAgB,CAAC;QAChC,SAAS,EAAE,KAAK,CAAC;YACf,OAAO,EAAE,OAAO,iBAAiB,CAAC;YAClC,UAAU,EAAE,MAAM,iBAAiB,CAAC;SACrC,CAAC,CAAC;QACH,OAAO,EAAE,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;QACzC,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,sBAAsB,CAAC,GAAG,sBAAsB,CAAC;QAC7F,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;KACpB,GAAG;QACF,MAAM,EAAE,OAAO,gBAAgB,CAAC;QAChC,SAAS,EAAE,KAAK,CAAC;YACf,OAAO,EAAE,MAAM,GAAG,OAAO,iBAAiB,CAAC;YAC3C,UAAU,EAAE,OAAO,CAAC;YACpB,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;SACpB,CAAC,CAAC;QACH,OAAO,EAAE,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;QACzC,MAAM,EAAE,OAAO,CAAC;KACjB;CAuBF"}

package/dist/grpc.client.module.js

@@ -0,0 +1,104 @@
+"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 GrpcClientModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcClientModule = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+const grpc_client_1 = require("./grpc.client");
+/**
+ * gRPC Client module for HazelJS
+ * Provides gRPC client support for calling remote gRPC services
+ *
+ * @example
+ * ```typescript
+ * // Static URL
+ * @HazelModule({
+ *   imports: [
+ *     GrpcClientModule.forRoot({
+ *       protoPath: join(__dirname, 'product.proto'),
+ *       package: 'catalog',
+ *       defaultUrl: 'localhost:50051',
+ *     }),
+ *   ],
+ *   providers: [OrderService],
+ * })
+ * export class AppModule {}
+ *
+ * // With Discovery
+ * GrpcClientModule.forRoot({
+ *   protoPath: join(__dirname, 'product.proto'),
+ *   package: 'catalog',
+ *   discovery: {
+ *     client: discoveryClient,
+ *     serviceName: 'product-service',
+ *     loadBalancingStrategy: 'round-robin',
+ *     filter: { metadata: { protocol: 'grpc' } },
+ *   },
+ * });
+ * ```
+ */
+let GrpcClientModule = GrpcClientModule_1 = class GrpcClientModule {
+    /**
+     * Configure gRPC client module with options
+     */
+    static forRoot(options) {
+        const { isGlobal = true, ...clientOptions } = options;
+        core_2.default.info('Configuring gRPC client module...');
+        const grpcClientProvider = {
+            provide: grpc_client_1.GrpcClientService,
+            useFactory: () => {
+                const client = new grpc_client_1.GrpcClientService();
+                client.configure(clientOptions);
+                return client;
+            },
+        };
+        return {
+            module: GrpcClientModule_1,
+            providers: [grpcClientProvider],
+            exports: [grpc_client_1.GrpcClientService],
+            global: isGlobal,
+        };
+    }
+    /**
+     * Configure gRPC client module asynchronously
+     */
+    static forRootAsync(options) {
+        return {
+            module: GrpcClientModule_1,
+            providers: [
+                {
+                    provide: 'GRPC_CLIENT_OPTIONS',
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                },
+                {
+                    provide: grpc_client_1.GrpcClientService,
+                    useFactory: (clientOptions) => {
+                        const client = new grpc_client_1.GrpcClientService();
+                        client.configure(clientOptions);
+                        return client;
+                    },
+                    inject: ['GRPC_CLIENT_OPTIONS'],
+                },
+            ],
+            exports: [grpc_client_1.GrpcClientService],
+            global: true,
+        };
+    }
+};
+exports.GrpcClientModule = GrpcClientModule;
+exports.GrpcClientModule = GrpcClientModule = GrpcClientModule_1 = __decorate([
+    (0, core_1.HazelModule)({
+        providers: [],
+        exports: [],
+    })
+], GrpcClientModule);

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