@lsdsoftware/janus-client-node 1.0.3 → 1.0.5

package/dist/client.d.ts

@@ -1,11 +1,11 @@
 import { ClientRequestArgs } from "http";
 import * as rxjs from "rxjs";
 import { ClientOptions } from "ws";
-import { JanusMessage, JanusRequest } from "./types.js";
+import { JanusRequest } from "./types.js";
 export declare function createClient(websocketUrl: string, websocketOpts?: ClientOptions | ClientRequestArgs): rxjs.Observable<{
     requestSubject: rxjs.Subject<JanusRequest>;
     send$: rxjs.Observable<never>;
-    receive$: rxjs.Observable<JanusMessage>;
+    receive$: rxjs.Observable<Record<string, unknown>>;
     close$: rxjs.Observable<import("ws").default.CloseEvent>;
     close: (code?: number, data?: string | Buffer) => void;
 }>;

package/dist/client.js

@@ -8,16 +8,31 @@ export function createClient(websocketUrl, websocketOpts) {
         const pendingTxs = new Map();
         return {
             requestSubject,
-            send$: requestSubject.pipe(rxjs.concatMap(request => {
+            send$: requestSubject.pipe(rxjs.mergeMap(request => {
                 const txId = String(Math.random());
                 request.message.transaction = txId;
-                conn.send(JSON.stringify(request.message), err => {
+                return new rxjs.Observable(subscriber => conn.send(JSON.stringify(request.message), err => {
+                    subscriber.next(err);
+                    subscriber.complete();
+                })).pipe(rxjs.exhaustMap(err => {
                     if (err) {
                         request.reject(err);
+                        return rxjs.EMPTY;
                     }
                     else {
-                        pendingTxs.set(txId, response => {
-                            pendingTxs.delete(txId);
+                        function waitResponse(timeout) {
+                            return new rxjs.Observable(subscriber => {
+                                pendingTxs.set(txId, response => {
+                                    subscriber.next(response);
+                                    subscriber.complete();
+                                });
+                                return () => pendingTxs.delete(txId);
+                            }).pipe(timeout == Infinity ? rxjs.identity : rxjs.timeout({
+                                first: timeout,
+                                with: () => rxjs.of({ janus: 'error', error: { code: 408, reason: 'Request timeout' } })
+                            }));
+                        }
+                        return waitResponse(30_000).pipe(rxjs.exhaustMap(response => rxjs.iif(() => response.janus == 'ack', waitResponse(request.timeout ?? 300_000), rxjs.of(response))), rxjs.exhaustMap(response => {
                             if (response.janus == 'error') {
                                 const { code, reason } = response.error;
                                 request.reject(makeJanusError(request, code, reason));
@@ -25,16 +40,16 @@ export function createClient(websocketUrl, websocketOpts) {
                             else {
                                 request.fulfill(response);
                             }
-                        });
+                            return rxjs.EMPTY;
+                        }));
                     }
-                });
-                return rxjs.EMPTY;
+                }));
             }), rxjs.share()),
             receive$: conn.message$.pipe(rxjs.concatMap(event => {
                 try {
                     assert(typeof event.data == 'string');
                     const message = JSON.parse(event.data);
-                    if (message.janus == 'event' && typeof message.transaction == 'undefined') {
+                    if (typeof message.transaction == 'undefined') {
                         return rxjs.of(message);
                     }
                     else {
@@ -53,7 +68,10 @@ export function createClient(websocketUrl, websocketOpts) {
                     return rxjs.EMPTY;
                 }
             }), rxjs.share()),
-            close$: conn.close$,
+            close$: conn.close$.pipe(rxjs.tap(() => {
+                for (const pending of pendingTxs.values())
+                    pending({ janus: 'error', error: { code: 503, reason: 'Connection closed before response was received' } });
+            })),
             close: conn.close.bind(conn)
         };
     }));

package/dist/plugin-handle.d.ts

@@ -1,8 +1,8 @@
 import * as rxjs from "rxjs";
-import { JanusMessage, JanusRequest } from "./types.js";
+import { JanusRequest } from "./types.js";
 export declare function createPluginHandle(session: {
     requestSubject: rxjs.Subject<JanusRequest>;
-    receive$: rxjs.Observable<JanusMessage>;
+    receive$: rxjs.Observable<Record<string, unknown>>;
 }, plugin: string): rxjs.Observable<{
     requestSubject: rxjs.Subject<JanusRequest>;
     send$: rxjs.Observable<never>;

package/dist/plugin-handle.js

@@ -35,7 +35,7 @@ export function createPluginHandle(session, plugin) {
             }), rxjs.share()),
             detach() {
                 session.requestSubject.next({
-                    message: { janus: "detach" },
+                    message: { janus: "detach", handle_id: handleId },
                     stacktrace: new Error(),
                     fulfill: rxjs.noop,
                     reject: err => console.error('JanusPluginHandle detach fail', handleId, err)

package/dist/session.d.ts

@@ -1,14 +1,14 @@
 import * as rxjs from "rxjs";
-import { JanusMessage, JanusRequest } from "./types.js";
+import { JanusRequest } from "./types.js";
 export declare function createSession(client: {
     requestSubject: rxjs.Subject<JanusRequest>;
-    receive$: rxjs.Observable<JanusMessage>;
+    receive$: rxjs.Observable<Record<string, unknown>>;
 }, { keepAliveInterval }?: {
     keepAliveInterval?: number;
 }): rxjs.Observable<{
     requestSubject: rxjs.Subject<JanusRequest>;
     send$: rxjs.Observable<never>;
-    receive$: rxjs.Observable<JanusMessage>;
+    receive$: rxjs.Observable<Record<string, unknown>>;
     keepAlive$: rxjs.Observable<Error>;
     destroy(): void;
 }>;

package/dist/session.js

@@ -11,7 +11,7 @@ export function createSession(client, { keepAliveInterval = 45_000 } = {}) {
                 return rxjs.EMPTY;
             }), rxjs.share()),
             receive$: client.receive$.pipe(rxjs.filter(message => message.session_id == sessionId), rxjs.share()),
-            keepAlive$: requestSubject.pipe(rxjs.switchMap(() => rxjs.interval(keepAliveInterval).pipe(rxjs.switchMap(() => new rxjs.Observable(subscriber => client.requestSubject.next({
+            keepAlive$: requestSubject.pipe(rxjs.startWith(null), rxjs.switchMap(() => rxjs.interval(keepAliveInterval).pipe(rxjs.switchMap(() => new rxjs.Observable(subscriber => client.requestSubject.next({
                 message: { janus: "keepalive", session_id: sessionId },
                 stacktrace: new Error(),
                 fulfill() {
@@ -24,7 +24,7 @@ export function createSession(client, { keepAliveInterval = 45_000 } = {}) {
             }))))), rxjs.share()),
             destroy() {
                 client.requestSubject.next({
-                    message: { janus: 'destroy' },
+                    message: { janus: 'destroy', session_id: sessionId },
                     stacktrace: new Error(),
                     fulfill: rxjs.noop,
                     reject: err => console.error('JanusSession destroy fail', sessionId, err)

package/dist/types.d.ts

@@ -1,7 +1,7 @@
-export type JanusMessage = Record<string, unknown>;
 export interface JanusRequest {
-    readonly message: JanusMessage;
+    readonly message: Record<string, unknown>;
+    readonly timeout?: number;
     readonly stacktrace: Error;
-    fulfill(response: JanusMessage): void;
+    fulfill(response: Record<string, unknown>): void;
     reject(err: Error): void;
 }

package/dist/util.d.ts

@@ -1,6 +1,8 @@
 import * as rxjs from "rxjs";
-import { JanusMessage, JanusRequest } from "./types.js";
-export declare function request<T extends JanusMessage>(requestSubject: rxjs.Subject<JanusRequest>, message: JanusMessage): rxjs.Observable<T>;
+import { JanusRequest } from "./types.js";
+export declare function request<T>(requestSubject: rxjs.Subject<JanusRequest>, message: Record<string, unknown>, { timeout }?: {
+    timeout?: number;
+}): rxjs.Observable<T>;
 export declare function makeJanusError({ stacktrace, message }: JanusRequest, code: number, reason: string): Error & {
     code: number;
 };

package/dist/util.js

@@ -1,8 +1,9 @@
 import * as rxjs from "rxjs";
-export function request(requestSubject, message) {
+export function request(requestSubject, message, { timeout } = {}) {
     const stacktrace = new Error();
     return new rxjs.Observable(subscriber => requestSubject.next({
         message,
+        timeout,
         stacktrace,
         fulfill(response) {
             subscriber.next(response);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lsdsoftware/janus-client-node",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Janus WebSocket client for Node, built on RxJS observables",
   "keywords": [
     "janus",

package/src/client.ts

@@ -3,36 +3,66 @@ import assert from "assert"
 import { ClientRequestArgs } from "http"
 import * as rxjs from "rxjs"
 import { ClientOptions } from "ws"
-import { JanusMessage, JanusRequest } from "./types.js"
+import { JanusRequest } from "./types.js"
 import { makeJanusError } from "./util.js"
 
 export function createClient(websocketUrl: string, websocketOpts?: ClientOptions | ClientRequestArgs) {
   return connect(websocketUrl, websocketOpts, 'janus-protocol').pipe(
     rxjs.map(conn => {
       const requestSubject = new rxjs.Subject<JanusRequest>()
-      const pendingTxs = new Map<unknown, (response: JanusMessage) => void>()
+      const pendingTxs = new Map<unknown, (response: Record<string, unknown>) => void>()
       return {
         requestSubject,
         send$: requestSubject.pipe(
-          rxjs.concatMap(request => {
+          rxjs.mergeMap(request => {
             const txId = String(Math.random())
             request.message.transaction = txId
-            conn.send(JSON.stringify(request.message), err => {
-              if (err) {
-                request.reject(err)
-              } else {
-                pendingTxs.set(txId, response => {
-                  pendingTxs.delete(txId)
-                  if (response.janus == 'error') {
-                    const { code, reason } = response.error as { code: number, reason: string }
-                    request.reject(makeJanusError(request, code, reason))
-                  } else {
-                    request.fulfill(response)
+            return new rxjs.Observable<Error | undefined>(subscriber =>
+              conn.send(JSON.stringify(request.message), err => {
+                subscriber.next(err)
+                subscriber.complete()
+              })
+            ).pipe(
+              rxjs.exhaustMap(err => {
+                if (err) {
+                  request.reject(err)
+                  return rxjs.EMPTY
+                } else {
+                  function waitResponse(timeout: number) {
+                    return new rxjs.Observable<Record<string, unknown>>(subscriber => {
+                      pendingTxs.set(txId, response => {
+                        subscriber.next(response)
+                        subscriber.complete()
+                      })
+                      return () => pendingTxs.delete(txId)
+                    }).pipe(
+                      timeout == Infinity ? rxjs.identity : rxjs.timeout({
+                        first: timeout,
+                        with: () => rxjs.of({ janus: 'error', error: { code: 408, reason: 'Request timeout' } })
+                      })
+                    )
                   }
-                })
-              }
-            })
-            return rxjs.EMPTY
+                  return waitResponse(30_000).pipe(
+                    rxjs.exhaustMap(response =>
+                      rxjs.iif(
+                        () => response.janus == 'ack',
+                        waitResponse(request.timeout ?? 300_000),
+                        rxjs.of(response)
+                      )
+                    ),
+                    rxjs.exhaustMap(response => {
+                      if (response.janus == 'error') {
+                        const { code, reason } = response.error as { code: number, reason: string }
+                        request.reject(makeJanusError(request, code, reason))
+                      } else {
+                        request.fulfill(response)
+                      }
+                      return rxjs.EMPTY
+                    })
+                  )
+                }
+              })
+            )
           }),
           rxjs.share()
         ),
@@ -40,8 +70,8 @@ export function createClient(websocketUrl: string, websocketOpts?: ClientOptions
           rxjs.concatMap(event => {
             try {
               assert(typeof event.data == 'string')
-              const message = JSON.parse(event.data) as JanusMessage
-              if (message.janus == 'event' && typeof message.transaction == 'undefined') {
+              const message = JSON.parse(event.data) as Record<string, unknown>
+              if (typeof message.transaction == 'undefined') {
                 return rxjs.of(message)
               } else {
                 const pending = pendingTxs.get(message.transaction)
@@ -59,7 +89,12 @@ export function createClient(websocketUrl: string, websocketOpts?: ClientOptions
           }),
           rxjs.share()
         ),
-        close$: conn.close$,
+        close$: conn.close$.pipe(
+          rxjs.tap(() => {
+            for (const pending of pendingTxs.values())
+              pending({ janus: 'error', error: { code: 503, reason: 'Connection closed before response was received' }})
+          })
+        ),
         close: conn.close.bind(conn)
       }
     })

package/src/plugin-handle.ts

@@ -1,11 +1,11 @@
 import * as rxjs from "rxjs"
-import { JanusMessage, JanusRequest } from "./types.js"
+import { JanusRequest } from "./types.js"
 import { makeJanusError, request } from "./util.js"
 
 export function createPluginHandle(
   session: {
     requestSubject: rxjs.Subject<JanusRequest>
-    receive$: rxjs.Observable<JanusMessage>
+    receive$: rxjs.Observable<Record<string, unknown>>
   },
   plugin: string
 ) {
@@ -50,7 +50,7 @@ export function createPluginHandle(
         ),
         detach() {
           session.requestSubject.next({
-            message: { janus: "detach" },
+            message: { janus: "detach", handle_id: handleId },
             stacktrace: new Error(),
             fulfill: rxjs.noop,
             reject: err => console.error('JanusPluginHandle detach fail', handleId, err)

package/src/session.ts

@@ -1,11 +1,11 @@
 import * as rxjs from "rxjs"
-import { JanusMessage, JanusRequest } from "./types.js"
+import { JanusRequest } from "./types.js"
 import { request } from "./util.js"
 
 export function createSession(
   client: {
     requestSubject: rxjs.Subject<JanusRequest>
-    receive$: rxjs.Observable<JanusMessage>
+    receive$: rxjs.Observable<Record<string, unknown>>
   },
   { keepAliveInterval = 45_000 }: {
     keepAliveInterval?: number
@@ -29,6 +29,7 @@ export function createSession(
           rxjs.share()
         ),
         keepAlive$: requestSubject.pipe(
+          rxjs.startWith(null),
           rxjs.switchMap(() =>
             rxjs.interval(keepAliveInterval).pipe(
               rxjs.switchMap(() =>
@@ -52,7 +53,7 @@ export function createSession(
         ),
         destroy() {
           client.requestSubject.next({
-            message: { janus: 'destroy' },
+            message: { janus: 'destroy', session_id: sessionId },
             stacktrace: new Error(),
             fulfill: rxjs.noop,
             reject: err => console.error('JanusSession destroy fail', sessionId, err)

package/src/types.ts

@@ -1,9 +1,8 @@
 
-export type JanusMessage = Record<string, unknown>
-
 export interface JanusRequest {
-  readonly message: JanusMessage
+  readonly message: Record<string, unknown>
+  readonly timeout?: number
   readonly stacktrace: Error
-  fulfill(response: JanusMessage): void
+  fulfill(response: Record<string, unknown>): void
   reject(err: Error): void
 }

package/src/util.ts

@@ -1,14 +1,16 @@
 import * as rxjs from "rxjs"
-import { JanusMessage, JanusRequest } from "./types.js"
+import { JanusRequest } from "./types.js"
 
-export function request<T extends JanusMessage>(
+export function request<T>(
   requestSubject: rxjs.Subject<JanusRequest>,
-  message: JanusMessage
+  message: Record<string, unknown>,
+  { timeout }: { timeout?: number } = {}
 ) {
   const stacktrace = new Error()
   return new rxjs.Observable<T>(subscriber =>
     requestSubject.next({
       message,
+      timeout,
       stacktrace,
       fulfill(response) {
         subscriber.next(response as T)