@app-connect/core 1.7.35 → 1.7.37

package/test/handlers/plugin.test.js

@@ -16,6 +16,7 @@ const { CacheModel } = require('../../models/cacheModel');
 const { AccountDataModel } = require('../../models/accountDataModel');
 const axios = require('axios');
 const { sequelize } = require('../../models/sequelize');
+const logger = require('../../lib/logger');
 
 describe('Plugin Handler', () => {
   beforeAll(async () => {
@@ -28,6 +29,7 @@ describe('Plugin Handler', () => {
     await CacheModel.destroy({ where: {} });
     await AccountDataModel.destroy({ where: {} });
     jest.clearAllMocks();
+    jest.restoreAllMocks();
   });
 
   afterAll(async () => {
@@ -108,8 +110,302 @@ describe('Plugin Handler', () => {
         pluginName: 'plugin.sample'
       })).rejects.toThrow('Plugin register API did not return jwtToken');
     });
+
+    test('should throw when resolved plugin manifest has no endpoint URL', async () => {
+      axios.get.mockResolvedValue({
+        data: {
+          platforms: {
+            'plugin.sample': {
+              userRegisterEndpointUrl: 'https://plugins.example.com/plugin/auth/register'
+            }
+          }
+        }
+      });
+
+      await expect(pluginHandler.registerPluginAccount({
+        pluginId: 'missing-endpoint',
+        rcAccessToken: 'rc-access-token',
+        rcAccountId: '12345',
+        pluginAccess: 'public',
+        pluginName: 'plugin.sample'
+      })).rejects.toThrow('Plugin endpoint URL not found for missing-endpoint');
+    });
   });
 
+  describe('plugin data helpers', () => {
+    test('should list persisted plugin data for an RC account', async () => {
+      await AccountDataModel.bulkCreate([
+        {
+          rcAccountId: '12345',
+          platformName: 'plugin-one',
+          dataKey: 'pluginData',
+          data: { endpointUrl: 'https://plugin-one.example.com' }
+        },
+        {
+          rcAccountId: '12345',
+          platformName: 'plugin-two',
+          dataKey: 'pluginData',
+          data: { endpointUrl: 'https://plugin-two.example.com' }
+        },
+        {
+          rcAccountId: '12345',
+          platformName: 'not-plugin',
+          dataKey: 'otherData',
+          data: { ignored: true }
+        }
+      ]);
+
+      await expect(pluginHandler.getPluginsFromRcAccountId({ rcAccountId: '12345' }))
+        .resolves.toEqual([
+          { id: 'plugin-one', data: { endpointUrl: 'https://plugin-one.example.com' } },
+          { id: 'plugin-two', data: { endpointUrl: 'https://plugin-two.example.com' } }
+        ]);
+    });
+
+    test('should resolve plugin config from user settings and return null for missing config', () => {
+      expect(pluginHandler.getPluginConfigFromUserSettings({
+        userSettings: null,
+        pluginId: 'plugin-one'
+      })).toBeNull();
+      expect(pluginHandler.getPluginConfigFromUserSettings({
+        userSettings: {
+          'plugin_plugin-one': {
+            value: {}
+          }
+        },
+        pluginId: 'plugin-one'
+      })).toBeNull();
+      expect(pluginHandler.getPluginConfigFromUserSettings({
+        userSettings: {
+          'plugin_plugin-one': {
+            value: {
+              config: {
+                queueId: 'q-1'
+              }
+            }
+          }
+        },
+        pluginId: 'plugin-one'
+      })).toEqual({ queueId: 'q-1' });
+    });
+
+    test('should update existing plugin data and log persist failures without throwing', async () => {
+      await AccountDataModel.create({
+        rcAccountId: '12345',
+        platformName: 'plugin-one',
+        dataKey: 'pluginData',
+        data: {
+          jwtToken: 'old-token',
+          endpointUrl: 'https://old.example.com'
+        }
+      });
+
+      await pluginHandler.persistPluginData({
+        rcAccountId: '12345',
+        pluginId: 'plugin-one',
+        jwtToken: 'new-token',
+        pluginData: {
+          endpointUrl: 'https://new.example.com'
+        }
+      });
+
+      const updated = await AccountDataModel.findOne({
+        where: {
+          rcAccountId: '12345',
+          platformName: 'plugin-one'
+        }
+      });
+      expect(updated.data).toEqual({
+        jwtToken: 'new-token',
+        endpointUrl: 'https://new.example.com'
+      });
+
+      const errorSpy = jest.spyOn(logger, 'error').mockImplementation(() => {});
+      jest.spyOn(AccountDataModel, 'findOne').mockRejectedValueOnce(new Error('db unavailable'));
+      await expect(pluginHandler.persistPluginData({
+        rcAccountId: '12345',
+        pluginId: 'plugin-one',
+        jwtToken: 'ignored'
+      })).resolves.toBeUndefined();
+      expect(errorSpy).toHaveBeenCalledWith('Failed to persist plugin data', {
+        pluginId: 'plugin-one',
+        rcAccountId: '12345',
+        message: 'db unavailable'
+      });
+    });
+  });
+
+  describe('resolvePluginManifest', () => {
+    test('should load private manifests with owner account id and infer the platform key', async () => {
+      axios.get.mockResolvedValue({
+        data: {
+          platforms: {
+            'plugin.private': {
+              endpointUrl: 'https://plugins.example.com/private',
+              userRegisterEndpointUrl: 'https://plugins.example.com/private/register'
+            }
+          }
+        }
+      });
+
+      const result = await pluginHandler.resolvePluginManifest({
+        pluginId: 'private-plugin',
+        pluginAccess: 'private',
+        ownerRcAccountId: 'owner-account'
+      });
+
+      expect(axios.get).toHaveBeenCalledWith(
+        'https://appconnect.labs.ringcentral.com/public-api/connectors/private-plugin/manifest?access=internal&type=plugin&accountId=owner-account'
+      );
+      expect(result.platformKey).toBe('plugin.private');
+      expect(result.pluginManifest.endpointUrl).toBe('https://plugins.example.com/private');
+    });
+
+    test('should fall back from public to internal manifest when access is unspecified', async () => {
+      axios.get
+        .mockRejectedValueOnce(new Error('public missing'))
+        .mockResolvedValueOnce({
+          data: {
+            platforms: {
+              'plugin.shared': {
+                endpointUrl: 'https://plugins.example.com/shared'
+              }
+            }
+          }
+        });
+
+      const result = await pluginHandler.resolvePluginManifest({
+        pluginId: 'shared-plugin',
+        ownerRcAccountId: 'owner-account'
+      });
+
+      expect(axios.get).toHaveBeenCalledTimes(2);
+      expect(axios.get.mock.calls[0][0]).toBe(
+        'https://appconnect.labs.ringcentral.com/public-api/connectors/shared-plugin/manifest?type=plugin'
+      );
+      expect(axios.get.mock.calls[1][0]).toBe(
+        'https://appconnect.labs.ringcentral.com/public-api/connectors/shared-plugin/manifest?access=internal&type=plugin&accountId=owner-account'
+      );
+      expect(result.platformKey).toBe('plugin.shared');
+    });
+
+    test('should throw the last manifest fetch error or platform resolution error', async () => {
+      axios.get.mockRejectedValueOnce(new Error('manifest unavailable'));
+
+      await expect(pluginHandler.resolvePluginManifest({
+        pluginId: 'missing-plugin',
+        pluginAccess: 'public'
+      })).rejects.toThrow('manifest unavailable');
+
+      axios.get.mockResolvedValueOnce({
+        data: {
+          platforms: {}
+        }
+      });
+      await expect(pluginHandler.resolvePluginManifest({
+        pluginId: 'empty-plugin',
+        pluginAccess: 'public',
+        pluginName: 'plugin.missing'
+      })).rejects.toThrow('Unable to resolve platform manifest for plugin empty-plugin');
+    });
+  });
+
+  describe('getPluginLicenseStatus', () => {
+    test('should return null and skip provider call when plugin account data is missing', async () => {
+      const result = await pluginHandler.getPluginLicenseStatus({
+        rcAccountId: '12345',
+        pluginId: 'sync-all-caps'
+      });
+
+      expect(result).toBeNull();
+      expect(axios.get).not.toHaveBeenCalled();
+    });
+
+    test('should call plugin license status endpoint with stored plugin bearer token', async () => {
+      const rcAccountId = '12345';
+      const pluginId = 'sync-all-caps';
+      await AccountDataModel.create({
+        rcAccountId,
+        platformName: pluginId,
+        dataKey: 'pluginData',
+        data: {
+          jwtToken: 'plugin-jwt-token',
+          licenseStatusUrl: `https://plugins.example.com/plugin/${pluginId}/license`
+        }
+      });
+      axios.get.mockResolvedValue({
+        data: {
+          licenseStatus: true,
+          licenseStatusDescription: 'Active'
+        }
+      });
+
+      const result = await pluginHandler.getPluginLicenseStatus({ rcAccountId, pluginId });
+
+      expect(axios.get).toHaveBeenCalledWith(
+        `https://plugins.example.com/plugin/${pluginId}/license`,
+        {
+          headers: {
+            Authorization: 'Bearer plugin-jwt-token'
+          }
+        }
+      );
+      expect(result).toEqual({
+        licenseStatus: true,
+        licenseStatusDescription: 'Active'
+      });
+    });
+    test('should normalize non-standard plugin license provider responses to invalid status', async () => {
+      const rcAccountId = '12345';
+      const pluginId = 'sync-all-caps';
+      await AccountDataModel.create({
+        rcAccountId,
+        platformName: pluginId,
+        dataKey: 'pluginData',
+        data: {
+          jwtToken: 'plugin-jwt-token',
+          licenseStatusUrl: `https://plugins.example.com/plugin/${pluginId}/license`
+        }
+      });
+      axios.get.mockResolvedValue({
+        data: {
+          message: 'temporary unavailable'
+        }
+      });
+
+      const result = await pluginHandler.getPluginLicenseStatus({ rcAccountId, pluginId });
+
+      expect(result).toEqual({
+        licenseStatus: false,
+        licenseStatusDescription: 'Plugin license status unavailable'
+      });
+    });
+  });
+  describe('unregisterPluginAccount', () => {
+    test('should remove persisted plugin account data', async () => {
+      const rcAccountId = '12345';
+      const pluginId = 'sync-all-caps';
+      await AccountDataModel.create({
+        rcAccountId,
+        platformName: pluginId,
+        dataKey: 'pluginData',
+        data: {
+          jwtToken: 'plugin-jwt-token'
+        }
+      });
+
+      await pluginHandler.unregisterPluginAccount({ rcAccountId, pluginId });
+
+      const accountData = await AccountDataModel.findOne({
+        where: {
+          rcAccountId,
+          platformName: pluginId,
+          dataKey: 'pluginData'
+        }
+      });
+      expect(accountData).toBeNull();
+    });
+  });
   describe('token header helper', () => {
     test('should parse refreshed jwt token from response headers', () => {
       const token = pluginHandler.getRefreshedJwtTokenFromHeaders({
@@ -119,6 +415,15 @@ describe('Plugin Handler', () => {
       });
       expect(token).toBe('new-plugin-token');
     });
+
+    test('should parse uppercase refreshed jwt token header and return null without headers', () => {
+      expect(pluginHandler.getRefreshedJwtTokenFromHeaders({ headers: null })).toBeNull();
+      expect(pluginHandler.getRefreshedJwtTokenFromHeaders({
+        headers: {
+          'X-Refreshed-Jwt-Token': 'upper-token'
+        }
+      })).toBe('upper-token');
+    });
   });
 });
 

package/test/handlers/user.test.js

@@ -0,0 +1,381 @@
+jest.mock('axios');
+jest.mock('../../models/adminConfigModel', () => ({
+  AdminConfigModel: {
+    findByPk: jest.fn()
+  }
+}));
+jest.mock('../../models/userModel', () => ({
+  UserModel: {
+    findOne: jest.fn()
+  }
+}));
+jest.mock('../../connector/registry', () => ({
+  getConnector: jest.fn()
+}));
+jest.mock('../../lib/oauth', () => ({
+  getOAuthApp: jest.fn(() => ({ app: true })),
+  checkAndRefreshAccessToken: jest.fn()
+}));
+jest.mock('../../lib/util', () => ({
+  getHashValue: jest.fn((value) => `hash-${value}`)
+}));
+jest.mock('../../models/dynamo/connectorSchema', () => ({
+  Connector: {
+    getProxyConfig: jest.fn()
+  }
+}));
+
+const axios = require('axios');
+const userHandler = require('../../handlers/user');
+const { AdminConfigModel } = require('../../models/adminConfigModel');
+const { UserModel } = require('../../models/userModel');
+const connectorRegistry = require('../../connector/registry');
+const oauth = require('../../lib/oauth');
+const { Connector } = require('../../models/dynamo/connectorSchema');
+
+describe('User Handler', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    process.env.HASH_KEY = 'hash-key';
+  });
+
+  test('refreshUserInfo returns warning when user is missing or has no access token', async () => {
+    UserModel.findOne.mockResolvedValueOnce(null);
+
+    await expect(userHandler.refreshUserInfo({
+      platform: 'testCRM',
+      userId: 'user-1'
+    })).resolves.toMatchObject({
+      successful: false,
+      returnMessage: {
+        message: 'User not found',
+        messageType: 'warning'
+      }
+    });
+
+    UserModel.findOne.mockResolvedValueOnce({ id: 'user-2' });
+    const noTokenResult = await userHandler.refreshUserInfo({
+      platform: 'testCRM',
+      userId: 'user-2'
+    });
+
+    expect(noTokenResult.returnMessage.message).toBe('User not found');
+  });
+
+  test('refreshUserInfo handles oauth proxy config and expired refreshed session', async () => {
+    const user = {
+      id: 'user-1',
+      hostname: 'crm.example.com',
+      accessToken: 'expired-token',
+      platformAdditionalInfo: {
+        proxyId: 'proxy-1',
+        tokenUrl: 'https://token.example.com'
+      }
+    };
+    const platformModule = {
+      getAuthType: jest.fn().mockResolvedValue('oauth'),
+      getOauthInfo: jest.fn().mockResolvedValue({ tokenUrl: 'https://token.example.com' })
+    };
+    UserModel.findOne.mockResolvedValue(user);
+    Connector.getProxyConfig.mockResolvedValue({ id: 'proxy-1' });
+    connectorRegistry.getConnector.mockReturnValue(platformModule);
+    oauth.checkAndRefreshAccessToken.mockResolvedValue(null);
+
+    const result = await userHandler.refreshUserInfo({
+      platform: 'testCRM',
+      userId: 'user-1',
+      tracer: {
+        trace: jest.fn(),
+        traceError: jest.fn()
+      }
+    });
+
+    expect(platformModule.getOauthInfo).toHaveBeenCalledWith({
+      tokenUrl: 'https://token.example.com',
+      hostname: 'crm.example.com',
+      proxyId: 'proxy-1',
+      proxyConfig: { id: 'proxy-1' }
+    });
+    expect(result).toMatchObject({
+      successful: false,
+      isRevokeUserSession: true,
+      returnMessage: {
+        message: 'User session expired. Please connect again.'
+      }
+    });
+  });
+
+  test('refreshUserInfo supports apiKey auth and maps platform result', async () => {
+    const user = {
+      id: 'user-1',
+      hostname: 'crm.example.com',
+      accessToken: 'api-key',
+      platformAdditionalInfo: {}
+    };
+    const platformModule = {
+      getAuthType: jest.fn().mockResolvedValue('apiKey'),
+      getBasicAuth: jest.fn(() => 'encoded-key'),
+      refreshUserInfo: jest.fn().mockResolvedValue({
+        successful: true,
+        returnMessage: {
+          messageType: 'success',
+          message: 'Refreshed'
+        }
+      })
+    };
+    UserModel.findOne.mockResolvedValue(user);
+    connectorRegistry.getConnector.mockReturnValue(platformModule);
+
+    const result = await userHandler.refreshUserInfo({
+      platform: 'testCRM',
+      userId: 'user-1'
+    });
+
+    expect(platformModule.refreshUserInfo).toHaveBeenCalledWith({
+      user,
+      authHeader: 'Basic encoded-key',
+      proxyConfig: null
+    });
+    expect(result.successful).toBe(true);
+  });
+
+  test('refreshUserInfo maps unexpected errors through API error handler', async () => {
+    UserModel.findOne.mockRejectedValueOnce(new Error('database unavailable'));
+
+    const result = await userHandler.refreshUserInfo({
+      platform: 'testCRM',
+      userId: 'user-1'
+    });
+
+    expect(result.successful).toBe(false);
+    expect(result.returnMessage.messageType).toBe('warning');
+  });
+
+  test('getUserSettingsByAdmin resolves account from explicit account id or RC token', async () => {
+    AdminConfigModel.findByPk.mockResolvedValueOnce({
+      userSettings: {
+        theme: { value: 'dark' }
+      }
+    });
+
+    await expect(userHandler.getUserSettingsByAdmin({
+      rcAccountId: 'hashed-account'
+    })).resolves.toEqual({
+      userSettings: {
+        theme: { value: 'dark' }
+      }
+    });
+    expect(AdminConfigModel.findByPk).toHaveBeenCalledWith('hashed-account');
+
+    axios.get.mockResolvedValueOnce({
+      data: {
+        account: {
+          id: 'rc-account-1'
+        }
+      }
+    });
+    AdminConfigModel.findByPk.mockResolvedValueOnce({
+      userSettings: {
+        language: { value: 'en' }
+      }
+    });
+
+    const result = await userHandler.getUserSettingsByAdmin({
+      rcAccessToken: 'rc-token'
+    });
+
+    expect(axios.get).toHaveBeenCalledWith(
+      'https://platform.ringcentral.com/restapi/v1.0/account/~/extension/~',
+      {
+        headers: {
+          Authorization: 'Bearer rc-token'
+        }
+      }
+    );
+    expect(AdminConfigModel.findByPk).toHaveBeenLastCalledWith('hash-rc-account-1');
+    expect(result.userSettings.language.value).toBe('en');
+  });
+
+  test('getUserSettings merges admin defaults, user overrides, removed keys, and plugin config rules', async () => {
+    AdminConfigModel.findByPk.mockResolvedValueOnce({
+      userSettings: {
+        removedSetting: { isRemoved: true, value: 'hidden' },
+        adminOnly: { value: 'admin-only', customizable: false },
+        userEditable: { value: 'admin-default', customizable: true },
+        plugin_sample: {
+          customizable: true,
+          value: {
+            config: {
+              locked: { value: 'admin-locked', customizable: false },
+              fillsEmpty: { value: 'admin-fill', customizable: true },
+              staysUserEditable: { value: 'admin-stay', customizable: true }
+            }
+          }
+        },
+        plugin_empty: {
+          customizable: true,
+          value: {
+            config: {
+              adminProvided: { value: 'admin-provided', customizable: true }
+            }
+          }
+        },
+        plugin_deleted: {
+          customizable: true,
+          value: {
+            config: null
+          }
+        }
+      }
+    });
+
+    const result = await userHandler.getUserSettings({
+      user: {
+        userSettings: {
+          removedSetting: { value: 'user-hidden' },
+          userEditable: { value: 'user-value', defaultValue: 'user-default', options: ['a'] },
+          userOnly: { value: 'user-only' },
+          plugin_sample: {
+            value: {
+              config: {
+                locked: { value: 'user-locked', customizable: true },
+                fillsEmpty: { value: '', customizable: true },
+                staysUserEditable: { value: 'user-stay', customizable: true }
+              }
+            }
+          },
+          plugin_empty: {
+            value: {
+              config: {}
+            }
+          },
+          plugin_deleted: {
+            value: {
+              config: {}
+            }
+          }
+        }
+      },
+      rcAccountId: 'hashed-account'
+    });
+
+    expect(result.removedSetting).toBeUndefined();
+    expect(result.adminOnly.value).toBe('admin-only');
+    expect(result.userOnly.value).toBe('user-only');
+    expect(result.userEditable).toEqual({
+      customizable: true,
+      value: 'user-value',
+      defaultValue: 'user-default',
+      options: ['a']
+    });
+    expect(result.plugin_sample.value.config.locked.value).toBe('admin-locked');
+    expect(result.plugin_sample.value.config.fillsEmpty.value).toBe('admin-fill');
+    expect(result.plugin_sample.value.config.staysUserEditable).toMatchObject({
+      value: 'user-stay',
+      customizable: true
+    });
+    expect(result.plugin_empty.value.config.adminProvided.value).toBe('admin-provided');
+    expect(result.plugin_deleted).toBeUndefined();
+  });
+
+  test('getUserSettings falls back to user settings when admin lookup fails', async () => {
+    AdminConfigModel.findByPk.mockRejectedValueOnce(new Error('admin settings unavailable'));
+
+    const result = await userHandler.getUserSettings({
+      user: {
+        userSettings: {
+          localOnly: { value: 'local' }
+        }
+      },
+      rcAccountId: 'hashed-account'
+    });
+
+    expect(result).toEqual({
+      localOnly: { value: 'local' }
+    });
+  });
+
+  test('updateUserSettings supports connector hooks, removals, and database error mapping', async () => {
+    const user = {
+      userSettings: {
+        oldKey: { value: 'old' },
+        removeMe: { value: 'remove' }
+      },
+      update: jest.fn().mockImplementation(async function update(values) {
+        user.userSettings = values.userSettings;
+      })
+    };
+
+    connectorRegistry.getConnector.mockReturnValueOnce({});
+    const defaultResult = await userHandler.updateUserSettings({
+      user,
+      userSettings: {
+        newKey: { value: 'new' }
+      },
+      settingKeysToRemove: ['removeMe'],
+      platformName: 'testCRM'
+    });
+
+    expect(defaultResult.userSettings).toEqual({
+      oldKey: { value: 'old' },
+      newKey: { value: 'new' }
+    });
+    expect(user.update).toHaveBeenCalledWith({
+      userSettings: {
+        oldKey: { value: 'old' },
+        newKey: { value: 'new' }
+      }
+    });
+
+    const hookUser = {
+      userSettings: {},
+      update: jest.fn()
+    };
+    connectorRegistry.getConnector.mockReturnValueOnce({
+      onUpdateUserSettings: jest.fn().mockResolvedValue({
+        successful: false,
+        returnMessage: {
+          messageType: 'warning',
+          message: 'Rejected by connector'
+        }
+      })
+    });
+    const rejectedResult = await userHandler.updateUserSettings({
+      user: hookUser,
+      userSettings: {
+        key: { value: 'value' }
+      },
+      settingKeysToRemove: [],
+      platformName: 'testCRM'
+    });
+
+    expect(rejectedResult.successful).toBe(false);
+    expect(hookUser.update).not.toHaveBeenCalled();
+
+    const failingUser = {
+      userSettings: {},
+      update: jest.fn().mockRejectedValue(new Error('write failed'))
+    };
+    connectorRegistry.getConnector.mockReturnValueOnce({
+      onUpdateUserSettings: jest.fn().mockResolvedValue({
+        successful: true,
+        returnMessage: {
+          messageType: 'success',
+          message: 'Allowed'
+        }
+      })
+    });
+
+    const failedUpdateResult = await userHandler.updateUserSettings({
+      user: failingUser,
+      userSettings: {
+        key: { value: 'value' }
+      },
+      settingKeysToRemove: [],
+      platformName: 'testCRM'
+    });
+
+    expect(failedUpdateResult.successful).toBe(false);
+    expect(failedUpdateResult.returnMessage.messageType).toBe('warning');
+  });
+});