@openfin/core 31.74.22 → 31.74.23

package/src/transport/transport.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Transport_wire;
+var _Transport_wire, _Transport_fin;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Transport = void 0;
 const events_1 = require("events");
@@ -18,6 +18,7 @@ const wire_1 = require("./wire");
 const transport_errors_1 = require("./transport-errors");
 const eventAggregator_1 = require("../api/events/eventAggregator");
 const me_1 = require("../api/me");
+const errors_1 = require("../util/errors");
 class Transport extends events_1.EventEmitter {
     constructor(WireType, environment, config) {
         super();
@@ -26,6 +27,8 @@ class Transport extends events_1.EventEmitter {
         this.eventAggregator = new eventAggregator_1.default();
         this.messageHandlers = [this.eventAggregator.dispatchEvent];
         _Transport_wire.set(this, void 0);
+        // Typing as unknown to avoid circular dependency, should not be used directly.
+        _Transport_fin.set(this, void 0);
         this.connectSync = () => {
             const wire = __classPrivateFieldGet(this, _Transport_wire, "f");
             wire.connectSync();
@@ -40,8 +43,8 @@ class Transport extends events_1.EventEmitter {
         this.sendRaw = __classPrivateFieldGet(this, _Transport_wire, "f").send.bind(__classPrivateFieldGet(this, _Transport_wire, "f"));
         this.registerMessageHandler(this.handleMessage.bind(this));
         __classPrivateFieldGet(this, _Transport_wire, "f").on('disconnected', () => {
-            for (const [, { reject }] of this.wireListeners) {
-                reject('Remote connection has closed');
+            for (const [, { handleNack }] of this.wireListeners) {
+                handleNack({ reason: 'Remote connection has closed' });
             }
             this.wireListeners.clear();
             this.emit('disconnected');
@@ -50,6 +53,18 @@ class Transport extends events_1.EventEmitter {
         const entityType = this.environment.getCurrentEntityType();
         this.me = (0, me_1.getBaseMe)(entityType, uuid, name);
     }
+    getFin() {
+        if (!__classPrivateFieldGet(this, _Transport_fin, "f")) {
+            throw new Error("No Fin object registered for this transport");
+        }
+        return __classPrivateFieldGet(this, _Transport_fin, "f");
+    }
+    registerFin(_fin) {
+        if (__classPrivateFieldGet(this, _Transport_fin, "f")) {
+            throw new Error("Fin object has already been registered for this transport");
+        }
+        __classPrivateFieldSet(this, _Transport_fin, _fin, "f");
+    }
     shutdown() {
         const wire = __classPrivateFieldGet(this, _Transport_wire, "f");
         return wire.shutdown();
@@ -95,20 +110,33 @@ class Transport extends events_1.EventEmitter {
             throw new transport_errors_1.RuntimeError(requestAuthRet.payload);
         }
     }
-    sendAction(action, payload = {}, uncorrelated = false
-    // specialResponse type is only used for 'requestAuthorization'
-    ) {
-        return new Promise((resolve, reject) => {
-            const id = this.environment.getNextMessageId();
+    sendAction(action, payload = {}, uncorrelated = false) {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        let cancel = () => { };
+        // We want the callsite from the caller of this function, not from here.
+        const callSites = transport_errors_1.RuntimeError.getCallSite(1);
+        const prom = new Promise((resolve, reject) => {
+            cancel = reject;
+            const messageId = this.environment.getNextMessageId();
             const msg = {
                 action,
                 payload,
-                messageId: id
+                messageId
             };
             const wire = __classPrivateFieldGet(this, _Transport_wire, "f");
-            this.addWireListener(id, resolve, reject, uncorrelated);
+            this.addWireListener(messageId, resolve, (payload) => this.nackHandler(payload, reject, callSites), uncorrelated);
             return wire.send(msg).catch(reject);
         });
+        return Object.assign(prom, { cancel });
+    }
+    nackHandler(payloadOrMessage, reject, callSites) {
+        if (typeof payloadOrMessage === 'string') {
+            // NOTE: this is for backwards compatibility to support plain string rejections
+            reject(payloadOrMessage);
+        }
+        else {
+            reject(new transport_errors_1.RuntimeError(payloadOrMessage, callSites));
+        }
     }
     ferryAction(origData) {
         return new Promise((resolve, reject) => {
@@ -120,22 +148,22 @@ class Transport extends events_1.EventEmitter {
             const wire = __classPrivateFieldGet(this, _Transport_wire, "f");
             return wire
                 .send(origData)
-                .then(() => this.addWireListener(id, resolver, reject, false))
+                .then(() => this.addWireListener(id, resolver, (payload) => this.nackHandler(payload, reject), false))
                 .catch(reject);
         });
     }
     registerMessageHandler(handler) {
         this.messageHandlers.push(handler);
     }
-    addWireListener(id, resolve, reject, uncorrelated) {
+    addWireListener(id, resolve, handleNack, uncorrelated) {
         if (uncorrelated) {
             this.uncorrelatedListener = resolve;
         }
         else if (this.wireListeners.has(id)) {
-            reject(new transport_errors_1.DuplicateCorrelationError(String(id)));
+            handleNack({ reason: 'Duplicate handler id', error: (0, errors_1.errorToPOJO)(new transport_errors_1.DuplicateCorrelationError(String(id))) });
         }
         else {
-            this.wireListeners.set(id, { resolve, reject });
+            this.wireListeners.set(id, { resolve, handleNack });
         }
         // Timeout and reject()?
     }
@@ -161,23 +189,23 @@ class Transport extends events_1.EventEmitter {
         else {
             // We just checked for existence above
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const { resolve, reject } = this.wireListeners.get(id);
+            const { resolve, handleNack } = this.wireListeners.get(id);
             if (data.action !== 'ack') {
-                reject(new transport_errors_1.NoAckError(data.action));
+                handleNack({ reason: 'Did not receive ack action', error: (0, errors_1.errorToPOJO)(new transport_errors_1.NoAckError(data.action)) });
             }
             else if (!('payload' in data)) {
                 // I'm not sure when this code would actually run, but passing in something that doeesn't have a reason to the runtimeerror constructor will not end well.
                 // @ts-expect-error
                 if (typeof data.reason === 'string') {
-                    reject(new transport_errors_1.RuntimeError(data));
+                    handleNack(data);
                 }
                 else {
                     console.warn('Received invalid response from core', data);
-                    reject(new Error('Invalid response'));
+                    handleNack({ reason: 'invalid response shape' });
                 }
             }
             else if (!data.payload.success) {
-                reject(new transport_errors_1.RuntimeError(data.payload));
+                handleNack(data.payload);
             }
             else {
                 resolve.call(null, data);
@@ -188,4 +216,4 @@ class Transport extends events_1.EventEmitter {
     }
 }
 exports.Transport = Transport;
-_Transport_wire = new WeakMap();
+_Transport_wire = new WeakMap(), _Transport_fin = new WeakMap();

package/src/util/channel-api-relay.d.ts

@@ -0,0 +1,13 @@
+import type * as OpenFin from '../OpenFin';
+/**
+ * @internal
+ * Create a channel relay for a given channel exposition, allowing a single provider to route
+ * actions to the designated clients.
+ *
+ * Designed to be used in conjunction with @expose
+ *
+ * @param channelProvider The channel provider to relay the actions on.
+ * @param config Determines which actions to relay. Please ensure action prefix matches the exposed api.
+ */
+export declare const relayChannelClientApi: (channelProvider: OpenFin.ChannelProvider, relayId: string) => Promise<void>;
+export declare const createRelayedDispatch: (client: OpenFin.ChannelClient, target: OpenFin.Identity, relayId: string, relayErrorMsg?: string) => OpenFin.ChannelClient['dispatch'];

package/src/util/channel-api-relay.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRelayedDispatch = exports.relayChannelClientApi = void 0;
+const EXPECTED_ERRORS = [
+    'no longer connected',
+    'RTCDataChannel closed unexpectedly',
+    'The client you are trying to dispatch from is disconnected from the target provider',
+];
+// Checks possible error messages that we want to trap, client error message can originate
+// from ChannelProvider::dispatch OR ClassicStrategy::closeEndpoint OR RTCEndPoint::dataChannel::onclose
+const isDisconnectedError = (errorMsg) => {
+    return EXPECTED_ERRORS.some(e => errorMsg.includes(e));
+};
+/**
+ * @internal
+ * Create a channel relay for a given channel exposition, allowing a single provider to route
+ * actions to the designated clients.
+ *
+ * Designed to be used in conjunction with @expose
+ *
+ * @param channelProvider The channel provider to relay the actions on.
+ * @param config Determines which actions to relay. Please ensure action prefix matches the exposed api.
+ */
+const relayChannelClientApi = async (channelProvider, relayId) => {
+    channelProvider.register(`relay:${relayId}`, ({ action, target, payload }) => {
+        return channelProvider.dispatch(target, action, payload);
+    });
+    await Promise.resolve();
+};
+exports.relayChannelClientApi = relayChannelClientApi;
+const createRelayedDispatch = (client, target, relayId, relayErrorMsg) => async (action, payload) => {
+    try {
+        return await client.dispatch(`relay:${relayId}`, {
+            action,
+            payload,
+            target
+        });
+    }
+    catch (e) {
+        if (isDisconnectedError(e.message) && relayErrorMsg) {
+            throw new Error(relayErrorMsg);
+        }
+        ;
+        throw e;
+    }
+};
+exports.createRelayedDispatch = createRelayedDispatch;

package/src/util/errors.d.ts

@@ -4,6 +4,7 @@
 export type ErrorPlainObject = {
     stack?: string;
     message: string;
+    name?: string;
     toString(): string;
 };
 export declare function errorToPOJO(error: Error): ErrorPlainObject;

package/src/util/errors.js

@@ -4,6 +4,7 @@ exports.errorToPOJO = void 0;
 function errorToPOJO(error) {
     return {
         stack: error.stack,
+        name: error.name,
         message: error.message,
         toString: error.toString
     };

package/src/util/lazy.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call the producer function once and only once when getValue is called,
+ * returning the resultant value for every subsequent call.
+ */
+export declare class Lazy<T> {
+    private producerFn;
+    constructor(producerFn: () => T);
+    private value;
+    /**
+     * Lazily get the value returned by the producer.
+     * @returns The value returned from the producer function
+     */
+    getValue(): T;
+}
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call asynchronous producer only after `getValue` is called.  If the
+ * deferred code errors, we can try it again by re-calling `getValue` after
+ * the promise rejects.
+ */
+export declare class AsyncRetryableLazy<T> {
+    private producerFn;
+    constructor(producerFn: () => Promise<T>);
+    private promise?;
+    /**
+     * Lazily get the value returned by the async producer.
+     *
+     * @returns The value returned from the producer function
+     */
+    getValue(): Promise<T>;
+}

package/src/util/lazy.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncRetryableLazy = exports.Lazy = void 0;
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call the producer function once and only once when getValue is called,
+ * returning the resultant value for every subsequent call.
+ */
+class Lazy {
+    // eslint-disable-next-line
+    constructor(producerFn) {
+        this.producerFn = producerFn;
+    }
+    /**
+     * Lazily get the value returned by the producer.
+     * @returns The value returned from the producer function
+     */
+    getValue() {
+        if (!this.value) {
+            this.value = this.producerFn();
+        }
+        return this.value;
+    }
+}
+exports.Lazy = Lazy;
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call asynchronous producer only after `getValue` is called.  If the
+ * deferred code errors, we can try it again by re-calling `getValue` after
+ * the promise rejects.
+ */
+class AsyncRetryableLazy {
+    // eslint-disable-next-line
+    constructor(producerFn) {
+        this.producerFn = producerFn;
+    }
+    /**
+     * Lazily get the value returned by the async producer.
+     *
+     * @returns The value returned from the producer function
+     */
+    async getValue() {
+        if (!this.promise) {
+            this.promise = this.producerFn().catch((e) => {
+                delete this.promise;
+                throw e;
+            });
+        }
+        return this.promise;
+    }
+}
+exports.AsyncRetryableLazy = AsyncRetryableLazy;

package/src/util/ref-counter.d.ts

@@ -1,4 +1,4 @@
-export default class RefCoutner {
+export declare class RefCounter {
     topicRefMap: Map<any, any>;
     incRefCount(key: string): number;
     decRefCount(key: string): number;

package/src/util/ref-counter.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-class RefCoutner {
+exports.RefCounter = void 0;
+class RefCounter {
     constructor() {
         this.topicRefMap = new Map();
     }
@@ -48,4 +49,4 @@ class RefCoutner {
         return isLastRef ? lastAction() : nonLastAction();
     }
 }
-exports.default = RefCoutner;
+exports.RefCounter = RefCounter;

package/src/util/reversible-map.d.ts

@@ -0,0 +1,11 @@
+export declare class ReversibleMap<TKey extends string | number | symbol, TValue extends Object | string | number> {
+    private readonly valueToKey;
+    private readonly keyToValue;
+    setUnique: (key: TKey, value: TValue) => void;
+    getKey: (value: TValue) => TKey;
+    getValue(key: TKey): TValue;
+    deleteKey: (key: TKey) => TValue | undefined;
+    deleteValue: (value: TValue) => TKey | undefined;
+    hasKey: (key: TKey) => boolean;
+    hasValue: (value: TValue) => boolean;
+}

package/src/util/reversible-map.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReversibleMap = void 0;
+class ReversibleMap {
+    constructor() {
+        this.valueToKey = new Map();
+        this.keyToValue = new Map();
+        this.setUnique = (key, value) => {
+            if (this.hasKey(key) || this.hasValue(value)) {
+                throw new Error('Key or value already in the map.');
+            }
+            this.keyToValue.set(key, value);
+            this.valueToKey.set(value, key);
+        };
+        this.getKey = (value) => {
+            const existingKey = this.valueToKey.get(value);
+            if (!existingKey) {
+                throw new Error('Value not found in the map.');
+            }
+            return existingKey;
+        };
+        this.deleteKey = (key) => {
+            const value = this.getValue(key);
+            this.keyToValue.delete(key);
+            this.valueToKey.delete(value);
+            return value;
+        };
+        this.deleteValue = (value) => {
+            const key = this.getKey(value);
+            this.keyToValue.delete(key);
+            this.valueToKey.delete(value);
+            return key;
+        };
+        this.hasKey = (key) => {
+            return this.keyToValue.has(key);
+        };
+        this.hasValue = (value) => {
+            return this.valueToKey.has(value);
+        };
+    }
+    getValue(key) {
+        const item = this.keyToValue.get(key);
+        if (!item) {
+            throw new Error('Key not found in the map.');
+        }
+        return item;
+    }
+}
+exports.ReversibleMap = ReversibleMap;

package/src/transport/fin_store.d.ts

@@ -1,4 +0,0 @@
-import Fin from '../api/fin';
-import { Transport } from './transport';
-export declare function registerFin(wire: Transport, fin: Fin): void;
-export declare function getFin(wire: Transport): Fin;

package/src/transport/fin_store.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFin = exports.registerFin = void 0;
-const finMap = new WeakMap();
-function registerFin(wire, fin) {
-    finMap.set(wire, fin);
-}
-exports.registerFin = registerFin;
-function getFin(wire) {
-    const fin = finMap.get(wire);
-    if (!fin) {
-        throw new Error('Could not locate fin api for given transport');
-    }
-    return fin;
-}
-exports.getFin = getFin;