@friggframework/core 2.0.0--canary.396.accf516.0 → 2.0.0--canary.396.469364a.0

package/handlers/backend-utils.js

@@ -1,5 +1,9 @@
 const { Router } = require('express');
 const { Worker } = require('@friggframework/core');
+const { loadAppDefinition } = require('./app-definition-loader');
+const { IntegrationRepository } = require('../integrations/integration-repository');
+const { ModuleService } = require('../module-plugin/module-service');
+const { GetIntegrationInstance } = require('../integrations/use-cases/get-integration-instance');
 
 const loadRouterFromObject = (IntegrationClass, routerObject) => {
     const router = Router();
@@ -23,29 +27,37 @@ const loadRouterFromObject = (IntegrationClass, routerObject) => {
 };
 
 //todo: this should be in a use case class
-const createQueueWorker = (integrationClass, integrationFactory) => {
+const createQueueWorker = (integrationClass) => {
     class QueueWorker extends Worker {
         async _run(params, context) {
             try {
-                let instance;
+                let integrationInstance;
                 if (!params.integrationId) {
-                    instance = new integrationClass();
-                    await instance.loadModules();
-                    // await instance.loadUserActions();
-                    await instance.registerEventHandlers();
+                    integrationInstance = new integrationClass();
+                    await integrationInstance.loadModules();
+                    await integrationInstance.registerEventHandlers();
                     console.log(
                         `${params.event} for ${integrationClass.Definition.name} integration with no integrationId`
                     );
                 } else {
-                    instance =
-                        await integrationFactory.getInstanceFromIntegrationId({
-                            integrationId: params.integrationId,
-                        });
+                    const { integrations: integrationClasses } = loadAppDefinition();
+                    const integrationRepository = new IntegrationRepository();
+                    const moduleService = new ModuleService();
+
+                    const getIntegrationInstance = new GetIntegrationInstance({
+                        integrationRepository,
+                        integrationClasses,
+                        moduleService,
+                    });
+
+                    // todo: are we going to have the userId available here?
+                    integrationInstance = await getIntegrationInstance.execute(params.integrationId, params.userId);
                     console.log(
-                        `${params.event} for ${instance.record.config.type} of integrationId: ${params.integrationId}`
+                        `${params.event} for ${integrationInstance.record.config.type} of integrationId: ${params.integrationId}`
                     );
                 }
-                const res = await instance.send(params.event, {
+
+                const res = await integrationInstance.send(params.event, {
                     data: params.data,
                     context,
                 });

package/handlers/routers/auth.js

@@ -4,11 +4,9 @@ const {
     loadAppDefinition,
 } = require('../app-definition-loader');
 const { UserRepository } = require('../../user/user-repository');
-const { IntegrationFactory } = require('../../integrations/integration-factory');
 const { GetUserFromBearerToken } = require('../../user/use-cases/get-user-from-bearer-token');
 
-const { integrations, userConfig } = loadAppDefinition();
-const integrationFactory = new IntegrationFactory(integrations);
+const { userConfig } = loadAppDefinition();
 const userRepository = new UserRepository({ userConfig });
 const getUserFromBearerToken = new GetUserFromBearerToken({
     userRepository,
@@ -16,10 +14,6 @@ const getUserFromBearerToken = new GetUserFromBearerToken({
 });
 
 const router = createIntegrationRouter({
-    factory: {
-        moduleFactory: integrationFactory.moduleFactory,
-        integrationFactory,
-    },
     getUserFromBearerToken,
 });
 

package/handlers/routers/integration-defined-routers.js

@@ -1,17 +1,15 @@
 const { createAppHandler } = require('./../app-handler-helpers');
 const {
     loadAppDefinition,
-    loadRouterFromObject,
 } = require('../app-definition-loader');
 const { Router } = require('express');
-const { IntegrationFactory } = require('../../integrations/integration-factory');
+const { loadRouterFromObject } = require('../backend-utils');
 
 const handlers = {};
-const { integrations } = loadAppDefinition();
-const integrationFactory = new IntegrationFactory(integrations);
+const { integrations: integrationClasses } = loadAppDefinition();
 
 //todo: this should be in a use case class
-for (const IntegrationClass of integrationFactory.integrationClasses) {
+for (const IntegrationClass of integrationClasses) {
     const router = Router();
     const basePath = `/api/${IntegrationClass.Definition.name}-integration`;
 

package/handlers/workers/integration-defined-workers.js

@@ -1,13 +1,12 @@
 const { createHandler } = require('@friggframework/core');
-const { loadAppDefinition, createQueueWorker } = require('../app-definition-loader');
-const { IntegrationFactory } = require('../../integrations/integration-factory');
+const { loadAppDefinition } = require('../app-definition-loader');
+const { createQueueWorker } = require('../backend-utils');
 
 const handlers = {};
-const { integrations } = loadAppDefinition();
-const integrationFactory = new IntegrationFactory(integrations);
+const { integrations: integrationClasses } = loadAppDefinition();
 
-integrationFactory.integrationClasses.forEach((IntegrationClass) => {
-    const defaultQueueWorker = createQueueWorker(IntegrationClass, integrationFactory);
+integrationClasses.forEach((IntegrationClass) => {
+    const defaultQueueWorker = createQueueWorker(IntegrationClass);
 
     handlers[`${IntegrationClass.Definition.name}`] = {
         queueWorker: createHandler({

package/index.js

@@ -38,7 +38,6 @@ const {
     IntegrationModel,
     Options,
     IntegrationMapping,
-    IntegrationFactory,
     createIntegrationRouter,
     checkRequiredParams,
 } = require('./integrations/index');
@@ -105,7 +104,6 @@ module.exports = {
     IntegrationModel,
     Options,
     IntegrationMapping,
-    IntegrationFactory,
     checkRequiredParams,
     createIntegrationRouter,
 

package/integrations/index.js

@@ -2,7 +2,6 @@ const { IntegrationBase } = require('./integration-base');
 const { IntegrationModel } = require('./integration-model');
 const { Options } = require('./options');
 const { IntegrationMapping } = require('./integration-mapping');
-const { IntegrationFactory } = require('./integration-factory');
 const { createIntegrationRouter, checkRequiredParams } = require('./integration-router');
 
 module.exports = {
@@ -10,7 +9,6 @@ module.exports = {
     IntegrationModel,
     Options,
     IntegrationMapping,
-    IntegrationFactory,
     createIntegrationRouter,
     checkRequiredParams,
 };

package/integrations/integration-repository.js

@@ -23,7 +23,7 @@ class IntegrationRepository {
         return {
             id: integrationRecord._id,
             entitiesIds: integrationRecord.entities.map(e => e._id),
-            userId: integrationRecord.user,
+            userId: integrationRecord.user.toString(),
             config: integrationRecord.config,
             version: integrationRecord.version,
             status: integrationRecord.status,

package/integrations/integration-router.js

@@ -2,7 +2,6 @@ const express = require('express');
 const { get } = require('../assertions');
 const Boom = require('@hapi/boom');
 const catchAsyncError = require('express-async-handler');
-const { debug } = require('../logs');
 const { IntegrationRepository } = require('./integration-repository');
 const { DeleteIntegrationForUser } = require('./use-cases/delete-integration-for-user');
 const { GetIntegrationsForUser } = require('./use-cases/get-integrations-for-user');
@@ -12,53 +11,36 @@ const { CreateIntegration } = require('./use-cases/create-integration');
 const { ModuleService } = require('../module-plugin/module-service');
 const { ModuleRepository } = require('../module-plugin/module-repository');
 const { GetEntitiesForUser } = require('../module-plugin/use-cases/get-entities-for-user');
-const {
-    loadAppDefinition,
-} = require('../handlers/app-definition-loader');
+const { loadAppDefinition } = require('../handlers/app-definition-loader');
+const { GetIntegrationInstance } = require('./use-cases/get-integration-instance');
+const { UpdateIntegration } = require('./use-cases/update-integration');
+const { getModulesDefinitionFromIntegrationClasses } = require('./utils/map-integration-dto');
 
-// todo: dont send moduleFactory and integrationFactory as a factory object, instead send them as separate params.
-// todo: this could be a use case class
 /**
  * Creates an Express router with integration and entity routes configured
  * @param {Object} params - Configuration parameters for the router
  * @param {express.Router} [params.router] - Optional Express router instance, creates new one if not provided
- * @param {Object} params.factory - Factory object containing moduleFactory and integrationFactory
- * @param {Object} params.factory.moduleFactory - Factory for creating and managing API modules
- * @param {Object} params.factory.integrationFactory - Factory for creating and managing integrations
  * @param {import('../user/use-cases/get-user-from-bearer-token').GetUserFromBearerToken} params.getUserFromBearerToken - Use case for retrieving a user from a bearer token
  * @returns {express.Router} Configured Express router with integration and entity routes
  */
 function createIntegrationRouter(params) {
-    const { integrations } = loadAppDefinition();
+    const { integrations: integrationClasses } = loadAppDefinition();
     const moduleRepository = new ModuleRepository();
     const integrationRepository = new IntegrationRepository();
     const credentialRepository = new CredentialRepository();
 
-    // todo: move this into a utils file
-    const getModules = () => {
-        return [
-            ...new Set(
-                integrations
-                    .map((integration) =>
-                        Object.values(integration.Definition.modules).map(
-                            (module) => module.definition
-                        )
-                    )
-                    .flat()
-            ),
-        ];
-    };
     const moduleService = new ModuleService({
         moduleRepository,
-        moduleDefinitions: getModules(),
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
     const deleteIntegrationForUser = new DeleteIntegrationForUser({
         integrationRepository,
+        integrationClasses,
     });
 
     const getIntegrationsForUser = new GetIntegrationsForUser({
         integrationRepository,
-        integrationClasses: integrations,
+        integrationClasses,
         moduleService,
         moduleRepository,
     });
@@ -67,25 +49,38 @@ function createIntegrationRouter(params) {
     });
     const createIntegration = new CreateIntegration({
         integrationRepository,
-        integrationClasses: integrations,
+        integrationClasses,
         moduleService,
     });
 
-    const getEntitiesForUserUseCase = new GetEntitiesForUser({
+    const getEntitiesForUser = new GetEntitiesForUser({
         moduleRepository,
-        moduleDefinitions: getModules(),
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
+    const getIntegrationInstance = new GetIntegrationInstance({
+        integrationRepository,
+        integrationClasses,
+        moduleService,
+    });
+
+    const updateIntegration = new UpdateIntegration({
+        integrationRepository,
+        integrationClasses,
+        moduleService,
     });
 
     const router = get(params, 'router', express());
     const factory = get(params, 'factory');
     const getUserFromBearerToken = get(params, 'getUserFromBearerToken');
 
-    // todo: moduleFactory in factory is not used here anymore, remove it
-    setIntegrationRoutes(router, factory, getUserFromBearerToken, integrations, {
+    setIntegrationRoutes(router, getUserFromBearerToken, {
         createIntegration,
         deleteIntegrationForUser,
         getIntegrationsForUser,
-        getEntitiesForUserUseCase,
+        getEntitiesForUser,
+        getIntegrationInstance,
+        updateIntegration,
     });
     setEntityRoutes(router, factory, getUserFromBearerToken, {
         getCredentialForUser,
@@ -118,18 +113,17 @@ function checkRequiredParams(params, requiredKeys) {
 /**
  * Sets up integration-related routes on the provided Express router
  * @param {express.Router} router - Express router instance to add routes to
- * @param {Object} factory - Factory object containing moduleFactory and integrationFactory
- * @param {Object} factory.moduleFactory - Factory for creating and managing API modules
- * @param {Object} factory.integrationFactory - Factory for creating and managing integrations
  * @param {import('../user/use-cases/get-user-from-bearer-token').GetUserFromBearerToken} getUserFromBearerToken - Use case for retrieving a user from a bearer token
+ * @param {Object} useCases - use cases for integration management
  */
-function setIntegrationRoutes(router, factory, getUserFromBearerToken, integrationClasses, useCases) {
-    const { integrationFactory } = factory;
+function setIntegrationRoutes(router, getUserFromBearerToken, useCases) {
     const {
         createIntegration,
         deleteIntegrationForUser,
         getIntegrationsForUser,
-        getEntitiesForUserUseCase,
+        getEntitiesForUser,
+        getIntegrationInstance,
+        updateIntegration,
     } = useCases;
     router.route('/api/integrations').get(
         catchAsyncError(async (req, res) => {
@@ -143,7 +137,7 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken, integrati
                     options: integrations.map((integration) =>
                         integration.options
                     ),
-                    authorized: await getEntitiesForUserUseCase.execute(userId),
+                    authorized: await getEntitiesForUser.execute(userId),
                 },
                 integrations: integrations,
             }
@@ -162,27 +156,16 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken, integrati
                 'entities',
                 'config',
             ]);
-            // throw if not value
+
             get(params.config, 'type');
 
-            // create integration
             const integration = await createIntegration.execute(
                 params.entities,
                 userId,
                 params.config
             );
 
-            // post integration initialization
-            debug(
-                `Calling onCreate on the ${integration?.constructor?.Config?.name} Integration with no arguments`
-            );
-            await integration.send('ON_CREATE', {});
-
-            res.status(201).json(
-                await integrationFactory.getFormattedIntegration(
-                    integration.record
-                )
-            );
+            res.status(201).json(integration);
         })
     );
 
@@ -194,23 +177,8 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken, integrati
             const userId = user.getId();
             const params = checkRequiredParams(req.body, ['config']);
 
-            const integration =
-                await integrationFactory.getInstanceFromIntegrationId({
-                    integrationId: req.params.integrationId,
-                    userId,
-                });
-
-            debug(
-                `Calling onUpdate on the ${integration?.constructor?.Config?.name} Integration arguments: `,
-                params
-            );
-            await integration.send('ON_UPDATE', params);
-
-            res.json(
-                await integrationFactory.getFormattedIntegration(
-                    integration.record
-                )
-            );
+            const integration = await updateIntegration.execute(req.params.integrationId, userId, params.config);
+            res.json(integration);
         })
     );
 
@@ -220,18 +188,7 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken, integrati
                 req.headers.authorization
             );
             const params = checkRequiredParams(req.params, ['integrationId']);
-            const integration =
-                await integrationFactory.getInstanceFromIntegrationId({
-                    userId: user.getId(),
-                    integrationId: params.integrationId,
-                });
-
-            debug(
-                `Calling onUpdate on the ${integration?.constructor?.Definition?.name} Integration with no arguments`
-            );
-            await integration.send('ON_DELETE');
             await deleteIntegrationForUser.execute(params.integrationId, user.getId());
-
             res.status(204).json({});
         })
     );
@@ -242,11 +199,7 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken, integrati
                 req.headers.authorization
             );
             const params = checkRequiredParams(req.params, ['integrationId']);
-            const integration =
-                await integrationFactory.getInstanceFromIntegrationId({
-                    integrationId: params.integrationId,
-                    userId: user.getId(),
-                });
+            const integration = await getIntegrationInstance.execute(params.integrationId, user.getId());
             res.json(await integration.send('GET_CONFIG_OPTIONS'));
         })
     );
@@ -261,13 +214,7 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken, integrati
                 const params = checkRequiredParams(req.params, [
                     'integrationId',
                 ]);
-                const integration =
-                    await integrationFactory.getInstanceFromIntegrationId(
-                        {
-                            integrationId: params.integrationId,
-                            userId: user.getId(),
-                        }
-                    );
+                const integration = await getIntegrationInstance.execute(params.integrationId, user.getId());
 
                 res.json(
                     await integration.send('REFRESH_CONFIG_OPTIONS', req.body)
@@ -280,11 +227,7 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken, integrati
                 req.headers.authorization
             );
             const params = checkRequiredParams(req.params, ['integrationId']);
-            const integration =
-                await integrationFactory.getInstanceFromIntegrationId({
-                    integrationId: params.integrationId,
-                    userId: user.getId(),
-                });
+            const integration = await getIntegrationInstance.execute(params.integrationId, user.getId());
             res.json(await integration.send('GET_USER_ACTIONS', req.body));
         })
     );
@@ -300,13 +243,7 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken, integrati
                     'integrationId',
                     'actionId',
                 ]);
-                const integration =
-                    await integrationFactory.getInstanceFromIntegrationId(
-                        {
-                            integrationId: params.integrationId,
-                            userId: user.getId(),
-                        }
-                    );
+                const integration = await getIntegrationInstance.execute(params.integrationId, user.getId());
 
                 res.json(
                     await integration.send('GET_USER_ACTION_OPTIONS', {
@@ -330,13 +267,7 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken, integrati
                     'integrationId',
                     'actionId',
                 ]);
-                const integration =
-                    await integrationFactory.getInstanceFromIntegrationId(
-                        {
-                            integrationId: params.integrationId,
-                            userId: user.getId(),
-                        }
-                    );
+                const integration = await getIntegrationInstance.execute(params.integrationId, user.getId());
 
                 res.json(
                     await integration.send('REFRESH_USER_ACTION_OPTIONS', {
@@ -356,12 +287,7 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken, integrati
                 'integrationId',
                 'actionId',
             ]);
-            const integration =
-                await integrationFactory.getInstanceFromIntegrationId({
-                    integrationId: params.integrationId,
-                    userId: user.getId(),
-                });
-
+            const integration = await getIntegrationInstance.execute(params.integrationId, user.getId());
             res.json(await integration.send(params.actionId, req.body));
         })
     );
@@ -395,13 +321,8 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken, integrati
             const user = await getUserFromBearerToken.execute(
                 req.headers.authorization
             );
-            const userId = user.getId();
             const params = checkRequiredParams(req.params, ['integrationId']);
-            const instance =
-                await integrationFactory.getInstanceFromIntegrationId({
-                    userId,
-                    integrationId: params.integrationId,
-                });
+            const instance = await getIntegrationInstance.execute(params.integrationId, user.getId());
 
             if (!instance) {
                 throw Boom.notFound();

package/integrations/integration.js

@@ -1,5 +1,37 @@
 const { Options } = require('./options');
 
+/**
+ * Integration (Domain Aggregate-Root)
+ * ----------------------------------
+ * This class represents a *configured* integration instance at runtime. It is
+ * deliberately split into **two layers**:
+ *   1.  A *data snapshot* of the persisted record (id, userId, config, etc.).
+ *   2.  A *behaviour* object: a concrete class supplied by the app developer
+ *       that extends `IntegrationBase` and implements event handlers, user
+ *       actions, custom routes, etc.
+ *
+ * The two layers are glued together via a **JavaScript `Proxy`**.  When a
+ * property is requested on an `Integration` instance we:
+ *   • Check if the property exists on the wrapper itself (data-layer).
+ *   • Fallback to the behaviour instance (logic-layer).
+ *   • If the value is a function we `.bind(this)` so that the function's
+ *     `this` always points to the *wrapper* – giving it access to both data
+ *     and behaviour transparently.
+ *
+ * This means you can treat a hydrated Integration as if it *were* the custom
+ * class:
+ *
+ * ```js
+ * const integration = await getIntegration.execute(id, userId);
+ * // `send` actually lives on IntegrationBase but is accessible here
+ * const actions = await integration.send('GET_USER_ACTIONS');
+ * ```
+ *
+ * A corollary benefit is that **circular references stay internal**: the heavy
+ * `Module → Api → delegate` graph is never exposed when we later serialise the
+ * object to JSON – we map it to a DTO first.
+ */
+
 /**
  * Integration Domain Entity
  * Represents a configured integration with its data and behavior
@@ -15,7 +47,6 @@ class Integration {
         status,
         version,
         messages,
-        entityReference,
         integrationClass,
         modules = {}
     }) {
@@ -27,7 +58,6 @@ class Integration {
         this.status = status;
         this.version = version;
         this.messages = messages;
-        this.entityReference = entityReference;
 
         // Integration behavior (strategy pattern)
         this.integrationClass = integrationClass;
@@ -38,7 +68,10 @@ class Integration {
         // Initialize basic behavior (sync parts only)
         this._initializeBasicBehavior();
 
-        // Return a Proxy to handle dynamic method delegation
+        // --- Behaviour delegation via Proxy --------------------------------
+        // The Proxy merges the *data layer* (this wrapper) with the *behaviour
+        // layer* (custom IntegrationBase subclass).  Consumers don't have to
+        // know (or care) where a method/property is defined.
         return new Proxy(this, {
             get(target, prop) {
                 // First, check if property exists on Integration entity
@@ -76,6 +109,21 @@ class Integration {
             // Copy events
             this.events = this.behavior.events || {};
             this.defaultEvents = this.behavior.defaultEvents || {};
+
+
+            // Expose behaviour instance methods directly on the wrapper so that
+            // early-bound handlers (created before behaviour existed) can still
+            // access them without falling back through the Proxy. This prevents
+            // `undefined` errors for methods like `loadDynamicUserActions` that
+            // may be invoked inside default event-handlers.
+            const proto = Object.getPrototypeOf(this.behavior);
+            for (const key of Object.getOwnPropertyNames(proto)) {
+                if (key === 'constructor') continue;
+                if (typeof proto[key] === 'function' && this[key] === undefined) {
+                    // Bind to behaviour so internal `this` remains correct.
+                    this[key] = proto[key].bind(this.behavior);
+                }
+            }
         }
     }
 
@@ -176,7 +224,6 @@ class Integration {
             status: this.status,
             version: this.version,
             messages: this.messages,
-            entityReference: this.entityReference,
             // Expose userActions if they were loaded/attached elsewhere
             userActions: this.userActions,
         };

package/integrations/use-cases/create-integration.js

@@ -17,29 +17,39 @@ class CreateIntegration {
     async execute(entities, userId, config) {
         const integrationRecord = await this.integrationRepository.createIntegration(entities, userId, config);
 
-        const modules = {};
-        for (const [key, entity] of Object.entries(integrationRecord.entities)) {
+
+        // 2. Get the correct Integration class by type
+        const integrationClass = this.integrationClasses.find(
+            (integrationClass) => integrationClass.Definition.name === integrationRecord.config.type
+        );
+
+        if (!integrationClass) {
+            throw new Error(`No integration class found for type: ${integrationRecord.config.type}`);
+        }
+
+        const modules = [];
+        for (const entityId of integrationRecord.entitiesIds) {
             const moduleInstance = await this.moduleService.getModuleInstance(
-                entity._id,
-                integrationRecord.user
+                entityId,
+                integrationRecord.userId
             );
-            modules[key] = moduleInstance;
+            modules.push(moduleInstance);
         }
 
         const integrationInstance = new Integration({
-            id: integrationRecord._id.toString(),
-            userId: integrationRecord.user,
-            entities: integrationRecord.entities,
+            id: integrationRecord.id,
+            userId: integrationRecord.userId,
+            entities: integrationRecord.entitiesIds,
             config: integrationRecord.config,
             status: integrationRecord.status,
             version: integrationRecord.version,
             messages: integrationRecord.messages,
-            entityReference: integrationRecord.entityReference,
-            integrationClass: this.integrationClasses[integrationRecord.config.type], // todo: check if this is correct
+            integrationClass: integrationClass,
             modules
         });
 
         await integrationInstance.initialize();
+        await integrationInstance.send('ON_CREATE', {});
 
         return mapIntegrationClassToIntegrationDTO(integrationInstance);
     }

package/integrations/use-cases/delete-integration-for-user.js

@@ -1,28 +1,52 @@
 const Boom = require('@hapi/boom');
 
 class DeleteIntegrationForUser {
-    constructor({ integrationRepository }) {
+    constructor({ integrationRepository, integrationClasses }) {
 
         /**
          * @type {import('../integration-repository').IntegrationRepository}
          */
         this.integrationRepository = integrationRepository;
+        this.integrationClasses = integrationClasses;
     }
 
     async execute(integrationId, userId) {
-        const integration = await this.integrationRepository.findIntegrationById(integrationId);
+        const integrationRecord = await this.integrationRepository.findIntegrationById(integrationId);
 
-        if (!integration) {
+        if (!integrationRecord) {
             throw Boom.notFound(
                 `Integration with id of ${integrationId} does not exist`
             );
         }
 
-        if (integration.user.toString() !== userId.toString()) {
-            throw Boom.forbidden('User does not have access to this integration');
+        const integrationClass = this.integrationClasses.find(
+            (integrationClass) => integrationClass.Definition.name === integrationRecord.config.type
+        );
+
+        if (integrationRecord.userId !== userId) {
+            throw new Error(
+                `Integration ${integrationId} does not belong to User ${userId}`
+            );
         }
 
+        const integrationInstance = new Integration({
+            id: integrationRecord.id,
+            userId: integrationRecord.userId,
+            entities: integrationRecord.entitiesIds,
+            config: integrationRecord.config,
+            status: integrationRecord.status,
+            version: integrationRecord.version,
+            messages: integrationRecord.messages,
+            integrationClass: integrationClass,
+            modules: [],
+        });
+
+        // 6. Complete async initialization (load dynamic actions, register handlers)
+        await integrationInstance.initialize();
+        await integrationInstance.send('ON_DELETE');
+
         await this.integrationRepository.deleteIntegrationById(integrationId);
+
     }
 }
 

package/integrations/use-cases/get-integration-for-user.js

@@ -34,13 +34,13 @@ class GetIntegrationForUser {
             (integrationClass) => integrationClass.Definition.name === integrationRecord.config.type
         );
 
-        const modules = {};
-        for (const [key, entity] of Object.entries(entities)) {
+        const modules = [];
+        for (const entity of entities) {
             const moduleInstance = await this.moduleService.getModuleInstance(
-                entity.id,
+                entity._id,
                 integrationRecord.user
             );
-            modules[key] = moduleInstance;
+            modules.push(moduleInstance);
         }
 
         const integrationInstance = new Integration({

package/integrations/use-cases/get-integration-instance.js

@@ -0,0 +1,73 @@
+const { Integration } = require('../integration');
+
+class GetIntegrationInstance {
+
+    /**
+     * @class GetIntegrationInstance
+     * @description Use case for retrieving a single integration instance by ID and user.
+     * @param {Object} params
+     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data access
+     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes
+     * @param {import('../module-plugin/module-service').ModuleService} params.moduleService - Service for module instantiation and management
+     */
+    constructor({
+        integrationRepository,
+        integrationClasses,
+        moduleService,
+    }) {
+        this.integrationRepository = integrationRepository;
+        this.integrationClasses = integrationClasses;
+        this.moduleService = moduleService;
+    }
+
+    async execute(integrationId, userId) {
+        const integrationRecord = await this.integrationRepository.findIntegrationById(integrationId);
+
+        if (!integrationRecord) {
+            throw new Error(`No integration found by the ID of ${integrationId}`);
+        }
+
+        const integrationClass = this.integrationClasses.find(
+            (integrationClass) => integrationClass.Definition.name === integrationRecord.config.type
+        );
+
+        if (!integrationClass) {
+            throw new Error(`No integration class found for type: ${integrationRecord.config.type}`);
+        }
+
+        if (integrationRecord.userId !== userId) {
+            throw new Error(
+                `Integration ${integrationId} does not belong to User ${userId}`
+            );
+        }
+
+
+        const modules = [];
+        for (const entityId of integrationRecord.entitiesIds) {
+            const moduleInstance = await this.moduleService.getModuleInstance(
+                entityId,
+                integrationRecord.userId
+            );
+            modules.push(moduleInstance);
+        }
+
+        const integrationInstance = new Integration({
+            id: integrationRecord.id,
+            userId: integrationRecord.userId,
+            entities: integrationRecord.entitiesIds,
+            config: integrationRecord.config,
+            status: integrationRecord.status,
+            version: integrationRecord.version,
+            messages: integrationRecord.messages,
+            integrationClass: integrationClass,
+            modules
+        });
+
+
+        await integrationInstance.initialize();
+
+        return integrationInstance;
+    }
+}
+
+module.exports = { GetIntegrationInstance }; 

package/integrations/use-cases/get-integrations-for-user.js

@@ -29,13 +29,13 @@ class GetIntegrationsForUser {
                 (integrationClass) => integrationClass.Definition.name === integrationRecord.config.type
             );
 
-            const modules = {};
-            for (const [key, entity] of Object.entries(entities)) {
+            const modules = [];
+            for (const entity of entities) {
                 const moduleInstance = await this.moduleService.getModuleInstance(
                     entity.id,
                     integrationRecord.userId
                 );
-                modules[key] = moduleInstance;
+                modules.push(moduleInstance);
             }
 
             const integrationInstance = new Integration({

package/integrations/use-cases/{get-integration.js → update-integration.js}

@@ -2,8 +2,16 @@ const { Integration } = require('../integration');
 const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
 
 
-// todo: remove this use case
-class GetIntegration {
+class UpdateIntegration {
+
+    /**
+     * @class UpdateIntegration
+     * @description Use case for updating a single integration by ID and user.
+     * @param {Object} params
+     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data access
+     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes
+     * @param {import('../module-plugin/module-service').ModuleService} params.moduleService - Service for module instantiation and management
+     */
     constructor({
         integrationRepository,
         integrationClasses,
@@ -14,7 +22,7 @@ class GetIntegration {
         this.moduleService = moduleService;
     }
 
-    async execute(integrationId, userId) {
+    async execute(integrationId, userId, config) {
         // 1. Get integration record from repository
         const integrationRecord = await this.integrationRepository.findIntegrationById(integrationId);
 
@@ -22,42 +30,41 @@ class GetIntegration {
             throw new Error(`No integration found by the ID of ${integrationId}`);
         }
 
+        // 2. Get the correct Integration class by type
+        const integrationClass = this.integrationClasses.find(
+            (integrationClass) => integrationClass.Definition.name === integrationRecord.config.type
+        );
+
         if (!integrationClass) {
             throw new Error(`No integration class found for type: ${integrationRecord.config.type}`);
         }
 
-        if (!integrationRecord.user.equals(userId)) {
+        if (integrationRecord.userId !== userId) {
             throw new Error(
                 `Integration ${integrationId} does not belong to User ${userId}`
             );
         }
 
-        // 2. Get the correct Integration class by type
-        const integrationClass = this.integrationClasses.find(
-            (integrationClass) => integrationClass.Definition.name === integrationRecord.config.type
-        );
-
 
         // 3. Load modules based on entity references
-        const modules = {};
-        for (const [key, entity] of Object.entries(integrationRecord.entities)) {
+        const modules = [];
+        for (const entityId of integrationRecord.entitiesIds) {
             const moduleInstance = await this.moduleService.getModuleInstance(
-                entity._id,
-                integrationRecord.user
+                entityId,
+                integrationRecord.userId
             );
-            modules[key] = moduleInstance;
+            modules.push(moduleInstance);
         }
 
         // 4. Create the Integration domain entity with modules
         const integrationInstance = new Integration({
-            id: integrationRecord._id.toString(),
-            userId: integrationRecord.user,
-            entities: integrationRecord.entities,
+            id: integrationRecord.id,
+            userId: integrationRecord.userId,
+            entities: integrationRecord.entitiesIds,
             config: integrationRecord.config,
             status: integrationRecord.status,
             version: integrationRecord.version,
             messages: integrationRecord.messages,
-            entityReference: integrationRecord.entityReference,
             integrationClass: integrationClass,
             modules
         });
@@ -65,9 +72,10 @@ class GetIntegration {
 
         // 6. Complete async initialization (load dynamic actions, register handlers)
         await integrationInstance.initialize();
+        await integrationInstance.send('ON_UPDATE', { config });
 
         return mapIntegrationClassToIntegrationDTO(integrationInstance);
     }
 }
 
-module.exports = { GetIntegration }; 
+module.exports = { UpdateIntegration }; 

package/integrations/utils/map-integration-dto.js

@@ -19,4 +19,19 @@ function mapIntegrationClassToIntegrationDTO(integration) {
     };
 }
 
-module.exports = { mapIntegrationClassToIntegrationDTO }; 
+
+const getModulesDefinitionFromIntegrationClasses = (integrationClasses) => {
+    return [
+        ...new Set(
+            integrationClasses
+                .map((integration) =>
+                    Object.values(integration.Definition.modules).map(
+                        (module) => module.definition
+                    )
+                )
+                .flat()
+        ),
+    ];
+};
+
+module.exports = { mapIntegrationClassToIntegrationDTO, getModulesDefinitionFromIntegrationClasses }; 

package/module-plugin/module-repository.js

@@ -22,7 +22,8 @@ class ModuleRepository {
     async findEntitiesByIds(entitiesIds) {
         const entitiesRecords = await Entity.find({ _id: { $in: entitiesIds } }, '', { lean: true }).populate('credential');
 
-        if (entitiesRecords.length !== entitiesIds.length) {
+        // todo: this is a workaround needed while we create an integration with the same entity twice
+        if (entitiesRecords.length !== entitiesIds.length && entitiesIds[0] !== entitiesIds[1]) {
             throw new Error(`Some entities not found`);
         }
 
@@ -45,6 +46,25 @@ class ModuleRepository {
             { lean: true }
         );
     }
+
+    async findEntitiesByIds(entityIds) {
+        const entities = await Entity.find(
+            { _id: { $in: entityIds } },
+            '',
+            { lean: true }
+        );
+
+        return entities.map(e => ({
+            id: e._id.toString(),
+            accountId: e.accountId,
+            credentialId: e.credential.toString(),
+            userId: e.user.toString(),
+            name: e.name,
+            externalId: e.externalId,
+            type: e.__t,
+            moduleName: e.moduleName,
+        }));
+    }
 }
 
 module.exports = { ModuleRepository }; 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/core",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.396.accf516.0",
+  "version": "2.0.0--canary.396.469364a.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.396.accf516.0",
-    "@friggframework/prettier-config": "2.0.0--canary.396.accf516.0",
-    "@friggframework/test": "2.0.0--canary.396.accf516.0",
+    "@friggframework/eslint-config": "2.0.0--canary.396.469364a.0",
+    "@friggframework/prettier-config": "2.0.0--canary.396.469364a.0",
+    "@friggframework/test": "2.0.0--canary.396.469364a.0",
     "@types/lodash": "4.17.15",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "chai": "^4.3.6",
@@ -53,5 +53,5 @@
   },
   "homepage": "https://github.com/friggframework/frigg#readme",
   "description": "",
-  "gitHead": "accf516c6aef6b581e2fe68268c28676275efa0d"
+  "gitHead": "469364a7e870439540866a1a8f35107e9e2aef18"
 }

package/integrations/integration-factory.js

@@ -1,195 +0,0 @@
-const { ModuleFactory, Entity } = require('../module-plugin');
-const { IntegrationModel } = require('./integration-model');
-
-class IntegrationFactory {
-    constructor(integrationClasses = []) {
-        this.integrationClasses = integrationClasses;
-        this.moduleFactory = new ModuleFactory(...this.getModules());
-        this.integrationTypes = this.integrationClasses.map(
-            (IntegrationClass) => IntegrationClass.getName()
-        );
-        this.getIntegrationDefinitions = this.integrationClasses.map(
-            (IntegrationClass) => IntegrationClass.Definition
-        );
-    }
-
-    async getIntegrationOptions() {
-        const options = this.integrationClasses.map(
-            (IntegrationClass) => IntegrationClass
-        );
-        return {
-            entities: {
-                options: options.map((IntegrationClass) =>
-                    IntegrationClass.getOptionDetails()
-                ),
-                authorized: [],
-            },
-            integrations: [],
-        };
-    }
-
-    getModules() {
-        return [
-            ...new Set(
-                this.integrationClasses
-                    .map((integration) =>
-                        Object.values(integration.Definition.modules).map(
-                            (module) => module.definition
-                        )
-                    )
-                    .flat()
-            ),
-        ];
-    }
-
-    getIntegrationClassByType(type) {
-        const integrationClassIndex = this.integrationTypes.indexOf(type);
-        return this.integrationClasses[integrationClassIndex];
-    }
-    getModuleTypesAndKeys(integrationClass) {
-        const moduleTypesAndKeys = {};
-        const moduleTypeCount = {};
-
-        if (integrationClass && integrationClass.Definition.modules) {
-            for (const [key, moduleClass] of Object.entries(
-                integrationClass.Definition.modules
-            )) {
-                if (
-                    moduleClass &&
-                    typeof moduleClass.definition.getName === 'function'
-                ) {
-                    const moduleType = moduleClass.definition.getName();
-
-                    // Check if this module type has already been seen
-                    if (moduleType in moduleTypesAndKeys) {
-                        throw new Error(
-                            `Duplicate module type "${moduleType}" found in integration class definition.`
-                        );
-                    }
-
-                    // Well how baout now
-
-                    moduleTypesAndKeys[moduleType] = key;
-                    moduleTypeCount[moduleType] =
-                        (moduleTypeCount[moduleType] || 0) + 1;
-                }
-            }
-        }
-
-        // Check for any module types with count > 1
-        for (const [moduleType, count] of Object.entries(moduleTypeCount)) {
-            if (count > 1) {
-                throw new Error(
-                    `Multiple instances of module type "${moduleType}" found in integration class definition.`
-                );
-            }
-        }
-
-        return moduleTypesAndKeys;
-    }
-
-    async getInstanceFromIntegrationId({ integrationId, userId }) {
-        const integrationRecord = await IntegrationHelper.getIntegrationById(
-            integrationId
-        );
-        if (!integrationRecord) {
-            throw new Error(
-                `No integration found by the ID of ${integrationId}`
-            );
-        }
-
-        if (!userId) {
-            userId = integrationRecord.user._id.toString();
-        } else if (userId.toString() !== integrationRecord.user.toString()) {
-            throw new Error(
-                `Integration ${integrationId
-                } does not belong to User ${userId}, ${integrationRecord.user.toString()}`
-            );
-        }
-
-        // getIntegrationClassByType is only used here
-        const integrationClass = this.getIntegrationClassByType(
-            integrationRecord.config.type
-        );
-
-        // here we should instantiate an Integration Domain class along with the integration record and it should happen in a use case class
-        // Actually, this integrationClass is a subclass of IntegrationBase.
-        const instance = new integrationClass({
-            userId,
-            integrationId,
-        });
-
-        if (
-            integrationRecord.entityReference &&
-            Object.keys(integrationRecord.entityReference) > 0
-        ) {
-            // Use the specified entityReference to find the modules and load them according to their key
-            // entityReference will be a map of entityIds with their corresponding desired key
-            for (const [entityId, key] of Object.entries(
-                integrationRecord.entityReference
-            )) {
-                const moduleInstance =
-                    await this.moduleFactory.getModuleInstanceFromEntityId(
-                        entityId,
-                        integrationRecord.user
-                    );
-                instance[key] = moduleInstance;
-            }
-        }
-
-        instance.record = integrationRecord;
-
-        try {
-            const additionalUserActions =
-                await instance.loadDynamicUserActions();
-            instance.events = { ...instance.events, ...additionalUserActions };
-        } catch (e) {
-            instance.record.status = 'ERROR';
-            instance.record.messages.errors.push(e);
-            await instance.record.save();
-        }
-        // Register all of the event handlers
-
-        await instance.registerEventHandlers();
-        return instance;
-    }
-
-    async createIntegration(entities, userId, config) {
-        const integrationRecord = await IntegrationModel.create({
-            entities: entities,
-            user: userId,
-            config,
-            version: '0.0.0',
-        });
-        return await this.getInstanceFromIntegrationId({
-            integrationId: integrationRecord.id,
-            userId,
-        });
-    }
-
-    async getFormattedIntegration(integrationRecord) {
-        const integrationObj = {
-            id: integrationRecord.id,
-            status: integrationRecord.status,
-            config: integrationRecord.config,
-            entities: [],
-            version: integrationRecord.version,
-            messages: integrationRecord.messages,
-        };
-        for (const entityId of integrationRecord.entities) {
-            // Only return non-internal fields. Leverages "select" and "options" to non-excepted fields and a pure object.
-            const entity = await Entity.findById(
-                entityId,
-                '-createdAt -updatedAt -user -credentials -credential -_id -__t -__v',
-                { lean: true }
-            );
-            integrationObj.entities.push({
-                id: entityId,
-                ...entity,
-            });
-        }
-        return integrationObj;
-    }
-}
-
-module.exports = { IntegrationFactory };