No Cancel method for steams

[joncomstock]

In this section of the Manual, https://github.com/timostamm/protobuf-ts/blob/main/MANUAL.md#generic-rpc-clients, it shows a cancel method to shut down a server stream.

Upon generating my code, server-streaming-call.d.ts in runtime-rpc does not contain a cancel method for me to use. Am I generating this code incorrectly?

Sample:

export declare class ServerStreamingCall<I extends object = object, O extends object = object> implements RpcCallShared<I, O>, PromiseLike<FinishedServerStreamingCall<I, O>> {
    /**
     * Reflection information about this call.
     */
    readonly method: MethodInfo<I, O>;
    /**
     * Request headers being sent with the request.
     *
     * Request headers are provided in the `meta` property of the
     * `RpcOptions` passed to a call.
     */
    readonly requestHeaders: Readonly<RpcMetadata>;
    /**
     * The request message being sent.
     */
    readonly request: Readonly<I>;
    /**
     * The response headers that the server sent.
     *
     * This promise will reject with a `RpcError` when the server sends a
     * error status code.
     */
    readonly headers: Promise<RpcMetadata>;
    /**
     * Response messages from the server.
     * This is an AsyncIterable that can be iterated with `await for .. of`.
     */
    readonly responses: RpcOutputStream<O>;
    /**
     * The response status the server replied with.
     *
     * This promise will resolve when the server has finished the request
     * successfully.
     *
     * If the server replies with an error status, this promise will
     * reject with a `RpcError`.
     */
    readonly status: Promise<RpcStatus>;
    /**
     * The trailers the server attached to the response.
     *
     * This promise will resolve when the server has finished the request
     * successfully.
     *
     * If the server replies with an error status, this promise will
     * reject with a `RpcError`.
     */
    readonly trailers: Promise<RpcMetadata>;
    constructor(method: MethodInfo<I, O>, requestHeaders: Readonly<RpcMetadata>, request: Readonly<I>, headers: Promise<RpcMetadata>, response: RpcOutputStream<O>, status: Promise<RpcStatus>, trailers: Promise<RpcMetadata>);
    /**
     * Instead of awaiting the response status and trailers, you can
     * just as well await this call itself to receive the server outcome.
     * You should first setup some listeners to the `request` to
     * see the actual messages the server replied with.
     */
    then<TResult1 = FinishedServerStreamingCall<I, O>, TResult2 = never>(onfulfilled?: ((value: FinishedServerStreamingCall<I, O>) => (PromiseLike<TResult1> | TResult1)) | undefined | null, onrejected?: ((reason: any) => (PromiseLike<TResult2> | TResult2)) | undefined | null): Promise<TResult1 | TResult2>;
    private promiseFinished;
}

[ban4e]

I needed the same functionality. After spending some time on the manual, I found such an opportunity:

generated.client.ts

listenEvents(input: ClientParameters, options?: RpcOptions): ServerStreamingCall<ClientParameters, ...>

rpc-options.d.ts

export interface RpcOptions {
    /**
     * A signal to cancel a call. Can be created with an [AbortController](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
     * The npm package `abort-controller` provides a polyfill for Node.js.
     */
    abort?: AbortSignal;
}

So you can do something like this:

async listenEvents() {
    const abortController = new AbortController();
    const params = ClientParameters.create({ someData: 'mockData' });
    
    this.stream = this.client.listenEvents(params, {
        abort: abortController.signal
    });

    setTimeout(() => {
        abortController.abort();
    }, 5000);

    for await (let resp of this.stream.responses) {
        console.log('got another steram event! ', resp)
    }
}

[jcready]

Yes, an AbortController (with AbortSignal) can be used to programmatically stop the stream. But just FYI your example would be better implemented using the timeout field in the RpcOptions.

[jcready]

I'm pretty sure the docs just need to be updated because, as you point out, there is no .cancel() method in the returned type.

[timostamm]

@jcready is correct, the cancel method in the manual refers to an older version that has been replaced by the use of abort signals a long time ago. Updated in #546.