@friggframework/core 2.0.0--canary.396.0dd37aa.0 → 2.0.0--canary.397.216d54b.0

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-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

@@ -32,7 +32,7 @@ class GetIntegrationsForUser {
             const modules = [];
             for (const entity of entities) {
                 const moduleInstance = await this.moduleService.getModuleInstance(
-                    entity._id,
+                    entity.id,
                     integrationRecord.userId
                 );
                 modules.push(moduleInstance);

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

@@ -2,12 +2,11 @@ const { Integration } = require('../integration');
 const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
 
 
-// todo: remove this use case
-class GetIntegration {
+class UpdateIntegration {
 
     /**
-     * @class GetIntegration
-     * @description Use case for retrieving a single integration by ID and user.
+     * @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
@@ -23,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);
 
@@ -31,6 +30,11 @@ 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}`);
         }
@@ -41,11 +45,6 @@ class GetIntegration {
             );
         }
 
-        // 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 = [];
@@ -59,14 +58,13 @@ class GetIntegration {
 
         // 4. Create the Integration domain entity with modules
         const integrationInstance = new Integration({
-            id: integrationRecord._id.toString(),
+            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
         });
@@ -74,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/index.js

@@ -6,7 +6,6 @@ const { BasicAuthRequester } = require('./requester/basic');
 const { OAuth2Requester } = require('./requester/oauth-2');
 const { Requester } = require('./requester/requester');
 const { ModuleConstants } = require('./ModuleConstants');
-const { ModuleFactory } = require('./module-factory');
 
 module.exports = {
     Credential,
@@ -17,5 +16,4 @@ module.exports = {
     OAuth2Requester,
     Requester,
     ModuleConstants,
-    ModuleFactory,
 };

package/module-plugin/module-repository.js

@@ -48,11 +48,22 @@ class ModuleRepository {
     }
 
     async findEntitiesByIds(entityIds) {
-        return Entity.find(
+        const entities = await Entity.find(
             { _id: { $in: entityIds } },
-            '-dateCreated -dateUpdated -user -credentials -credential -__t -__v',
+            '',
             { 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,
+        }));
     }
 }
 

package/module-plugin/module.js

@@ -9,6 +9,7 @@ const { ModuleConstants } = require('./ModuleConstants');
 
 class Module extends Delegate {
 
+    //todo: entity should be replaced with actual entity properties
     /**
      * 
      * @param {Object} params
@@ -25,8 +26,6 @@ class Module extends Delegate {
         this.entity = entityObj;
         this.credential = entityObj?.credential;
         this.definition = definition;
-        this.getEntityOptions = this.definition.getEntityOptions;
-        this.refreshEntityOptions = this.definition.refreshEntityOptions;
         this.name = this.definition.moduleName;
         this.modelName = this.definition.modelName;
         this.apiClass = this.definition.API;
@@ -56,6 +55,15 @@ class Module extends Delegate {
         return this.name;
     }
 
+    getEntityOptions() {
+        return this.definition.getEntityOptions()
+    }
+
+    async refreshEntityOptions(options) {
+        await this.definition.refreshEntityOptions(options);
+        return this.getEntityOptions();
+    }
+
     apiParamsFromCredential(credential) {
         return _.pick(credential, ...this.apiPropertiesToPersist?.credential);
     }
@@ -103,22 +111,6 @@ class Module extends Delegate {
         return this.CredentialModel;
     }
 
-    // todo: remove this method from all places
-    // async getEntitiesForUserId(userId) {
-    //     // Only return non-internal fields. Leverages "select" and "options" to non-excepted fields and a pure object.
-    //     const list = await this.EntityModel.find(
-    //         { user: userId },
-    //         '-dateCreated -dateUpdated -user -credentials -credential -__t -__v',
-    //         { lean: true }
-    //     );
-    //     console.log('getEntitiesForUserId list', list, userId);
-    //     return list.map((entity) => ({
-    //         id: entity._id,
-    //         type: this.getName(),
-    //         ...entity,
-    //     }));
-    // }
-
     async validateAuthorizationRequirements() {
         const requirements = await this.getAuthorizationRequirements();
         let valid = true;

package/module-plugin/use-cases/get-entity-options-by-id.js

@@ -0,0 +1,58 @@
+const { Module } = require('../module');
+
+class GetEntityOptionsById {
+    /**
+     * @param {Object} params
+     * @param {import('../module-repository').ModuleRepository} params.moduleRepository
+     * @param {} params.moduleDefinitions
+     */
+    constructor({ moduleRepository, moduleDefinitions }) {
+        this.moduleRepository = moduleRepository;
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    /**
+     * Retrieve a Module instance for a given user and entity/module type.
+     * @param {string} userId
+     * @param {string} entityId
+     */
+    async execute(entityId, userId) {
+        const entity = await this.moduleRepository.findEntityById(
+            entityId,
+            userId
+        );
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        if (entity.userId !== userId) {
+            throw new Error(
+                `Entity ${entityId} does not belong to user ${userId}`
+            );
+        }
+
+        const entityType = entity.type;
+        const moduleDefinition = this.moduleDefinitions.find((def) => {
+            const modelName = Module.getEntityModelFromDefinition(def).modelName;
+            return entityType === modelName;
+        });
+
+        if (!moduleDefinition) {
+            throw new Error(
+                `Module definition not found for entity type: ${entityType}`
+            );
+        }
+
+        const module = new Module({
+            userId,
+            entity,
+            definition: moduleDefinition,
+        });
+
+        const entityOptions = await module.getEntityOptions();
+        return entityOptions;
+    }
+}
+
+module.exports = { GetEntityOptionsById };

package/module-plugin/use-cases/get-entity-options-by-type.js

@@ -0,0 +1,34 @@
+const { Module } = require('../module');
+
+class GetEntityOptionsByType {
+    /**
+     * @param {Object} params
+     * @param {} params.moduleDefinitions
+     */
+    constructor({ moduleDefinitions }) {
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    /**
+     * Retrieve a Module instance for a given user and entity/module type.
+     * @param {string} userId
+     * @param {string} type – human-readable module/entity type (e.g. "Hubspot")
+     */
+    async execute(userId, type) {
+        const moduleDefinition = this.moduleDefinitions.find(
+            (def) => def.getName() === type
+        );
+        if (!moduleDefinition) {
+            throw new Error(`Module definition not found for type: ${type}`);
+        }
+        const moduleInstance = new Module({
+            userId,
+            definition: moduleDefinition,
+        });
+
+        const entityOptions = await moduleInstance.getEntityOptions();
+        return entityOptions;
+    }
+}
+
+module.exports = { GetEntityOptionsByType };

package/module-plugin/use-cases/get-module-instance-from-type.js

@@ -0,0 +1,31 @@
+const { Module } = require('../module');
+
+class GetModuleInstanceFromType {
+    /**
+     * @param {Object} params
+     * @param {} params.moduleDefinitions
+     */
+    constructor({ moduleDefinitions }) {
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    /**
+     * Retrieve a Module instance for a given user and entity/module type.
+     * @param {string} userId
+     * @param {string} type – human-readable module/entity type (e.g. "Hubspot")
+     */
+    async execute(userId, type) {
+        const moduleDefinition = this.moduleDefinitions.find(
+            (def) => def.getName() === type
+        );
+        if (!moduleDefinition) {
+            throw new Error(`Module definition not found for type: ${type}`);
+        }
+        return new Module({
+            userId,
+            definition: moduleDefinition,
+        });
+    }
+}
+
+module.exports = { GetModuleInstanceFromType };

package/module-plugin/use-cases/get-module.js

@@ -0,0 +1,56 @@
+const { Module } = require('../module');
+
+class GetModule {
+    constructor({ moduleRepository, moduleDefinitions }) {
+        this.moduleRepository = moduleRepository;
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    async execute(entityId, userId) {
+        const entity = await this.moduleRepository.findEntityById(
+            entityId,
+            userId
+        );
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        if (entity.userId !== userId) {
+            throw new Error(
+                `Entity ${entityId} does not belong to user ${userId}`
+            );
+        }
+
+        const entityType = entity.type;
+        const moduleDefinition = this.moduleDefinitions.find((def) => {
+            const modelName = Module.getEntityModelFromDefinition(def).modelName;
+            return entityType === modelName;
+        });
+
+        if (!moduleDefinition) {
+            throw new Error(
+                `Module definition not found for entity type: ${entityType}`
+            );
+        }
+
+        const module = new Module({
+            userId,
+            entity,
+            definition: moduleDefinition,
+        });
+
+        // todo: this properties should be methods in the Module class
+        return {
+            id: module.entity.id,
+            name: module.entity.name,
+            type: module.entity.moduleName,
+            moduleName: module.entity.moduleName,
+            credential: module.credential,
+            externalId: module.entity.externalId,
+            userId: module.entity.user.toString(),
+        }
+    }
+}
+
+module.exports = { GetModule };

package/module-plugin/use-cases/refresh-entity-options.js

@@ -0,0 +1,58 @@
+const { Module } = require('../module');
+
+class RefreshEntityOptions {
+    /**
+     * @param {Object} params
+     * @param {import('../module-repository').ModuleRepository} params.moduleRepository
+     * @param {} params.moduleDefinitions
+     */
+    constructor({ moduleRepository, moduleDefinitions }) {
+        this.moduleRepository = moduleRepository;
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    /**
+     * Retrieve a Module instance for a given user and entity/module type.
+     * @param {string} userId
+     * @param {string} entityId
+     */
+    async execute(entityId, userId, options) {
+        const entity = await this.moduleRepository.findEntityById(
+            entityId,
+            userId
+        );
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        if (entity.userId !== userId) {
+            throw new Error(
+                `Entity ${entityId} does not belong to user ${userId}`
+            );
+        }
+
+        const entityType = entity.type;
+        const moduleDefinition = this.moduleDefinitions.find((def) => {
+            const modelName = Module.getEntityModelFromDefinition(def).modelName;
+            return entityType === modelName;
+        });
+
+        if (!moduleDefinition) {
+            throw new Error(
+                `Module definition not found for entity type: ${entityType}`
+            );
+        }
+
+        const module = new Module({
+            userId,
+            entity,
+            definition: moduleDefinition,
+        });
+
+        await module.refreshEntityOptions(options);
+        return module.getEntityOptions();
+    }
+}
+
+module.exports = { RefreshEntityOptions };

package/module-plugin/use-cases/test-module-auth.js

@@ -0,0 +1,54 @@
+const { Module } = require('../module');
+
+class TestModuleAuth {
+    /**
+ * @param {Object} params - Configuration parameters.
+ * @param {import('./module-repository').ModuleRepository} params.moduleRepository - Repository for module data operations.
+ * @param {Array<Object>} params.moduleDefinitions - Array of module definitions.
+ */
+    constructor({ moduleRepository, moduleDefinitions }) {
+        this.moduleRepository = moduleRepository;
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    async execute(entityId, userId) {
+        const entity = await this.moduleRepository.findEntityById(
+            entityId,
+            userId
+        );
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        if (entity.userId !== userId) {
+            throw new Error(
+                `Entity ${entityId} does not belong to user ${userId}`
+            );
+        }
+
+        const entityType = entity.type;
+        const moduleDefinition = this.moduleDefinitions.find((def) => {
+            const modelName = Module.getEntityModelFromDefinition(def).modelName;
+            return entityType === modelName;
+        });
+
+        if (!moduleDefinition) {
+            throw new Error(
+                `Module definition not found for entity type: ${entityType}`
+            );
+        }
+
+        const module = new Module({
+            userId,
+            entity,
+            definition: moduleDefinition,
+        });
+
+        const testAuthResponse = await module.testAuth();
+
+        return testAuthResponse;
+    }
+}
+
+module.exports = { TestModuleAuth };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/core",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.396.0dd37aa.0",
+  "version": "2.0.0--canary.397.216d54b.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.0dd37aa.0",
-    "@friggframework/prettier-config": "2.0.0--canary.396.0dd37aa.0",
-    "@friggframework/test": "2.0.0--canary.396.0dd37aa.0",
+    "@friggframework/eslint-config": "2.0.0--canary.397.216d54b.0",
+    "@friggframework/prettier-config": "2.0.0--canary.397.216d54b.0",
+    "@friggframework/test": "2.0.0--canary.397.216d54b.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": "0dd37aa78998c9291f90e3fdeb0e07096e2e140a"
+  "gitHead": "216d54b42aece5fa6473620fca6ee1ae11a46d8b"
 }