rxjs-grpc-minimal 0.2.5 → 0.2.8

package/.eslintrc.js

@@ -1,24 +1,35 @@
 module.exports = {
   env: {
     node: true,
-    commonjs: true,
-    es6: true
+    es2022: true
+  },
+  extends: ['standard'],
+  parserOptions: {
+    ecmaVersion: 'latest'
   },
-  extends: 'standard',
   rules: {
-    'no-var': 'error',
-    'space-before-function-paren': 0,
-    'prefer-const': 'error',
-    semi: ['error', 'always']
+    semi: ['error', 'always'],
+    'space-before-function-paren': ['error', {
+      anonymous: 'always',
+      named: 'never',
+      asyncArrow: 'always'
+    }],
+    'no-unused-vars': ['error', { argsIgnorePattern: '^_' }]
   },
-  overrides: {
-    files: ['tests/**/*spec.js'],
-    env: {
-      mocha: true,
-    },
-    rules: {
-      'handle-callback-err': 0,
-      'no-unused-expressions': 0
+  overrides: [
+    {
+      files: ['tests/**/*.js'],
+      globals: {
+        describe: 'readonly',
+        it: 'readonly',
+        expect: 'readonly',
+        beforeEach: 'readonly',
+        afterEach: 'readonly',
+        beforeAll: 'readonly',
+        afterAll: 'readonly',
+        vi: 'readonly'
+      }
     }
-  }
+  ],
+  ignorePatterns: ['node_modules/', 'coverage/']
 };

package/README.md

@@ -1,201 +1,247 @@
-[![Build Status](https://travis-ci.org/nmccready/rxjs-grpc-minimal.svg?branch=master)](https://travis-ci.org/nmccready/rxjs-grpc-minimal)
+[![tests](https://github.com/brickhouse-tech/rxjs-grpc-minimal/actions/workflows/tests.yml/badge.svg)](https://github.com/brickhouse-tech/rxjs-grpc-minimal/actions/workflows/tests.yml)
 [![npm version](https://badge.fury.io/js/rxjs-grpc-minimal.svg)](https://badge.fury.io/js/rxjs-grpc-minimal)
 
 # rxjs-grpc-minimal
 
-Based off the great work of [rxjs-grpc](https://github.com/kondi/rxjs-grpc). However, this library intends to
-very little except to offer you to wrap your server or client GRPC implementation the way you want it.
+Based off the great work of [rxjs-grpc](https://github.com/kondi/rxjs-grpc). This library wraps gRPC server and client implementations with RxJS Observables, giving you a reactive interface without imposing opinions on your setup.
 
-There is no cli as this library is trying to stay out of the way and allow grpc, or protobufjs do the amazing things they already do.
+There is no CLI—this library stays out of the way and lets `@grpc/grpc-js` and `@grpc/proto-loader` do what they do best.
+
+## Requirements
+
+- Node.js >= 18
+- RxJS 7.x
+- @grpc/grpc-js (replaces deprecated `grpc` package)
 
 ## Install
 
 ```bash
-> yarn add rxjs-grpc-minimal
+npm install rxjs-grpc-minimal
+# or
+yarn add rxjs-grpc-minimal
+```
+
+You'll also need gRPC dependencies:
+
+```bash
+npm install @grpc/grpc-js @grpc/proto-loader
 ```
 
 ## Usage
 
-### Client
+### Loading Proto Files
+
+Use `@grpc/proto-loader` with `@grpc/grpc-js` (the modern approach):
 
 ```js
-const path = require('path');
-const { loadSync } = require('protobufjs');
-const { loadObject: toGrpc, credentials } = require('grpc');
-const { Subject, ReplaySubject } = require('rxjs');
-
-const {
-  toRxClient, // used most often
-  toRxServer, // used most often
-  utils,
-  errors
-} = require('rxjs-grpc-minimal');
-
-const pbAPI = loadSync(
-    path.join(__dirname,'../examples/helloworld/helloworld.proto'))
-  .lookup('helloworld');
-
-/*
-Wraps all service.prototype methods with RXJS implementations.
-Each method is appended to the prototype as `method${RX}` by default.
-Thus allowing you access to both RX and nonRx grpc implementations.
-*/
-const grpcAPI = toRxClient(toGrpc(pbAPI));
-/*
-Wraps all service.prototype methods with RXJS implementations. However,
-this overrides / overwrites all original prototype methods with the RX impl.
-*/
-const grpcApiOverride = toRxClient(toGrpc(pbAPI), '');
-
-const greeter = new grpcAPI.Greeter('localhost:56001', credentials.createInsecure());
-
-// non stream
-conn.sayHelloRx({ name: 'Bob' });
-.forEach(resp => {
-    console.log(grpcAPI.cancelCache.size) // 0
-    console.log(resp); // { message: 'Hello Bob' } // depends on server
-  })
-
-let calls = 0;
-
-// STREAMING REPLY FROM SERVER
-conn.sayMultiHelloRx({
-  name: 'Brody',
-  numGreetings: 2,
-  doComplete: true
-})
-.forEach(resp => {
-  calls++;
-  console.log({ size: grpcAPI.cancelCache.size})
-  console.log(resp)
-})
-.then(() => {
-  console.log({ size: grpcAPI.cancelCache.size})
-  console.log({ calls })
+import grpc from '@grpc/grpc-js';
+import protoLoader from '@grpc/proto-loader';
+import { toRxClient } from 'rxjs-grpc-minimal';
+
+// Load proto file
+const packageDefinition = protoLoader.loadSync('./helloworld.proto', {
+  keepCase: false,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true
 });
 
-calls = 0;
-
-/* console out
-
-{ size: 1 }
-{ message: 'Hello Brody' }
-{ size: 1 }
-{ message: 'Hello Brody' }
-{ size: 0 }
-{ calls: 2 }
-*/
-
-// streaming reply from server
-const multiHelloStream = conn.sayMultiHelloRx({
-  name: 'Brody',
-  numGreetings: 2,
-  doComplete: true
-})
-.forEach(resp => {
-  calls++;
-  console.log({ size: grpcAPI.cancelCache.size})
-  console.log(resp)
-  // imagine you need to cancel this stream in between and abort early
-  multiHelloStream.grpcCancel();
-})
-.then(() => {
-  console.log({ size: grpcAPI.cancelCache.size})
-  console.log({ calls })
+const grpcAPI = grpc.loadPackageDefinition(packageDefinition);
+const helloworldAPI = toRxClient(grpcAPI.helloworld);
+```
+
+### Client
+
+```js
+import grpc from '@grpc/grpc-js';
+import protoLoader from '@grpc/proto-loader';
+import { toRxClient } from 'rxjs-grpc-minimal';
+
+// Load and wrap the API
+const packageDefinition = protoLoader.loadSync('./helloworld.proto', {
+  keepCase: false,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true
+});
+const grpcAPI = toRxClient(
+  grpc.loadPackageDefinition(packageDefinition).helloworld
+);
+
+// Create client connection
+const greeter = new grpcAPI.Greeter(
+  'localhost:50051',
+  grpc.credentials.createInsecure()
+);
+
+// Unary call - returns Observable
+await greeter.sayHelloRx({ name: 'Bob' }).forEach(resp => {
+  console.log(resp); // { message: 'Hello Bob!' }
 });
-calls = 0;
-/* console out
 
-{ size: 1 }
-{ message: 'Hello Brody' }
-{ size: 0 }
-{ calls: 1 }
-*/
+// Server streaming - Observable emits each response
+await greeter
+  .sayMultiHelloRx({ name: 'World', numGreetings: 3 })
+  .forEach(resp => {
+    console.log(resp.message);
+  });
+
+// Client streaming - pass a Subject/Observable as the request
+import { Subject } from 'rxjs';
 
-// STREAMING REQUEST | client streaming to server
 const writer = new Subject();
-const observable = conn.streamSayHelloRx(writer);
-
-observable
-.forEach(resp => {
-  calls++;
-  console.log(resp);
-  console.log({ calls });
-})
-.then(() => {
-  writer.unsubscribe();
+const response$ = greeter.streamSayHelloRx(writer);
+
+response$.forEach(resp => {
+  console.log(resp.message);
 });
 
-console(grpcAPI.cancelCache.size) // 1
-// ok we're now subscribed
-writer.next({ name:  'Al' });
-writer.next({ name: 'Bundy' });
-writer.complete();
-
-console.log(grpcAPI.cancelCache.size) // 0
-
-/* console out
-
-1
-{ message: 'Hello Al' }
-{ calls: 1 }
-{ message: 'Hello Bundy' }
-{ calls: 2 }
-0
-*/
-
-// CONNECTION CLEANUP
-/*
-Imagine we abort in between or crash but catch the problem.
-prior to conn.close we could clean up all.
-
-This guarantees that the observer on the sever side is cleaned up and released.
-This also allows you to truly close your connection without dangling a channel/subchannel.
-*/
-grpcAPI.cancelCache.forEach((cancel) => cancel());
-conn.close();
+// Send messages
+writer.next({ name: 'Alice' });
+writer.next({ name: 'Bob' });
+writer.complete(); // Signal end of stream
+```
+
+### Cancellation
+
+RxJS methods return Observables with a `grpcCancel()` function for early termination:
+
+```js
+const stream$ = greeter.sayMultiHelloRx({ name: 'World', numGreetings: 100 });
+
+stream$.forEach(resp => {
+  console.log(resp.message);
+  if (someCondition) {
+    stream$.grpcCancel(); // Cancel the underlying gRPC call
+  }
+});
+
+// Clean up all pending calls before closing connection
+grpcAPI.cancelCache.forEach(cancel => cancel());
+greeter.close();
 ```
 
 ### Server
 
-See [serverRx.js](./examples/helloworld/impls/serverRx.js)
+```js
+import { of, Observable } from 'rxjs';
+import grpc from '@grpc/grpc-js';
+import protoLoader from '@grpc/proto-loader';
+import { toRxServer } from 'rxjs-grpc-minimal';
+
+// Load proto
+const packageDefinition = protoLoader.loadSync('./helloworld.proto', {
+  keepCase: false,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true
+});
+const proto = grpc.loadPackageDefinition(packageDefinition).helloworld;
+
+// Define RxJS implementation
+const rxImpl = {
+  // Unary: return an Observable
+  sayHello({ value: { name } }) {
+    return of({ message: `Hello ${name}!` });
+  },
+
+  // Server streaming: return Observable that emits multiple values
+  sayMultiHello({ value: { name, numGreetings } }) {
+    return new Observable(observer => {
+      for (let i = 0; i < numGreetings; i++) {
+        observer.next({ message: `Hello ${name}!` });
+      }
+      observer.complete();
+    });
+  },
+
+  // Client streaming: receive Observable, return Observable
+  streamSayHello(requestStream$) {
+    return new Observable(observer => {
+      requestStream$.forEach(val => {
+        observer.next({ message: `Hello ${val.name}!` });
+      }).then(
+        () => observer.complete(),
+        err => observer.error(err)
+      );
+    });
+  }
+};
+
+// Create and start server
+const server = new grpc.Server();
+server.addService(proto.Greeter.service, toRxServer(proto.Greeter, rxImpl, 'Greeter'));
+server.bindAsync('0.0.0.0:50051', grpc.ServerCredentials.createInsecure(), () => {
+  console.log('Server running on port 50051');
+});
+```
+
+See [examples/helloworld/impls/serverRx.js](./examples/helloworld/impls/serverRx.js) for a complete example.
 
 ## API
 
-### toRxClient(grpcObject, methodExt)
+### `toRxClient(grpcObject, methodExt = 'Rx')`
+
+Wraps all service prototype methods with RxJS implementations.
+
+- **grpcObject** - Object created by `grpc.loadPackageDefinition()`
+- **methodExt** - String appended to method names (default: `'Rx'`)
 
-- #### grpcObject
+```js
+const api = toRxClient(grpcAPI);
+greeter.sayHelloRx();    // RxJS Observable
+greeter.sayHello();      // Original callback-based method
+
+// Override original methods instead of extending:
+const api = toRxClient(grpcAPI, '');
+greeter.sayHello();      // Now returns Observable
+```
+
+Returns the modified `grpcObject` with a `cancelCache` Set for tracking active calls.
+
+### `toRxServer(service, rxImpl, serviceName?)`
 
-  Type: `Object` - initially created by `grpc.loadObject` w or w/o protobufjs `load`|`loadSync`
+Wraps RxJS server handlers to work with gRPC.
 
-- #### methodExt
+- **service** - gRPC service definition (e.g., `proto.Greeter`)
+- **rxImpl** - Object with method handlers returning Observables
+- **serviceName** - Optional string for debug logging
 
-  Type: `String` - defaults to `'Rx'`
+## Development
 
-  This is the method naming extension where the original method name is appended
-  with `something{RX}`.
+```bash
+# Install dependencies
+npm install
 
-  ```js
-  greeter.sayMultiHelloRx // RX function
-  greeter.sayMultiHello // node stream function, and other functions could be callback, callback and steams
+# Run tests
+npm test
 
-  toRxClient(grpcAPI, '');
-  // ...
-  greeter.sayMultiHello // RX function all node stream, callback etc hidden / wrapped
-  // NOTE: all RX functions will always return observables (consistent!) .
-  ```
+# Run tests in watch mode
+npm run test:watch
 
-### toRxServer(service, rxImpl, serviceName)
+# Run tests with coverage
+npm run test:coverage
 
-- #### service
+# Lint code
+npm run lint
 
-  Type: `Object` - GrpcService definition `grpcAPI[serviceName]`
+# Fix lint issues
+npm run lint:fix
+```
 
-- #### rxImpl
+### Running Examples
 
-  Type: `Object` - Your RxJS server implementation which matches the service method handles
-  to be implemented.
+```bash
+# Terminal 1: Start server
+npm run server
+
+# Terminal 2: Run client
+npm run client
+```
 
-- #### serviceName (optional)
+## License
 
-  Type: `String` - aids in [debug](./debug.js) via [debug-fabulous](https://github.com/nmccready/debug-fabulous) logging.
+MIT

package/commitlint.config.js

@@ -0,0 +1 @@
+module.exports = { extends: ['@commitlint/config-conventional'] };

package/package.json

@@ -1,8 +1,8 @@
 {
-  "main": "src/index",
   "name": "rxjs-grpc-minimal",
-  "version": "0.2.5",
+  "version": "0.2.8",
   "description": "grpc node callback and streams wrapped in observables",
+  "main": "src/index.js",
   "license": "MIT",
   "keywords": [
     "rxjs",
@@ -14,42 +14,43 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/nmccready/rxjs-grpc-minimal.git"
+    "url": "https://github.com/brickhouse-tech/rxjs-grpc-minimal.git"
   },
   "files": [
     "src",
     "*.js"
   ],
   "scripts": {
-    "lint": "eslint **/*.js",
-    "test": "yarn lint && mocha --exclude node_modules ./**/*.js",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "server": "node ./examples/helloworld/server.js",
     "client": "node ./examples/helloworld/client.js",
     "client2": "node ./examples/helloworld/client2.js"
   },
   "dependencies": {
-    "debug-fabulous": "^1.1.0",
-    "rxjs": "^5.2.0",
-    "through2": "^2.0.3"
+    "debug-fabulous": "^2.0.1",
+    "rxjs": "^7.8.1",
+    "through2": "^4.0.2"
   },
   "devDependencies": {
-    "JSONStream": "^1.3.2",
-    "chai": "^4.1.2",
-    "eslint": "^4",
-    "eslint-config-standard": "^11.0.0",
-    "eslint-plugin-import": "^2.11.0",
-    "eslint-plugin-node": "^6.0.1",
-    "eslint-plugin-promise": "^3.7.0",
-    "eslint-plugin-standard": "^3.0.1",
-    "grpc": "^1.13",
-    "lodash": "^4.17.13",
-    "mocha": "^5.1.1",
-    "prettier": "^1",
-    "prettier-eslint": "^8",
-    "protobufjs": "^6",
-    "sinon": "^7.2.0"
+    "@commitlint/cli": "^20.4.1",
+    "@commitlint/config-conventional": "^20.4.1",
+    "@grpc/grpc-js": "^1.12.5",
+    "@grpc/proto-loader": "^0.7.13",
+    "@vitest/coverage-v8": "^2.1.8",
+    "commit-and-tag-version": "^12.6.1",
+    "eslint": "^8.57.1",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-promise": "^6.6.0",
+    "lodash": "^4.17.21",
+    "vitest": "^2.1.8"
   },
   "engines": {
-    "node": ">=8"
+    "node": ">=18"
   }
 }

package/src/client.js

@@ -1,12 +1,9 @@
 const { Observable } = require('rxjs');
 const though2 = require('through2');
-const EventEmitter = require('events');
-const { noop } = require('lodash');
 
 const { getServiceNames } = require('../src/utils');
 
 const debug = require('../debug').spawn('client');
-
 /**
  * @param  {Object} grpcApi - pre-loaded grpcApi
  * @param  {String} methExt - your choice to extend or override the methodNames
@@ -78,9 +75,6 @@ function createMethod(clientMethod, dbg, cancelCache) {
       }
 
       if (clientMethod.responseStream) {
-        const domain = createDomain();
-        call.domain = domain;
-
         const d = dbg.spawn('responseStream');
         const onData = (data, _, cb) => {
           d(() => ({ data }));
@@ -98,17 +92,23 @@ function createMethod(clientMethod, dbg, cancelCache) {
           call.removeListener('error', onError);
         };
 
-        call.pipe(though2.obj(onData, onEnd));
-        call.on('error', onError);
-        domain.once('error', onError);
-
         const originalUnsub = observer.unsubscribe;
-        observer.unsubscribe = function(...args) {
-          grpcCancel();
+        observer.unsubscribe = function (...args) {
+          // Remove observable errror listener
           call.removeListener('error', onError);
-          originalUnsub.apply(observer, args);
+          // Add silent error handler. Avoids errors if stream responses have already come in
+          // and we are delaying observable response, like when using delay()
+          call.on('error', () => {});
+          // Like end, but does not throw error
+          // @see https://nodejs.org/api/stream.html#stream_readable_streams
+          // note GRPC stream extends readable_stream
           call.destroy();
+          originalUnsub.call(observer, ...args);
+          grpcCancel(false);
         };
+
+        call.pipe(though2.obj(onData, onEnd));
+        call.on('error', onError);
       }
 
       let requestStreamCompleted = false;
@@ -148,10 +148,10 @@ function createMethod(clientMethod, dbg, cancelCache) {
         cb ? cb() : observer.complete();
       }
 
-      function grpcCancel(doCancel = true) {
+      function grpcCancel() {
         dbg(() => 'canceled');
         cancelCache.delete(grpcCancel);
-        if (doCancel) call.cancel();
+        call.cancel();
       }
       if (
         call.cancel &&
@@ -169,20 +169,6 @@ function createMethod(clientMethod, dbg, cancelCache) {
   return rxWrapper;
 }
 
-/*
-  node domain require('domain') is deprecated
-  mock one
-
-  Domain is to trap unhandled connection resets etc.. and pass them on
-  to some observer / observable.
-*/
-const createDomain = () => {
-  const domain = new EventEmitter();
-  domain.enter = noop;
-  domain.exit = noop;
-  return domain;
-};
-
 module.exports = {
   create,
   createMethod

package/src/server.js

@@ -1,4 +1,4 @@
-const { Observable } = require('rxjs');
+const { of, Observable } = require('rxjs');
 const through2 = require('through2');
 
 const debug = require('../debug').spawn('server');
@@ -23,10 +23,12 @@ function create(Service, rxImpl, serviceName) {
 
 function createMethod(rxImpl, name, methods, dbg) {
   const serviceMethod = methods[name];
-  return async function(call, callback) {
+  return async function (call, callback) {
     dbg(() => 'called');
     // SET SYNC REQUEST OBSERVER
-    let observable = Observable.of(call.request);
+    // Create an observable that also has .value for backward compat
+    let observable = of(call.request);
+    observable.value = call.request;
 
     if (serviceMethod.requestStream) {
       observable = createRequestStream({ call, name, dbg });
@@ -59,7 +61,10 @@ function createRequestStream({ call, name, dbg }) {
     call.on('error', onError);
 
     function onError(err) {
-      observer.error(err);
+      // Skip if observer is already closed (e.g., during server shutdown)
+      if (!observer.closed) {
+        observer.error(err);
+      }
     }
 
     function onData(data, _, cb) {
@@ -68,8 +73,17 @@ function createRequestStream({ call, name, dbg }) {
     }
 
     function onEnd(cb) {
+      // Capture cancelled state NOW, before setImmediate
+      // (forceShutdown() may set call.cancelled between now and the callback)
+      const wasCancelled = call.cancelled;
+
       setImmediate(() => {
-        if (call.cancelled) {
+        // Skip if observer is already closed (e.g., during server shutdown)
+        // to avoid unhandled rejection errors
+        if (observer.closed) {
+          return;
+        }
+        if (wasCancelled) {
           /*
           TODO: DEBATING ON WHETHER THIS SHOULD BE AN ERROR OBJECT
           We're using error event here to signal cancellation.

package/src/utils/index.js

@@ -2,8 +2,10 @@ function getServiceNames(grpcApi) {
   const keys = Object.keys(grpcApi);
   const serviceNames = keys.filter(name => {
     try {
-      return grpcApi[name].service;
-    } catch (e) {}
+      return Boolean(grpcApi[name].service);
+    } catch (_e) {
+      return false;
+    }
   });
 
   return serviceNames;

package/src/utils/testHelpers/server.js

@@ -1,16 +1,28 @@
-const { Server, ServerCredentials } = require('grpc');
+const grpc = require('@grpc/grpc-js');
+const { Server, ServerCredentials } = grpc;
 
 const initServer = initService => ({ uri, grpcAPI, serviceName }) => {
   const server = new Server();
   const GrpcService = grpcAPI[serviceName];
 
-  server.bind(uri, ServerCredentials.createInsecure());
   server.addService(GrpcService.service, initService());
-  server.start();
+
+  // Create a promise that resolves when the server is ready
+  const ready = new Promise((resolve, reject) => {
+    server.bindAsync(uri, ServerCredentials.createInsecure(), (err, _port) => {
+      if (err) {
+        console.error('Failed to bind server:', err);
+        reject(err);
+        return;
+      }
+      resolve();
+    });
+  });
 
   return {
     server,
-    GrpcService
+    GrpcService,
+    ready
   };
 };
 

package/src/utils/testHelpers/serverRx.js

@@ -1,4 +1,5 @@
-const { Server, ServerCredentials } = require('grpc');
+const grpc = require('@grpc/grpc-js');
+const { Server, ServerCredentials } = grpc;
 const { toRxServer } = require('../../..');
 
 const initServer = initService => ({ uri, grpcAPI, serviceName }) => {
@@ -6,17 +7,28 @@ const initServer = initService => ({ uri, grpcAPI, serviceName }) => {
   const GrpcService = grpcAPI[serviceName];
   const impl = initService();
 
-  server.bind(uri, ServerCredentials.createInsecure());
   server.addService(
     GrpcService.service,
     toRxServer(GrpcService, impl, serviceName)
   );
-  server.start();
+
+  // Create a promise that resolves when the server is ready
+  const ready = new Promise((resolve, reject) => {
+    server.bindAsync(uri, ServerCredentials.createInsecure(), (err, _port) => {
+      if (err) {
+        console.error('Failed to bind server:', err);
+        reject(err);
+        return;
+      }
+      resolve();
+    });
+  });
 
   return {
     server,
     GrpcService,
-    impl
+    impl,
+    ready
   };
 };
 

package/vitest.config.js

@@ -0,0 +1,26 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    testTimeout: 30000,
+    hookTimeout: 30000,
+    sequence: {
+      concurrent: false
+    },
+    fileParallelism: false,
+    include: ['tests/**/*.spec.js'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'html', 'lcov'],
+      include: ['src/**/*.js'],
+      exclude: ['src/utils/testHelpers/**'],
+      thresholds: {
+        statements: 80,
+        branches: 70,
+        functions: 80,
+        lines: 80
+      }
+    }
+  }
+});