@friggframework/core 2.0.0--canary.405.1f6792c.0 → 2.0.0--canary.396.6862738.0

package/module-plugin/index.js

@@ -1,5 +1,4 @@
 const { Credential } = require('./credential');
-const { EntityManager } = require('./entity-manager');
 const { Entity } = require('./entity');
 const { ModuleManager } = require('./manager');
 const { ApiKeyRequester } = require('./requester/api-key');
@@ -8,11 +7,9 @@ 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,
-    EntityManager,
     Entity,
     ModuleManager,
     ApiKeyRequester,
@@ -21,5 +18,4 @@ module.exports = {
     Requester,
     ModuleConstants,
     ModuleFactory,
-    Auther
 };

package/module-plugin/module-factory.js

@@ -1,23 +1,16 @@
-const { Entity } = require('./entity');
-const { Auther } = require('./auther');
+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);
-    }
-
-    async getEntitiesForUser(userId) {
-        let results = [];
-        for (const moduleDefinition of this.moduleDefinitions) {
-            const moduleInstance = await Auther.getInstance({
-                userId,
-                definition: moduleDefinition,
-            });
-            const list = await moduleInstance.getEntitiesForUserId(userId);
-            results.push(...list);
-        }
-        return results;
+        this.moduleRepository = new ModuleRepository();
+        this.moduleService = new ModuleService({
+            moduleRepository: this.moduleRepository,
+            moduleDefinitions: this.moduleDefinitions,
+        });
     }
 
     checkIsValidType(entityType) {
@@ -29,29 +22,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.moduleService.getModuleInstance(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,70 @@
+const { Entity } = require('./entity');
+
+class ModuleRepository {
+    async findEntityById(entityId) {
+        const entity = await Entity.findById(entityId, undefined, { lean: true }).populate('credential');
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        return {
+            id: entity._id,
+            accountId: entity.accountId,
+            credential: entity.credential,
+            userId: entity.user.toString(),
+            name: entity.name,
+            externalId: entity.externalId,
+            type: entity.__t,
+            moduleName: entity.moduleName,
+        };
+    }
+
+    async findEntitiesByIds(entitiesIds) {
+        const entitiesRecords = await Entity.find({ _id: { $in: entitiesIds } }, '', { lean: true }).populate('credential');
+
+        // todo: this is a workaround needed while we create an integration with the same entity twice
+        if (entitiesRecords.length !== entitiesIds.length && entitiesIds[0] !== entitiesIds[1]) {
+            throw new Error(`Some entities not found`);
+        }
+
+        return entitiesRecords.map(e => ({
+            id: e._id,
+            accountId: e.accountId,
+            credential: e.credential,
+            userId: e.user.toString(),
+            name: e.name,
+            externalId: e.externalId,
+            type: e.__t,
+            moduleName: e.moduleName,
+        }));
+    }
+
+    async findEntitiesByUserId(userId) {
+        return Entity.find(
+            { user: userId },
+            '-dateCreated -dateUpdated -user -credentials -credential -__t -__v',
+            { lean: true }
+        );
+    }
+
+    async findEntitiesByIds(entityIds) {
+        const entities = await Entity.find(
+            { _id: { $in: entityIds } },
+            '',
+            { 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,
+        }));
+    }
+}
+
+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.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}`
+            );
+        }
+
+        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;
+        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;
+
+
+        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) {
@@ -205,20 +103,21 @@ class Auther extends Delegate {
         return this.CredentialModel;
     }
 
-    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,
-        }));
-    }
+    // 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();
@@ -233,18 +132,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"]
-        // }
         return this.api.getAuthorizationRequirements();
     }
 
-    async testAuth(params) {
+    async testAuth() {
         let validAuth = false;
         try {
             if (await this.testAuthRequest(this.api)) validAuth = true;
@@ -307,18 +198,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');
@@ -326,7 +205,7 @@ class Auther extends Delegate {
         if (search.length > 1) {
             throw new Error(
                 'Multiple entities found with the same identifiers: ' +
-                    JSON.stringify(identifiers)
+                JSON.stringify(identifiers)
             );
         } else if (search.length === 0) {
             this.entity = await this.EntityModel.create({
@@ -388,6 +267,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 }; 

package/module-plugin/test/mock-api/api.js

@@ -1,5 +1,5 @@
-const { get } = require('../../assertions');
-const { OAuth2Requester } = require('../../module-plugin');
+const { get } = require('../../../assertions');
+const { OAuth2Requester } = require('../..');
 
 class Api extends OAuth2Requester {
     constructor(params) {
@@ -23,7 +23,12 @@ class Api extends OAuth2Requester {
         return this.authorizationUri;
     }
 
-
+    getAuthorizationRequirements() {
+        return {
+            url: this.getAuthUri(),
+            type: 'oauth2',
+        };
+    }
 }
 
 module.exports = { Api };

package/module-plugin/test/mock-api/definition.js

@@ -1,19 +1,23 @@
 require('dotenv').config();
-const {Api} = require('./api');
-const {get} = require('../../assertions');
-const config = {name: 'anapi'}
+const { Api } = require('./api');
+const { get } = require('../../../assertions');
+const config = { name: 'anapi' }
 
 const Definition = {
     API: Api,
-    getName: function() {return config.name},
+    getAuthorizationRequirements: () => ({
+        url: 'http://localhost:3000/redirect/anapi',
+        type: 'oauth2',
+    }),
+    getName: function () { return config.name },
     moduleName: config.name,
     modelName: 'AnApi',
     requiredAuthMethods: {
-        getToken: async function(api, params){
+        getToken: async function (api, params) {
             const code = get(params.data, 'code');
             return api.getTokenFromCode(code);
         },
-        getEntityDetails: async function(api, callbackParams, tokenResponse, userId) {
+        getEntityDetails: async function (api, callbackParams, tokenResponse, userId) {
             const userDetails = await api.getUserDetails();
             return {
                 identifiers: { externalId: userDetails.portalId, user: userId },
@@ -26,14 +30,14 @@ const Definition = {
             ],
             entity: [],
         },
-        getCredentialDetails: async function(api, userId) {
+        getCredentialDetails: async function (api, userId) {
             const userDetails = await api.getUserDetails();
             return {
                 identifiers: { externalId: userDetails.portalId, user: userId },
                 details: {}
             };
         },
-        testAuthRequest: async function(api){
+        testAuthRequest: async function (api) {
             return api.getUserDetails()
         },
     },

package/module-plugin/use-cases/get-entities-for-user.js

@@ -0,0 +1,32 @@
+const { Module } = require('../module');
+const { mapModuleClassToModuleDTO } = require('../utils/map-module-dto');
+
+class GetEntitiesForUser {
+    constructor({ moduleRepository, moduleDefinitions }) {
+        this.moduleRepository = moduleRepository;
+
+        this.definitionMap = new Map();
+        for (const definition of moduleDefinitions) {
+            this.definitionMap.set(definition.modelName, definition);
+        }
+    }
+
+    async execute(userId) {
+        const entities = await this.moduleRepository.findEntitiesByUserId(
+            userId
+        );
+
+        return entities.map((entity) => {
+            const definition = this.definitionMap.get(entity.moduleName);
+
+            const moduleInstance = new Module({
+                userId,
+                definition: definition,
+                entity: entity,
+            });
+            return mapModuleClassToModuleDTO(moduleInstance);
+        });
+    }
+}
+
+module.exports = { GetEntitiesForUser }; 

package/module-plugin/utils/map-module-dto.js

@@ -0,0 +1,18 @@
+/**
+ * @param {import('../module').Module} moduleInstance
+ * Convert a Module domain instance to a plain DTO suitable for JSON responses.
+ */
+function mapModuleClassToModuleDTO(moduleInstance) {
+    if (!moduleInstance) return null;
+
+    return {
+        id: moduleInstance.entity._id.toString(),
+        name: moduleInstance.name,
+        userId: moduleInstance.userId,
+        entity: moduleInstance.entity,
+        credentialId: moduleInstance.credential?._id?.toString(),
+        type: moduleInstance.getName()
+    };
+}
+
+module.exports = { mapModuleClassToModuleDTO };