@friggframework/core 2.0.0--canary.395.af305ea.0 → 2.0.0--canary.396.d14a555.0

package/credential/credential-repository.js

@@ -0,0 +1,9 @@
+const { Credential } = require('../module-plugin');
+
+class CredentialRepository {
+    async findCredentialById(id) {
+        return Credential.findById(id);
+    }
+}
+
+module.exports = { CredentialRepository };

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

@@ -0,0 +1,21 @@
+class GetCredentialForUser {
+    constructor({ credentialRepository }) {
+        this.credentialRepository = credentialRepository;
+    }
+
+    async execute(credentialId, userId) {
+        const credential = await this.credentialRepository.findCredentialById(credentialId);
+
+        if (!credential) {
+            throw new Error(`Credential with id ${credentialId} not found`);
+        }
+
+        if (credential.user.toString() !== userId.toString()) {
+            throw new Error(`Credential ${credentialId} does not belong to user ${userId}`);
+        }
+
+        return credential;
+    }
+}
+
+module.exports = { GetCredentialForUser };

package/handlers/backend-utils.js

@@ -44,7 +44,7 @@ const loadRouterFromObject = (IntegrationClass, routerObject) => {
     );
     router[method.toLowerCase()](path, async (req, res, next) => {
         try {
-            const integration = new IntegrationClass({});
+            const integration = new IntegrationClass();
             await integration.loadModules();
             await integration.registerEventHandlers();
             const result = await integration.send(event, { req, res, next });
@@ -64,7 +64,7 @@ const createQueueWorker = (integrationClass, integrationFactory) => {
             try {
                 let instance;
                 if (!params.integrationId) {
-                    instance = new integrationClass({});
+                    instance = new integrationClass();
                     await instance.loadModules();
                     // await instance.loadUserActions();
                     await instance.registerEventHandlers();

package/handlers/routers/auth.js

@@ -4,7 +4,7 @@ const {
     loadAppDefinition,
 } = require('./../backend-utils');
 const { UserRepository } = require('../../user/user-repository');
-const { IntegrationFactory, IntegrationHelper } = require('../../integrations/integration-factory');
+const { IntegrationFactory } = require('../../integrations/integration-factory');
 const { GetUserFromBearerToken } = require('../../user/use-cases/get-user-from-bearer-token');
 
 const { integrations, userConfig } = loadAppDefinition();
@@ -19,7 +19,6 @@ const router = createIntegrationRouter({
     factory: {
         moduleFactory: integrationFactory.moduleFactory,
         integrationFactory,
-        IntegrationHelper
     },
     getUserFromBearerToken,
 });

package/index.js

@@ -39,7 +39,6 @@ const {
     Options,
     IntegrationMapping,
     IntegrationFactory,
-    IntegrationHelper,
     createIntegrationRouter,
     checkRequiredParams,
 } = require('./integrations/index');
@@ -56,7 +55,6 @@ const {
     Requester,
     ModuleConstants,
     ModuleFactory,
-    Auther,
 } = require('./module-plugin/index');
 const utils = require('./utils');
 
@@ -109,7 +107,6 @@ module.exports = {
     Options,
     IntegrationMapping,
     IntegrationFactory,
-    IntegrationHelper,
     checkRequiredParams,
     createIntegrationRouter,
 
@@ -132,8 +129,6 @@ module.exports = {
     Requester,
     ModuleConstants,
     ModuleFactory,
-    Auther,
-
     // queues
     QueuerUtil,
 

package/integrations/integration-base.js

@@ -1,5 +1,6 @@
 const { IntegrationMapping } = require('./integration-mapping');
 const { Options } = require('./options');
+
 const constantsToBeMigrated = {
     defaultEvents: {
         ON_CREATE: 'ON_CREATE',
@@ -19,6 +20,7 @@ const constantsToBeMigrated = {
 };
 
 class IntegrationBase {
+
     static getOptionDetails() {
         const options = new Options({
             module: Object.values(this.Definition.modules)[0], // This is a placeholder until we revamp the frontend
@@ -26,6 +28,7 @@ class IntegrationBase {
         });
         return options.get();
     }
+
     /**
      * CHILDREN SHOULD SPECIFY A DEFINITION FOR THE INTEGRATION
      */
@@ -197,9 +200,9 @@ class IntegrationBase {
         return this.record;
     }
 
-    async onUpdate(params) {}
+    async onUpdate(params) { }
 
-    async onDelete(params) {}
+    async onDelete(params) { }
 
     async getConfigOptions() {
         const options = {
@@ -236,10 +239,10 @@ class IntegrationBase {
         const dynamicUserActions = await this.loadDynamicUserActions();
         const filteredDynamicActions = actionType
             ? Object.fromEntries(
-                  Object.entries(dynamicUserActions).filter(
-                      ([_, event]) => event.userActionType === actionType
-                  )
-              )
+                Object.entries(dynamicUserActions).filter(
+                    ([_, event]) => event.userActionType === actionType
+                )
+            )
             : dynamicUserActions;
         return { ...userActions, ...filteredDynamicActions };
     }

package/integrations/integration-factory.js

@@ -1,6 +1,5 @@
-const { ModuleFactory, Credential, Entity } = require('../module-plugin');
+const { ModuleFactory, Entity } = require('../module-plugin');
 const { IntegrationModel } = require('./integration-model');
-const _ = require('lodash');
 
 class IntegrationFactory {
     constructor(integrationClasses = []) {
@@ -108,10 +107,13 @@ class IntegrationFactory {
             );
         }
 
+        // 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,
@@ -133,29 +135,8 @@ class IntegrationFactory {
                     );
                 instance[key] = moduleInstance;
             }
-        } else {
-            // for each entity, get the moduleinstance and load them according to their keys
-            // If it's the first entity, load the moduleinstance into primary as well
-            // If it's the second entity, load the moduleinstance into target as well
-            const moduleTypesAndKeys =
-                this.getModuleTypesAndKeys(integrationClass);
-            for (let i = 0; i < integrationRecord.entities.length; i++) {
-                const entityId = integrationRecord.entities[i];
-                const moduleInstance =
-                    await this.moduleFactory.getModuleInstanceFromEntityId(
-                        entityId,
-                        integrationRecord.user
-                    );
-                const moduleType = moduleInstance.getName();
-                const key = moduleTypesAndKeys[moduleType];
-                instance[key] = moduleInstance;
-                if (i === 0) {
-                    instance.primary = moduleInstance;
-                } else if (i === 1) {
-                    instance.target = moduleInstance;
-                }
-            }
         }
+
         instance.record = integrationRecord;
 
         try {
@@ -185,11 +166,8 @@ class IntegrationFactory {
             userId,
         });
     }
-}
 
-// todo: this should be split into use case classes
-const IntegrationHelper = {
-    getFormattedIntegration: async function (integrationRecord) {
+    async getFormattedIntegration(integrationRecord) {
         const integrationObj = {
             id: integrationRecord.id,
             status: integrationRecord.status,
@@ -211,40 +189,7 @@ const IntegrationHelper = {
             });
         }
         return integrationObj;
-    },
-
-    getIntegrationsForUserId: async function (userId) {
-        const integrationList = await IntegrationModel.find({ user: userId });
-        return await Promise.all(
-            integrationList.map(
-                async (integrationRecord) =>
-                    await IntegrationHelper.getFormattedIntegration(
-                        integrationRecord
-                    )
-            )
-        );
-    },
-
-    deleteIntegrationForUserById: async function (userId, integrationId) {
-        const integrationList = await IntegrationModel.find({
-            user: userId,
-            _id: integrationId,
-        });
-        if (integrationList.length !== 1) {
-            throw new Error(
-                `Integration with id of ${integrationId} does not exist for this user`
-            );
-        }
-        await IntegrationModel.deleteOne({ _id: integrationId });
-    },
-
-    getIntegrationById: async function (id) {
-        return IntegrationModel.findById(id).populate('entities');
-    },
-
-    listCredentials: async function (options) {
-        return Credential.find(options);
-    },
-};
+    }
+}
 
-module.exports = { IntegrationFactory, IntegrationHelper };
+module.exports = { IntegrationFactory };

package/integrations/integration-repository.js

@@ -0,0 +1,26 @@
+const { IntegrationModel } = require('./integration-model');
+
+class IntegrationRepository {
+    async findIntegrationsByUserId(userId) {
+        return IntegrationModel.find({ user: userId });
+    }
+
+    async deleteIntegrationById(integrationId) {
+        return IntegrationModel.deleteOne({ _id: integrationId });
+    }
+
+    async findIntegrationById(id) {
+        return IntegrationModel.findById(id).populate('entities');
+    }
+
+    async createIntegration(entities, userId, config) {
+        return IntegrationModel.create({
+            entities: entities,
+            user: userId,
+            config,
+            version: '0.0.0',
+        });
+    }
+}
+
+module.exports = { IntegrationRepository };

package/integrations/integration-router.js

@@ -3,19 +3,57 @@ 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 { GetIntegrationForUser } = require('./use-cases/get-integration-for-user');
+const { GetIntegrationsForUser } = require('./use-cases/get-integrations-for-user');
+const { CredentialRepository } = require('../credential/credential-repository');
+const { GetCredentialForUser } = require('../credential/use-cases/get-credential-for-user');
+const { CreateIntegration } = require('./use-cases/create-integration');
+const { ModuleService } = require('../module-plugin/module-service');
+const { ModuleRepository } = require('../module-plugin/module-repository');
+const { loadAppDefinition } = require('../backend-utils');
+
+
+const { integrations } = loadAppDefinition();
+const moduleRepository = new ModuleRepository();
+const integrationRepository = new IntegrationRepository();
+const credentialRepository = new CredentialRepository();
+const moduleService = new ModuleService({ moduleRepository, moduleDefinitions: { ...getModules() } });
+const deleteIntegrationForUser = new DeleteIntegrationForUser({ integrationRepository });
+const getIntegrationForUser = new GetIntegrationForUser({ integrationRepository });
+const getIntegrationsForUser = new GetIntegrationsForUser({ integrationRepository });
+const getCredentialForUser = new GetCredentialForUser({ credentialRepository });
+const createIntegration = new CreateIntegration({
+    integrationRepository,
+    integrationClasses: integrations,
+    moduleService,
+});
+
+// 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()
+        ),
+    ];
+}
 
-
-// todo: dont send moduleFactory, integrationFactory, and IntegrationHelper as a factory object, instead send them as separate
-// params and import IntegrationHelper where needed.
+// 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, integrationFactory, and IntegrationHelper
+ * @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 {Object} params.factory.IntegrationHelper - Helper utilities for integration operations
  * @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
  */
@@ -54,14 +92,14 @@ 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, integrationFactory, and IntegrationHelper
+ * @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 {Object} factory.IntegrationHelper - Helper utilities for integration operations
  * @param {import('../user/use-cases/get-user-from-bearer-token').GetUserFromBearerToken} getUserFromBearerToken - Use case for retrieving a user from a bearer token
  */
 function setIntegrationRoutes(router, factory, getUserFromBearerToken) {
-    const { moduleFactory, integrationFactory, IntegrationHelper } = factory;
+    const { moduleFactory, integrationFactory } = factory;
+
     router.route('/api/integrations').get(
         catchAsyncError(async (req, res) => {
             const user = await getUserFromBearerToken.execute(
@@ -72,7 +110,7 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken) {
             results.entities.authorized =
                 await moduleFactory.getEntitiesForUser(userId);
             results.integrations =
-                await IntegrationHelper.getIntegrationsForUserId(userId);
+                await getIntegrationsForUser.execute(userId);
 
             for (const integrationRecord of results.integrations) {
                 const integration =
@@ -100,7 +138,7 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken) {
             get(params.config, 'type');
 
             // create integration
-            const integration = await integrationFactory.createIntegration(
+            const integration = await createIntegration.execute(
                 params.entities,
                 userId,
                 params.config
@@ -113,7 +151,7 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken) {
             await integration.send('ON_CREATE', {});
 
             res.status(201).json(
-                await IntegrationHelper.getFormattedIntegration(
+                await integrationFactory.getFormattedIntegration(
                     integration.record
                 )
             );
@@ -141,7 +179,7 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken) {
             await integration.send('ON_UPDATE', params);
 
             res.json(
-                await IntegrationHelper.getFormattedIntegration(
+                await integrationFactory.getFormattedIntegration(
                     integration.record
                 )
             );
@@ -153,11 +191,10 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken) {
             const user = await getUserFromBearerToken.execute(
                 req.headers.authorization
             );
-            const userId = user.getId();
             const params = checkRequiredParams(req.params, ['integrationId']);
             const integration =
                 await integrationFactory.getInstanceFromIntegrationId({
-                    userId,
+                    userId: user.getId(),
                     integrationId: params.integrationId,
                 });
 
@@ -165,12 +202,9 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken) {
                 `Calling onUpdate on the ${integration?.constructor?.Definition?.name} Integration with no arguments`
             );
             await integration.send('ON_DELETE');
-            await IntegrationHelper.deleteIntegrationForUserById(
-                userId,
-                params.integrationId
-            );
+            await deleteIntegrationForUser.execute(params.integrationId, user.getId());
 
-            res.status(201).json({});
+            res.status(204).json({});
         })
     );
 
@@ -309,13 +343,14 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken) {
             const user = await getUserFromBearerToken.execute(
                 req.headers.authorization
             );
+
+            if (!user) {
+                throw Boom.forbidden('User not found');
+            }
+
             const params = checkRequiredParams(req.params, ['integrationId']);
-            const integration = await IntegrationHelper.getIntegrationById(
-                {
-                    integrationId: params.integrationId,
-                    userId: user.getId(),
-                }
-            );
+            const integration = await getIntegrationForUser.execute(params.integrationId, user.getId());
+
             // We could perhaps augment router with dynamic options? Haven't decided yet, but here may be the place
 
             res.json({
@@ -364,11 +399,11 @@ function setIntegrationRoutes(router, factory, getUserFromBearerToken) {
 /**
  * Sets up entity-related routes for the integration router
  * @param {Object} router - Express router instance
- * @param {Object} factory - Factory object containing moduleFactory and IntegrationHelper
+ * @param {Object} factory - Factory object containing moduleFactory
  * @param {import('../user/use-cases/get-user-from-bearer-token').GetUserFromBearerToken} getUserFromBearerToken - Use case for retrieving a user from a bearer token
  */
 function setEntityRoutes(router, factory, getUserFromBearerToken) {
-    const { moduleFactory, IntegrationHelper } = factory;
+    const { moduleFactory } = factory;
     const getModuleInstance = async (userId, entityType) => {
         if (!moduleFactory.checkIsValidType(entityType)) {
             throw Boom.badRequest(
@@ -437,8 +472,9 @@ function setEntityRoutes(router, factory, getUserFromBearerToken) {
             checkRequiredParams(req.body.data, ['credential_id']);
 
             // May want to pass along the user ID as well so credential ID's can't be fished???
-            const credential = await IntegrationHelper.getCredentialById(
-                params.data.credential_id
+            const credential = await getCredentialForUser.execute(
+                params.data.credential_id,
+                userId
             );
 
             if (!credential) {
@@ -465,8 +501,9 @@ function setEntityRoutes(router, factory, getUserFromBearerToken) {
             const userId = user.getId();
             // TODO May want to pass along the user ID as well so credential ID's can't be fished???
             // TODO **flagging this for review** -MW
-            const credential = await IntegrationHelper.getCredentialById(
-                req.params.credentialId
+            const credential = await getCredentialForUser.execute(
+                req.params.credentialId,
+                userId
             );
             if (credential.user._id.toString() !== userId) {
                 throw Boom.forbidden('Credential does not belong to user');

package/integrations/integration.js

@@ -0,0 +1,156 @@
+/**
+ * Integration Domain Entity
+ * Represents a configured integration with its data and behavior
+ * Uses the strategy pattern to delegate behavior to the integration class
+ * This is the main class that is used to interact with integrations
+ */
+class Integration {
+    constructor({
+        id,
+        userId,
+        entities,
+        config,
+        status,
+        version,
+        messages,
+        entityReference,
+        integrationClass,
+        modules = {}
+    }) {
+        // Data from record
+        this.id = id;
+        this.userId = userId;
+        this.entities = entities;
+        this.config = config;
+        this.status = status;
+        this.version = version;
+        this.messages = messages;
+        this.entityReference = entityReference;
+
+        // Integration behavior (strategy pattern)
+        this.integrationClass = integrationClass;
+
+        // Loaded modules
+        this.modules = modules;
+
+        // Initialize basic behavior (sync parts only)
+        this._initializeBasicBehavior();
+
+        // Return a Proxy to handle dynamic method delegation
+        return new Proxy(this, {
+            get(target, prop) {
+                // First, check if property exists on Integration entity
+                if (prop in target) {
+                    return target[prop];
+                }
+
+                // Then, check if it exists on the behavior instance
+                if (target.behavior && prop in target.behavior) {
+                    const value = target.behavior[prop];
+
+                    // If it's a function, bind the context to the Integration entity
+                    if (typeof value === 'function') {
+                        return value.bind(target);
+                    }
+
+                    return value;
+                }
+
+                // Return undefined for non-existent properties
+                return undefined;
+            }
+        });
+    }
+
+    _initializeBasicBehavior() {
+        // Initialize basic behavior (sync parts only)
+        if (this.integrationClass) {
+            // Create instance for behavior delegation
+            this.behavior = new this.integrationClass({
+                userId: this.userId,
+                integrationId: this.id
+            });
+
+            // Copy events
+            this.events = this.behavior.events || {};
+            this.defaultEvents = this.behavior.defaultEvents || {};
+        }
+    }
+
+    async initialize() {
+        // Complete async initialization
+        if (this.behavior) {
+            // Load dynamic user actions
+            try {
+                const additionalUserActions = await this.loadDynamicUserActions();
+                this.events = { ...this.events, ...additionalUserActions };
+            } catch (e) {
+                this.addError(e);
+            }
+
+            // Register event handlers
+            await this.registerEventHandlers();
+        }
+    }
+
+    // Core methods that should always be on Integration entity
+    // These override any behavior methods with the same name
+
+    // Module access helpers
+    getModule(key) {
+        return this.modules[key];
+    }
+
+    setModule(key, module) {
+        this.modules[key] = module;
+        // Also set on behavior for backward compatibility
+        if (this.behavior) {
+            this.behavior[key] = module;
+        }
+    }
+
+    // State management
+    addError(error) {
+        if (!this.messages.errors) {
+            this.messages.errors = [];
+        }
+        this.messages.errors.push(error);
+        this.status = 'ERROR';
+    }
+
+    addWarning(warning) {
+        if (!this.messages.warnings) {
+            this.messages.warnings = [];
+        }
+        this.messages.warnings.push(warning);
+    }
+
+    // Domain methods
+    isActive() {
+        return this.status === 'ENABLED' || this.status === 'ACTIVE';
+    }
+
+    needsConfiguration() {
+        return this.status === 'NEEDS_CONFIG';
+    }
+
+    hasErrors() {
+        return this.status === 'ERROR';
+    }
+
+    belongsToUser(userId) {
+        return this.userId.toString() === userId.toString();
+    }
+
+    // Get the underlying behavior instance (useful for debugging or special cases)
+    getBehavior() {
+        return this.behavior;
+    }
+
+    // Check if a method exists (either on entity or behavior)
+    hasMethod(methodName) {
+        return methodName in this || (this.behavior && methodName in this.behavior);
+    }
+}
+
+module.exports = { Integration }; 

package/integrations/options.js

@@ -1,5 +1,5 @@
 const { RequiredPropertyError } = require('../errors');
-const { get, getAndVerifyType } = require('../assertions');
+const { get } = require('../assertions');
 
 class Options {
     constructor(params) {