@friggframework/core 2.0.0-next.41 → 2.0.0-next.43

package/integrations/repositories/integration-repository-postgres.js

@@ -0,0 +1,319 @@
+const { prisma } = require('../../database/prisma');
+const {
+    IntegrationRepositoryInterface,
+} = require('./integration-repository-interface');
+
+/**
+ * PostgreSQL Integration Repository Adapter
+ * Handles integration persistence using Prisma with PostgreSQL
+ *
+ * PostgreSQL-specific characteristics:
+ * - Uses nested relations for foreign keys (user, entities)
+ * - Uses Int IDs with autoincrement
+ * - Requires ID conversion: String (app layer) ↔ Int (database)
+ * - All returned IDs are converted to strings for application layer consistency
+ * - Implicit join tables for many-to-many relationships (_EntityToIntegration)
+ * - Uses connect/disconnect syntax for relations
+ */
+class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+    }
+
+    /**
+     * Convert string ID to integer for PostgreSQL queries
+     * @private
+     * @param {string|number|null|undefined} id - ID to convert
+     * @returns {number|null|undefined} Integer ID or null/undefined
+     * @throws {Error} If ID cannot be converted to integer
+     */
+    _convertId(id) {
+        if (id === null || id === undefined) return id;
+        const parsed = parseInt(id, 10);
+        if (isNaN(parsed)) {
+            throw new Error(`Invalid ID: ${id} cannot be converted to integer`);
+        }
+        return parsed;
+    }
+
+    /**
+     * Convert integration object IDs to strings
+     * @private
+     * @param {Object|null} integration - Integration object from database
+     * @returns {Object|null} Integration with string IDs
+     */
+    _convertIntegrationIds(integration) {
+        if (!integration) return integration;
+        return {
+            ...integration,
+            id: integration.id?.toString(),
+            userId: integration.userId?.toString(),
+            entities: integration.entities?.map(e => ({
+                ...e,
+                id: e.id?.toString(),
+                userId: e.userId?.toString(),
+                credentialId: e.credentialId?.toString()
+            }))
+        };
+    }
+
+    /**
+     * Find all integrations for a user
+     *
+     * @param {string} userId - User ID (string from application layer)
+     * @returns {Promise<Array>} Array of integration objects with string IDs
+     */
+    async findIntegrationsByUserId(userId) {
+        const intUserId = this._convertId(userId);
+        const integrations = await this.prisma.integration.findMany({
+            where: { userId: intUserId },
+            include: {
+                entities: true,
+            },
+        });
+
+        // Map to domain objects with string IDs
+        return integrations.map((integration) => {
+            const converted = this._convertIntegrationIds(integration);
+            return {
+                id: converted.id,
+                entitiesIds: converted.entities.map((e) => e.id),
+                userId: converted.userId,
+                config: converted.config,
+                version: converted.version,
+                status: converted.status,
+                messages: converted.messages,
+            };
+        });
+    }
+
+    /**
+     * Delete integration by ID
+     *
+     * @param {string} integrationId - Integration ID (string from application layer)
+     * @returns {Promise<Object>} Deletion result
+     */
+    async deleteIntegrationById(integrationId) {
+        const intId = this._convertId(integrationId);
+        await this.prisma.integration.delete({
+            where: { id: intId },
+        });
+
+        // Return Mongoose-compatible result
+        return { acknowledged: true, deletedCount: 1 };
+    }
+
+    /**
+     * Find integration by name
+     *
+     * @param {string} name - Integration type name
+     * @returns {Promise<Object>} Integration object with string IDs
+     */
+    async findIntegrationByName(name) {
+        const integration = await this.prisma.integration.findFirst({
+            where: {
+                config: {
+                    path: ['type'],
+                    equals: name,
+                },
+            },
+            include: {
+                entities: true,
+            },
+        });
+
+        if (!integration) {
+            throw new Error(`Integration with name ${name} not found`);
+        }
+
+        const converted = this._convertIntegrationIds(integration);
+        return {
+            id: converted.id,
+            entitiesIds: converted.entities.map((e) => e.id),
+            userId: converted.userId,
+            config: converted.config,
+            version: converted.version,
+            status: converted.status,
+            messages: converted.messages,
+        };
+    }
+
+    /**
+     * Find integration by ID
+     *
+     * @param {string} id - Integration ID (string from application layer)
+     * @returns {Promise<Object>} Integration object with string IDs
+     */
+    async findIntegrationById(id) {
+        const intId = this._convertId(id);
+        const integration = await this.prisma.integration.findUnique({
+            where: { id: intId },
+            include: {
+                entities: true,
+            },
+        });
+
+        if (!integration) {
+            throw new Error(`Integration with id ${id} not found`);
+        }
+
+        const converted = this._convertIntegrationIds(integration);
+        return {
+            id: converted.id,
+            entitiesIds: converted.entities.map((e) => e.id),
+            userId: converted.userId,
+            config: converted.config,
+            version: converted.version,
+            status: converted.status,
+            messages: converted.messages,
+        };
+    }
+
+    /**
+     * Update integration status
+     *
+     * @param {string} integrationId - Integration ID (string from application layer)
+     * @param {string} status - New status
+     * @returns {Promise<boolean>} Success indicator
+     */
+    async updateIntegrationStatus(integrationId, status) {
+        const intId = this._convertId(integrationId);
+        await this.prisma.integration.update({
+            where: { id: intId },
+            data: { status },
+        });
+
+        return true; // Mongoose compatibility
+    }
+
+    /**
+     * Update integration messages
+     *
+     * @param {string} integrationId - Integration ID (string from application layer)
+     * @param {string} messageType - Type of message (errors, warnings, info, logs)
+     * @param {string} messageTitle - Message title
+     * @param {string} messageBody - Message body
+     * @param {Date} messageTimestamp - Message timestamp
+     * @returns {Promise<boolean>} Success indicator
+     */
+    async updateIntegrationMessages(
+        integrationId,
+        messageType,
+        messageTitle,
+        messageBody,
+        messageTimestamp
+    ) {
+        const intId = this._convertId(integrationId);
+
+        // Get current integration
+        const integration = await this.prisma.integration.findUnique({
+            where: { id: intId },
+        });
+
+        if (!integration) {
+            throw new Error(`Integration ${integrationId} not found`);
+        }
+
+        // Parse existing messages (JSON field)
+        const messages = integration.messages || {};
+        const messageArray = Array.isArray(messages[messageType])
+            ? messages[messageType]
+            : [];
+
+        // Add new message
+        messageArray.push({
+            title: messageTitle,
+            message: messageBody,
+            timestamp: messageTimestamp,
+        });
+
+        // Update messages
+        await this.prisma.integration.update({
+            where: { id: intId },
+            data: {
+                [messageType]: messageArray,
+            },
+        });
+
+        return true; // Mongoose compatibility
+    }
+
+    /**
+     * Create a new integration
+     *
+     * PostgreSQL-specific: Uses nested relations with connect syntax
+     *
+     * @param {Array<string>} entities - Array of entity IDs (strings from application layer)
+     * @param {string} userId - User ID (string from application layer)
+     * @param {Object} config - Integration configuration
+     * @returns {Promise<Object>} Created integration object with string IDs
+     */
+    async createIntegration(entities, userId, config) {
+        const data = {
+            config,
+            version: '0.0.0',
+        };
+
+        // PostgreSQL: use nested relations with ID conversion
+        if (userId) {
+            data.user = { connect: { id: this._convertId(userId) } };
+        }
+        if (entities && entities.length > 0) {
+            data.entities = {
+                connect: entities.map((id) => ({ id: this._convertId(id) })),
+            };
+        }
+
+        const integration = await this.prisma.integration.create({
+            data,
+            include: {
+                entities: true,
+            },
+        });
+
+        const converted = this._convertIntegrationIds(integration);
+        return {
+            id: converted.id,
+            entitiesIds: converted.entities.map((e) => e.id),
+            userId: converted.userId,
+            config: converted.config,
+            version: converted.version,
+            status: converted.status,
+            messages: converted.messages,
+        };
+    }
+
+    /**
+     * Find integration by user ID (returns single integration)
+     *
+     * @param {string} userId - User ID (string from application layer)
+     * @returns {Promise<Object|null>} Integration object with string IDs or null
+     */
+    async findIntegrationByUserId(userId) {
+        const intUserId = this._convertId(userId);
+        const integration = await this.prisma.integration.findFirst({
+            where: { userId: intUserId },
+            include: {
+                entities: true,
+            },
+        });
+
+        if (!integration) {
+            return null;
+        }
+
+        const converted = this._convertIntegrationIds(integration);
+        return {
+            id: converted.id,
+            entitiesIds: converted.entities.map((e) => e.id),
+            userId: converted.userId,
+            config: converted.config,
+            version: converted.version,
+            status: converted.status,
+            messages: converted.messages,
+        };
+    }
+}
+
+module.exports = { IntegrationRepositoryPostgres };

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,99 @@
+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 findIntegrationByUserId(userId) {
+        const record = Array.from(this.store.values()).find((r) => r.userId === userId);
+        this.operationHistory.push({
+            operation: 'findSingleByUserId',
+            userId,
+            found: !!record,
+        });
+        return record || null;
+    }
+
+    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,131 @@
+jest.mock('../../../database/config', () => ({
+    DB_TYPE: 'mongodb',
+    getDatabaseType: jest.fn(() => 'mongodb'),
+    PRISMA_LOG_LEVEL: 'error,warn',
+    PRISMA_QUERY_LOGGING: false,
+}));
+
+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);
+        });
+    });
+});