@xdcobra/react-native-grpc 1.0.0 → 1.1.8
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE.md +22 -22
- package/README.md +284 -114
- package/android/build.gradle +127 -127
- package/android/gradle.properties +4 -4
- package/android/src/main/AndroidManifest.xml +3 -3
- package/android/src/main/java/com/reactnativegrpc/GrpcMarshaller.java +27 -27
- package/android/src/main/java/com/reactnativegrpc/GrpcModule.java +730 -585
- package/android/src/main/java/com/reactnativegrpc/GrpcPackage.java +27 -27
- package/android/src/main/java/com/reactnativegrpc/SpkiPinTrustManager.java +101 -101
- package/android/src/main/java/com/reactnativegrpc/TrustManagers.java +51 -51
- package/ios/Grpc.h +22 -22
- package/ios/Grpc.m +625 -439
- package/ios/SpkiPinning.h +22 -22
- package/ios/SpkiPinning.m +114 -114
- package/lib/commonjs/bidi-streaming.js.map +1 -1
- package/lib/commonjs/channel.js +84 -0
- package/lib/commonjs/channel.js.map +1 -0
- package/lib/commonjs/client-streaming.js +3 -3
- package/lib/commonjs/client-streaming.js.map +1 -1
- package/lib/commonjs/client.js +538 -135
- package/lib/commonjs/client.js.map +1 -1
- package/lib/commonjs/create-client.js +206 -0
- package/lib/commonjs/create-client.js.map +1 -0
- package/lib/commonjs/errors.js.map +1 -1
- package/lib/commonjs/index.js +32 -1
- package/lib/commonjs/index.js.map +1 -1
- package/lib/commonjs/interceptors.js +116 -0
- package/lib/commonjs/interceptors.js.map +1 -0
- package/lib/commonjs/native.js +24 -0
- package/lib/commonjs/native.js.map +1 -0
- package/lib/commonjs/retry.js +153 -0
- package/lib/commonjs/retry.js.map +1 -0
- package/lib/commonjs/server-streaming.js.map +1 -1
- package/lib/commonjs/status.js +54 -0
- package/lib/commonjs/status.js.map +1 -0
- package/lib/commonjs/types.js +29 -0
- package/lib/commonjs/types.js.map +1 -1
- package/lib/commonjs/unary.js.map +1 -1
- package/lib/module/bidi-streaming.js.map +1 -1
- package/lib/module/channel.js +76 -0
- package/lib/module/channel.js.map +1 -0
- package/lib/module/client-streaming.js +3 -3
- package/lib/module/client-streaming.js.map +1 -1
- package/lib/module/client.js +525 -129
- package/lib/module/client.js.map +1 -1
- package/lib/module/create-client.js +201 -0
- package/lib/module/create-client.js.map +1 -0
- package/lib/module/errors.js.map +1 -1
- package/lib/module/index.js +3 -0
- package/lib/module/index.js.map +1 -1
- package/lib/module/interceptors.js +104 -0
- package/lib/module/interceptors.js.map +1 -0
- package/lib/module/native.js +17 -0
- package/lib/module/native.js.map +1 -0
- package/lib/module/retry.js +141 -0
- package/lib/module/retry.js.map +1 -0
- package/lib/module/server-streaming.js.map +1 -1
- package/lib/module/status.js +46 -0
- package/lib/module/status.js.map +1 -0
- package/lib/module/types.js +17 -0
- package/lib/module/types.js.map +1 -1
- package/lib/module/unary.js.map +1 -1
- package/lib/typescript/channel.d.ts +27 -0
- package/lib/typescript/channel.d.ts.map +1 -0
- package/lib/typescript/client.d.ts +56 -49
- package/lib/typescript/client.d.ts.map +1 -1
- package/lib/typescript/create-client.d.ts +65 -0
- package/lib/typescript/create-client.d.ts.map +1 -0
- package/lib/typescript/index.d.ts +5 -0
- package/lib/typescript/index.d.ts.map +1 -1
- package/lib/typescript/interceptors.d.ts +43 -0
- package/lib/typescript/interceptors.d.ts.map +1 -0
- package/lib/typescript/native.d.ts +53 -0
- package/lib/typescript/native.d.ts.map +1 -0
- package/lib/typescript/retry.d.ts +56 -0
- package/lib/typescript/retry.d.ts.map +1 -0
- package/lib/typescript/status.d.ts +24 -0
- package/lib/typescript/status.d.ts.map +1 -0
- package/lib/typescript/types.d.ts +60 -0
- package/lib/typescript/types.d.ts.map +1 -1
- package/package.json +209 -169
- package/react-native-grpc.podspec +29 -29
- package/src/bidi-streaming.ts +78 -78
- package/src/channel.ts +110 -0
- package/src/client-streaming.ts +106 -106
- package/src/client.ts +1046 -521
- package/src/create-client.ts +391 -0
- package/src/errors.ts +11 -11
- package/src/index.ts +28 -11
- package/src/interceptors.ts +167 -0
- package/src/native.ts +99 -0
- package/src/retry.ts +208 -0
- package/src/server-streaming.ts +105 -105
- package/src/status.ts +50 -0
- package/src/types.ts +171 -107
- package/src/unary.ts +71 -71
|
@@ -0,0 +1,391 @@
|
|
|
1
|
+
import type {
|
|
2
|
+
DescMessage,
|
|
3
|
+
DescMethod,
|
|
4
|
+
DescService,
|
|
5
|
+
MessageShape,
|
|
6
|
+
} from '@bufbuild/protobuf';
|
|
7
|
+
import { fromBinary, toBinary } from '@bufbuild/protobuf';
|
|
8
|
+
import type {
|
|
9
|
+
GenService,
|
|
10
|
+
GenServiceMethods,
|
|
11
|
+
} from '@bufbuild/protobuf/codegenv2';
|
|
12
|
+
import type { GrpcCallApi } from './client';
|
|
13
|
+
import type {
|
|
14
|
+
GrpcCallOptions,
|
|
15
|
+
GrpcMetadata,
|
|
16
|
+
GrpcServerOutputStream,
|
|
17
|
+
RemoveListener,
|
|
18
|
+
ServerOutputEvent,
|
|
19
|
+
ServerOutputEventCallback,
|
|
20
|
+
} from './types';
|
|
21
|
+
|
|
22
|
+
/** Channel or singleton client that exposes the raw byte RPC surface. */
|
|
23
|
+
export type GrpcTransport = Pick<
|
|
24
|
+
GrpcCallApi,
|
|
25
|
+
'unaryCall' | 'serverStreamCall' | 'clientStreamCall' | 'bidiStreamCall'
|
|
26
|
+
>;
|
|
27
|
+
|
|
28
|
+
function makePath(service: DescService, method: DescMethod): string {
|
|
29
|
+
return `/${service.typeName}/${method.name}`;
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
function decodeOutputStream<O extends DescMessage>(
|
|
33
|
+
schema: O,
|
|
34
|
+
stream: GrpcServerOutputStream
|
|
35
|
+
): TypedServerOutputStream<MessageShape<O>> {
|
|
36
|
+
return {
|
|
37
|
+
on(event, callback) {
|
|
38
|
+
if (event === 'data') {
|
|
39
|
+
return stream.on('data', (data) => {
|
|
40
|
+
(callback as (message: MessageShape<O>) => void)(
|
|
41
|
+
fromBinary(schema, data)
|
|
42
|
+
);
|
|
43
|
+
});
|
|
44
|
+
}
|
|
45
|
+
return stream.on(
|
|
46
|
+
event,
|
|
47
|
+
callback as ServerOutputEventCallback<typeof event>
|
|
48
|
+
);
|
|
49
|
+
},
|
|
50
|
+
};
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
function toAsyncIterable<O>(
|
|
54
|
+
stream: TypedServerOutputStream<O>,
|
|
55
|
+
trailers: Promise<GrpcMetadata>
|
|
56
|
+
): AsyncIterable<O> {
|
|
57
|
+
return {
|
|
58
|
+
[Symbol.asyncIterator](): AsyncIterator<O> {
|
|
59
|
+
const queue: O[] = [];
|
|
60
|
+
let pending:
|
|
61
|
+
| {
|
|
62
|
+
resolve: (r: IteratorResult<O>) => void;
|
|
63
|
+
reject: (e: unknown) => void;
|
|
64
|
+
}
|
|
65
|
+
| undefined;
|
|
66
|
+
let done = false;
|
|
67
|
+
let error: unknown;
|
|
68
|
+
|
|
69
|
+
const flush = () => {
|
|
70
|
+
if (!pending) {
|
|
71
|
+
return;
|
|
72
|
+
}
|
|
73
|
+
if (error !== undefined) {
|
|
74
|
+
const { reject } = pending;
|
|
75
|
+
pending = undefined;
|
|
76
|
+
reject(error);
|
|
77
|
+
return;
|
|
78
|
+
}
|
|
79
|
+
if (queue.length > 0) {
|
|
80
|
+
const { resolve } = pending;
|
|
81
|
+
pending = undefined;
|
|
82
|
+
resolve({ value: queue.shift() as O, done: false });
|
|
83
|
+
return;
|
|
84
|
+
}
|
|
85
|
+
if (done) {
|
|
86
|
+
const { resolve } = pending;
|
|
87
|
+
pending = undefined;
|
|
88
|
+
resolve({ value: undefined, done: true });
|
|
89
|
+
}
|
|
90
|
+
};
|
|
91
|
+
|
|
92
|
+
stream.on('data', (message) => {
|
|
93
|
+
queue.push(message);
|
|
94
|
+
flush();
|
|
95
|
+
});
|
|
96
|
+
stream.on('error', (reason) => {
|
|
97
|
+
error = reason;
|
|
98
|
+
flush();
|
|
99
|
+
});
|
|
100
|
+
stream.on('complete', () => {
|
|
101
|
+
done = true;
|
|
102
|
+
flush();
|
|
103
|
+
});
|
|
104
|
+
// Ensure we observe trailers rejection as stream failure.
|
|
105
|
+
trailers.catch((reason) => {
|
|
106
|
+
error = reason;
|
|
107
|
+
flush();
|
|
108
|
+
});
|
|
109
|
+
|
|
110
|
+
return {
|
|
111
|
+
next(): Promise<IteratorResult<O>> {
|
|
112
|
+
if (error !== undefined) {
|
|
113
|
+
return Promise.reject(error);
|
|
114
|
+
}
|
|
115
|
+
if (queue.length > 0) {
|
|
116
|
+
return Promise.resolve({
|
|
117
|
+
value: queue.shift() as O,
|
|
118
|
+
done: false,
|
|
119
|
+
});
|
|
120
|
+
}
|
|
121
|
+
if (done) {
|
|
122
|
+
return Promise.resolve({ value: undefined, done: true });
|
|
123
|
+
}
|
|
124
|
+
return new Promise<IteratorResult<O>>((resolve, reject) => {
|
|
125
|
+
pending = { resolve, reject };
|
|
126
|
+
});
|
|
127
|
+
},
|
|
128
|
+
};
|
|
129
|
+
},
|
|
130
|
+
};
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
export type TypedServerOutputStream<O> = {
|
|
134
|
+
on<T extends ServerOutputEvent>(
|
|
135
|
+
event: T,
|
|
136
|
+
callback: T extends 'data'
|
|
137
|
+
? (message: O) => void
|
|
138
|
+
: ServerOutputEventCallback<T>
|
|
139
|
+
): RemoveListener;
|
|
140
|
+
};
|
|
141
|
+
|
|
142
|
+
export type UnaryMethod<I extends DescMessage, O extends DescMessage> = (
|
|
143
|
+
request: MessageShape<I>,
|
|
144
|
+
headers?: GrpcMetadata,
|
|
145
|
+
options?: GrpcCallOptions
|
|
146
|
+
) => Promise<MessageShape<O>>;
|
|
147
|
+
|
|
148
|
+
export type ServerStreamingMethod<
|
|
149
|
+
I extends DescMessage,
|
|
150
|
+
O extends DescMessage
|
|
151
|
+
> = (
|
|
152
|
+
request: MessageShape<I>,
|
|
153
|
+
headers?: GrpcMetadata,
|
|
154
|
+
options?: GrpcCallOptions
|
|
155
|
+
) => ServerStreamingCall<MessageShape<O>>;
|
|
156
|
+
|
|
157
|
+
export type ServerStreamingCall<O> = AsyncIterable<O> & {
|
|
158
|
+
readonly headers: Promise<GrpcMetadata>;
|
|
159
|
+
readonly responses: TypedServerOutputStream<O>;
|
|
160
|
+
readonly trailers: Promise<GrpcMetadata>;
|
|
161
|
+
cancel(): void;
|
|
162
|
+
};
|
|
163
|
+
|
|
164
|
+
export type ClientStreamingMethod<
|
|
165
|
+
I extends DescMessage,
|
|
166
|
+
O extends DescMessage
|
|
167
|
+
> = (
|
|
168
|
+
headers?: GrpcMetadata,
|
|
169
|
+
options?: GrpcCallOptions
|
|
170
|
+
) => ClientStreamingCall<MessageShape<I>, MessageShape<O>>;
|
|
171
|
+
|
|
172
|
+
export type ClientStreamingCall<I, O> = {
|
|
173
|
+
send(message: I): Promise<void>;
|
|
174
|
+
complete(): Promise<void>;
|
|
175
|
+
readonly response: Promise<O>;
|
|
176
|
+
readonly headers: Promise<GrpcMetadata>;
|
|
177
|
+
readonly trailers: Promise<GrpcMetadata>;
|
|
178
|
+
cancel(): void;
|
|
179
|
+
};
|
|
180
|
+
|
|
181
|
+
export type BidiStreamingMethod<
|
|
182
|
+
I extends DescMessage,
|
|
183
|
+
O extends DescMessage
|
|
184
|
+
> = (
|
|
185
|
+
headers?: GrpcMetadata,
|
|
186
|
+
options?: GrpcCallOptions
|
|
187
|
+
) => BidiStreamingCall<MessageShape<I>, MessageShape<O>>;
|
|
188
|
+
|
|
189
|
+
export type BidiStreamingCall<I, O> = {
|
|
190
|
+
send(message: I): Promise<void>;
|
|
191
|
+
complete(): Promise<void>;
|
|
192
|
+
readonly responses: TypedServerOutputStream<O>;
|
|
193
|
+
readonly headers: Promise<GrpcMetadata>;
|
|
194
|
+
readonly trailers: Promise<GrpcMetadata>;
|
|
195
|
+
cancel(): void;
|
|
196
|
+
} & AsyncIterable<O>;
|
|
197
|
+
|
|
198
|
+
type ClientMethod<M> = M extends {
|
|
199
|
+
methodKind: 'unary';
|
|
200
|
+
input: infer I;
|
|
201
|
+
output: infer O;
|
|
202
|
+
}
|
|
203
|
+
? I extends DescMessage
|
|
204
|
+
? O extends DescMessage
|
|
205
|
+
? UnaryMethod<I, O>
|
|
206
|
+
: never
|
|
207
|
+
: never
|
|
208
|
+
: M extends {
|
|
209
|
+
methodKind: 'server_streaming';
|
|
210
|
+
input: infer I;
|
|
211
|
+
output: infer O;
|
|
212
|
+
}
|
|
213
|
+
? I extends DescMessage
|
|
214
|
+
? O extends DescMessage
|
|
215
|
+
? ServerStreamingMethod<I, O>
|
|
216
|
+
: never
|
|
217
|
+
: never
|
|
218
|
+
: M extends {
|
|
219
|
+
methodKind: 'client_streaming';
|
|
220
|
+
input: infer I;
|
|
221
|
+
output: infer O;
|
|
222
|
+
}
|
|
223
|
+
? I extends DescMessage
|
|
224
|
+
? O extends DescMessage
|
|
225
|
+
? ClientStreamingMethod<I, O>
|
|
226
|
+
: never
|
|
227
|
+
: never
|
|
228
|
+
: M extends {
|
|
229
|
+
methodKind: 'bidi_streaming';
|
|
230
|
+
input: infer I;
|
|
231
|
+
output: infer O;
|
|
232
|
+
}
|
|
233
|
+
? I extends DescMessage
|
|
234
|
+
? O extends DescMessage
|
|
235
|
+
? BidiStreamingMethod<I, O>
|
|
236
|
+
: never
|
|
237
|
+
: never
|
|
238
|
+
: never;
|
|
239
|
+
|
|
240
|
+
/** Typed RPC client for a Protobuf-ES `GenService` schema. */
|
|
241
|
+
export type Client<Desc extends DescService> = {
|
|
242
|
+
[K in keyof Desc['method']]: ClientMethod<Desc['method'][K]>;
|
|
243
|
+
};
|
|
244
|
+
|
|
245
|
+
function createUnaryMethod<I extends DescMessage, O extends DescMessage>(
|
|
246
|
+
transport: GrpcTransport,
|
|
247
|
+
service: DescService,
|
|
248
|
+
method: DescMethod
|
|
249
|
+
): UnaryMethod<I, O> {
|
|
250
|
+
const path = makePath(service, method);
|
|
251
|
+
const input = method.input as I;
|
|
252
|
+
const output = method.output as O;
|
|
253
|
+
return async (request, headers, options) => {
|
|
254
|
+
const call = transport.unaryCall(
|
|
255
|
+
path,
|
|
256
|
+
toBinary(input, request),
|
|
257
|
+
headers,
|
|
258
|
+
options
|
|
259
|
+
);
|
|
260
|
+
const bytes = await call.response;
|
|
261
|
+
return fromBinary(output, bytes);
|
|
262
|
+
};
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
function createServerStreamingMethod<
|
|
266
|
+
I extends DescMessage,
|
|
267
|
+
O extends DescMessage
|
|
268
|
+
>(
|
|
269
|
+
transport: GrpcTransport,
|
|
270
|
+
service: DescService,
|
|
271
|
+
method: DescMethod
|
|
272
|
+
): ServerStreamingMethod<I, O> {
|
|
273
|
+
const path = makePath(service, method);
|
|
274
|
+
const input = method.input as I;
|
|
275
|
+
const output = method.output as O;
|
|
276
|
+
return (request, headers, options) => {
|
|
277
|
+
const call = transport.serverStreamCall(
|
|
278
|
+
path,
|
|
279
|
+
toBinary(input, request),
|
|
280
|
+
headers,
|
|
281
|
+
options
|
|
282
|
+
);
|
|
283
|
+
const responses = decodeOutputStream(output, call.responses);
|
|
284
|
+
const iterable = toAsyncIterable(responses, call.trailers);
|
|
285
|
+
return {
|
|
286
|
+
headers: call.headers,
|
|
287
|
+
responses,
|
|
288
|
+
trailers: call.trailers,
|
|
289
|
+
cancel: () => call.cancel(),
|
|
290
|
+
[Symbol.asyncIterator]: () => iterable[Symbol.asyncIterator](),
|
|
291
|
+
};
|
|
292
|
+
};
|
|
293
|
+
}
|
|
294
|
+
|
|
295
|
+
function createClientStreamingMethod<
|
|
296
|
+
I extends DescMessage,
|
|
297
|
+
O extends DescMessage
|
|
298
|
+
>(
|
|
299
|
+
transport: GrpcTransport,
|
|
300
|
+
service: DescService,
|
|
301
|
+
method: DescMethod
|
|
302
|
+
): ClientStreamingMethod<I, O> {
|
|
303
|
+
const path = makePath(service, method);
|
|
304
|
+
const input = method.input as I;
|
|
305
|
+
const output = method.output as O;
|
|
306
|
+
return (headers, options) => {
|
|
307
|
+
const call = transport.clientStreamCall(path, headers, options);
|
|
308
|
+
return {
|
|
309
|
+
send: (message) => call.requests.send(toBinary(input, message)),
|
|
310
|
+
complete: () => call.requests.complete(),
|
|
311
|
+
response: call.response.then((bytes) => fromBinary(output, bytes)),
|
|
312
|
+
headers: call.headers,
|
|
313
|
+
trailers: call.trailers,
|
|
314
|
+
cancel: () => call.cancel(),
|
|
315
|
+
};
|
|
316
|
+
};
|
|
317
|
+
}
|
|
318
|
+
|
|
319
|
+
function createBidiStreamingMethod<
|
|
320
|
+
I extends DescMessage,
|
|
321
|
+
O extends DescMessage
|
|
322
|
+
>(
|
|
323
|
+
transport: GrpcTransport,
|
|
324
|
+
service: DescService,
|
|
325
|
+
method: DescMethod
|
|
326
|
+
): BidiStreamingMethod<I, O> {
|
|
327
|
+
const path = makePath(service, method);
|
|
328
|
+
const input = method.input as I;
|
|
329
|
+
const output = method.output as O;
|
|
330
|
+
return (headers, options) => {
|
|
331
|
+
const call = transport.bidiStreamCall(path, headers, options);
|
|
332
|
+
const responses = decodeOutputStream(output, call.responses);
|
|
333
|
+
const iterable = toAsyncIterable(responses, call.trailers);
|
|
334
|
+
return {
|
|
335
|
+
send: (message) => call.requests.send(toBinary(input, message)),
|
|
336
|
+
complete: () => call.requests.complete(),
|
|
337
|
+
responses,
|
|
338
|
+
headers: call.headers,
|
|
339
|
+
trailers: call.trailers,
|
|
340
|
+
cancel: () => call.cancel(),
|
|
341
|
+
[Symbol.asyncIterator]: () => iterable[Symbol.asyncIterator](),
|
|
342
|
+
};
|
|
343
|
+
};
|
|
344
|
+
}
|
|
345
|
+
|
|
346
|
+
/**
|
|
347
|
+
* Create a typed client for a Protobuf-ES service schema (`protoc-gen-es`).
|
|
348
|
+
*
|
|
349
|
+
* Requires peer dependency `@bufbuild/protobuf`. Maps RPCs onto
|
|
350
|
+
* {@link GrpcTransport} (`GrpcClient` or a `GrpcChannel`).
|
|
351
|
+
*/
|
|
352
|
+
export function createClient<T extends GenServiceMethods>(
|
|
353
|
+
service: GenService<T>,
|
|
354
|
+
transport: GrpcTransport
|
|
355
|
+
): Client<GenService<T>> {
|
|
356
|
+
const client = {} as Client<GenService<T>>;
|
|
357
|
+
for (const method of service.methods) {
|
|
358
|
+
const key = method.localName as keyof Client<GenService<T>>;
|
|
359
|
+
switch (method.methodKind) {
|
|
360
|
+
case 'unary':
|
|
361
|
+
client[key] = createUnaryMethod(transport, service, method) as Client<
|
|
362
|
+
GenService<T>
|
|
363
|
+
>[typeof key];
|
|
364
|
+
break;
|
|
365
|
+
case 'server_streaming':
|
|
366
|
+
client[key] = createServerStreamingMethod(
|
|
367
|
+
transport,
|
|
368
|
+
service,
|
|
369
|
+
method
|
|
370
|
+
) as Client<GenService<T>>[typeof key];
|
|
371
|
+
break;
|
|
372
|
+
case 'client_streaming':
|
|
373
|
+
client[key] = createClientStreamingMethod(
|
|
374
|
+
transport,
|
|
375
|
+
service,
|
|
376
|
+
method
|
|
377
|
+
) as Client<GenService<T>>[typeof key];
|
|
378
|
+
break;
|
|
379
|
+
case 'bidi_streaming':
|
|
380
|
+
client[key] = createBidiStreamingMethod(
|
|
381
|
+
transport,
|
|
382
|
+
service,
|
|
383
|
+
method
|
|
384
|
+
) as Client<GenService<T>>[typeof key];
|
|
385
|
+
break;
|
|
386
|
+
default:
|
|
387
|
+
break;
|
|
388
|
+
}
|
|
389
|
+
}
|
|
390
|
+
return client;
|
|
391
|
+
}
|
package/src/errors.ts
CHANGED
|
@@ -1,11 +1,11 @@
|
|
|
1
|
-
import { GrpcMetadata } from './types';
|
|
2
|
-
|
|
3
|
-
export class GrpcError extends Error {
|
|
4
|
-
constructor(
|
|
5
|
-
public error: string,
|
|
6
|
-
public code?: number,
|
|
7
|
-
public trailers?: GrpcMetadata
|
|
8
|
-
) {
|
|
9
|
-
super(error);
|
|
10
|
-
}
|
|
11
|
-
}
|
|
1
|
+
import { GrpcMetadata } from './types';
|
|
2
|
+
|
|
3
|
+
export class GrpcError extends Error {
|
|
4
|
+
constructor(
|
|
5
|
+
public error: string,
|
|
6
|
+
public code?: number,
|
|
7
|
+
public trailers?: GrpcMetadata
|
|
8
|
+
) {
|
|
9
|
+
super(error);
|
|
10
|
+
}
|
|
11
|
+
}
|
package/src/index.ts
CHANGED
|
@@ -1,11 +1,28 @@
|
|
|
1
|
-
import { GrpcClient as GrpcClientImpl } from './client';
|
|
2
|
-
|
|
3
|
-
const GrpcClient = new GrpcClientImpl();
|
|
4
|
-
|
|
5
|
-
export * from './types';
|
|
6
|
-
export * from './unary';
|
|
7
|
-
export * from './server-streaming';
|
|
8
|
-
export * from './client-streaming';
|
|
9
|
-
export * from './bidi-streaming';
|
|
10
|
-
export * from './errors';
|
|
11
|
-
export {
|
|
1
|
+
import { GrpcClient as GrpcClientImpl } from './client';
|
|
2
|
+
|
|
3
|
+
const GrpcClient = new GrpcClientImpl();
|
|
4
|
+
|
|
5
|
+
export * from './types';
|
|
6
|
+
export * from './unary';
|
|
7
|
+
export * from './server-streaming';
|
|
8
|
+
export * from './client-streaming';
|
|
9
|
+
export * from './bidi-streaming';
|
|
10
|
+
export * from './errors';
|
|
11
|
+
export { createChannel, GrpcChannel } from './channel';
|
|
12
|
+
export type { GrpcInterceptStart, GrpcInterceptor } from './interceptors';
|
|
13
|
+
export type { GrpcHedgingPolicy, GrpcRetryPolicy } from './retry';
|
|
14
|
+
export { GrpcStatusCode } from './status';
|
|
15
|
+
export {
|
|
16
|
+
createClient,
|
|
17
|
+
type BidiStreamingCall,
|
|
18
|
+
type BidiStreamingMethod,
|
|
19
|
+
type Client,
|
|
20
|
+
type ClientStreamingCall,
|
|
21
|
+
type ClientStreamingMethod,
|
|
22
|
+
type GrpcTransport,
|
|
23
|
+
type ServerStreamingCall,
|
|
24
|
+
type ServerStreamingMethod,
|
|
25
|
+
type TypedServerOutputStream,
|
|
26
|
+
type UnaryMethod,
|
|
27
|
+
} from './create-client';
|
|
28
|
+
export { GrpcClient };
|
|
@@ -0,0 +1,167 @@
|
|
|
1
|
+
import { GrpcError } from './errors';
|
|
2
|
+
import { GrpcCallOptions, GrpcMetadata } from './types';
|
|
3
|
+
|
|
4
|
+
/** Mutable start payload; interceptors may replace fields before the native call. */
|
|
5
|
+
export type GrpcInterceptStart = {
|
|
6
|
+
method: string;
|
|
7
|
+
headers: GrpcMetadata;
|
|
8
|
+
options: GrpcCallOptions;
|
|
9
|
+
/** Present for unary / server-streaming; optional for client/bidi until first send. */
|
|
10
|
+
request?: Uint8Array;
|
|
11
|
+
};
|
|
12
|
+
|
|
13
|
+
/**
|
|
14
|
+
* Request/response middleware hooks.
|
|
15
|
+
* Outbound hooks run index 0→n; inbound hooks run n→0 (onion).
|
|
16
|
+
*/
|
|
17
|
+
export type GrpcInterceptor = {
|
|
18
|
+
/**
|
|
19
|
+
* Outbound: before native start. Throw to abort (rejected call).
|
|
20
|
+
* Return a value to replace the start payload; `void` keeps the previous value.
|
|
21
|
+
*/
|
|
22
|
+
onStart?(
|
|
23
|
+
start: GrpcInterceptStart
|
|
24
|
+
): void | GrpcInterceptStart | Promise<void | GrpcInterceptStart>;
|
|
25
|
+
/**
|
|
26
|
+
* Each outbound message (unary/server request, every client/bidi send).
|
|
27
|
+
*/
|
|
28
|
+
onSendMessage?(
|
|
29
|
+
message: Uint8Array,
|
|
30
|
+
method: string
|
|
31
|
+
): void | Uint8Array | Promise<void | Uint8Array>;
|
|
32
|
+
/** Inbound response headers. */
|
|
33
|
+
onHeaders?(headers: GrpcMetadata, method: string): void | GrpcMetadata;
|
|
34
|
+
/** Each inbound message. */
|
|
35
|
+
onMessage?(message: Uint8Array, method: string): void | Uint8Array;
|
|
36
|
+
/** Successful close trailers. */
|
|
37
|
+
onTrailers?(trailers: GrpcMetadata, method: string): void | GrpcMetadata;
|
|
38
|
+
/** Error path. May remap to another Error / GrpcError. */
|
|
39
|
+
onError?(error: GrpcError, method: string): void | GrpcError | Error;
|
|
40
|
+
};
|
|
41
|
+
|
|
42
|
+
/** Channel interceptors first, then per-call interceptors. */
|
|
43
|
+
export function combineInterceptors(
|
|
44
|
+
channel: readonly GrpcInterceptor[] | undefined,
|
|
45
|
+
perCall: readonly GrpcInterceptor[] | undefined
|
|
46
|
+
): GrpcInterceptor[] {
|
|
47
|
+
const out: GrpcInterceptor[] = [];
|
|
48
|
+
if (channel && channel.length > 0) {
|
|
49
|
+
out.push(...channel);
|
|
50
|
+
}
|
|
51
|
+
if (perCall && perCall.length > 0) {
|
|
52
|
+
out.push(...perCall);
|
|
53
|
+
}
|
|
54
|
+
return out;
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
export async function runOnStart(
|
|
58
|
+
interceptors: readonly GrpcInterceptor[],
|
|
59
|
+
start: GrpcInterceptStart
|
|
60
|
+
): Promise<GrpcInterceptStart> {
|
|
61
|
+
let current = start;
|
|
62
|
+
for (const interceptor of interceptors) {
|
|
63
|
+
if (!interceptor.onStart) {
|
|
64
|
+
continue;
|
|
65
|
+
}
|
|
66
|
+
const result = await interceptor.onStart(current);
|
|
67
|
+
if (result !== undefined) {
|
|
68
|
+
current = result;
|
|
69
|
+
}
|
|
70
|
+
}
|
|
71
|
+
return current;
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
export async function runOnSendMessage(
|
|
75
|
+
interceptors: readonly GrpcInterceptor[],
|
|
76
|
+
message: Uint8Array,
|
|
77
|
+
method: string
|
|
78
|
+
): Promise<Uint8Array> {
|
|
79
|
+
let current = message;
|
|
80
|
+
for (const interceptor of interceptors) {
|
|
81
|
+
if (!interceptor.onSendMessage) {
|
|
82
|
+
continue;
|
|
83
|
+
}
|
|
84
|
+
const result = await interceptor.onSendMessage(current, method);
|
|
85
|
+
if (result !== undefined) {
|
|
86
|
+
current = result;
|
|
87
|
+
}
|
|
88
|
+
}
|
|
89
|
+
return current;
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
export function runOnHeaders(
|
|
93
|
+
interceptors: readonly GrpcInterceptor[],
|
|
94
|
+
headers: GrpcMetadata,
|
|
95
|
+
method: string
|
|
96
|
+
): GrpcMetadata {
|
|
97
|
+
let current = headers;
|
|
98
|
+
for (let i = interceptors.length - 1; i >= 0; i--) {
|
|
99
|
+
const result = interceptors[i].onHeaders?.(current, method);
|
|
100
|
+
if (result !== undefined) {
|
|
101
|
+
current = result;
|
|
102
|
+
}
|
|
103
|
+
}
|
|
104
|
+
return current;
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
export function runOnMessage(
|
|
108
|
+
interceptors: readonly GrpcInterceptor[],
|
|
109
|
+
message: Uint8Array,
|
|
110
|
+
method: string
|
|
111
|
+
): Uint8Array {
|
|
112
|
+
let current = message;
|
|
113
|
+
for (let i = interceptors.length - 1; i >= 0; i--) {
|
|
114
|
+
const result = interceptors[i].onMessage?.(current, method);
|
|
115
|
+
if (result !== undefined) {
|
|
116
|
+
current = result;
|
|
117
|
+
}
|
|
118
|
+
}
|
|
119
|
+
return current;
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
export function runOnTrailers(
|
|
123
|
+
interceptors: readonly GrpcInterceptor[],
|
|
124
|
+
trailers: GrpcMetadata,
|
|
125
|
+
method: string
|
|
126
|
+
): GrpcMetadata {
|
|
127
|
+
let current = trailers;
|
|
128
|
+
for (let i = interceptors.length - 1; i >= 0; i--) {
|
|
129
|
+
const result = interceptors[i].onTrailers?.(current, method);
|
|
130
|
+
if (result !== undefined) {
|
|
131
|
+
current = result;
|
|
132
|
+
}
|
|
133
|
+
}
|
|
134
|
+
return current;
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
export function runOnError(
|
|
138
|
+
interceptors: readonly GrpcInterceptor[],
|
|
139
|
+
error: GrpcError,
|
|
140
|
+
method: string
|
|
141
|
+
): GrpcError {
|
|
142
|
+
let current: GrpcError | Error = error;
|
|
143
|
+
for (let i = interceptors.length - 1; i >= 0; i--) {
|
|
144
|
+
const asGrpc =
|
|
145
|
+
current instanceof GrpcError
|
|
146
|
+
? current
|
|
147
|
+
: new GrpcError(current.message || String(current));
|
|
148
|
+
const result = interceptors[i].onError?.(asGrpc, method);
|
|
149
|
+
if (result !== undefined) {
|
|
150
|
+
current = result;
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
if (current instanceof GrpcError) {
|
|
154
|
+
return current;
|
|
155
|
+
}
|
|
156
|
+
return new GrpcError(current.message || String(current));
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
export function toGrpcError(reason: unknown): GrpcError {
|
|
160
|
+
if (reason instanceof GrpcError) {
|
|
161
|
+
return reason;
|
|
162
|
+
}
|
|
163
|
+
if (reason instanceof Error) {
|
|
164
|
+
return new GrpcError(reason.message);
|
|
165
|
+
}
|
|
166
|
+
return new GrpcError(String(reason));
|
|
167
|
+
}
|