@openfin/core 31.74.31 → 31.75.2

package/src/transport/transport-errors.js

@@ -23,13 +23,56 @@ exports.NotImplementedError = NotImplementedError;
 class NotSupportedError extends Error {
 }
 exports.NotSupportedError = NotSupportedError;
+class InternalError extends Error {
+    constructor(err) {
+        const { message, name, stack, ...rest } = err;
+        super(message);
+        this.name = name || 'Error';
+        this.stack = stack !== null && stack !== void 0 ? stack : this.toString();
+        Object.keys(rest).forEach(key => {
+            this[key] = rest[key];
+        });
+    }
+}
+// For documentation of the error methods being used see here: https://v8.dev/docs/stack-trace-api
 class RuntimeError extends Error {
-    constructor(payload) {
+    static getCallSite(callsToRemove = 0) {
+        var _a, _b;
+        const length = Error.stackTraceLimit;
+        const realCallsToRemove = callsToRemove + 1; // remove this call;
+        Error.stackTraceLimit = length + realCallsToRemove;
+        // eslint-disable-next-line no-underscore-dangle
+        const _prepareStackTrace = Error.prepareStackTrace;
+        // This will be called when we access the `stack` property
+        Error.prepareStackTrace = (_, stack) => stack;
+        // stack is optional in non chromium contexts
+        const stack = (_b = (_a = new Error().stack) === null || _a === void 0 ? void 0 : _a.slice(realCallsToRemove)) !== null && _b !== void 0 ? _b : [];
+        Error.prepareStackTrace = _prepareStackTrace;
+        Error.stackTraceLimit = length;
+        return stack;
+    }
+    static prepareStackTrace(err, callSites) {
+        if (typeof Error.prepareStackTrace === 'function') {
+            return Error.prepareStackTrace(err, callSites);
+        }
+        let string = "";
+        string += err.name || "Error";
+        string += `: ${err.message || ""}`;
+        for (const callSite of callSites) {
+            string += `\n    at ${callSite.toString()}`;
+        }
+        return string;
+    }
+    ;
+    constructor(payload, callSites) {
         const { reason, error } = payload;
         super(reason);
         this.name = 'RuntimeError';
         if (error === null || error === void 0 ? void 0 : error.stack) {
-            this.stack = error.stack;
+            this.cause = new InternalError(error);
+        }
+        if (callSites) {
+            this.stack = RuntimeError.prepareStackTrace(this, callSites);
         }
     }
 }

package/src/transport/transport.d.ts

@@ -1,20 +1,29 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { EventEmitter } from 'events';
 import type * as OpenFin from '../OpenFin';
 import { ExistingConnectConfig, InternalConnectConfig, RemoteConfig, Wire, WireConstructor } from './wire';
 import { Environment } from '../environment/environment';
+import { RuntimeErrorPayload } from './transport-errors';
 import EventAggregator from '../api/events/eventAggregator';
 import { EntityTypeHelpers } from '../api/me';
 import { ProtocolMap } from '../shapes/protocol';
 import { NamedEvent } from '../api/events/base';
 import { ErrorPlainObject } from '../util/errors';
 type EntityType = OpenFin.EntityType;
+type SendActionResponse<T extends keyof ProtocolMap> = Message<{
+    data: ProtocolMap[T]['response'];
+} & ProtocolMap[T]['specialResponse']>;
 export type MessageHandler = (data: any) => boolean;
+export type CancellablePromise<T> = Promise<T> & {
+    cancel: (reason?: any) => void;
+};
+type NackHandler = (payloadOrMessage: RuntimeErrorPayload | string) => void;
 export declare class Transport<MeType extends EntityType = EntityType> extends EventEmitter {
     #private;
     protected wireListeners: Map<number, {
         resolve: Function;
-        reject: Function;
+        handleNack: (payload: RuntimeErrorPayload) => void;
     }>;
     protected uncorrelatedListener: Function;
     me: OpenFin.EntityInfo & EntityTypeHelpers<MeType>;
@@ -24,6 +33,8 @@ export declare class Transport<MeType extends EntityType = EntityType> extends E
     eventAggregator: EventAggregator;
     protected messageHandlers: MessageHandler[];
     constructor(WireType: WireConstructor, environment: Environment, config: OpenFin.Identity);
+    getFin(): OpenFin.Fin<MeType>;
+    registerFin(_fin: OpenFin.Fin<MeType>): void;
     connectSync: () => void;
     getPort: () => string;
     shutdown(): Promise<void>;
@@ -31,12 +42,11 @@ export declare class Transport<MeType extends EntityType = EntityType> extends E
     private connectRemote;
     connectByPort(config: ExistingConnectConfig): Promise<void>;
     private authorize;
-    sendAction<T extends keyof ProtocolMap = string>(action: T, payload?: ProtocolMap[T]['request'], uncorrelated?: boolean): Promise<Message<{
-        data: ProtocolMap[T]['response'];
-    } & ProtocolMap[T]['specialResponse']>>;
+    sendAction<T extends keyof ProtocolMap = string>(action: T, payload?: ProtocolMap[T]['request'], uncorrelated?: boolean): CancellablePromise<SendActionResponse<T>>;
+    protected nackHandler(payloadOrMessage: RuntimeErrorPayload | string, reject: Function, callSites?: NodeJS.CallSite[]): void;
     ferryAction(origData: any): Promise<Message<any>>;
     registerMessageHandler(handler: MessageHandler): void;
-    protected addWireListener(id: number, resolve: Function, reject: Function, uncorrelated: boolean): void;
+    protected addWireListener(id: number, resolve: Function, handleNack: NackHandler, uncorrelated: boolean): void;
     protected onmessage(data: Message<Payload>): void;
     protected handleMessage(data: Message<Payload>): boolean;
 }

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.js

@@ -1,6 +1,16 @@
 "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
@@ -27,7 +37,7 @@ const createRelayedDispatch = (client, target, relayId, relayErrorMsg) => async
         });
     }
     catch (e) {
-        if (e.message.includes('no longer connected') && relayErrorMsg) {
+        if (isDisconnectedError(e.message) && relayErrorMsg) {
             throw new Error(relayErrorMsg);
         }
         ;

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

@@ -14,3 +14,21 @@ export declare class Lazy<T> {
      */
     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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Lazy = void 0;
+exports.AsyncRetryableLazy = exports.Lazy = void 0;
 /**
  * Handy class for managing asynchronous dependencies of classes.
  *
@@ -24,3 +24,31 @@ class Lazy {
     }
 }
 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/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;