@openfin/cloud-interop 0.40.38 → 0.40.39

package/README.md

@@ -4,7 +4,26 @@ This package contains an override that enables Cloud Interop for `InteropBroker`
 
 Overrides are passed to `fin.Platform.init` when initializing a platform or to `fin.Interop.init` when creating an `InteropBroker` directly.
 
-Once overriden the `InteropBroker` will connect to the given Cloud Interop Service upon initialization. `Context` will be sent to the Cloud Interop server and the broker will receive `Context` updates from other any other connected brokers in the shared session.
+Once overriden the `InteropBroker` will connect to the given Cloud Interop Service upon initialization. `Context` will be sent to the Cloud Interop Service when the override broker calls `setContext` and the broker will also subscribe `Context` updates from other any other connected brokers in the shared session.
+
+The Cloud Interop Service also supports `Intent`'s. Connected `InteropBroker`'s info calls (`handleInfoForIntent`, `handleInfoForIntentsByContext`, `fdc3.findIntent`, `fdc3.findIntentsByContext`) will include results for remote sessions and decorate those app identifiers with additional metadata which can then be used to raise `Intent`'s on remote sessions.
+
+## Override Options
+
+| Option                             | Type                                                           | Description                                                                                   | Default Value     | Required |
+|------------------------------------|----------------------------------------------------------------|-----------------------------------------------------------------------------------------------|-------------------|----------|
+| `url`                              | `string`                                                       | URL of the Cloud Interop service                                                              | N/A               | Yes      |
+| `platformId`                       | `string`                                                       | Platform ID                                                                                  | N/A               | Yes      |
+| `sourceId`                         | `string`                                                       | Source ID                                                                                     | N/A               | Yes      |
+| `reconnectRetryLimit`              | `number` (optional)                                            | Limit for reconnect retries                                                                   | N/A               | No       |
+| `keepAliveIntervalSeconds`         | `number` (optional)                                            | Interval in seconds to keep the connection alive                                              | N/A               | No       |
+| `findIntentTimeout`                | `number` (optional)                                            | How long to wait for connected clients to respond. Do not make this too high.                 | `3 seconds`       | No       |
+| `authenticationType`               | ``'jwt' \| 'basic' \| 'default'`` (optional)                   | Type of authentication to use                                                                  | N/A               | No       |
+| `basicAuthenticationParameters`    | `{ username: string, password: string }` (optional)            | Parameters for basic authentication                                                            | N/A               | No       |
+| `jwtAuthenticationParameters`      | `{ jwtRequestCallback: () => string \| object, authenticationId: string }` (optional) | Parameters for JWT authentication                                                               | N/A               | No       |
+| `logger`                           | ``(logLevel: 'log' \| 'debug' \| 'info' \| 'warn' \| 'error', message: string, ...args: unknown[]) => void`` (optional) | If provided, will defer to this logger, otherwise logs to `console.debug`, reduced by LogLevel | `console.debug`   | No       |
+| `logLevel`                         | ``'log' \| 'debug' \| 'info' \| 'warn' \| 'error'`` (optional) | The level at which cloud-interop override will log.                                            | `'warn'`          | No       |
+
 
 ## Usage
 

package/out/index.js

@@ -4123,11 +4123,18 @@ async function cloudInteropOverride(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)
-    });
+    const initConnect = async (connectParams = settings) => {
+        client.connect({
+            ...connectParams,
+            // shim our logSink onto cloud-api logger func
+            logger: (level, msg) => logger.log(level, msg)
+        });
+    };
+    const isLocalTargetSession = (targetAppId) => {
+        const target = typeof targetAppId === 'string' ? targetAppId : targetAppId.appId;
+        const targetSessionId = client.parseSessionId(target);
+        return !targetSessionId || targetSessionId === client.sessionDetails?.sessionId;
+    };
     try {
         await initConnect();
     }
@@ -4177,9 +4184,10 @@ async function cloudInteropOverride(config) {
                 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);
+                        raiseOptions.context.metadata.target = {
+                            ...raiseOptions.context.metadata.target,
+                            appId: client.parseAppId(raiseOptions.context.metadata.target)
+                        };
                     }
                     let result;
                     try {
@@ -4189,15 +4197,15 @@ async function cloudInteropOverride(config) {
                         const intentResult = await intentResolution.getResult();
                         const { intent, source, version } = intentResolution;
                         result = { intent, source, version };
+                        logger.log('debug', `Intent result: ${JSON.stringify(intentResult, null, 2)}`);
                         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('warn', `Error in raise-intent, forwarding error response to the cloud: ${e}`, e.stack);
+                        result = { error: e.message };
                     }
                     logger.log('debug', `Sending intent result to ${initiatingSessionId}:\n${JSON.stringify(result, null, 2)}`);
                     await this.#maybeReconnect();
@@ -4207,48 +4215,64 @@ async function cloudInteropOverride(config) {
             async handleInfoForIntent(options, clientIdentity) {
                 logger.log('debug', `in handleInfoForIntent`, options);
                 const { name, context, metadata } = options;
-                return this.#handleInfoForIntent(name, context, metadata?.resultType);
+                const intentsPromise = super.handleInfoForIntent(options, clientIdentity);
+                return this.#handleInfoForIntent(intentsPromise, 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));
+                const intentsPromise = super.handleInfoForIntentsByContext(context, clientIdentity);
+                return 'type' in context
+                    ? this.#handleInfoForIntent(intentsPromise, undefined, context, undefined)
+                    : this.#handleInfoForIntent(intentsPromise, undefined, context.context, context.metadata?.resultType);
             }
             async handleFiredIntent(intent, clientIdentity) {
                 logger.log('debug', `in handleFiredIntent`, intent);
-                return this.#handleFiredIntent(intent);
+                return this.#handleFiredIntent(clientIdentity, intent);
             }
             async handleFiredIntentForContext(contextForIntent, clientIdentity) {
                 logger.log('debug', `in handleFiredIntentForContext`, contextForIntent);
-                return this.#handleFiredIntent(undefined, contextForIntent);
+                return this.#handleFiredIntent(clientIdentity, contextForIntent);
             }
-            async #handleInfoForIntent(intent, context, resultType) {
+            async #handleInfoForIntent(
+            /**
+             * Promise to execute in parallel with intent discovery
+             */
+            localIntentsPromise, 
+            /**
+             * if present -> findIntent
+             */
+            intent, 
+            /**
+             * if present -> findIntentsByContext
+             */
+            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');
+                    // safeguard MQ traffic by short circuiting here
+                    // if session id not parsable, it's a local intent, also if session id
+                    // is parsed and matches the current session, treat it as a local findIntent action
+                    if (isLocalTargetSession(context.metadata.target)) {
+                        logger.log('debug', `#handleInfoForIntent received an appId for the same session, returning local intent results only`);
+                        return localIntentsPromise;
                     }
                 }
-                const appIntentsMap = new Map();
+                await this.#maybeReconnect();
+                const appIntentMap = new Map();
+                const upsertToMap = ({ intent, apps }) => {
+                    // merge all apps for the same intent
+                    const existingApps = appIntentMap.get(intent.name) ?? [];
+                    appIntentMap.set(intent.name, [...existingApps, ...apps]);
+                };
                 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);
-                        });
-                    });
+                    responses.forEach(({ intents }) => intents.forEach(upsertToMap));
                     aggregateResolve();
                 });
                 const options = {
@@ -4261,25 +4285,35 @@ async function cloudInteropOverride(config) {
                 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;
+                const localAppIntents = (await localIntentsPromise
+                    .then((intents) => (Array.isArray(intents) ? intents : [intents]))
+                    .catch(() => []));
+                localAppIntents.forEach(upsertToMap);
+                const appIntents = Array.from(appIntentMap.entries()).map(([intent, apps]) => ({
+                    intent: { name: intent, displayName: intent },
+                    apps
+                }));
+                if (appIntents.length === 0) {
+                    throw new Error('NoAppsFound');
+                }
+                return (intent ? appIntents[0] : appIntents);
             }
-            async #handleFiredIntent(intent, context) {
-                logger.log('debug', `in #handleFiredIntent`, { intent, context });
+            async #handleFiredIntent(clientIdentity, input) {
+                logger.log('debug', `in #handleFiredIntent`, { input });
                 await this.#maybeReconnect();
-                const targetApp = intent?.metadata?.target ?? context?.metadata?.target;
+                const targetApp = input?.metadata?.target;
                 if (!targetApp) {
                     throw new Error(`[CloudInteropOverride] handleFiredIntent requires intent.metadata.target or context.metadata.target to be an appId`);
                 }
+                const isIntent = (input) => 'name' in input;
                 // 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');
+                // if session id not parsable, it's a local intent, also if session id
+                // is parsed and matches the current session, treat it as a local intent
+                if (isLocalTargetSession(targetApp)) {
+                    logger.log('debug', `#handleFiredIntent received an appId for the same session, firing intent locally`);
+                    return (isIntent(input)
+                        ? super.handleFiredIntent(input, clientIdentity)
+                        : super.handleFiredIntentForContext(input, clientIdentity));
                 }
                 let intentResolve;
                 const intentResultPromise = new Promise((resolve) => {
@@ -4289,25 +4323,41 @@ async function cloudInteropOverride(config) {
                     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 };
+                const raiseOptions = isIntent(input)
+                    ? { type: 'raise-intent', intent: input.name, context: input.context }
+                    : { type: 'raise-intent-for-context', context: input };
                 await client.raiseIntent({ appId: targetApp, raiseOptions });
                 // TODO: raise-intent timeout via promise.race?
                 const intentResult = await intentResultPromise;
+                const publishLocalResult = async (result) => {
+                    // NOTE: since we aren't changing getIntentResolution in the fdc3 impl code,
+                    // we "fake" a local intent result to ensure getResult resolves correctly, see:
+                    // js-adapter/src/api/interop/fdc3/utils.ts::getIntentResolution::fin.InterApplicationBus.subscribe
+                    const intentResolutionResultId = input.metadata?.intentResolutionResultId;
+                    // skip for web/external connections
+                    if (!this.fin.me.isOpenFin) {
+                        return;
+                    }
+                    if (intentResolutionResultId) {
+                        this.fin.InterApplicationBus.publish(intentResolutionResultId, result).catch(() => {
+                            logger.log('warn', `#handleFiredIntent could not create an intent resolution for AppId: ${targetApp}, getResult call will not work.`, intentResult);
+                        });
+                    }
+                };
                 if ('error' in intentResult) {
                     logger.log('warn', `#handleFiredIntent could not raise intent for AppId: ${targetApp}`);
+                    // matching { error: Boolean } type of js-adapter/src/api/interop/fdc3/utils.ts::IntentResultPromisePayload
+                    publishLocalResult({ error: true });
                     // 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;
+                const finalResult = { ...intentResult, source };
+                publishLocalResult(finalResult.getResult);
                 return {
-                    intent: intentResult.intent,
-                    version: intentResult.version,
-                    source,
+                    ...finalResult,
                     // Currently only supporting contexts as results
-                    getResult: async () => intentResult.getResult
+                    getResult: async () => finalResult.getResult
                 };
             }
             async setContextForGroup({ context }, contextGroupId) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/cloud-interop",
-    "version": "0.40.38",
+    "version": "0.40.39",
     "description": "",
     "private": false,
     "files": [
@@ -20,7 +20,7 @@
     "author": "",
     "license": "SEE LICENSE IN LICENSE.md",
     "peerDependencies": {
-        "@openfin/core": "40.103.4"
+        "@openfin/core": "40.103.5"
     },
     "dependencies": {
         "@openfin/cloud-interop-core-api": "0.0.1-alpha.a27677b"