@app-connect/core 0.0.1

package/README.md

@@ -0,0 +1,266 @@
+# App Connect Core
+
+Core package for RingCentral App Connect project providing modular APIs for CRM integration, authentication, contact management, and call logging.
+
+## Features
+
+- **Modular API Design**: Flexible Express app setup with customizable middleware and routes
+- **CRM Adapter Registry**: Centralized adapter 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
+- **Analytics**: Built-in analytics tracking for all operations
+- **Database Integration**: DynamoDB integration with automatic table management
+
+## Installation
+
+```bash
+npm install @app-connect/core
+```
+
+## Quick Start
+
+### Basic Usage
+
+```javascript
+const { createCoreApp, adapterRegistry } = require('@app-connect/core');
+
+// Register your CRM adapters
+adapterRegistry.registerAdapter('myCRM', myCRMAdapter);
+
+// Create Express app with all core functionality
+const app = createCoreApp();
+
+// Add your custom routes
+app.get('/my-custom-route', (req, res) => {
+    res.send('Hello from custom route!');
+});
+
+exports.getServer = () => app;
+```
+
+### Advanced Usage with Custom Middleware
+
+```javascript
+const express = require('express');
+const { 
+    createCoreRouter, 
+    createCoreMiddleware, 
+    initializeCore, 
+    adapterRegistry 
+} = require('@app-connect/core');
+
+// Register adapters
+adapterRegistry.registerAdapter('myCRM', myCRMAdapter);
+
+// Initialize core services
+initializeCore();
+
+// Create your own Express app
+const app = express();
+
+// Add custom middleware first
+app.use(express.static('public'));
+app.use('/api/v2', customApiMiddleware);
+
+// Apply core middleware
+const coreMiddleware = createCoreMiddleware();
+coreMiddleware.forEach(middleware => app.use(middleware));
+
+// Add core routes
+const coreRouter = createCoreRouter();
+app.use('/', coreRouter);
+
+// Add custom routes
+app.get('/my-custom-route', (req, res) => {
+    res.send('Hello from custom route!');
+});
+```
+
+## API Reference
+
+### Core Functions
+
+#### `createCoreApp(options)`
+Creates a complete Express app with all core functionality.
+
+**Parameters:**
+- `options` (Object, optional): Configuration options
+  - `skipDatabaseInit` (Boolean): Skip database initialization (default: false)
+  - `skipAnalyticsInit` (Boolean): Skip analytics initialization (default: false)
+
+**Returns:** Express application instance
+
+#### `createCoreRouter()`
+Creates an Express router with all core routes.
+
+**Returns:** Express router instance
+
+#### `createCoreMiddleware()`
+Returns an array of core middleware functions.
+
+**Returns:** Array of middleware functions
+
+#### `initializeCore(options)`
+Initializes core services (database, analytics).
+
+**Parameters:**
+- `options` (Object, optional): Configuration options
+  - `skipDatabaseInit` (Boolean): Skip database initialization (default: false)
+  - `skipAnalyticsInit` (Boolean): Skip analytics initialization (default: false)
+
+### Adapter Registry
+
+#### `adapterRegistry.setDefaultManifest(manifest)`
+Sets the default manifest for adapters.
+
+**Parameters:**
+- `manifest` (Object): Default manifest
+
+#### `adapterRegistry.registerAdapter(name, adapter, manifest)`
+Registers a CRM adapter.
+
+**Parameters:**
+- `name` (String): Adapter name
+- `adapter` (Object): Adapter implementation
+- `manifest` (Object, optional): Adapter manifest
+
+#### `adapterRegistry.getAdapter(name)`
+Retrieves a registered adapter.
+
+**Parameters:**
+- `name` (String): Adapter name
+
+**Returns:** Adapter instance
+
+### Exported Components
+
+#### Handlers
+```javascript
+const authHandler = require('@app-connect/core/handlers/auth');
+const contactHandler = require('@app-connect/core/handlers/contact');
+const logHandler = require('@app-connect/core/handlers/log');
+const adminHandler = require('@app-connect/core/handlers/admin');
+const userHandler = require('@app-connect/core/handlers/user');
+const dispositionHandler = require('@app-connect/core/handlers/disposition');
+
+// Available handlers:
+// authHandler      - Authentication operations
+// contactHandler   - Contact management
+// logHandler       - Call/message logging
+// adminHandler     - Admin operations
+// userHandler      - User management
+// dispositionHandler - Call disposition
+```
+
+#### Models
+```javascript
+const { UserModel } = require('@app-connect/core/models/userModel');
+const { CallLogModel } = require('@app-connect/core/models/callLogModel');
+const { MessageLogModel } = require('@app-connect/core/models/messageLogModel');
+const { AdminConfigModel } = require('@app-connect/core/models/adminConfigModel');
+const { CacheModel } = require('@app-connect/core/models/cacheModel');
+
+// Available models:
+// UserModel        - User data model
+// CallLogModel     - Call log data model
+// MessageLogModel  - Message log data model
+// AdminConfigModel - Admin configuration model
+// CacheModel       - Cache data model
+```
+
+#### Utilities
+```javascript
+const jwt = require('@app-connect/core/lib/jwt');
+const analytics = require('@app-connect/core/lib/analytics');
+const util = require('@app-connect/core/lib/util');
+
+// Available utilities:
+// jwt        - JWT token management
+// analytics  - Analytics tracking
+// util       - General utilities
+```
+
+## Core Routes
+
+The core package provides the following API endpoints:
+
+### Authentication
+- `GET /authValidation` - Validate user authentication
+- `GET /oauth-callback` - OAuth callback handler
+- `POST /apiKeyLogin` - API key authentication
+- `POST /unAuthorize` - Logout user
+
+### Contact Management
+- `GET /contact` - Find contacts by phone number
+- `POST /contact` - Create new contact
+- `GET /custom/contact/search` - Search contacts by name
+
+### Call Logging
+- `GET /callLog` - Retrieve call logs
+- `POST /callLog` - Create call log
+- `PATCH /callLog` - Update call log
+- `PUT /callDisposition` - Set call disposition
+- `POST /messageLog` - Create message log
+
+### User Management
+- `GET /user/settings` - Get user settings
+- `POST /user/settings` - Update user settings
+- `GET /user/preloadSettings` - Preload user settings
+
+### Admin Operations
+- `GET /admin/settings` - Get admin settings
+- `POST /admin/settings` - Update admin settings
+- `GET /admin/serverLoggingSettings` - Get server logging settings
+- `POST /admin/serverLoggingSettings` - Update server logging settings
+
+### System
+- `GET /releaseNotes` - Get release notes
+- `GET /crmManifest` - Get CRM manifest
+- `GET /is-alive` - Health check
+- `GET /serverVersionInfo` - Get server version
+- `GET /hostname` - Get user hostname
+- `GET /userInfoHash` - Get hashed user info
+
+## Environment Variables
+
+The core package uses the following environment variables:
+
+- `DYNAMODB_LOCALHOST` - Local DynamoDB endpoint for development
+- `DISABLE_SYNC_DB_TABLE` - Skip database table synchronization
+- `OVERRIDE_APP_SERVER` - Override app server URL in manifests
+- `HASH_KEY` - Key for hashing user information
+- `APP_SERVER_SECRET_KEY` - Server secret key
+- `IS_PROD` - Production environment flag
+
+## Architecture
+
+The core package follows a modular architecture:
+
+```
+Core Package
+├── Handlers (Business Logic)
+│   ├── auth.js      - Authentication logic
+│   ├── contact.js   - Contact management
+│   ├── log.js       - Call/message logging
+│   ├── admin.js     - Admin operations
+│   ├── user.js      - User management
+│   └── disposition.js - Call disposition
+├── Models (Data Layer)
+│   ├── userModel.js
+│   ├── callLogModel.js
+│   ├── messageLogModel.js
+│   ├── adminConfigModel.js
+│   └── cacheModel.js
+├── Utils (Utilities)
+│   ├── jwt.js       - JWT operations
+│   ├── analytics.js - Analytics tracking
+│   └── util.js      - General utilities
+├── Adapter Registry
+│   └── registry.js  - CRM adapter management
+└── API Layer
+    ├── createCoreApp()     - Complete app setup
+    ├── createCoreRouter()  - Route management
+    ├── createCoreMiddleware() - Middleware management
+    └── initializeCore()    - Service initialization
+```

package/adapter/mock.js

@@ -0,0 +1,77 @@
+// This mock is to run high traffic tests on the server
+
+const { UserModel } = require("../models/userModel");
+const { CallLogModel } = require("../models/callLogModel");
+const shortid = require("shortid");
+const Op = require('sequelize').Op;
+
+async function createUser() {
+    let mockUser = await UserModel.findByPk('mockUser');
+    if (!mockUser) {
+        mockUser = await UserModel.create({
+            id: 'mockUser'
+        });
+    }
+    return mockUser;
+}
+
+async function deleteUser() {
+    let mockUser = await UserModel.findByPk('mockUser');
+    if (mockUser) {
+        await mockUser.destroy();
+        return true;
+    }
+    return false;
+}
+
+async function getCallLog({ sessionIds }) {
+    const sessionIdsArray = sessionIds.split(',');
+    const callLogs = await CallLogModel.findAll({
+        where: {
+            sessionId: {
+                [Op.in]: sessionIdsArray
+            }
+        }
+    });
+    const logs = [];
+    for (const sId of sessionIdsArray) {
+        const callLog = callLogs.find(c => c.sessionId === sId);
+        if (!callLog) {
+            logs.push({ sessionId: sId, matched: false });
+        }
+        else {
+            logs.push({ sessionId: callLog.sessionId, matched: true, logId: 'mockThirdPartyLogId' });
+        }
+    }
+
+    return logs;
+}
+
+async function createCallLog({ sessionId }) {
+    let callLog = await CallLogModel.findOne({
+        where: {
+            sessionId
+        }
+    });
+    if (!callLog) {
+        callLog = await CallLogModel.create({
+            id: shortid.generate(),
+            sessionId,
+            userId: 'mockUser'
+        });
+    }
+}
+
+async function cleanUpMockLogs() {
+    await CallLogModel.destroy({
+        where: {
+            userId: 'mockUser'
+        }
+    });
+}
+
+exports.createUser = createUser;
+exports.deleteUser = deleteUser;
+exports.getCallLog = getCallLog;
+exports.createCallLog = createCallLog;
+exports.cleanUpMockLogs = cleanUpMockLogs;

package/adapter/registry.js

@@ -0,0 +1,115 @@
+// core/src/adapter/registry.js
+class AdapterRegistry {
+  constructor() {
+      this.adapters = new Map();
+      this.manifests = new Map();
+      this.releaseNotes = {};
+  }
+
+  setDefaultManifest(manifest) {
+    this.manifests.set('default', manifest);
+  }
+
+  /**
+   * Register an adapter with the core system
+   * @param {string} platform - Platform identifier (e.g., 'pipedrive', 'salesforce')
+   * @param {Object} adapter - Adapter implementation
+   * @param {Object} manifest - Adapter manifest configuration
+   */
+  registerAdapter(platform, adapter, manifest = null) {
+      // Validate adapter interface
+      this.validateAdapterInterface(platform, adapter);
+      
+      this.adapters.set(platform, adapter);
+      if (manifest) {
+        this.manifests.set(platform, manifest);
+      }
+      
+      console.log(`Registered adapter: ${platform}`);
+  }
+
+  /**
+   * Get adapter by platform name
+   * @param {string} platform - Platform identifier
+   * @returns {Object} Adapter implementation
+   */
+  getAdapter(platform) {
+      const adapter = this.adapters.get(platform);
+      if (!adapter) {
+          throw new Error(`Adapter not found for platform: ${platform}`);
+      }
+      return adapter;
+  }
+
+  /**
+   * Get manifest for a platform
+   * @param {string} platform - Platform identifier
+   * @returns {Object} Manifest configuration
+   */
+  getManifest(platform, fallbackToDefault = false) {
+      let manifest = this.manifests.get(platform);
+      if (!manifest && fallbackToDefault) {
+        manifest = this.manifests.get('default');
+      }
+      if (!manifest) {
+        throw new Error(`Manifest not found for platform: ${platform}`);
+      }
+      return manifest;
+  }
+
+  /**
+   * Get all registered platforms
+   * @returns {Array<string>} Array of platform names
+   */
+  getRegisteredPlatforms() {
+      return Array.from(this.adapters.keys());
+  }
+
+  /**
+   * Check if platform is registered
+   * @param {string} platform - Platform identifier
+   * @returns {boolean} True if platform is registered
+   */
+  isRegistered(platform) {
+      return this.adapters.has(platform);
+  }
+
+  /**
+   * Validate that adapter implements required interface
+   * @param {Object} adapter - Adapter to validate
+   */
+  validateAdapterInterface(platform, adapter) {
+      const requiredMethods = [
+          'createCallLog',
+          'updateCallLog',
+      ];
+
+      for (const method of requiredMethods) {
+          if (typeof adapter[method] !== 'function') {
+              throw new Error(`Adapter ${platform} missing required method: ${method}`);
+          }
+      }
+  }
+
+  /**
+   * Unregister an adapter
+   * @param {string} platform - Platform identifier
+   */
+  unregisterAdapter(platform) {
+      this.adapters.delete(platform);
+      this.manifests.delete(platform);
+      console.log(`Unregistered adapter: ${platform}`);
+  }
+
+  setReleaseNotes(releaseNotes) {
+    this.releaseNotes = releaseNotes;
+  }
+
+  getReleaseNotes(platform) {
+    return this.releaseNotes; 
+  }
+}
+
+// Export singleton instance
+const adapterRegistry = new AdapterRegistry();
+module.exports = adapterRegistry;

package/handlers/admin.js

@@ -0,0 +1,60 @@
+const axios = require('axios');
+const { AdminConfigModel } = require('../models/adminConfigModel');
+const adapterRegistry = require('../adapter/registry');
+
+async function validateAdminRole({ rcAccessToken }) {
+    const rcExtensionResponse = await axios.get(
+        'https://platform.ringcentral.com/restapi/v1.0/account/~/extension/~',
+        {
+            headers: {
+                Authorization: `Bearer ${rcAccessToken}`,
+            },
+        });
+    return {
+        isValidated: !!rcExtensionResponse.data?.permissions?.admin?.enabled || (!!process.env.ADMIN_EXTENSION_ID_DEV_PASS_LIST && process.env.ADMIN_EXTENSION_ID_DEV_PASS_LIST.split(',').includes(rcExtensionResponse.data.id.toString())),
+        rcAccountId: rcExtensionResponse.data.account.id
+    };
+}
+
+async function upsertAdminSettings({ hashedRcAccountId, adminSettings }) {
+    let existingAdminConfig = await AdminConfigModel.findByPk(hashedRcAccountId);
+    if (existingAdminConfig) {
+        await existingAdminConfig.update({
+            ...adminSettings
+        });
+    } else {
+        await AdminConfigModel.create({
+            id: hashedRcAccountId,
+            ...adminSettings
+        });
+    }
+}
+
+async function getAdminSettings({ hashedRcAccountId }) {
+    const existingAdminConfig = await AdminConfigModel.findByPk(hashedRcAccountId);
+    return existingAdminConfig;
+}
+
+async function getServerLoggingSettings({ user }) {
+    const platformModule = adapterRegistry.getAdapter(user.platform);
+    if (platformModule.getServerLoggingSettings) {
+        const serverLoggingSettings = await platformModule.getServerLoggingSettings({ user });
+        return serverLoggingSettings;
+    }
+    return {};
+}
+
+async function updateServerLoggingSettings({ user, additionalFieldValues }) {
+    const platformModule = adapterRegistry.getAdapter(user.platform);
+    if (platformModule.updateServerLoggingSettings) {
+        const serverLoggingSettings = await platformModule.updateServerLoggingSettings({ user, additionalFieldValues });
+        return serverLoggingSettings;
+    }
+    return {};
+}
+
+exports.validateAdminRole = validateAdminRole;
+exports.upsertAdminSettings = upsertAdminSettings;
+exports.getAdminSettings = getAdminSettings;
+exports.getServerLoggingSettings = getServerLoggingSettings;
+exports.updateServerLoggingSettings = updateServerLoggingSettings;

package/handlers/auth.js

@@ -0,0 +1,156 @@
+const oauth = require('../lib/oauth');
+const { UserModel } = require('../models/userModel');
+const adapterRegistry = require('../adapter/registry');
+const Op = require('sequelize').Op;
+
+async function onOAuthCallback({ platform, hostname, tokenUrl, callbackUri, apiUrl, username, query }) {
+    const platformModule = adapterRegistry.getAdapter(platform);
+    const oauthInfo = await platformModule.getOauthInfo({ tokenUrl, hostname, rcAccountId: query.rcAccountId });
+
+    if (oauthInfo.failMessage) {
+        return {
+            userInfo: null,
+            returnMessage: {
+                messageType: 'danger',
+                message: oauthInfo.failMessage
+            }
+        }
+    }
+
+    // Some platforms require different oauth queries, this won't affect normal OAuth process unless CRM module implements getOverridingOAuthOption() method
+    let overridingOAuthOption = null;
+    if (platformModule.getOverridingOAuthOption != null) {
+        overridingOAuthOption = platformModule.getOverridingOAuthOption({ code: callbackUri.split('code=')[1] });
+    }
+    const oauthApp = oauth.getOAuthApp(oauthInfo);
+    const { accessToken, refreshToken, expires } = await oauthApp.code.getToken(callbackUri, overridingOAuthOption);
+    const authHeader = `Bearer ${accessToken}`;
+    const { successful, platformUserInfo, returnMessage } = await platformModule.getUserInfo({ authHeader, tokenUrl, apiUrl, hostname, username, callbackUri, query });
+    if (successful) {
+        const userInfo = await saveUserInfo({
+            platformUserInfo,
+            platform,
+            tokenUrl,
+            apiUrl,
+            username,
+            hostname: platformUserInfo?.overridingHostname ? platformUserInfo.overridingHostname : hostname,
+            accessToken,
+            refreshToken,
+            tokenExpiry: expires
+        });
+        return {
+            userInfo,
+            returnMessage
+        };
+    }
+    else {
+        return {
+            userInfo: null,
+            returnMessage
+        }
+    }
+}
+
+async function onApiKeyLogin({ platform, hostname, apiKey, additionalInfo }) {
+    const platformModule = adapterRegistry.getAdapter(platform);
+    const basicAuth = platformModule.getBasicAuth({ apiKey });
+    const { successful, platformUserInfo, returnMessage } = await platformModule.getUserInfo({ authHeader: `Basic ${basicAuth}`, hostname, additionalInfo, apiKey });
+    if (successful) {
+        const userInfo = await saveUserInfo({
+            platformUserInfo,
+            platform,
+            hostname,
+            accessToken: platformUserInfo.overridingApiKey ?? apiKey
+        });
+        return {
+            userInfo,
+            returnMessage
+        };
+    }
+    else {
+        return {
+            userInfo: null,
+            returnMessage
+        }
+    }
+}
+
+async function saveUserInfo({ platformUserInfo, platform, hostname, accessToken, refreshToken, tokenExpiry }) {
+    const id = platformUserInfo.id;
+    const name = platformUserInfo.name;
+    const existingUser = await UserModel.findByPk(id);
+    const timezoneName = platformUserInfo.timezoneName;
+    const timezoneOffset = platformUserInfo.timezoneOffset;
+    const platformAdditionalInfo = platformUserInfo.platformAdditionalInfo;
+    if (existingUser) {
+        await existingUser.update(
+            {
+                hostname,
+                timezoneName,
+                timezoneOffset,
+                accessToken,
+                refreshToken,
+                tokenExpiry,
+                platformAdditionalInfo: {
+                    ...existingUser.platformAdditionalInfo, // keep existing platformAdditionalInfo
+                    ...platformAdditionalInfo,
+                }
+            }
+        );
+    }
+    else {
+        await UserModel.create({
+            id,
+            hostname,
+            timezoneName,
+            timezoneOffset,
+            platform,
+            accessToken,
+            refreshToken,
+            tokenExpiry,
+            platformAdditionalInfo,
+            userSettings: {}
+        });
+    }
+    return {
+        id,
+        name
+    };
+}
+
+// Just for oauth ATM
+async function authValidation({ platform, userId }) {
+    let existingUser = await UserModel.findOne({
+        where: {
+            [Op.and]: [
+                {
+                    id: userId,
+                    platform
+                }
+            ]
+        }
+    });
+    if (existingUser) {
+        const platformModule = adapterRegistry.getAdapter(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 });
+        return {
+            successful,
+            returnMessage,
+            status,
+            failReason: successful ? '' : 'CRM. API failed'
+        }
+    }
+    else {
+        return {
+            successful: false,
+            status: 404,
+            failReason: 'App Connect. User not found in database'
+        }
+    }
+}
+
+exports.onOAuthCallback = onOAuthCallback;
+exports.onApiKeyLogin = onApiKeyLogin;
+exports.authValidation = authValidation;