@friggframework/core 2.0.0--canary.397.1b51778.0 → 2.0.0--canary.397.3862908.0

package/integrations/test/integration-base.test.js

@@ -2,10 +2,10 @@ const _ = require('lodash');
 const { mongoose } = require('../../database/mongoose');
 const { expect } = require('chai');
 const { IntegrationBase } = require("../integration-base");
-const {Credential} = require('../../module-plugin/credential');
-const {Entity} = require('../../module-plugin/entity');
+const { Credential } = require('../../module-plugin/credential');
+const { Entity } = require('../../module-plugin/entity');
 const { IntegrationMapping } = require('../integration-mapping')
-const {IntegrationModel} = require("../integration-model");
+const { IntegrationModel } = require("../integration-model");
 
 describe(`Should fully test the IntegrationBase Class`, () => {
     let integrationRecord;
@@ -93,15 +93,15 @@ describe(`Should fully test the IntegrationBase Class`, () => {
     describe('upsertIntegrationMapping()', () => {
         it('should throw error if sourceId is null', async () => {
             try {
-                await integration.upsertMapping( null, {});
+                await integration.upsertMapping(null, {});
                 fail('should have thrown error')
-            } catch(err) {
+            } catch (err) {
                 expect(err.message).to.contain('sourceId must be set');
             }
         });
 
         it('should return for empty mapping', async () => {
-            const mapping = await integration.upsertMapping( 'validId2', {});
+            const mapping = await integration.upsertMapping('validId2', {});
             expect(_.pick(mapping, ['integration', 'sourceId', 'mapping'])).to.eql({
                 integration: integrationRecord._id,
                 sourceId: 'validId2',

package/integrations/tests/doubles/dummy-integration-class.js

@@ -0,0 +1,11 @@
+const { IntegrationBase } = require('../../integration-base');
+
+class DummyIntegration extends IntegrationBase {
+    static Definition = {
+        name: 'dummy',
+        version: '1.0.0',
+        modules: {},
+    };
+}
+
+module.exports = { DummyIntegration }; 

package/integrations/tests/doubles/test-integration-repository.js

@@ -0,0 +1,52 @@
+const { v4: uuid } = require('uuid');
+
+class TestIntegrationRepository {
+    constructor() {
+        this.store = new Map();
+    }
+
+    async createIntegration(entities, userId, config) {
+        const id = uuid();
+        const record = {
+            id,
+            entitiesIds: entities,
+            userId,
+            config,
+            version: '0.0.0',
+            status: 'NEW',
+            messages: {},
+        };
+        this.store.set(id, record);
+        return record;
+    }
+
+    async findIntegrationById(id) {
+        const rec = this.store.get(id);
+        if (!rec) return null;
+        return rec;
+    }
+
+    async findIntegrationsByUserId(userId) {
+        return Array.from(this.store.values()).filter(r => r.userId === userId);
+    }
+
+    async updateIntegrationMessages(id, type, title, body, timestamp) {
+        const rec = this.store.get(id);
+        if (!rec) return false;
+        if (!rec.messages[type]) rec.messages[type] = [];
+        rec.messages[type].push({ title, message: body, timestamp });
+        return true;
+    }
+
+    async deleteIntegrationById(id) {
+        return this.store.delete(id);
+    }
+
+    async updateIntegrationStatus(id, status) {
+        const rec = this.store.get(id);
+        if (rec) rec.status = status;
+        return true;
+    }
+}
+
+module.exports = { TestIntegrationRepository }; 

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

@@ -0,0 +1,27 @@
+const { CreateIntegration } = require('../../use-cases/create-integration');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('CreateIntegration Use-Case', () => {
+    it('creates an integration and returns DTO', async () => {
+        const integrationRepository = new TestIntegrationRepository();
+        const moduleFactory = new TestModuleFactory();
+
+        const useCase = new CreateIntegration({
+            integrationRepository,
+            integrationClasses: [DummyIntegration],
+            moduleFactory,
+        });
+
+        const entities = ['entity-1'];
+        const userId = 'user-1';
+        const config = { type: 'dummy', foo: 'bar' };
+
+        const dto = await useCase.execute(entities, userId, config);
+
+        expect(dto.id).toBeDefined();
+        expect(dto.config).toEqual(config);
+        expect(dto.userId).toBe(userId);
+    });
+}); 

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

@@ -0,0 +1,20 @@
+const { DeleteIntegrationForUser } = require('../../use-cases/delete-integration-for-user');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('DeleteIntegrationForUser', () => {
+    it('deletes integration', async () => {
+        const repo = new TestIntegrationRepository();
+        const record = await repo.createIntegration(['e1'], 'user-1', { type: 'dummy' });
+
+        const useCase = new DeleteIntegrationForUser({
+            integrationRepository: repo,
+            integrationClasses: [DummyIntegration],
+        });
+
+        await useCase.execute(record.id, 'user-1');
+
+        const found = await repo.findIntegrationById(record.id);
+        expect(found).toBeNull();
+    });
+}); 

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

@@ -0,0 +1,29 @@
+const { GetIntegrationForUser } = require('../../use-cases/get-integration-for-user');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
+const { TestModuleRepository } = require('../../../modules/tests/doubles/test-module-repository');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+
+describe('GetIntegrationForUser', () => {
+    it('returns integration dto', async () => {
+        const iRepo = new TestIntegrationRepository();
+        const mRepo = new TestModuleRepository();
+        const mFactory = new TestModuleFactory();
+
+        const entity = { id: 'entity-1' };
+        mRepo.addEntity(entity);
+
+        const record = await iRepo.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+        const useCase = new GetIntegrationForUser({
+            integrationRepository: iRepo,
+            integrationClasses: [DummyIntegration],
+            moduleFactory: mFactory,
+            moduleRepository: mRepo,
+        });
+
+        const dto = await useCase.execute(record.id, 'user-1');
+        expect(dto.id).toBe(record.id);
+    });
+}); 

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

@@ -0,0 +1,26 @@
+const { GetIntegrationInstance } = require('../../use-cases/get-integration-instance');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('GetIntegrationInstance Use-Case', () => {
+    it('returns hydrated integration instance', async () => {
+        const integrationRepository = new TestIntegrationRepository();
+        const moduleFactory = new TestModuleFactory();
+
+        // first create record directly via repo
+        const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
+
+        const useCase = new GetIntegrationInstance({
+            integrationRepository,
+            integrationClasses: [DummyIntegration],
+            moduleFactory,
+        });
+
+        const instance = await useCase.execute(record.id, 'user-1');
+
+        expect(instance.id).toBe(record.id);
+        expect(instance.getConfig().type).toBe('dummy');
+        expect(instance.entities).toEqual(record.entitiesIds);
+    });
+}); 

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

@@ -0,0 +1,30 @@
+const { GetIntegrationsForUser } = require('../../use-cases/get-integrations-for-user');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
+const { TestModuleRepository } = require('../../../modules/tests/doubles/test-module-repository');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('GetIntegrationsForUser', () => {
+    it('returns integrations dto list', async () => {
+        const integrationRepo = new TestIntegrationRepository();
+        const moduleRepo = new TestModuleRepository();
+        const moduleFactory = new TestModuleFactory();
+
+        // setup entity and module repo
+        const entity = { id: 'entity-1' };
+        moduleRepo.addEntity(entity);
+
+        await integrationRepo.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+        const useCase = new GetIntegrationsForUser({
+            integrationRepository: integrationRepo,
+            integrationClasses: [DummyIntegration],
+            moduleFactory,
+            moduleRepository: moduleRepo,
+        });
+
+        const list = await useCase.execute('user-1');
+        expect(list.length).toBe(1);
+        expect(list[0].config.type).toBe('dummy');
+    });
+}); 

package/integrations/tests/use-cases/get-possible-integrations.test.js

@@ -0,0 +1,12 @@
+const { GetPossibleIntegrations } = require('../../use-cases/get-possible-integrations');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('GetPossibleIntegrations', () => {
+    it('returns option details array', async () => {
+        const useCase = new GetPossibleIntegrations({ integrationClasses: [DummyIntegration] });
+        const res = await useCase.execute();
+        expect(Array.isArray(res)).toBe(true);
+        expect(res.length).toBe(1);
+        expect(res[0].display).toBeDefined();
+    });
+}); 

package/integrations/tests/use-cases/update-integration-messages.test.js

@@ -0,0 +1,15 @@
+const { UpdateIntegrationMessages } = require('../../use-cases/update-integration-messages');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+
+describe('UpdateIntegrationMessages', () => {
+    it('adds message', async () => {
+        const repo = new TestIntegrationRepository();
+        const rec = await repo.createIntegration(['e1'], 'user-1', { type: 'dummy' });
+
+        const useCase = new UpdateIntegrationMessages({ integrationRepository: repo });
+        await useCase.execute(rec.id, 'errors', 'title', 'body', Date.now());
+
+        const fetched = await repo.findIntegrationById(rec.id);
+        expect(fetched.messages.errors.length).toBe(1);
+    });
+}); 

package/integrations/tests/use-cases/update-integration.test.js

@@ -0,0 +1,24 @@
+const { UpdateIntegration } = require('../../use-cases/update-integration');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('UpdateIntegration', () => {
+    it('calls on update and returns dto', async () => {
+        const repo = new TestIntegrationRepository();
+        const mf = new TestModuleFactory();
+
+        const record = await repo.createIntegration(['e1'], 'user-1', { type: 'dummy', foo: 'bar' });
+
+        const useCase = new UpdateIntegration({
+            integrationRepository: repo,
+            integrationClasses: [DummyIntegration],
+            moduleFactory: mf,
+        });
+
+        const newConfig = { type: 'dummy', foo: 'baz' };
+        const dto = await useCase.execute(record.id, 'user-1', newConfig);
+
+        expect(dto.config.foo).toBe('baz');
+    });
+}); 

package/modules/module-repository.js

@@ -19,26 +19,6 @@ class ModuleRepository {
         };
     }
 
-    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) {
         const entitiesRecords = await Entity.find(
             { user: userId },
@@ -84,7 +64,8 @@ class ModuleRepository {
      * @returns {Promise<import('mongoose').UpdateWriteOpResult>}
      */
     async unsetCredential(entityId) {
-        return Entity.updateOne({ _id: entityId }, { $unset: { credential: "" } });
+        const result = await Entity.updateOne({ _id: entityId }, { $unset: { credential: "" } });
+        return result.acknowledged;
     }
 }
 

package/modules/tests/doubles/test-module-factory.js

@@ -0,0 +1,16 @@
+class TestModuleFactory {
+    constructor() { }
+
+    async getModuleInstance(entityId, userId) {
+        // return minimal stub module with getName and api property
+        return {
+            getName() { return 'stubModule'; },
+            api: {},
+            entityId,
+            userId,
+            testAuth: async () => true,
+        };
+    }
+}
+
+module.exports = { TestModuleFactory }; 

package/modules/tests/doubles/test-module-repository.js

@@ -0,0 +1,19 @@
+class TestModuleRepository {
+    constructor() {
+        this.entities = new Map();
+    }
+
+    addEntity(entity) {
+        this.entities.set(entity.id, entity);
+    }
+
+    async findEntityById(id) {
+        return this.entities.get(id);
+    }
+
+    async findEntitiesByIds(ids) {
+        return ids.map((id) => this.entities.get(id));
+    }
+}
+
+module.exports = { TestModuleRepository }; 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/core",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.397.1b51778.0",
+  "version": "2.0.0--canary.397.3862908.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.397.1b51778.0",
-    "@friggframework/prettier-config": "2.0.0--canary.397.1b51778.0",
-    "@friggframework/test": "2.0.0--canary.397.1b51778.0",
+    "@friggframework/eslint-config": "2.0.0--canary.397.3862908.0",
+    "@friggframework/prettier-config": "2.0.0--canary.397.3862908.0",
+    "@friggframework/test": "2.0.0--canary.397.3862908.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": "1b51778697149cbb26c6ba4de50e507461663f48"
+  "gitHead": "3862908989603188a6c3a404d456f4349c84e54b"
 }