Registry / observability / nice-grpc-client-middleware-devtools

nice-grpc-client-middleware-devtools

JSON →
library1.0.10jsnpmunverified

This package provides a client-side middleware for `nice-grpc` and `nice-grpc-web` that integrates with the `grpc-web-devtools` browser extension. Its primary function is to log gRPC-Web requests and responses, making them visible and inspectable within the browser's developer tools. This is crucial for debugging frontend applications that communicate with gRPC backends via gRPC-Web, a common pain point due to gRPC-Web's protocol translation layer. Currently at version 1.0.10, the package generally follows the active development and release cadence of its parent `nice-grpc` project, which sees frequent updates. It offers a straightforward way to gain visibility into gRPC-Web traffic, differentiating itself by specifically targeting the popular `grpc-web-devtools` extension for an enhanced developer experience.

npm install nice-grpc-client-middleware-devtools
INSTALL
IMPORT
SIG · NICE-GRPC-CLIENT-M
N
nice-grpc-client-middleware-devtools
observabilityjavascriptv1.0.10
Install
Import
Disk
Pass rate
0/ 6
Env Coverage0 / 6
glibc
1822
musl
1822
Install & Compatibility
Where this runs
tested against v? · npm install
Install × environment matrix
Each cell = how many times install + import succeeded across repeated harness runs. Partial = flaky.
glibc = Debian/Ubuntu slim · musl = Alpine Linux
musl
node 18226 runs
build_error
glibc
node 18226 runs
build_error
Code
Verified usage

Verified import paths — ran on the pinned version, not inferred.

devtoolsClientMiddleware
import { devtoolsClientMiddleware } from 'nice-grpc-client-middleware-devtools';
const { devtoolsClientMiddleware } = require('nice-grpc-client-middleware-devtools');
The `nice-grpc` ecosystem is primarily ESM-first and TypeScript-centric. While CommonJS might technically work with transpilation, direct `require` is not the idiomatic approach.
devtoolsUnaryLoggingMiddleware
import { devtoolsUnaryLoggingMiddleware } from 'nice-grpc-client-middleware-devtools';
Use this specific middleware if you only want to log unary (request-response) gRPC calls to devtools, excluding streaming calls.
devtoolsStreamLoggingMiddleware
import { devtoolsStreamLoggingMiddleware } from 'nice-grpc-client-middleware-devtools';
Use this specific middleware if you only want to log streaming gRPC calls to devtools, excluding unary calls.

This quickstart demonstrates how to integrate `devtoolsClientMiddleware` into a `nice-grpc-web` client, enabling automatic logging of gRPC-Web requests and responses to the `grpc-web-devtools` browser extension for debugging.

import { createClientFactory, createChannel, ClientError, Status } from 'nice-grpc-web'; import { devtoolsClientMiddleware } from 'nice-grpc-client-middleware-devtools'; import { type ExampleServiceDefinition, ExampleServiceDefinition } from './compiled_proto/example'; // Imagine your compiled Protobuf types look like this (e.g., from ts-proto) interface ExampleServiceDefinition { readonly methodName: string; readonly requestType: any; readonly responseType: any; // ... other protobuf definitions } // 1. Define your gRPC service (usually compiled from .proto) // ExampleServiceDefinition would come from your proto compilation output // 2. Create a gRPC-Web channel pointing to your proxy/server const channel = createChannel('http://localhost:8080'); // 3. Create a client factory and apply the devtools middleware const clientFactory = createClientFactory() .use(devtoolsClientMiddleware); // 4. Create your gRPC client instance const client = clientFactory.create( ExampleServiceDefinition, channel, ); // 5. Make a gRPC call (this will now be logged in grpc-web-devtools) async function callService() { try { console.log('Making a gRPC call...'); const response = await client.exampleMethod({ name: 'World' }, { metadata: { 'x-request-id': '123' }, // Additional call options can be passed here }); console.log('gRPC response:', response); } catch (error: unknown) { if (error instanceof ClientError) { console.error(`gRPC Error: ${error.code} - ${error.details}`); } else { console.error('Unknown error:', error); } } } callService(); // A minimal example for ExampleServiceDefinition if not using ts-proto directly: export const ExampleServiceDefinition = { methodName: 'ExampleService', requestType: {}, // Define your request type structure responseType: {}, // Define your response type structure // Typically, this comes from compiled .proto files methods: { exampleMethod: {}, } } as unknown as ExampleServiceDefinition;
Debug
Known issues
gotchaThis middleware is designed to work with the `grpc-web-devtools` browser extension. Requests will not appear in browser DevTools unless the extension is installed and active.
fix
Ensure the `grpc-web-devtools` Chrome/Edge extension (or equivalent) is installed in your browser.
affects: >=1.0.0
gotchaThe `nice-grpc` middleware chain processes in reverse order of attachment: `clientFactory.use(middleware1).use(middleware2)` means `middleware1` is invoked last, and `middleware2` is invoked first. Consider middleware order carefully if you have multiple middlewares.
fix
Arrange your `.use()` calls based on the desired execution order. If `devtoolsClientMiddleware` needs to see the final request/response before other transformations, place it earlier in the chain. If it needs to see them after transformations, place it later.
affects: >=1.0.0
gotchaThis middleware is primarily intended for `nice-grpc-web` clients running in the browser. While technically usable with `nice-grpc` in Node.js, it won't provide benefits for browser-based debugging there and might lead to confusion.
fix
Ensure you are using `createClientFactory` and `createChannel` from `nice-grpc-web` when targeting browser environments for `grpc-web-devtools` integration.
affects: >=1.0.0
Errors
Common errors & fixes
ReferenceError: require is not defined
Attempting to use CommonJS `require()` syntax in an ESM-only or ESM-configured project.
fix
Use ESM `import` statements: `import { devtoolsClientMiddleware } from 'nice-grpc-client-middleware-devtools';`
TypeError: Cannot read properties of undefined (reading 'use')
Likely attempting to call `.use()` on something other than a `ClientFactory` or an incorrectly initialized factory.
fix
Ensure you correctly import `createClientFactory` from `nice-grpc-web` and call `createClientFactory()` before chaining `.use()` calls: `const clientFactory = createClientFactory().use(middleware);`
gRPC-Web calls not appearing in browser's Network tab or grpc-web-devtools extension.
The `grpc-web-devtools` browser extension is not installed, not enabled, or the middleware is not correctly applied to the client factory. Also, ensure your gRPC-Web proxy (e.g., Envoy) is correctly configured.
fix
Verify the `grpc-web-devtools` extension is installed and enabled. Double-check that `devtoolsClientMiddleware` is applied to your `createClientFactory()` instance. Ensure your browser is indeed making gRPC-Web requests (often visible as POST requests to `/Service/Method` with `Content-Type: application/grpc-web+proto` or `application/grpc-web-text`).
Upgrade
Version history
1.0.10latest on npm
Audit
Dependencies
nice-grpc-webrequiredThis middleware is specifically designed to work with gRPC-Web clients and the `grpc-web-devtools` browser extension.
nice-grpcrequiredWhile primarily for web, `nice-grpc` is the foundational library for the ecosystem. The middleware expects a `nice-grpc` compatible client factory.
nice-grpc-commonrequiredProvides common types and utilities shared across the `nice-grpc` ecosystem.
Agent activity
10 hits · last 30 days
node
8
OpenAI (training)
2
Resources
nice-grpc-client-middleware-devtools — npm install nice-grpc-client-middleware-devtools · libregistry