@openfin/cloud-interop 0.40.35 → 0.40.37

package/out/index.js

@@ -4055,22 +4055,88 @@ class CloudInteropAPI {
     };
 }
 
+/* eslint-disable no-console */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    // TODO: eventually support NONE = 3
+})(LogLevel || (LogLevel = {}));
+const levelToStr = new Map([
+    [LogLevel.DEBUG, 'debug'],
+    [LogLevel.INFO, 'info'],
+    [LogLevel.WARN, 'warn']
+]);
+const strToLevel = new Map([
+    ['debug', LogLevel.DEBUG],
+    ['info', LogLevel.INFO],
+    ['warn', LogLevel.WARN],
+    // reduce 'error' and 'log' to warn/info
+    ['error', LogLevel.WARN],
+    ['log', LogLevel.INFO]
+]);
+const getTimestamp = () => new Date().toISOString().replace('T', ' ').replace('Z', '');
+/**
+ * This logger retrofits on top of the CloudAPILogger function signature so it must use CloudAPILogLevel inputs
+ */
+class Logger {
+    logLevel;
+    // eslint-disable-next-line no-useless-constructor
+    constructor(level = 'warn') {
+        this.logLevel = strToLevel.get(level) ?? LogLevel.WARN;
+    }
+    log(logLevel, message, ...args) {
+        const level = strToLevel.get(logLevel) ?? this.logLevel;
+        if (this.logLevel <= level) {
+            // always write to console.debug to avoid cluttering client logs
+            // TODO(RUN-9370): Change this to console.debug after this runtime ticket is fixed
+            console.log(`${getTimestamp()} | CloudInteropOverride [${levelToStr.get(level)}] ${message}`, ...args);
+        }
+    }
+}
+
+const isContext = (chan) => {
+    const c = chan;
+    return c && typeof c === 'object' && 'type' in c && !('broadcast' in c);
+};
+
+const DEFAULT_TIMEOUT = 3000;
 /**
  * Enhances InteropBroker with Cloud Interop functionality
+ *
+ * Ensure that CloudInteropOverride comes first in the list of composable overrides, for example:
+ * ```
+ * const CloudInteropOverride = await cloudInteropOverride(settings);
+ * await fin.Platform.init({
+ *     ...,
+ *     interopOverride: [
+ *         CloudInteropOverride, // <--- must come first
+ *         (BaseProvider) => class MyCustomProvider extends BaseProvider { ... }
+ *     ]
+ * });
+ * ```
+ *
  * @param {CloudInteropOverrideParams} config Configuration to connect to the Cloud Interop service
  */
 async function cloudInteropOverride(config) {
-    const { url, ...settings } = config;
+    const { url, findIntentTimeout = DEFAULT_TIMEOUT, logLevel = 'warn', logger = new Logger(logLevel), ...settings } = config;
     const client = new CloudInteropAPI({ url });
+    // create closure to use computed settings above in the CloudInteropOverride::reconnect function below
+    const initConnect = async (connectParams = settings) => client.connect({
+        ...connectParams,
+        // shim our logSink onto cloud-api logger func
+        logger: (level, msg) => logger.log(level, msg)
+    });
     try {
-        await client.connect(settings);
+        await initConnect();
     }
     catch (err) {
         // eslint-disable-next-line no-console
-        console.warn(`[CloudInteropOverride] Failed to connect to Cloud Interop Service. Call interopBroker.cloudReconnect() to attempt reconnection`, err);
+        logger.log('warn', `Failed to connect to Cloud Interop Service. Call interopBroker.cloudReconnect() to attempt reconnection`, err);
     }
-    return (Base) => {
-        return class CloudInteropOverride extends Base {
+    return (BaseProvider) => {
+        return class CloudInteropOverride extends BaseProvider {
             contextListener;
             setContextFilter = (context) => true;
             constructor() {
@@ -4085,10 +4151,169 @@ async function cloudInteropOverride(config) {
                     }
                 };
                 client.addEventListener('context', this.contextListener);
+                client.addEventListener('report-intents', async ({ discoveryId, initiatingSessionId, findOptions }) => {
+                    logger.log('debug', `Received report-intents request from ${initiatingSessionId}`);
+                    let appIntents = [];
+                    try {
+                        if (findOptions.type === 'find-intent') {
+                            const intent = (await super.handleInfoForIntent({
+                                name: findOptions.intent,
+                                metadata: { resultType: findOptions.resultType },
+                                context: findOptions.context
+                            }, null));
+                            appIntents = [intent];
+                        }
+                        else {
+                            appIntents = (await super.handleInfoForIntentsByContext({ context: findOptions.context, metadata: { resultType: findOptions.resultType } }, null));
+                        }
+                    }
+                    catch (e) {
+                        logger.log('warn', `Error in report-intents listener, proceeding with an empty response: ${e}`);
+                    }
+                    logger.log('debug', `Reporting intents :\n${JSON.stringify(appIntents, null, 2)}`);
+                    await this.#maybeReconnect();
+                    await client.reportAppIntents(discoveryId, appIntents);
+                });
+                client.addEventListener('raise-intent', async ({ initiatingSessionId, raiseOptions }) => {
+                    logger.log('debug', `Received raise-intent request from ${initiatingSessionId}`);
+                    if ('metadata' in raiseOptions.context && raiseOptions.context.metadata.target) {
+                        const { target } = raiseOptions.context.metadata;
+                        // parse the actual app id from the cloud-app-id string
+                        raiseOptions.context.metadata.target = client.parseAppId(target);
+                    }
+                    let result;
+                    try {
+                        const intentResolution = (raiseOptions.type === 'raise-intent'
+                            ? await super.handleFiredIntent({ name: raiseOptions.intent, context: raiseOptions.context }, null)
+                            : await super.handleFiredIntentForContext(raiseOptions.context, null));
+                        const intentResult = await intentResolution.getResult();
+                        const { intent, source, version } = intentResolution;
+                        result = { intent, source, version };
+                        if (isContext(intentResult)) {
+                            // currently only supporting Contexts as results
+                            result.getResult = intentResult;
+                        }
+                    }
+                    catch (e) {
+                        logger.log('warn', `Error in raise-intent, forwarding error response to the cloud: ${e}`);
+                        // TODO: maybe set the message as a separate key to carry-forward the actual fdc3 error string
+                        result = { error: `Error raising intent: ${e}` };
+                    }
+                    logger.log('debug', `Sending intent result to ${initiatingSessionId}:\n${JSON.stringify(result, null, 2)}`);
+                    await this.#maybeReconnect();
+                    await client.sendIntentResult(initiatingSessionId, result);
+                });
+            }
+            async handleInfoForIntent(options, clientIdentity) {
+                logger.log('debug', `in handleInfoForIntent`, options);
+                const { name, context, metadata } = options;
+                return this.#handleInfoForIntent(name, context, metadata?.resultType);
+            }
+            async handleInfoForIntentsByContext(context, clientIdentity) {
+                logger.log('debug', `in handleInfoForIntentsByContext`, context);
+                return ('type' in context
+                    ? this.#handleInfoForIntent(undefined, context, undefined)
+                    : this.#handleInfoForIntent(undefined, context.context, context.metadata?.resultType));
+            }
+            async handleFiredIntent(intent, clientIdentity) {
+                logger.log('debug', `in handleFiredIntent`, intent);
+                return this.#handleFiredIntent(intent);
+            }
+            async handleFiredIntentForContext(contextForIntent, clientIdentity) {
+                logger.log('debug', `in handleFiredIntentForContext`, contextForIntent);
+                return this.#handleFiredIntent(undefined, contextForIntent);
+            }
+            async #handleInfoForIntent(intent, context, resultType) {
+                logger.log('debug', `in #handleInfoForIntent`, { intent, context, resultType });
+                await this.#maybeReconnect();
+                if (!intent && !context) {
+                    throw new Error('[CloudInteropOverride] #handleInfoForIntent requires intent or context');
+                }
+                if (context?.metadata?.target) {
+                    const targetSessionId = client.parseSessionId(context?.metadata?.target);
+                    if (targetSessionId && targetSessionId === client.sessionDetails?.sessionId) {
+                        throw new Error('[CloudInteropOverride] handleInfoForIntent cannot be called on the same session');
+                    }
+                }
+                const appIntentsMap = new Map();
+                let aggregateResolve;
+                const aggregatePromise = new Promise((resolve) => {
+                    aggregateResolve = resolve;
+                });
+                client.once('aggregate-intent-details', ({ responses }) => {
+                    logger.log('debug', `Received aggregate intent details, length: ${responses.length}`);
+                    responses.forEach(({ intents }) => {
+                        intents.forEach((intent) => {
+                            const appIntentList = appIntentsMap.get(intent.intent.name) || [];
+                            appIntentList.push(intent);
+                            appIntentsMap.set(intent.intent.name, appIntentList);
+                        });
+                    });
+                    aggregateResolve();
+                });
+                const options = {
+                    timeout: findIntentTimeout,
+                    findOptions: intent
+                        ? { type: 'find-intent', intent, context, resultType }
+                        : { type: 'find-intents-by-context', context: context, resultType }
+                };
+                logger.log('debug', 'Starting intent discovery');
+                await client.startIntentDiscovery(options);
+                await aggregatePromise;
+                logger.log('debug', 'Intent discovery completed');
+                const appIntents = intent
+                    ? appIntentsMap.get(intent) || []
+                    : Array.from(appIntentsMap.entries()).map(([intent, appIntents]) => ({
+                        intent: { name: intent, displayName: intent },
+                        apps: appIntents.flatMap(({ apps }) => apps)
+                    }));
+                return appIntents;
+            }
+            async #handleFiredIntent(intent, context) {
+                logger.log('debug', `in #handleFiredIntent`, { intent, context });
+                await this.#maybeReconnect();
+                const targetApp = intent?.metadata?.target ?? context?.metadata?.target;
+                if (!targetApp) {
+                    throw new Error(`[CloudInteropOverride] handleFiredIntent requires intent.metadata.target or context.metadata.target to be an appId`);
+                }
+                // safeguard MQ traffic by short circuiting here
+                const targetSessionId = client.parseSessionId(targetApp);
+                if (targetSessionId === client.sessionDetails?.sessionId) {
+                    throw new Error('[CloudInteropOverride] handleFiredIntent cannot be called on the same session');
+                }
+                let intentResolve;
+                const intentResultPromise = new Promise((resolve) => {
+                    intentResolve = resolve;
+                });
+                client.once('intent-result', ({ result, source }) => {
+                    logger.log('debug', `Received intent-result`, JSON.stringify({ source, result }, null, 2));
+                    intentResolve(result);
+                });
+                const raiseOptions = intent
+                    ? { type: 'raise-intent', intent: intent.name, context: intent.context }
+                    : { type: 'raise-intent-for-context', context: context };
+                await client.raiseIntent({ appId: targetApp, raiseOptions });
+                // TODO: raise-intent timeout via promise.race?
+                const intentResult = await intentResultPromise;
+                if ('error' in intentResult) {
+                    logger.log('warn', `#handleFiredIntent could not raise intent for AppId: ${targetApp}`);
+                    // Presumably, the error is FDC3 compliant, so throw it as is
+                    // TODO: use the message key instead of the entire error string
+                    throw new Error(intentResult.error);
+                }
+                const source = typeof intentResult.source === 'string' ? { appId: intentResult.source } : intentResult.source;
+                return {
+                    intent: intentResult.intent,
+                    version: intentResult.version,
+                    source,
+                    // Currently only supporting contexts as results
+                    getResult: async () => intentResult.getResult
+                };
             }
             async setContextForGroup({ context }, contextGroupId) {
+                // TODO: is this right? should we attempt a reconnect instead of check connected state?
                 if (this.cloudConnectionState === 'connected' && this.setContextFilter(context)) {
-                    client.setContext(contextGroupId, context);
+                    await client.setContext(contextGroupId, context);
                 }
                 super.setContextForGroup({ context }, contextGroupId);
             }
@@ -4105,10 +4330,10 @@ async function cloudInteropOverride(config) {
                     if (this.cloudConnectionState === 'connected') {
                         await client.disconnect();
                     }
-                    await client.connect(settings || config);
+                    await initConnect(settings);
                 }
                 catch (err) {
-                    console.warn(`[CloudInteropOverride] Failed reconnection to Cloud Interop Service.`, err);
+                    logger.log('warn', `Failed reconnection to Cloud Interop Service.`, err);
                 }
             }
             /**
@@ -4140,6 +4365,12 @@ async function cloudInteropOverride(config) {
                 }
                 return 'disconnected';
             }
+            #maybeReconnect = async () => {
+                // TODO: Remove this helper when SAAS-1588 is solved
+                if (this.cloudConnectionState !== 'connected') {
+                    await this.cloudReconnect();
+                }
+            };
         };
     };
 }

package/out/logger.d.ts

@@ -0,0 +1,17 @@
+import { LogLevel as CloudAPILogLevel } from '@openfin/cloud-interop-core-api';
+export declare const enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2
+}
+export interface LogSink {
+    log: (logLevel: CloudAPILogLevel, message: string, ...args: unknown[]) => void;
+}
+/**
+ * This logger retrofits on top of the CloudAPILogger function signature so it must use CloudAPILogLevel inputs
+ */
+export declare class Logger implements LogSink {
+    private readonly logLevel;
+    constructor(level?: CloudAPILogLevel);
+    log(logLevel: CloudAPILogLevel, message: string, ...args: unknown[]): void;
+}

package/out/override.d.ts

@@ -1,11 +1,43 @@
-import { ConnectParameters } from '@openfin/cloud-interop-core-api';
+import { LogLevel as CloudAPILogLevel, ConnectParameters } from '@openfin/cloud-interop-core-api';
 import type OpenFin from '@openfin/core';
-export type CloudInteropOverrideParams = ConnectParameters & {
+import { LogSink } from './logger';
+type ConnectParametersNoLogger = Omit<ConnectParameters, 'logger'>;
+export type CloudInteropOverrideParams = ConnectParametersNoLogger & {
+    /**
+     * URL of the Cloud Interop service
+     */
     url: string;
+    /**
+     * How long to wait for connected clients to respond, defaults to 3 seconds.
+     * Do not make this number too high, as it will block findIntent/findIntentsByContext calls
+     */
+    findIntentTimeout?: number;
+    /**
+     * If provided will defer to this logger, otherwise logs to console.debug, reduced by LogLevel
+     */
+    logger?: LogSink;
+    /**
+     * The level which cloud-interop override will log. Defaults to 'warn'
+     */
+    logLevel?: CloudAPILogLevel;
 };
 export type CloudInteropConnectionStates = 'connected' | 'reconnecting' | 'disconnected';
 /**
  * Enhances InteropBroker with Cloud Interop functionality
+ *
+ * Ensure that CloudInteropOverride comes first in the list of composable overrides, for example:
+ * ```
+ * const CloudInteropOverride = await cloudInteropOverride(settings);
+ * await fin.Platform.init({
+ *     ...,
+ *     interopOverride: [
+ *         CloudInteropOverride, // <--- must come first
+ *         (BaseProvider) => class MyCustomProvider extends BaseProvider { ... }
+ *     ]
+ * });
+ * ```
+ *
  * @param {CloudInteropOverrideParams} config Configuration to connect to the Cloud Interop service
  */
 export declare function cloudInteropOverride(config: CloudInteropOverrideParams): Promise<OpenFin.ConstructorOverride<OpenFin.InteropBroker>>;
+export {};

package/out/utils.d.ts

@@ -0,0 +1,2 @@
+import type { v2_0 as FDC3v2 } from '@openfin/fdc3';
+export declare const isContext: (chan: unknown) => chan is FDC3v2.Context;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/cloud-interop",
-    "version": "0.40.35",
+    "version": "0.40.37",
     "description": "",
     "private": false,
     "files": [
@@ -11,6 +11,7 @@
     "scripts": {
         "prebuild": "rimraf out",
         "build": "rollup -c",
+        "watch": "rollup -c --watch",
         "ci:prepublish": "of-npm prepublish",
         "ci:postpublish": "of-npm postpublish",
         "ci:publish": "npm publish",
@@ -19,9 +20,9 @@
     "author": "",
     "license": "SEE LICENSE IN LICENSE.md",
     "peerDependencies": {
-        "@openfin/core": "40.102.2"
+        "@openfin/core": "40.103.1"
     },
     "dependencies": {
-        "@openfin/cloud-interop-core-api": "^0.0.1-alpha.fba3468"
+        "@openfin/cloud-interop-core-api": "0.0.1-alpha.a27677b"
     }
 }