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

package/core/create-handler.js

@@ -34,6 +34,7 @@ const createHandler = (optionByName = {}) => {
             // Helps mongoose reuse the connection.  Lowers response times.
             context.callbackWaitsForEmptyEventLoop = false;
 
+            // todo: this should not be necessary anymore
             if (shouldUseDatabase) {
                 await connectToDatabase();
             }

package/handlers/routers/auth.js

@@ -1,21 +1,7 @@
 const { createIntegrationRouter } = require('@friggframework/core');
 const { createAppHandler } = require('./../app-handler-helpers');
-const {
-    loadAppDefinition,
-} = require('../app-definition-loader');
-const { UserRepository } = require('../../user/user-repository');
-const { GetUserFromBearerToken } = require('../../user/use-cases/get-user-from-bearer-token');
 
-const { userConfig } = loadAppDefinition();
-const userRepository = new UserRepository({ userConfig });
-const getUserFromBearerToken = new GetUserFromBearerToken({
-    userRepository,
-    userConfig,
-});
-
-const router = createIntegrationRouter({
-    getUserFromBearerToken,
-});
+const router = createIntegrationRouter();
 
 router.route('/redirect/:appId').get((req, res) => {
     res.redirect(

package/integrations/integration-router.js

@@ -22,19 +22,20 @@ const { GetModule } = require('../modules/use-cases/get-module');
 const { GetEntityOptionsById } = require('../modules/use-cases/get-entity-options-by-id');
 const { RefreshEntityOptions } = require('../modules/use-cases/refresh-entity-options');
 const { GetPossibleIntegrations } = require('./use-cases/get-possible-integrations');
+const { UserRepository } = require('../user/user-repository');
+const { GetUserFromBearerToken } = require('../user/use-cases/get-user-from-bearer-token');
 
-/**
- * Creates an Express router with integration and entity routes configured
- * @param {Object} params - Configuration parameters for the router
- * @param {express.Router} [params.router] - Optional Express router instance, creates new one if not provided
- * @param {import('../user/use-cases/get-user-from-bearer-token').GetUserFromBearerToken} params.getUserFromBearerToken - Use case for retrieving a user from a bearer token
- * @returns {express.Router} Configured Express router with integration and entity routes
- */
-function createIntegrationRouter(params) {
-    const { integrations: integrationClasses } = loadAppDefinition();
+function createIntegrationRouter() {
+    const { integrations: integrationClasses, userConfig } = loadAppDefinition();
     const moduleRepository = new ModuleRepository();
     const integrationRepository = new IntegrationRepository();
     const credentialRepository = new CredentialRepository();
+    const userRepository = new UserRepository({ userConfig });
+
+    const getUserFromBearerToken = new GetUserFromBearerToken({
+        userRepository,
+        userConfig,
+    });
 
     const moduleFactory = new ModuleFactory({
         moduleRepository,
@@ -111,8 +112,7 @@ function createIntegrationRouter(params) {
         integrationClasses,
     });
 
-    const router = get(params, 'router', express());
-    const getUserFromBearerToken = get(params, 'getUserFromBearerToken');
+    const router = express();
 
     setIntegrationRoutes(router, getUserFromBearerToken, {
         createIntegration,

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

@@ -0,0 +1,90 @@
+const { IntegrationBase } = require('../../integration-base');
+
+class DummyModule {
+    static definition = {
+        getName: () => 'dummy'
+    };
+}
+
+class DummyIntegration extends IntegrationBase {
+    static Definition = {
+        name: 'dummy',
+        version: '1.0.0',
+        modules: {
+            dummy: DummyModule
+        },
+        display: {
+            label: 'Dummy Integration',
+            description: 'A dummy integration for testing',
+            detailsUrl: 'https://example.com',
+            icon: 'dummy-icon'
+        }
+    };
+
+    static getOptionDetails() {
+        return {
+            name: this.Definition.name,
+            version: this.Definition.version,
+            display: this.Definition.display
+        };
+    }
+
+    constructor(params) {
+        super(params);
+        this.sendSpy = jest.fn();
+        this.eventCallHistory = [];
+        this.events = {};
+
+        this.integrationRepository = {
+            updateIntegrationById: jest.fn().mockResolvedValue({}),
+            findIntegrationById: jest.fn().mockResolvedValue({}),
+        };
+
+        this.updateIntegrationStatus = {
+            execute: jest.fn().mockResolvedValue({})
+        };
+
+        this.updateIntegrationMessages = {
+            execute: jest.fn().mockResolvedValue({})
+        };
+
+        this.registerEventHandlers();
+    }
+
+    async loadDynamicUserActions() {
+        return {};
+    }
+
+    async registerEventHandlers() {
+        super.registerEventHandlers();
+        return;
+    }
+
+    async send(event, data) {
+        this.sendSpy(event, data);
+        this.eventCallHistory.push({ event, data, timestamp: Date.now() });
+        return super.send(event, data);
+    }
+
+    async initialize() {
+        return;
+    }
+
+    async onCreate({ integrationId }) {
+        return;
+    }
+
+    async onUpdate(params) {
+        return;
+    }
+
+    async onDelete(params) {
+        return;
+    }
+
+    getConfig() {
+        return this.config || {};
+    }
+}
+
+module.exports = { DummyIntegration }; 

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

@@ -0,0 +1,89 @@
+const { v4: uuid } = require('uuid');
+
+class TestIntegrationRepository {
+    constructor() {
+        this.store = new Map();
+        this.operationHistory = [];
+    }
+
+    async createIntegration(entities, userId, config) {
+        const id = uuid();
+        const record = {
+            id,
+            _id: id,
+            entitiesIds: entities,
+            userId: userId,
+            config,
+            version: '0.0.0',
+            status: 'NEW',
+            messages: {},
+        };
+        this.store.set(id, record);
+        this.operationHistory.push({ operation: 'create', id, userId, config });
+        return record;
+    }
+
+    async findIntegrationById(id) {
+        const rec = this.store.get(id);
+        this.operationHistory.push({ operation: 'findById', id, found: !!rec });
+        if (!rec) return null;
+        return rec;
+    }
+
+    async findIntegrationsByUserId(userId) {
+        const results = Array.from(this.store.values()).filter(r => r.userId === userId);
+        this.operationHistory.push({ operation: 'findByUserId', userId, count: results.length });
+        return results;
+    }
+
+    async updateIntegrationMessages(id, type, title, body, timestamp) {
+        const rec = this.store.get(id);
+        if (!rec) {
+            this.operationHistory.push({ operation: 'updateMessages', id, success: false });
+            return false;
+        }
+        if (!rec.messages[type]) rec.messages[type] = [];
+        rec.messages[type].push({ title, message: body, timestamp });
+        this.operationHistory.push({ operation: 'updateMessages', id, type, success: true });
+        return true;
+    }
+
+    async updateIntegrationConfig(id, config) {
+        const rec = this.store.get(id);
+        if (!rec) {
+            this.operationHistory.push({ operation: 'updateConfig', id, success: false });
+            return false;
+        }
+        rec.config = config;
+        this.operationHistory.push({ operation: 'updateConfig', id, success: true });
+        return true;
+    }
+
+    async deleteIntegrationById(id) {
+        const existed = this.store.has(id);
+        const result = this.store.delete(id);
+        this.operationHistory.push({ operation: 'delete', id, existed, success: result });
+        return result;
+    }
+
+    async updateIntegrationStatus(id, status) {
+        const rec = this.store.get(id);
+        if (rec) {
+            rec.status = status;
+            this.operationHistory.push({ operation: 'updateStatus', id, status, success: true });
+        } else {
+            this.operationHistory.push({ operation: 'updateStatus', id, status, success: false });
+        }
+        return !!rec;
+    }
+
+    getOperationHistory() {
+        return [...this.operationHistory];
+    }
+
+    clearHistory() {
+        this.operationHistory = [];
+    }
+}
+
+module.exports = { TestIntegrationRepository }; 

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

@@ -0,0 +1,124 @@
+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', () => {
+    let integrationRepository;
+    let moduleFactory;
+    let useCase;
+
+    beforeEach(() => {
+        integrationRepository = new TestIntegrationRepository();
+        moduleFactory = new TestModuleFactory();
+        useCase = new CreateIntegration({
+            integrationRepository,
+            integrationClasses: [DummyIntegration],
+            moduleFactory,
+        });
+    });
+
+    describe('happy path', () => {
+        it('creates an integration and returns DTO', async () => {
+            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);
+            expect(dto.entities).toEqual(entities);
+            expect(dto.status).toBe('NEW');
+        });
+
+        it('triggers ON_CREATE event with correct payload', async () => {
+            const entities = ['entity-1'];
+            const userId = 'user-1';
+            const config = { type: 'dummy', foo: 'bar' };
+
+            const dto = await useCase.execute(entities, userId, config);
+
+            const record = await integrationRepository.findIntegrationById(dto.id);
+            expect(record).toBeTruthy();
+
+            const history = integrationRepository.getOperationHistory();
+            const createOperation = history.find(op => op.operation === 'create');
+            expect(createOperation).toEqual({
+                operation: 'create',
+                id: dto.id,
+                userId,
+                config
+            });
+        });
+
+        it('loads modules for each entity', async () => {
+            const entities = ['entity-1', 'entity-2'];
+            const userId = 'user-1';
+            const config = { type: 'dummy' };
+
+            const dto = await useCase.execute(entities, userId, config);
+
+            expect(dto.entities).toEqual(entities);
+        });
+    });
+
+    describe('error cases', () => {
+        it('throws error when integration class is not found', async () => {
+            const entities = ['entity-1'];
+            const userId = 'user-1';
+            const config = { type: 'unknown-type' };
+
+            await expect(useCase.execute(entities, userId, config))
+                .rejects
+                .toThrow('No integration class found for type: unknown-type');
+        });
+
+        it('throws error when no integration classes provided', async () => {
+            const useCaseWithoutClasses = new CreateIntegration({
+                integrationRepository,
+                integrationClasses: [],
+                moduleFactory,
+            });
+
+            const entities = ['entity-1'];
+            const userId = 'user-1';
+            const config = { type: 'dummy' };
+
+            await expect(useCaseWithoutClasses.execute(entities, userId, config))
+                .rejects
+                .toThrow('No integration class found for type: dummy');
+        });
+    });
+
+    describe('edge cases', () => {
+        it('handles empty entities array', async () => {
+            const entities = [];
+            const userId = 'user-1';
+            const config = { type: 'dummy' };
+
+            const dto = await useCase.execute(entities, userId, config);
+
+            expect(dto.entities).toEqual([]);
+            expect(dto.id).toBeDefined();
+        });
+
+        it('handles complex config objects', async () => {
+            const entities = ['entity-1'];
+            const userId = 'user-1';
+            const config = {
+                type: 'dummy',
+                nested: {
+                    value: 123,
+                    array: [1, 2, 3],
+                    bool: true
+                }
+            };
+
+            const dto = await useCase.execute(entities, userId, config);
+
+            expect(dto.config).toEqual(config);
+        });
+    });
+}); 

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

@@ -0,0 +1,143 @@
+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 Use-Case', () => {
+    let integrationRepository;
+    let useCase;
+
+    beforeEach(() => {
+        integrationRepository = new TestIntegrationRepository();
+        useCase = new DeleteIntegrationForUser({
+            integrationRepository,
+            integrationClasses: [DummyIntegration],
+        });
+    });
+
+    describe('happy path', () => {
+        it('deletes integration successfully', async () => {
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
+
+            await useCase.execute(record.id, 'user-1');
+
+            const found = await integrationRepository.findIntegrationById(record.id);
+            expect(found).toBeNull();
+        });
+
+        it('tracks delete operation', async () => {
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
+            integrationRepository.clearHistory();
+
+            await useCase.execute(record.id, 'user-1');
+
+            const history = integrationRepository.getOperationHistory();
+            const deleteOperation = history.find(op => op.operation === 'delete');
+            expect(deleteOperation).toEqual({
+                operation: 'delete',
+                id: record.id,
+                existed: true,
+                success: true
+            });
+        });
+
+        it('deletes integration with multiple entities', async () => {
+            const record = await integrationRepository.createIntegration(['e1', 'e2', 'e3'], 'user-1', { type: 'dummy' });
+
+            await useCase.execute(record.id, 'user-1');
+
+            const found = await integrationRepository.findIntegrationById(record.id);
+            expect(found).toBeNull();
+        });
+    });
+
+    describe('error cases', () => {
+        it('throws error when integration not found', async () => {
+            const nonExistentId = 'non-existent-id';
+
+            await expect(useCase.execute(nonExistentId, 'user-1'))
+                .rejects
+                .toThrow(`Integration with id of ${nonExistentId} does not exist`);
+        });
+
+        it('throws error when user does not own integration', async () => {
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
+
+            await expect(useCase.execute(record.id, 'different-user'))
+                .rejects
+                .toThrow(`Integration ${record.id} does not belong to User different-user`);
+        });
+
+        it('throws error when integration class not found', async () => {
+            const useCaseWithoutClasses = new DeleteIntegrationForUser({
+                integrationRepository,
+                integrationClasses: [],
+            });
+
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
+
+            await expect(useCaseWithoutClasses.execute(record.id, 'user-1'))
+                .rejects
+                .toThrow();
+        });
+
+        it('tracks failed delete operation for non-existent integration', async () => {
+            const nonExistentId = 'non-existent-id';
+            integrationRepository.clearHistory();
+
+            try {
+                await useCase.execute(nonExistentId, 'user-1');
+            } catch (error) {
+                const history = integrationRepository.getOperationHistory();
+                const findOperation = history.find(op => op.operation === 'findById');
+                expect(findOperation).toEqual({
+                    operation: 'findById',
+                    id: nonExistentId,
+                    found: false
+                });
+            }
+        });
+    });
+
+    describe('edge cases', () => {
+        it('handles deletion of already deleted integration', async () => {
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
+
+            await useCase.execute(record.id, 'user-1');
+
+            await expect(useCase.execute(record.id, 'user-1'))
+                .rejects
+                .toThrow(`Integration with id of ${record.id} does not exist`);
+        });
+
+        it('handles integration with complex config during deletion', async () => {
+            const complexConfig = {
+                type: 'dummy',
+                settings: { nested: { deep: 'value' } },
+                credentials: { encrypted: true }
+            };
+
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', complexConfig);
+
+            await useCase.execute(record.id, 'user-1');
+
+            const found = await integrationRepository.findIntegrationById(record.id);
+            expect(found).toBeNull();
+        });
+
+        it('handles null userId gracefully', async () => {
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
+
+            await expect(useCase.execute(record.id, null))
+                .rejects
+                .toThrow(`Integration ${record.id} does not belong to User null`);
+        });
+
+        it('handles undefined userId gracefully', async () => {
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
+
+            await expect(useCase.execute(record.id, undefined))
+                .rejects
+                .toThrow(`Integration ${record.id} does not belong to User undefined`);
+        });
+    });
+}); 

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

@@ -0,0 +1,143 @@
+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 Use-Case', () => {
+    let integrationRepository;
+    let moduleRepository;
+    let moduleFactory;
+    let useCase;
+
+    beforeEach(() => {
+        integrationRepository = new TestIntegrationRepository();
+        moduleRepository = new TestModuleRepository();
+        moduleFactory = new TestModuleFactory();
+        useCase = new GetIntegrationForUser({
+            integrationRepository,
+            integrationClasses: [DummyIntegration],
+            moduleFactory,
+            moduleRepository,
+        });
+    });
+
+    describe('happy path', () => {
+        it('returns integration dto', async () => {
+            const entity = { id: 'entity-1', _id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+            const dto = await useCase.execute(record.id, 'user-1');
+            expect(dto.id).toBe(record.id);
+            expect(dto.userId).toBe('user-1');
+            expect(dto.config.type).toBe('dummy');
+        });
+
+        it('returns integration with multiple entities', async () => {
+            const entity1 = { id: 'entity-1', _id: 'entity-1' };
+            const entity2 = { id: 'entity-2', _id: 'entity-2' };
+            moduleRepository.addEntity(entity1);
+            moduleRepository.addEntity(entity2);
+
+            const record = await integrationRepository.createIntegration([entity1.id, entity2.id], 'user-1', { type: 'dummy' });
+
+            const dto = await useCase.execute(record.id, 'user-1');
+            expect(dto.entities).toEqual([entity1, entity2]);
+        });
+
+        it('returns integration with complex config', async () => {
+            const entity = { id: 'entity-1', _id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            const complexConfig = {
+                type: 'dummy',
+                settings: { api: { timeout: 5000 }, debug: true },
+                features: ['webhooks', 'sync']
+            };
+
+            const record = await integrationRepository.createIntegration([entity.id], 'user-1', complexConfig);
+
+            const dto = await useCase.execute(record.id, 'user-1');
+            expect(dto.config).toEqual(complexConfig);
+        });
+    });
+
+    describe('error cases', () => {
+        it('throws error when integration not found', async () => {
+            const nonExistentId = 'non-existent-id';
+
+            await expect(useCase.execute(nonExistentId, 'user-1'))
+                .rejects
+                .toThrow();
+        });
+
+        it('throws error when user does not own integration', async () => {
+            const entity = { id: 'entity-1', _id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+            await expect(useCase.execute(record.id, 'different-user'))
+                .rejects
+                .toThrow();
+        });
+
+        it('throws error when integration class not found', async () => {
+            const useCaseWithoutClasses = new GetIntegrationForUser({
+                integrationRepository,
+                integrationClasses: [],
+                moduleFactory,
+                moduleRepository,
+            });
+
+            const entity = { id: 'entity-1', _id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+            await expect(useCaseWithoutClasses.execute(record.id, 'user-1'))
+                .rejects
+                .toThrow();
+        });
+
+        it('handles missing entities gracefully', async () => {
+            const record = await integrationRepository.createIntegration(['missing-entity'], 'user-1', { type: 'dummy' });
+
+            await expect(useCase.execute(record.id, 'user-1'))
+                .rejects
+                .toThrow();
+        });
+    });
+
+    describe('edge cases', () => {
+        it('handles userId as string vs number comparison', async () => {
+            const entity = { id: 'entity-1', _id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+            const dto1 = await useCase.execute(record.id, 'user-1');
+            const dto2 = await useCase.execute(record.id, 'user-1');
+
+            expect(dto1.userId).toBe(dto2.userId);
+        });
+
+        it('returns all integration properties', async () => {
+            const entity = { id: 'entity-1', _id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+            record.status = 'ACTIVE';
+            record.version = '1.0.0';
+            record.messages = { info: [{ title: 'Test', message: 'Message' }] };
+
+            const dto = await useCase.execute(record.id, 'user-1');
+            expect(dto.status).toBe('ACTIVE');
+            expect(dto.version).toBe('1.0.0');
+            expect(dto.messages).toEqual({ info: [{ title: 'Test', message: 'Message' }] });
+        });
+    });
+});