@app-connect/core 1.7.36 → 1.7.38

package/test/handlers/managedOAuth.test.js

@@ -1,262 +0,0 @@
-jest.mock('../../models/sequelize', () => {
-  const { Sequelize } = require('sequelize');
-  return {
-    sequelize: new Sequelize({
-      dialect: 'sqlite',
-      storage: ':memory:',
-      logging: false
-    })
-  };
-});
-
-const managedOAuth = require('../../handlers/managedOAuth');
-const { AccountDataModel } = require('../../models/accountDataModel');
-const { CacheModel } = require('../../models/cacheModel');
-const { sequelize } = require('../../models/sequelize');
-
-describe('Managed OAuth Handler', () => {
-  beforeAll(async () => {
-    process.env.APP_SERVER_SECRET_KEY = 'test-app-server-secret-key-123456';
-    await AccountDataModel.sync({ force: true });
-    await CacheModel.sync({ force: true });
-  });
-
-  afterEach(async () => {
-    await AccountDataModel.destroy({ where: {} });
-    await CacheModel.destroy({ where: {} });
-  });
-
-  afterAll(async () => {
-    await sequelize.close();
-  });
-
-  test('returns empty state when account and platform are missing', async () => {
-    await expect(managedOAuth.getManagedOAuthState({
-      rcAccountId: '',
-      platform: '',
-      isAdmin: false
-    })).resolves.toEqual({
-      isAdmin: false,
-      hasAccountOAuth: false,
-      hasPendingOAuth: false
-    });
-
-    await expect(managedOAuth.clearPendingManagedOAuth({})).resolves.toBe(0);
-    await expect(managedOAuth.clearAccountManagedOAuth({ rcAccountId: 'acc-1' })).resolves.toBe(0);
-  });
-
-  test('upserts pending OAuth values, filters empty fields, and exposes pending values to admin', async () => {
-    const firstRecord = await managedOAuth.upsertPendingManagedOAuth({
-      rcAccountId: 'acc-1',
-      values: {
-        clientId: 'client-id',
-        clientSecret: 'client-secret',
-        accessTokenUri: '',
-        authorizationUri: 'https://auth.example.com',
-        ignored: 'ignored'
-      }
-    });
-
-    expect(firstRecord.id).toBe('acc-1-managed-oauth-account');
-
-    const secondRecord = await managedOAuth.upsertPendingManagedOAuth({
-      rcAccountId: 'acc-1',
-      values: {
-        clientId: 'client-id-2',
-        redirectUri: 'https://app.example.com/callback',
-        scopes: ['read', 'write'],
-        hostname: 'crm.example.com'
-      }
-    });
-
-    expect(secondRecord.id).toBe(firstRecord.id);
-
-    const pendingValues = await managedOAuth.getPendingManagedOAuthValues({ rcAccountId: 'acc-1' });
-    expect(pendingValues).toEqual({
-      clientId: 'client-id-2',
-      redirectUri: 'https://app.example.com/callback',
-      scopes: ['read', 'write'],
-      hostname: 'crm.example.com'
-    });
-
-    const state = await managedOAuth.getManagedOAuthState({
-      rcAccountId: 'acc-1',
-      platform: 'testCRM',
-      isAdmin: true
-    });
-
-    expect(state).toEqual({
-      isAdmin: true,
-      hasAccountOAuth: false,
-      hasPendingOAuth: true,
-      pendingValues
-    });
-  });
-
-  test('expired pending OAuth cache is destroyed and ignored', async () => {
-    const record = await managedOAuth.upsertPendingManagedOAuth({
-      rcAccountId: 'expired-acc',
-      values: {
-        clientId: 'expired-client'
-      }
-    });
-    await record.update({
-      expiry: new Date(Date.now() - 1000)
-    });
-
-    const values = await managedOAuth.getPendingManagedOAuthValues({ rcAccountId: 'expired-acc' });
-
-    expect(values).toEqual({});
-    expect(await CacheModel.findByPk('expired-acc-managed-oauth-account')).toBeNull();
-  });
-
-  test('migrates pending OAuth to account record and hides account client secret in state', async () => {
-    await managedOAuth.upsertPendingManagedOAuth({
-      rcAccountId: 'acc-2',
-      values: {
-        clientId: 'client-id',
-        clientSecret: 'client-secret',
-        accessTokenUri: 'https://token.example.com'
-      }
-    });
-
-    await expect(managedOAuth.migratePendingManagedOAuth({
-      rcAccountId: 'acc-2',
-      platform: 'testCRM'
-    })).resolves.toBe(true);
-
-    expect(await managedOAuth.getPendingManagedOAuthValues({ rcAccountId: 'acc-2' })).toEqual({});
-
-    const accountValues = await managedOAuth.getAccountManagedOAuthValues({
-      rcAccountId: 'acc-2',
-      platform: 'testCRM'
-    });
-    expect(accountValues).toEqual({
-      clientId: 'client-id',
-      clientSecret: 'client-secret',
-      accessTokenUri: 'https://token.example.com'
-    });
-
-    const state = await managedOAuth.getManagedOAuthState({
-      rcAccountId: 'acc-2',
-      platform: 'testCRM',
-      isAdmin: true
-    });
-
-    expect(state).toEqual({
-      isAdmin: true,
-      hasAccountOAuth: true,
-      hasPendingOAuth: false,
-      oauthValues: {
-        clientId: 'client-id',
-        accessTokenUri: 'https://token.example.com'
-      }
-    });
-  });
-
-  test('migrates pending OAuth into an existing account record and resolves account source first', async () => {
-    await managedOAuth.upsertPendingManagedOAuth({
-      rcAccountId: 'acc-3',
-      values: {
-        clientId: 'pending-client'
-      }
-    });
-    await AccountDataModel.create({
-      rcAccountId: 'acc-3',
-      platformName: 'testCRM',
-      dataKey: managedOAuth.MANAGED_OAUTH_ACCOUNT_DATA_KEY,
-      data: {
-        fields: {
-          clientId: {
-            encrypted: false,
-            value: 'old-client'
-          }
-        }
-      }
-    });
-
-    await expect(managedOAuth.migratePendingManagedOAuth({
-      rcAccountId: 'acc-3',
-      platform: 'testCRM'
-    })).resolves.toBe(true);
-
-    await expect(managedOAuth.resolveManagedOAuthInfo({
-      rcAccountId: 'acc-3',
-      platform: 'testCRM'
-    })).resolves.toEqual({
-      source: 'account',
-      oauthInfo: {
-        clientId: 'pending-client'
-      }
-    });
-  });
-
-  test('resolveManagedOAuthInfo falls back to pending values or null source', async () => {
-    await managedOAuth.upsertPendingManagedOAuth({
-      rcAccountId: 'acc-4',
-      values: {
-        clientId: 'pending-client'
-      }
-    });
-
-    await expect(managedOAuth.resolveManagedOAuthInfo({
-      rcAccountId: 'acc-4',
-      platform: 'testCRM'
-    })).resolves.toEqual({
-      source: 'pending',
-      oauthInfo: {
-        clientId: 'pending-client'
-      }
-    });
-
-    await expect(managedOAuth.resolveManagedOAuthInfo({
-      rcAccountId: 'missing-acc',
-      platform: 'testCRM'
-    })).resolves.toEqual({
-      source: null,
-      oauthInfo: null
-    });
-  });
-
-  test('clear and reset delete account and pending OAuth data', async () => {
-    await managedOAuth.upsertPendingManagedOAuth({
-      rcAccountId: 'acc-5',
-      values: {
-        clientId: 'pending-client'
-      }
-    });
-    await managedOAuth.migratePendingManagedOAuth({
-      rcAccountId: 'acc-5',
-      platform: 'testCRM'
-    });
-    await managedOAuth.upsertPendingManagedOAuth({
-      rcAccountId: 'acc-5',
-      values: {
-        clientId: 'pending-client-2'
-      }
-    });
-
-    const resetResult = await managedOAuth.resetManagedOAuth({
-      rcAccountId: 'acc-5',
-      platform: 'testCRM'
-    });
-
-    expect(resetResult).toEqual({
-      deletedAccountCount: 1,
-      deletedPendingCount: 1
-    });
-  });
-
-  test('throws when upserting pending OAuth without account id and no-ops missing migrations', async () => {
-    await expect(managedOAuth.upsertPendingManagedOAuth({
-      values: {
-        clientId: 'client-id'
-      }
-    })).rejects.toThrow('rcAccountId is required');
-
-    await expect(managedOAuth.migratePendingManagedOAuth({
-      rcAccountId: 'no-pending',
-      platform: 'testCRM'
-    })).resolves.toBe(false);
-  });
-});

package/test/handlers/plugin.test.js

@@ -1,429 +0,0 @@
-// Use in-memory SQLite for isolated model tests
-jest.mock('../../models/sequelize', () => {
-  const { Sequelize } = require('sequelize');
-  return {
-    sequelize: new Sequelize({
-      dialect: 'sqlite',
-      storage: ':memory:',
-      logging: false,
-    }),
-  };
-});
-jest.mock('axios');
-
-const pluginHandler = require('../../handlers/plugin');
-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 () => {
-    process.env.HASH_KEY = 'unit-test-hash-key';
-    await CacheModel.sync({ force: true });
-    await AccountDataModel.sync({ force: true });
-  });
-
-  afterEach(async () => {
-    await CacheModel.destroy({ where: {} });
-    await AccountDataModel.destroy({ where: {} });
-    jest.clearAllMocks();
-    jest.restoreAllMocks();
-  });
-
-  afterAll(async () => {
-    await sequelize.close();
-  });
-
-  describe('registerPluginAccount', () => {
-    test('should register plugin account and persist plugin jwt token in account data', async () => {
-      const rcAccountId = '12345';
-      const pluginId = 'sync-all-caps';
-
-      axios.get.mockResolvedValue({
-        data: {
-          platforms: {
-            'plugin.sample': {
-              endpointUrl: `https://plugins.example.com/plugin/${pluginId}`,
-              userRegisterEndpointUrl: `https://plugins.example.com/plugin/${pluginId}/auth/register`
-            }
-          }
-        }
-      });
-      axios.post.mockResolvedValue({
-        data: {
-          jwtToken: 'plugin-jwt-token'
-        }
-      });
-
-      const result = await pluginHandler.registerPluginAccount({
-        pluginId,
-        rcAccessToken: 'rc-access-token',
-        rcAccountId,
-        pluginAccess: 'public',
-        pluginName: 'plugin.sample'
-      });
-
-      expect(result.successful).toBe(true);
-      expect(axios.post).toHaveBeenCalledWith(
-        `https://plugins.example.com/plugin/${pluginId}/auth/register`,
-        {
-          rcAccessToken: 'rc-access-token',
-          rcAccountId
-        }
-      );
-
-      const accountData = await AccountDataModel.findOne({
-        where: {
-          rcAccountId,
-          platformName: pluginId,
-          dataKey: 'pluginData'
-        }
-      });
-      expect(accountData).not.toBeNull();
-      expect(accountData.data.jwtToken).toBe('plugin-jwt-token');
-      expect(accountData.data.endpointUrl).toBe(`https://plugins.example.com/plugin/${pluginId}`);
-    });
-
-    test('should throw when register API does not return jwt token', async () => {
-      const rcAccountId = '12345';
-      const pluginId = 'sync-all-caps';
-
-      axios.get.mockResolvedValue({
-        data: {
-          platforms: {
-            'plugin.sample': {
-              endpointUrl: `https://plugins.example.com/plugin/${pluginId}`,
-              userRegisterEndpointUrl: `https://plugins.example.com/plugin/${pluginId}/auth/register`
-            }
-          }
-        }
-      });
-      axios.post.mockResolvedValue({ data: {} });
-
-      await expect(pluginHandler.registerPluginAccount({
-        pluginId,
-        rcAccessToken: 'rc-access-token',
-        rcAccountId,
-        pluginAccess: 'public',
-        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({
-        headers: {
-          'x-refreshed-jwt-token': 'new-plugin-token'
-        }
-      });
-      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');
-    });
-  });
-});
-