@app-connect/core 1.7.36 → 1.7.38

package/mcp/ui/vite.config.ts

@@ -1,16 +0,0 @@
-import { defineConfig } from 'vite'
-import react from '@vitejs/plugin-react'
-import tailwindcss from '@tailwindcss/vite'
-import { viteSingleFile } from 'vite-plugin-singlefile'
-
-export default defineConfig({
-  plugins: [
-    react(),
-    tailwindcss(),
-    viteSingleFile(),
-  ],
-  build: {
-    outDir: 'dist',
-  }
-})
-

package/models/accountDataModel.js

@@ -1,34 +0,0 @@
-const Sequelize = require('sequelize');
-const { sequelize } = require('./sequelize');
-
-// Model for account data with composite primary key
-exports.AccountDataModel = sequelize.define('accountData', {
-    rcAccountId: {
-        type: Sequelize.STRING,
-        primaryKey: true,
-    },
-    platformName: {
-        type: Sequelize.STRING,
-        primaryKey: true,
-    },
-    dataKey: {
-        type: Sequelize.STRING,
-        primaryKey: true,
-    },
-    data: {
-        type: Sequelize.JSON,
-    }
-});
-
-exports.getOrRefreshAccountData = async function getOrRefreshAccountData({ rcAccountId, platformName, dataKey, forceRefresh, fetchFn }) {
-    const existing = await exports.AccountDataModel.findOne({ where: { rcAccountId, platformName, dataKey } });
-    if (existing && !forceRefresh) return existing.data;
-
-    const fresh = await fetchFn();
-    if (existing) {
-        await existing.update({ data: fresh });
-    } else {
-        await exports.AccountDataModel.create({ rcAccountId, platformName, dataKey, data: fresh });
-    }
-    return fresh;
-}

package/models/adminConfigModel.js

@@ -1,35 +0,0 @@
-const Sequelize = require('sequelize');
-const { sequelize } = require('./sequelize');
-
-// Model for Admin data
-exports.AdminConfigModel = sequelize.define('adminConfigs', {
-  // hashed rc account ID
-  id: {
-    type: Sequelize.STRING,
-    primaryKey: true,
-  },
-  userSettings: {
-    type: Sequelize.JSON
-  },
-  // Obsolete
-  customAdapter: {
-    type: Sequelize.JSON
-  },
-  adminAccessToken: {
-    type: Sequelize.STRING(512),
-  },
-  adminRefreshToken: {
-    type: Sequelize.STRING(512),
-  },
-  adminTokenExpiry: {
-    type: Sequelize.DATE
-  },
-    // Array of:
-  // {
-  //   crmUserId: string,
-  //   rcExtensionId: array of strings
-  // }
-  userMappings: {
-    type: Sequelize.JSON
-  }
-});

package/models/callLogModel.js

@@ -1,39 +0,0 @@
-const Sequelize = require('sequelize');
-const { sequelize } = require('./sequelize');
-
-// Model for User data
-exports.CallLogModel = sequelize.define('callLogs', {
-  // callId
-  id: {
-    type: Sequelize.STRING,
-    primaryKey: true,
-  },
-  sessionId: {
-    type: Sequelize.STRING,
-    primaryKey: true,
-  },
-  extensionNumber: {
-    type: Sequelize.STRING,
-    primaryKey: true,
-    allowNull: false,
-    defaultValue: '',
-  },
-  hashedExtensionId: {
-    type: Sequelize.STRING,
-    primaryKey: true,
-    allowNull: false,
-    defaultValue: '',
-  },
-  platform: {
-    type: Sequelize.STRING,
-  },
-  thirdPartyLogId: {
-    type: Sequelize.STRING,
-  },
-  userId: {
-    type: Sequelize.STRING,
-  },
-  contactId: {
-    type: Sequelize.STRING,
-  }
-});

package/models/dynamo/connectorSchema.js

@@ -1,146 +0,0 @@
-const dynamoose = require('dynamoose');
-const crypto = require('crypto');
-
-const CONNECTOR_STATUS = {
-  PRIVATE: 'private',
-  UNDER_REVIEW: 'under_review',
-  APPROVED: 'approved',
-  REJECTED: 'rejected',
-};
-
-const connectorSchema = new dynamoose.Schema({
-  accountId: {
-    type: String,
-    hashKey: true,
-  },
-  id: {
-    type: String,
-    rangeKey: true,
-  },
-  // Reference to original connector (for partition records)
-  originalAccountId: {
-    type: String,
-    required: false, // Only set for partition records (under_review, approved)
-  },
-  // Basic Information
-  name: {
-    type: String,
-    required: true,
-  },
-  displayName: String,
-  description: String,
-  iconUrl: String,
-  // Status and Workflow
-  status: {
-    type: String,
-    required: true,
-    enum: Object.values(CONNECTOR_STATUS),
-    default: CONNECTOR_STATUS.PRIVATE,
-    index: {
-      name: 'statusIdIndex',
-      global: true,
-      rangeKey: 'id',
-      project: ['accountId', 'name', 'displayName', 'developer', 'originalAccountId'],
-    },
-  },
-  creatorId: String,
-  // Developer Information
-  developer: {
-    type: Object,
-    schema: {
-      name: String,
-      websiteUrl: String,
-      supportUrl: String,
-    },
-  },
-  // Manifest Management
-  manifest: {
-    type: Object,
-    required: true,
-  },
-  proxyConfig: {
-    type: Object,
-    required: false,
-  },
-  proxyId: {
-    type: String,
-    index: {
-      name: 'proxyIdIndex',
-      global: true,
-      project: ['id', 'accountId', 'creatorId', 'name', 'displayName', 'status', 'developer', 'originalAccountId', 'proxyConfig'],
-    }
-  },
-  // Review and Approval
-  submittedAt: Number,
-  reviewedBy: String,
-  reviewedAt: Number,
-  reviewNotes: String,
-  rejectionReason: String,
-  demoAccounts: String,
-  // Usage and Analytics
-  usageCount: {
-    type: Number,
-    default: 0,
-  },
-  lastUsedAt: Number,
-  allowedAccounts: {
-    type: Array,
-    schema: [String],
-  },
-  encodedSecretKey: String,
-}, {
-  saveUnknown: ['manifest.**', 'proxyConfig.**'],
-  timestamps: true,
-});
-
-const tableOptions = {
-  prefix: process.env.DEVELOPER_DYNAMODB_TABLE_PREFIX,
-};
-
-if (process.env.NODE_ENV === 'production') {
-  tableOptions.create = false;
-  tableOptions.waitForActive = false;
-}
-
-const Connector = dynamoose.model('connectors', connectorSchema, tableOptions);
-
-function getDeveloperCipherKey() {
-  if (!process.env.DEVELOPER_APP_SERVER_SECRET_KEY) {
-    throw new Error('DEVELOPER_APP_SERVER_SECRET_KEY is not defined');
-  }
-  if (process.env.DEVELOPER_APP_SERVER_SECRET_KEY.length < 32) {
-    // pad secret key with spaces if it is less than 32 bytes
-    return process.env.DEVELOPER_APP_SERVER_SECRET_KEY.padEnd(32, ' ');
-  }
-  if (process.env.DEVELOPER_APP_SERVER_SECRET_KEY.length > 32) {
-    // truncate secret key if it is more than 32 bytes
-    return process.env.DEVELOPER_APP_SERVER_SECRET_KEY.slice(0, 32);
-  }
-  return process.env.DEVELOPER_APP_SERVER_SECRET_KEY;
-}
-
-function decode(encryptedData) {
-  const decipher = crypto.createDecipheriv('aes-256-cbc', getDeveloperCipherKey(), Buffer.alloc(16, 0));
-  return decipher.update(encryptedData, 'hex', 'utf8') + decipher.final('utf8');
-}
-
-// ADD static method to get connector by proxyId
-Connector.getProxyConfig = async (proxyId) => {
-  const connectors = await Connector
-    .query('proxyId')
-    .eq(proxyId)
-    .using('proxyIdIndex')
-    .exec();
-  if (connectors.length > 0) {
-    const proxyConfig = connectors[0].proxyConfig;
-    const encodedSecretKey = connectors[0].encodedSecretKey;
-    const secretKey = encodedSecretKey ? decode(encodedSecretKey) : null;
-    if (secretKey) {
-      proxyConfig.secretKey = secretKey;
-    }
-    return proxyConfig;
-  }
-  return null;
-};
-
-exports.Connector = Connector;

package/models/llmSessionModel.js

@@ -1,17 +0,0 @@
-const Sequelize = require('sequelize');
-const { sequelize } = require('./sequelize');
-
-// Model for Admin data
-exports.LlmSessionModel = sequelize.define('llmSessions', {
-    // LLM session ID
-    id: {
-        type: Sequelize.STRING,
-        primaryKey: true,
-    },
-    jwtToken: {
-        type: Sequelize.STRING,
-    },
-    expiry: {
-        type: Sequelize.DATE
-    }
-});

package/models/sequelize.js

@@ -1,17 +0,0 @@
-const { Sequelize } = require('sequelize');
-
-const sequelize = new Sequelize(process.env.DATABASE_URL,
-  {
-    dialect: 'postgres',
-    protocol: 'postgres',
-    dialectOptions:{
-      ssl: {
-        rejectUnauthorized: false
-      }
-    },
-    logging: false
-  }
-);
- 
-
-exports.sequelize = sequelize;

package/models/userModel.js

@@ -1,45 +0,0 @@
-const Sequelize = require('sequelize');
-const { sequelize } = require('./sequelize');
-
-// Model for User data
-exports.UserModel = sequelize.define('users', {
-  // id = {crmName}-{crmUserId}
-  id: {
-    type: Sequelize.STRING,
-    primaryKey: true,
-  },
-  rcAccountId: {
-    type: Sequelize.STRING,
-  },
-  hostname: {
-    type: Sequelize.STRING,
-  },
-  timezoneName: {
-    type: Sequelize.STRING,
-  },
-  timezoneOffset: {
-    type: Sequelize.STRING,
-  },
-  platform: {
-    type: Sequelize.STRING,
-  },
-  // in apiKey auth, accessToken will be API key
-  accessToken: {
-    type: Sequelize.STRING(2000),
-  },
-  refreshToken: {
-    type: Sequelize.STRING(2000),
-  },
-  tokenExpiry: {
-    type: Sequelize.DATE
-  },
-  platformAdditionalInfo: {
-    type: Sequelize.JSON
-  },
-  hashedRcExtensionId: {
-    type: Sequelize.STRING,
-  },
-  userSettings: {
-    type: Sequelize.JSON
-  }
-});

package/test/connector/developerPortal.test.js

@@ -1,166 +0,0 @@
-jest.mock('axios', () => ({
-  get: jest.fn(),
-}));
-
-jest.mock('../../lib/logger', () => ({
-  logger: {
-    error: jest.fn(),
-  },
-}));
-
-const axios = require('axios');
-const { logger } = require('../../lib/logger');
-const {
-  getPublicConnectorList,
-  getConnectorManifest,
-} = require('../../connector/developerPortal');
-
-describe('developerPortal connector', () => {
-  beforeEach(() => {
-    axios.get.mockReset();
-    logger.error.mockReset();
-  });
-
-  test('loads the public connector list', async () => {
-    axios.get.mockResolvedValueOnce({
-      data: {
-        connectors: [
-          { id: 'public-a' },
-          { id: 'public-b' },
-        ],
-      },
-    });
-
-    await expect(getPublicConnectorList()).resolves.toEqual({
-      connectors: [
-        { id: 'public-a' },
-        { id: 'public-b' },
-      ],
-    });
-    expect(axios.get).toHaveBeenCalledWith('https://appconnect.labs.ringcentral.com/public-api/connectors');
-    expect(logger.error).not.toHaveBeenCalled();
-  });
-
-  test('returns null when public connector list loading fails', async () => {
-    const error = new Error('network down');
-    axios.get.mockRejectedValueOnce(error);
-
-    await expect(getPublicConnectorList()).resolves.toBeNull();
-
-    expect(logger.error).toHaveBeenCalledWith('Error getting public connector list:', error);
-  });
-
-  test('loads a public connector manifest by id', async () => {
-    axios.get.mockResolvedValueOnce({
-      data: {
-        id: 'salesforce',
-        name: 'Salesforce',
-      },
-    });
-
-    await expect(getConnectorManifest({
-      connectorId: 'salesforce',
-    })).resolves.toEqual({
-      id: 'salesforce',
-      name: 'Salesforce',
-    });
-    expect(axios.get).toHaveBeenCalledWith('https://appconnect.labs.ringcentral.com/public-api/connectors/salesforce/manifest');
-  });
-
-  test('loads a private connector manifest for the requesting account', async () => {
-    axios.get
-      .mockResolvedValueOnce({
-        data: {
-          privateConnectors: [
-            { id: 'private-crm' },
-          ],
-          sharedConnectors: [],
-        },
-      })
-      .mockResolvedValueOnce({
-        data: {
-          id: 'private-crm',
-          access: 'internal',
-        },
-      });
-
-    await expect(getConnectorManifest({
-      rcAccountId: 'rc-account-1',
-      connectorId: 'private-crm',
-      isPrivate: true,
-    })).resolves.toEqual({
-      id: 'private-crm',
-      access: 'internal',
-    });
-
-    expect(axios.get).toHaveBeenNthCalledWith(
-      1,
-      'https://appconnect.labs.ringcentral.com/public-api/connectors/internal?accountId=rc-account-1',
-    );
-    expect(axios.get).toHaveBeenNthCalledWith(
-      2,
-      'https://appconnect.labs.ringcentral.com/public-api/connectors/private-crm/manifest?access=internal&type=connector&accountId=rc-account-1',
-    );
-  });
-
-  test('loads a shared private connector manifest from the owner account', async () => {
-    axios.get
-      .mockResolvedValueOnce({
-        data: {
-          privateConnectors: [],
-          sharedConnectors: [
-            { id: 'shared-crm', accountId: 'owner-account' },
-          ],
-        },
-      })
-      .mockResolvedValueOnce({
-        data: {
-          id: 'shared-crm',
-          ownerAccountId: 'owner-account',
-        },
-      });
-
-    await expect(getConnectorManifest({
-      rcAccountId: 'viewer-account',
-      connectorId: 'shared-crm',
-      isPrivate: true,
-    })).resolves.toEqual({
-      id: 'shared-crm',
-      ownerAccountId: 'owner-account',
-    });
-
-    expect(axios.get).toHaveBeenNthCalledWith(
-      2,
-      'https://appconnect.labs.ringcentral.com/public-api/connectors/shared-crm/manifest?access=internal&type=connector&accountId=owner-account',
-    );
-  });
-
-  test('returns null when a private connector is not visible to the account', async () => {
-    axios.get.mockResolvedValueOnce({
-      data: {
-        privateConnectors: [],
-        sharedConnectors: [],
-      },
-    });
-
-    await expect(getConnectorManifest({
-      rcAccountId: 'rc-account-2',
-      connectorId: 'missing-crm',
-      isPrivate: true,
-    })).resolves.toBeNull();
-
-    expect(logger.error.mock.calls[0][0]).toBe('Error getting connector manifest:');
-    expect(logger.error.mock.calls[0][1].message).toBe('Connector not found');
-  });
-
-  test('returns null when public manifest loading fails', async () => {
-    const error = new Error('manifest unavailable');
-    axios.get.mockRejectedValueOnce(error);
-
-    await expect(getConnectorManifest({
-      connectorId: 'broken-crm',
-    })).resolves.toBeNull();
-
-    expect(logger.error).toHaveBeenCalledWith('Error getting connector manifest:', error);
-  });
-});

package/test/connector/mock.test.js

@@ -1,131 +0,0 @@
-jest.mock('shortid', () => ({
-  generate: jest.fn(() => 'mock-log-id'),
-}));
-
-const mockConnector = require('../../connector/mock');
-const { UserModel } = require('../../models/userModel');
-const { CallLogModel } = require('../../models/callLogModel');
-
-describe('mock connector', () => {
-  beforeEach(async () => {
-    await CallLogModel.destroy({ where: {} });
-    await UserModel.destroy({ where: {} });
-  });
-
-  test('creates and deletes the mock user idempotently', async () => {
-    const firstUser = await mockConnector.createUser();
-    const secondUser = await mockConnector.createUser();
-
-    expect(firstUser.id).toBe('mockUser');
-    expect(secondUser.id).toBe('mockUser');
-    await expect(UserModel.count({ where: { id: 'mockUser' } })).resolves.toBe(1);
-
-    await expect(mockConnector.deleteUser()).resolves.toBe(true);
-    await expect(mockConnector.deleteUser()).resolves.toBe(false);
-    await expect(UserModel.findByPk('mockUser')).resolves.toBeNull();
-  });
-
-  test('creates a mock call log only once for the same session identity', async () => {
-    await mockConnector.createCallLog({
-      sessionId: 'session-1',
-      extensionNumber: 101,
-      hashedExtensionId: 'hash-101',
-    });
-    await mockConnector.createCallLog({
-      sessionId: 'session-1',
-      extensionNumber: '101',
-      hashedExtensionId: 'hash-101',
-    });
-
-    const records = await CallLogModel.findAll({
-      where: {
-        sessionId: 'session-1',
-      },
-    });
-    expect(records).toHaveLength(1);
-    expect(records[0]).toMatchObject({
-      id: 'mock-log-id',
-      sessionId: 'session-1',
-      extensionNumber: '101',
-      hashedExtensionId: 'hash-101',
-      userId: 'mockUser',
-    });
-  });
-
-  test('returns matched and unmatched call logs in requested session order', async () => {
-    await mockConnector.createCallLog({
-      sessionId: 'session-1',
-      extensionNumber: '101',
-      hashedExtensionId: 'hash-101',
-    });
-    await mockConnector.createCallLog({
-      sessionId: 'session-3',
-      extensionNumber: '101',
-      hashedExtensionId: 'hash-101',
-    });
-
-    await expect(mockConnector.getCallLog({
-      sessionIds: 'session-1,session-2,session-3',
-      extensionNumber: '101',
-      hashedExtensionId: 'hash-101',
-    })).resolves.toEqual([
-      { sessionId: 'session-1', matched: true, logId: 'mockThirdPartyLogId' },
-      { sessionId: 'session-2', matched: false },
-      { sessionId: 'session-3', matched: true, logId: 'mockThirdPartyLogId' },
-    ]);
-  });
-
-  test('falls back to legacy extension matching when hashed extension id does not match', async () => {
-    await CallLogModel.create({
-      id: 'legacy-log-id',
-      sessionId: 'session-legacy',
-      extensionNumber: '101',
-      hashedExtensionId: '',
-      userId: 'mockUser',
-    });
-
-    await expect(mockConnector.getCallLog({
-      sessionIds: 'session-legacy',
-      extensionNumber: '101',
-      hashedExtensionId: 'new-hash-101',
-    })).resolves.toEqual([
-      { sessionId: 'session-legacy', matched: true, logId: 'mockThirdPartyLogId' },
-    ]);
-  });
-
-  test('cleanUpMockLogs removes only mock user call logs', async () => {
-    await CallLogModel.bulkCreate([
-      {
-        id: 'mock-log',
-        sessionId: 'mock-session',
-        extensionNumber: '',
-        hashedExtensionId: '',
-        userId: 'mockUser',
-      },
-      {
-        id: 'real-log',
-        sessionId: 'real-session',
-        extensionNumber: '',
-        hashedExtensionId: '',
-        userId: 'realUser',
-      },
-    ]);
-
-    await mockConnector.cleanUpMockLogs();
-
-    await expect(CallLogModel.findOne({
-      where: {
-        userId: 'mockUser',
-      },
-    })).resolves.toBeNull();
-    const realLog = await CallLogModel.findOne({
-      where: {
-        userId: 'realUser',
-      },
-    });
-    expect(realLog).toMatchObject({
-      id: 'real-log',
-      sessionId: 'real-session',
-    });
-  });
-});