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

package/handlers/app-definition-loader.js

@@ -1,38 +0,0 @@
-const { findNearestBackendPackageJson } = require('@friggframework/core/utils');
-const path = require('node:path');
-const fs = require('fs-extra');
-
-/**
- * Loads the App definition from the nearest backend package
- * @function loadAppDefinition
- * @description Searches for the nearest backend package.json, loads the corresponding index.js file,
- * and extracts the application definition containing integrations and user configuration.
- * @returns {{integrations: Array<object>, userConfig: object | null}} An object containing the application definition.
- * @throws {Error} Throws error if backend package.json cannot be found.
- * @throws {Error} Throws error if index.js file cannot be found in the backend directory.
- * @example
- * const { integrations, userConfig } = loadAppDefinition();
- * console.log(`Found ${integrations.length} integrations`);
- */
-function loadAppDefinition() {
-    const backendPath = findNearestBackendPackageJson();
-    if (!backendPath) {
-        throw new Error('Could not find backend package.json');
-    }
-
-    const backendDir = path.dirname(backendPath);
-    const backendFilePath = path.join(backendDir, 'index.js');
-    if (!fs.existsSync(backendFilePath)) {
-        throw new Error('Could not find index.js');
-    }
-
-    const backendJsFile = require(backendFilePath);
-    const appDefinition = backendJsFile.Definition;
-
-    const { integrations = [], user: userConfig = null } = appDefinition;
-    return { integrations, userConfig };
-}
-
-module.exports = {
-    loadAppDefinition,
-}; 

package/integrations/integration-repository.js

@@ -1,80 +0,0 @@
-const { IntegrationModel } = require('./integration-model');
-
-class IntegrationRepository {
-    async findIntegrationsByUserId(userId) {
-        const integrationRecords = await IntegrationModel.find({ user: userId }, '', { lean: true }).populate('entities');
-        return integrationRecords.map(integrationRecord => ({
-            id: integrationRecord._id.toString(),
-            entitiesIds: integrationRecord.entities.map(e => e._id),
-            userId: integrationRecord.user.toString(),
-            config: integrationRecord.config,
-            version: integrationRecord.version,
-            status: integrationRecord.status,
-            messages: integrationRecord.messages,
-        }));
-    }
-
-    async deleteIntegrationById(integrationId) {
-        return IntegrationModel.deleteOne({ _id: integrationId });
-    }
-
-    async findIntegrationByName(name) {
-        const integrationRecord = await IntegrationModel.findOne({ 'config.type': name }, '', { lean: true }).populate('entities');
-        return {
-            id: integrationRecord._id.toString(),
-            entitiesIds: integrationRecord.entities.map(e => e._id),
-            userId: integrationRecord.user.toString(),
-            config: integrationRecord.config,
-            version: integrationRecord.version,
-            status: integrationRecord.status,
-            messages: integrationRecord.messages,
-        };
-    }
-
-    async findIntegrationById(id) {
-        const integrationRecord = await IntegrationModel.findById(id, '', { lean: true }).populate('entities');
-        return {
-            id: integrationRecord._id.toString(),
-            entitiesIds: integrationRecord.entities.map(e => e._id),
-            userId: integrationRecord.user.toString(),
-            config: integrationRecord.config,
-            version: integrationRecord.version,
-            status: integrationRecord.status,
-            messages: integrationRecord.messages,
-        }
-    }
-
-    async updateIntegrationStatus(integrationId, status) {
-        const integrationRecord = await IntegrationModel.updateOne({ _id: integrationId }, { status });
-        return integrationRecord.acknowledged;
-    }
-
-    async updateIntegrationMessages(integrationId, messageType, messageTitle, messageBody, messageTimestamp) {
-        const integrationRecord = await IntegrationModel.updateOne(
-            { _id: integrationId },
-            { $push: { [`messages.${messageType}`]: { title: messageTitle, message: messageBody, timestamp: messageTimestamp } } }
-        );
-        return integrationRecord.acknowledged;
-    }
-
-    async createIntegration(entities, userId, config) {
-        const integrationRecord = await IntegrationModel.create({
-            entities: entities,
-            user: userId,
-            config,
-            version: '0.0.0',
-        });
-
-        return {
-            id: integrationRecord._id.toString(),
-            entitiesIds: integrationRecord.entities.map(e => e._id),
-            userId: integrationRecord.user.toString(),
-            config: integrationRecord.config,
-            version: integrationRecord.version,
-            status: integrationRecord.status,
-            messages: integrationRecord.messages,
-        };
-    }
-}
-
-module.exports = { IntegrationRepository };

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

@@ -1,90 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,143 +0,0 @@
-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`);
-        });
-    });
-});