@grouparoo/core/dist/modules/ops/app.js

The Grouparoo Core

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AppOps = void 0;
const actionhero_1 = require("actionhero");
const locks_1 = require("../locks");
const optionHelper_1 = require("../optionHelper");
var AppOps;
(function (AppOps) {
    /**
     * Connect to an App
     */
    async function connect(app, options, forceReconnect = false) {
        const { pluginApp } = await app.getPlugin();
        if (!pluginApp.methods.connect)
            return;
        let connection;
        const appOptions = await app.getOptions(true);
        const { releaseLock } = await getConnectionLock(app);
        try {
            connection = actionhero_1.api.plugins.persistentConnections[app.id];
            if (connection) {
                if (forceReconnect) {
                    await disconnect(app, true);
                }
                else {
                    return connection;
                }
            }
            (0, actionhero_1.log)(`connecting to app ${app.name} - ${pluginApp.name} (${app.id})`, "debug");
            connection = await pluginApp.methods.connect({
                app,
                appId: app.id,
                appOptions: options ? options : appOptions,
            });
            app.setConnection(connection);
        }
        finally {
            await releaseLock();
        }
        return connection;
    }
    AppOps.connect = connect;
    /**
     * Disconnect from an App
     */
    async function disconnect(app, alreadyLocked = false) {
        const appOptions = await app.getOptions(true);
        const { pluginApp } = await app.getPlugin();
        if (!pluginApp.methods.disconnect)
            return;
        let releaseLock;
        try {
            if (!alreadyLocked) {
                const lockResponse = await getConnectionLock(app);
                releaseLock = lockResponse.releaseLock;
            }
            const connection = actionhero_1.api.plugins.persistentConnections[app.id];
            if (connection) {
                (0, actionhero_1.log)(`disconnecting from app ${app.name} - ${pluginApp.name} (${app.id})`, "debug");
                await pluginApp.methods.disconnect({
                    app,
                    appId: app.id,
                    appOptions,
                    connection,
                });
                app.setConnection(undefined);
            }
        }
        finally {
            if (releaseLock)
                await releaseLock();
        }
    }
    AppOps.disconnect = disconnect;
    /**
     * Test an App's Connection
     */
    async function test(app, options) {
        let success = false;
        let message;
        let error;
        const { pluginApp } = await app.getPlugin();
        if (!pluginApp) {
            throw new Error(`cannot find a pluginApp type of ${app.type}`);
        }
        const filteredOptions = optionHelper_1.OptionHelper.filterEmptyOptions(options);
        let sanitizedOptions = await optionHelper_1.OptionHelper.replaceObfuscatedOptions(app, filteredOptions);
        sanitizedOptions = optionHelper_1.OptionHelper.sourceEnvironmentVariableOptions(app, sanitizedOptions);
        let connection;
        try {
            if (pluginApp.methods.connect) {
                connection = await pluginApp.methods.connect({
                    app,
                    appId: app.id,
                    appOptions: sanitizedOptions,
                });
            }
            const result = await pluginApp.methods.test({
                app,
                appId: app.id,
                appOptions: sanitizedOptions,
                connection,
            });
            message = result.message;
            success = result.success;
        }
        catch (err) {
            error = err.message || err.toString();
            success = false;
            (0, actionhero_1.log)(`[ app ] testing app ${app.name} (${app.id}) threw error: ${error}`, "notice");
        }
        finally {
            if (connection && pluginApp.methods.disconnect) {
                await pluginApp.methods.disconnect({
                    connection,
                    app,
                    appId: app.id,
                    appOptions: sanitizedOptions,
                });
            }
        }
        return { success, message, error };
    }
    AppOps.test = test;
    async function getConnectionLock(app) {
        const key = `app:${app.id}:connection:${actionhero_1.id}`;
        return (0, locks_1.waitForLock)(key);
    }
})(AppOps = exports.AppOps || (exports.AppOps = {}));