@app-connect/core 0.0.2 → 1.5.8

package/.env.test

@@ -0,0 +1,5 @@
+NODE_ENV=test
+APP_SERVER_SECRET_KEY='test-secret-key'
+HASH_KEY='test-hash-key'
+DISABLE_SYNC_DB_TABLE='true'
+DATABASE_URL='sqlite::memory:'

package/README.md

@@ -24,9 +24,14 @@ npm install @app-connect/core
 
 ```javascript
 const { createCoreApp, adapterRegistry } = require('@app-connect/core');
-
-// Register your CRM adapters
-adapterRegistry.registerAdapter('myCRM', myCRMAdapter);
+const myCRMAdapter = require('./adapters/myCRM');
+const manifest = require('./adapters/manifest.json');
+// Set the default manifest for the adapter registry. This ensures that all adapters
+// 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);
 
 // Create Express app with all core functionality
 const app = createCoreApp();
@@ -39,6 +44,69 @@ app.get('/my-custom-route', (req, res) => {
 exports.getServer = () => app;
 ```
 
+### Adapter Interface Registration
+
+The adapter registry supports dynamic interface registration, allowing you to extend adapter functionality without modifying the original adapter:
+
+```javascript
+const { adapterRegistry } = require('@app-connect/core');
+
+// Register interface functions for a platform
+async function customCreateCallLog({ user, contactInfo, authHeader, callLog, note }) {
+  // Custom implementation
+  return {
+    logId: 'custom-log-id',
+    returnMessage: {
+      message: 'Call logged with custom implementation',
+      messageType: 'success',
+      ttl: 2000
+    }
+  };
+}
+
+async function customFindContact({ user, authHeader, phoneNumber }) {
+  // Custom implementation
+  return [
+    {
+      id: 'custom-contact-id',
+      name: 'Custom Contact',
+      type: 'Contact',
+      phone: phoneNumber,
+      additionalInfo: null
+    }
+  ];
+}
+
+// Register interface functions
+adapterRegistry.registerAdapterInterface('myCRM', 'createCallLog', customCreateCallLog);
+adapterRegistry.registerAdapterInterface('myCRM', 'findContact', customFindContact);
+
+// Register the base adapter
+adapterRegistry.registerAdapter('myCRM', myCRMAdapter);
+
+// Get composed adapter with interfaces
+const composedAdapter = adapterRegistry.getAdapter('myCRM');
+```
+
+**Interface-Only Adapters (No Base Adapter):**
+
+```javascript
+// Register only interface functions, no base adapter
+adapterRegistry.registerAdapterInterface('interfaceOnlyCRM', 'createCallLog', customCreateCallLog);
+adapterRegistry.registerAdapterInterface('interfaceOnlyCRM', 'findContact', customFindContact);
+
+// Get interface-only adapter
+const interfaceOnlyAdapter = adapterRegistry.getAdapter('interfaceOnlyCRM');
+console.log('Interface-only methods:', Object.keys(interfaceOnlyAdapter));
+// 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));
+// Output: ['getAuthType', 'getUserInfo', 'updateCallLog', 'unAuthorize', 'createContact', 'createCallLog', 'findContact']
+```
+
 ### Advanced Usage with Custom Middleware
 
 ```javascript
@@ -50,8 +118,12 @@ const {
     adapterRegistry 
 } = require('@app-connect/core');
 
+const myCRMAdapter = require('./adapters/myCRM');
+const manifest = require('./adapters/manifest.json');
+// Set manifest
+adapterRegistry.setDefaultManifest(manifest);
 // Register adapters
-adapterRegistry.registerAdapter('myCRM', myCRMAdapter);
+adapterRegistry.registerAdapter('myCRM', myCRMAdapter, manifest);
 
 // Initialize core services
 initializeCore();
@@ -125,13 +197,84 @@ Registers a CRM adapter.
 - `adapter` (Object): Adapter implementation
 - `manifest` (Object, optional): Adapter manifest
 
+#### `adapterRegistry.registerAdapterInterface(platformName, interfaceName, interfaceFunction)`
+Registers an interface function for a specific platform that will be composed with the adapter at retrieval time.
+
+**Parameters:**
+- `platformName` (String): Platform identifier (e.g., 'pipedrive', 'salesforce')
+- `interfaceName` (String): Interface function name (e.g., 'createCallLog', 'findContact')
+- `interfaceFunction` (Function): The interface function to register
+
+**Example:**
+```javascript
+async function customCreateCallLog({ user, contactInfo, authHeader, callLog, note }) {
+  // Custom implementation
+  return {
+    logId: 'custom-log-id',
+    returnMessage: {
+      message: 'Call logged with custom implementation',
+      messageType: 'success',
+      ttl: 2000
+    }
+  };
+}
+
+adapterRegistry.registerAdapterInterface('myCRM', 'createCallLog', customCreateCallLog);
+```
+
 #### `adapterRegistry.getAdapter(name)`
-Retrieves a registered adapter.
+Retrieves a registered adapter with composed interfaces.
 
 **Parameters:**
 - `name` (String): Adapter name
 
-**Returns:** Adapter instance
+**Returns:** Composed adapter 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
+
+#### `adapterRegistry.getOriginalAdapter(name)`
+Retrieves the original adapter without any composed interface functions.
+
+**Parameters:**
+- `name` (String): Adapter name
+
+**Returns:** Original adapter object
+
+#### `adapterRegistry.getPlatformInterfaces(platformName)`
+Returns a Map of registered interface functions for a platform.
+
+**Parameters:**
+- `platformName` (String): Platform identifier
+
+**Returns:** Map of interface functions
+
+#### `adapterRegistry.hasPlatformInterface(platformName, interfaceName)`
+Checks if a specific interface function is registered for a platform.
+
+**Parameters:**
+- `platformName` (String): Platform identifier
+- `interfaceName` (String): Interface function name
+
+**Returns:** Boolean indicating if interface exists
+
+#### `adapterRegistry.unregisterAdapterInterface(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.
+
+**Parameters:**
+- `platformName` (String): Platform identifier
+
+**Returns:** Object with adapter capabilities information
 
 ### Exported Components
 
@@ -234,9 +377,33 @@ The core package uses the following environment variables:
 - `IS_PROD` - Production environment flag
 - `DYNAMODB_LOCALHOST` - Local DynamoDB endpoint for development, used for lock cache
 
-## Architecture
+## Adapter Interface Registration Benefits
+
+### Key Features
 
-The core package follows a modular architecture:
+- **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)
+
+### Best Practices
+
+1. **Register Required Interfaces**: Register all required interface functions before using the adapter
+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
+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
+- **Modular Development**: Develop interface functions independently
+- **Plugin Architecture**: Create pluggable interface functions for different scenarios
+
+## Architecture
 
 ```
 Core Package

package/adapter/registry.js

@@ -4,12 +4,67 @@ class AdapterRegistry {
       this.adapters = new Map();
       this.manifests = new Map();
       this.releaseNotes = {};
+      this.platformInterfaces = new Map(); // Store interface functions per platform
   }
 
   setDefaultManifest(manifest) {
     this.manifests.set('default', manifest);
   }
 
+  /**
+   * Register an interface function for a specific platform
+   * @param {string} platformName - Platform identifier (e.g., 'pipedrive', 'salesforce')
+   * @param {string} interfaceName - Interface function name (e.g., 'createCallLog', 'findContact')
+   * @param {Function} interfaceFunction - The interface function to register
+   */
+  registerAdapterInterface(platformName, interfaceName, interfaceFunction) {
+    if (typeof interfaceFunction !== 'function') {
+      throw new Error(`Interface function must be a function, got: ${typeof interfaceFunction}`);
+    }
+
+    if (!this.platformInterfaces.has(platformName)) {
+      this.platformInterfaces.set(platformName, new Map());
+    }
+
+    const platformInterfaceMap = this.platformInterfaces.get(platformName);
+    platformInterfaceMap.set(interfaceName, interfaceFunction);
+
+    console.log(`Registered interface function: ${platformName}.${interfaceName}`);
+  }
+
+  /**
+   * Get registered interface functions for a platform
+   * @param {string} platformName - Platform identifier
+   * @returns {Map} Map of interface functions
+   */
+  getPlatformInterfaces(platformName) {
+    return this.platformInterfaces.get(platformName) || new Map();
+  }
+
+  /**
+   * Check if an interface function is registered for a platform
+   * @param {string} platformName - Platform identifier
+   * @param {string} interfaceName - Interface function name
+   * @returns {boolean} True if interface is registered
+   */
+  hasPlatformInterface(platformName, interfaceName) {
+    const platformInterfaceMap = this.platformInterfaces.get(platformName);
+    return platformInterfaceMap ? platformInterfaceMap.has(interfaceName) : false;
+  }
+
+  /**
+   * Unregister an interface function for a platform
+   * @param {string} platformName - Platform identifier
+   * @param {string} interfaceName - Interface function name
+   */
+  unregisterAdapterInterface(platformName, interfaceName) {
+    const platformInterfaceMap = this.platformInterfaces.get(platformName);
+    if (platformInterfaceMap && platformInterfaceMap.has(interfaceName)) {
+      platformInterfaceMap.delete(interfaceName);
+      console.log(`Unregistered interface function: ${platformName}.${interfaceName}`);
+    }
+  }
+
   /**
    * Register an adapter with the core system
    * @param {string} platform - Platform identifier (e.g., 'pipedrive', 'salesforce')
@@ -29,16 +84,62 @@ class AdapterRegistry {
   }
 
   /**
-   * Get adapter by platform name
+   * Get adapter by platform name with composed interfaces
    * @param {string} platform - Platform identifier
-   * @returns {Object} Adapter implementation
+   * @returns {Object} Composed adapter with interface functions
    */
   getAdapter(platform) {
       const adapter = this.adapters.get(platform);
-      if (!adapter) {
+      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}`);
       }
-      return adapter;
+
+      // If no adapter but interfaces exist, create a composed object with just interfaces
+      if (!adapter && platformInterfaceMap && platformInterfaceMap.size > 0) {
+          const composedAdapter = {};
+          
+          // Add interface functions to the composed adapter
+          for (const [interfaceName, interfaceFunction] of platformInterfaceMap) {
+              composedAdapter[interfaceName] = interfaceFunction;
+          }
+
+          console.log(`Returning interface-only adapter for platform: ${platform}`);
+          return composedAdapter;
+      }
+
+      // If adapter exists but no interfaces, return original adapter
+      if (adapter && (!platformInterfaceMap || platformInterfaceMap.size === 0)) {
+          return adapter;
+      }
+
+      // If both adapter and interfaces exist, create a composed object
+      const composedAdapter = Object.create(adapter);
+      
+      // Add interface functions to the composed adapter
+      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;
+        }
+      }
+
+      return composedAdapter;
+  }
+
+  /**
+   * Get the original adapter without composed interfaces
+   * @param {string} platform - Platform identifier
+   * @returns {Object} Original adapter implementation
+   */
+  getOriginalAdapter(platform) {
+    const adapter = this.adapters.get(platform);
+    if (!adapter) {
+      throw new Error(`Adapter not found for platform: ${platform}`);
+    }
+    return adapter;
   }
 
   /**
@@ -98,6 +199,7 @@ class AdapterRegistry {
   unregisterAdapter(platform) {
       this.adapters.delete(platform);
       this.manifests.delete(platform);
+      this.platformInterfaces.delete(platform);
       console.log(`Unregistered adapter: ${platform}`);
   }
 
@@ -108,8 +210,38 @@ class AdapterRegistry {
   getReleaseNotes(platform) {
     return this.releaseNotes; 
   }
+
+  /**
+   * Get adapter capabilities summary including composed interfaces
+   * @param {string} platform - Platform identifier
+   * @returns {Object} Adapter capabilities
+   */
+  getAdapterCapabilities(platform) {
+    const originalAdapter = this.getOriginalAdapter(platform);
+    const composedAdapter = this.getAdapter(platform);
+    const platformInterfaceMap = this.getPlatformInterfaces(platform);
+    
+    const capabilities = {
+      platform,
+      originalMethods: Object.keys(originalAdapter),
+      composedMethods: Object.keys(composedAdapter),
+      registeredInterfaces: Array.from(platformInterfaceMap.keys()),
+      authType: null
+    };
+
+    // Get auth type if available
+    if (typeof originalAdapter.getAuthType === 'function') {
+      try {
+        capabilities.authType = originalAdapter.getAuthType();
+      } catch (error) {
+        capabilities.authType = 'unknown';
+      }
+    }
+
+    return capabilities;
+  }
 }
 
 // Export singleton instance
 const adapterRegistry = new AdapterRegistry();
-module.exports = adapterRegistry;
+module.exports = adapterRegistry;

package/handlers/log.js

@@ -4,8 +4,9 @@ const { MessageLogModel } = require('../models/messageLogModel');
 const { UserModel } = require('../models/userModel');
 const oauth = require('../lib/oauth');
 const errorMessage = require('../lib/generalErrorMessage');
-const { composeCallLog, getLogFormatType, FORMAT_TYPES } = require('../lib/callLogComposer');
+const { composeCallLog, getLogFormatType } = require('../lib/callLogComposer');
 const adapterRegistry = require('../adapter/registry');
+const { LOG_DETAILS_FORMAT_TYPE } = require('../lib/constants');
 
 async function createCallLog({ platform, userId, incomingData }) {
     try {
@@ -76,7 +77,7 @@ async function createCallLog({ platform, userId, incomingData }) {
         // Compose call log details centrally
         const logFormat = getLogFormatType(platform);
         let composedLogDetails = '';
-        if (logFormat === FORMAT_TYPES.PLAIN_TEXT || logFormat === FORMAT_TYPES.HTML) {
+        if (logFormat === LOG_DETAILS_FORMAT_TYPE.PLAIN_TEXT || logFormat === LOG_DETAILS_FORMAT_TYPE.HTML || logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
             composedLogDetails = await composeCallLog({
                 logFormat,
                 callLog,
@@ -309,7 +310,7 @@ async function updateCallLog({ platform, userId, incomingData }) {
             let existingCallLogDetails = null;    // Compose updated call log details centrally
             const logFormat = getLogFormatType(platform);
             let composedLogDetails = '';
-            if (logFormat === FORMAT_TYPES.PLAIN_TEXT || logFormat === FORMAT_TYPES.HTML) {
+            if (logFormat === LOG_DETAILS_FORMAT_TYPE.PLAIN_TEXT || logFormat === LOG_DETAILS_FORMAT_TYPE.HTML || logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
                 let existingBody = '';
                 try {
                     const getLogResult = await platformModule.getCallLog({

package/index.js

@@ -76,7 +76,7 @@ function createCoreRouter() {
         const versions = Object.keys(adapterReleaseNotes);
         for (const version of versions) {
             mergedReleaseNotes[version] = {
-                global: globalReleaseNotes[version].global,
+                global: globalReleaseNotes[version]?.global ?? {},
                 ...adapterReleaseNotes[version] ?? {}
             };
         }
@@ -229,7 +229,8 @@ function createCoreRouter() {
                 platformName = unAuthData?.platform ?? 'Unknown';
                 const user = await UserModel.findByPk(unAuthData?.id);
                 if (!user) {
-                    res.status(400).send();
+                    res.status(400).send('User not found');
+                    return;
                 }
                 const { isValidated, rcAccountId } = await adminCore.validateAdminRole({ rcAccessToken: req.query.rcAccessToken });
                 const hashedRcAccountId = util.getHashValue(rcAccountId, process.env.HASH_KEY);
@@ -402,7 +403,8 @@ function createCoreRouter() {
                 platformName = unAuthData?.platform ?? 'Unknown';
                 const user = await UserModel.findByPk(unAuthData?.id);
                 if (!user) {
-                    res.status(400).send();
+                    res.status(400).send('User not found');
+                    return;
                 }
                 else {
                     const rcAccessToken = req.query.rcAccessToken;

package/jest.config.js

@@ -0,0 +1,57 @@
+const path = require('path');
+
+module.exports = {
+  // Test environment
+  testEnvironment: 'node',
+  
+  // Test file patterns
+  testMatch: [
+    '<rootDir>/test/**/*.test.js',
+    '<rootDir>/**/*.test.js'
+  ],
+  
+  // Setup files
+  setupFilesAfterEnv: [
+    '<rootDir>/test/setup.js'
+  ],
+  
+  // Coverage configuration
+  collectCoverage: true,
+  coverageDirectory: '<rootDir>/coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+  coveragePathIgnorePatterns: [
+    '/node_modules/',
+    '/test/',
+    '/coverage/',
+    'jest.config.js',
+    'setup.js'
+  ],
+  
+  // Module resolution
+  moduleDirectories: ['node_modules', '<rootDir>'],
+  moduleNameMapper: {
+    '^@app-connect/core/(.*)$': '<rootDir>/$1'
+  },
+  
+  // Test timeout
+  testTimeout: 30000,
+  
+  // Reporters
+  reporters: ['default'],
+  
+  // Ignore patterns
+  modulePathIgnorePatterns: [
+    '<rootDir>/node_modules/',
+    '<rootDir>/coverage/',
+    '<rootDir>/test-results/'
+  ],
+  
+  // Clear mocks between tests
+  clearMocks: true,
+  
+  // Restore mocks between tests
+  restoreMocks: true,
+  
+  // Verbose output
+  verbose: true
+};