@friggframework/core 2.0.0--canary.395.6ee402d.0 → 2.0.0--canary.395.704a466.0

package/handlers/auth-flow.integration.test.js

@@ -0,0 +1,427 @@
+//todo: this test can probably be removed later
+
+/**
+ * Integration test to verify that the auth flow works without requiring a database record
+ * This test simulates the actual problem we're solving.
+ */
+
+const {
+    IntegrationEventDispatcher,
+} = require('./integration-event-dispatcher');
+const { IntegrationBase } = require('../integrations/integration-base');
+
+// Simulate AsanaIntegration-like class
+class SimulatedAsanaIntegration extends IntegrationBase {
+    static Definition = {
+        name: 'asana',
+        version: '1.0.0',
+        modules: {
+            asana: { definition: { name: 'asana' } },
+            frontify: { definition: { name: 'frontify' } },
+        },
+        routes: [
+            { path: '/auth', method: 'GET', event: 'AUTH_REQUEST' },
+            {
+                path: '/auth/redirect/:provider',
+                method: 'GET',
+                event: 'AUTH_REDIRECT',
+            },
+            { path: '/fetch-form', method: 'GET', event: 'LOAD_FORM' },
+        ],
+    };
+
+    constructor(params) {
+        super(params);
+
+        // Define events like AsanaIntegration does
+        this.events = {
+            AUTH_REQUEST: {
+                handler: this.authRequest.bind(this),
+            },
+            AUTH_REDIRECT: {
+                handler: this.authRedirect.bind(this),
+            },
+            LOAD_FORM: {
+                handler: this.loadForm.bind(this),
+            },
+        };
+    }
+
+    async authRequest({ req, res }) {
+        // This should work WITHOUT any database record
+        // Simulating OAuth flow initiation
+        const provider = req.params?.provider || 'asana';
+
+        return {
+            success: true,
+            action: 'redirect',
+            url: `https://app.asana.com/oauth/authorize?client_id=test&redirect_uri=test`,
+            provider: provider,
+            message: 'Auth initiated without database record!',
+        };
+    }
+
+    async authRedirect({ req, res }) {
+        // Handle OAuth callback
+        const code = req.query?.code;
+
+        if (!code) {
+            throw new Error('No authorization code provided');
+        }
+
+        // In real implementation, would exchange code for tokens
+        // and create database record here
+        return {
+            success: true,
+            action: 'tokens_received',
+            message: 'Would create integration record here',
+        };
+    }
+
+    async loadForm({ req, res }) {
+        // This SHOULD require database record
+        if (!this.id) {
+            throw new Error('Integration not found - must authenticate first');
+        }
+
+        return {
+            success: true,
+            form: {
+                fields: ['field1', 'field2'],
+            },
+            integrationId: this.id,
+        };
+    }
+}
+
+describe('Auth Flow Integration Test', () => {
+    let dispatcher;
+    let mockIntegrationRepository;
+    let mockModuleRepository;
+    let mockModuleFactory;
+
+    beforeEach(() => {
+        // Create mocks
+        mockIntegrationRepository = {
+            findIntegrationByName: jest.fn(),
+        };
+
+        mockModuleRepository = {
+            findEntitiesByIds: jest.fn(),
+        };
+
+        mockModuleFactory = {
+            getModuleInstance: jest.fn(),
+        };
+
+        // Create dispatcher
+        dispatcher = new IntegrationEventDispatcher({
+            integrationRepository: mockIntegrationRepository,
+            moduleFactory: mockModuleFactory,
+            moduleRepository: mockModuleRepository,
+        });
+    });
+
+    describe('First-time authentication (no database record)', () => {
+        it('should handle AUTH_REQUEST without database record', async () => {
+            // Simulate: No integration exists in database yet
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(
+                null
+            );
+
+            const req = { params: { provider: 'asana' }, query: {} };
+            const res = { json: jest.fn(), redirect: jest.fn() };
+            const next = jest.fn();
+
+            // This is the key test - auth should work WITHOUT database record
+            const result = await dispatcher.dispatchHttp({
+                integrationClass: SimulatedAsanaIntegration,
+                event: 'AUTH_REQUEST',
+                req,
+                res,
+                next,
+            });
+
+            expect(result).toMatchObject({
+                success: true,
+                action: 'redirect',
+                message: 'Auth initiated without database record!',
+            });
+
+            // Verify we tried to look up the integration
+            expect(
+                mockIntegrationRepository.findIntegrationByName
+            ).toHaveBeenCalledWith('asana');
+
+            // Verify we didn't try to load modules (stateless)
+            expect(mockModuleFactory.getModuleInstance).not.toHaveBeenCalled();
+        });
+
+        it('should handle AUTH_REDIRECT without database record', async () => {
+            // Still no database record during OAuth callback
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(
+                null
+            );
+
+            const req = {
+                params: { provider: 'asana' },
+                query: { code: 'auth_code_123' },
+            };
+            const res = { json: jest.fn() };
+            const next = jest.fn();
+
+            const result = await dispatcher.dispatchHttp({
+                integrationClass: SimulatedAsanaIntegration,
+                event: 'AUTH_REDIRECT',
+                req,
+                res,
+                next,
+            });
+
+            expect(result).toMatchObject({
+                success: true,
+                action: 'tokens_received',
+                message: 'Would create integration record here',
+            });
+        });
+
+        it('should fail LOAD_FORM without database record', async () => {
+            // No database record means not authenticated
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(
+                null
+            );
+
+            const req = { query: {} };
+            const res = { json: jest.fn() };
+            const next = jest.fn();
+
+            // This should fail because loadForm requires database state
+            await expect(
+                dispatcher.dispatchHttp({
+                    integrationClass: SimulatedAsanaIntegration,
+                    event: 'LOAD_FORM',
+                    req,
+                    res,
+                    next,
+                })
+            ).rejects.toThrow(
+                'Integration not found - must authenticate first'
+            );
+        });
+    });
+
+    describe('Authenticated user (with database record)', () => {
+        it('should handle LOAD_FORM with database record', async () => {
+            // Simulate existing integration in database
+            const mockRecord = {
+                id: 'integration-abc-123',
+                userId: 'user-456',
+                config: {
+                    type: 'asana',
+                    asanaWorkspaceId: 'workspace-789',
+                },
+                status: 'ENABLED',
+                version: '1.0.0',
+                messages: { errors: [], warnings: [] },
+                entitiesIds: ['entity-asana', 'entity-frontify'],
+            };
+
+            const mockEntities = [
+                { _id: 'entity-asana', name: 'asana' },
+                { _id: 'entity-frontify', name: 'frontify' },
+            ];
+
+            const mockAsanaModule = {
+                getName: () => 'asana',
+                api: { getUser: jest.fn() },
+            };
+
+            const mockFrontifyModule = {
+                getName: () => 'frontify',
+                api: { getProjects: jest.fn() },
+            };
+
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(
+                mockRecord
+            );
+            mockModuleRepository.findEntitiesByIds.mockResolvedValue(
+                mockEntities
+            );
+            mockModuleFactory.getModuleInstance
+                .mockResolvedValueOnce(mockAsanaModule)
+                .mockResolvedValueOnce(mockFrontifyModule);
+
+            const req = { query: {} };
+            const res = { json: jest.fn() };
+            const next = jest.fn();
+
+            const result = await dispatcher.dispatchHttp({
+                integrationClass: SimulatedAsanaIntegration,
+                event: 'LOAD_FORM',
+                req,
+                res,
+                next,
+            });
+
+            expect(result).toMatchObject({
+                success: true,
+                form: {
+                    fields: expect.any(Array),
+                },
+                integrationId: 'integration-abc-123',
+            });
+
+            // Verify modules were loaded
+            expect(mockModuleFactory.getModuleInstance).toHaveBeenCalledTimes(
+                2
+            );
+        });
+    });
+
+    describe('Error scenarios', () => {
+        it('should gracefully handle database connection errors during auth', async () => {
+            // Database is down but auth should still work
+            mockIntegrationRepository.findIntegrationByName.mockRejectedValue(
+                new Error('MongoDB connection failed')
+            );
+
+            const req = { params: { provider: 'asana' }, query: {} };
+            const res = { json: jest.fn() };
+            const next = jest.fn();
+
+            // Should still work with stateless instance
+            const result = await dispatcher.dispatchHttp({
+                integrationClass: SimulatedAsanaIntegration,
+                event: 'AUTH_REQUEST',
+                req,
+                res,
+                next,
+            });
+
+            expect(result).toMatchObject({
+                success: true,
+                action: 'redirect',
+                message: 'Auth initiated without database record!',
+            });
+        });
+
+        it('should handle missing event gracefully', async () => {
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(
+                null
+            );
+
+            const req = {};
+            const res = { json: jest.fn() };
+            const next = jest.fn();
+
+            await expect(
+                dispatcher.dispatchHttp({
+                    integrationClass: SimulatedAsanaIntegration,
+                    event: 'UNKNOWN_EVENT',
+                    req,
+                    res,
+                    next,
+                })
+            ).rejects.toThrow('Event UNKNOWN_EVENT not registered for asana');
+        });
+    });
+});
+
+describe('Real-world scenario simulation', () => {
+    it('should handle complete auth flow from start to finish', async () => {
+        const mockIntegrationRepository = {
+            findIntegrationByName: jest.fn(),
+            createIntegration: jest.fn(),
+        };
+
+        const mockModuleRepository = {
+            findEntitiesByIds: jest.fn(),
+        };
+
+        const mockModuleFactory = {
+            getModuleInstance: jest.fn(),
+        };
+
+        const dispatcher = new IntegrationEventDispatcher({
+            integrationRepository: mockIntegrationRepository,
+            moduleFactory: mockModuleFactory,
+            moduleRepository: mockModuleRepository,
+        });
+
+        // Step 1: User initiates auth - no DB record exists
+        mockIntegrationRepository.findIntegrationByName.mockResolvedValue(null);
+
+        const authReq = { params: { provider: 'asana' } };
+        const authRes = { json: jest.fn() };
+        const authNext = jest.fn();
+
+        const step1 = await dispatcher.dispatchHttp({
+            integrationClass: SimulatedAsanaIntegration,
+            event: 'AUTH_REQUEST',
+            req: authReq,
+            res: authRes,
+            next: authNext,
+        });
+
+        expect(step1.success).toBe(true);
+        expect(step1.action).toBe('redirect');
+
+        // Step 2: OAuth callback - still no DB record
+        const callbackReq = {
+            params: { provider: 'asana' },
+            query: { code: 'oauth_code_xyz' },
+        };
+        const callbackRes = { json: jest.fn() };
+        const callbackNext = jest.fn();
+
+        const step2 = await dispatcher.dispatchHttp({
+            integrationClass: SimulatedAsanaIntegration,
+            event: 'AUTH_REDIRECT',
+            req: callbackReq,
+            res: callbackRes,
+            next: callbackNext,
+        });
+
+        expect(step2.success).toBe(true);
+        expect(step2.message).toBe('Would create integration record here');
+
+        // In real implementation, the AUTH_REDIRECT handler would create the DB record
+        // Let's simulate that it was created
+
+        // Step 3: Now user can access protected routes with DB record
+        const mockRecord = {
+            id: 'new-integration-123',
+            userId: 'user-456',
+            config: { type: 'asana' },
+            status: 'ENABLED',
+            version: '1.0.0',
+            messages: { errors: [], warnings: [] },
+            entitiesIds: [],
+        };
+
+        mockIntegrationRepository.findIntegrationByName.mockResolvedValue(
+            mockRecord
+        );
+        mockModuleRepository.findEntitiesByIds.mockResolvedValue([]);
+
+        const formReq = { query: {} };
+        const formRes = { json: jest.fn() };
+        const formNext = jest.fn();
+
+        const step3 = await dispatcher.dispatchHttp({
+            integrationClass: SimulatedAsanaIntegration,
+            event: 'LOAD_FORM',
+            req: formReq,
+            res: formRes,
+            next: formNext,
+        });
+
+        expect(step3.success).toBe(true);
+        expect(step3.integrationId).toBe('new-integration-123');
+
+        // Verify the progression from stateless to stateful
+        expect(
+            mockIntegrationRepository.findIntegrationByName
+        ).toHaveBeenCalledTimes(3);
+    });
+});

package/handlers/backend-utils.js

@@ -4,7 +4,7 @@ const { IntegrationRepository } = require('../integrations/integration-repositor
 const { ModuleFactory } = require('../modules/module-factory');
 const { getModulesDefinitionFromIntegrationClasses } = require('../integrations/utils/map-integration-dto');
 const { ModuleRepository } = require('../modules/module-repository');
-const { GetIntegrationInstanceByDefinition } = require('../integrations/use-cases/get-integration-instance-by-definition');
+const { IntegrationEventDispatcher } = require('./integration-event-dispatcher');
 
 const loadRouterFromObject = (IntegrationClass, routerObject) => {
 
@@ -14,6 +14,14 @@ const loadRouterFromObject = (IntegrationClass, routerObject) => {
         moduleRepository,
         moduleDefinitions: getModulesDefinitionFromIntegrationClasses([IntegrationClass]),
     });
+
+    // Create the event dispatcher
+    const dispatcher = new IntegrationEventDispatcher({
+        integrationRepository,
+        moduleFactory,
+        moduleRepository,
+    });
+
     const router = Router();
     const { path, method, event } = routerObject;
 
@@ -23,13 +31,13 @@ const loadRouterFromObject = (IntegrationClass, routerObject) => {
 
     router[method.toLowerCase()](path, async (req, res, next) => {
         try {
-            const getIntegrationInstanceByDefinition = new GetIntegrationInstanceByDefinition({
-                integrationRepository,
-                moduleFactory,
-                moduleRepository,
+            const result = await dispatcher.dispatchHttp({
+                integrationClass: IntegrationClass,
+                event,
+                req,
+                res,
+                next
             });
-            const integration = await getIntegrationInstanceByDefinition.execute(IntegrationClass);
-            const result = await integration.send(event, { req, res, next });
             res.json(result);
         } catch (error) {
             next(error);
@@ -50,19 +58,19 @@ const createQueueWorker = (integrationClass) => {
             moduleDefinitions: getModulesDefinitionFromIntegrationClasses([integrationClass]),
         });
 
+        dispatcher = new IntegrationEventDispatcher({
+            integrationRepository: this.integrationRepository,
+            moduleFactory: this.moduleFactory,
+            moduleRepository: this.moduleRepository,
+        });
+
         async _run(params, context) {
             try {
-                const getIntegrationInstanceByDefinition = new GetIntegrationInstanceByDefinition({
-                    integrationRepository: this.integrationRepository,
-                    moduleFactory: this.moduleFactory,
-                    moduleRepository: this.moduleRepository,
-                });
-
-                const integration = await getIntegrationInstanceByDefinition.execute(integrationClass);
-
-                const res = await integration.send(params.event, {
+                const res = await this.dispatcher.dispatchJob({
+                    integrationClass: integrationClass,
+                    event: params.event,
                     data: params.data,
-                    context,
+                    context: context,
                 });
                 return res;
             } catch (error) {

package/handlers/integration-event-dispatcher.js

@@ -0,0 +1,101 @@
+
+class IntegrationEventDispatcher {
+  constructor({ integrationRepository, moduleFactory, moduleRepository }) {
+    this.integrationRepository = integrationRepository;
+    this.moduleFactory = moduleFactory;
+    this.moduleRepository = moduleRepository;
+  }
+
+  async dispatchHttp({ integrationClass, event, req, res, next }) {
+    // Create or get integration instance
+    const integration = await this.resolveIntegration(integrationClass);
+
+    // Get the handler method from the integration's events object
+    // The integration defines this.events = { EVENT_NAME: { handler: this.method.bind(this) } }
+    const handler = this.findEventHandler(integration, event);
+
+    if (!handler) {
+      throw new Error(`Event ${event} not registered for ${integrationClass.Definition.name}`);
+    }
+
+    // Call the handler directly
+    return await handler.call(integration, { req, res, next });
+  }
+
+  async dispatchJob({ integrationClass, event, data, context }) {
+    const integration = await this.resolveIntegration(integrationClass);
+
+    const handler = this.findEventHandler(integration, event);
+
+    if (!handler) {
+      throw new Error(`Event ${event} not registered for ${integrationClass.Definition.name}`);
+    }
+
+    return await handler.call(integration, { data, context });
+  }
+
+  findEventHandler(integration, event) {
+    // First check if integration has events object
+    if (integration.events && integration.events[event]) {
+      return integration.events[event].handler;
+    }
+
+    // Check default events (ON_CREATE, ON_UPDATE, etc.)
+    if (integration.defaultEvents && integration.defaultEvents[event]) {
+      return integration.defaultEvents[event].handler;
+    }
+
+    return null;
+  }
+
+  async resolveIntegration(integrationClass) {
+    let integrationInstance;
+
+    try {
+      // Try to get persisted integration from database
+      const integrationRecord = await this.integrationRepository.findIntegrationByName(
+        integrationClass.Definition.name
+      );
+
+      if (integrationRecord) {
+        // Load with full database state and modules
+        const entities = await this.moduleRepository.findEntitiesByIds(integrationRecord.entitiesIds);
+        const modules = [];
+
+        for (const entity of entities) {
+          const moduleInstance = await this.moduleFactory.getModuleInstance(
+            entity.id,
+            integrationRecord.userId
+          );
+          modules.push(moduleInstance);
+        }
+
+        integrationInstance = new integrationClass({
+          id: integrationRecord.id,
+          userId: integrationRecord.userId,
+          entities: entities,
+          config: integrationRecord.config,
+          status: integrationRecord.status,
+          version: integrationRecord.version,
+          messages: integrationRecord.messages,
+          modules: modules
+        });
+      } else {
+        // No DB record - create stateless instance for auth routes
+        integrationInstance = new integrationClass({});
+      }
+    } catch (error) {
+      // If DB lookup fails, create stateless instance
+      integrationInstance = new integrationClass({});
+    }
+
+    // Initialize the integration (loads dynamic events if any)
+    if (typeof integrationInstance.initialize === 'function') {
+      await integrationInstance.initialize();
+    }
+
+    return integrationInstance;
+  }
+}
+
+module.exports = { IntegrationEventDispatcher };

package/handlers/integration-event-dispatcher.test.js

@@ -0,0 +1,473 @@
+const { IntegrationEventDispatcher } = require('./integration-event-dispatcher');
+const { IntegrationBase } = require('../integrations/integration-base');
+
+// Mock dependencies
+const mockIntegrationRepository = {
+    findIntegrationByName: jest.fn()
+};
+
+const mockModuleRepository = {
+    findEntitiesByIds: jest.fn()
+};
+
+const mockModuleFactory = {
+    getModuleInstance: jest.fn()
+};
+
+// Create a test integration class
+class TestIntegration extends IntegrationBase {
+    static Definition = {
+        name: 'test-integration',
+        version: '1.0.0',
+        modules: {},
+        routes: [
+            {
+                path: '/auth',
+                method: 'GET',
+                event: 'AUTH_REQUEST'
+            },
+            {
+                path: '/data',
+                method: 'GET',
+                event: 'LOAD_DATA'
+            },
+            {
+                path: '/test',
+                method: 'POST',
+                event: 'TEST_EVENT'
+            },
+            {
+                path: '/dynamic',
+                method: 'GET',
+                event: 'DYNAMIC_EVENT'
+            }
+        ]
+    };
+
+    constructor(params) {
+        super(params);
+        // Define events in constructor like AsanaIntegration does
+        this.events = {
+            'AUTH_REQUEST': {
+                handler: this.authRequest.bind(this)
+            },
+            'LOAD_DATA': {
+                handler: this.loadData.bind(this)
+            },
+            'TEST_EVENT': {
+                handler: this.testHandler.bind(this)
+            }
+        };
+    }
+
+    async authRequest({ req, res }) {
+        return {
+            success: true,
+            message: 'Auth request handled',
+            hasDatabase: !!this.id
+        };
+    }
+
+    async loadData({ req, res }) {
+        if (!this.id) {
+            throw new Error('Database record required');
+        }
+        return {
+            success: true,
+            data: this.config,
+            integrationId: this.id
+        };
+    }
+
+    async testHandler({ data }) {
+        return {
+            success: true,
+            received: data
+        };
+    }
+
+    async initialize() {
+        // Simulate loading dynamic events
+        const additionalEvents = {
+            'DYNAMIC_EVENT': {
+                handler: this.dynamicHandler.bind(this)
+            }
+        };
+        this.events = { ...this.events, ...additionalEvents };
+    }
+
+    async dynamicHandler({ req }) {
+        return { dynamic: true };
+    }
+}
+
+describe('IntegrationEventDispatcher', () => {
+    let dispatcher;
+
+    beforeEach(() => {
+        // Reset all mocks
+        jest.clearAllMocks();
+
+        // Create dispatcher instance
+        dispatcher = new IntegrationEventDispatcher({
+            integrationRepository: mockIntegrationRepository,
+            moduleFactory: mockModuleFactory,
+            moduleRepository: mockModuleRepository
+        });
+    });
+
+    describe('dispatchHttp', () => {
+        it('should handle auth request without database record (stateless)', async () => {
+            // Mock no database record found
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(null);
+
+            const req = { headers: {} };
+            const res = { json: jest.fn() };
+            const next = jest.fn();
+
+            const result = await dispatcher.dispatchHttp({
+                integrationClass: TestIntegration,
+                event: 'AUTH_REQUEST',
+                req,
+                res,
+                next
+            });
+
+            expect(result).toEqual({
+                success: true,
+                message: 'Auth request handled',
+                hasDatabase: false
+            });
+
+            // Verify repository was called
+            expect(mockIntegrationRepository.findIntegrationByName).toHaveBeenCalledWith('test-integration');
+
+            // Verify modules were not loaded (stateless)
+            expect(mockModuleRepository.findEntitiesByIds).not.toHaveBeenCalled();
+            expect(mockModuleFactory.getModuleInstance).not.toHaveBeenCalled();
+        });
+
+        it('should handle request with database record (stateful)', async () => {
+            // Mock database record
+            const mockRecord = {
+                id: 'integration-123',
+                userId: 'user-456',
+                config: { type: 'test', apiKey: 'secret' },
+                status: 'ENABLED',
+                version: '1.0.0',
+                messages: { errors: [], warnings: [] },
+                entitiesIds: ['entity-1', 'entity-2']
+            };
+
+            const mockEntities = [
+                { _id: 'entity-1', name: 'module1' },
+                { _id: 'entity-2', name: 'module2' }
+            ];
+
+            const mockModule1 = { getName: () => 'module1', api: {} };
+            const mockModule2 = { getName: () => 'module2', api: {} };
+
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(mockRecord);
+            mockModuleRepository.findEntitiesByIds.mockResolvedValue(mockEntities);
+            mockModuleFactory.getModuleInstance
+                .mockResolvedValueOnce(mockModule1)
+                .mockResolvedValueOnce(mockModule2);
+
+            const req = { headers: {} };
+            const res = { json: jest.fn() };
+            const next = jest.fn();
+
+            const result = await dispatcher.dispatchHttp({
+                integrationClass: TestIntegration,
+                event: 'LOAD_DATA',
+                req,
+                res,
+                next
+            });
+
+            expect(result).toEqual({
+                success: true,
+                data: mockRecord.config,
+                integrationId: 'integration-123'
+            });
+
+            // Verify all dependencies were called
+            expect(mockIntegrationRepository.findIntegrationByName).toHaveBeenCalledWith('test-integration');
+            expect(mockModuleRepository.findEntitiesByIds).toHaveBeenCalledWith(['entity-1', 'entity-2']);
+            expect(mockModuleFactory.getModuleInstance).toHaveBeenCalledTimes(2);
+        });
+
+        it('should call initialize and load dynamic events', async () => {
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(null);
+
+            const req = { headers: {} };
+            const res = { json: jest.fn() };
+            const next = jest.fn();
+
+            const result = await dispatcher.dispatchHttp({
+                integrationClass: TestIntegration,
+                event: 'DYNAMIC_EVENT',
+                req,
+                res,
+                next
+            });
+
+            expect(result).toEqual({ dynamic: true });
+        });
+
+        it('should throw error if event is not registered', async () => {
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(null);
+
+            const req = { headers: {} };
+            const res = { json: jest.fn() };
+            const next = jest.fn();
+
+            await expect(dispatcher.dispatchHttp({
+                integrationClass: TestIntegration,
+                event: 'UNKNOWN_EVENT',
+                req,
+                res,
+                next
+            })).rejects.toThrow('Event UNKNOWN_EVENT not registered for test-integration');
+        });
+
+        it('should handle database lookup errors gracefully', async () => {
+            // Mock database error
+            mockIntegrationRepository.findIntegrationByName.mockRejectedValue(
+                new Error('Database connection failed')
+            );
+
+            const req = { headers: {} };
+            const res = { json: jest.fn() };
+            const next = jest.fn();
+
+            // Should still work with stateless instance
+            const result = await dispatcher.dispatchHttp({
+                integrationClass: TestIntegration,
+                event: 'AUTH_REQUEST',
+                req,
+                res,
+                next
+            });
+
+            expect(result).toEqual({
+                success: true,
+                message: 'Auth request handled',
+                hasDatabase: false
+            });
+        });
+    });
+
+    describe('dispatchJob', () => {
+        it('should handle job with integration context', async () => {
+            const mockRecord = {
+                id: 'integration-123',
+                userId: 'user-456',
+                config: { type: 'test' },
+                status: 'ENABLED',
+                version: '1.0.0',
+                messages: { errors: [], warnings: [] },
+                entitiesIds: []
+            };
+
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(mockRecord);
+            mockModuleRepository.findEntitiesByIds.mockResolvedValue([]);
+
+            const data = { testData: 'value' };
+            const context = { integrationId: 'integration-123' };
+
+            const result = await dispatcher.dispatchJob({
+                integrationClass: TestIntegration,
+                event: 'TEST_EVENT',
+                data,
+                context
+            });
+
+            expect(result).toEqual({
+                success: true,
+                received: data
+            });
+        });
+
+        it('should handle job without integration context', async () => {
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(null);
+
+            const data = { testData: 'value' };
+            const context = {};
+
+            const result = await dispatcher.dispatchJob({
+                integrationClass: TestIntegration,
+                event: 'TEST_EVENT',
+                data,
+                context
+            });
+
+            expect(result).toEqual({
+                success: true,
+                received: data
+            });
+        });
+
+        it('should throw error for unknown job event', async () => {
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(null);
+
+            const data = {};
+            const context = {};
+
+            await expect(dispatcher.dispatchJob({
+                integrationClass: TestIntegration,
+                event: 'UNKNOWN_JOB',
+                data,
+                context
+            })).rejects.toThrow('Event UNKNOWN_JOB not registered for test-integration');
+        });
+    });
+
+    describe('findEventHandler', () => {
+        it('should find handler in events object', async () => {
+            const integration = new TestIntegration({});
+            await integration.initialize();
+
+            const handler = dispatcher.findEventHandler(integration, 'AUTH_REQUEST');
+            expect(handler).toBeDefined();
+            expect(typeof handler).toBe('function');
+        });
+
+        it('should find handler in defaultEvents', async () => {
+            const integration = new TestIntegration({});
+
+            const handler = dispatcher.findEventHandler(integration, 'ON_CREATE');
+            expect(handler).toBeDefined();
+            expect(typeof handler).toBe('function');
+        });
+
+        it('should return null for non-existent event', async () => {
+            const integration = new TestIntegration({});
+
+            const handler = dispatcher.findEventHandler(integration, 'NON_EXISTENT');
+            expect(handler).toBeNull();
+        });
+    });
+
+    describe('resolveIntegration', () => {
+        it('should create stateless instance when no database record exists', async () => {
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(null);
+
+            const integration = await dispatcher.resolveIntegration(TestIntegration);
+
+            expect(integration).toBeInstanceOf(TestIntegration);
+            expect(integration.id).toBeUndefined();
+            expect(integration.config).toBeUndefined();
+        });
+
+        it('should create stateful instance with all properties', async () => {
+            const mockRecord = {
+                id: 'integration-123',
+                userId: 'user-456',
+                config: { apiKey: 'secret' },
+                status: 'ENABLED',
+                version: '1.0.0',
+                messages: { errors: [], warnings: [] },
+                entitiesIds: ['entity-1']
+            };
+
+            const mockEntities = [{ _id: 'entity-1', name: 'module1' }];
+            const mockModule = {
+                getName: () => 'testModule',
+                name: 'testModule',
+                api: {}
+            };
+
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(mockRecord);
+            mockModuleRepository.findEntitiesByIds.mockResolvedValue(mockEntities);
+            mockModuleFactory.getModuleInstance.mockResolvedValue(mockModule);
+
+            const integration = await dispatcher.resolveIntegration(TestIntegration);
+
+            expect(integration).toBeInstanceOf(TestIntegration);
+            expect(integration.id).toBe('integration-123');
+            expect(integration.userId).toBe('user-456');
+            expect(integration.config).toEqual({ apiKey: 'secret' });
+            expect(integration.status).toBe('ENABLED');
+            expect(integration.testModule).toBe(mockModule);
+        });
+
+        it('should fall back to stateless when module loading fails', async () => {
+            const mockRecord = {
+                id: 'integration-123',
+                userId: 'user-456',
+                config: {},
+                status: 'ENABLED',
+                version: '1.0.0',
+                messages: { errors: [], warnings: [] },
+                entitiesIds: ['entity-1']
+            };
+
+            mockIntegrationRepository.findIntegrationByName.mockResolvedValue(mockRecord);
+            mockModuleRepository.findEntitiesByIds.mockResolvedValue([{ _id: 'entity-1' }]);
+            mockModuleFactory.getModuleInstance.mockRejectedValue(new Error('Module load failed'));
+
+            // Should fall back to stateless instance
+            const integration = await dispatcher.resolveIntegration(TestIntegration);
+
+            expect(integration).toBeInstanceOf(TestIntegration);
+            // Should be stateless (no id, config, etc.)
+            expect(integration.id).toBeUndefined();
+            expect(integration.config).toBeUndefined();
+        });
+    });
+});
+
+// Test for default events from IntegrationBase
+describe('IntegrationEventDispatcher with default events', () => {
+    let dispatcher;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        dispatcher = new IntegrationEventDispatcher({
+            integrationRepository: mockIntegrationRepository,
+            moduleFactory: mockModuleFactory,
+            moduleRepository: mockModuleRepository
+        });
+    });
+
+    it('should handle default ON_CREATE event', async () => {
+        const mockRecord = {
+            id: 'integration-123',
+            userId: 'user-456',
+            config: {},
+            status: 'ENABLED',
+            version: '1.0.0',
+            messages: { errors: [], warnings: [] },
+            entitiesIds: []
+        };
+
+        mockIntegrationRepository.findIntegrationByName.mockResolvedValue(mockRecord);
+        mockModuleRepository.findEntitiesByIds.mockResolvedValue([]);
+
+        // Mock the updateIntegrationStatus to avoid actual DB calls
+        const integration = new TestIntegration({
+            id: mockRecord.id,
+            userId: mockRecord.userId,
+            config: mockRecord.config,
+            status: mockRecord.status
+        });
+        integration.updateIntegrationStatus = {
+            execute: jest.fn().mockResolvedValue(true)
+        };
+
+        const req = {};
+        const res = {};
+        const next = jest.fn();
+
+        // The dispatcher should be able to find and call ON_CREATE
+        const handler = dispatcher.findEventHandler(integration, 'ON_CREATE');
+        expect(handler).toBeDefined();
+
+        // Call the handler
+        const result = await handler.call(integration, { integrationId: 'integration-123' });
+
+        // ON_CREATE should update status to ENABLED
+        expect(integration.updateIntegrationStatus.execute).toHaveBeenCalledWith('integration-123', 'ENABLED');
+    });
+});

package/integrations/integration-base.js

@@ -62,12 +62,7 @@ class IntegrationBase {
         return this.Definition.version;
     }
 
-    registerEventHandlers() {
-        this.on = {
-            ...this.defaultEvents,
-            ...this.events,
-        };
-    }
+    // REMOVED: registerEventHandlers() - Event handling is now done by IntegrationEventDispatcher
 
     constructor(params = {}) {
         // Data from database record (when instantiated by use cases)
@@ -130,14 +125,7 @@ class IntegrationBase {
         };
     }
 
-    async send(event, object) {
-        if (!this.on[event]) {
-            throw new Error(
-                `Event ${event} is not defined in the Integration event object`
-            );
-        }
-        return this.on[event].handler.call(this, object);
-    }
+    // REMOVED: send() - Event dispatching is now done by IntegrationEventDispatcher
 
     async validateConfig() {
         const configOptions = await this.getConfigOptions();
@@ -336,8 +324,7 @@ class IntegrationBase {
             this.addError(e);
         }
 
-        // Register event handlers
-        await this.registerEventHandlers();
+        // Event handlers are no longer registered here - handled by IntegrationEventDispatcher
     }
 
     getOptionDetails() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/core",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.395.6ee402d.0",
+  "version": "2.0.0--canary.395.704a466.0",
   "dependencies": {
     "@hapi/boom": "^10.0.1",
     "aws-sdk": "^2.1200.0",
@@ -22,9 +22,9 @@
     "uuid": "^9.0.1"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.395.6ee402d.0",
-    "@friggframework/prettier-config": "2.0.0--canary.395.6ee402d.0",
-    "@friggframework/test": "2.0.0--canary.395.6ee402d.0",
+    "@friggframework/eslint-config": "2.0.0--canary.395.704a466.0",
+    "@friggframework/prettier-config": "2.0.0--canary.395.704a466.0",
+    "@friggframework/test": "2.0.0--canary.395.704a466.0",
     "@types/lodash": "4.17.15",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "chai": "^4.3.6",
@@ -56,5 +56,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "6ee402d0d7aec57c3f90972901751c23a3b734ec"
+  "gitHead": "704a466eb0e5b9fd4db245f95071f85842c698de"
 }