@openfin/cloud-interop 0.41.107 → 0.42.0

package/out/index.js

@@ -726,11 +726,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();
     }
@@ -780,9 +787,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 {
@@ -792,15 +800,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();
@@ -810,48 +818,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 = {
@@ -864,25 +888,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;
-            }
-            async #handleFiredIntent(intent, context) {
-                logger.log('debug', `in #handleFiredIntent`, { intent, context });
+                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(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) => {
@@ -892,25 +926,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.41.107",
+    "version": "0.42.0",
     "description": "",
     "private": false,
     "files": [
@@ -20,7 +20,7 @@
     "author": "",
     "license": "SEE LICENSE IN LICENSE.md",
     "peerDependencies": {
-        "@openfin/core": "41.100.105"
+        "@openfin/core": "42.100.1"
     },
     "dependencies": {
         "@openfin/cloud-interop-core-api": "0.0.1-alpha.a27677b"