@openfin/core 27.71.23 → 27.71.25

package/OpenFin.d.ts

@@ -1546,7 +1546,7 @@ declare namespace OpenFin {
         topic: string,
         payload: unknown,
         senderIdentity: ProviderIdentity | OpenFin.ClientIdentity
-    ) => unknown;
+    ) => Promise<unknown> |unknown;
 
     export type ErrorMiddleware = (
         topic: string,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "27.71.23",
+    "version": "27.71.25",
     "license": "Apache-2.0",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelBase = exports.ProtectedItems = void 0;
-const resultOrPayload = (func) => (topic, payload, senderIdentity) => {
-    const res = func(topic, payload, senderIdentity);
+const resultOrPayload = (func) => async (topic, payload, senderIdentity) => {
+    const res = await func(topic, payload, senderIdentity);
     return res === undefined ? payload : res;
 };
 class ProtectedItems {

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

@@ -15,7 +15,6 @@ export default class ChannelClient extends ChannelBase {
     constructor(routingInfo: RoutingInfo, wire: Transport, strategy: AnyStrategy);
     protected processAction: (action: string, payload: any, senderIdentity: ProviderIdentity | OpenFin.ClientIdentity) => Promise<any>;
     get providerIdentity(): ProviderIdentity;
-    getRTCConnection(): RTCPeerConnection;
     dispatch(action: string, payload?: any): Promise<any>;
     onDisconnection(listener: DisconnectionListener): void;
     disconnect(): Promise<void>;

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

@@ -49,9 +49,6 @@ class ChannelClient extends channel_1.ChannelBase {
         const protectedObj = __classPrivateFieldGet(this, _protectedObj);
         return protectedObj.providerIdentity;
     }
-    getRTCConnection() {
-        return __classPrivateFieldGet(this, _strategy).getRTCConnection(this.providerIdentity.channelId);
-    }
     async dispatch(action, payload) {
         if (__classPrivateFieldGet(this, _strategy).isEndpointConnected(this.providerIdentity.channelId)) {
             return __classPrivateFieldGet(this, _strategy).send(this.providerIdentity.channelId, action, payload);

package/src/api/interappbus/channel/protocols/classic/strategy.d.ts

@@ -10,7 +10,6 @@ export declare class ClassicStrategy implements ChannelStrategy<EndpointPayload>
     private providerIdentity;
     constructor(wire: Transport, messageReceiver: MessageReceiver, endpointId: string, // Provider endpointId is channelId
     providerIdentity: ProviderIdentity);
-    getRTCConnection(endpointId: string): RTCPeerConnection;
     onEndpointDisconnect(endpointId: string, listener: () => void): void;
     receive(listener: (action: string, payload: any, identity: OpenFin.ClientIdentity | OpenFin.ClientIdentityMultiRuntime | ProviderIdentity) => Promise<any>): void;
     send: (endpointId: string, action: string, payload: any) => Promise<any>;

package/src/api/interappbus/channel/protocols/classic/strategy.js

@@ -57,9 +57,6 @@ class ClassicStrategy {
         };
         __classPrivateFieldSet(this, _wire, wire);
     }
-    getRTCConnection(endpointId) {
-        throw new Error("Not implemented");
-    }
     onEndpointDisconnect(endpointId, listener) {
         // Never fires for 'classic'.
     }

package/src/api/interappbus/channel/protocols/combined/strategy.d.ts

@@ -15,7 +15,6 @@ export default class CombinedStrategy<A, B> implements ChannelStrategy<OnlyIfCom
     addEndpoint(endpoint: string, payload: OnlyIfCompatible<A, B>): Promise<void>;
     receive(listener: (action: string, payload: any, identity: any) => Promise<any>): void;
     send(endpointId: string, action: string, payload: any): Promise<any>;
-    getRTCConnection(endpointId: string): RTCPeerConnection;
     close(): Promise<void>;
 }
 export {};

package/src/api/interappbus/channel/protocols/combined/strategy.js

@@ -51,18 +51,6 @@ class CombinedStrategy {
         }
         return this.secondary.send(endpointId, action, payload);
     }
-    getRTCConnection(endpointId) {
-        let connection;
-        try {
-            if (this.primary.isEndpointConnected(endpointId)) {
-                connection = this.primary.getRTCConnection(endpointId);
-            }
-        }
-        catch (error) {
-            console.log("error getting rtcpeer from primary");
-        }
-        return connection !== null && connection !== void 0 ? connection : this.secondary.getRTCConnection(endpointId);
-    }
     async close() {
         await Promise.all([this.primary.close(), this.secondary.close()]);
     }

package/src/api/interappbus/channel/protocols/rtc/endpoint.d.ts

@@ -20,5 +20,4 @@ export declare class RTCEndpoint {
     send: (action: string, payload: any) => Promise<any>;
     close: () => void;
     get connected(): boolean;
-    get peerConnection(): RTCPeerConnection;
 }

package/src/api/interappbus/channel/protocols/rtc/endpoint.js

@@ -130,9 +130,6 @@ class RTCEndpoint {
     get connected() {
         return this.rtc.rtcClient.connectionState === 'connected';
     }
-    get peerConnection() {
-        return this.rtc.rtcClient;
-    }
 }
 exports.RTCEndpoint = RTCEndpoint;
 _processAction = new WeakMap(), _disconnectListener = new WeakMap();

package/src/api/interappbus/channel/protocols/rtc/strategy.d.ts

@@ -9,7 +9,6 @@ export interface RTCStrategyEndpointPayload {
 export declare class RTCStrategy implements ChannelStrategy<RTCStrategyEndpointPayload> {
     #private;
     onEndpointDisconnect(endpointId: string, listener: () => void): void;
-    getRTCConnection(endpointId: string): RTCPeerConnection;
     receive(listener: (action: string, payload: any, identity: OpenFin.ClientIdentity | OpenFin.ClientIdentityMultiRuntime | ProviderIdentity) => Promise<any>): void;
     send: (endpointId: string, action: string, payload: any) => Promise<any>;
     close: () => Promise<void>;

package/src/api/interappbus/channel/protocols/rtc/strategy.js

@@ -38,13 +38,6 @@ class RTCStrategy {
     onEndpointDisconnect(endpointId, listener) {
         this.getEndpointById(endpointId).onDisconnect(listener);
     }
-    getRTCConnection(endpointId) {
-        const endpoint = __classPrivateFieldGet(this, _rtcEndpointMap).get(endpointId);
-        if (!endpoint) {
-            throw new Error('Could not find WebRTC connection');
-        }
-        return endpoint.peerConnection;
-    }
     receive(listener) {
         if (__classPrivateFieldGet(this, _processAction)) {
             throw new Error('You have already set a listener for this RTC Strategy');

package/src/api/interappbus/channel/protocols/strategy.d.ts

@@ -8,7 +8,6 @@ export interface ChannelStrategy<T extends unknown> {
     isEndpointConnected(endpointId: string): boolean;
     addEndpoint(endpointId: string, payload: T): void;
     isValidEndpointPayload(payload: unknown): payload is T;
-    getRTCConnection(endpointId: string): RTCPeerConnection;
 }
 export declare type EndpointIdentity = OpenFin.ClientIdentity | ProviderIdentity;
 export declare type EndpointPayload = {

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

@@ -3,7 +3,7 @@ import Transport from '../../../transport/transport';
 import { AnyStrategy } from './protocols/strategy-types';
 import ProviderIdentity = OpenFin.ProviderIdentity;
 import ClientIdentity = OpenFin.ClientIdentity;
-export declare type ConnectionListener = (identity: ClientIdentity, connectionMessage?: any) => any;
+export declare type ConnectionListener = (identity: ClientIdentity, connectionMessage?: any) => Promise<any> | any;
 export declare type DisconnectionListener = (identity: ClientIdentity) => any;
 export declare class ChannelProvider extends ChannelBase {
     #private;
@@ -13,7 +13,6 @@ export declare class ChannelProvider extends ChannelBase {
     get connections(): OpenFin.ClientIdentity[];
     static handleClientDisconnection(channel: ChannelProvider, payload: any): void;
     static setProviderRemoval(provider: ChannelProvider, remove: Function): void;
-    getRTCPeerConnection(endpointId: string): RTCPeerConnection;
     constructor(providerIdentity: ProviderIdentity, wire: Transport, strategy: AnyStrategy);
     dispatch(to: OpenFin.ClientIdentity | OpenFin.Identity, action: string, payload?: any): Promise<any>;
     protected processAction: (action: string, payload: any, senderIdentity: OpenFin.ClientIdentity | OpenFin.ClientIdentityMultiRuntime) => Promise<any>;

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

@@ -73,9 +73,6 @@ let ChannelProvider = /** @class */ (() => {
         static setProviderRemoval(provider, remove) {
             ChannelProvider.removalMap.set(provider, remove);
         }
-        getRTCPeerConnection(endpointId) {
-            return __classPrivateFieldGet(this, _strategy).getRTCConnection(endpointId);
-        }
         dispatch(to, action, payload) {
             var _a;
             const endpointId = (_a = to.endpointId) !== null && _a !== void 0 ? _a : this.getEndpointIdForOpenFinId(to, action);

package/src/api/interop/InteropBroker.d.ts

@@ -351,7 +351,7 @@ export declare class InteropBroker extends Base {
      * @param _id the identity tryinc to connect
      * @param _connectionPayload optional payload to use in custom implementations, will be undefined by default
      */
-    isConnectionAuthorized(_id: Identity, _connectionPayload?: any): Promise<boolean>;
+    isConnectionAuthorized(_id: Identity, _connectionPayload?: any): Promise<boolean> | boolean;
     /**
      * Called before every action to check if this entity should be allowed to take the action.
      * Return false to prevent the action
@@ -359,5 +359,5 @@ export declare class InteropBroker extends Base {
      * @param _payload the data being sent for this action
      * @param _identity the connection attempting to dispatch this action
      */
-    isActionAuthorized(_action: string, _payload: any, _identity: OpenFin.ClientIdentity): Promise<boolean>;
+    isActionAuthorized(_action: string, _payload: any, _identity: OpenFin.ClientIdentity): Promise<boolean> | boolean;
 }

package/src/api/interop/InteropBroker.js

@@ -828,8 +828,8 @@ class InteropBroker extends base_1.Base {
     }
     // Setup Channel Connection Logic
     wireChannel(channel) {
-        channel.onConnection((clientIdentity, payload) => {
-            if (!this.isConnectionAuthorized(clientIdentity, payload)) {
+        channel.onConnection(async (clientIdentity, payload) => {
+            if (!(await this.isConnectionAuthorized(clientIdentity, payload))) {
                 throw new Error(`Connection not authorized for ${clientIdentity.uuid}, ${clientIdentity.name}`);
             }
             if (!clientIdentity.endpointId) {
@@ -860,8 +860,8 @@ class InteropBroker extends base_1.Base {
         });
         // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
         // @ts-ignore
-        channel.beforeAction((action, payload, clientIdentity) => {
-            if (!this.isActionAuthorized(action, payload, clientIdentity)) {
+        channel.beforeAction(async (action, payload, clientIdentity) => {
+            if (!(await this.isActionAuthorized(action, payload, clientIdentity))) {
                 throw new Error(`Action (${action}) not authorized for ${clientIdentity.uuid}, ${clientIdentity.name}`);
             }
             console.log(action, payload, clientIdentity);
@@ -891,11 +891,11 @@ class InteropBroker extends base_1.Base {
      * @param _id the identity tryinc to connect
      * @param _connectionPayload optional payload to use in custom implementations, will be undefined by default
      */
-    async isConnectionAuthorized(_id, _connectionPayload) {
+    isConnectionAuthorized(_id, _connectionPayload) {
         this.wire.sendAction('interop-broker-is-connection-authorized').catch((e) => {
             // don't expose, analytics-only call
         });
-        return true;
+        return Promise.resolve(true);
     }
     /**
      * Called before every action to check if this entity should be allowed to take the action.
@@ -904,11 +904,11 @@ class InteropBroker extends base_1.Base {
      * @param _payload the data being sent for this action
      * @param _identity the connection attempting to dispatch this action
      */
-    async isActionAuthorized(_action, _payload, _identity) {
+    isActionAuthorized(_action, _payload, _identity) {
         this.wire.sendAction('interop-broker-is-action-authorized').catch((e) => {
             // don't expose, analytics-only call
         });
-        return true;
+        return Promise.resolve(true);
     }
 }
 exports.InteropBroker = InteropBroker;