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

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

@@ -0,0 +1,49 @@
+const { Integration } = require('../integration');
+
+class CreateIntegration {
+    /**
+     * @param {Object} params
+     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository
+     * @param {import('../integration-classes').IntegrationClasses} params.integrationClasses
+     * @param {import('../../module-plugin/module-service').ModuleService} params.moduleService
+     */
+    constructor({ integrationRepository, integrationClasses, moduleService }) {
+        this.integrationRepository = integrationRepository;
+        this.integrationClasses = integrationClasses;
+        this.moduleService = moduleService;
+    }
+
+    async execute(entities, userId, config) {
+        const integrationRecord = await this.integrationRepository.createIntegration(entities, userId, config);
+
+        const modules = {};
+        for (const [entityId, key] of Object.entries(integrationRecord.entityReference)) {
+            const moduleInstance = await this.moduleService.getModuleInstance(
+                entityId,
+                integrationRecord.user
+            );
+            modules[key] = moduleInstance;
+        }
+
+        const integration = new Integration({
+            id: integrationRecord.id,
+            userId: integrationRecord.user,
+            entities: integrationRecord.entities,
+            config: integrationRecord.config,
+            status: integrationRecord.status,
+            version: integrationRecord.version,
+            messages: integrationRecord.messages,
+            entityReference: integrationRecord.entityReference,
+            integrationClass: this.integrationClasses[integrationRecord.config.type], // todo: check if this is correct
+            modules
+        });
+
+
+        // load dynamic user actions and register event handlers
+        await integration.initialize();
+
+        return integration;
+    }
+}
+
+module.exports = { CreateIntegration }; 

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

@@ -0,0 +1,27 @@
+class DeleteIntegrationForUser {
+    constructor({ integrationRepository }) {
+
+        /**
+         * @type {import('../integration-repository').IntegrationRepository}
+         */
+        this.integrationRepository = integrationRepository;
+    }
+
+    async execute(integrationId, userId) {
+        const integration = await this.integrationRepository.findIntegrationById(integrationId);
+
+        if (!integration) {
+            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');
+        }
+
+        await this.integrationRepository.deleteIntegrationById(integrationId);
+    }
+}
+
+module.exports = { DeleteIntegrationForUser }; 

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

@@ -0,0 +1,30 @@
+class GetIntegrationForUser {
+    constructor({ integrationRepository }) {
+
+        /**
+         * @type {import('../integration-repository').IntegrationRepository}
+         */
+        this.integrationRepository = integrationRepository;
+    }
+
+    /**
+     * @param {string} integrationId
+     * @param {string} userId
+     * @returns {Promise<Integration>}
+     */
+    async execute(integrationId, userId) {
+        const integration = await this.integrationRepository.findIntegrationById(integrationId);
+
+        if (!integration) {
+            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');
+        }
+
+        return integration;
+    }
+}
+
+module.exports = { GetIntegrationForUser }; 

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

@@ -0,0 +1,77 @@
+const { Integration } = require('../integration');
+const { ModuleService } = require('../../module-plugin/module-service');
+
+
+// todo: remove this use case
+class GetIntegrationInstance {
+    constructor({
+        integrationRepository,
+        integrationClasses,
+        moduleService,
+    }) {
+        this.integrationRepository = integrationRepository;
+        this.integrationClasses = integrationClasses;
+        this.moduleService = moduleService;
+
+        // Build type mapping for quick lookup
+        this.integrationTypeMap = new Map();
+        this.integrationClasses.forEach((IntegrationClass) => {
+            this.integrationTypeMap.set(IntegrationClass.getName(), IntegrationClass);
+        });
+    }
+
+    // todo: check if this is really all we need to instantiate an integration instance
+    async execute(integrationId, userId) {
+        // 1. Get integration record from repository
+        const integrationRecord = await this.integrationRepository.findIntegrationById(integrationId);
+
+        if (!integrationRecord) {
+            throw new Error(`No integration found by the ID of ${integrationId}`);
+        }
+
+        // 2. Get the correct Integration class by type
+        const IntegrationClass = this.integrationTypeMap.get(integrationRecord.config.type);
+
+        if (!IntegrationClass) {
+            throw new Error(`No integration class found for type: ${integrationRecord.config.type}`);
+        }
+
+        if (!integrationRecord.user.equals(userId)) {
+            throw new Error(
+                `Integration ${integrationId} does not belong to User ${userId}`
+            );
+        }
+
+        // 3. Load modules based on entity references
+        const modules = {};
+        for (const [entityId, key] of Object.entries(integrationRecord.entityReference)) {
+            const moduleInstance = await this.moduleService.getModuleInstance(
+                entityId,
+                integrationRecord.user
+            );
+            modules[key] = moduleInstance;
+        }
+
+        // 4. Create the Integration domain entity with modules
+        const integration = new Integration({
+            id: integrationRecord.id,
+            userId: integrationRecord.user,
+            entities: integrationRecord.entities,
+            config: integrationRecord.config,
+            status: integrationRecord.status,
+            version: integrationRecord.version,
+            messages: integrationRecord.messages,
+            entityReference: integrationRecord.entityReference,
+            integrationClass: IntegrationClass,
+            modules
+        });
+
+
+        // 6. Complete async initialization (load dynamic actions, register handlers)
+        await integration.initialize();
+
+        return integration;
+    }
+}
+
+module.exports = { GetIntegrationInstance }; 

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

@@ -0,0 +1,19 @@
+class GetIntegrationsForUser {
+    constructor({ integrationRepository }) {
+
+        /**
+         * @type {import('../integration-repository').IntegrationRepository}
+         */
+        this.integrationRepository = integrationRepository;
+    }
+
+    /**
+     * @param {string} userId
+     * @returns {Promise<Integration[]>}
+     */
+    async execute(userId) {
+        return this.integrationRepository.findIntegrationsByUserId(userId);
+    }
+}
+
+module.exports = { GetIntegrationsForUser }; 

package/integrations/use-cases/index.js

@@ -0,0 +1,15 @@
+const { GetIntegrationsForUserId } = require('./get-integrations-for-user');
+const { DeleteIntegrationForUserById } = require('./delete-integration-for-user-by-id');
+const { GetIntegrationById } = require('./get-integration-by-id');
+const { ListCredentials } = require('./list-credentials');
+const { CreateIntegration } = require('./create-integration');
+const { GetIntegrationInstance } = require('./get-integration-instance');
+
+module.exports = {
+    GetIntegrationsForUserId,
+    DeleteIntegrationForUserById,
+    GetIntegrationById,
+    ListCredentials,
+    CreateIntegration,
+    GetIntegrationInstance,
+}; 

package/module-plugin/index.js

@@ -8,7 +8,6 @@ const { OAuth2Requester } = require('./requester/oauth-2');
 const { Requester } = require('./requester/requester');
 const { ModuleConstants } = require('./ModuleConstants');
 const { ModuleFactory } = require('./module-factory');
-const { Auther } = require('./auther');
 
 module.exports = {
     Credential,
@@ -21,5 +20,4 @@ module.exports = {
     Requester,
     ModuleConstants,
     ModuleFactory,
-    Auther
 };

package/module-plugin/module-factory.js

@@ -1,16 +1,22 @@
-const { Entity } = require('./entity');
-const { Auther } = require('./auther');
+const { ModuleRepository } = require('./module-repository');
+const { GetModuleInstance } = require('./use-cases/get-module-instance');
+const { Module } = require('./module');
 
 class ModuleFactory {
     constructor(...params) {
         this.moduleDefinitions = params;
         this.moduleTypes = this.moduleDefinitions.map((def) => def.moduleName);
+        this.moduleRepository = new ModuleRepository();
+        this.getModuleInstanceUseCase = new GetModuleInstance({
+            moduleRepository: this.moduleRepository,
+            moduleDefinitions: this.moduleDefinitions,
+        });
     }
 
     async getEntitiesForUser(userId) {
         let results = [];
         for (const moduleDefinition of this.moduleDefinitions) {
-            const moduleInstance = await Auther.getInstance({
+            const moduleInstance = new Module({
                 userId,
                 definition: moduleDefinition,
             });
@@ -29,29 +35,17 @@ class ModuleFactory {
     }
 
     async getModuleInstanceFromEntityId(entityId, userId) {
-        const entity = await Entity.findById(entityId);
-        const moduleDefinition = this.moduleDefinitions.find(
-            (def) =>
-                entity.toJSON()['__t'] ===
-                Auther.getEntityModelFromDefinition(def).modelName
-        );
-        if (!moduleDefinition) {
-            throw new Error(
-                'Module definition not found for entity type: ' + entity['__t']
-            );
-        }
-        return await Auther.getInstance({
-            userId,
-            entityId,
-            definition: moduleDefinition,
-        });
+        return this.getModuleInstanceUseCase.execute(entityId, userId);
     }
 
     async getInstanceFromTypeName(typeName, userId) {
         const moduleDefinition = this.moduleDefinitions.find(
             (def) => def.getName() === typeName
         );
-        return await Auther.getInstance({
+        if (!moduleDefinition) {
+            throw new Error(`Module definition not found for type: ${typeName}`);
+        }
+        return new Module({
             userId,
             definition: moduleDefinition,
         });

package/module-plugin/module-repository.js

@@ -0,0 +1,14 @@
+const { Entity } = require('./entity');
+
+class ModuleRepository {
+    async findEntityById(entityId) {
+        const entity = await Entity.findById(entityId).populate('credential');
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        return entity;
+    }
+}
+
+module.exports = { ModuleRepository }; 

package/module-plugin/module-service.js

@@ -0,0 +1,50 @@
+const { Module } = require('./module');
+
+class ModuleService {
+    /**
+     * @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 getModuleInstance(entityId, userId) {
+        const entity = await this.moduleRepository.findEntityById(
+            entityId,
+            userId
+        );
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        if (entity.user.toString() !== userId.toString()) {
+            throw new Error(
+                `Entity ${entityId} does not belong to user ${userId}`
+            );
+        }
+
+        const entityType = entity.toJSON().__t;
+        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}`
+            );
+        }
+
+        return new Module({
+            userId,
+            entity,
+            definition: moduleDefinition,
+        });
+    }
+}
+
+module.exports = { ModuleService }; 

package/module-plugin/{auther.js → module.js}

@@ -1,30 +1,3 @@
-// Manages authorization and credential persistence
-// Instantiation of an API Class
-// Expects input object like this:
-// const authDef = {
-//     API: class anAPI{},
-//     moduleName: 'anAPI', //maybe not required
-//     requiredAuthMethods: {
-//         // oauth methods, how to handle these being required/not?
-//         getToken: async function(params, callbackParams, tokenResponse) {},
-//         // required for all Auth methods
-//         getEntityDetails: async function(params) {}, //probably calls api method
-//         getCredentialDetails: async function(params) {}, // might be same as above
-//         apiParamsFromCredential: function(params) {},
-//         testAuth: async function() {}, // basic request to testAuth
-//     },
-//     env: {
-//         client_id: process.env.HUBSPOT_CLIENT_ID,
-//         client_secret: process.env.HUBSPOT_CLIENT_SECRET,
-//         scope: process.env.HUBSPOT_SCOPE,
-//         redirect_uri: `${process.env.REDIRECT_URI}/an-api`,
-//     }
-// };
-
-//TODO:
-// 1. Add definition of expected params to API Class (or could just be credential?)
-// 2.
-
 const { Delegate } = require('../core');
 const { get } = require('../assertions');
 const _ = require('lodash');
@@ -34,119 +7,44 @@ const { Entity } = require('./entity');
 const { mongoose } = require('../database/mongoose');
 const { ModuleConstants } = require('./ModuleConstants');
 
-class Auther extends Delegate {
-    static validateDefinition(definition) {
-        if (!definition) {
-            throw new Error('Auther definition is required');
-        }
-        if (!definition.moduleName) {
-            throw new Error('Auther definition requires moduleName');
-        }
-        if (!definition.API) {
-            throw new Error('Auther definition requires API class');
-        }
-        // if (!definition.Credential) {
-        //     throw new Error('Auther definition requires Credential class');
-        // }
-        // if (!definition.Entity) {
-        //     throw new Error('Auther definition requires Entity class');
-        // }
-        if (!definition.requiredAuthMethods) {
-            throw new Error('Auther definition requires requiredAuthMethods');
-        } else {
-            if (
-                definition.API.requesterType ===
-                ModuleConstants.authType.oauth2 &&
-                !definition.requiredAuthMethods.getToken
-            ) {
-                throw new Error(
-                    'Auther definition requires requiredAuthMethods.getToken'
-                );
-            }
-            if (!definition.requiredAuthMethods.getEntityDetails) {
-                throw new Error(
-                    'Auther definition requires requiredAuthMethods.getEntityDetails'
-                );
-            }
-            if (!definition.requiredAuthMethods.getCredentialDetails) {
-                throw new Error(
-                    'Auther definition requires requiredAuthMethods.getCredentialDetails'
-                );
-            }
-            if (!definition.requiredAuthMethods.apiPropertiesToPersist) {
-                throw new Error(
-                    'Auther definition requires requiredAuthMethods.apiPropertiesToPersist'
-                );
-            } else if (definition.Credential) {
-                for (const prop of definition.requiredAuthMethods
-                    .apiPropertiesToPersist?.credential) {
-                    if (
-                        !definition.Credential.schema.paths.hasOwnProperty(prop)
-                    ) {
-                        throw new Error(
-                            `Auther definition requires Credential schema to have property ${prop}`
-                        );
-                    }
-                }
-            }
-            if (!definition.requiredAuthMethods.testAuthRequest) {
-                throw new Error(
-                    'Auther definition requires requiredAuthMethods.testAuth'
-                );
-            }
-        }
-    }
+class Module extends Delegate {
+
+    /**
+     * 
+     * @param {Object} params
+     * @param {Object} params.definition The definition of the Api Module
+     * @param {string} params.userId The user id
+     * @param {Object} params.entity The entity record from the database
+     */
+    constructor({ definition, userId = null, entity: entityObj = null }) {
+        super({ definition, userId, entity: entityObj });
+
+        this.validateDefinition(definition);
+
+        this.userId = userId;
+        this.entity = entityObj.toObject();
+        this.credential = entityObj?.credential.toObject();
+        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;
+
+
+        Object.assign(this, this.definition.requiredAuthMethods);
+
+        this.CredentialModel = this.getCredentialModel();
+        this.EntityModel = this.getEntityModel();
 
-    constructor(params) {
-        super(params);
-        this.userId = get(params, 'userId', null); // Making this non-required
-        const definition = get(params, 'definition');
-        Auther.validateDefinition(definition);
-        Object.assign(this, definition.requiredAuthMethods);
-        if (definition.getEntityOptions) {
-            this.getEntityOptions = definition.getEntityOptions;
-        }
-        if (definition.refreshEntityOptions) {
-            this.refreshEntityOptions = definition.refreshEntityOptions;
-        }
-        this.name = definition.moduleName;
-        this.modelName = definition.modelName;
-        this.apiClass = definition.API;
-        this.CredentialModel =
-            definition.Credential || this.getCredentialModel();
-        this.EntityModel = definition.Entity || this.getEntityModel();
-    }
 
-    static async getInstance(params) {
-        const instance = new this(params);
-        if (params.entityId) {
-            instance.entity = await instance.EntityModel.findById(
-                params.entityId
-            );
-            instance.credential = await instance.CredentialModel.findById(
-                instance.entity.credential
-            );
-        } else if (params.credentialId) {
-            instance.credential = await instance.CredentialModel.findById(
-                params.credentialId
-            );
-        }
-        let credential = {};
-        let entity = {};
-        if (instance.credential) {
-            credential = instance.credential.toObject();
-        }
-        if (instance.entity) {
-            entity = instance.entity.toObject();
-        }
         const apiParams = {
-            ...params.definition.env,
-            delegate: instance,
-            ...instance.apiParamsFromCredential(credential),
-            ...instance.apiParamsFromEntity(entity),
+            ...this.definition.env,
+            delegate: this,
+            ...this.apiParamsFromCredential(this.credential),
+            ...this.apiParamsFromEntity(this.entity),
         };
-        instance.api = new instance.apiClass(apiParams);
-        return instance;
+        this.api = new this.apiClass(apiParams);
     }
 
     static getEntityModelFromDefinition(definition) {
@@ -233,19 +131,10 @@ class Auther extends Delegate {
     }
 
     async getAuthorizationRequirements(params) {
-        // TODO: How can this be more helpful both to implement and consume
-        // this function must return a dictionary with the following format
-        // node only url key is required. Data would be used for Base Authentication
-        // let returnData = {
-        //     url: "callback url for the data or teh redirect url for login",
-        //     type: one of the types defined in modules/Constants.js
-        //     data: ["required", "fields", "we", "may", "need"]
-        // }
-        console.log(this.api);
         return this.api.getAuthorizationRequirements();
     }
 
-    async testAuth(params) {
+    async testAuth() {
         let validAuth = false;
         try {
             if (await this.testAuthRequest(this.api)) validAuth = true;
@@ -308,18 +197,6 @@ class Auther extends Delegate {
         }
     }
 
-    async getEntityOptions() {
-        throw new Error(
-            'Method getEntityOptions() is not defined in the class'
-        );
-    }
-
-    async refreshEntityOptions() {
-        throw new Error(
-            'Method refreshEntityOptions() is not defined in the class'
-        );
-    }
-
     async findOrCreateEntity(entityDetails) {
         const identifiers = get(entityDetails, 'identifiers');
         const details = get(entityDetails, 'details');
@@ -389,6 +266,63 @@ class Auther extends Delegate {
             await this.entity.save();
         }
     }
+
+    // todo: check if all these props are still up to date
+    validateDefinition(definition) {
+        if (!definition) {
+            throw new Error('Module definition is required');
+        }
+        if (!definition.moduleName) {
+            throw new Error('Module definition requires moduleName');
+        }
+        if (!definition.API) {
+            throw new Error('Module definition requires API class');
+        }
+        if (!definition.requiredAuthMethods) {
+            throw new Error('Module definition requires requiredAuthMethods');
+        } else {
+            if (
+                definition.API.requesterType ===
+                ModuleConstants.authType.oauth2 &&
+                !definition.requiredAuthMethods.getToken
+            ) {
+                throw new Error(
+                    'Module definition requires requiredAuthMethods.getToken'
+                );
+            }
+            if (!definition.requiredAuthMethods.getEntityDetails) {
+                throw new Error(
+                    'Module definition requires requiredAuthMethods.getEntityDetails'
+                );
+            }
+            if (!definition.requiredAuthMethods.getCredentialDetails) {
+                throw new Error(
+                    'Module definition requires requiredAuthMethods.getCredentialDetails'
+                );
+            }
+            if (!definition.requiredAuthMethods.apiPropertiesToPersist) {
+                throw new Error(
+                    'Module definition requires requiredAuthMethods.apiPropertiesToPersist'
+                );
+            } else if (definition.Credential) {
+                for (const prop of definition.requiredAuthMethods
+                    .apiPropertiesToPersist?.credential) {
+                    if (
+                        !definition.Credential.schema.paths.hasOwnProperty(prop)
+                    ) {
+                        throw new Error(
+                            `Module definition requires Credential schema to have property ${prop}`
+                        );
+                    }
+                }
+            }
+            if (!definition.requiredAuthMethods.testAuthRequest) {
+                throw new Error(
+                    'Module definition requires requiredAuthMethods.testAuth'
+                );
+            }
+        }
+    }
 }
 
-module.exports = { Auther };
+module.exports = { Module };