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

package/module-plugin/entity-manager.js

@@ -0,0 +1,70 @@
+const { loadInstalledModules, Delegate } = require('../core');
+
+const { Entity } = require('./entity');
+const { ModuleManager } = require('./manager');
+
+class EntityManager {
+    static primaryEntityClass = null; //primaryEntity;
+
+    static entityManagerClasses = loadInstalledModules().map(
+        (m) => m.EntityManager
+    );
+
+    static entityTypes = EntityManager.entityManagerClasses.map(
+        (ManagerClass) => ManagerClass.getName()
+    );
+
+    static async getEntitiesForUser(userId) {
+        const results = [];
+        for (const Manager of this.entityManagerClasses) {
+            results.push(...(await Manager.getEntitiesForUserId(userId)));
+        }
+        return results;
+    }
+
+    static checkIsValidType(entityType) {
+        const indexOfEntity = EntityManager.entityTypes.indexOf(entityType);
+        return indexOfEntity >= 0;
+    }
+
+    static getEntityManagerClass(entityType = '') {
+        const normalizedType = entityType.toLowerCase();
+
+        const indexOfEntityType =
+            EntityManager.entityTypes.indexOf(normalizedType);
+        if (!EntityManager.checkIsValidType(normalizedType)) {
+            throw new Error(
+                `Error: Invalid entity type of ${normalizedType}, options are ${EntityManager.entityTypes.join(
+                    ', '
+                )}`
+            );
+        }
+
+        const managerClass =
+            EntityManager.entityManagerClasses[indexOfEntityType];
+
+        if (!(managerClass.prototype instanceof ModuleManager)) {
+            throw new Error('The Entity is not an instance of ModuleManager');
+        }
+
+        return managerClass;
+    }
+
+    static async getEntityManagerInstanceFromEntityId(entityId, userId) {
+        const entityMO = new Entity();
+        const entity = await entityMO.get(entityId);
+        let entityManagerClass;
+        for (const Manager of this.entityManagerClasses) {
+            if (entity instanceof Manager.Entity.Model) {
+                entityManagerClass = Manager;
+            }
+        }
+        const instance = await entityManagerClass.getInstance({
+            userId,
+            entityId,
+        });
+        return instance;
+    }
+}
+
+module.exports = { EntityManager };

package/{modules → module-plugin}/entity.js

@@ -13,7 +13,6 @@ const schema = new mongoose.Schema(
             required: false,
         },
         name: { type: String },
-        moduleName: { type: String },
         externalId: { type: String },
     },
     { timestamps: true }

package/{modules → module-plugin}/index.js

@@ -1,17 +1,25 @@
 const { Credential } = require('./credential');
+const { EntityManager } = require('./entity-manager');
 const { Entity } = require('./entity');
+const { ModuleManager } = require('./manager');
 const { ApiKeyRequester } = require('./requester/api-key');
 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');
+const { Auther } = require('./auther');
 
 module.exports = {
     Credential,
+    EntityManager,
     Entity,
+    ModuleManager,
     ApiKeyRequester,
     BasicAuthRequester,
     OAuth2Requester,
     Requester,
     ModuleConstants,
+    ModuleFactory,
+    Auther
 };

package/module-plugin/manager.js

@@ -0,0 +1,169 @@
+const { Delegate } = require('../core');
+const { Credential } = require('./credential');
+const { Entity } = require('./entity');
+const { get } = require('../assertions');
+
+class ModuleManager extends Delegate {
+    static Entity = Entity;
+    static Credential = Credential;
+
+    constructor(params) {
+        super(params);
+        this.userId = get(params, 'userId', null); // Making this non-required
+    }
+
+    static getName() {
+        throw new Error('Module name is not defined');
+    }
+
+    static async getInstance(params) {
+        throw new Error(
+            'getInstance is not implemented. It is required for ModuleManager. '
+        );
+    }
+
+    static async getEntitiesForUserId(userId) {
+        // Only return non-internal fields. Leverages "select" and "options" to non-excepted fields and a pure object.
+        const list = await this.Entity.find(
+            { user: userId },
+            '-dateCreated -dateUpdated -user -credentials -credential -__t -__v',
+            { lean: true }
+        );
+        return list.map((entity) => ({
+            id: entity._id,
+            type: this.getName(),
+            ...entity,
+        }));
+    }
+
+    async getEntityId() {
+        const list = await Entity.find({ user: this.userId });
+        if (list.length > 1) {
+            throw new Error(
+                'There should not be more than one entity associated with a user for this specific class type'
+            );
+        }
+        if (list.length == 0) {
+            return null;
+        }
+        return list[0].id;
+    }
+
+    async validateAuthorizationRequirements() {
+        const requirements = await this.getAuthorizationRequirements();
+        let valid = true;
+        if (['oauth1', 'oauth2'].includes(requirements.type) && !requirements.url) {
+            valid = false;
+        }
+        return valid;
+    }
+
+    async getAuthorizationRequirements(params) {
+        // 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"]
+        // }
+        throw new Error(
+            'Authorization requirements method getAuthorizationRequirements() is not defined in the class'
+        );
+    }
+
+    async testAuth(params) {
+        // this function must invoke a method on the API using authentication
+        // if it fails, an exception should be thrown
+        throw new Error(
+            'Authentication test method testAuth() is not defined in the class'
+        );
+    }
+
+    async processAuthorizationCallback(params) {
+        // this function takes in a dictionary of callback information along with
+        // a unique user id to associate with the entity in the form of
+        // {
+        //   userId: "some id",
+        //   data: {}
+        // }
+
+        throw new Error(
+            'Authorization requirements method processAuthorizationCallback() is not defined in the class'
+        );
+    }
+
+    //----------------------------------------------------------------------------------------------------
+    // optional
+
+    async getEntityOptions() {
+        // May not be needed if the callback already creates the entity, such as in situations
+        // like HubSpot where the account is determined in the authorization flow.
+        // This should only be used in situations such as FreshBooks where the user needs to make
+        // an account decision on the front end.
+        throw new Error(
+            'Entity requirement method getEntityOptions() is not defined in the class'
+        );
+    }
+
+    async findOrCreateEntity(params) {
+        // May not be needed if the callback already creates the entity, such as in situations
+        // like HubSpot where the account is determined in the authorization flow.
+        // This should only be used in situations such as FreshBooks where the user needs to make
+        // an account decision on the front end.
+        throw new Error(
+            'Entity requirement method findOrCreateEntity() is not defined in the class'
+        );
+    }
+
+    async getAllSyncObjects(SyncClass) {
+        // takes in a Sync class and will return all objects associated with the SyncClass in an array
+        // in the form of
+        // [
+        //      {...object1},{...object2}...
+        // ]
+
+        throw new Error(
+            'The method "getAllSyncObjects()" is not defined in the class'
+        );
+    }
+
+    async batchCreateSyncObjects(syncObjects, syncManager) {
+        // takes in an array of Sync objects that has two pieces of data that
+        // are important to the updating module:
+        // 1. obj.data -> The data mapped to the obj.keys data
+        // 2. obj.syncId -> the id of the newly created sync object in our database. You will need to update
+        //                  the sync object in the database with the your id associated with this data. You
+        //                  can do this by calling the SyncManager function updateSyncObject.
+        // [
+        //      syncObject1,syncObject2, ...
+        // ]
+
+        throw new Error(
+            'The method "batchUpdateSyncObjects()" is not defined in the class'
+        );
+    }
+
+    async batchUpdateSyncObjects(syncObjects, syncManager) {
+        // takes in an array of Sync objects that has two pieces of data that
+        // are important to the updating module:
+        // 1. obj.data -> The data mapped to the obj.keys data
+        // 2. obj.moduleObjectIds[this.constructor.getName()] -> Indexed from the point of view of the module manager
+        //                                                   it will return a json object holding all of the keys
+        //                                                   required update this datapoint. an example would be:
+        //                                                   {companyId:12, email:"test@test.com"}
+        // [
+        //      syncObject1,syncObject2, ...
+        // ]
+
+        throw new Error(
+            'The method "batchUpdateSyncObjects()" is not defined in the class'
+        );
+    }
+
+    async markCredentialsInvalid() {
+        this.credential.auth_is_valid = false;
+        return await this.credential.save();
+    }
+}
+
+module.exports = { ModuleManager };

package/module-plugin/module-factory.js

@@ -0,0 +1,61 @@
+const { Entity } = require('./entity');
+const { Auther } = require('./auther');
+
+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;
+    }
+
+    checkIsValidType(entityType) {
+        return this.moduleTypes.includes(entityType);
+    }
+
+    getModuleDefinitionFromTypeName(typeName) {
+        return;
+    }
+
+    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,
+        });
+    }
+
+    async getInstanceFromTypeName(typeName, userId) {
+        const moduleDefinition = this.moduleDefinitions.find(
+            (def) => def.getName() === typeName
+        );
+        return await Auther.getInstance({
+            userId,
+            definition: moduleDefinition,
+        });
+    }
+}
+
+module.exports = { ModuleFactory };

package/{modules → module-plugin}/test/mock-api/api.js

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

package/{modules → module-plugin}/test/mock-api/definition.js

@@ -1,23 +1,19 @@
 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,
-    getAuthorizationRequirements: () => ({
-        url: 'http://localhost:3000/redirect/anapi',
-        type: 'oauth2',
-    }),
-    getName: function () { return config.name },
+    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 },
@@ -30,14 +26,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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/core",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.395.65f5f64.0",
+  "version": "2.0.0--canary.398.24926ac.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.395.65f5f64.0",
-    "@friggframework/prettier-config": "2.0.0--canary.395.65f5f64.0",
-    "@friggframework/test": "2.0.0--canary.395.65f5f64.0",
+    "@friggframework/eslint-config": "2.0.0--canary.398.24926ac.0",
+    "@friggframework/prettier-config": "2.0.0--canary.398.24926ac.0",
+    "@friggframework/test": "2.0.0--canary.398.24926ac.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": "65f5f647659c08514933a2d07a2a11f1a6fad87a"
+  "gitHead": "24926ace5bdfefc9187ad658f26a3c67d6f8ec96"
 }

package/syncs/sync.js

@@ -1,4 +1,5 @@
 const md5 = require("md5");
+const ModuleManager = require('../module-plugin');
 const { debug } = require("packages/logs");
 const { get } = require("packages/assertions");
 

package/types/integrations/index.d.ts

@@ -1,6 +1,7 @@
 declare module "@friggframework/integrations" {
   import { Delegate, IFriggDelegate } from "@friggframework/core";
   import { Model } from "mongoose";
+  import { EntityManager } from "@friggframework/module-plugin";
 
   export class Integration extends Model {
     entities: any[];
@@ -18,7 +19,8 @@ declare module "@friggframework/integrations" {
 
   export class IntegrationManager
     extends Delegate
-    implements IFriggIntegrationManager {
+    implements IFriggIntegrationManager
+  {
     integration: Integration;
     primaryInstance: any;
     targetInstance: any;
@@ -54,6 +56,7 @@ declare module "@friggframework/integrations" {
       entities: { id: string; user: any },
       userId: string,
       config: any,
+      EntityManager: EntityManager
     ): Promise<any>;
 
     static getFormattedIntegration(
@@ -113,7 +116,8 @@ declare module "@friggframework/integrations" {
   }
 
   export class IntegrationConfigManager
-    implements IFriggIntegrationConfigManager {
+    implements IFriggIntegrationConfigManager
+  {
     options: IntegrationOptions[];
     primary: any;
 

package/types/module-plugin/index.d.ts

@@ -9,7 +9,21 @@ declare module "@friggframework/module-plugin" {
     externalId: string;
   }
 
-  interface IFriggEntityManager { }
+  export class EntityManager implements IFriggEntityManager {
+    static primaryEntityClass: any;
+    static entityManagerClasses: any[];
+    static entityTypes: string[];
+    static getEntitiesForUser(userId: string): Promise<any[]>;
+    static checkIsValidType(entityType: string): boolean;
+    static getEntityManagerClass(entityType?: string): any;
+
+    static getEntityManagerInstanceFromEntityId(
+      entityId: string,
+      userId: string
+    ): Promise<any>;
+  }
+
+  interface IFriggEntityManager {}
 
   export class Entity extends Model {
     credentialId: string;
@@ -20,7 +34,42 @@ declare module "@friggframework/module-plugin" {
   }
 
   export type MappedEntity = Entity & { id: string; type: any };
+  export class ModuleManager extends Delegate implements IFriggModuleManager {
+    static Entity: Entity;
+    static Credential: Credential;
+
+    constructor(params: { userId: string });
 
+    static getName(): any;
+    static getInstance(params: any): Promise<any>;
+    static getEntitiesForUserId(userId: string): Promise<MappedEntity[]>;
+
+    batchCreateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
+    batchUpdateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
+    findOrCreateEntity(params: any): Promise<any>;
+    getAllSyncObjects(SyncClass: any): Promise<any>;
+    getAuthorizationRequirements(params: any): Promise<any>;
+    getEntityId(): Promise<string>;
+    getEntityOptions(): Promise<any>;
+    markCredentialsInvalid(): Promise<Credential>;
+    processAuthorizationCallback(params: any): Promise<any>;
+    testAuth(params: any): Promise<any>;
+    validateAuthorizationRequirements(): Promise<boolean>;
+  }
+
+  interface IFriggModuleManager extends IFriggDelegate {
+    getEntityId(): Promise<string>;
+    validateAuthorizationRequirements(): Promise<boolean>;
+    getAuthorizationRequirements(params: any): Promise<any>;
+    testAuth(params: any): Promise<any>;
+    processAuthorizationCallback(params: any): Promise<any>;
+    getEntityOptions(): Promise<any>;
+    findOrCreateEntity(params: any): Promise<any>;
+    getAllSyncObjects(SyncClass: any): Promise<any>;
+    batchCreateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
+    batchUpdateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
+    markCredentialsInvalid(): Promise<Credential>;
+  }
 
   export class Requester implements IFriggRequester {
     DLGT_INVALID_AUTH: string;
@@ -89,7 +138,8 @@ declare module "@friggframework/module-plugin" {
 
   export class ApiKeyRequester
     extends Requester
-    implements IFriggApiKeyRequester {
+    implements IFriggApiKeyRequester
+  {
     API_KEY_NAME: string;
     API_KEY_VALUE: any;
 
@@ -110,7 +160,8 @@ declare module "@friggframework/module-plugin" {
 
   export class BasicAuthRequester
     extends Requester
-    implements IFriggBasicAuthRequester {
+    implements IFriggBasicAuthRequester
+  {
     password: string;
     username: string;
 
@@ -138,7 +189,8 @@ declare module "@friggframework/module-plugin" {
 
   export class OAuth2Requester
     extends Requester
-    implements IFriggOAuth2Requester {
+    implements IFriggOAuth2Requester
+  {
     DLGT_TOKEN_DEAUTHORIZED: string;
     DLGT_TOKEN_UPDATE: string;
     accessTokenExpire: any;

package/types/syncs/index.d.ts

@@ -28,6 +28,7 @@ declare module "@friggframework/syncs/manager" {
     confirmCreate(
       syncObj: Sync,
       createdId: string,
+      moduleManager: any
     ): Promise<any>;
     confirmUpdate(syncObj: Sync): Promise<any>;
     createSyncDBObject(objArr: any[], entities: any[]): Promise<any>;
@@ -49,6 +50,7 @@ declare module "@friggframework/syncs/manager" {
     confirmCreate(
       syncObj: Sync,
       createdId: string,
+      moduleManager: any
     ): Promise<any>;
     confirmUpdate(syncObj: Sync): Promise<any>;
   }

package/credential/credential-repository.js

@@ -1,56 +0,0 @@
-const { Credential } = require('../modules');
-
-class CredentialRepository {
-    async findCredentialById(id) {
-        return Credential.findById(id);
-    }
-
-    async updateAuthenticationStatus(credentialId, authIsValid) {
-        return Credential.updateOne({ _id: credentialId }, { $set: { auth_is_valid: authIsValid } });
-    }
-
-    /**
-     * Permanently remove a credential document.
-     * @param {string} credentialId
-     * @returns {Promise<import('mongoose').DeleteResult>}
-     */
-    async deleteCredentialById(credentialId) {
-        return Credential.deleteOne({ _id: credentialId });
-    }
-
-    /**
-     * Create a new credential or update an existing one matching the identifiers.
-     * `credentialDetails` format: { identifiers: { ... }, details: { ... } }
-     * Identifiers are used in the query filter; details are merged into the document.
-     * @param {{identifiers: Object, details: Object}} credentialDetails
-     * @returns {Promise<Object>} The persisted credential (lean object)
-     */
-    async upsertCredential(credentialDetails) {
-        const { identifiers, details } = credentialDetails;
-        if (!identifiers) throw new Error('identifiers required to upsert credential');
-
-        const query = { ...identifiers };
-
-        const update = { $set: { ...details } };
-
-        const options = {
-            upsert: true,
-            new: true,
-            setDefaultsOnInsert: true,
-            lean: true,
-            strict: false,
-        };
-
-        const credential = await Credential.findOneAndUpdate(query, update, options);
-        return {
-            id: credential._id.toString(),
-            externalId: credential.externalId,
-            userId: credential.user.toString(),
-            auth_is_valid: credential.auth_is_valid,
-            access_token: credential.access_token,
-            refresh_token: credential.refresh_token,
-        }
-    }
-}
-
-module.exports = { CredentialRepository };

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

@@ -1,21 +0,0 @@
-class GetCredentialForUser {
-    constructor({ credentialRepository }) {
-        this.credentialRepository = credentialRepository;
-    }
-
-    async execute(credentialId, userId) {
-        const credential = await this.credentialRepository.findCredentialById(credentialId);
-
-        if (!credential) {
-            throw new Error(`Credential with id ${credentialId} not found`);
-        }
-
-        if (credential.user.toString() !== userId.toString()) {
-            throw new Error(`Credential ${credentialId} does not belong to user ${userId}`);
-        }
-
-        return credential;
-    }
-}
-
-module.exports = { GetCredentialForUser };

package/credential/use-cases/update-authentication-status.js

@@ -1,15 +0,0 @@
-class UpdateAuthenticationStatus {
-    constructor({ credentialRepository }) {
-        this.credentialRepository = credentialRepository;
-    }
-
-    /**
-     * @param {string} credentialId
-     * @param {boolean} authIsValid
-     */
-    async execute(credentialId, authIsValid) {
-        await this.credentialRepository.updateAuthenticationStatus(credentialId, authIsValid);
-    }
-}
-
-module.exports = { UpdateAuthenticationStatus };