@app-connect/core 1.7.0-beta.4 → 1.7.0-beta.6

package/README.md

@@ -5,7 +5,7 @@ Core package for RingCentral App Connect project providing modular APIs for CRM
 ## Features
 
 - **Modular API Design**: Flexible Express app setup with customizable middleware and routes
-- **CRM Adapter Registry**: Centralized adapter management for multiple CRM platforms
+- **CRM Connector Registry**: Centralized connector management for multiple CRM platforms
 - **Authentication**: OAuth and API key authentication support
 - **Contact Management**: Find, create, and manage contacts across CRM platforms
 - **Call Logging**: Comprehensive call and message logging capabilities
@@ -23,15 +23,15 @@ npm install @app-connect/core
 ### Basic Usage
 
 ```javascript
-const { createCoreApp, adapterRegistry } = require('@app-connect/core');
-const myCRMAdapter = require('./adapters/myCRM');
-const manifest = require('./adapters/manifest.json');
-// Set the default manifest for the adapter registry. This ensures that all adapters
+const { createCoreApp, connectorRegistry } = require('@app-connect/core');
+const myCRMConnector = require('./connectors/myCRM');
+const manifest = require('./connectors/manifest.json');
+// Set the default manifest for the connector registry. This ensures that all connectors
 // have access to the necessary configuration and metadata before registration.
-adapterRegistry.setDefaultManifest(manifest);
-// Register your CRM adapters. The default manifest must be set before registration
-// to ensure proper initialization of the adapter with the required settings.
-adapterRegistry.registerAdapter('myCRM', myCRMAdapter, manifest);
+connectorRegistry.setDefaultManifest(manifest);
+// Register your CRM connectors. The default manifest must be set before registration
+// to ensure proper initialization of the connector with the required settings.
+connectorRegistry.registerConnector('myCRM', myCRMConnector, manifest);
 
 // Create Express app with all core functionality
 const app = createCoreApp();
@@ -44,12 +44,12 @@ app.get('/my-custom-route', (req, res) => {
 exports.getServer = () => app;
 ```
 
-### Adapter Interface Registration
+### Connector Interface Registration
 
-The adapter registry supports dynamic interface registration, allowing you to extend adapter functionality without modifying the original adapter:
+The connector registry supports dynamic interface registration, allowing you to extend connector functionality without modifying the original connector:
 
 ```javascript
-const { adapterRegistry } = require('@app-connect/core');
+const { connectorRegistry } = require('@app-connect/core');
 
 // Register interface functions for a platform
 async function customCreateCallLog({ user, contactInfo, authHeader, callLog, note }) {
@@ -78,32 +78,32 @@ async function customFindContact({ user, authHeader, phoneNumber }) {
 }
 
 // Register interface functions
-adapterRegistry.registerAdapterInterface('myCRM', 'createCallLog', customCreateCallLog);
-adapterRegistry.registerAdapterInterface('myCRM', 'findContact', customFindContact);
+connectorRegistry.registerConnectorInterface('myCRM', 'createCallLog', customCreateCallLog);
+connectorRegistry.registerConnectorInterface('myCRM', 'findContact', customFindContact);
 
-// Register the base adapter
-adapterRegistry.registerAdapter('myCRM', myCRMAdapter);
+// Register the base connector
+connectorRegistry.registerConnector('myCRM', myCRMConnector);
 
-// Get composed adapter with interfaces
-const composedAdapter = adapterRegistry.getAdapter('myCRM');
+// Get composed connector with interfaces
+const composedConnector = connectorRegistry.getConnector('myCRM');
 ```
 
-**Interface-Only Adapters (No Base Adapter):**
+**Interface-Only Connectors (No Base Connector):**
 
 ```javascript
-// Register only interface functions, no base adapter
-adapterRegistry.registerAdapterInterface('interfaceOnlyCRM', 'createCallLog', customCreateCallLog);
-adapterRegistry.registerAdapterInterface('interfaceOnlyCRM', 'findContact', customFindContact);
+// Register only interface functions, no base connector
+connectorRegistry.registerConnectorInterface('interfaceOnlyCRM', 'createCallLog', customCreateCallLog);
+connectorRegistry.registerConnectorInterface('interfaceOnlyCRM', 'findContact', customFindContact);
 
-// Get interface-only adapter
-const interfaceOnlyAdapter = adapterRegistry.getAdapter('interfaceOnlyCRM');
-console.log('Interface-only methods:', Object.keys(interfaceOnlyAdapter));
+// Get interface-only connector
+const interfaceOnlyConnector = connectorRegistry.getConnector('interfaceOnlyCRM');
+console.log('Interface-only methods:', Object.keys(interfaceOnlyConnector));
 // Output: ['createCallLog', 'findContact']
 
-// Later, you can add a base adapter
-adapterRegistry.registerAdapter('interfaceOnlyCRM', myCRMAdapter);
-const fullAdapter = adapterRegistry.getAdapter('interfaceOnlyCRM');
-console.log('Full adapter methods:', Object.keys(fullAdapter));
+// Later, you can add a base connector
+connectorRegistry.registerConnector('interfaceOnlyCRM', myCRMConnector);
+const fullConnector = connectorRegistry.getConnector('interfaceOnlyCRM');
+console.log('Full connector methods:', Object.keys(fullConnector));
 // Output: ['getAuthType', 'getUserInfo', 'updateCallLog', 'unAuthorize', 'createContact', 'createCallLog', 'findContact']
 ```
 
@@ -115,15 +115,15 @@ const {
     createCoreRouter, 
     createCoreMiddleware, 
     initializeCore, 
-    adapterRegistry 
+    connectorRegistry 
 } = require('@app-connect/core');
 
-const myCRMAdapter = require('./adapters/myCRM');
-const manifest = require('./adapters/manifest.json');
+const myCRMConnector = require('./connectors/myCRM');
+const manifest = require('./connectors/manifest.json');
 // Set manifest
-adapterRegistry.setDefaultManifest(manifest);
-// Register adapters
-adapterRegistry.registerAdapter('myCRM', myCRMAdapter, manifest);
+connectorRegistry.setDefaultManifest(manifest);
+// Register connectors
+connectorRegistry.registerConnector('myCRM', myCRMConnector, manifest);
 
 // Initialize core services
 initializeCore();
@@ -181,24 +181,24 @@ Initializes core services (database, analytics).
   - `skipDatabaseInit` (Boolean): Skip database initialization (default: false)
   - `skipAnalyticsInit` (Boolean): Skip analytics initialization (default: false)
 
-### Adapter Registry
+### Connector Registry
 
-#### `adapterRegistry.setDefaultManifest(manifest)`
-Sets the default manifest for adapters.
+#### `connectorRegistry.setDefaultManifest(manifest)`
+Sets the default manifest for connectors.
 
 **Parameters:**
 - `manifest` (Object): Default manifest
 
-#### `adapterRegistry.registerAdapter(name, adapter, manifest)`
-Registers a CRM adapter.
+#### `connectorRegistry.registerConnector(name, connector, manifest)`
+Registers a CRM connector.
 
 **Parameters:**
-- `name` (String): Adapter name
-- `adapter` (Object): Adapter implementation
-- `manifest` (Object, optional): Adapter manifest
+- `name` (String): Connector name
+- `connector` (Object): Connector implementation
+- `manifest` (Object, optional): Connector manifest
 
-#### `adapterRegistry.registerAdapterInterface(platformName, interfaceName, interfaceFunction)`
-Registers an interface function for a specific platform that will be composed with the adapter at retrieval time.
+#### `connectorRegistry.registerConnectorInterface(platformName, interfaceName, interfaceFunction)`
+Registers an interface function for a specific platform that will be composed with the connector at retrieval time.
 
 **Parameters:**
 - `platformName` (String): Platform identifier (e.g., 'pipedrive', 'salesforce')
@@ -219,32 +219,32 @@ async function customCreateCallLog({ user, contactInfo, authHeader, callLog, not
   };
 }
 
-adapterRegistry.registerAdapterInterface('myCRM', 'createCallLog', customCreateCallLog);
+connectorRegistry.registerConnectorInterface('myCRM', 'createCallLog', customCreateCallLog);
 ```
 
-#### `adapterRegistry.getAdapter(name)`
-Retrieves a registered adapter with composed interfaces.
+#### `connectorRegistry.getConnector(name)`
+Retrieves a registered connector with composed interfaces.
 
 **Parameters:**
-- `name` (String): Adapter name
+- `name` (String): Connector name
 
-**Returns:** Composed adapter object or interface-only object
+**Returns:** Composed connector object or interface-only object
 
 **Behavior:**
-- If adapter exists and interfaces exist: Returns composed adapter with both
-- If adapter exists but no interfaces: Returns original adapter
-- If no adapter but interfaces exist: Returns object with just interface functions
-- If no adapter and no interfaces: Throws error
+- If connector exists and interfaces exist: Returns composed connector with both
+- If connector exists but no interfaces: Returns original connector
+- If no connector but interfaces exist: Returns object with just interface functions
+- If no connector and no interfaces: Throws error
 
-#### `adapterRegistry.getOriginalAdapter(name)`
-Retrieves the original adapter without any composed interface functions.
+#### `connectorRegistry.getOriginalConnector(name)`
+Retrieves the original connector without any composed interface functions.
 
 **Parameters:**
-- `name` (String): Adapter name
+- `name` (String): Connector name
 
-**Returns:** Original adapter object
+**Returns:** Original connector object
 
-#### `adapterRegistry.getPlatformInterfaces(platformName)`
+#### `connectorRegistry.getPlatformInterfaces(platformName)`
 Returns a Map of registered interface functions for a platform.
 
 **Parameters:**
@@ -252,7 +252,7 @@ Returns a Map of registered interface functions for a platform.
 
 **Returns:** Map of interface functions
 
-#### `adapterRegistry.hasPlatformInterface(platformName, interfaceName)`
+#### `connectorRegistry.hasPlatformInterface(platformName, interfaceName)`
 Checks if a specific interface function is registered for a platform.
 
 **Parameters:**
@@ -261,20 +261,20 @@ Checks if a specific interface function is registered for a platform.
 
 **Returns:** Boolean indicating if interface exists
 
-#### `adapterRegistry.unregisterAdapterInterface(platformName, interfaceName)`
+#### `connectorRegistry.unregisterConnectorInterface(platformName, interfaceName)`
 Unregisters an interface function for a platform.
 
 **Parameters:**
 - `platformName` (String): Platform identifier
 - `interfaceName` (String): Interface function name
 
-#### `adapterRegistry.getAdapterCapabilities(platformName)`
-Gets comprehensive information about an adapter including its capabilities and registered interfaces.
+#### `connectorRegistry.getConnectorCapabilities(platformName)`
+Gets comprehensive information about an connector including its capabilities and registered interfaces.
 
 **Parameters:**
 - `platformName` (String): Platform identifier
 
-**Returns:** Object with adapter capabilities information
+**Returns:** Object with connector capabilities information
 
 ### Exported Components
 
@@ -377,29 +377,29 @@ The core package uses the following environment variables:
 - `IS_PROD` - Production environment flag
 - `DYNAMODB_LOCALHOST` - Local DynamoDB endpoint for development, used for lock cache
 
-## Adapter Interface Registration Benefits
+## Connector Interface Registration Benefits
 
 ### Key Features
 
-- **Composition over Mutation**: Interface functions are composed with adapters at retrieval time, preserving the original adapter
-- **Dynamic Registration**: Register interface functions before or after adapter registration
-- **Immutability**: Original adapter objects remain unchanged
-- **Clean Separation**: Interface functions are kept separate from core adapter logic
-- **Flexibility**: Support for interface-only adapters (no base adapter required)
+- **Composition over Mutation**: Interface functions are composed with connectors at retrieval time, preserving the original connector
+- **Dynamic Registration**: Register interface functions before or after connector registration
+- **Immutability**: Original connector objects remain unchanged
+- **Clean Separation**: Interface functions are kept separate from core connector logic
+- **Flexibility**: Support for interface-only connectors (no base connector required)
 
 ### Best Practices
 
-1. **Register Required Interfaces**: Register all required interface functions before using the adapter
+1. **Register Required Interfaces**: Register all required interface functions before using the connector
 2. **Use Descriptive Names**: Use clear, descriptive names for interface functions
 3. **Handle Errors**: Implement proper error handling in interface functions
-4. **Test Composed Adapters**: Test the final composed adapter to ensure interfaces work correctly
+4. **Test Composed Connectors**: Test the final composed connector to ensure interfaces work correctly
 5. **Document Interfaces**: Document what each interface function does and expects
 
 ### Use Cases
 
-- **Extending Existing Adapters**: Add new functionality to existing adapters without modification
-- **Progressive Enhancement**: Start with interfaces, add base adapter later
-- **Testing**: Test interface functions separately from base adapters
+- **Extending Existing Connectors**: Add new functionality to existing connectors without modification
+- **Progressive Enhancement**: Start with interfaces, add base connector later
+- **Testing**: Test interface functions separately from base connectors
 - **Modular Development**: Develop interface functions independently
 - **Plugin Architecture**: Create pluggable interface functions for different scenarios
 
@@ -424,8 +424,8 @@ Core Package
 │   ├── jwt.js       - JWT operations
 │   ├── analytics.js - Analytics tracking
 │   └── util.js      - General utilities
-├── Adapter Registry
-│   └── registry.js  - CRM adapter management
+├── Connector Registry
+│   └── registry.js  - CRM connector management
 └── API Layer
     ├── createCoreApp()     - Complete app setup
     ├── createCoreRouter()  - Route management

package/{adapter → connector}/registry.js

@@ -1,7 +1,7 @@
-// core/src/adapter/registry.js
-class AdapterRegistry {
+// core/src/connector/registry.js
+class ConnectorRegistry {
   constructor() {
-      this.adapters = new Map();
+      this.connectors = new Map();
       this.manifests = new Map();
       this.releaseNotes = {};
       this.platformInterfaces = new Map(); // Store interface functions per platform
@@ -17,7 +17,7 @@ class AdapterRegistry {
    * @param {string} interfaceName - Interface function name (e.g., 'createCallLog', 'findContact')
    * @param {Function} interfaceFunction - The interface function to register
    */
-  registerAdapterInterface(platformName, interfaceName, interfaceFunction) {
+  registerConnectorInterface(platformName, interfaceName, interfaceFunction) {
     if (typeof interfaceFunction !== 'function') {
       throw new Error(`Interface function must be a function, got: ${typeof interfaceFunction}`);
     }
@@ -57,7 +57,7 @@ class AdapterRegistry {
    * @param {string} platformName - Platform identifier
    * @param {string} interfaceName - Interface function name
    */
-  unregisterAdapterInterface(platformName, interfaceName) {
+  unregisterConnectorInterface(platformName, interfaceName) {
     const platformInterfaceMap = this.platformInterfaces.get(platformName);
     if (platformInterfaceMap && platformInterfaceMap.has(interfaceName)) {
       platformInterfaceMap.delete(interfaceName);
@@ -66,80 +66,80 @@ class AdapterRegistry {
   }
 
   /**
-   * Register an adapter with the core system
+   * Register an connector with the core system
    * @param {string} platform - Platform identifier (e.g., 'pipedrive', 'salesforce')
-   * @param {Object} adapter - Adapter implementation
-   * @param {Object} manifest - Adapter manifest configuration
+   * @param {Object} connector - Connector implementation
+   * @param {Object} manifest - Connector manifest configuration
    */
-  registerAdapter(platform, adapter, manifest = null) {
-      // Validate adapter interface
-      this.validateAdapterInterface(platform, adapter);
+  registerConnector(platform, connector, manifest = null) {
+      // Validate connector interface
+      this.validateConnectorInterface(platform, connector);
       
-      this.adapters.set(platform, adapter);
+      this.connectors.set(platform, connector);
       if (manifest) {
         this.manifests.set(platform, manifest);
       }
       
-      console.log(`Registered adapter: ${platform}`);
+      console.log(`Registered connector: ${platform}`);
   }
 
   /**
-   * Get adapter by platform name with composed interfaces
+   * Get connector by platform name with composed interfaces
    * @param {string} platform - Platform identifier
-   * @returns {Object} Composed adapter with interface functions
+   * @returns {Object} Composed connector with interface functions
    */
-  getAdapter(platform) {
-      const adapter = this.adapters.get(platform);
+  getConnector(platform) {
+      const connector = this.connectors.get(platform);
       const platformInterfaceMap = this.platformInterfaces.get(platform);
       
-      // If no adapter and no interfaces, throw error
-      if (!adapter && (!platformInterfaceMap || platformInterfaceMap.size === 0)) {
-          throw new Error(`Adapter not found for platform: ${platform}`);
+      // If no connector and no interfaces, throw error
+      if (!connector && (!platformInterfaceMap || platformInterfaceMap.size === 0)) {
+          throw new Error(`Connector not found for platform: ${platform}`);
       }
 
-      // If no adapter but interfaces exist, create a composed object with just interfaces
-      if (!adapter && platformInterfaceMap && platformInterfaceMap.size > 0) {
-          const composedAdapter = {};
+      // If no connector but interfaces exist, create a composed object with just interfaces
+      if (!connector && platformInterfaceMap && platformInterfaceMap.size > 0) {
+          const composedConnector = {};
           
-          // Add interface functions to the composed adapter
+          // Add interface functions to the composed connector
           for (const [interfaceName, interfaceFunction] of platformInterfaceMap) {
-              composedAdapter[interfaceName] = interfaceFunction;
+              composedConnector[interfaceName] = interfaceFunction;
           }
 
-          console.log(`Returning interface-only adapter for platform: ${platform}`);
-          return composedAdapter;
+          console.log(`Returning interface-only connector for platform: ${platform}`);
+          return composedConnector;
       }
 
-      // If adapter exists but no interfaces, return original adapter
-      if (adapter && (!platformInterfaceMap || platformInterfaceMap.size === 0)) {
-          return adapter;
+      // If connector exists but no interfaces, return original connector
+      if (connector && (!platformInterfaceMap || platformInterfaceMap.size === 0)) {
+          return connector;
       }
 
-      // If both adapter and interfaces exist, create a composed object
-      const composedAdapter = Object.create(adapter);
+      // If both connector and interfaces exist, create a composed object
+      const composedConnector = Object.create(connector);
       
-      // Add interface functions to the composed adapter
+      // Add interface functions to the composed connector
       for (const [interfaceName, interfaceFunction] of platformInterfaceMap) {
-        // Only add if the interface doesn't already exist in the adapter
-        if (!Object.prototype.hasOwnProperty.call(adapter, interfaceName)) {
-          composedAdapter[interfaceName] = interfaceFunction;
+        // Only add if the interface doesn't already exist in the connector
+        if (!Object.prototype.hasOwnProperty.call(connector, interfaceName)) {
+          composedConnector[interfaceName] = interfaceFunction;
         }
       }
 
-      return composedAdapter;
+      return composedConnector;
   }
 
   /**
-   * Get the original adapter without composed interfaces
+   * Get the original connector without composed interfaces
    * @param {string} platform - Platform identifier
-   * @returns {Object} Original adapter implementation
+   * @returns {Object} Original connector implementation
    */
-  getOriginalAdapter(platform) {
-    const adapter = this.adapters.get(platform);
-    if (!adapter) {
-      throw new Error(`Adapter not found for platform: ${platform}`);
+  getOriginalConnector(platform) {
+    const connector = this.connectors.get(platform);
+    if (!connector) {
+      throw new Error(`Connector not found for platform: ${platform}`);
     }
-    return adapter;
+    return connector;
   }
 
   /**
@@ -163,7 +163,7 @@ class AdapterRegistry {
    * @returns {Array<string>} Array of platform names
    */
   getRegisteredPlatforms() {
-      return Array.from(this.adapters.keys());
+      return Array.from(this.connectors.keys());
   }
 
   /**
@@ -172,35 +172,35 @@ class AdapterRegistry {
    * @returns {boolean} True if platform is registered
    */
   isRegistered(platform) {
-      return this.adapters.has(platform);
+      return this.connectors.has(platform);
   }
 
   /**
-   * Validate that adapter implements required interface
-   * @param {Object} adapter - Adapter to validate
+   * Validate that connector implements required interface
+   * @param {Object} connector - Connector to validate
    */
-  validateAdapterInterface(platform, adapter) {
+  validateConnectorInterface(platform, connector) {
       const requiredMethods = [
           'createCallLog',
           'updateCallLog',
       ];
 
       for (const method of requiredMethods) {
-          if (typeof adapter[method] !== 'function') {
-              throw new Error(`Adapter ${platform} missing required method: ${method}`);
+          if (typeof connector[method] !== 'function') {
+              throw new Error(`Connector ${platform} missing required method: ${method}`);
           }
       }
   }
 
   /**
-   * Unregister an adapter
+   * Unregister an connector
    * @param {string} platform - Platform identifier
    */
-  unregisterAdapter(platform) {
-      this.adapters.delete(platform);
+  unregisterConnector(platform) {
+      this.connectors.delete(platform);
       this.manifests.delete(platform);
       this.platformInterfaces.delete(platform);
-      console.log(`Unregistered adapter: ${platform}`);
+      console.log(`Unregistered connector: ${platform}`);
   }
 
   setReleaseNotes(releaseNotes) {
@@ -212,27 +212,27 @@ class AdapterRegistry {
   }
 
   /**
-   * Get adapter capabilities summary including composed interfaces
+   * Get connector capabilities summary including composed interfaces
    * @param {string} platform - Platform identifier
-   * @returns {Object} Adapter capabilities
+   * @returns {Object} Connector capabilities
    */
-  getAdapterCapabilities(platform) {
-    const originalAdapter = this.getOriginalAdapter(platform);
-    const composedAdapter = this.getAdapter(platform);
+  getConnectorCapabilities(platform) {
+    const originalConnector = this.getOriginalConnector(platform);
+    const composedConnector = this.getConnector(platform);
     const platformInterfaceMap = this.getPlatformInterfaces(platform);
     
     const capabilities = {
       platform,
-      originalMethods: Object.keys(originalAdapter),
-      composedMethods: Object.keys(composedAdapter),
+      originalMethods: Object.keys(originalConnector),
+      composedMethods: Object.keys(composedConnector),
       registeredInterfaces: Array.from(platformInterfaceMap.keys()),
       authType: null
     };
 
     // Get auth type if available
-    if (typeof originalAdapter.getAuthType === 'function') {
+    if (typeof originalConnector.getAuthType === 'function') {
       try {
-        capabilities.authType = originalAdapter.getAuthType();
+        capabilities.authType = originalConnector.getAuthType();
       } catch (error) {
         capabilities.authType = 'unknown';
       }
@@ -243,5 +243,5 @@ class AdapterRegistry {
 }
 
 // Export singleton instance
-const adapterRegistry = new AdapterRegistry();
-module.exports = adapterRegistry;
+const connectorRegistry = new ConnectorRegistry();
+module.exports = connectorRegistry;

package/handlers/admin.js

@@ -1,6 +1,6 @@
 const axios = require('axios');
 const { AdminConfigModel } = require('../models/adminConfigModel');
-const adapterRegistry = require('../adapter/registry');
+const connectorRegistry = require('../connector/registry');
 const oauth = require('../lib/oauth');
 const { RingCentral } = require('../lib/ringcentral');
 
@@ -53,7 +53,7 @@ async function updateAdminRcTokens({ hashedRcAccountId, adminAccessToken, adminR
 }
 
 async function getServerLoggingSettings({ user }) {
-    const platformModule = adapterRegistry.getAdapter(user.platform);
+    const platformModule = connectorRegistry.getConnector(user.platform);
     if (platformModule.getServerLoggingSettings) {
         const serverLoggingSettings = await platformModule.getServerLoggingSettings({ user });
         return serverLoggingSettings;
@@ -62,7 +62,7 @@ async function getServerLoggingSettings({ user }) {
 }
 
 async function updateServerLoggingSettings({ user, additionalFieldValues }) {
-    const platformModule = adapterRegistry.getAdapter(user.platform);
+    const platformModule = connectorRegistry.getConnector(user.platform);
     const oauthApp = oauth.getOAuthApp((await platformModule.getOauthInfo({ tokenUrl: user?.platformAdditionalInfo?.tokenUrl, hostname: user?.hostname })));
     if (platformModule.updateServerLoggingSettings) {
         const { successful, returnMessage } = await platformModule.updateServerLoggingSettings({ user, additionalFieldValues, oauthApp });
@@ -200,7 +200,7 @@ async function getUserReport({ rcAccountId, rcExtensionId, timezone, timeFrom, t
 
 async function getUserMapping({ user, hashedRcAccountId, rcExtensionList }) {
     const adminConfig = await getAdminSettings({ hashedRcAccountId });
-    const platformModule = adapterRegistry.getAdapter(user.platform);
+    const platformModule = connectorRegistry.getConnector(user.platform);
     if (platformModule.getUserList) {
         const authType = platformModule.getAuthType();
         let authHeader = '';

package/handlers/auth.js

@@ -1,12 +1,12 @@
 const oauth = require('../lib/oauth');
 const { UserModel } = require('../models/userModel');
-const adapterRegistry = require('../adapter/registry');
+const connectorRegistry = require('../connector/registry');
 const Op = require('sequelize').Op;
 const { RingCentral } = require('../lib/ringcentral');
 const adminCore = require('./admin');
 
 async function onOAuthCallback({ platform, hostname, tokenUrl, callbackUri, apiUrl, username, query }) {
-    const platformModule = adapterRegistry.getAdapter(platform);
+    const platformModule = connectorRegistry.getConnector(platform);
     const oauthInfo = await platformModule.getOauthInfo({ tokenUrl, hostname, rcAccountId: query.rcAccountId });
 
     if (oauthInfo.failMessage) {
@@ -58,7 +58,7 @@ async function onOAuthCallback({ platform, hostname, tokenUrl, callbackUri, apiU
 }
 
 async function onApiKeyLogin({ platform, hostname, apiKey, additionalInfo }) {
-    const platformModule = adapterRegistry.getAdapter(platform);
+    const platformModule = connectorRegistry.getConnector(platform);
     const basicAuth = platformModule.getBasicAuth({ apiKey });
     const { successful, platformUserInfo, returnMessage } = await platformModule.getUserInfo({ authHeader: `Basic ${basicAuth}`, hostname, additionalInfo, apiKey });
     if (successful) {
@@ -169,7 +169,7 @@ async function saveUserInfo({ platformUserInfo, platform, hostname, accessToken,
 }
 
 async function getLicenseStatus({ userId, platform }) {
-    const platformModule = adapterRegistry.getAdapter(platform);
+    const platformModule = connectorRegistry.getConnector(platform);
     const licenseStatus = await platformModule.getLicenseStatus({ userId });
     return licenseStatus;
 }
@@ -187,7 +187,7 @@ async function authValidation({ platform, userId }) {
         }
     });
     if (existingUser) {
-        const platformModule = adapterRegistry.getAdapter(platform);
+        const platformModule = connectorRegistry.getConnector(platform);
         const oauthApp = oauth.getOAuthApp((await platformModule.getOauthInfo({ tokenUrl: existingUser?.platformAdditionalInfo?.tokenUrl, hostname: existingUser?.hostname })));
         existingUser = await oauth.checkAndRefreshAccessToken(oauthApp, existingUser);
         const { successful, returnMessage, status } = await platformModule.authValidation({ user: existingUser });

package/handlers/contact.js

@@ -1,7 +1,7 @@
 const oauth = require('../lib/oauth');
 const { UserModel } = require('../models/userModel');
 const errorMessage = require('../lib/generalErrorMessage');
-const adapterRegistry = require('../adapter/registry');
+const connectorRegistry = require('../connector/registry');
 async function findContact({ platform, userId, phoneNumber, overridingFormat, isExtension }) {
     try {
         let user = await UserModel.findOne({
@@ -20,7 +20,7 @@ async function findContact({ platform, userId, phoneNumber, overridingFormat, is
                 }
             };
         }
-        const platformModule = adapterRegistry.getAdapter(platform);
+        const platformModule = connectorRegistry.getConnector(platform);
         const authType = platformModule.getAuthType();
         let authHeader = '';
         switch (authType) {
@@ -127,7 +127,7 @@ async function createContact({ platform, userId, phoneNumber, newContactName, ne
         if (!user || !user.accessToken) {
             return { successful: false, message: `Contact not found` };
         }
-        const platformModule = adapterRegistry.getAdapter(platform);
+        const platformModule = connectorRegistry.getConnector(platform);
         const authType = platformModule.getAuthType();
         let authHeader = '';
         switch (authType) {
@@ -207,7 +207,7 @@ async function findContactWithName({ platform, userId, name }) {
                 }
             };
         }
-        const platformModule = adapterRegistry.getAdapter(platform);
+        const platformModule = connectorRegistry.getConnector(platform);
         const authType = platformModule.getAuthType();
         let authHeader = '';
         switch (authType) {