@friggframework/core 2.0.0--canary.395.65f5f64.0 → 2.0.0--canary.398.24926ac.0

package/integrations/integration-base.js

@@ -1,9 +1,5 @@
 const { IntegrationMapping } = require('./integration-mapping');
 const { Options } = require('./options');
-const { UpdateIntegrationStatus } = require('./use-cases/update-integration-status');
-const { IntegrationRepository } = require('./integration-repository');
-const { UpdateIntegrationMessages } = require('./use-cases/update-integration-messages');
-
 const constantsToBeMigrated = {
     defaultEvents: {
         ON_CREATE: 'ON_CREATE',
@@ -23,12 +19,6 @@ const constantsToBeMigrated = {
 };
 
 class IntegrationBase {
-
-    // todo: maybe we can pass this as Dependency Injection in the sub-class constructor
-    integrationRepository = new IntegrationRepository();
-    updateIntegrationStatus = new UpdateIntegrationStatus({ integrationRepository: this.integrationRepository });
-    updateIntegrationMessages = new UpdateIntegrationMessages({ integrationRepository: this.integrationRepository });
-
     static getOptionDetails() {
         const options = new Options({
             module: Object.values(this.Definition.modules)[0], // This is a placeholder until we revamp the frontend
@@ -36,7 +26,6 @@ class IntegrationBase {
         });
         return options.get();
     }
-
     /**
      * CHILDREN SHOULD SPECIFY A DEFINITION FOR THE INTEGRATION
      */
@@ -61,7 +50,21 @@ class IntegrationBase {
     static getCurrentVersion() {
         return this.Definition.version;
     }
-
+    loadModules() {
+        // Load all the modules defined in Definition.modules
+        const moduleNames = Object.keys(this.constructor.Definition.modules);
+        for (const moduleName of moduleNames) {
+            const { definition } =
+                this.constructor.Definition.modules[moduleName];
+            if (typeof definition.API === 'function') {
+                this[moduleName] = { api: new definition.API() };
+            } else {
+                throw new Error(
+                    `Module ${moduleName} must be a function that extends IntegrationModule`
+                );
+            }
+        }
+    }
     registerEventHandlers() {
         this.on = {
             ...this.defaultEvents,
@@ -69,31 +72,7 @@ class IntegrationBase {
         };
     }
 
-    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 || {};
-
+    constructor(params) {
         this.defaultEvents = {
             [constantsToBeMigrated.defaultEvents.ON_CREATE]: {
                 type: constantsToBeMigrated.types.LIFE_CYCLE_EVENT,
@@ -128,6 +107,7 @@ class IntegrationBase {
                 handler: this.refreshActionOptions,
             },
         };
+        this.loadModules();
     }
 
     async send(event, object) {
@@ -141,7 +121,7 @@ class IntegrationBase {
 
     async validateConfig() {
         const configOptions = await this.getConfigOptions();
-        const currentConfig = this.getConfig();
+        const currentConfig = this.record.config;
         let needsConfig = false;
         for (const option of configOptions) {
             if (option.required) {
@@ -153,59 +133,56 @@ class IntegrationBase {
                     )
                 ) {
                     needsConfig = true;
-                    await this.updateIntegrationMessages.execute(
-                        this.id,
-                        'warnings',
-                        'Config Validation Error',
-                        `Missing required field of ${option.label}`,
-                        Date.now()
-                    );
+                    this.record.messages.warnings.push({
+                        title: 'Config Validation Error',
+                        message: `Missing required field of ${option.label}`,
+                        timestamp: Date.now(),
+                    });
                 }
             }
         }
         if (needsConfig) {
-            await this.updateIntegrationStatus.execute(this.id, 'NEEDS_CONFIG');
+            this.record.status = 'NEEDS_CONFIG';
+            await this.record.save();
         }
     }
 
     async testAuth() {
         let didAuthPass = true;
 
-        for (const module of Object.keys(this.constructor.Definition.modules)) {
+        for (const module of Object.keys(IntegrationBase.Definition.modules)) {
             try {
                 await this[module].testAuth();
             } catch {
                 didAuthPass = false;
-                await this.updateIntegrationMessages.execute(
-                    this.id,
-                    'errors',
-                    'Authentication Error',
-                    `There was an error with your ${this[
+                this.record.messages.errors.push({
+                    title: 'Authentication Error',
+                    message: `There was an error with your ${this[
                         module
                     ].constructor.getName()} Entity.
                 Please reconnect/re-authenticate, or reach out to Support for assistance.`,
-                    Date.now()
-                );
+                    timestamp: Date.now(),
+                });
             }
         }
 
         if (!didAuthPass) {
-            await this.updateIntegrationStatus.execute(this.id, 'ERROR');
+            this.record.status = 'ERROR';
+            this.record.markModified('messages.error');
+            await this.record.save();
         }
     }
 
     async getMapping(sourceId) {
-        // todo: this should be a use case
-        return IntegrationMapping.findBy(this.id, sourceId);
+        return IntegrationMapping.findBy(this.record.id, sourceId);
     }
 
     async upsertMapping(sourceId, mapping) {
         if (!sourceId) {
             throw new Error(`sourceId must be set`);
         }
-        // todo: this should be a use case
         return await IntegrationMapping.upsert(
-            this.id,
+            this.record.id,
             sourceId,
             mapping
         );
@@ -214,13 +191,15 @@ class IntegrationBase {
     /**
      * CHILDREN CAN OVERRIDE THESE CONFIGURATION METHODS
      */
-    async onCreate({ integrationId }) {
-        await this.updateIntegrationStatus.execute(integrationId, 'ENABLED');
+    async onCreate(params) {
+        this.record.status = 'ENABLED';
+        await this.record.save();
+        return this.record;
     }
 
-    async onUpdate(params) { }
+    async onUpdate(params) {}
 
-    async onDelete(params) { }
+    async onDelete(params) {}
 
     async getConfigOptions() {
         const options = {
@@ -257,10 +236,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 };
     }
@@ -280,81 +259,6 @@ class IntegrationBase {
         };
         return options;
     }
-
-    // === Domain Methods (moved from Integration.js) ===
-    
-    getConfig() {
-        return this.config;
-    }
-
-    getModule(key) {
-        return this.modules[key];
-    }
-
-    setModule(key, module) {
-        this.modules[key] = module;
-        this[key] = module;
-    }
-
-    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);
-    }
-
-    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();
-    }
-
-    async initialize() {
-        // 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();
-    }
-
-    getOptionDetails() {
-        const options = new Options({
-            module: Object.values(this.constructor.Definition.modules)[0],
-            ...this.constructor.Definition,
-        });
-        return options.get();
-    }
-
-    // Legacy method for backward compatibility
-    async loadModules() {
-        // This method was used in the old architecture for loading modules
-        // In the new architecture, modules are injected via constructor
-        // For backward compatibility, this is a no-op
-        return;
-    }
 }
 
 module.exports = { IntegrationBase };

package/integrations/integration-factory.js

@@ -0,0 +1,251 @@
+const { ModuleFactory, Credential, Entity } = require('../module-plugin');
+const { IntegrationModel } = require('./integration-model');
+const _ = require('lodash');
+
+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(params) {
+        const integrationRecord = await IntegrationHelper.getIntegrationById(
+            params.integrationId
+        );
+        let { userId } = params;
+        if (!integrationRecord) {
+            throw new Error(
+                `No integration found by the ID of ${params.integrationId}`
+            );
+        }
+
+        if (!userId) {
+            userId = integrationRecord.user._id.toString();
+        } else if (userId.toString() !== integrationRecord.user.toString()) {
+            throw new Error(
+                `Integration ${
+                    params.integrationId
+                } does not belong to User ${userId}, ${integrationRecord.user.toString()}`
+            );
+        }
+
+        const integrationClass = this.getIntegrationClassByType(
+            integrationRecord.config.type
+        );
+
+        const instance = new integrationClass({
+            userId,
+            integrationId: params.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;
+            }
+        } 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 {
+            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,
+        });
+    }
+}
+
+const IntegrationHelper = {
+    getFormattedIntegration: async function (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;
+    },
+
+    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 };