@openfin/core 30.74.12 → 30.74.13

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "30.74.12",
+    "version": "30.74.13",
     "license": "SEE LICENSE IN LICENSE.MD",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

package/src/api/interappbus/channel/client.d.ts

@@ -4,9 +4,9 @@ import { Transport } from '../../../transport/transport';
 import { AnyStrategy } from './protocols/strategy-types';
 declare type ProviderIdentity = OpenFin.ProviderIdentity;
 declare type DisconnectionListener = (providerIdentity: ProviderIdentity) => any;
-interface RoutingInfo extends ProviderIdentity {
+export declare type RoutingInfo = ProviderIdentity & {
     endpointId: string;
-}
+};
 export default class ChannelClient extends ChannelBase {
     #private;
     private disconnectListener;

package/src/api/interappbus/channel/index.d.ts

@@ -1,9 +1,9 @@
 import type * as OpenFin from '../../../OpenFin';
-import ChannelClient from './client';
-import { ChannelProvider } from './provider';
+import { Message, Transport } from '../../../transport/transport';
 import { EmitterBase } from '../../base';
-import { Transport, Message } from '../../../transport/transport';
 import { ChannelEvent } from '../../events/channel';
+import ChannelClient from './client';
+import { ChannelProvider } from './provider';
 declare type ProviderIdentity = OpenFin.ProviderIdentity;
 declare type Identity = OpenFin.Identity;
 export interface ChannelMessage extends Message<any> {
@@ -15,10 +15,10 @@ export interface ChannelMessage extends Message<any> {
 export declare class Channel extends EmitterBase<ChannelEvent> {
     #private;
     constructor(wire: Transport);
-    private channelExists;
     getAllChannels(): Promise<ProviderIdentity[]>;
     onChannelConnect(listener: (...args: any[]) => void): Promise<void>;
     onChannelDisconnect(listener: (...args: any[]) => void): Promise<void>;
+    private safeConnect;
     connect(channelName: string, options?: OpenFin.ChannelConnectOptions): Promise<ChannelClient>;
     create(channelName: string, options?: OpenFin.ChannelCreateOptions): Promise<ChannelProvider>;
 }

package/src/api/interappbus/channel/index.js

@@ -14,12 +14,25 @@ var _Channel_connectionManager, _Channel_internalEmitter, _Channel_readyToConnec
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Channel = void 0;
 /* eslint-disable no-console */
-const client_1 = require("./client");
-const provider_1 = require("./provider");
-const base_1 = require("../../base");
-const connection_manager_1 = require("./connection-manager");
 const events_1 = require("events");
 const lazy_1 = require("../../../util/lazy");
+const base_1 = require("../../base");
+const client_1 = require("./client");
+const connection_manager_1 = require("./connection-manager");
+const provider_1 = require("./provider");
+function retryDelay(count) {
+    const interval = 500; // base delay
+    const steps = 10; // How many retries to do before incrementing the delay
+    const base = 2; // How much to multiply the previous delay by
+    const max = 30000; // max delay
+    const step = Math.floor(count / steps);
+    const delay = Math.min(max, interval * base ** step);
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve(false);
+        }, delay);
+    });
+}
 class Channel extends base_1.EmitterBase {
     constructor(wire) {
         super(wire, 'channel');
@@ -38,10 +51,6 @@ class Channel extends base_1.EmitterBase {
         }));
         __classPrivateFieldSet(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), "f");
     }
-    async channelExists(channelName) {
-        const channels = await this.getAllChannels();
-        return channels.some((providerIdentity) => providerIdentity.channelName === channelName);
-    }
     async getAllChannels() {
         return this.wire.sendAction('get-all-channels').then(({ payload }) => payload.data);
     }
@@ -51,6 +60,57 @@ class Channel extends base_1.EmitterBase {
     async onChannelDisconnect(listener) {
         await this.on('disconnected', listener);
     }
+    async safeConnect(channelName, shouldWait, connectPayload) {
+        const retryInfo = { count: 0 };
+        /* eslint-disable no-await-in-loop, no-constant-condition */
+        do {
+            // setup a listener and a connected promise to await in case we connect before the channel is ready
+            let connectedListener = () => undefined;
+            const connectedPromise = new Promise((resolve) => {
+                connectedListener = (payload) => {
+                    if (channelName === payload.channelName) {
+                        resolve(true);
+                    }
+                };
+                __classPrivateFieldGet(this, _Channel_internalEmitter, "f").on('connected', connectedListener);
+            });
+            try {
+                if (retryInfo.count > 0) {
+                    // Wait before retrying
+                    // Delay returns false connectedPromise returns true so we can know if a retry is due to connected event
+                    retryInfo.gotConnectedEvent = await Promise.race([retryDelay(retryInfo.count), connectedPromise]);
+                    const result = await this.wire.sendAction('connect-to-channel', { ...connectPayload, retryInfo });
+                    // log only if there was a retry
+                    console.log(`Successfully connected to channelName: ${channelName}`);
+                    return result.payload.data;
+                }
+                // Send retryInfo to the core for debug log inclusion
+                const sentMessagePromise = this.wire.sendAction('connect-to-channel', connectPayload);
+                // Save messageId from the first connection attempt
+                retryInfo.originalMessageId = sentMessagePromise.messageId;
+                const result = await sentMessagePromise;
+                return result.payload.data;
+            }
+            catch (error) {
+                if (!error.message.includes('internal-nack')) {
+                    // Not an internal nack, break the loop
+                    throw error;
+                }
+                if (shouldWait && retryInfo.count === 0) {
+                    // start waiting on the next iteration, warn the user
+                    console.warn(`No channel found for channelName: ${channelName}. Waiting for connection...`);
+                }
+            }
+            finally {
+                retryInfo.count += 1;
+                // in case of other errors, remove our listener
+                __classPrivateFieldGet(this, _Channel_internalEmitter, "f").removeListener('connected', connectedListener);
+            }
+        } while (shouldWait); // If we're waiting we retry the above loop
+        // Should wait was false, no channel was found.
+        throw new Error(`No channel found for channelName: ${channelName}.`);
+        /* eslint-enable no-await-in-loop, no-constant-condition */
+    }
     async connect(channelName, options = {}) {
         // Make sure we don't connect before listeners are set up
         // This also errors if we're not in OpenFin, ensuring we don't run unnecessary code
@@ -59,58 +119,35 @@ class Channel extends base_1.EmitterBase {
             throw new Error('Please provide a channelName string to connect to a channel.');
         }
         const opts = { wait: true, ...this.wire.environment.getDefaultChannelOptions().connect, ...options };
-        const shouldWait = opts.wait;
-        if (shouldWait) {
-            const channelExists = await this.channelExists(channelName);
-            if (!channelExists) {
-                console.warn(`Channel not found for channelName: ${channelName}, waiting for channel connection.`);
-                await new Promise((resolve) => {
-                    const connectedListener = (payload) => {
-                        if (channelName === payload.channelName) {
-                            __classPrivateFieldGet(this, _Channel_internalEmitter, "f").removeListener('connected', connectedListener);
-                            resolve();
-                        }
-                    };
-                    __classPrivateFieldGet(this, _Channel_internalEmitter, "f").on('connected', connectedListener);
-                });
-            }
-        }
-        try {
-            const { offer, rtc: rtcPacket } = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientOffer(opts);
-            const connectionUrl = (await this.fin.me.getInfo()).url;
-            const { payload: { data: routingInfo } } = await this.wire.sendAction('connect-to-channel', {
-                channelName,
-                ...opts,
-                offer,
-                connectionUrl
-            });
-            const strategy = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
-            const channel = new client_1.default(routingInfo, this.wire, strategy);
-            // It is the client's responsibility to handle endpoint disconnection to the provider.
-            // If the endpoint dies, the client will force a disconnection through the core.
-            // The provider does not care about endpoint disconnection.
-            strategy.onEndpointDisconnect(routingInfo.channelId, async () => {
-                try {
-                    await channel.sendDisconnectAction();
-                }
-                catch (error) {
-                    console.warn(`Something went wrong during disconnect for client with uuid: ${routingInfo.uuid} / name: ${routingInfo.name} / endpointId: ${routingInfo.endpointId}.`);
-                }
-                finally {
-                    client_1.default.handleProviderDisconnect(routingInfo);
-                }
-            });
-            return channel;
+        const { offer, rtc: rtcPacket } = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientOffer(opts);
+        let connectionUrl;
+        if (this.fin.me.isFrame || this.fin.me.isView || this.fin.me.isWindow) {
+            connectionUrl = (await this.fin.me.getInfo()).url;
         }
-        catch (error) {
-            const internalNackMessage = 'internal-nack';
-            if (error.message.includes(internalNackMessage)) {
-                throw new Error(`No channel found for channelName: ${channelName}.`);
+        const connectPayload = {
+            channelName,
+            ...opts,
+            offer,
+            connectionUrl
+        };
+        const routingInfo = await this.safeConnect(channelName, opts.wait, connectPayload);
+        const strategy = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
+        const channel = new client_1.default(routingInfo, this.wire, strategy);
+        // It is the client's responsibility to handle endpoint disconnection to the provider.
+        // If the endpoint dies, the client will force a disconnection through the core.
+        // The provider does not care about endpoint disconnection.
+        strategy.onEndpointDisconnect(routingInfo.channelId, async () => {
+            try {
+                await channel.sendDisconnectAction();
             }
-            else {
-                throw new Error(error);
+            catch (error) {
+                console.warn(`Something went wrong during disconnect for client with uuid: ${routingInfo.uuid} / name: ${routingInfo.name} / endpointId: ${routingInfo.endpointId}.`);
             }
-        }
+            finally {
+                client_1.default.handleProviderDisconnect(routingInfo);
+            }
+        });
+        return channel;
     }
     async create(channelName, options) {
         if (!channelName) {

package/src/api/interappbus/channel/protocols/classic/strategy.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 _ClassicStrategy_wire, _ClassicStrategy_endpointIdentityMap;
+var _ClassicStrategy_wire, _ClassicStrategy_endpointIdentityMap, _ClassicStrategy_pendingMessagesByEndpointId;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassicInfo = exports.ClassicStrategy = void 0;
 /*
@@ -26,6 +26,9 @@ class ClassicStrategy {
         // Store full endpointIdentity by endpointId of all known endpoints for this strategy instance.
         // (clients will only have 1: the provider, the provider will have all clients)
         _ClassicStrategy_endpointIdentityMap.set(this, new Map());
+        // Store a set of cancellable promises to be able to reject them when client
+        // connection problems occur
+        _ClassicStrategy_pendingMessagesByEndpointId.set(this, new Map());
         this.send = async (endpointId, action, payload) => {
             const to = __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
             if (!to) {
@@ -78,6 +81,6 @@ class ClassicStrategy {
     }
 }
 exports.ClassicStrategy = ClassicStrategy;
-_ClassicStrategy_wire = new WeakMap(), _ClassicStrategy_endpointIdentityMap = new WeakMap();
+_ClassicStrategy_wire = new WeakMap(), _ClassicStrategy_endpointIdentityMap = new WeakMap(), _ClassicStrategy_pendingMessagesByEndpointId = new WeakMap();
 // Arbitrarily starting at 5 to leave the door open to backfilling pre endpointId etc.
 exports.ClassicInfo = { version: 5, minimumVersion: 0, type: 'classic' };

package/src/transport/transport.d.ts

@@ -1,15 +1,24 @@
 /// <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';
 declare type EntityType = OpenFin.EntityType;
+declare type SendActionResponse<T extends keyof ProtocolMap> = Message<{
+    data: ProtocolMap[T]['response'];
+} & ProtocolMap[T]['specialResponse']>;
 export declare type MessageHandler = (data: any) => boolean;
+export declare type SentMessage<Value> = Promise<Value> & {
+    cancel: (reason?: any) => void;
+    messageId: ReturnType<Environment['getNextMessageId']>;
+};
 export declare class Transport<MeType extends EntityType = EntityType> extends EventEmitter {
     #private;
     protected wireListeners: Map<number, {
@@ -31,9 +40,8 @@ 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): SentMessage<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;

package/src/transport/transport.js

@@ -101,17 +101,31 @@ class Transport extends events_1.EventEmitter {
     sendAction(action, payload = {}, uncorrelated = false
     // specialResponse type is only used for 'requestAuthorization'
     ) {
-        return new Promise((resolve, reject) => {
-            const id = this.environment.getNextMessageId();
+        // 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 messageId = this.environment.getNextMessageId();
+        const prom = new Promise((resolve, reject) => {
+            cancel = reject;
             const msg = {
                 action,
                 payload,
-                messageId: id
+                messageId
             };
             const wire = __classPrivateFieldGet(this, _Transport_wire, "f");
-            this.addWireListener(id, resolve, reject, uncorrelated);
+            this.addWireListener(messageId, resolve, reject, uncorrelated);
             return wire.send(msg).catch(reject);
         });
+        return Object.assign(prom, { cancel, messageId });
+    }
+    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));
+        }
     }
     ferryAction(origData) {
         return new Promise((resolve, reject) => {