@friggframework/core 2.0.0--canary.396.469364a.0 → 2.0.0--canary.397.3d4865d.0

package/index.js

@@ -52,7 +52,6 @@ const {
     OAuth2Requester,
     Requester,
     ModuleConstants,
-    ModuleFactory,
 } = require('./module-plugin/index');
 const utils = require('./utils');
 
@@ -124,7 +123,6 @@ module.exports = {
     OAuth2Requester,
     Requester,
     ModuleConstants,
-    ModuleFactory,
     // queues
     QueuerUtil,
 

package/integrations/integration-router.js

@@ -15,6 +15,12 @@ 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');
+const { GetModuleInstanceFromType } = require('../module-plugin/use-cases/get-module-instance-from-type');
+const { GetEntityOptionsByType } = require('../module-plugin/use-cases/get-entity-options-by-type');
+const { TestModuleAuth } = require('../module-plugin/use-cases/test-module-auth');
+const { GetModule } = require('../module-plugin/use-cases/get-module');
+const { GetEntityOptionsById } = require('../module-plugin/use-cases/get-entity-options-by-id');
+const { RefreshEntityOptions } = require('../module-plugin/use-cases/refresh-entity-options');
 
 /**
  * Creates an Express router with integration and entity routes configured
@@ -70,8 +76,35 @@ function createIntegrationRouter(params) {
         moduleService,
     });
 
+    const getModuleInstanceFromType = new GetModuleInstanceFromType({
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
+    const getEntityOptionsByType = new GetEntityOptionsByType({
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
+    const testModuleAuth = new TestModuleAuth({
+        moduleRepository,
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
+    const getModule = new GetModule({
+        moduleRepository,
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
+    const getEntityOptionsById = new GetEntityOptionsById({
+        moduleRepository,
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
+    const refreshEntityOptions = new RefreshEntityOptions({
+        moduleRepository,
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
     const router = get(params, 'router', express());
-    const factory = get(params, 'factory');
     const getUserFromBearerToken = get(params, 'getUserFromBearerToken');
 
     setIntegrationRoutes(router, getUserFromBearerToken, {
@@ -82,8 +115,14 @@ function createIntegrationRouter(params) {
         getIntegrationInstance,
         updateIntegration,
     });
-    setEntityRoutes(router, factory, getUserFromBearerToken, {
+    setEntityRoutes(router, getUserFromBearerToken, {
         getCredentialForUser,
+        getModuleInstanceFromType,
+        getEntityOptionsByType,
+        testModuleAuth,
+        getModule,
+        getEntityOptionsById,
+        refreshEntityOptions,
     });
     return router;
 }
@@ -348,25 +387,18 @@ function setIntegrationRoutes(router, getUserFromBearerToken, useCases) {
 /**
  * Sets up entity-related routes for the integration router
  * @param {Object} router - Express router instance
- * @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, useCases) {
-    const { moduleFactory } = factory;
-    const { getCredentialForUser } = useCases;
-    const getModuleInstance = async (userId, entityType) => {
-        if (!moduleFactory.checkIsValidType(entityType)) {
-            throw Boom.badRequest(
-                `Error: Invalid entity type of ${entityType}, options are ${moduleFactory.moduleTypes.join(
-                    ', '
-                )}`
-            );
-        }
-        return await moduleFactory.getInstanceFromTypeName(
-            entityType,
-            userId
-        );
-    };
+function setEntityRoutes(router, getUserFromBearerToken, useCases) {
+    const {
+        getCredentialForUser,
+        getModuleInstanceFromType,
+        getEntityOptionsByType,
+        testModuleAuth,
+        getModule,
+        getEntityOptionsById,
+        refreshEntityOptions,
+    } = useCases;
 
     router.route('/api/authorize').get(
         catchAsyncError(async (req, res) => {
@@ -375,7 +407,7 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
             );
             const userId = user.getId();
             const params = checkRequiredParams(req.query, ['entityType']);
-            const module = await getModuleInstance(userId, params.entityType);
+            const module = await getModuleInstanceFromType.execute(userId, params.entityType);
             const areRequirementsValid =
                 module.validateAuthorizationRequirements();
             if (!areRequirementsValid) {
@@ -398,7 +430,7 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
                 'entityType',
                 'data',
             ]);
-            const module = await getModuleInstance(userId, params.entityType);
+            const module = await getModuleInstanceFromType.execute(userId, params.entityType);
 
             res.json(
                 await module.processAuthorizationCallback({
@@ -431,7 +463,7 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
                 throw Boom.badRequest('Invalid credential ID');
             }
 
-            const module = await getModuleInstance(userId, params.entityType);
+            const module = await getModuleInstanceFromType.execute(userId, params.entityType);
             const entityDetails = await module.getEntityDetails(
                 module.api,
                 null,
@@ -460,9 +492,9 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
             }
 
             const params = checkRequiredParams(req.query, ['entityType']);
-            const module = await getModuleInstance(userId, params.entityType);
+            const entityOptions = await getEntityOptionsByType.execute(userId, params.entityType);
 
-            res.json(await module.getEntityOptions());
+            res.json(entityOptions);
         })
     );
 
@@ -473,17 +505,11 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
             );
             const userId = user.getId();
             const params = checkRequiredParams(req.params, ['entityId']);
-            const module = await moduleFactory.getModuleInstanceFromEntityId(
+            const testAuthResponse = await testModuleAuth.execute(
                 params.entityId,
                 userId
             );
 
-            if (!module) {
-                throw Boom.notFound();
-            }
-
-            const testAuthResponse = await module.testAuth();
-
             if (!testAuthResponse) {
                 res.status(400);
                 res.json({
@@ -508,16 +534,12 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
             );
             const userId = user.getId();
             const params = checkRequiredParams(req.params, ['entityId']);
-            const module = await moduleFactory.getModuleInstanceFromEntityId(
+            const module = await getModule.execute(
                 params.entityId,
                 userId
             );
 
-            if (!module) {
-                throw Boom.notFound();
-            }
-
-            res.json(module.entity);
+            res.json(module);
         })
     );
 
@@ -530,16 +552,10 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
             const params = checkRequiredParams(req.params, [
                 'entityId',
             ]);
-            const module = await moduleFactory.getModuleInstanceFromEntityId(
-                params.entityId,
-                userId
-            );
 
-            if (!module) {
-                throw Boom.notFound();
-            }
+            const entityOptions = await getEntityOptionsById.execute(params.entityId, userId);
 
-            res.json(await module.getEntityOptions());
+            res.json(entityOptions);
         })
     );
 
@@ -552,16 +568,13 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
             const params = checkRequiredParams(req.params, [
                 'entityId',
             ]);
-            const module = await moduleFactory.getModuleInstanceFromEntityId(
+            const updatedOptions = await refreshEntityOptions.execute(
                 params.entityId,
-                userId
+                userId,
+                req.body
             );
 
-            if (!module) {
-                throw Boom.notFound();
-            }
-
-            res.json(await module.refreshEntityOptions(req.body));
+            res.json(updatedOptions);
         })
     );
 }

package/integrations/integration.js

@@ -116,13 +116,15 @@ class Integration {
             // 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);
+            let proto = Object.getPrototypeOf(this.behavior);
+            while (proto && proto !== Object.prototype) {
+                for (const key of Object.getOwnPropertyNames(proto)) {
+                    if (key === 'constructor') continue;
+                    if (typeof proto[key] === 'function' && this[key] === undefined) {
+                        this[key] = proto[key].bind(this.behavior);
+                    }
                 }
+                proto = Object.getPrototypeOf(proto);
             }
         }
     }

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.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.469364a.0",
+  "version": "2.0.0--canary.397.3d4865d.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.469364a.0",
-    "@friggframework/prettier-config": "2.0.0--canary.396.469364a.0",
-    "@friggframework/test": "2.0.0--canary.396.469364a.0",
+    "@friggframework/eslint-config": "2.0.0--canary.397.3d4865d.0",
+    "@friggframework/prettier-config": "2.0.0--canary.397.3d4865d.0",
+    "@friggframework/test": "2.0.0--canary.397.3d4865d.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": "469364a7e870439540866a1a8f35107e9e2aef18"
+  "gitHead": "3d4865d4a752858baaa1f723ca9d07b38bfd7e5e"
 }

package/module-plugin/module-factory.js

@@ -1,42 +0,0 @@
-const { ModuleRepository } = require('./module-repository');
-const { ModuleService } = require('./module-service');
-const { Module } = require('./module');
-
-class ModuleFactory {
-    constructor(...params) {
-        this.moduleDefinitions = params;
-        this.moduleTypes = this.moduleDefinitions.map((def) => def.moduleName);
-        this.moduleRepository = new ModuleRepository();
-        this.moduleService = new ModuleService({
-            moduleRepository: this.moduleRepository,
-            moduleDefinitions: this.moduleDefinitions,
-        });
-    }
-
-    checkIsValidType(entityType) {
-        return this.moduleTypes.includes(entityType);
-    }
-
-    getModuleDefinitionFromTypeName(typeName) {
-        return;
-    }
-
-    async getModuleInstanceFromEntityId(entityId, userId) {
-        return this.moduleService.getModuleInstance(entityId, userId);
-    }
-
-    async getInstanceFromTypeName(typeName, userId) {
-        const moduleDefinition = this.moduleDefinitions.find(
-            (def) => def.getName() === typeName
-        );
-        if (!moduleDefinition) {
-            throw new Error(`Module definition not found for type: ${typeName}`);
-        }
-        return new Module({
-            userId,
-            definition: moduleDefinition,
-        });
-    }
-}
-
-module.exports = { ModuleFactory };