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

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

@@ -0,0 +1,44 @@
+const { IntegrationRepositoryMongo } = require('./integration-repository-mongo');
+const { IntegrationRepositoryPostgres } = require('./integration-repository-postgres');
+const config = require('../../database/config');
+
+/**
+ * Integration Repository Factory
+ * Creates the appropriate repository adapter based on database type
+ *
+ * This implements the Factory pattern for Hexagonal Architecture:
+ * - Reads database type from app definition (backend/index.js)
+ * - Returns correct adapter (MongoDB or PostgreSQL)
+ * - Provides clear error for unsupported databases
+ *
+ * Usage:
+ * ```javascript
+ * const repository = createIntegrationRepository();
+ * ```
+ *
+ * @returns {IntegrationRepositoryInterface} Configured repository adapter
+ * @throws {Error} If database type is not supported
+ */
+function createIntegrationRepository() {
+    const dbType = config.DB_TYPE;
+
+    switch (dbType) {
+        case 'mongodb':
+            return new IntegrationRepositoryMongo();
+
+        case 'postgresql':
+            return new IntegrationRepositoryPostgres();
+
+        default:
+            throw new Error(
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+            );
+    }
+}
+
+module.exports = {
+    createIntegrationRepository,
+    // Export adapters for direct testing
+    IntegrationRepositoryMongo,
+    IntegrationRepositoryPostgres,
+};

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

@@ -0,0 +1,115 @@
+/**
+ * Integration Repository Interface
+ * Abstract base class defining the contract for integration persistence adapters
+ *
+ * This follows the Port in Hexagonal Architecture:
+ * - Domain layer depends on this abstraction
+ * - Concrete adapters (MongoDB, PostgreSQL) implement this interface
+ * - Use cases receive repositories via dependency injection
+ *
+ * @abstract
+ */
+class IntegrationRepositoryInterface {
+    /**
+     * Find all integrations for a user
+     *
+     * @param {string|number} userId - User ID
+     * @returns {Promise<Array>} Array of integration objects
+     * @abstract
+     */
+    async findIntegrationsByUserId(userId) {
+        throw new Error('Method findIntegrationsByUserId must be implemented by subclass');
+    }
+
+    /**
+     * Delete integration by ID
+     *
+     * @param {string|number} integrationId - Integration ID
+     * @returns {Promise<Object>} Deletion result
+     * @abstract
+     */
+    async deleteIntegrationById(integrationId) {
+        throw new Error('Method deleteIntegrationById must be implemented by subclass');
+    }
+
+    /**
+     * Find integration by name
+     *
+     * @param {string} name - Integration type name
+     * @returns {Promise<Object>} Integration object
+     * @abstract
+     */
+    async findIntegrationByName(name) {
+        throw new Error('Method findIntegrationByName must be implemented by subclass');
+    }
+
+    /**
+     * Find integration by ID
+     *
+     * @param {string|number} id - Integration ID
+     * @returns {Promise<Object>} Integration object
+     * @abstract
+     */
+    async findIntegrationById(id) {
+        throw new Error('Method findIntegrationById must be implemented by subclass');
+    }
+
+    /**
+     * Update integration status
+     *
+     * @param {string|number} integrationId - Integration ID
+     * @param {string} status - New status
+     * @returns {Promise<boolean>} Success indicator
+     * @abstract
+     */
+    async updateIntegrationStatus(integrationId, status) {
+        throw new Error('Method updateIntegrationStatus must be implemented by subclass');
+    }
+
+    /**
+     * Update integration messages
+     *
+     * @param {string|number} integrationId - Integration ID
+     * @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
+     * @abstract
+     */
+    async updateIntegrationMessages(
+        integrationId,
+        messageType,
+        messageTitle,
+        messageBody,
+        messageTimestamp
+    ) {
+        throw new Error('Method updateIntegrationMessages must be implemented by subclass');
+    }
+
+    /**
+     * Create a new integration
+     *
+     * @param {Array<string|number>} entities - Array of entity IDs
+     * @param {string|number} userId - User ID
+     * @param {Object} config - Integration configuration
+     * @returns {Promise<Object>} Created integration object
+     * @abstract
+     */
+    async createIntegration(entities, userId, config) {
+        throw new Error('Method createIntegration must be implemented by subclass');
+    }
+
+    /**
+     * Find integration by user ID (returns single integration)
+     *
+     * @param {string|number} userId - User ID
+     * @returns {Promise<Object|null>} Integration object or null
+     * @abstract
+     */
+    async findIntegrationByUserId(userId) {
+        throw new Error('Method findIntegrationByUserId must be implemented by subclass');
+    }
+}
+
+module.exports = { IntegrationRepositoryInterface };

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

@@ -0,0 +1,271 @@
+const { prisma } = require('../../database/prisma');
+const {
+    IntegrationRepositoryInterface,
+} = require('./integration-repository-interface');
+
+/**
+ * MongoDB Integration Repository Adapter
+ * Handles integration persistence using Prisma with MongoDB
+ *
+ * MongoDB-specific characteristics:
+ * - Uses scalar fields for relations (userId, entityIds)
+ * - IDs are strings with @db.ObjectId
+ * - Arrays used for many-to-many relationships
+ *
+ * Migration from Mongoose:
+ * - Constructor injection of Prisma client
+ * - populate() → include in Prisma queries
+ * - lean: true → No longer needed (Prisma returns plain objects)
+ * - toString() conversions → Done automatically by Prisma
+ */
+class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+    }
+
+    /**
+     * Find all integrations for a user
+     * Replaces: IntegrationModel.find({ user: userId }).populate('entities')
+     *
+     * @param {string} userId - User ID (MongoDB ObjectId as string)
+     * @returns {Promise<Array>} Array of integration objects
+     */
+    async findIntegrationsByUserId(userId) {
+        const integrations = await this.prisma.integration.findMany({
+            where: { userId },
+            include: {
+                entities: true,
+            },
+        });
+
+        // Map to domain objects (maintains same API)
+        return integrations.map((integration) => ({
+            id: integration.id,
+            entitiesIds: integration.entities.map((e) => e.id),
+            userId: integration.userId,
+            config: integration.config,
+            version: integration.version,
+            status: integration.status,
+            messages: integration.messages,
+        }));
+    }
+
+    /**
+     * Delete integration by ID
+     * Replaces: IntegrationModel.deleteOne({ _id: integrationId })
+     *
+     * @param {string} integrationId - Integration ID
+     * @returns {Promise<Object>} Deletion result
+     */
+    async deleteIntegrationById(integrationId) {
+        await this.prisma.integration.delete({
+            where: { id: integrationId },
+        });
+
+        // Return Mongoose-compatible result
+        return { acknowledged: true, deletedCount: 1 };
+    }
+
+    /**
+     * Find integration by name
+     * Replaces: IntegrationModel.findOne({ 'config.type': name }).populate('entities')
+     *
+     * @param {string} name - Integration type name
+     * @returns {Promise<Object>} Integration object
+     */
+    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`);
+        }
+
+        return {
+            id: integration.id,
+            entitiesIds: integration.entities.map((e) => e.id),
+            userId: integration.userId,
+            config: integration.config,
+            version: integration.version,
+            status: integration.status,
+            messages: integration.messages,
+        };
+    }
+
+    /**
+     * Find integration by ID
+     * Replaces: IntegrationModel.findById(id).populate('entities')
+     *
+     * @param {string} id - Integration ID
+     * @returns {Promise<Object>} Integration object
+     */
+    async findIntegrationById(id) {
+        const integration = await this.prisma.integration.findUnique({
+            where: { id },
+            include: {
+                entities: true,
+            },
+        });
+
+        if (!integration) {
+            throw new Error(`Integration with id ${id} not found`);
+        }
+
+        return {
+            id: integration.id,
+            entitiesIds: integration.entities.map((e) => e.id),
+            userId: integration.userId,
+            config: integration.config,
+            version: integration.version,
+            status: integration.status,
+            messages: integration.messages,
+        };
+    }
+
+    /**
+     * Update integration status
+     * Replaces: IntegrationModel.updateOne({ _id: integrationId }, { status })
+     *
+     * @param {string} integrationId - Integration ID
+     * @param {string} status - New status
+     * @returns {Promise<boolean>} Success indicator
+     */
+    async updateIntegrationStatus(integrationId, status) {
+        await this.prisma.integration.update({
+            where: { id: integrationId },
+            data: { status },
+        });
+
+        return true; // Mongoose compatibility
+    }
+
+    /**
+     * Update integration messages
+     * Replaces: IntegrationModel.updateOne with $push operator
+     *
+     * @param {string} integrationId - Integration ID
+     * @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
+    ) {
+        // Get current integration
+        const integration = await this.prisma.integration.findUnique({
+            where: { id: integrationId },
+        });
+
+        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: integrationId },
+            data: {
+                [messageType]: messageArray,
+            },
+        });
+
+        return true; // Mongoose compatibility
+    }
+
+    /**
+     * Create a new integration
+     * Replaces: IntegrationModel.create({ entities, user, config })
+     *
+     * MongoDB-specific: Uses scalar fields for relations
+     *
+     * @param {Array<string>} entities - Array of entity IDs (MongoDB ObjectIds)
+     * @param {string} userId - User ID (MongoDB ObjectId)
+     * @param {Object} config - Integration configuration
+     * @returns {Promise<Object>} Created integration object
+     */
+    async createIntegration(entities, userId, config) {
+        const data = {
+            config,
+            version: '0.0.0',
+            userId: userId,
+            entityIds: entities,
+        };
+
+        const integration = await this.prisma.integration.create({
+            data,
+            include: {
+                entities: true,
+            },
+        });
+
+        return {
+            id: integration.id,
+            entitiesIds: integration.entities.map((e) => e.id),
+            userId: integration.userId,
+            config: integration.config,
+            version: integration.version,
+            status: integration.status,
+            messages: integration.messages,
+        };
+    }
+
+    /**
+     * Find integration by user ID (returns single integration)
+     * Replaces: IntegrationModel.findOne({ user: userId }).populate('entities')
+     *
+     * @param {string} userId - User ID
+     * @returns {Promise<Object|null>} Integration object or null
+     */
+    async findIntegrationByUserId(userId) {
+        const integration = await this.prisma.integration.findFirst({
+            where: { userId },
+            include: {
+                entities: true,
+            },
+        });
+
+        if (!integration) {
+            return null;
+        }
+
+        return {
+            id: integration.id,
+            entitiesIds: integration.entities.map((e) => e.id),
+            userId: integration.userId,
+            config: integration.config,
+            version: integration.version,
+            status: integration.status,
+            messages: integration.messages,
+        };
+    }
+}
+
+module.exports = { IntegrationRepositoryMongo };