@friggframework/core 2.0.0--canary.490.dfd8df5.0 → 2.0.0--canary.490.1d4d68c.0

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

@@ -1,307 +0,0 @@
-const { prisma } = require('../../database/prisma');
-const {
-    IntegrationRepositoryInterface,
-} = require('./integration-repository-interface');
-const { BaseRepositoryMongoDB } = require('../../database/repositories/base-repository-mongodb');
-
-/**
- * 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();
-        
-        // Use MongoDB base repository for DocumentDB compatibility
-        const mongoBase = new BaseRepositoryMongoDB({ prismaClient: prisma });
-        this.prisma = mongoBase.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,
-        };
-    }
-
-    /**
-     * Update integration configuration
-     * Replaces: IntegrationModel.updateOne({ _id: integrationId }, { config })
-     *
-     * @param {string} integrationId - Integration ID (MongoDB ObjectId as string)
-     * @param {Object} config - Updated configuration object
-     * @returns {Promise<Object>} Updated integration object
-     */
-    async updateIntegrationConfig(integrationId, config) {
-        if (config === null || config === undefined) {
-            throw new Error('Config parameter is required');
-        }
-
-        const integration = await this.prisma.integration.update({
-            where: { id: integrationId },
-            data: { config },
-            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,
-        };
-    }
-}
-
-module.exports = { IntegrationRepositoryMongo };

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

@@ -1,194 +0,0 @@
-const { prisma } = require('../../database/prisma');
-const { ProcessRepositoryInterface } = require('./process-repository-interface');
-const { BaseRepositoryMongoDB } = require('../../database/repositories/base-repository-mongodb');
-
-/**
- * MongoDB Process Repository Adapter
- * Handles process persistence using Prisma with MongoDB
- *
- * MongoDB-specific characteristics:
- * - Uses scalar fields for relations (userId, integrationId)
- * - IDs are strings with @db.ObjectId
- * - JSON fields for flexible context and results storage
- * - Array field for childProcesses references
- *
- * Design Philosophy:
- * - Generic Process model supports any type of long-running operation
- * - Context and results stored as JSON for maximum flexibility
- * - Integration-specific logic lives in use cases and services
- */
-class ProcessRepositoryMongo extends ProcessRepositoryInterface {
-    constructor() {
-        super();
-        
-        // Use MongoDB base repository for DocumentDB compatibility
-        const mongoBase = new BaseRepositoryMongoDB({ prismaClient: prisma });
-        this.prisma = mongoBase.prisma;
-    }
-
-    /**
-     * Create a new process record
-     * @param {Object} processData - Process data to create
-     * @returns {Promise<Object>} Created process record
-     */
-    async create(processData) {
-        const process = await this.prisma.process.create({
-            data: {
-                userId: processData.userId,
-                integrationId: processData.integrationId,
-                name: processData.name,
-                type: processData.type,
-                state: processData.state || 'INITIALIZING',
-                context: processData.context || {},
-                results: processData.results || {},
-                childProcesses: processData.childProcesses || [],
-                parentProcessId: processData.parentProcessId || null,
-            },
-        });
-
-        return this._toPlainObject(process);
-    }
-
-    /**
-     * Find a process by ID
-     * @param {string} processId - Process ID to find
-     * @returns {Promise<Object|null>} Process record or null if not found
-     */
-    async findById(processId) {
-        const process = await this.prisma.process.findUnique({
-            where: { id: processId },
-        });
-
-        return process ? this._toPlainObject(process) : null;
-    }
-
-    /**
-     * Update a process record
-     * @param {string} processId - Process ID to update
-     * @param {Object} updates - Fields to update
-     * @returns {Promise<Object>} Updated process record
-     */
-    async update(processId, updates) {
-        // Prepare update data, excluding undefined values
-        const updateData = {};
-
-        if (updates.state !== undefined) {
-            updateData.state = updates.state;
-        }
-        if (updates.context !== undefined) {
-            updateData.context = updates.context;
-        }
-        if (updates.results !== undefined) {
-            updateData.results = updates.results;
-        }
-        if (updates.childProcesses !== undefined) {
-            updateData.childProcesses = updates.childProcesses;
-        }
-        if (updates.parentProcessId !== undefined) {
-            updateData.parentProcessId = updates.parentProcessId;
-        }
-
-        const process = await this.prisma.process.update({
-            where: { id: processId },
-            data: updateData,
-        });
-
-        return this._toPlainObject(process);
-    }
-
-    /**
-     * Find processes by integration and type
-     * @param {string} integrationId - Integration ID
-     * @param {string} type - Process type
-     * @returns {Promise<Array>} Array of process records
-     */
-    async findByIntegrationAndType(integrationId, type) {
-        const processes = await this.prisma.process.findMany({
-            where: {
-                integrationId,
-                type,
-            },
-            orderBy: {
-                createdAt: 'desc',
-            },
-        });
-
-        return processes.map((p) => this._toPlainObject(p));
-    }
-
-    /**
-     * Find active processes (not in excluded states)
-     * @param {string} integrationId - Integration ID
-     * @param {string[]} [excludeStates=['COMPLETED', 'ERROR']] - States to exclude
-     * @returns {Promise<Array>} Array of active process records
-     */
-    async findActiveProcesses(integrationId, excludeStates = ['COMPLETED', 'ERROR']) {
-        const processes = await this.prisma.process.findMany({
-            where: {
-                integrationId,
-                state: {
-                    notIn: excludeStates,
-                },
-            },
-            orderBy: {
-                createdAt: 'desc',
-            },
-        });
-
-        return processes.map((p) => this._toPlainObject(p));
-    }
-
-    /**
-     * Find a process by name (most recent)
-     * @param {string} name - Process name
-     * @returns {Promise<Object|null>} Most recent process with given name, or null
-     */
-    async findByName(name) {
-        const process = await this.prisma.process.findFirst({
-            where: { name },
-            orderBy: {
-                createdAt: 'desc',
-            },
-        });
-
-        return process ? this._toPlainObject(process) : null;
-    }
-
-    /**
-     * Delete a process by ID
-     * @param {string} processId - Process ID to delete
-     * @returns {Promise<void>}
-     */
-    async deleteById(processId) {
-        await this.prisma.process.delete({
-            where: { id: processId },
-        });
-    }
-
-    /**
-     * Convert Prisma model to plain JavaScript object
-     * Ensures consistent API across repository implementations
-     * @private
-     * @param {Object} process - Prisma process model
-     * @returns {Object} Plain process object
-     */
-    _toPlainObject(process) {
-        return {
-            id: process.id,
-            userId: process.userId,
-            integrationId: process.integrationId,
-            name: process.name,
-            type: process.type,
-            state: process.state,
-            context: process.context,
-            results: process.results,
-            childProcesses: process.childProcesses,
-            parentProcessId: process.parentProcessId,
-            createdAt: process.createdAt,
-            updatedAt: process.updatedAt,
-        };
-    }
-}
-
-module.exports = { ProcessRepositoryMongo };
-