@lsdsoftware/janus-client-node 1.0.1 → 1.0.3

package/dist/client.d.ts

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

package/dist/client.js

@@ -1,26 +1,34 @@
 import { connect } from "@service-broker/websocket";
 import assert from "assert";
 import * as rxjs from "rxjs";
-import { JanusError } from "./types.js";
+import { makeJanusError } from "./util.js";
 export function createClient(websocketUrl, websocketOpts) {
     return connect(websocketUrl, websocketOpts, 'janus-protocol').pipe(rxjs.map(conn => {
         const requestSubject = new rxjs.Subject();
-        const pendingRequests = new Map();
+        const pendingTxs = new Map();
         return {
             requestSubject,
             send$: requestSubject.pipe(rxjs.concatMap(request => {
                 const txId = String(Math.random());
                 request.message.transaction = txId;
-                return new rxjs.Observable(subscriber => conn.send(JSON.stringify(request.message), err => {
+                conn.send(JSON.stringify(request.message), err => {
                     if (err) {
-                        subscriber.next(new Error('JanusClient sendMessage fail', { cause: err }));
-                        subscriber.complete();
+                        request.reject(err);
                     }
                     else {
-                        subscriber.complete();
-                        pendingRequests.set(txId, request);
+                        pendingTxs.set(txId, response => {
+                            pendingTxs.delete(txId);
+                            if (response.janus == 'error') {
+                                const { code, reason } = response.error;
+                                request.reject(makeJanusError(request, code, reason));
+                            }
+                            else {
+                                request.fulfill(response);
+                            }
+                        });
                     }
-                }));
+                });
+                return rxjs.EMPTY;
             }), rxjs.share()),
             receive$: conn.message$.pipe(rxjs.concatMap(event => {
                 try {
@@ -30,16 +38,9 @@ export function createClient(websocketUrl, websocketOpts) {
                         return rxjs.of(message);
                     }
                     else {
-                        const request = pendingRequests.get(message.transaction);
-                        if (request) {
-                            pendingRequests.delete(message.transaction);
-                            if (message.janus == 'error') {
-                                const { code, reason } = message.error;
-                                request.reject(new JanusError(code, reason));
-                            }
-                            else {
-                                request.fulfill(message);
-                            }
+                        const pending = pendingTxs.get(message.transaction);
+                        if (pending) {
+                            pending(message);
                             return rxjs.EMPTY;
                         }
                         else {
@@ -48,9 +49,8 @@ export function createClient(websocketUrl, websocketOpts) {
                     }
                 }
                 catch (err) {
-                    if (err instanceof Error)
-                        err.cause = event.data;
-                    return rxjs.of(new Error('JanusClient processMessage fail', { cause: err }));
+                    console.error('JanusClient receive fail', event.data, err);
+                    return rxjs.EMPTY;
                 }
             }), rxjs.share()),
             close$: conn.close$,

package/dist/index.test.js

@@ -1,7 +1,7 @@
 import { afterEverything, describe, expect, Expectation } from "@service-broker/test-utils";
 import assert from "assert";
 import * as rxjs from "rxjs";
-import { createClient, createPluginHandle, createSession, JanusError, request } from "./index.js";
+import { createClient, createPluginHandle, createSession, request } from "./index.js";
 const requestSubject = new rxjs.ReplaySubject();
 const shutdownSubject = new rxjs.Subject();
 assert(process.env.JANUS_URL, 'Missing env JANUS_URL');
@@ -15,8 +15,6 @@ rxjs.exhaustMap(client => rxjs.merge(client.send$, client.receive$, createSessio
     next(event) {
         if (event instanceof Error)
             console.error(event);
-        else if (event instanceof JanusError)
-            console.error('JanusError', event);
         else
             console.info('Unhandled', event);
     },

package/dist/plugin-handle.d.ts

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

package/dist/plugin-handle.js

@@ -1,6 +1,5 @@
 import * as rxjs from "rxjs";
-import { JanusError } from "./types.js";
-import { request } from "./util.js";
+import { makeJanusError, request } from "./util.js";
 export function createPluginHandle(session, plugin) {
     return request(session.requestSubject, { janus: "attach", plugin }).pipe(rxjs.map(({ data: { id: handleId } }) => {
         const requestSubject = new rxjs.Subject();
@@ -13,11 +12,12 @@ export function createPluginHandle(session, plugin) {
                         handle_id: handleId,
                         body: request.message
                     },
+                    stacktrace: request.stacktrace,
                     fulfill(response) {
                         const { data } = response.plugindata;
                         if (data.error) {
                             const { error, error_code } = data;
-                            request.reject(new JanusError(error_code, error));
+                            request.reject(makeJanusError(this, error_code, error));
                         }
                         else {
                             request.fulfill(data);
@@ -28,10 +28,15 @@ export function createPluginHandle(session, plugin) {
                     }
                 });
                 return rxjs.EMPTY;
-            })),
+            }), rxjs.share()),
+            receive$: session.receive$.pipe(rxjs.filter(message => message.handle_id == handleId), rxjs.map(message => {
+                const { data } = message.plugindata;
+                return data;
+            }), rxjs.share()),
             detach() {
                 session.requestSubject.next({
                     message: { janus: "detach" },
+                    stacktrace: new Error(),
                     fulfill: rxjs.noop,
                     reject: err => console.error('JanusPluginHandle detach fail', handleId, err)
                 });

package/dist/session.d.ts

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

package/dist/session.js

@@ -9,9 +9,11 @@ export function createSession(client, { keepAliveInterval = 45_000 } = {}) {
                 request.message.session_id = sessionId;
                 client.requestSubject.next(request);
                 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({
                 message: { janus: "keepalive", session_id: sessionId },
+                stacktrace: new Error(),
                 fulfill() {
                     subscriber.complete();
                 },
@@ -19,10 +21,11 @@ export function createSession(client, { keepAliveInterval = 45_000 } = {}) {
                     subscriber.next(err);
                     subscriber.complete();
                 }
-            })))))),
+            }))))), rxjs.share()),
             destroy() {
                 client.requestSubject.next({
                     message: { janus: 'destroy' },
+                    stacktrace: new Error(),
                     fulfill: rxjs.noop,
                     reject: err => console.error('JanusSession destroy fail', sessionId, err)
                 });

package/dist/types.d.ts

@@ -1,11 +1,7 @@
 export type JanusMessage = Record<string, unknown>;
-export declare class JanusError {
-    readonly code: number;
-    readonly reason: string;
-    constructor(code: number, reason: string);
-}
 export interface JanusRequest {
     readonly message: JanusMessage;
+    readonly stacktrace: Error;
     fulfill(response: JanusMessage): void;
-    reject(err: JanusError): void;
+    reject(err: Error): void;
 }

package/dist/types.js

@@ -1,8 +1 @@
-export class JanusError {
-    code;
-    reason;
-    constructor(code, reason) {
-        this.code = code;
-        this.reason = reason;
-    }
-}
+export {};

package/dist/util.d.ts

@@ -1,3 +1,6 @@
 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>;
+export declare function makeJanusError({ stacktrace, message }: JanusRequest, code: number, reason: string): Error & {
+    code: number;
+};

package/dist/util.js

@@ -1,7 +1,9 @@
 import * as rxjs from "rxjs";
 export function request(requestSubject, message) {
+    const stacktrace = new Error();
     return new rxjs.Observable(subscriber => requestSubject.next({
         message,
+        stacktrace,
         fulfill(response) {
             subscriber.next(response);
             subscriber.complete();
@@ -11,3 +13,9 @@ export function request(requestSubject, message) {
         }
     }));
 }
+export function makeJanusError({ stacktrace, message }, code, reason) {
+    stacktrace.name = 'JanusError';
+    stacktrace.cause = message;
+    stacktrace.message = reason;
+    return Object.assign(stacktrace, { code });
+}

package/package.json

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

package/src/client.ts

@@ -3,30 +3,36 @@ import assert from "assert"
 import { ClientRequestArgs } from "http"
 import * as rxjs from "rxjs"
 import { ClientOptions } from "ws"
-import { JanusError, JanusMessage, JanusRequest } from "./types.js"
+import { JanusMessage, 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 pendingRequests = new Map<unknown, JanusRequest>()
+      const pendingTxs = new Map<unknown, (response: JanusMessage) => void>()
       return {
         requestSubject,
         send$: requestSubject.pipe(
           rxjs.concatMap(request => {
             const txId = String(Math.random())
             request.message.transaction = txId
-            return new rxjs.Observable<Error>(subscriber =>
-              conn.send(JSON.stringify(request.message), err => {
-                if (err) {
-                  subscriber.next(new Error('JanusClient sendMessage fail', { cause: err }))
-                  subscriber.complete()
-                } else {
-                  subscriber.complete()
-                  pendingRequests.set(txId, request)
-                }
-              })
-            )
+            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 rxjs.EMPTY
           }),
           rxjs.share()
         ),
@@ -38,23 +44,17 @@ export function createClient(websocketUrl: string, websocketOpts?: ClientOptions
               if (message.janus == 'event' && typeof message.transaction == 'undefined') {
                 return rxjs.of(message)
               } else {
-                const request = pendingRequests.get(message.transaction)
-                if (request) {
-                  pendingRequests.delete(message.transaction)
-                  if (message.janus == 'error') {
-                    const { code, reason } = message.error as { code: number, reason: string }
-                    request.reject(new JanusError(code, reason))
-                  } else {
-                    request.fulfill(message)
-                  }
+                const pending = pendingTxs.get(message.transaction)
+                if (pending) {
+                  pending(message)
                   return rxjs.EMPTY
                 } else {
                   throw new Error('Stray')
                 }
               }
             } catch (err) {
-              if (err instanceof Error) err.cause = event.data
-              return rxjs.of(new Error('JanusClient processMessage fail', { cause: err }))
+              console.error('JanusClient receive fail', event.data, err)
+              return rxjs.EMPTY
             }
           }),
           rxjs.share()

package/src/index.test.ts

@@ -1,7 +1,7 @@
 import { afterEverything, describe, expect, Expectation } from "@service-broker/test-utils"
 import assert from "assert"
 import * as rxjs from "rxjs"
-import { createClient, createPluginHandle, createSession, JanusError, JanusRequest, request } from "./index.js"
+import { createClient, createPluginHandle, createSession, JanusRequest, request } from "./index.js"
 
 const requestSubject = new rxjs.ReplaySubject<JanusRequest>()
 const shutdownSubject = new rxjs.Subject<void>()
@@ -52,7 +52,6 @@ createClient(process.env.JANUS_URL).pipe(
 ).subscribe({
   next(event) {
     if (event instanceof Error) console.error(event)
-    else if (event instanceof JanusError) console.error('JanusError', event)
     else console.info('Unhandled', event)
   },
   error(err) {

package/src/plugin-handle.ts

@@ -1,8 +1,14 @@
 import * as rxjs from "rxjs"
-import { JanusError, JanusRequest } from "./types.js"
-import { request } from "./util.js"
+import { JanusMessage, JanusRequest } from "./types.js"
+import { makeJanusError, request } from "./util.js"
 
-export function createPluginHandle(session: { requestSubject: rxjs.Subject<JanusRequest> }, plugin: string) {
+export function createPluginHandle(
+  session: {
+    requestSubject: rxjs.Subject<JanusRequest>
+    receive$: rxjs.Observable<JanusMessage>
+  },
+  plugin: string
+) {
   return request<{ data: { id: number } }>(session.requestSubject, { janus: "attach", plugin }).pipe(
     rxjs.map(({ data: { id: handleId }}) => {
       const requestSubject = new rxjs.Subject<JanusRequest>()
@@ -16,11 +22,12 @@ export function createPluginHandle(session: { requestSubject: rxjs.Subject<Janus
                 handle_id: handleId,
                 body: request.message
               },
+              stacktrace: request.stacktrace,
               fulfill(response) {
                 const { data } = response.plugindata as { data: Record<string, unknown> }
                 if (data.error) {
                   const { error, error_code } = data as { error: string, error_code: number }
-                  request.reject(new JanusError(error_code, error))
+                  request.reject(makeJanusError(this, error_code, error))
                 } else {
                   request.fulfill(data)
                 }
@@ -30,11 +37,21 @@ export function createPluginHandle(session: { requestSubject: rxjs.Subject<Janus
               }
             })
             return rxjs.EMPTY
-          })
+          }),
+          rxjs.share()
+        ),
+        receive$: session.receive$.pipe(
+          rxjs.filter(message => message.handle_id == handleId),
+          rxjs.map(message => {
+            const { data } = message.plugindata as { data: Record<string, unknown> }
+            return data
+          }),
+          rxjs.share()
         ),
         detach() {
           session.requestSubject.next({
             message: { janus: "detach" },
+            stacktrace: new Error(),
             fulfill: rxjs.noop,
             reject: err => console.error('JanusPluginHandle detach fail', handleId, err)
           })

package/src/session.ts

@@ -1,10 +1,16 @@
 import * as rxjs from "rxjs"
-import { JanusError, JanusRequest } from "./types.js"
+import { JanusMessage, JanusRequest } from "./types.js"
 import { request } from "./util.js"
 
-export function createSession(client: { requestSubject: rxjs.Subject<JanusRequest> }, { keepAliveInterval = 45_000 }: {
-  keepAliveInterval?: number
-} = {}) {
+export function createSession(
+  client: {
+    requestSubject: rxjs.Subject<JanusRequest>
+    receive$: rxjs.Observable<JanusMessage>
+  },
+  { keepAliveInterval = 45_000 }: {
+    keepAliveInterval?: number
+  } = {}
+) {
   return request<{ data: { id: number } }>(client.requestSubject, { janus: 'create' }).pipe(
     rxjs.map(({ data: { id: sessionId } }) => {
       const requestSubject = new rxjs.Subject<JanusRequest>()
@@ -15,15 +21,21 @@ export function createSession(client: { requestSubject: rxjs.Subject<JanusReques
             request.message.session_id = sessionId
             client.requestSubject.next(request)
             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<JanusError>(subscriber =>
+                new rxjs.Observable<Error>(subscriber =>
                   client.requestSubject.next({
                     message: { janus: "keepalive", session_id: sessionId },
+                    stacktrace: new Error(),
                     fulfill() {
                       subscriber.complete()
                     },
@@ -35,11 +47,13 @@ export function createSession(client: { requestSubject: rxjs.Subject<JanusReques
                 )
               )
             )
-          )
+          ),
+          rxjs.share()
         ),
         destroy() {
           client.requestSubject.next({
             message: { janus: 'destroy' },
+            stacktrace: new Error(),
             fulfill: rxjs.noop,
             reject: err => console.error('JanusSession destroy fail', sessionId, err)
           })

package/src/types.ts

@@ -1,12 +1,9 @@
 
 export type JanusMessage = Record<string, unknown>
 
-export class JanusError {
-  constructor(readonly code: number, readonly reason: string) {}
-}
-
 export interface JanusRequest {
   readonly message: JanusMessage
+  readonly stacktrace: Error
   fulfill(response: JanusMessage): void
-  reject(err: JanusError): void
+  reject(err: Error): void
 }

package/src/util.ts

@@ -5,9 +5,11 @@ export function request<T extends JanusMessage>(
   requestSubject: rxjs.Subject<JanusRequest>,
   message: JanusMessage
 ) {
+  const stacktrace = new Error()
   return new rxjs.Observable<T>(subscriber =>
     requestSubject.next({
       message,
+      stacktrace,
       fulfill(response) {
         subscriber.next(response as T)
         subscriber.complete()
@@ -18,3 +20,10 @@ export function request<T extends JanusMessage>(
     })
   )
 }
+
+export function makeJanusError({ stacktrace, message }: JanusRequest, code: number, reason: string) {
+  stacktrace.name = 'JanusError'
+  stacktrace.cause = message
+  stacktrace.message = reason
+  return Object.assign(stacktrace, { code })
+}