@app-connect/core 0.0.1 → 0.0.3

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

@@ -10,7 +10,7 @@ Core package for RingCentral App Connect project providing modular APIs for CRM
 - **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
+- **Database Integration**: Sequelize.js ORM with automatic table management
 
 ## Installation
 
@@ -39,6 +39,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
@@ -125,13 +188,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:** 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:** Adapter instance
+**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
 
@@ -226,16 +360,41 @@ The core package provides the following API endpoints:
 
 The core package uses the following environment variables:
 
-- `DYNAMODB_LOCALHOST` - Local DynamoDB endpoint for development
+- `DATABASE_URL` - Database connection string for Sequelize ORM
 - `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
+- `DYNAMODB_LOCALHOST` - Local DynamoDB endpoint for development, used for lock cache
 
-## Architecture
+## Adapter 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)
 
-The core package follows a modular architecture:
+### 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/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
+}; 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@app-connect/core",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "RingCentral App Connect Core",
   "main": "index.js",
   "repository": {
@@ -35,6 +35,12 @@
     "tz-lookup": "^6.1.25",
     "ua-parser-js": "^1.0.38"
   },
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:ci": "jest --ci --coverage --watchAll=false"
+  },
   "devDependencies": {
     "@eslint/js": "^9.22.0",
     "@octokit/rest": "^19.0.5",

package/test/adapter/registry.test.js

@@ -0,0 +1,271 @@
+const adapterRegistry = require('../../adapter/registry');
+
+describe('AdapterRegistry Interface Registration with Composition', () => {
+  beforeEach(() => {
+    // Clear the registry before each test
+    adapterRegistry.adapters.clear();
+    adapterRegistry.manifests.clear();
+    adapterRegistry.platformInterfaces.clear();
+  });
+
+  test('should register interface functions for a platform', () => {
+    const mockFunction = jest.fn();
+    
+    adapterRegistry.registerAdapterInterface('testPlatform', 'testInterface', mockFunction);
+    
+    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
+    expect(adapterRegistry.getPlatformInterfaces('testPlatform').get('testInterface')).toBe(mockFunction);
+  });
+
+  test('should throw error when registering non-function as interface', () => {
+    expect(() => {
+      adapterRegistry.registerAdapterInterface('testPlatform', 'testInterface', 'not a function');
+    }).toThrow('Interface function must be a function, got: string');
+  });
+
+  test('should return original adapter when no interfaces are registered', () => {
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    const retrievedAdapter = adapterRegistry.getAdapter('testPlatform');
+    expect(retrievedAdapter).toBe(mockAdapter);
+  });
+
+  test('should return composed adapter with interface functions when interfaces are registered', () => {
+    const mockInterface = jest.fn();
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    // Register interface function first
+    adapterRegistry.registerAdapterInterface('testPlatform', 'customMethod', mockInterface);
+    
+    // Register adapter
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    // Get composed adapter
+    const composedAdapter = adapterRegistry.getAdapter('testPlatform');
+    
+    // Should be a different object (composed)
+    expect(composedAdapter).not.toBe(mockAdapter);
+    
+    // Should have the interface function
+    expect(composedAdapter.customMethod).toBe(mockInterface);
+    
+    // Should still have original methods
+    expect(composedAdapter.getAuthType).toBe(mockAdapter.getAuthType);
+    expect(composedAdapter.createCallLog).toBe(mockAdapter.createCallLog);
+  });
+
+  test('should not override existing adapter methods when composing interfaces', () => {
+    const existingMethod = jest.fn();
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn(),
+      existingMethod: existingMethod
+    };
+
+    // Register adapter first
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    // Try to register interface with same name as existing method
+    const newMethod = jest.fn();
+    adapterRegistry.registerAdapterInterface('testPlatform', 'existingMethod', newMethod);
+    
+    // Get composed adapter
+    const composedAdapter = adapterRegistry.getAdapter('testPlatform');
+    
+    // Should not override the existing method
+    expect(composedAdapter.existingMethod).toBe(existingMethod);
+    expect(composedAdapter.existingMethod).not.toBe(newMethod);
+  });
+
+  test('should preserve original adapter when composing interfaces', () => {
+    const mockInterface = jest.fn();
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    adapterRegistry.registerAdapterInterface('testPlatform', 'customMethod', mockInterface);
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    // Get original adapter
+    const originalAdapter = adapterRegistry.getOriginalAdapter('testPlatform');
+    
+    // Original adapter should be unchanged
+    expect(originalAdapter).toBe(mockAdapter);
+    expect(originalAdapter.customMethod).toBeUndefined();
+    
+    // Composed adapter should have the interface
+    const composedAdapter = adapterRegistry.getAdapter('testPlatform');
+    expect(composedAdapter.customMethod).toBe(mockInterface);
+  });
+
+  test('should unregister interface functions', () => {
+    const mockFunction = jest.fn();
+    
+    adapterRegistry.registerAdapterInterface('testPlatform', 'testInterface', mockFunction);
+    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
+    
+    adapterRegistry.unregisterAdapterInterface('testPlatform', 'testInterface');
+    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(false);
+  });
+
+  test('should return empty map for non-existent platform interfaces', () => {
+    const interfaces = adapterRegistry.getPlatformInterfaces('nonExistentPlatform');
+    expect(interfaces).toBeInstanceOf(Map);
+    expect(interfaces.size).toBe(0);
+  });
+
+  test('should return false for non-existent platform interface', () => {
+    expect(adapterRegistry.hasPlatformInterface('nonExistentPlatform', 'anyInterface')).toBe(false);
+  });
+
+  test('should handle multiple interface functions for same platform', () => {
+    const mockFunction1 = jest.fn();
+    const mockFunction2 = jest.fn();
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+    
+    adapterRegistry.registerAdapterInterface('testPlatform', 'interface1', mockFunction1);
+    adapterRegistry.registerAdapterInterface('testPlatform', 'interface2', mockFunction2);
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    const platformInterfaces = adapterRegistry.getPlatformInterfaces('testPlatform');
+    expect(platformInterfaces.size).toBe(2);
+    expect(platformInterfaces.get('interface1')).toBe(mockFunction1);
+    expect(platformInterfaces.get('interface2')).toBe(mockFunction2);
+    
+    // Check composed adapter has both interfaces
+    const composedAdapter = adapterRegistry.getAdapter('testPlatform');
+    expect(composedAdapter.interface1).toBe(mockFunction1);
+    expect(composedAdapter.interface2).toBe(mockFunction2);
+  });
+
+  test('should clean up platform interfaces when unregistering adapter', () => {
+    const mockFunction = jest.fn();
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    adapterRegistry.registerAdapterInterface('testPlatform', 'testInterface', mockFunction);
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
+    
+    adapterRegistry.unregisterAdapter('testPlatform');
+    
+    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(false);
+  });
+
+  test('should get adapter capabilities correctly', () => {
+    const mockInterface = jest.fn();
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    adapterRegistry.registerAdapterInterface('testPlatform', 'customMethod', mockInterface);
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    const capabilities = adapterRegistry.getAdapterCapabilities('testPlatform');
+    
+    expect(capabilities.platform).toBe('testPlatform');
+    expect(capabilities.originalMethods).toContain('getAuthType');
+    expect(capabilities.originalMethods).toContain('createCallLog');
+    expect(capabilities.originalMethods).toContain('updateCallLog');
+    expect(capabilities.composedMethods).toContain('customMethod');
+    expect(capabilities.registeredInterfaces).toContain('customMethod');
+    expect(capabilities.authType).toBe('apiKey');
+  });
+
+  test('should handle interface registration after adapter registration', () => {
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    // Register adapter first
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    // Register interface function after
+    const mockInterface = jest.fn();
+    adapterRegistry.registerAdapterInterface('testPlatform', 'customMethod', mockInterface);
+    
+    // Get composed adapter
+    const composedAdapter = adapterRegistry.getAdapter('testPlatform');
+    
+    // Should have the interface function
+    expect(composedAdapter.customMethod).toBe(mockInterface);
+    
+    // Original adapter should be unchanged
+    const originalAdapter = adapterRegistry.getOriginalAdapter('testPlatform');
+    expect(originalAdapter.customMethod).toBeUndefined();
+  });
+
+  test('should return interface-only adapter when no base adapter is registered', () => {
+    const mockInterface1 = jest.fn();
+    const mockInterface2 = jest.fn();
+    
+    // Register only interface functions, no base adapter
+    adapterRegistry.registerAdapterInterface('interfaceOnlyPlatform', 'method1', mockInterface1);
+    adapterRegistry.registerAdapterInterface('interfaceOnlyPlatform', 'method2', mockInterface2);
+    
+    // Get adapter - should return interface-only object
+    const interfaceOnlyAdapter = adapterRegistry.getAdapter('interfaceOnlyPlatform');
+    
+    // Should have interface functions
+    expect(interfaceOnlyAdapter.method1).toBe(mockInterface1);
+    expect(interfaceOnlyAdapter.method2).toBe(mockInterface2);
+    
+    // Should not have base adapter methods
+    expect(interfaceOnlyAdapter.getAuthType).toBeUndefined();
+    
+    // Should be a plain object, not inherited from any adapter
+    expect(Object.getPrototypeOf(interfaceOnlyAdapter)).toBe(Object.prototype);
+  });
+
+  test('should throw error when no adapter and no interfaces are registered', () => {
+    expect(() => {
+      adapterRegistry.getAdapter('nonExistentPlatform');
+    }).toThrow('Adapter not found for platform: nonExistentPlatform');
+  });
+
+  test('should handle mixed scenarios correctly', () => {
+    // Scenario 1: Only interfaces, no adapter
+    adapterRegistry.registerAdapterInterface('mixedPlatform', 'interfaceMethod', jest.fn());
+    const interfaceOnly = adapterRegistry.getAdapter('mixedPlatform');
+    expect(interfaceOnly.interfaceMethod).toBeDefined();
+    expect(interfaceOnly.getAuthType).toBeUndefined();
+    
+    // Scenario 2: Add adapter later
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+    adapterRegistry.registerAdapter('mixedPlatform', mockAdapter);
+    
+    const composedAdapter = adapterRegistry.getAdapter('mixedPlatform');
+    expect(composedAdapter.interfaceMethod).toBeDefined();
+    expect(composedAdapter.getAuthType).toBeDefined();
+    expect(composedAdapter.getAuthType()).toBe('apiKey');
+  });
+}); 

package/test/handlers/auth.test.js

@@ -0,0 +1,231 @@
+const authHandler = require('../../handlers/auth');
+const adapterRegistry = require('../../adapter/registry');
+
+// Mock the adapter registry
+jest.mock('../../adapter/registry');
+
+describe('Auth Handler', () => {
+  beforeEach(() => {
+    // Reset mocks
+    jest.clearAllMocks();
+    global.testUtils.resetAdapterRegistry();
+  });
+
+  describe('onApiKeyLogin', () => {
+    test('should handle successful API key login', async () => {
+      // Arrange
+      const mockUserInfo = {
+        successful: true,
+        platformUserInfo: {
+          id: 'test-user-id',
+          name: 'Test User',
+          timezoneName: 'America/Los_Angeles',
+          timezoneOffset: 0,
+          platformAdditionalInfo: {}
+        },
+        returnMessage: {
+          messageType: 'success',
+          message: 'Login successful',
+          ttl: 1000
+        }
+      };
+
+      const mockAdapter = global.testUtils.createMockAdapter({
+        getBasicAuth: jest.fn().mockReturnValue('dGVzdC1hcGkta2V5Og=='),
+        getUserInfo: jest.fn().mockResolvedValue(mockUserInfo)
+      });
+      
+      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+
+      const requestData = {
+        platform: 'testCRM',
+        hostname: 'test.example.com',
+        apiKey: 'test-api-key',
+        additionalInfo: {}
+      };
+
+      // Act
+      const result = await authHandler.onApiKeyLogin(requestData);
+
+      // Assert
+      expect(result.userInfo).toBeDefined();
+      expect(result.userInfo.id).toBe('test-user-id');
+      expect(result.userInfo.name).toBe('Test User');
+      expect(result.returnMessage).toEqual(mockUserInfo.returnMessage);
+      expect(mockAdapter.getBasicAuth).toHaveBeenCalledWith({ apiKey: 'test-api-key' });
+      expect(mockAdapter.getUserInfo).toHaveBeenCalledWith({
+        authHeader: 'Basic dGVzdC1hcGkta2V5Og==',
+        hostname: 'test.example.com',
+        additionalInfo: {},
+        apiKey: 'test-api-key'
+      });
+    });
+
+    test('should handle failed API key login', async () => {
+      // Arrange
+      const mockUserInfo = {
+        successful: false,
+        platformUserInfo: null,
+        returnMessage: {
+          messageType: 'error',
+          message: 'Invalid API key',
+          ttl: 3000
+        }
+      };
+
+      const mockAdapter = global.testUtils.createMockAdapter({
+        getBasicAuth: jest.fn().mockReturnValue('dGVzdC1hcGkta2V5Og=='),
+        getUserInfo: jest.fn().mockResolvedValue(mockUserInfo)
+      });
+      
+      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+
+      const requestData = {
+        platform: 'testCRM',
+        hostname: 'test.example.com',
+        apiKey: 'invalid-api-key',
+        additionalInfo: {}
+      };
+
+      // Act
+      const result = await authHandler.onApiKeyLogin(requestData);
+
+      // Assert
+      expect(result.userInfo).toBeNull();
+      expect(result.returnMessage).toEqual(mockUserInfo.returnMessage);
+    });
+
+    test('should throw error when adapter not found', async () => {
+      // Arrange
+      adapterRegistry.getAdapter.mockImplementation(() => {
+        throw new Error('Adapter not found for platform: testCRM');
+      });
+
+      const requestData = {
+        platform: 'testCRM',
+        hostname: 'test.example.com',
+        apiKey: 'test-api-key',
+        additionalInfo: {}
+      };
+
+      // Act & Assert
+      await expect(authHandler.onApiKeyLogin(requestData))
+        .rejects.toThrow('Adapter not found for platform: testCRM');
+    });
+  });
+
+  describe('authValidation', () => {
+    test('should validate user authentication successfully', async () => {
+      // Arrange
+      const mockUser = global.testUtils.createMockUser();
+      const mockValidationResponse = {
+        successful: true,
+        returnMessage: {
+          messageType: 'success',
+          message: 'Authentication valid',
+          ttl: 1000
+        },
+        status: 200
+      };
+
+      const mockAdapter = global.testUtils.createMockAdapter({
+        getOauthInfo: jest.fn().mockResolvedValue({}),
+        authValidation: jest.fn().mockResolvedValue(mockValidationResponse)
+      });
+      
+      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+
+      // Mock UserModel.findOne to return a user
+      const { UserModel } = require('../../models/userModel');
+      jest.spyOn(UserModel, 'findOne').mockResolvedValue(mockUser);
+
+      // Mock oauth.checkAndRefreshAccessToken
+      const oauth = require('../../lib/oauth');
+      jest.spyOn(oauth, 'checkAndRefreshAccessToken').mockResolvedValue(mockUser);
+
+      const requestData = {
+        platform: 'testCRM',
+        userId: 'test-user-id'
+      };
+
+      // Act
+      const result = await authHandler.authValidation(requestData);
+
+      // Assert
+      expect(result).toEqual({
+        ...mockValidationResponse,
+        failReason: ''
+      });
+      expect(mockAdapter.authValidation).toHaveBeenCalledWith({ user: mockUser });
+    });
+
+    test('should handle user not found in database', async () => {
+      // Arrange
+      const mockAdapter = global.testUtils.createMockAdapter();
+      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+
+      // Mock UserModel.findOne to return null (user not found)
+      const { UserModel } = require('../../models/userModel');
+      jest.spyOn(UserModel, 'findOne').mockResolvedValue(null);
+
+      const requestData = {
+        platform: 'testCRM',
+        userId: 'non-existent-user'
+      };
+
+      // Act
+      const result = await authHandler.authValidation(requestData);
+
+      // Assert
+      expect(result).toEqual({
+        successful: false,
+        status: 404,
+        failReason: 'App Connect. User not found in database'
+      });
+    });
+
+    test('should handle validation failure', async () => {
+      // Arrange
+      const mockUser = global.testUtils.createMockUser();
+      const mockValidationResponse = {
+        successful: false,
+        returnMessage: {
+          messageType: 'error',
+          message: 'Authentication failed',
+          ttl: 3000
+        },
+        status: 401
+      };
+
+      const mockAdapter = global.testUtils.createMockAdapter({
+        getOauthInfo: jest.fn().mockResolvedValue({}),
+        authValidation: jest.fn().mockResolvedValue(mockValidationResponse)
+      });
+      
+      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+
+      // Mock UserModel.findOne to return a user
+      const { UserModel } = require('../../models/userModel');
+      jest.spyOn(UserModel, 'findOne').mockResolvedValue(mockUser);
+
+      // Mock oauth.checkAndRefreshAccessToken
+      const oauth = require('../../lib/oauth');
+      jest.spyOn(oauth, 'checkAndRefreshAccessToken').mockResolvedValue(mockUser);
+
+      const requestData = {
+        platform: 'testCRM',
+        userId: 'test-user-id'
+      };
+
+      // Act
+      const result = await authHandler.authValidation(requestData);
+
+      // Assert
+      expect(result).toEqual({
+        ...mockValidationResponse,
+        failReason: 'CRM. API failed'
+      });
+      expect(result.successful).toBe(false);
+    });
+  });
+}); 

package/test/lib/jwt.test.js

@@ -0,0 +1,161 @@
+const jwt = require('../../lib/jwt');
+
+describe('JWT Utility', () => {
+  beforeEach(() => {
+    // Reset environment
+    process.env.APP_SERVER_SECRET_KEY = 'test-secret-key';
+  });
+
+  describe('generateJwt', () => {
+    test('should generate JWT token from payload', () => {
+      // Arrange
+      const payload = {
+        id: 'test-user-id',
+        platform: 'testCRM'
+      };
+
+      // Act
+      const token = jwt.generateJwt(payload);
+
+      // Assert
+      expect(token).toBeDefined();
+      expect(typeof token).toBe('string');
+      expect(token.split('.')).toHaveLength(3); // JWT has 3 parts
+    });
+
+    test('should generate different tokens for different payloads', () => {
+      // Arrange
+      const payload1 = { id: 'user1', platform: 'testCRM' };
+      const payload2 = { id: 'user2', platform: 'testCRM' };
+
+      // Act
+      const token1 = jwt.generateJwt(payload1);
+      const token2 = jwt.generateJwt(payload2);
+
+      // Assert
+      expect(token1).not.toBe(token2);
+    });
+  });
+
+  describe('decodeJwt', () => {
+    test('should decode valid JWT token', () => {
+      // Arrange
+      const payload = {
+        id: 'test-user-id',
+        platform: 'testCRM'
+      };
+      const token = jwt.generateJwt(payload);
+
+      // Act
+      const decoded = jwt.decodeJwt(token);
+
+      // Assert
+      expect(decoded).toMatchObject(payload);
+      expect(decoded).toHaveProperty('exp');
+      expect(decoded).toHaveProperty('iat');
+    });
+
+    test('should return null for invalid token', () => {
+      // Arrange
+      const invalidToken = 'invalid.jwt.token';
+
+      // Act
+      const decoded = jwt.decodeJwt(invalidToken);
+
+      // Assert
+      expect(decoded).toBeNull();
+    });
+
+    test('should return null for malformed token', () => {
+      // Arrange
+      const malformedToken = 'not-a-jwt-token';
+
+      // Act
+      const decoded = jwt.decodeJwt(malformedToken);
+
+      // Assert
+      expect(decoded).toBeNull();
+    });
+
+    test('should return null for token with wrong secret', () => {
+      // Arrange
+      const payload = { id: 'test-user-id', platform: 'testCRM' };
+      const token = jwt.generateJwt(payload);
+      
+      // Change secret temporarily
+      const originalSecret = process.env.APP_SERVER_SECRET_KEY;
+      process.env.APP_SERVER_SECRET_KEY = 'different-secret';
+
+      // Act
+      const decoded = jwt.decodeJwt(token);
+
+      // Restore secret
+      process.env.APP_SERVER_SECRET_KEY = originalSecret;
+
+      // Assert
+      expect(decoded).toBeNull();
+    });
+  });
+
+  describe('generateJwt and decodeJwt round trip', () => {
+    test('should successfully generate and decode complex payload', () => {
+      // Arrange
+      const complexPayload = {
+        id: 'test-user-id',
+        platform: 'testCRM',
+        timestamp: Date.now(),
+        metadata: {
+          timezone: 'America/Los_Angeles',
+          preferences: {
+            autoLog: true,
+            callPop: false
+          }
+        }
+      };
+
+      // Act
+      const token = jwt.generateJwt(complexPayload);
+      const decoded = jwt.decodeJwt(token);
+
+      // Assert
+      expect(decoded).toMatchObject(complexPayload);
+      expect(decoded).toHaveProperty('exp');
+      expect(decoded).toHaveProperty('iat');
+    });
+
+    test('should handle empty payload', () => {
+      // Arrange
+      const emptyPayload = {};
+
+      // Act
+      const token = jwt.generateJwt(emptyPayload);
+      const decoded = jwt.decodeJwt(token);
+
+      // Assert
+      expect(decoded).toMatchObject(emptyPayload);
+      expect(decoded).toHaveProperty('exp');
+      expect(decoded).toHaveProperty('iat');
+    });
+  });
+
+  describe('error handling', () => {
+    test('should handle missing secret key', () => {
+      // Arrange
+      const payload = { id: 'test-user-id' };
+      delete process.env.APP_SERVER_SECRET_KEY;
+
+      // Act & Assert
+      expect(() => jwt.generateJwt(payload)).toThrow();
+    });
+
+    test('should handle null payload', () => {
+      // Act & Assert
+      expect(() => jwt.generateJwt(null)).toThrow();
+    });
+
+    test('should handle undefined payload', () => {
+      // Act & Assert
+      expect(() => jwt.generateJwt(undefined)).toThrow();
+    });
+  });
+});

package/test/setup.js

@@ -0,0 +1,176 @@
+// Test setup for @app-connect/core package
+const path = require('path');
+require('dotenv').config({ path: path.resolve(__dirname, '../.env.test') });
+
+// Set test timeout
+jest.setTimeout(30000);
+
+// Mock console methods to reduce noise in tests
+global.console = {
+  ...console,
+  log: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+};
+
+// Setup database models for testing
+beforeAll(async () => {
+  try {
+    // Set up test database URL if not provided
+    if (!process.env.DATABASE_URL) {
+      process.env.DATABASE_URL = 'sqlite::memory:';
+    }
+
+    // Import models
+    const { CallLogModel } = require('../models/callLogModel');
+    const { MessageLogModel } = require('../models/messageLogModel');
+    const { UserModel } = require('../models/userModel');
+    const { CacheModel } = require('../models/cacheModel');
+    const { AdminConfigModel } = require('../models/adminConfigModel');
+
+    // Sync database models
+    await CallLogModel.sync({ force: true });
+    await MessageLogModel.sync({ force: true });
+    await UserModel.sync({ force: true });
+    await CacheModel.sync({ force: true });
+    await AdminConfigModel.sync({ force: true });
+
+    console.log('Database models synced for testing');
+  } catch (error) {
+    console.error('Error setting up test database:', error);
+    // Don't fail the setup, some tests might not need database
+  }
+});
+
+// Clean up after all tests
+afterAll(async () => {
+  try {
+    // Close database connections
+    const { sequelize } = require('../models/sequelize');
+    if (sequelize) {
+      await sequelize.close();
+    }
+  } catch (error) {
+    console.error('Error closing database connection:', error);
+  }
+});
+
+// Global test utilities
+global.testUtils = {
+  // Helper to create mock user
+  createMockUser: (overrides = {}) => ({
+    id: 'test-user-id',
+    platform: 'testCRM',
+    accessToken: 'test-access-token',
+    refreshToken: 'test-refresh-token',
+    tokenExpiry: new Date(Date.now() + 3600000), // 1 hour from now
+    platformUserInfo: {
+      id: 'test-platform-user-id',
+      name: 'Test User',
+      timezoneName: 'America/Los_Angeles',
+      timezoneOffset: 0,
+      platformAdditionalInfo: {}
+    },
+    ...overrides
+  }),
+
+  // Helper to create mock call log
+  createMockCallLog: (overrides = {}) => ({
+    id: 'test-call-log-id',
+    userId: 'test-user-id',
+    platform: 'testCRM',
+    thirdPartyLogId: 'test-third-party-id',
+    contactId: 'test-contact-id',
+    contactType: 'Contact',
+    phoneNumber: '+1234567890',
+    callDirection: 'Inbound',
+    callResult: 'Answered',
+    callDuration: 120,
+    callStartTime: new Date(),
+    callEndTime: new Date(Date.now() + 120000),
+    recordingLink: 'https://example.com/recording.mp3',
+    subject: 'Test Call',
+    note: 'Test call note',
+    ...overrides
+  }),
+
+  // Helper to create mock contact
+  createMockContact: (overrides = {}) => ({
+    id: 'test-contact-id',
+    name: 'Test Contact',
+    type: 'Contact',
+    phone: '+1234567890',
+    additionalInfo: null,
+    ...overrides
+  }),
+
+  // Helper to reset adapter registry
+  resetAdapterRegistry: () => {
+    const adapterRegistry = require('../adapter/registry');
+    adapterRegistry.adapters.clear();
+    adapterRegistry.manifests.clear();
+    adapterRegistry.platformInterfaces.clear();
+    adapterRegistry.releaseNotes = {};
+  },
+
+  // Helper to create mock adapter
+  createMockAdapter: (overrides = {}) => ({
+    getAuthType: jest.fn().mockReturnValue('apiKey'),
+    getUserInfo: jest.fn().mockResolvedValue({
+      successful: true,
+      platformUserInfo: {
+        id: 'test-user-id',
+        name: 'Test User',
+        timezoneName: 'America/Los_Angeles',
+        timezoneOffset: 0,
+        platformAdditionalInfo: {}
+      }
+    }),
+    createCallLog: jest.fn().mockResolvedValue({
+      logId: 'test-log-id',
+      returnMessage: {
+        message: 'Call logged successfully',
+        messageType: 'success',
+        ttl: 2000
+      }
+    }),
+    updateCallLog: jest.fn().mockResolvedValue({
+      updatedNote: 'Call log updated',
+      returnMessage: {
+        message: 'Call log updated successfully',
+        messageType: 'success',
+        ttl: 2000
+      }
+    }),
+    unAuthorize: jest.fn().mockResolvedValue({
+      returnMessage: {
+        messageType: 'success',
+        message: 'Logged out successfully',
+        ttl: 1000
+      }
+    }),
+    findContact: jest.fn().mockResolvedValue([
+      {
+        id: 'test-contact-id',
+        name: 'Test Contact',
+        type: 'Contact',
+        phone: '+1234567890',
+        additionalInfo: null
+      }
+    ]),
+    createContact: jest.fn().mockResolvedValue({
+      contactInfo: {
+        id: 'new-contact-id',
+        name: 'New Contact'
+      },
+      returnMessage: {
+        message: 'Contact created successfully',
+        messageType: 'success',
+        ttl: 2000
+      }
+    }),
+    ...overrides
+  })
+};