different types for rxjs WebSocketSubject based on request/response (next msg type, subscribe msg type), but only one generic is allowed

user_16662138 0
Viewed 340

i'm working with webSocket from rxjs, and having an issue with the generic type argument.

the websocket API documentation states that request and response messages have different properties, but the generic for WebSocketSubject only accepts one type.

so we have something like:

import { webSocket } from "rxjs/webSocket";

const subject = new webSocket<MessageType>('wss://something');

subject.subscribe({
    error: err => {
        throw err;
    },
    next: msg /* this is of type MessageType, but the actual object is not the same type as what is input into `subject.next` */ => {
        console.log(msg); // outputs something like: { anotherProperty: "anotherValue" }
    },
    complete: () => {
        done();
    }
}); 

// but this argument is also of type MessageType
subject.next({
    testProperty1: "test value 1"
});

the problem is then that the type of msg in the next property of the subscribe method but also subject.next is the same, while the documentation specifies differing types (the objects have different properties) for input and output messages.

now of course it would be possible to use any or create a union type with optional parameters in order to make things work, but it would be more ideal to be able to specify one type for input messages and another for output messages. can this be achieved easily with the rxjs implementation of webSocket or do i need to write a wrapper or something in order to make this more clean?

ideally what i'd like to do would be something to the effect of the following (although of course i don't currently see that it's possible):


const subject = new webSocket<RequestMessageType, ResponseMessageType>('wss://something');
rxjs typescript websocket generics types
1 Answers

The two types in question...

  1. The generic when you invoke webSocket<T>()
  2. The value being passed into next .next<T>()

...they are the exact same type.

The generic you're defining at instantiation T is the message type that will be received from the web socket upon subscription.

WebSocketSubject is an extension of a Subject, which includes methods like .next(). This mean WebSocketSubject.next() does the same thing as Subject.next(), it emits the next value of type T for all RxJS subscribers. This is why the .next() method has the same T generic.

The way WebSocketSubject lets you send messages (which is of type any) to the WS is when you declare your public observables that will be for subscribers.

const wsSubject = webSocket<MessageType>('wss://something');

const wsMessages$ = wsSubject.multiplex(
  () => {} , // send message to WS server to start 
  () => {} , // send message to WS server to stop 
  (message) => true // filter messages by condition
);

These start and stop messages are automatically executed as subscribers start or end subscriptions to wsMessages$.

Reference: https://rxjs.dev/api/webSocket/WebSocketSubject

user_12241190
Related