@hazeljs/grpc 0.2.0-beta.34 → 0.2.0-beta.35

package/dist/grpc.client.d.ts

@@ -0,0 +1,50 @@
+import type { GrpcClientOptions } from './grpc.client.types';
+type GrpcClientStub = Record<string, (req: unknown, cb: (err: Error | null, res: unknown) => void) => void>;
+/**
+ * gRPC Client service - creates and caches gRPC client stubs for calling remote gRPC services
+ */
+export declare class GrpcClientService {
+    private packageDefinition;
+    private protoDescriptor;
+    private options;
+    private stubCache;
+    /**
+     * Configure the client with proto path and options
+     */
+    configure(options: GrpcClientOptions): void;
+    /**
+     * Resolve URL from Discovery when configured
+     */
+    private resolveUrl;
+    /**
+     * Build filter for Discovery.
+     * Passes user filter; for protocol: 'grpc' use metadata: { protocol: 'grpc' }
+     * since ServiceFilter filters by metadata.
+     */
+    private buildDiscoveryFilter;
+    /**
+     * 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: string, url?: string): GrpcClientStub;
+    /**
+     * 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
+     */
+    getClientAsync(serviceName: string, url?: string): Promise<GrpcClientStub>;
+    /**
+     * Close all cached client channels (for graceful shutdown)
+     */
+    close(): void;
+}
+export {};
+//# sourceMappingURL=grpc.client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grpc.client.d.ts","sourceRoot":"","sources":["../src/grpc.client.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,iBAAiB,EAGlB,MAAM,qBAAqB,CAAC;AAE7B,KAAK,cAAc,GAAG,MAAM,CAC1B,MAAM,EACN,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,OAAO,KAAK,IAAI,KAAK,IAAI,CACtE,CAAC;AAEF;;GAEG;AACH,qBACa,iBAAiB;IAC5B,OAAO,CAAC,iBAAiB,CAAkC;IAC3D,OAAO,CAAC,eAAe,CAAwC;IAC/D,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,SAAS,CAAkD;IAEnE;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAwB3C;;OAEG;YACW,UAAU;IA0BxB;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;;;;;;;OAQG;IACH,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,cAAc;IA2D5D;;;;;;;OAOG;IACG,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAKhF;;OAEG;IACH,KAAK,IAAI,IAAI;CAOd"}

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.Injectable)()
+], 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.types.d.ts

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

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

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

package/dist/grpc.client.types.js

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

package/dist/index.d.ts

@@ -1,11 +1,14 @@
 /**
  * @hazeljs/grpc - gRPC module for HazelJS
  *
- * RPC server support with decorator-based handlers.
+ * RPC server and client support with decorator-based handlers.
  * Built on @grpc/grpc-js and @grpc/proto-loader.
  */
 export { GrpcModule } from './grpc.module';
 export { GrpcServer } from './grpc.server';
+export { GrpcClientModule } from './grpc.client.module';
+export { GrpcClientService } from './grpc.client';
 export { GrpcMethod, getGrpcMethodMetadata } from './decorators/grpc-method.decorator';
 export type { GrpcModuleOptions, GrpcModuleConfig, GrpcMethodMetadata, ProtoLoaderOptions, GrpcPackageDefinition, } from './grpc.types';
+export type { GrpcClientOptions, GrpcClientModuleConfig, GrpcClientDiscoveryConfig, GrpcDiscoveryClientLike, GrpcServiceInstanceLike, } from './grpc.client.types';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AACvF,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,GACtB,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AACvF,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,GACtB,MAAM,cAAc,CAAC;AACtB,YAAY,EACV,iBAAiB,EACjB,sBAAsB,EACtB,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -2,15 +2,19 @@
 /**
  * @hazeljs/grpc - gRPC module for HazelJS
  *
- * RPC server support with decorator-based handlers.
+ * RPC server and client support with decorator-based handlers.
  * Built on @grpc/grpc-js and @grpc/proto-loader.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGrpcMethodMetadata = exports.GrpcMethod = exports.GrpcServer = exports.GrpcModule = void 0;
+exports.getGrpcMethodMetadata = exports.GrpcMethod = exports.GrpcClientService = exports.GrpcClientModule = exports.GrpcServer = exports.GrpcModule = void 0;
 var grpc_module_1 = require("./grpc.module");
 Object.defineProperty(exports, "GrpcModule", { enumerable: true, get: function () { return grpc_module_1.GrpcModule; } });
 var grpc_server_1 = require("./grpc.server");
 Object.defineProperty(exports, "GrpcServer", { enumerable: true, get: function () { return grpc_server_1.GrpcServer; } });
+var grpc_client_module_1 = require("./grpc.client.module");
+Object.defineProperty(exports, "GrpcClientModule", { enumerable: true, get: function () { return grpc_client_module_1.GrpcClientModule; } });
+var grpc_client_1 = require("./grpc.client");
+Object.defineProperty(exports, "GrpcClientService", { enumerable: true, get: function () { return grpc_client_1.GrpcClientService; } });
 var grpc_method_decorator_1 = require("./decorators/grpc-method.decorator");
 Object.defineProperty(exports, "GrpcMethod", { enumerable: true, get: function () { return grpc_method_decorator_1.GrpcMethod; } });
 Object.defineProperty(exports, "getGrpcMethodMetadata", { enumerable: true, get: function () { return grpc_method_decorator_1.getGrpcMethodMetadata; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/grpc",
-  "version": "0.2.0-beta.34",
+  "version": "0.2.0-beta.35",
   "description": "gRPC module for HazelJS framework - RPC server and client support with decorators",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -52,5 +52,5 @@
     "url": "https://github.com/hazeljs/hazel-js/issues"
   },
   "homepage": "https://hazeljs.com",
-  "gitHead": "56191ccdd4a307986c03b3c8bf9f9fc3d5e6548d"
+  "gitHead": "e8b3e24b025b079b0d7ec4046bd083c151676215"
 }