@atls/nestjs-grpc-http-proxy 0.0.15 → 0.0.17

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+
+
+## [0.0.17](https://github.com/atls/nestjs/compare/@atls/nestjs-grpc-http-proxy@0.0.16...@atls/nestjs-grpc-http-proxy@0.0.17) (2026-01-08)
+
+
+
+
+
+
+## 0.0.15 (2025-12-31)
+
+
+### Bug Fixes
+
+
+* **packages:** linter errors ([204ce22](https://github.com/atls/nestjs/commit/204ce229e375b09ffd69d93e47c08bd1d1fbea1b))
+* **packages:** linter errors ([d41854b](https://github.com/atls/nestjs/commit/d41854b94d5502ebf2b9e18d22cac33f98c8fc41))
+* **packages:** tests ([ae0f308](https://github.com/atls/nestjs/commit/ae0f308e695cfe39b4e2d38b6a33be4f7e5a8821))
+
+### Features
+
+
+* **batch-queue:** init ([6ecbffa](https://github.com/atls/nestjs/commit/6ecbffa3fc54f9bb33ac1ae57b274772b99c8e9d))
+* **common:** bump yarn, trigger release ([#338](https://github.com/atls/nestjs/issues/338)) ([9837d48](https://github.com/atls/nestjs/commit/9837d482f75928a3ac132d0306ab6de04d8a04b9))
+
+

package/dist/authenticators/authentication.service.d.ts

@@ -1,6 +1,6 @@
 import type { Request } from 'express';
 import type { Response } from 'express';
-import { GrpcHttpProxyModuleOptions } from '../module/index.js';
+import type { GrpcHttpProxyModuleOptions } from '../module/index.js';
 export declare class AuthenticationService {
     private readonly options;
     constructor(options: GrpcHttpProxyModuleOptions);

package/dist/authenticators/private-key.authenticator.js

@@ -1,7 +1,7 @@
-import { promises as fs } from 'fs';
-import { sign } from 'jsonwebtoken';
+import { promises as fs } from 'node:fs';
 import { v4 as uuid } from 'uuid';
 import cookie from 'cookie';
+import jwt from 'jsonwebtoken';
 export class PrivateKeyAuthenticator {
     privateKey;
     constructor(privateKey) {
@@ -22,7 +22,7 @@ export class PrivateKeyAuthenticator {
                 }));
             }
             const privateKey = await fs.readFile(this.privateKey, 'utf-8');
-            const token = sign({ sub: subject }, privateKey, { algorithm: 'RS256' });
+            const token = jwt.sign({ sub: subject }, privateKey, { algorithm: 'RS256' });
             return `Bearer ${token}`;
         }
         return null;

package/dist/controllers/grpc-http-proxy.controller.d.ts

@@ -1,10 +1,10 @@
-import { Request } from 'express';
-import { Response } from 'express';
+import type { Request } from 'express';
+import type { Response } from 'express';
 import { AuthenticationService } from '../authenticators/index.js';
 import { ProtoRegistry } from '../proto/index.js';
 export declare class GrpcHttpProxyController {
     private readonly protoRegistry;
     private readonly authenticator;
     constructor(protoRegistry: ProtoRegistry, authenticator: AuthenticationService);
-    call(service: any, method: any, body: any, req: Request, res: Response): Promise<void>;
+    call(service: string, method: string, body: unknown, req: Request, res: Response): Promise<void>;
 }

package/dist/controllers/grpc-http-proxy.controller.js

@@ -50,7 +50,7 @@ __decorate([
     __param(3, Req()),
     __param(4, Res()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object, Object, Object]),
+    __metadata("design:paramtypes", [String, String, Object, Object, Object]),
     __metadata("design:returntype", Promise)
 ], GrpcHttpProxyController.prototype, "call", null);
 GrpcHttpProxyController = __decorate([

package/dist/module/grpc-http-proxy-module-options.interface.d.ts

@@ -1,4 +1,6 @@
+import type { InjectionToken } from '@nestjs/common/interfaces';
 import type { ModuleMetadata } from '@nestjs/common/interfaces';
+import type { OptionalFactoryDependency } from '@nestjs/common/interfaces';
 import type { Type } from '@nestjs/common/interfaces';
 import type { GrpcOptions } from '@nestjs/microservices';
 import type { Authenticator } from '../authenticators/index.js';
@@ -12,6 +14,6 @@ export interface GrpcHttpProxyOptionsFactory {
 export interface GrpcHttpProxyModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
     useExisting?: Type<GrpcHttpProxyOptionsFactory>;
     useClass?: Type<GrpcHttpProxyOptionsFactory>;
-    useFactory?: (...args: Array<any>) => GrpcHttpProxyModuleOptions | Promise<GrpcHttpProxyModuleOptions>;
-    inject?: Array<any>;
+    useFactory?: (...args: Array<unknown>) => GrpcHttpProxyModuleOptions | Promise<GrpcHttpProxyModuleOptions>;
+    inject?: Array<InjectionToken | OptionalFactoryDependency>;
 }

package/dist/module/grpc-http-proxy.module.js

@@ -38,6 +38,9 @@ let GrpcHttpProxyModule = GrpcHttpProxyModule_1 = class GrpcHttpProxyModule {
         if (options.useExisting || options.useFactory) {
             return [this.createAsyncOptionsProvider(options)];
         }
+        if (!options.useClass) {
+            throw new Error('GrpcHttpProxyModule requires useClass when useExisting/useFactory not provided');
+        }
         return [
             this.createAsyncOptionsProvider(options),
             {
@@ -54,10 +57,14 @@ let GrpcHttpProxyModule = GrpcHttpProxyModule_1 = class GrpcHttpProxyModule {
                 inject: options.inject || [],
             };
         }
+        const injectTarget = options.useExisting ?? options.useClass;
+        if (!injectTarget) {
+            throw new Error('GrpcHttpProxyModule requires useExisting, useClass, or useFactory');
+        }
         return {
             provide: GRPC_HTTP_PROXY_MODULE_OPTIONS,
             useFactory: async (optionsFactory) => optionsFactory.createGrpcHttpProxyOptions(),
-            inject: [options.useExisting || options.useClass],
+            inject: [injectTarget],
         };
     }
 };

package/dist/proto/proto.client.d.ts

@@ -1,7 +1,10 @@
+import type { ChannelCredentials } from '@grpc/grpc-js';
 import type { Client } from '@grpc/grpc-js';
+type ServiceClientConstructor = new (address: string, creds: ChannelCredentials, options: Record<string, unknown>) => Client;
 export declare class ProtoClient {
     private readonly client;
     constructor(client: Client);
-    static create(url: string | undefined, ServiceClient: any): ProtoClient;
-    call(method: string, request: any, meta?: {}): Promise<unknown>;
+    static create(ServiceClient: ServiceClientConstructor, url?: string): ProtoClient;
+    call(method: string, request: unknown, meta?: Record<string, Buffer | string | null>): Promise<unknown>;
 }
+export {};

package/dist/proto/proto.client.js

@@ -1,22 +1,33 @@
 import { Metadata } from '@grpc/grpc-js';
 import { credentials } from '@grpc/grpc-js';
+const getClientMethod = (client, method) => {
+    const candidate = client[method];
+    if (typeof candidate !== 'function') {
+        throw new Error(`Unknown gRPC method: ${method}`);
+    }
+    return candidate;
+};
 export class ProtoClient {
     client;
     constructor(client) {
         this.client = client;
     }
-    static create(url = '0.0.0.0:50051', ServiceClient) {
+    static create(ServiceClient, url = '0.0.0.0:50051') {
         return new ProtoClient(new ServiceClient(url, credentials.createInsecure(), {}));
     }
     async call(method, request, meta = {}) {
         const metadata = new Metadata();
         Object.keys(meta).forEach((key) => {
-            if (meta[key])
-                metadata.add(key, meta[key]);
+            const value = meta[key];
+            if (typeof value === 'string' || value instanceof Buffer) {
+                metadata.add(key, value);
+            }
         });
         return new Promise((resolve, reject) => {
-            if (this.client[method].requestStream) {
-                const call = this.client[method](metadata);
+            const methodImpl = getClientMethod(this.client, method);
+            const hasRequestStream = 'requestStream' in methodImpl && Boolean(methodImpl.requestStream);
+            if (hasRequestStream) {
+                const call = methodImpl.call(this.client, metadata);
                 call.write(request);
                 let response;
                 call.on('data', (data) => {
@@ -28,7 +39,8 @@ export class ProtoClient {
                 });
             }
             else {
-                this.client[method](request, metadata, (error, response) => {
+                ;
+                methodImpl.call(this.client, request, metadata, (error, response) => {
                     if (error) {
                         reject(error);
                     }

package/dist/proto/proto.registry.d.ts

@@ -1,5 +1,5 @@
 import type { OnApplicationBootstrap } from '@nestjs/common';
-import { GrpcHttpProxyModuleOptions } from '../module/index.js';
+import type { GrpcHttpProxyModuleOptions } from '../module/index.js';
 import { ProtoClient } from './proto.client.js';
 export declare class ProtoRegistry implements OnApplicationBootstrap {
     private readonly options;

package/dist/proto/proto.registry.js

@@ -24,9 +24,11 @@ let ProtoRegistry = class ProtoRegistry {
         this.options = options;
     }
     async onApplicationBootstrap() {
-        const protoPaths = Array.isArray(this.options.options.protoPath)
-            ? this.options.options.protoPath
-            : [this.options.options.protoPath];
+        const protoPathOption = this.options.options.protoPath;
+        if (!protoPathOption) {
+            throw new Error('GrpcHttpProxyModule requires protoPath');
+        }
+        const protoPaths = Array.isArray(protoPathOption) ? protoPathOption : [protoPathOption];
         this.definitions = await Promise.all(protoPaths.map(async (protoPath) => {
             const packageDefinition = await load(protoPath, this.options.options.loader);
             return loadPackageDefinition(packageDefinition);
@@ -42,7 +44,7 @@ let ProtoRegistry = class ProtoRegistry {
         if (!client) {
             throw new Error('GRPC service not found');
         }
-        return ProtoClient.create(this.options.options.url, client);
+        return ProtoClient.create(client, this.options.options.url);
     }
 };
 ProtoRegistry = __decorate([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atls/nestjs-grpc-http-proxy",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "license": "BSD-3-Clause",
   "type": "module",
   "exports": {