@friggframework/core 2.0.0--canary.395.a6dcc5a.0 → 2.0.0--canary.395.de6bcdf.0

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

@@ -0,0 +1,140 @@
+const { IntegrationEventDispatcher } = require('./integration-event-dispatcher');
+const { IntegrationBase } = require('../integrations/integration-base');
+
+class SimulatedAsanaIntegration extends IntegrationBase {
+    static Definition = {
+        name: 'asana',
+        version: '1.0.0',
+        modules: {},
+        routes: [
+            { path: '/auth', method: 'GET', event: 'AUTH_REQUEST' },
+            { path: '/auth/redirect/:provider', method: 'GET', event: 'AUTH_REDIRECT' },
+            { path: '/form', method: 'GET', event: 'LOAD_FORM' },
+        ],
+    };
+
+    constructor(params = {}) {
+        super(params);
+        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() {
+        return {
+            success: true,
+            action: 'redirect',
+            hydrated: this.isHydrated,
+        };
+    }
+
+    async authRedirect({ req }) {
+        const { code } = req.query || {};
+        return {
+            success: true,
+            action: 'tokens_received',
+            receivedCode: code,
+            hydrated: this.isHydrated,
+        };
+    }
+
+    async loadForm() {
+        if (!this.isHydrated && SimulatedAsanaIntegration.testRecord) {
+            this.setIntegrationRecord({
+                record: SimulatedAsanaIntegration.testRecord.record,
+                modules: SimulatedAsanaIntegration.testRecord.modules,
+            });
+        }
+
+        this.assertHydrated('Integration not found - must authenticate first');
+
+        return {
+            success: true,
+            form: {
+                fields: ['field1', 'field2'],
+            },
+            integrationId: this.id,
+        };
+    }
+}
+
+describe('IntegrationEventDispatcher auth flow', () => {
+    const createDispatcher = () =>
+        new IntegrationEventDispatcher(new SimulatedAsanaIntegration());
+
+    beforeEach(() => {
+        SimulatedAsanaIntegration.testRecord = null;
+    });
+
+    it('handles auth request without hydration', async () => {
+        const dispatcher = createDispatcher();
+        const result = await dispatcher.dispatchHttp({
+            event: 'AUTH_REQUEST',
+            req: { params: { provider: 'asana' }, query: {} },
+            res: {},
+            next: jest.fn(),
+        });
+
+        expect(result).toEqual({ success: true, action: 'redirect', hydrated: false });
+    });
+
+    it('handles auth redirect without hydration', async () => {
+        const dispatcher = createDispatcher();
+        const result = await dispatcher.dispatchHttp({
+            event: 'AUTH_REDIRECT',
+            req: { params: { provider: 'asana' }, query: { code: 'abc123' } },
+            res: {},
+            next: jest.fn(),
+        });
+
+        expect(result).toEqual({
+            success: true,
+            action: 'tokens_received',
+            receivedCode: 'abc123',
+            hydrated: false,
+        });
+    });
+
+    it('throws for protected routes when no record is loaded', async () => {
+        const dispatcher = createDispatcher();
+        await expect(
+            dispatcher.dispatchHttp({
+                event: 'LOAD_FORM',
+                req: { query: {} },
+                res: {},
+                next: jest.fn(),
+            })
+        ).rejects.toThrow('Integration not found - must authenticate first');
+    });
+
+    it('allows handlers to hydrate explicitly before continuing', async () => {
+        SimulatedAsanaIntegration.testRecord = {
+            record: {
+                id: 'integration-123',
+                userId: 'user-456',
+                config: { type: 'asana' },
+                status: 'ENABLED',
+                version: '1.0.0',
+                messages: { errors: [], warnings: [] },
+                entities: [],
+            },
+            modules: [],
+        };
+
+        const dispatcher = createDispatcher();
+        const result = await dispatcher.dispatchHttp({
+            event: 'LOAD_FORM',
+            req: { query: {} },
+            res: {},
+            next: jest.fn(),
+        });
+
+        expect(result).toEqual({
+            success: true,
+            form: { fields: ['field1', 'field2'] },
+            integrationId: 'integration-123',
+        });
+    });
+});

package/handlers/backend-utils.js

@@ -1,19 +1,10 @@
 const { Router } = require('express');
 const { Worker } = require('@friggframework/core');
-const { IntegrationRepository } = require('../integrations/integration-repository');
-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) => {
-
-    const integrationRepository = new IntegrationRepository();
-    const moduleRepository = new ModuleRepository();
-    const moduleFactory = new ModuleFactory({
-        moduleRepository,
-        moduleDefinitions: getModulesDefinitionFromIntegrationClasses([IntegrationClass]),
-    });
     const router = Router();
     const { path, method, event } = routerObject;
 
@@ -23,13 +14,16 @@ const loadRouterFromObject = (IntegrationClass, routerObject) => {
 
     router[method.toLowerCase()](path, async (req, res, next) => {
         try {
-            const getIntegrationInstanceByDefinition = new GetIntegrationInstanceByDefinition({
-                integrationRepository,
-                moduleFactory,
-                moduleRepository,
+            const integrationInstance = new IntegrationClass();
+            const dispatcher = new IntegrationEventDispatcher(
+                integrationInstance
+            );
+            const result = await dispatcher.dispatchHttp({
+                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);
@@ -39,30 +33,18 @@ const loadRouterFromObject = (IntegrationClass, routerObject) => {
     return router;
 };
 
-//todo: this should be in a use case class
 const createQueueWorker = (integrationClass) => {
     class QueueWorker extends Worker {
-
-        integrationRepository = new IntegrationRepository();
-        moduleRepository = new ModuleRepository();
-        moduleFactory = new ModuleFactory({
-            moduleRepository: this.moduleRepository,
-            moduleDefinitions: getModulesDefinitionFromIntegrationClasses([integrationClass]),
-        });
-
         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 integrationInstance = new integrationClass();
+                const dispatcher = new IntegrationEventDispatcher(
+                    integrationInstance
+                );
+                const res = await dispatcher.dispatchJob({
+                    event: params.event,
                     data: params.data,
-                    context,
+                    context: context,
                 });
                 return res;
             } catch (error) {

package/handlers/integration-event-dispatcher.js

@@ -0,0 +1,55 @@
+
+/**
+ * Lightweight dispatcher that executes integration event handlers.
+ * Signature: `new IntegrationEventDispatcher(integrationInstance)`
+ * @param {import('../integrations/integration-base')} integrationInstance Pre-instantiated integration.
+ */
+class IntegrationEventDispatcher {
+  constructor(integrationInstance) {
+    if (!integrationInstance) {
+      throw new Error('Integration instance is required');
+    }
+    this.integrationInstance = integrationInstance;
+  }
+
+  async dispatchHttp({ event, req, res, next }) {
+    const instance = this.integrationInstance;
+
+    const handler = this.findEventHandler(instance, event);
+
+    if (!handler) {
+      const name = instance.constructor?.Definition?.name || 'integration';
+      throw new Error(`Event ${event} not registered for ${name}`);
+    }
+
+    return await handler.call(instance, { req, res, next });
+  }
+
+  async dispatchJob({ event, data, context }) {
+    const instance = this.integrationInstance;
+
+    const handler = this.findEventHandler(instance, event);
+
+    if (!handler) {
+      const name = instance.constructor?.Definition?.name || 'integration';
+      throw new Error(`Event ${event} not registered for ${name}`);
+    }
+
+    return await handler.call(instance, { data, context });
+  }
+
+  findEventHandler(integration, event) {
+    if (integration.events && integration.events[event]) {
+      return integration.events[event].handler;
+    }
+
+    if (integration.defaultEvents && integration.defaultEvents[event]) {
+      return integration.defaultEvents[event].handler;
+    }
+
+    return null;
+  }
+
+}
+
+module.exports = { IntegrationEventDispatcher };

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

@@ -0,0 +1,134 @@
+const { IntegrationEventDispatcher } = require('./integration-event-dispatcher');
+const { IntegrationBase } = require('../integrations/integration-base');
+
+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: '/job', method: 'POST', event: 'TEST_EVENT' },
+            { path: '/dynamic', method: 'GET', event: 'DYNAMIC_EVENT' },
+        ],
+    };
+
+    constructor(params) {
+        super(params);
+        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() {
+        TestIntegration.latestInstance = this;
+        return {
+            success: true,
+            hydrated: this.isHydrated,
+        };
+    }
+
+    async loadData() {
+        this.assertHydrated('loadData requires hydration');
+        return { success: true };
+    }
+
+    async testHandler({ data }) {
+        TestIntegration.latestInstance = this;
+        return { received: data };
+    }
+
+    async initialize() {
+        this.events = {
+            ...this.events,
+            DYNAMIC_EVENT: { handler: this.dynamicHandler.bind(this) },
+        };
+    }
+
+    async dynamicHandler() {
+        TestIntegration.latestInstance = this;
+        return { dynamic: true };
+    }
+}
+
+describe('IntegrationEventDispatcher', () => {
+    const createDispatcher = () =>
+        new IntegrationEventDispatcher(new TestIntegration());
+
+    beforeEach(() => {
+        TestIntegration.latestInstance = null;
+    });
+
+    describe('dispatchHttp', () => {
+        it('creates a stateless integration instance for HTTP events', async () => {
+            const dispatcher = createDispatcher();
+            const result = await dispatcher.dispatchHttp({
+                event: 'AUTH_REQUEST',
+                req: {},
+                res: {},
+                next: jest.fn(),
+            });
+
+            expect(result).toEqual({ success: true, hydrated: false });
+            expect(TestIntegration.latestInstance).toBeInstanceOf(TestIntegration);
+            expect(TestIntegration.latestInstance.isHydrated).toBe(false);
+        });
+
+        it('calls initialize to register dynamic events', async () => {
+            const dispatcher = createDispatcher();
+            await dispatcher.integrationInstance.initialize();
+            const result = await dispatcher.dispatchHttp({
+                event: 'DYNAMIC_EVENT',
+                req: {},
+                res: {},
+                next: jest.fn(),
+            });
+
+            expect(result).toEqual({ dynamic: true });
+            expect(TestIntegration.latestInstance).toBeInstanceOf(TestIntegration);
+        });
+
+        it('throws when requesting an unknown event', async () => {
+            const dispatcher = createDispatcher();
+            await expect(
+                dispatcher.dispatchHttp({
+                    event: 'UNKNOWN',
+                    req: {},
+                    res: {},
+                    next: jest.fn(),
+                })
+            ).rejects.toThrow('Event UNKNOWN not registered for test-integration');
+        });
+
+        it('does not hydrate automatically for handlers that require data', async () => {
+            const dispatcher = createDispatcher();
+            await expect(
+                dispatcher.dispatchHttp({
+                    event: 'LOAD_DATA',
+                    req: {},
+                    res: {},
+                    next: jest.fn(),
+                })
+            ).rejects.toThrow('loadData requires hydration');
+        });
+    });
+
+    describe('dispatchJob', () => {
+        it('creates a stateless integration instance for job events', async () => {
+            const payload = { foo: 'bar' };
+            const dispatcher = createDispatcher();
+            const result = await dispatcher.dispatchJob({
+                event: 'TEST_EVENT',
+                data: payload,
+                context: {},
+            });
+
+            expect(result).toEqual({ received: payload });
+            expect(TestIntegration.latestInstance).toBeInstanceOf(TestIntegration);
+            expect(TestIntegration.latestInstance.isHydrated).toBe(false);
+        });
+    });
+});

package/index.js

@@ -40,6 +40,9 @@ const {
     IntegrationMapping,
     createIntegrationRouter,
     checkRequiredParams,
+    IntegrationRepository,
+    getModulesDefinitionFromIntegrationClasses,
+    LoadIntegrationContextUseCase,
 } = require('./integrations/index');
 const { TimeoutCatcher } = require('./lambda/index');
 const { debug, initDebugLog, flushDebugLog } = require('./logs/index');
@@ -51,6 +54,8 @@ const {
     OAuth2Requester,
     Requester,
     ModuleConstants,
+    ModuleFactory,
+    ModuleRepository,
 } = require('./modules/index');
 const utils = require('./utils');
 
@@ -104,6 +109,9 @@ module.exports = {
     IntegrationMapping,
     checkRequiredParams,
     createIntegrationRouter,
+    IntegrationRepository,
+    getModulesDefinitionFromIntegrationClasses,
+    LoadIntegrationContextUseCase,
 
     // lambda
     TimeoutCatcher,
@@ -121,6 +129,8 @@ module.exports = {
     OAuth2Requester,
     Requester,
     ModuleConstants,
+    ModuleFactory,
+    ModuleRepository,
     // queues
     QueuerUtil,
 

package/integrations/index.js

@@ -3,6 +3,9 @@ const { IntegrationModel } = require('./integration-model');
 const { Options } = require('./options');
 const { IntegrationMapping } = require('./integration-mapping');
 const { createIntegrationRouter, checkRequiredParams } = require('./integration-router');
+const { IntegrationRepository } = require('./integration-repository');
+const { getModulesDefinitionFromIntegrationClasses } = require('./utils/map-integration-dto');
+const { LoadIntegrationContextUseCase } = require('./use-cases/load-integration-context');
 
 module.exports = {
     IntegrationBase,
@@ -11,4 +14,7 @@ module.exports = {
     IntegrationMapping,
     createIntegrationRouter,
     checkRequiredParams,
+    IntegrationRepository,
+    getModulesDefinitionFromIntegrationClasses,
+    LoadIntegrationContextUseCase,
 };

package/integrations/integration-base.js

@@ -62,37 +62,17 @@ 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)
-        this.id = params.id;
-        this.userId = params.userId || params.integrationId; // fallback for legacy
-        this.entities = params.entities;
-        this.config = params.config;
-        this.status = params.status;
-        this.version = params.version;
-        this.messages = params.messages || { errors: [], warnings: [] };
-        
-        // Module instances (injected by factory)
         this.modules = {};
-        if (params.modules) {
-            for (const mod of params.modules) {
-                const key = typeof mod.getName === 'function' ? mod.getName() : mod.name;
-                if (key) {
-                    this.modules[key] = mod;
-                    this[key] = mod; // Direct access (e.g., this.hubspot)
-                }
-            }
-        }
-
-        // Initialize events object (will be populated by child classes)
         this.events = this.events || {};
+        this.messages = { errors: [], warnings: [] };
+        this._isHydrated = false;
+
+        if (params && Object.keys(params).length > 0) {
+            this.setIntegrationRecord(params);
+        }
 
         this.defaultEvents = {
             [constantsToBeMigrated.defaultEvents.ON_CREATE]: {
@@ -130,13 +110,93 @@ class IntegrationBase {
         };
     }
 
-    async send(event, object) {
-        if (!this.on[event]) {
-            throw new Error(
-                `Event ${event} is not defined in the Integration event object`
-            );
+    // REMOVED: send() - Event dispatching is now done by IntegrationEventDispatcher
+
+    /**
+     * Persist the database record and module instances onto this integration instance.
+     * Accepts either a plain object containing the persisted fields or an object with
+     * a `record` property plus a `modules` collection.
+     * @param {Object} payload
+     * @param {Object} [payload.record]
+     * @param {Array|Object} [payload.modules]
+     */
+    setIntegrationRecord(payload = {}) {
+        if (!payload || Object.keys(payload).length === 0) {
+            throw new Error('setIntegrationRecord requires integration data');
+        }
+
+        const record = payload.record ? payload.record : payload;
+        const modulesInput = payload.modules ?? record.modules;
+
+        if (!record) {
+            throw new Error('Integration record not provided');
+        }
+
+        const {
+            id,
+            userId,
+            entities,
+            config,
+            status,
+            version,
+            messages,
+        } = record;
+
+        this.id = id;
+        this.userId = userId || record.integrationId;
+        this.entities = entities;
+        this.config = config;
+        this.status = status;
+        this.version = version;
+        this.messages = messages || { errors: [], warnings: [] };
+
+        const existingModuleKeys = Object.keys(this.modules || {});
+        for (const key of existingModuleKeys) {
+            if (Object.prototype.hasOwnProperty.call(this, key) && this[key] === this.modules[key]) {
+                delete this[key];
+            }
+        }
+
+        this.modules = {};
+
+        if (modulesInput) {
+            const modulesArray = Array.isArray(modulesInput)
+                ? modulesInput
+                : Object.values(modulesInput);
+
+            for (const mod of modulesArray) {
+                if (!mod) continue;
+                const key = typeof mod.getName === 'function' ? mod.getName() : mod.name;
+                if (key) {
+                    this.modules[key] = mod;
+                    this[key] = mod;
+                }
+            }
+        }
+
+        this.integrationRecord = {
+            id: this.id,
+            userId: this.userId,
+            entities: this.entities,
+            config: this.config,
+            status: this.status,
+            version: this.version,
+            messages: this.messages,
+        };
+        this.record = this.integrationRecord;
+
+        this._isHydrated = Boolean(this.id);
+        return this;
+    }
+
+    get isHydrated() {
+        return this._isHydrated;
+    }
+
+    assertHydrated(message = 'Integration instance is not hydrated') {
+        if (!this.isHydrated) {
+            throw new Error(message);
         }
-        return this.on[event].handler.call(this, object);
     }
 
     async validateConfig() {
@@ -336,8 +396,7 @@ class IntegrationBase {
             this.addError(e);
         }
 
-        // Register event handlers
-        await this.registerEventHandlers();
+        // Event handlers are no longer registered here - handled by IntegrationEventDispatcher
     }
 
     getOptionDetails() {