@lsdsoftware/janus-client-node 1.0.1 → 1.0.2

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<Error>;
-    receive$: rxjs.Observable<Error | JanusMessage>;
+    receive$: rxjs.Observable<unknown>;
     close$: rxjs.Observable<import("ws").default.CloseEvent>;
     close: (code?: number, data?: string | Buffer) => void;
 }>;

package/dist/client.js

@@ -1,11 +1,11 @@
 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 => {
@@ -13,12 +13,21 @@ export function createClient(websocketUrl, websocketOpts) {
                 request.message.transaction = txId;
                 return new rxjs.Observable(subscriber => conn.send(JSON.stringify(request.message), err => {
                     if (err) {
-                        subscriber.next(new Error('JanusClient sendMessage fail', { cause: err }));
+                        subscriber.next(err);
                         subscriber.complete();
                     }
                     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);
+                            }
+                        });
                     }
                 }));
             }), rxjs.share()),
@@ -30,16 +39,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 {
@@ -50,7 +52,7 @@ 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 }));
+                    return rxjs.of(err);
                 }
             }), 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.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);
@@ -32,6 +32,7 @@ export function createPluginHandle(session, plugin) {
             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.js

@@ -12,6 +12,7 @@ export function createSession(client, { keepAliveInterval = 45_000 } = {}) {
             })),
             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();
                 },
@@ -23,6 +24,7 @@ export function createSession(client, { keepAliveInterval = 45_000 } = {}) {
             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,10 @@
 export type JanusMessage = Record<string, unknown>;
-export declare class JanusError {
-    readonly code: number;
-    readonly reason: string;
-    constructor(code: number, reason: string);
-}
+export type JanusError = Error & {
+    code: number;
+};
 export interface JanusRequest {
     readonly message: JanusMessage;
+    readonly stacktrace: Error;
     fulfill(response: JanusMessage): void;
     reject(err: JanusError): 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,4 @@
 import * as rxjs from "rxjs";
-import { JanusMessage, JanusRequest } from "./types.js";
+import { JanusError, 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): JanusError;

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.2",
   "description": "Janus WebSocket client for Node, built on RxJS observables",
   "keywords": [
     "janus",

package/src/client.ts

@@ -3,13 +3,14 @@ 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(
@@ -19,11 +20,19 @@ export function createClient(websocketUrl: string, websocketOpts?: ClientOptions
             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.next(err)
                   subscriber.complete()
                 } else {
                   subscriber.complete()
-                  pendingRequests.set(txId, request)
+                  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)
+                    }
+                  })
                 }
               })
             )
@@ -38,15 +47,9 @@ 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')
@@ -54,7 +57,7 @@ export function createClient(websocketUrl: string, websocketOpts?: ClientOptions
               }
             } catch (err) {
               if (err instanceof Error) err.cause = event.data
-              return rxjs.of(new Error('JanusClient processMessage fail', { cause: err }))
+              return rxjs.of(err)
             }
           }),
           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,6 +1,6 @@
 import * as rxjs from "rxjs"
-import { JanusError, JanusRequest } from "./types.js"
-import { request } from "./util.js"
+import { JanusRequest } from "./types.js"
+import { makeJanusError, request } from "./util.js"
 
 export function createPluginHandle(session: { requestSubject: rxjs.Subject<JanusRequest> }, plugin: string) {
   return request<{ data: { id: number } }>(session.requestSubject, { janus: "attach", plugin }).pipe(
@@ -16,11 +16,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)
                 }
@@ -35,6 +36,7 @@ export function createPluginHandle(session: { requestSubject: rxjs.Subject<Janus
         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

@@ -24,6 +24,7 @@ export function createSession(client: { requestSubject: rxjs.Subject<JanusReques
                 new rxjs.Observable<JanusError>(subscriber =>
                   client.requestSubject.next({
                     message: { janus: "keepalive", session_id: sessionId },
+                    stacktrace: new Error(),
                     fulfill() {
                       subscriber.complete()
                     },
@@ -40,6 +41,7 @@ export function createSession(client: { requestSubject: rxjs.Subject<JanusReques
         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,11 @@
 
 export type JanusMessage = Record<string, unknown>
 
-export class JanusError {
-  constructor(readonly code: number, readonly reason: string) {}
-}
+export type JanusError = Error & { code: number }
 
 export interface JanusRequest {
   readonly message: JanusMessage
+  readonly stacktrace: Error
   fulfill(response: JanusMessage): void
   reject(err: JanusError): void
 }

package/src/util.ts

@@ -1,13 +1,15 @@
 import * as rxjs from "rxjs"
-import { JanusMessage, JanusRequest } from "./types.js"
+import { JanusError, JanusMessage, JanusRequest } from "./types.js"
 
 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): JanusError {
+  stacktrace.name = 'JanusError'
+  stacktrace.cause = message
+  stacktrace.message = reason
+  return Object.assign(stacktrace, { code })
+}