@app-connect/core 1.7.36 → 1.7.38

package/{handlers → dist/handlers}/managedOAuth.js

@@ -1,7 +1,23 @@
-const { AccountDataModel } = require('../models/accountDataModel');
-const { CacheModel } = require('../models/cacheModel');
-const { encode, decoded } = require('../lib/encode');
-
+"use strict";
+// @ts-check
+/** @typedef {import('../types').ManagedOAuthAccountParams} ManagedOAuthAccountParams */
+/** @typedef {import('../types').ManagedOAuthPendingParams} ManagedOAuthPendingParams */
+/** @typedef {import('../types').ManagedOAuthRecord} ManagedOAuthRecord */
+/** @typedef {import('../types').ManagedOAuthResolution} ManagedOAuthResolution */
+/** @typedef {import('../types').ManagedOAuthState} ManagedOAuthState */
+/** @typedef {import('../types').ManagedOAuthStateParams} ManagedOAuthStateParams */
+/** @typedef {import('../types').ManagedOAuthStoredData} ManagedOAuthStoredData */
+/** @typedef {import('../types').ManagedOAuthStoredValue} ManagedOAuthStoredValue */
+/** @typedef {import('../types').ManagedOAuthValue} ManagedOAuthValue */
+/** @typedef {import('../types').ManagedOAuthValues} ManagedOAuthValues */
+/** @typedef {import('../types').ResetManagedOAuthResult} ResetManagedOAuthResult */
+/** @typedef {import('../types').UpsertPendingManagedOAuthParams} UpsertPendingManagedOAuthParams */
+Object.defineProperty(exports, "__esModule", { value: true });
+const { AccountDataModel: AccountDataModelImport } = require('../models/accountDataModel');
+const { CacheModel: CacheModelImport } = require('../models/cacheModel');
+const AccountDataModel = /** @type {any} */ (AccountDataModelImport);
+const CacheModel = /** @type {any} */ (CacheModelImport);
+const { encode, decoded } = /** @type {{ encode(data: string): string, decoded(data: string): string }} */ (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 = [
@@ -13,15 +29,24 @@ const MANAGED_OAUTH_FIELDS = [
     'scopes',
     'hostname'
 ];
-
+/**
+ * @param {ManagedOAuthPendingParams} params
+ * @returns {string}
+ */
 function getPendingManagedOAuthCacheId({ rcAccountId }) {
     return `${rcAccountId}-${MANAGED_OAUTH_ACCOUNT_DATA_KEY}`;
 }
-
+/**
+ * @param {unknown} value
+ * @returns {boolean}
+ */
 function isFilled(value) {
     return value !== undefined && value !== null && value !== '';
 }
-
+/**
+ * @param {ManagedOAuthValue} value
+ * @returns {ManagedOAuthStoredValue}
+ */
 function encryptStoredValue(value) {
     return {
         version: 1,
@@ -29,19 +54,26 @@ function encryptStoredValue(value) {
         value: encode(JSON.stringify(value))
     };
 }
-
+/**
+ * @param {ManagedOAuthStoredValue | ManagedOAuthValue} value
+ * @returns {ManagedOAuthValue | undefined}
+ */
 function decryptStoredValue(value) {
     if (!value) {
         return undefined;
     }
-    if (value?.encrypted && value?.value) {
-        return JSON.parse(decoded(value.value));
+    const storedValue = /** @type {ManagedOAuthStoredValue} */ (value);
+    if (storedValue?.encrypted && storedValue?.value) {
+        return JSON.parse(decoded(storedValue.value));
     }
     return value;
 }
-
+/**
+ * @param {ManagedOAuthValues} [values]
+ * @returns {ManagedOAuthValues}
+ */
 function normalizeManagedOAuthValues(values = {}) {
-    const normalized = {};
+    const normalized = /** @type {ManagedOAuthValues} */ ({});
     MANAGED_OAUTH_FIELDS.forEach(field => {
         if (isFilled(values[field])) {
             normalized[field] = values[field];
@@ -49,31 +81,43 @@ function normalizeManagedOAuthValues(values = {}) {
     });
     return normalized;
 }
-
+/**
+ * @param {ManagedOAuthValues} [values]
+ * @returns {ManagedOAuthStoredData}
+ */
 function buildStoredData(values = {}) {
     const normalized = normalizeManagedOAuthValues(values);
-    const fields = {};
+    const fields = /** @type {Record<string, ManagedOAuthStoredValue>} */ ({});
     Object.keys(normalized).forEach(key => {
         fields[key] = encryptStoredValue(normalized[key]);
     });
     return { fields };
 }
-
+/**
+ * @param {ManagedOAuthStoredData} [data]
+ * @returns {ManagedOAuthValues}
+ */
 function decryptStoredData(data = {}) {
     const fields = data?.fields ?? {};
-    const values = {};
+    const values = /** @type {ManagedOAuthValues} */ ({});
     Object.keys(fields).forEach(key => {
         values[key] = decryptStoredValue(fields[key]);
     });
     return values;
 }
-
+/**
+ * @param {ManagedOAuthValues} [values]
+ * @returns {ManagedOAuthValues}
+ */
 function removeSecret(values = {}) {
     const sanitized = { ...values };
     delete sanitized.clientSecret;
     return sanitized;
 }
-
+/**
+ * @param {ManagedOAuthAccountParams} params
+ * @returns {Promise<ManagedOAuthRecord | null>}
+ */
 async function getAccountManagedOAuthRecord({ rcAccountId, platform }) {
     if (!rcAccountId || !platform) {
         return null;
@@ -86,7 +130,10 @@ async function getAccountManagedOAuthRecord({ rcAccountId, platform }) {
         }
     });
 }
-
+/**
+ * @param {ManagedOAuthPendingParams} params
+ * @returns {Promise<ManagedOAuthRecord | null>}
+ */
 async function getPendingManagedOAuthRecord({ rcAccountId }) {
     if (!rcAccountId) {
         return null;
@@ -101,17 +148,26 @@ async function getPendingManagedOAuthRecord({ rcAccountId }) {
     }
     return record;
 }
-
+/**
+ * @param {ManagedOAuthAccountParams} params
+ * @returns {Promise<ManagedOAuthValues>}
+ */
 async function getAccountManagedOAuthValues({ rcAccountId, platform }) {
     const record = await getAccountManagedOAuthRecord({ rcAccountId, platform });
     return decryptStoredData(record?.data);
 }
-
+/**
+ * @param {ManagedOAuthPendingParams} params
+ * @returns {Promise<ManagedOAuthValues>}
+ */
 async function getPendingManagedOAuthValues({ rcAccountId }) {
     const record = await getPendingManagedOAuthRecord({ rcAccountId });
     return decryptStoredData(record?.data);
 }
-
+/**
+ * @param {ManagedOAuthStateParams} params
+ * @returns {Promise<ManagedOAuthState>}
+ */
 async function getManagedOAuthState({ rcAccountId, platform, isAdmin }) {
     const accountValues = await getAccountManagedOAuthValues({ rcAccountId, platform });
     const hasAccountOAuth = Object.keys(accountValues).length > 0;
@@ -119,7 +175,6 @@ async function getManagedOAuthState({ rcAccountId, platform, isAdmin }) {
         ? await getPendingManagedOAuthValues({ rcAccountId })
         : {};
     const hasPendingOAuth = Object.keys(pendingValues).length > 0;
-
     return {
         isAdmin: !!isAdmin,
         hasAccountOAuth,
@@ -128,7 +183,10 @@ async function getManagedOAuthState({ rcAccountId, platform, isAdmin }) {
         ...(isAdmin && hasPendingOAuth ? { pendingValues } : {})
     };
 }
-
+/**
+ * @param {UpsertPendingManagedOAuthParams} params
+ * @returns {Promise<ManagedOAuthRecord>}
+ */
 async function upsertPendingManagedOAuth({ rcAccountId, values = {} }) {
     if (!rcAccountId) {
         throw new Error('rcAccountId is required');
@@ -156,7 +214,10 @@ async function upsertPendingManagedOAuth({ rcAccountId, values = {} }) {
         expiry
     });
 }
-
+/**
+ * @param {ManagedOAuthAccountParams} params
+ * @returns {Promise<boolean>}
+ */
 async function migratePendingManagedOAuth({ rcAccountId, platform }) {
     const pending = await getPendingManagedOAuthRecord({ rcAccountId });
     if (!pending) {
@@ -178,7 +239,10 @@ async function migratePendingManagedOAuth({ rcAccountId, platform }) {
     await pending.destroy();
     return true;
 }
-
+/**
+ * @param {ManagedOAuthAccountParams} params
+ * @returns {Promise<ManagedOAuthResolution>}
+ */
 async function resolveManagedOAuthInfo({ rcAccountId, platform }) {
     const accountValues = await getAccountManagedOAuthValues({ rcAccountId, platform });
     if (Object.keys(accountValues).length > 0) {
@@ -199,7 +263,10 @@ async function resolveManagedOAuthInfo({ rcAccountId, platform }) {
         oauthInfo: null
     };
 }
-
+/**
+ * @param {ManagedOAuthPendingParams} params
+ * @returns {Promise<number>}
+ */
 async function clearPendingManagedOAuth({ rcAccountId }) {
     if (!rcAccountId) {
         return 0;
@@ -210,7 +277,10 @@ async function clearPendingManagedOAuth({ rcAccountId }) {
         }
     });
 }
-
+/**
+ * @param {ManagedOAuthAccountParams} params
+ * @returns {Promise<number>}
+ */
 async function clearAccountManagedOAuth({ rcAccountId, platform }) {
     if (!rcAccountId || !platform) {
         return 0;
@@ -223,7 +293,10 @@ async function clearAccountManagedOAuth({ rcAccountId, platform }) {
         }
     });
 }
-
+/**
+ * @param {ManagedOAuthAccountParams} params
+ * @returns {Promise<ResetManagedOAuthResult>}
+ */
 async function resetManagedOAuth({ rcAccountId, platform }) {
     const deletedAccountCount = await clearAccountManagedOAuth({ rcAccountId, platform });
     const deletedPendingCount = await clearPendingManagedOAuth({ rcAccountId });
@@ -232,7 +305,6 @@ async function resetManagedOAuth({ rcAccountId, platform }) {
         deletedPendingCount
     };
 }
-
 exports.MANAGED_OAUTH_ACCOUNT_DATA_KEY = MANAGED_OAUTH_ACCOUNT_DATA_KEY;
 exports.MANAGED_OAUTH_FIELDS = MANAGED_OAUTH_FIELDS;
 exports.getManagedOAuthState = getManagedOAuthState;

package/dist/handlers/plugin.d.ts

@@ -0,0 +1 @@
+export {};

package/{handlers → dist/handlers}/plugin.js

@@ -1,11 +1,24 @@
+"use strict";
+// @ts-check
+Object.defineProperty(exports, "__esModule", { value: true });
 const { CacheModel } = require('../models/cacheModel');
 const { Op } = require('sequelize');
-const axios = require('axios');
-const { AccountDataModel } = require('../models/accountDataModel');
+const axios = /** @type {any} */ (require('axios'));
+const { AccountDataModel: AccountDataModelImport } = require('../models/accountDataModel');
+const AccountDataModel = /** @type {any} */ (AccountDataModelImport);
 const logger = require('../lib/logger');
-
+/** @typedef {import('../types').InstalledPlugin} InstalledPlugin */
+/** @typedef {import('../types').JsonObject} JsonObject */
+/** @typedef {import('../types').PluginAccess} PluginAccess */
+/** @typedef {import('../types').PluginLicenseStatus} PluginLicenseStatus */
+/** @typedef {import('../types').ResolvePluginManifestResult} ResolvePluginManifestResult */
+/** @typedef {import('../types').RegisterPluginAccountResult} RegisterPluginAccountResult */
+/** @typedef {import('../types').UserSettings} UserSettings */
 const PUBLIC_MANIFEST_BASE = 'https://appconnect.labs.ringcentral.com/public-api/connectors';
-
+/**
+ * @param {{ rcAccountId: string | number }} params
+ * @returns {Promise<InstalledPlugin[]>}
+ */
 async function getPluginsFromRcAccountId({ rcAccountId }) {
     const accountData = await AccountDataModel.findAll({
         where: {
@@ -19,18 +32,25 @@ async function getPluginsFromRcAccountId({ rcAccountId }) {
     }));
     return workingPlugins;
 }
-
+/**
+ * @param {{ userSettings?: UserSettings | null, pluginId: string }} params
+ * @returns {JsonObject | null}
+ */
 function getPluginConfigFromUserSettings({ userSettings, pluginId }) {
     if (!userSettings) {
         return null;
     }
     const targetPluginSettings = userSettings[`plugin_${pluginId}`];
-    if (!targetPluginSettings?.value?.config) {
+    const targetPluginSettingsValue = /** @type {{ config?: JsonObject } | undefined} */ (targetPluginSettings?.value);
+    if (!targetPluginSettingsValue?.config) {
         return null;
     }
-    return targetPluginSettings.value.config;
+    return targetPluginSettingsValue.config;
 }
-
+/**
+ * @param {{ rcAccountId: string | number, pluginId: string }} params
+ * @returns {Promise<PluginLicenseStatus | null>}
+ */
 async function getPluginLicenseStatus({ rcAccountId, pluginId }) {
     const accountData = await AccountDataModel.findOne({
         where: {
@@ -57,25 +77,32 @@ async function getPluginLicenseStatus({ rcAccountId, pluginId }) {
     }
     return licenseStatus;
 }
-
+/**
+ * @param {{ headers?: Record<string, string> | null }} params
+ * @returns {string | null}
+ */
 function getRefreshedJwtTokenFromHeaders({ headers }) {
     if (!headers) {
         return null;
     }
     return headers['x-refreshed-jwt-token'] || headers['X-Refreshed-Jwt-Token'] || null;
 }
-
+/**
+ * @param {{ pluginId: string, pluginAccess?: PluginAccess, ownerRcAccountId?: string | number, pluginName?: string }} params
+ * @returns {Promise<ResolvePluginManifestResult>}
+ */
 async function resolvePluginManifest({ pluginId, pluginAccess, ownerRcAccountId, pluginName }) {
     const manifestFetchers = [];
     if (pluginAccess === 'public') {
         manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?type=plugin`);
-    } else if (pluginAccess === 'private' || pluginAccess === 'shared') {
+    }
+    else if (pluginAccess === 'private' || pluginAccess === 'shared') {
         manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?access=internal&type=plugin&accountId=${ownerRcAccountId}`);
-    } else {
+    }
+    else {
         manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?type=plugin`);
         manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?access=internal&type=plugin&accountId=${ownerRcAccountId}`);
     }
-
     let pluginData = null;
     let lastError = null;
     for (const url of manifestFetchers) {
@@ -83,27 +110,28 @@ async function resolvePluginManifest({ pluginId, pluginAccess, ownerRcAccountId,
             const pluginDataResponse = await axios.get(url);
             pluginData = pluginDataResponse.data;
             break;
-        } catch (error) {
+        }
+        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,
     };
 }
-
+/**
+ * @param {{ rcAccountId: string | number, pluginId: string, jwtToken: string, pluginData?: JsonObject }} params
+ * @returns {Promise<void>}
+ */
 async function persistPluginData({ rcAccountId, pluginId, jwtToken, pluginData = {} }) {
     try {
         const accountData = await AccountDataModel.findOne({
@@ -122,7 +150,8 @@ async function persistPluginData({ rcAccountId, pluginId, jwtToken, pluginData =
                     ...pluginData,
                 },
             });
-        } else {
+        }
+        else {
             await accountData.update({
                 data: {
                     jwtToken,
@@ -130,7 +159,8 @@ async function persistPluginData({ rcAccountId, pluginId, jwtToken, pluginData =
                 },
             });
         }
-    } catch (error) {
+    }
+    catch (error) {
         logger.error('Failed to persist plugin data', {
             pluginId,
             rcAccountId,
@@ -138,13 +168,15 @@ async function persistPluginData({ rcAccountId, pluginId, jwtToken, pluginData =
         });
     }
 }
-
+/**
+ * @param {{ pluginId: string, rcAccessToken: string, rcAccountId: string | number, pluginAccess?: PluginAccess, pluginName?: string, ownerRcAccountId?: string | number }} params
+ * @returns {Promise<RegisterPluginAccountResult>}
+ */
 async function registerPluginAccount({ pluginId, rcAccessToken, rcAccountId, pluginAccess, pluginName, ownerRcAccountId }) {
     const { pluginManifest } = await resolvePluginManifest({ pluginId, pluginAccess, ownerRcAccountId, 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,
@@ -154,21 +186,22 @@ async function registerPluginAccount({ pluginId, rcAccessToken, rcAccountId, plu
     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,
     };
 }
-
+/**
+ * @param {{ pluginId: string, rcAccountId: string | number }} params
+ * @returns {Promise<void>}
+ */
 async function unregisterPluginAccount({ pluginId, rcAccountId }) {
     const accountData = await AccountDataModel.findOne({
         where: {
@@ -181,7 +214,6 @@ async function unregisterPluginAccount({ pluginId, rcAccountId }) {
         await accountData.destroy();
     }
 }
-
 exports.getPluginsFromRcAccountId = getPluginsFromRcAccountId;
 exports.getPluginConfigFromUserSettings = getPluginConfigFromUserSettings;
 exports.getPluginLicenseStatus = getPluginLicenseStatus;
@@ -189,4 +221,4 @@ exports.getRefreshedJwtTokenFromHeaders = getRefreshedJwtTokenFromHeaders;
 exports.resolvePluginManifest = resolvePluginManifest;
 exports.persistPluginData = persistPluginData;
 exports.registerPluginAccount = registerPluginAccount;
-exports.unregisterPluginAccount = unregisterPluginAccount;
+exports.unregisterPluginAccount = unregisterPluginAccount;

package/dist/handlers/user.d.ts

@@ -0,0 +1 @@
+export {};

package/{handlers → dist/handlers}/user.js

@@ -1,14 +1,30 @@
-const axios = require('axios');
-const { AdminConfigModel } = require('../models/adminConfigModel');
+"use strict";
+// @ts-check
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios = /** @type {any} */ (require('axios'));
+const { AdminConfigModel: AdminConfigModelImport } = require('../models/adminConfigModel');
 const { getHashValue } = require('../lib/util');
-const connectorRegistry = require('../connector/registry');
+const connectorRegistry = /** @type {any} */ (require('../connector/registry'));
 const logger = require('../lib/logger');
 const { handleDatabaseError } = require('../lib/errorHandler');
-const { UserModel } = require('../models/userModel');
+const { UserModel: UserModelImport } = require('../models/userModel');
 const { handleApiError } = require('../lib/errorHandler');
-const oauth = require('../lib/oauth');
-const { Connector } = require('../models/dynamo/connectorSchema');
-
+const oauth = /** @type {any} */ (require('../lib/oauth'));
+const { Connector: ConnectorImport } = require('../models/dynamo/connectorSchema');
+const AdminConfigModel = /** @type {any} */ (AdminConfigModelImport);
+const UserModel = /** @type {any} */ (UserModelImport);
+const Connector = /** @type {any} */ (ConnectorImport);
+/** @typedef {import('../types').GetUserSettingsParams} GetUserSettingsParams */
+/** @typedef {import('../types').HandlerResult} HandlerResult */
+/** @typedef {import('../types').RefreshUserInfoParams} RefreshUserInfoParams */
+/** @typedef {import('../types').UpdateUserSettingsParams} UpdateUserSettingsParams */
+/** @typedef {import('../types').UserSettings} UserSettings */
+/** @typedef {import('../types').UserSettingsByAdminParams} UserSettingsByAdminParams */
+/** @typedef {import('../types').UserSettingsByAdminResult} UserSettingsByAdminResult */
+/**
+ * @param {RefreshUserInfoParams} params
+ * @returns {Promise<HandlerResult>}
+ */
 async function refreshUserInfo({ platform, userId, tracer }) {
     tracer?.trace('refreshUserInfo:start', { platform, userId });
     try {
@@ -19,7 +35,6 @@ async function refreshUserInfo({ platform, userId, tracer }) {
             }
         });
         tracer?.trace('refreshUserInfo:userFound', { user });
-
         if (!user || !user.accessToken) {
             tracer?.trace('refreshUserInfo:noUser', { userId });
             return {
@@ -31,18 +46,15 @@ async function refreshUserInfo({ platform, userId, tracer }) {
                 }
             };
         }
-
         const proxyId = user.platformAdditionalInfo?.proxyId;
         let proxyConfig = null;
         if (proxyId) {
             proxyConfig = await Connector.getProxyConfig(proxyId);
             tracer?.trace('refreshUserInfo:proxyConfig', { proxyConfig });
         }
-
         const platformModule = connectorRegistry.getConnector(platform);
         const authType = await platformModule.getAuthType({ proxyId, proxyConfig });
         tracer?.trace('refreshUserInfo:authType', { authType });
-
         let authHeader = '';
         switch (authType) {
             case 'oauth':
@@ -57,7 +69,7 @@ async function refreshUserInfo({ platform, userId, tracer }) {
                             ttl: 5000
                         },
                         isRevokeUserSession: true
-                    }
+                    };
                 }
                 authHeader = `Bearer ${user.accessToken}`;
                 tracer?.trace('refreshUserInfo:oauthAuth', { authHeader });
@@ -68,7 +80,6 @@ async function refreshUserInfo({ platform, userId, tracer }) {
                 tracer?.trace('refreshUserInfo:apiKeyAuth', {});
                 break;
         }
-
         const { successful, returnMessage } = await platformModule.refreshUserInfo({ user, authHeader, proxyConfig });
         tracer?.trace('refreshUserInfo:platformRefreshResult', { successful, returnMessage });
         return {
@@ -81,20 +92,21 @@ async function refreshUserInfo({ platform, userId, tracer }) {
         return handleApiError(e, platform, 'refreshUserInfo', { userId });
     }
 }
-
+/**
+ * @param {UserSettingsByAdminParams} params
+ * @returns {Promise<UserSettingsByAdminResult>}
+ */
 async function getUserSettingsByAdmin({ rcAccessToken, rcAccountId }) {
     let hashedRcAccountId = null;
     if (rcAccountId) {
         hashedRcAccountId = rcAccountId;
     }
     else {
-        const rcExtensionResponse = await axios.get(
-            'https://platform.ringcentral.com/restapi/v1.0/account/~/extension/~',
-            {
-                headers: {
-                    Authorization: `Bearer ${rcAccessToken}`,
-                },
-            });
+        const rcExtensionResponse = await axios.get('https://platform.ringcentral.com/restapi/v1.0/account/~/extension/~', {
+            headers: {
+                Authorization: `Bearer ${rcAccessToken}`,
+            },
+        });
         hashedRcAccountId = getHashValue(rcExtensionResponse.data.account.id, process.env.HASH_KEY);
     }
     const adminConfig = await AdminConfigModel.findByPk(hashedRcAccountId);
@@ -102,21 +114,25 @@ async function getUserSettingsByAdmin({ rcAccessToken, rcAccountId }) {
         userSettings: adminConfig?.userSettings
     };
 }
-
+/**
+ * @param {GetUserSettingsParams} params
+ * @returns {Promise<UserSettings>}
+ */
 async function getUserSettings({ user, rcAccessToken, rcAccountId }) {
+    /** @type {any} */
     let userSettingsByAdmin = [];
     if (rcAccessToken || rcAccountId) {
         try {
             userSettingsByAdmin = await getUserSettingsByAdmin({ rcAccessToken, rcAccountId });
         }
         catch (e) {
-            logger.error('Error getting user settings by admin', { stack: e.stack });
+            logger.error('Error getting user settings by admin', { stack: /** @type {any} */ (e).stack });
             userSettingsByAdmin = [];
         }
     }
-
     // For non-readonly admin settings, user use its own setting
     let userSettings = await user?.userSettings;
+    /** @type {any} */
     let result = {};
     if (!userSettingsByAdmin?.userSettings) {
         result = userSettings;
@@ -177,7 +193,10 @@ async function getUserSettings({ user, rcAccessToken, rcAccountId }) {
     }
     return result;
 }
-
+/**
+ * @param {UpdateUserSettingsParams} params
+ * @returns {Promise<HandlerResult | { userSettings?: UserSettings }>}
+ */
 async function updateUserSettings({ user, userSettings, settingKeysToRemove, platformName }) {
     const keys = Object.keys(userSettings || {});
     let updatedSettings = {
@@ -223,8 +242,7 @@ async function updateUserSettings({ user, userSettings, settingKeysToRemove, pla
         userSettings: user.userSettings
     };
 }
-
 exports.refreshUserInfo = refreshUserInfo;
 exports.getUserSettingsByAdmin = getUserSettingsByAdmin;
 exports.getUserSettings = getUserSettings;
-exports.updateUserSettings = updateUserSettings;
+exports.updateUserSettings = updateUserSettings;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};