@app-connect/core 1.7.25 → 1.7.27

package/handlers/managedOAuth.js

@@ -0,0 +1,247 @@
+const { AccountDataModel } = require('../models/accountDataModel');
+const { CacheModel } = require('../models/cacheModel');
+const { encode, decoded } = require('../lib/encode');
+
+const MANAGED_OAUTH_ACCOUNT_DATA_KEY = 'managed-oauth-account';
+const MANAGED_OAUTH_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const MANAGED_OAUTH_FIELDS = [
+    'clientId',
+    'clientSecret',
+    'accessTokenUri',
+    'authorizationUri',
+    'redirectUri',
+    'scopes',
+    'hostname'
+];
+
+function getPendingManagedOAuthCacheId({ rcAccountId }) {
+    return `${rcAccountId}-${MANAGED_OAUTH_ACCOUNT_DATA_KEY}`;
+}
+
+function isFilled(value) {
+    return value !== undefined && value !== null && value !== '';
+}
+
+function encryptStoredValue(value) {
+    return {
+        version: 1,
+        encrypted: true,
+        value: encode(JSON.stringify(value))
+    };
+}
+
+function decryptStoredValue(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (value?.encrypted && value?.value) {
+        return JSON.parse(decoded(value.value));
+    }
+    return value;
+}
+
+function normalizeManagedOAuthValues(values = {}) {
+    const normalized = {};
+    MANAGED_OAUTH_FIELDS.forEach(field => {
+        if (isFilled(values[field])) {
+            normalized[field] = values[field];
+        }
+    });
+    return normalized;
+}
+
+function buildStoredData(values = {}) {
+    const normalized = normalizeManagedOAuthValues(values);
+    const fields = {};
+    Object.keys(normalized).forEach(key => {
+        fields[key] = encryptStoredValue(normalized[key]);
+    });
+    return { fields };
+}
+
+function decryptStoredData(data = {}) {
+    const fields = data?.fields ?? {};
+    const values = {};
+    Object.keys(fields).forEach(key => {
+        values[key] = decryptStoredValue(fields[key]);
+    });
+    return values;
+}
+
+function removeSecret(values = {}) {
+    const sanitized = { ...values };
+    delete sanitized.clientSecret;
+    return sanitized;
+}
+
+async function getAccountManagedOAuthRecord({ rcAccountId, platform }) {
+    if (!rcAccountId || !platform) {
+        return null;
+    }
+    return AccountDataModel.findOne({
+        where: {
+            rcAccountId,
+            platformName: platform,
+            dataKey: MANAGED_OAUTH_ACCOUNT_DATA_KEY
+        }
+    });
+}
+
+async function getPendingManagedOAuthRecord({ rcAccountId }) {
+    if (!rcAccountId) {
+        return null;
+    }
+    const record = await CacheModel.findByPk(getPendingManagedOAuthCacheId({ rcAccountId }));
+    if (!record) {
+        return null;
+    }
+    if (record.expiry && new Date(record.expiry).getTime() <= Date.now()) {
+        await record.destroy();
+        return null;
+    }
+    return record;
+}
+
+async function getAccountManagedOAuthValues({ rcAccountId, platform }) {
+    const record = await getAccountManagedOAuthRecord({ rcAccountId, platform });
+    return decryptStoredData(record?.data);
+}
+
+async function getPendingManagedOAuthValues({ rcAccountId }) {
+    const record = await getPendingManagedOAuthRecord({ rcAccountId });
+    return decryptStoredData(record?.data);
+}
+
+async function getManagedOAuthState({ rcAccountId, platform, isAdmin }) {
+    const accountValues = await getAccountManagedOAuthValues({ rcAccountId, platform });
+    const hasAccountOAuth = Object.keys(accountValues).length > 0;
+    const pendingValues = isAdmin && !hasAccountOAuth
+        ? await getPendingManagedOAuthValues({ rcAccountId })
+        : {};
+    const hasPendingOAuth = Object.keys(pendingValues).length > 0;
+
+    return {
+        isAdmin: !!isAdmin,
+        hasAccountOAuth,
+        hasPendingOAuth,
+        ...(hasAccountOAuth ? { oauthValues: removeSecret(accountValues) } : {}),
+        ...(isAdmin && hasPendingOAuth ? { pendingValues } : {})
+    };
+}
+
+async function upsertPendingManagedOAuth({ rcAccountId, values = {} }) {
+    if (!rcAccountId) {
+        throw new Error('rcAccountId is required');
+    }
+    const id = getPendingManagedOAuthCacheId({ rcAccountId });
+    const data = buildStoredData(values);
+    const expiry = new Date(Date.now() + MANAGED_OAUTH_CACHE_TTL_MS);
+    const existing = await CacheModel.findByPk(id);
+    if (existing) {
+        await existing.update({
+            status: 'pending',
+            userId: rcAccountId,
+            cacheKey: MANAGED_OAUTH_ACCOUNT_DATA_KEY,
+            data,
+            expiry
+        });
+        return existing;
+    }
+    return CacheModel.create({
+        id,
+        status: 'pending',
+        userId: rcAccountId,
+        cacheKey: MANAGED_OAUTH_ACCOUNT_DATA_KEY,
+        data,
+        expiry
+    });
+}
+
+async function migratePendingManagedOAuth({ rcAccountId, platform }) {
+    const pending = await getPendingManagedOAuthRecord({ rcAccountId });
+    if (!pending) {
+        return false;
+    }
+    const existing = await getAccountManagedOAuthRecord({ rcAccountId, platform });
+    const data = pending.data ?? { fields: {} };
+    if (existing) {
+        await existing.update({ data });
+    }
+    else {
+        await AccountDataModel.create({
+            rcAccountId,
+            platformName: platform,
+            dataKey: MANAGED_OAUTH_ACCOUNT_DATA_KEY,
+            data
+        });
+    }
+    await pending.destroy();
+    return true;
+}
+
+async function resolveManagedOAuthInfo({ rcAccountId, platform }) {
+    const accountValues = await getAccountManagedOAuthValues({ rcAccountId, platform });
+    if (Object.keys(accountValues).length > 0) {
+        return {
+            source: 'account',
+            oauthInfo: accountValues
+        };
+    }
+    const pendingValues = await getPendingManagedOAuthValues({ rcAccountId });
+    if (Object.keys(pendingValues).length > 0) {
+        return {
+            source: 'pending',
+            oauthInfo: pendingValues
+        };
+    }
+    return {
+        source: null,
+        oauthInfo: null
+    };
+}
+
+async function clearPendingManagedOAuth({ rcAccountId }) {
+    if (!rcAccountId) {
+        return 0;
+    }
+    return CacheModel.destroy({
+        where: {
+            id: getPendingManagedOAuthCacheId({ rcAccountId })
+        }
+    });
+}
+
+async function clearAccountManagedOAuth({ rcAccountId, platform }) {
+    if (!rcAccountId || !platform) {
+        return 0;
+    }
+    return AccountDataModel.destroy({
+        where: {
+            rcAccountId,
+            platformName: platform,
+            dataKey: MANAGED_OAUTH_ACCOUNT_DATA_KEY
+        }
+    });
+}
+
+async function resetManagedOAuth({ rcAccountId, platform }) {
+    const deletedAccountCount = await clearAccountManagedOAuth({ rcAccountId, platform });
+    const deletedPendingCount = await clearPendingManagedOAuth({ rcAccountId });
+    return {
+        deletedAccountCount,
+        deletedPendingCount
+    };
+}
+
+exports.MANAGED_OAUTH_ACCOUNT_DATA_KEY = MANAGED_OAUTH_ACCOUNT_DATA_KEY;
+exports.MANAGED_OAUTH_FIELDS = MANAGED_OAUTH_FIELDS;
+exports.getManagedOAuthState = getManagedOAuthState;
+exports.upsertPendingManagedOAuth = upsertPendingManagedOAuth;
+exports.getPendingManagedOAuthValues = getPendingManagedOAuthValues;
+exports.getAccountManagedOAuthValues = getAccountManagedOAuthValues;
+exports.migratePendingManagedOAuth = migratePendingManagedOAuth;
+exports.resolveManagedOAuthInfo = resolveManagedOAuthInfo;
+exports.clearPendingManagedOAuth = clearPendingManagedOAuth;
+exports.clearAccountManagedOAuth = clearAccountManagedOAuth;
+exports.resetManagedOAuth = resetManagedOAuth;
+exports.removeSecret = removeSecret;

package/handlers/plugin.js

@@ -1,209 +1,209 @@
-const { CacheModel } = require('../models/cacheModel');
-const { Op } = require('sequelize');
-const axios = require('axios');
-const { AccountDataModel } = require('../models/accountDataModel');
-const logger = require('../lib/logger');
-
-const PUBLIC_MANIFEST_BASE = 'https://appconnect.labs.ringcentral.com/public-api/connectors';
-
-async function getPluginsFromRcAccountId({ rcAccountId }) {
-    const accountData = await AccountDataModel.findAll({
-        where: {
-            rcAccountId,
-            dataKey: 'pluginData',
-        },
-    });
-    const workingPlugins = accountData.map(data => ({
-        id: data.platformName,
-        data: data.data,
-    }));
-    return workingPlugins;
-}
-
-function getPluginConfigFromUserSettings({ userSettings, pluginId }) {
-    if (!userSettings) {
-        return null;
-    }
-    const targetPluginSettings = userSettings[`plugin_${pluginId}`];
-    if (!targetPluginSettings?.value?.config) {
-        return null;
-    }
-    return targetPluginSettings.value.config;
-}
-
-async function getPluginLicenseStatus({ rcAccountId, pluginId }) {
-    const accountData = await AccountDataModel.findOne({
-        where: {
-            rcAccountId,
-            platformName: pluginId,
-            dataKey: 'pluginData',
-        },
-    });
-    if (!accountData) {
-        return null;
-    }
-    const licenseStatusUrl = accountData.data.licenseStatusUrl;
-    const licenseStatusResponse = await axios.get(licenseStatusUrl, {
-        headers: {
-            'Authorization': `Bearer ${accountData.data.jwtToken}`
-        }
-    });
-    return licenseStatusResponse.data;
-}
-
-async function getPluginAsyncTasks({ asyncTaskIds }) {
-    const caches = await CacheModel.findAll({
-        where: {
-            id: {
-                [Op.in]: asyncTaskIds
-            }
-        }
-    });
-    const result = caches.map(cache => ({
-        cacheKey: cache.cacheKey,
-        status: cache.status
-    }));
-    const toRemoveCaches = caches.filter(cache => cache.status === 'completed' || cache.status === 'failed');
-    await CacheModel.destroy({
-        where: {
-            id: {
-                [Op.in]: toRemoveCaches.map(cache => cache.id)
-            }
-        }
-    });
-    return result;
-}
-
-function getRefreshedJwtTokenFromHeaders({ headers }) {
-    if (!headers) {
-        return null;
-    }
-    return headers['x-refreshed-jwt-token'] || headers['X-Refreshed-Jwt-Token'] || null;
-}
-
-async function resolvePluginManifest({ pluginId, pluginAccess, rcAccountId, pluginName }) {
-    const manifestFetchers = [];
-    if (pluginAccess === 'public') {
-        manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?type=plugin`);
-    } else if (pluginAccess === 'private' || pluginAccess === 'shared') {
-        manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?access=internal&type=plugin&accountId=${rcAccountId}`);
-    } else {
-        manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?type=plugin`);
-        manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?access=internal&type=plugin&accountId=${rcAccountId}`);
-    }
-
-    let pluginData = null;
-    let lastError = null;
-    for (const url of manifestFetchers) {
-        try {
-            const pluginDataResponse = await axios.get(url);
-            pluginData = pluginDataResponse.data;
-            break;
-        } catch (error) {
-            lastError = error;
-        }
-    }
-
-    if (!pluginData) {
-        throw lastError || new Error(`Unable to resolve manifest for plugin ${pluginId}`);
-    }
-
-    const platformKey = pluginName || Object.keys(pluginData.platforms || {})[0];
-    if (!platformKey || !pluginData.platforms?.[platformKey]) {
-        throw new Error(`Unable to resolve platform manifest for plugin ${pluginId}`);
-    }
-
-    return {
-        pluginData,
-        pluginManifest: pluginData.platforms[platformKey],
-        platformKey,
-    };
-}
-
-async function persistPluginData({ rcAccountId, pluginId, jwtToken, pluginData = {} }) {
-    try {
-        const accountData = await AccountDataModel.findOne({
-            where: {
-                rcAccountId,
-                platformName: pluginId
-            },
-        });
-        if (!accountData) {
-            await AccountDataModel.create({
-                rcAccountId,
-                platformName: pluginId,
-                dataKey: 'pluginData',
-                data: {
-                    jwtToken,
-                    ...pluginData,
-                },
-            });
-        } else {
-            await accountData.update({
-                data: {
-                    jwtToken,
-                    ...pluginData,
-                },
-            });
-        }
-    } catch (error) {
-        logger.error('Failed to persist plugin data', {
-            pluginId,
-            rcAccountId,
-            message: error.message,
-        });
-    }
-}
-
-async function registerPluginAccount({ pluginId, rcAccessToken, rcAccountId, pluginAccess, pluginName }) {
-    const { pluginManifest } = await resolvePluginManifest({ pluginId, pluginAccess, rcAccountId, pluginName });
-    if (!pluginManifest?.endpointUrl) {
-        throw new Error(`Plugin endpoint URL not found for ${pluginId}`);
-    }
-
-    const registerUrl = pluginManifest.userRegisterEndpointUrl;
-    const registerResponse = await axios.post(registerUrl, {
-        rcAccessToken,
-        rcAccountId: rcAccountId?.toString(),
-    });
-    const pluginJwtToken = registerResponse.data?.jwtToken;
-    if (!pluginJwtToken) {
-        throw new Error('Plugin register API did not return jwtToken');
-    }
-
-    await persistPluginData({
-        rcAccountId: rcAccountId?.toString(),
-        pluginId,
-        jwtToken: pluginJwtToken,
-        pluginData: pluginManifest,
-    });
-
-    return {
-        successful: true,
-        registerUrl,
-        jwtToken: pluginJwtToken,
-    };
-}
-
-async function unregisterPluginAccount({ pluginId, rcAccountId }) {
-    const accountData = await AccountDataModel.findOne({
-        where: {
-            rcAccountId,
-            platformName: pluginId,
-            dataKey: 'pluginData'
-        },
-    });
-    if (accountData) {
-        await accountData.destroy();
-    }
-}
-
-exports.getPluginsFromRcAccountId = getPluginsFromRcAccountId;
-exports.getPluginConfigFromUserSettings = getPluginConfigFromUserSettings;
-exports.getPluginLicenseStatus = getPluginLicenseStatus;
-exports.getPluginAsyncTasks = getPluginAsyncTasks;
-exports.getRefreshedJwtTokenFromHeaders = getRefreshedJwtTokenFromHeaders;
-exports.resolvePluginManifest = resolvePluginManifest;
-exports.persistPluginData = persistPluginData;
-exports.registerPluginAccount = registerPluginAccount;
+const { CacheModel } = require('../models/cacheModel');
+const { Op } = require('sequelize');
+const axios = require('axios');
+const { AccountDataModel } = require('../models/accountDataModel');
+const logger = require('../lib/logger');
+
+const PUBLIC_MANIFEST_BASE = 'https://appconnect.labs.ringcentral.com/public-api/connectors';
+
+async function getPluginsFromRcAccountId({ rcAccountId }) {
+    const accountData = await AccountDataModel.findAll({
+        where: {
+            rcAccountId,
+            dataKey: 'pluginData',
+        },
+    });
+    const workingPlugins = accountData.map(data => ({
+        id: data.platformName,
+        data: data.data,
+    }));
+    return workingPlugins;
+}
+
+function getPluginConfigFromUserSettings({ userSettings, pluginId }) {
+    if (!userSettings) {
+        return null;
+    }
+    const targetPluginSettings = userSettings[`plugin_${pluginId}`];
+    if (!targetPluginSettings?.value?.config) {
+        return null;
+    }
+    return targetPluginSettings.value.config;
+}
+
+async function getPluginLicenseStatus({ rcAccountId, pluginId }) {
+    const accountData = await AccountDataModel.findOne({
+        where: {
+            rcAccountId,
+            platformName: pluginId,
+            dataKey: 'pluginData',
+        },
+    });
+    if (!accountData) {
+        return null;
+    }
+    const licenseStatusUrl = accountData.data.licenseStatusUrl;
+    const licenseStatusResponse = await axios.get(licenseStatusUrl, {
+        headers: {
+            'Authorization': `Bearer ${accountData.data.jwtToken}`
+        }
+    });
+    return licenseStatusResponse.data;
+}
+
+async function getPluginAsyncTasks({ asyncTaskIds }) {
+    const caches = await CacheModel.findAll({
+        where: {
+            id: {
+                [Op.in]: asyncTaskIds
+            }
+        }
+    });
+    const result = caches.map(cache => ({
+        cacheKey: cache.cacheKey,
+        status: cache.status
+    }));
+    const toRemoveCaches = caches.filter(cache => cache.status === 'completed' || cache.status === 'failed');
+    await CacheModel.destroy({
+        where: {
+            id: {
+                [Op.in]: toRemoveCaches.map(cache => cache.id)
+            }
+        }
+    });
+    return result;
+}
+
+function getRefreshedJwtTokenFromHeaders({ headers }) {
+    if (!headers) {
+        return null;
+    }
+    return headers['x-refreshed-jwt-token'] || headers['X-Refreshed-Jwt-Token'] || null;
+}
+
+async function resolvePluginManifest({ pluginId, pluginAccess, rcAccountId, pluginName }) {
+    const manifestFetchers = [];
+    if (pluginAccess === 'public') {
+        manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?type=plugin`);
+    } else if (pluginAccess === 'private' || pluginAccess === 'shared') {
+        manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?access=internal&type=plugin&accountId=${rcAccountId}`);
+    } else {
+        manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?type=plugin`);
+        manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?access=internal&type=plugin&accountId=${rcAccountId}`);
+    }
+
+    let pluginData = null;
+    let lastError = null;
+    for (const url of manifestFetchers) {
+        try {
+            const pluginDataResponse = await axios.get(url);
+            pluginData = pluginDataResponse.data;
+            break;
+        } catch (error) {
+            lastError = error;
+        }
+    }
+
+    if (!pluginData) {
+        throw lastError || new Error(`Unable to resolve manifest for plugin ${pluginId}`);
+    }
+
+    const platformKey = pluginName || Object.keys(pluginData.platforms || {})[0];
+    if (!platformKey || !pluginData.platforms?.[platformKey]) {
+        throw new Error(`Unable to resolve platform manifest for plugin ${pluginId}`);
+    }
+
+    return {
+        pluginData,
+        pluginManifest: pluginData.platforms[platformKey],
+        platformKey,
+    };
+}
+
+async function persistPluginData({ rcAccountId, pluginId, jwtToken, pluginData = {} }) {
+    try {
+        const accountData = await AccountDataModel.findOne({
+            where: {
+                rcAccountId,
+                platformName: pluginId
+            },
+        });
+        if (!accountData) {
+            await AccountDataModel.create({
+                rcAccountId,
+                platformName: pluginId,
+                dataKey: 'pluginData',
+                data: {
+                    jwtToken,
+                    ...pluginData,
+                },
+            });
+        } else {
+            await accountData.update({
+                data: {
+                    jwtToken,
+                    ...pluginData,
+                },
+            });
+        }
+    } catch (error) {
+        logger.error('Failed to persist plugin data', {
+            pluginId,
+            rcAccountId,
+            message: error.message,
+        });
+    }
+}
+
+async function registerPluginAccount({ pluginId, rcAccessToken, rcAccountId, pluginAccess, pluginName }) {
+    const { pluginManifest } = await resolvePluginManifest({ pluginId, pluginAccess, rcAccountId, pluginName });
+    if (!pluginManifest?.endpointUrl) {
+        throw new Error(`Plugin endpoint URL not found for ${pluginId}`);
+    }
+
+    const registerUrl = pluginManifest.userRegisterEndpointUrl;
+    const registerResponse = await axios.post(registerUrl, {
+        rcAccessToken,
+        rcAccountId: rcAccountId?.toString(),
+    });
+    const pluginJwtToken = registerResponse.data?.jwtToken;
+    if (!pluginJwtToken) {
+        throw new Error('Plugin register API did not return jwtToken');
+    }
+
+    await persistPluginData({
+        rcAccountId: rcAccountId?.toString(),
+        pluginId,
+        jwtToken: pluginJwtToken,
+        pluginData: pluginManifest,
+    });
+
+    return {
+        successful: true,
+        registerUrl,
+        jwtToken: pluginJwtToken,
+    };
+}
+
+async function unregisterPluginAccount({ pluginId, rcAccountId }) {
+    const accountData = await AccountDataModel.findOne({
+        where: {
+            rcAccountId,
+            platformName: pluginId,
+            dataKey: 'pluginData'
+        },
+    });
+    if (accountData) {
+        await accountData.destroy();
+    }
+}
+
+exports.getPluginsFromRcAccountId = getPluginsFromRcAccountId;
+exports.getPluginConfigFromUserSettings = getPluginConfigFromUserSettings;
+exports.getPluginLicenseStatus = getPluginLicenseStatus;
+exports.getPluginAsyncTasks = getPluginAsyncTasks;
+exports.getRefreshedJwtTokenFromHeaders = getRefreshedJwtTokenFromHeaders;
+exports.resolvePluginManifest = resolvePluginManifest;
+exports.persistPluginData = persistPluginData;
+exports.registerPluginAccount = registerPluginAccount;
 exports.unregisterPluginAccount = unregisterPluginAccount;