@codiac.io/codiac-cli 1.2.157 → 1.2.165

package/lib/relay/wsclient/relay-socket-listener.d.ts

@@ -1,68 +1,68 @@
-import { interfaces } from "inversify";
-import { IBetterLogger } from "@codiac.io/codiac-common";
-import { SocketActionHandler } from './socket-contracts';
-/** Configuration for the relay web socket client
- * (ie: duplex comms with the relay via Websocket)  */
-export declare class RelaySocketListenerSettings {
-    constructor();
-    /** Fully qualified url of the target web socket service. */
-    url?: string | undefined;
-    /** The pause in mmilliseconds to wait after a connection failure before attempting to reconnect.  */
-    reconnectIntervalMs?: number | undefined;
-    /** The number of retries on a failed connection before throwing exception. */
-    reconnectAttempts?: number | undefined;
-}
-/**
- * **USAGE:**
- *
- * At bootstrap time...
- * ```
- * RelaySocketListenerService.bootstrap(ioc, { reconnectIntervalMs: 2000 });
- * ```
- * At ctor injection...
- * ```
- * export class MyClass {
- *  constructor(@inject(RelaySocketListener) private socket: RelaySocketListener) { ... }
- *
- *  public doSomething() {
- *    // wire up a msg handler...
- *    this.socket.listenFor("MyAction", msg => {
- *      console.log(`I just got a ${msg.action}, with cid: ${msg.correlationId}`);
- *    });
- *
- *    // Start listening (if its not already)
- *    this.socket.start();
- *  }
- * }
- * ```
- */
-export declare class RelaySocketListener {
-    private logger;
-    static bootstrap(ioc: interfaces.Container, settings?: RelaySocketListenerSettings | undefined): void;
-    static readonly DEFAULT_SETTINGS: Required<RelaySocketListenerSettings>;
-    constructor(settings: RelaySocketListenerSettings, logger: IBetterLogger);
-    private readonly settings;
-    private rxWebsocketSubject;
-    /** Connects and initiates the listeners.
-     * Returns the SocketId.
-     * (IDEMPOTENT) Lazy-start: this method wont duplicate connections if it's already connected to the remote websocket server.
-     */
-    start(): Promise<string>;
-    /** (IDEMPOTENT) Lazy-stop: this method can be called even if the (one-and-only) socket is already closed. */
-    stop(): void;
-    /** Late-bound subscribers to incoming messages, mapped by `SocketAction.action`.
-     *
-     * If multiple handlers are registered for a given action,
-     * they get fired in order they subscribed (first-come first served).
-     */
-    private subscribers;
-    /** Returns the subscription id for the handler (reqd for unsubcribing).
-     */
-    listenFor(action: string, handler: SocketActionHandler): string;
-    /** Removes the given listener.  (IDEMPOTENT) Returns whether a handler was indeed removed (false if it didn't exist).
-     *
-     * Throws any exceptions. */
-    unlisten(action: string, subscriptionId: string): boolean;
-    /** Fires any registered handlers. */
-    private routeInboundMessage;
-}
+import { interfaces } from "inversify";
+import { IBetterLogger } from "@codiac.io/codiac-common";
+import { SocketActionHandler } from './socket-contracts';
+/** Configuration for the relay web socket client
+ * (ie: duplex comms with the relay via Websocket)  */
+export declare class RelaySocketListenerSettings {
+    constructor();
+    /** Fully qualified url of the target web socket service. */
+    url?: string | undefined;
+    /** The pause in mmilliseconds to wait after a connection failure before attempting to reconnect.  */
+    reconnectIntervalMs?: number | undefined;
+    /** The number of retries on a failed connection before throwing exception. */
+    reconnectAttempts?: number | undefined;
+}
+/**
+ * **USAGE:**
+ *
+ * At bootstrap time...
+ * ```
+ * RelaySocketListenerService.bootstrap(ioc, { reconnectIntervalMs: 2000 });
+ * ```
+ * At ctor injection...
+ * ```
+ * export class MyClass {
+ *  constructor(@inject(RelaySocketListener) private socket: RelaySocketListener) { ... }
+ *
+ *  public doSomething() {
+ *    // wire up a msg handler...
+ *    this.socket.listenFor("MyAction", msg => {
+ *      console.log(`I just got a ${msg.action}, with cid: ${msg.correlationId}`);
+ *    });
+ *
+ *    // Start listening (if its not already)
+ *    this.socket.start();
+ *  }
+ * }
+ * ```
+ */
+export declare class RelaySocketListener {
+    private logger;
+    static bootstrap(ioc: interfaces.Container, settings?: RelaySocketListenerSettings | undefined): void;
+    static readonly DEFAULT_SETTINGS: Required<RelaySocketListenerSettings>;
+    constructor(settings: RelaySocketListenerSettings, logger: IBetterLogger);
+    private readonly settings;
+    private rxWebsocketSubject;
+    /** Connects and initiates the listeners.
+     * Returns the SocketId.
+     * (IDEMPOTENT) Lazy-start: this method wont duplicate connections if it's already connected to the remote websocket server.
+     */
+    start(): Promise<string>;
+    /** (IDEMPOTENT) Lazy-stop: this method can be called even if the (one-and-only) socket is already closed. */
+    stop(): void;
+    /** Late-bound subscribers to incoming messages, mapped by `SocketAction.action`.
+     *
+     * If multiple handlers are registered for a given action,
+     * they get fired in order they subscribed (first-come first served).
+     */
+    private subscribers;
+    /** Returns the subscription id for the handler (reqd for unsubcribing).
+     */
+    listenFor(action: string, handler: SocketActionHandler): string;
+    /** Removes the given listener.  (IDEMPOTENT) Returns whether a handler was indeed removed (false if it didn't exist).
+     *
+     * Throws any exceptions. */
+    unlisten(action: string, subscriptionId: string): boolean;
+    /** Fires any registered handlers. */
+    private routeInboundMessage;
+}

package/lib/relay/wsclient/relay-socket-listener.js

@@ -1,165 +1,165 @@
-"use strict";
-var RelaySocketListener_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelaySocketListener = exports.RelaySocketListenerSettings = void 0;
-const tslib_1 = require("tslib");
-const inversify_1 = require("inversify");
-const _ = require("lodash");
-const guid_typescript_1 = require("guid-typescript");
-const stringify = require("json-stringify-safe");
-const codiac_common_1 = require("@codiac.io/codiac-common");
-const rx_websocket_subject_1 = require("./rx-websocket-subject");
-/** Configuration for the relay web socket client
- * (ie: duplex comms with the relay via Websocket)  */
-let RelaySocketListenerSettings = class RelaySocketListenerSettings {
-    constructor() { }
-};
-RelaySocketListenerSettings = tslib_1.__decorate([
-    (0, inversify_1.injectable)(),
-    tslib_1.__metadata("design:paramtypes", [])
-], RelaySocketListenerSettings);
-exports.RelaySocketListenerSettings = RelaySocketListenerSettings;
-/** Meta added to a message handler for facility in managing message subscribers. */
-class HandlerSubx {
-    constructor(id, handler) {
-        this.id = id;
-        this.handler = handler;
-    }
-}
-/**
- * **USAGE:**
- *
- * At bootstrap time...
- * ```
- * RelaySocketListenerService.bootstrap(ioc, { reconnectIntervalMs: 2000 });
- * ```
- * At ctor injection...
- * ```
- * export class MyClass {
- *  constructor(@inject(RelaySocketListener) private socket: RelaySocketListener) { ... }
- *
- *  public doSomething() {
- *    // wire up a msg handler...
- *    this.socket.listenFor("MyAction", msg => {
- *      console.log(`I just got a ${msg.action}, with cid: ${msg.correlationId}`);
- *    });
- *
- *    // Start listening (if its not already)
- *    this.socket.start();
- *  }
- * }
- * ```
- */
-let RelaySocketListener = RelaySocketListener_1 = class RelaySocketListener {
-    static bootstrap(ioc, settings) {
-        ioc.bind(RelaySocketListenerSettings).toConstantValue(settings !== null && settings !== void 0 ? settings : {});
-        ioc.bind(RelaySocketListener_1).toSelf().inSingletonScope(); // <-- There can be only one socket connection from the CLI.
-    }
-    constructor(settings, logger) {
-        this.logger = logger;
-        /** Fires any registered handlers. */
-        this.routeInboundMessage = (msg) => {
-            var _a, _b;
-            if (msg.action) {
-                let actionMsg = msg;
-                let subxs = this.subscribers[actionMsg.action];
-                if (subxs && subxs.length > 0) {
-                    for (let subx of subxs) {
-                        try {
-                            this.logger.debug(`Handling inbound [${actionMsg.action}] SocketAction [handler id: ${subx.id}]...`);
-                            /* TODO: await */ subx.handler(actionMsg);
-                        }
-                        catch (err) {
-                            this.logger.error(`Unhandled error in [${actionMsg.action}] SocketAction handler [id: ${subx.id}]: ${(_a = err.name) !== null && _a !== void 0 ? _a : ""} ${(_b = err.message) !== null && _b !== void 0 ? _b : "(No details available)"}`);
-                        }
-                    }
-                }
-                else {
-                    this.logger.warn(`Received unhandled [${actionMsg.action}] message from [${this.settings.url}];`);
-                }
-            }
-            else {
-                this.logger.warn(`Received unrecognized WebSocket message.`, stringify(msg));
-            }
-            return msg; // <--- Do we need to return this?
-        };
-        this.settings = _.assignIn({}, RelaySocketListener_1.DEFAULT_SETTINGS, settings);
-        this.subscribers = {};
-    }
-    /** Connects and initiates the listeners.
-     * Returns the SocketId.
-     * (IDEMPOTENT) Lazy-start: this method wont duplicate connections if it's already connected to the remote websocket server.
-     */
-    start() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                // if (this.rxWebsocketSubject?.connectionStatus !== connected) {
-                if (this.rxWebsocketSubject == undefined) {
-                    this.rxWebsocketSubject = new rx_websocket_subject_1.RxWebsocketSubject(this.settings.url, this.settings.reconnectIntervalMs, this.settings.reconnectAttempts, this.routeInboundMessage, this.logger);
-                }
-                this.rxWebsocketSubject.onSocketConnection((err, socketId) => {
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        resolve(socketId);
-                    }
-                });
-                this.rxWebsocketSubject.connect();
-                this.rxWebsocketSubject.subscribe();
-                // }
-                // How do we observe the connection status and return the socketId once connected?
-                // resolve("fakeSocketId-123-345");
-            }));
-        });
-    }
-    /** (IDEMPOTENT) Lazy-stop: this method can be called even if the (one-and-only) socket is already closed. */
-    stop() {
-        if (this.rxWebsocketSubject) {
-            if (this.rxWebsocketSubject.closed !== true /* .isStopped ? */) {
-                this.rxWebsocketSubject.complete(); // Is this right?
-            }
-        }
-    }
-    /** Returns the subscription id for the handler (reqd for unsubcribing).
-     */
-    listenFor(action, handler) {
-        if (this.subscribers[action] == undefined) {
-            this.subscribers[action] = [];
-        }
-        let subx = {
-            id: guid_typescript_1.Guid.create().toString(),
-            handler: handler
-        };
-        this.subscribers[action].push(subx);
-        return subx.id;
-    }
-    /** Removes the given listener.  (IDEMPOTENT) Returns whether a handler was indeed removed (false if it didn't exist).
-     *
-     * Throws any exceptions. */
-    unlisten(action, subscriptionId) {
-        let existings = this.subscribers[action];
-        if (existings && existings.length > 0) {
-            let removed = _.remove(existings, x => x.id === subscriptionId);
-            return Boolean(removed.length > 0);
-        }
-        else {
-            return false;
-        }
-    }
-};
-RelaySocketListener.DEFAULT_SETTINGS = {
-    url: "ws://localhost:5798",
-    reconnectIntervalMs: 2000,
-    /** Deliberately kept short because the retry is limited to a single cli command execution,
-     * not an ongoing user session (thus it needs to fail fast).  */
-    reconnectAttempts: 5
-};
-RelaySocketListener = RelaySocketListener_1 = tslib_1.__decorate([
-    (0, inversify_1.injectable)(),
-    tslib_1.__param(0, (0, inversify_1.inject)(RelaySocketListenerSettings)),
-    tslib_1.__param(1, (0, inversify_1.inject)(codiac_common_1.INTERFACES.IBetterLogger)),
-    tslib_1.__metadata("design:paramtypes", [RelaySocketListenerSettings, Object])
-], RelaySocketListener);
-exports.RelaySocketListener = RelaySocketListener;
+"use strict";
+var RelaySocketListener_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelaySocketListener = exports.RelaySocketListenerSettings = void 0;
+const tslib_1 = require("tslib");
+const inversify_1 = require("inversify");
+const _ = require("lodash");
+const guid_typescript_1 = require("guid-typescript");
+const stringify = require("json-stringify-safe");
+const codiac_common_1 = require("@codiac.io/codiac-common");
+const rx_websocket_subject_1 = require("./rx-websocket-subject");
+/** Configuration for the relay web socket client
+ * (ie: duplex comms with the relay via Websocket)  */
+let RelaySocketListenerSettings = class RelaySocketListenerSettings {
+    constructor() { }
+};
+RelaySocketListenerSettings = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    tslib_1.__metadata("design:paramtypes", [])
+], RelaySocketListenerSettings);
+exports.RelaySocketListenerSettings = RelaySocketListenerSettings;
+/** Meta added to a message handler for facility in managing message subscribers. */
+class HandlerSubx {
+    constructor(id, handler) {
+        this.id = id;
+        this.handler = handler;
+    }
+}
+/**
+ * **USAGE:**
+ *
+ * At bootstrap time...
+ * ```
+ * RelaySocketListenerService.bootstrap(ioc, { reconnectIntervalMs: 2000 });
+ * ```
+ * At ctor injection...
+ * ```
+ * export class MyClass {
+ *  constructor(@inject(RelaySocketListener) private socket: RelaySocketListener) { ... }
+ *
+ *  public doSomething() {
+ *    // wire up a msg handler...
+ *    this.socket.listenFor("MyAction", msg => {
+ *      console.log(`I just got a ${msg.action}, with cid: ${msg.correlationId}`);
+ *    });
+ *
+ *    // Start listening (if its not already)
+ *    this.socket.start();
+ *  }
+ * }
+ * ```
+ */
+let RelaySocketListener = RelaySocketListener_1 = class RelaySocketListener {
+    static bootstrap(ioc, settings) {
+        ioc.bind(RelaySocketListenerSettings).toConstantValue(settings !== null && settings !== void 0 ? settings : {});
+        ioc.bind(RelaySocketListener_1).toSelf().inSingletonScope(); // <-- There can be only one socket connection from the CLI.
+    }
+    constructor(settings, logger) {
+        this.logger = logger;
+        /** Fires any registered handlers. */
+        this.routeInboundMessage = (msg) => {
+            var _a, _b;
+            if (msg.action) {
+                let actionMsg = msg;
+                let subxs = this.subscribers[actionMsg.action];
+                if (subxs && subxs.length > 0) {
+                    for (let subx of subxs) {
+                        try {
+                            this.logger.debug(`Handling inbound [${actionMsg.action}] SocketAction [handler id: ${subx.id}]...`);
+                            /* TODO: await */ subx.handler(actionMsg);
+                        }
+                        catch (err) {
+                            this.logger.error(`Unhandled error in [${actionMsg.action}] SocketAction handler [id: ${subx.id}]: ${(_a = err.name) !== null && _a !== void 0 ? _a : ""} ${(_b = err.message) !== null && _b !== void 0 ? _b : "(No details available)"}`);
+                        }
+                    }
+                }
+                else {
+                    this.logger.warn(`Received unhandled [${actionMsg.action}] message from [${this.settings.url}];`);
+                }
+            }
+            else {
+                this.logger.warn(`Received unrecognized WebSocket message.`, stringify(msg));
+            }
+            return msg; // <--- Do we need to return this?
+        };
+        this.settings = _.assignIn({}, RelaySocketListener_1.DEFAULT_SETTINGS, settings);
+        this.subscribers = {};
+    }
+    /** Connects and initiates the listeners.
+     * Returns the SocketId.
+     * (IDEMPOTENT) Lazy-start: this method wont duplicate connections if it's already connected to the remote websocket server.
+     */
+    start() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                // if (this.rxWebsocketSubject?.connectionStatus !== connected) {
+                if (this.rxWebsocketSubject == undefined) {
+                    this.rxWebsocketSubject = new rx_websocket_subject_1.RxWebsocketSubject(this.settings.url, this.settings.reconnectIntervalMs, this.settings.reconnectAttempts, this.routeInboundMessage, this.logger);
+                }
+                this.rxWebsocketSubject.onSocketConnection((err, socketId) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(socketId);
+                    }
+                });
+                this.rxWebsocketSubject.connect();
+                this.rxWebsocketSubject.subscribe();
+                // }
+                // How do we observe the connection status and return the socketId once connected?
+                // resolve("fakeSocketId-123-345");
+            }));
+        });
+    }
+    /** (IDEMPOTENT) Lazy-stop: this method can be called even if the (one-and-only) socket is already closed. */
+    stop() {
+        if (this.rxWebsocketSubject) {
+            if (this.rxWebsocketSubject.closed !== true /* .isStopped ? */) {
+                this.rxWebsocketSubject.complete(); // Is this right?
+            }
+        }
+    }
+    /** Returns the subscription id for the handler (reqd for unsubcribing).
+     */
+    listenFor(action, handler) {
+        if (this.subscribers[action] == undefined) {
+            this.subscribers[action] = [];
+        }
+        let subx = {
+            id: guid_typescript_1.Guid.create().toString(),
+            handler: handler
+        };
+        this.subscribers[action].push(subx);
+        return subx.id;
+    }
+    /** Removes the given listener.  (IDEMPOTENT) Returns whether a handler was indeed removed (false if it didn't exist).
+     *
+     * Throws any exceptions. */
+    unlisten(action, subscriptionId) {
+        let existings = this.subscribers[action];
+        if (existings && existings.length > 0) {
+            let removed = _.remove(existings, x => x.id === subscriptionId);
+            return Boolean(removed.length > 0);
+        }
+        else {
+            return false;
+        }
+    }
+};
+RelaySocketListener.DEFAULT_SETTINGS = {
+    url: "ws://localhost:5798",
+    reconnectIntervalMs: 2000,
+    /** Deliberately kept short because the retry is limited to a single cli command execution,
+     * not an ongoing user session (thus it needs to fail fast).  */
+    reconnectAttempts: 5
+};
+RelaySocketListener = RelaySocketListener_1 = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    tslib_1.__param(0, (0, inversify_1.inject)(RelaySocketListenerSettings)),
+    tslib_1.__param(1, (0, inversify_1.inject)(codiac_common_1.INTERFACES.IBetterLogger)),
+    tslib_1.__metadata("design:paramtypes", [RelaySocketListenerSettings, Object])
+], RelaySocketListener);
+exports.RelaySocketListener = RelaySocketListener;
 //# sourceMappingURL=relay-socket-listener.js.map

package/lib/relay/wsclient/relay-websocket-client.d.ts

@@ -1,33 +1,33 @@
-import { IBetterLogger } from "@codiac.io/codiac-common";
-import { interfaces } from "inversify";
-import { RelaySocketListenerSettings } from "./relay-socket-listener";
-import { SocketActionHandler } from './socket-contracts';
-import { ApiUserCreds } from "../../apis/codiac-api/common/api-user-creds";
-export declare class RelayWebsocketClient {
-    private credentials;
-    private logger;
-    static bootstrap(ioc: interfaces.Container, settings?: RelaySocketListenerSettings | undefined): void;
-    static readonly DEFAULT_SETTINGS: Required<RelaySocketListenerSettings>;
-    constructor(credentials: ApiUserCreds, settings: RelaySocketListenerSettings, logger: IBetterLogger);
-    private readonly settings;
-    private socket;
-    open(): Promise<string>;
-    close(): Promise<void>;
-    /** Late-bound subscribers to incoming messages, mapped by `SocketAction.action`.
-   *
-   * If multiple handlers are registered for a given action,
-   * they get fired in order they subscribed (first-come first served).
-   */
-    private subscribers;
-    /** Returns the subscription id for the handler (reqd for unsubcribing).
-     */
-    listenFor(action: string, handler: SocketActionHandler): string;
-    /** Removes the given listener.  (IDEMPOTENT) Returns whether a handler was indeed removed (false if it didn't exist).
-     *
-     * Throws any exceptions. */
-    unlisten(action: string, subscriptionId: string): boolean;
-    /** Fires any registered handlers.
-     * (and doesnt wait for them).
-    */
-    private routeInboundMessage;
-}
+import { IBetterLogger } from "@codiac.io/codiac-common";
+import { interfaces } from "inversify";
+import { RelaySocketListenerSettings } from "./relay-socket-listener";
+import { SocketActionHandler } from './socket-contracts';
+import { ApiUserCreds } from "../../apis/codiac-api/common/api-user-creds";
+export declare class RelayWebsocketClient {
+    private credentials;
+    private logger;
+    static bootstrap(ioc: interfaces.Container, settings?: RelaySocketListenerSettings | undefined): void;
+    static readonly DEFAULT_SETTINGS: Required<RelaySocketListenerSettings>;
+    constructor(credentials: ApiUserCreds, settings: RelaySocketListenerSettings, logger: IBetterLogger);
+    private readonly settings;
+    private socket;
+    open(): Promise<string>;
+    close(): Promise<void>;
+    /** Late-bound subscribers to incoming messages, mapped by `SocketAction.action`.
+   *
+   * If multiple handlers are registered for a given action,
+   * they get fired in order they subscribed (first-come first served).
+   */
+    private subscribers;
+    /** Returns the subscription id for the handler (reqd for unsubcribing).
+     */
+    listenFor(action: string, handler: SocketActionHandler): string;
+    /** Removes the given listener.  (IDEMPOTENT) Returns whether a handler was indeed removed (false if it didn't exist).
+     *
+     * Throws any exceptions. */
+    unlisten(action: string, subscriptionId: string): boolean;
+    /** Fires any registered handlers.
+     * (and doesnt wait for them).
+    */
+    private routeInboundMessage;
+}