@friggframework/core 2.0.0-next.6 → 2.0.0-next.61

package/integrations/use-cases/get-integration-instance.js

@@ -0,0 +1,83 @@
+// Removed Integration wrapper - using IntegrationBase directly
+
+/**
+ * Use case for retrieving a single integration instance by ID and user.
+ * @class GetIntegrationInstance
+ */
+class GetIntegrationInstance {
+    /**
+     * Creates a new GetIntegrationInstance instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface} params.integrationRepository - Repository for integration data access
+     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes
+     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management
+     */
+    constructor({ integrationRepository, integrationClasses, moduleFactory }) {
+        this.integrationRepository = integrationRepository;
+        this.integrationClasses = integrationClasses;
+        this.moduleFactory = moduleFactory;
+    }
+
+    /**
+     * Executes the retrieval of a single integration instance.
+     * @async
+     * @param {string} integrationId - ID of the integration to retrieve.
+     * @param {string} userId - ID of the user requesting the integration.
+     * @returns {Promise<Integration>} The fully initialized integration instance.
+     * @throws {Error} When integration is not found, doesn't belong to user, or integration class is not found.
+     */
+    async execute(integrationId, userId) {
+        const integrationRecord =
+            await this.integrationRepository.findIntegrationById(integrationId);
+
+        if (!integrationRecord) {
+            throw new Error(
+                `No integration found by the ID of ${integrationId}`
+            );
+        }
+
+        const integrationClass = this.integrationClasses.find(
+            (integrationClass) =>
+                integrationClass.Definition.name ===
+                integrationRecord.config.type
+        );
+
+        if (!integrationClass) {
+            throw new Error(
+                `No integration class found for type: ${integrationRecord.config.type}`
+            );
+        }
+
+        if (integrationRecord.userId !== userId) {
+            throw new Error(
+                `Integration ${integrationId} does not belong to User ${userId}`
+            );
+        }
+
+        const modules = [];
+        for (const entityId of integrationRecord.entitiesIds) {
+            const moduleInstance = await this.moduleFactory.getModuleInstance(
+                entityId,
+                integrationRecord.userId
+            );
+            modules.push(moduleInstance);
+        }
+
+        const integrationInstance = new integrationClass({
+            id: integrationRecord.id,
+            userId: integrationRecord.userId,
+            entities: integrationRecord.entitiesIds,
+            config: integrationRecord.config,
+            status: integrationRecord.status,
+            version: integrationRecord.version,
+            messages: integrationRecord.messages,
+            modules,
+        });
+
+        await integrationInstance.initialize();
+
+        return integrationInstance;
+    }
+}
+
+module.exports = { GetIntegrationInstance };

package/integrations/use-cases/get-integrations-for-user.js

@@ -0,0 +1,88 @@
+// Removed Integration wrapper - using IntegrationBase directly
+const {
+    mapIntegrationClassToIntegrationDTO,
+} = require('../utils/map-integration-dto');
+
+/**
+ * Use case for retrieving all integrations for a specific user.
+ * @class GetIntegrationsForUser
+ */
+class GetIntegrationsForUser {
+    /**
+     * Creates a new GetIntegrationsForUser instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface} params.integrationRepository - Repository for integration data operations.
+     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes.
+     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management.
+     * @param {import('../../modules/repositories/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository - Repository for module and entity data operations.
+     */
+    constructor({
+        integrationRepository,
+        integrationClasses,
+        moduleFactory,
+        moduleRepository,
+    }) {
+        /**
+         * @type {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface}
+         */
+        this.integrationRepository = integrationRepository;
+        this.integrationClasses = integrationClasses;
+        this.moduleFactory = moduleFactory;
+        this.moduleRepository = moduleRepository;
+    }
+
+    /**
+     * Executes the retrieval of all integrations for a user.
+     * @async
+     * @param {string} userId - ID of the user whose integrations to retrieve.
+     * @returns {Promise<Object[]>} Array of integration DTOs for the specified user.
+     */
+    async execute(userId) {
+        const integrationRecords =
+            await this.integrationRepository.findIntegrationsByUserId(userId);
+
+        const integrations = [];
+
+        for (const integrationRecord of integrationRecords) {
+            const entities = await this.moduleRepository.findEntitiesByIds(
+                integrationRecord.entitiesIds
+            );
+
+            const integrationClass = this.integrationClasses.find(
+                (integrationClass) =>
+                    integrationClass.Definition.name ===
+                    integrationRecord.config.type
+            );
+
+            const modules = [];
+            for (const entity of entities) {
+                const moduleInstance =
+                    await this.moduleFactory.getModuleInstance(
+                        entity.id,
+                        integrationRecord.userId
+                    );
+                modules.push(moduleInstance);
+            }
+
+            const integrationData = {
+                id: integrationRecord.id,
+                userId: integrationRecord.userId,
+                entities: entities,
+                config: integrationRecord.config,
+                status: integrationRecord.status,
+                version: integrationRecord.version,
+                messages: integrationRecord.messages || { errors: [], warnings: [] },
+                modules,
+                options: integrationClass.getOptionDetails(),
+            };
+
+            integrations.push(
+                mapIntegrationClassToIntegrationDTO(integrationData)
+            );
+        }
+
+        return integrations;
+    }
+}
+
+module.exports = { GetIntegrationsForUser };

package/integrations/use-cases/get-possible-integrations.js

@@ -0,0 +1,27 @@
+/**
+ * Use case for retrieving all possible integration types that can be created.
+ * @class GetPossibleIntegrations
+ */
+class GetPossibleIntegrations {
+    /**
+     * Creates a new GetPossibleIntegrations instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes.
+     */
+    constructor({ integrationClasses }) {
+        this.integrationClasses = integrationClasses;
+    }
+
+    /**
+     * Executes the retrieval of all possible integration types.
+     * @async
+     * @returns {Promise<Object[]>} Array of integration option details for all available integration types.
+     */
+    async execute() {
+        return this.integrationClasses.map((integrationClass) =>
+            integrationClass.getOptionDetails()
+        );
+    }
+}
+
+module.exports = { GetPossibleIntegrations };

package/integrations/use-cases/get-process.js

@@ -0,0 +1,87 @@
+/**
+ * GetProcess Use Case
+ * 
+ * Retrieves a process by ID with proper error handling.
+ * Simple use case that delegates to repository.
+ * 
+ * Design Philosophy:
+ * - Use cases provide consistent error handling
+ * - Business logic layer between controllers and repositories
+ * - Return null for not found vs throwing error (configurable)
+ * 
+ * @example
+ * const getProcess = new GetProcess({ processRepository });
+ * const process = await getProcess.execute(processId);
+ * // or
+ * const process = await getProcess.executeOrThrow(processId);
+ */
+class GetProcess {
+    /**
+     * @param {Object} params
+     * @param {ProcessRepositoryInterface} params.processRepository - Repository for process data access
+     */
+    constructor({ processRepository }) {
+        if (!processRepository) {
+            throw new Error('processRepository is required');
+        }
+        this.processRepository = processRepository;
+    }
+
+    /**
+     * Execute the use case to get a process by ID
+     * @param {string} processId - Process ID to retrieve
+     * @returns {Promise<Object|null>} Process record or null if not found
+     * @throws {Error} If processId is invalid
+     */
+    async execute(processId) {
+        // Validate input
+        if (!processId || typeof processId !== 'string') {
+            throw new Error('processId must be a non-empty string');
+        }
+
+        // Delegate to repository
+        try {
+            const process = await this.processRepository.findById(processId);
+            return process;
+        } catch (error) {
+            throw new Error(`Failed to retrieve process: ${error.message}`);
+        }
+    }
+
+    /**
+     * Execute and throw if process not found
+     * @param {string} processId - Process ID to retrieve
+     * @returns {Promise<Object>} Process record
+     * @throws {Error} If process not found or retrieval fails
+     */
+    async executeOrThrow(processId) {
+        const process = await this.execute(processId);
+
+        if (!process) {
+            throw new Error(`Process not found: ${processId}`);
+        }
+
+        return process;
+    }
+
+    /**
+     * Get multiple processes by IDs
+     * @param {string[]} processIds - Array of process IDs
+     * @returns {Promise<Array>} Array of process records (excludes not found)
+     */
+    async executeMany(processIds) {
+        if (!Array.isArray(processIds)) {
+            throw new Error('processIds must be an array');
+        }
+
+        const processes = await Promise.all(
+            processIds.map(id => this.execute(id))
+        );
+
+        // Filter out nulls (not found)
+        return processes.filter(p => p !== null);
+    }
+}
+
+module.exports = { GetProcess };
+

package/integrations/use-cases/index.js

@@ -0,0 +1,19 @@
+const { GetIntegrationsForUser } = require('./get-integrations-for-user');
+const { DeleteIntegrationForUser } = require('./delete-integration-for-user');
+const { CreateIntegration } = require('./create-integration');
+const { GetIntegration } = require('./get-integration');
+const { CreateProcess } = require('./create-process');
+const { UpdateProcessState } = require('./update-process-state');
+const { UpdateProcessMetrics } = require('./update-process-metrics');
+const { GetProcess } = require('./get-process');
+
+module.exports = {
+    GetIntegrationsForUser,
+    DeleteIntegrationForUser,
+    CreateIntegration,
+    GetIntegration,
+    CreateProcess,
+    UpdateProcessState,
+    UpdateProcessMetrics,
+    GetProcess,
+}; 

package/integrations/use-cases/load-integration-context.js

@@ -0,0 +1,71 @@
+class LoadIntegrationContextUseCase {
+    constructor({
+        integrationRepository,
+        moduleRepository,
+        moduleFactory,
+    }) {
+        if (!integrationRepository) {
+            throw new Error('integrationRepository is required');
+        }
+        if (!moduleRepository) {
+            throw new Error('moduleRepository is required');
+        }
+        if (!moduleFactory) {
+            throw new Error('moduleFactory is required');
+        }
+
+        this.integrationRepository = integrationRepository;
+        this.moduleRepository = moduleRepository;
+        this.moduleFactory = moduleFactory;
+    }
+
+    async execute({ integrationId, integrationRecord }) {
+        const record = integrationRecord
+            ? integrationRecord
+            : await this.integrationRepository.findIntegrationById(
+                  integrationId
+              );
+
+        if (!record) {
+            const error = new Error('Integration record not found');
+            error.code = 'INTEGRATION_RECORD_NOT_FOUND';
+            throw error;
+        }
+
+        if (
+            !Array.isArray(record.entitiesIds) ||
+            record.entitiesIds.length === 0
+        ) {
+            return {
+                record: {
+                    ...record,
+                    entities: [],
+                },
+                modules: [],
+            };
+        }
+
+        const entities = await this.moduleRepository.findEntitiesByIds(
+            record.entitiesIds
+        );
+
+        const modules = [];
+        for (const entity of entities) {
+            const moduleInstance = await this.moduleFactory.getModuleInstance(
+                entity.id,
+                record.userId
+            );
+            modules.push(moduleInstance);
+        }
+
+        return {
+            record: {
+                ...record,
+                entities,
+            },
+            modules,
+        };
+    }
+}
+
+module.exports = { LoadIntegrationContextUseCase };

package/integrations/use-cases/update-integration-messages.js

@@ -0,0 +1,44 @@
+/**
+ * Use case for updating messages associated with an integration.
+ * @class UpdateIntegrationMessages
+ */
+class UpdateIntegrationMessages {
+    /**
+     * Creates a new UpdateIntegrationMessages instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface} params.integrationRepository - Repository for integration data operations.
+     */
+    constructor({ integrationRepository }) {
+        this.integrationRepository = integrationRepository;
+    }
+
+    /**
+     * Executes the integration messages update.
+     * @async
+     * @param {string} integrationId - ID of the integration to update.
+     * @param {string} messageType - Type of message: 'errors', 'warnings', 'info', or 'logs'.
+     * @param {string} messageTitle - Title of the message.
+     * @param {string} messageBody - Body content of the message.
+     * @param {string} messageTimestamp - Timestamp when the message was created.
+     * @returns {Promise<Object>} The updated integration record.
+     */
+    async execute(
+        integrationId,
+        messageType,
+        messageTitle,
+        messageBody,
+        messageTimestamp
+    ) {
+        const integration =
+            await this.integrationRepository.updateIntegrationMessages(
+                integrationId,
+                messageType,
+                messageTitle,
+                messageBody,
+                messageTimestamp
+            );
+        return integration;
+    }
+}
+
+module.exports = { UpdateIntegrationMessages };

package/integrations/use-cases/update-integration-status.js

@@ -0,0 +1,32 @@
+/**
+ * Use case for updating the status of an integration.
+ * @class UpdateIntegrationStatus
+ */
+class UpdateIntegrationStatus {
+    /**
+     * Creates a new UpdateIntegrationStatus instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface} params.integrationRepository - Repository for integration data operations.
+     */
+    constructor({ integrationRepository }) {
+        this.integrationRepository = integrationRepository;
+    }
+
+    /**
+     * Executes the integration status update.
+     * @async
+     * @param {string} integrationId - ID of the integration to update.
+     * @param {string} status - New status for the integration (e.g., 'ENABLED', 'DISABLED', 'ERROR').
+     * @returns {Promise<Object>} The updated integration record.
+     */
+    async execute(integrationId, status) {
+        const integration =
+            await this.integrationRepository.updateIntegrationStatus(
+                integrationId,
+                status
+            );
+        return integration;
+    }
+}
+
+module.exports = { UpdateIntegrationStatus };

package/integrations/use-cases/update-integration.js

@@ -0,0 +1,92 @@
+const {
+    mapIntegrationClassToIntegrationDTO,
+} = require('../utils/map-integration-dto');
+
+/**
+ * Use case for updating a single integration by ID and user.
+ * @class UpdateIntegration
+ */
+class UpdateIntegration {
+    /**
+     * Creates a new UpdateIntegration instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface} params.integrationRepository - Repository for integration data access
+     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes
+     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management
+     */
+    constructor({ integrationRepository, integrationClasses, moduleFactory }) {
+        this.integrationRepository = integrationRepository;
+        this.integrationClasses = integrationClasses;
+        this.moduleFactory = moduleFactory;
+    }
+
+    /**
+     * Executes the integration update process.
+     * @async
+     * @param {string} integrationId - ID of the integration to update.
+     * @param {string} userId - ID of the user requesting the update.
+     * @param {Object} config - New configuration object for the integration.
+     * @returns {Promise<Object>} The updated integration DTO.
+     * @throws {Error} When integration is not found, doesn't belong to user, or integration class is not found.
+     */
+    async execute(integrationId, userId, config) {
+        // 1. Get integration record from repository
+        const integrationRecord =
+            await this.integrationRepository.findIntegrationById(integrationId);
+
+        if (!integrationRecord) {
+            throw new Error(
+                `No integration found by the ID of ${integrationId}`
+            );
+        }
+
+        // 2. Get the correct Integration class by type
+        const integrationClass = this.integrationClasses.find(
+            (integrationClass) =>
+                integrationClass.Definition.name ===
+                integrationRecord.config.type
+        );
+
+        if (!integrationClass) {
+            throw new Error(
+                `No integration class found for type: ${integrationRecord.config.type}`
+            );
+        }
+
+        if (integrationRecord.userId !== userId) {
+            throw new Error(
+                `Integration ${integrationId} does not belong to User ${userId}`
+            );
+        }
+
+        // 3. Load modules based on entity references
+        const modules = [];
+        for (const entityId of integrationRecord.entitiesIds) {
+            const moduleInstance = await this.moduleFactory.getModuleInstance(
+                entityId,
+                integrationRecord.userId
+            );
+            modules.push(moduleInstance);
+        }
+
+        // 4. Create the Integration domain entity with modules and existing config
+        const integrationInstance = new integrationClass({
+            id: integrationRecord.id,
+            userId: integrationRecord.userId,
+            entities: integrationRecord.entitiesIds,
+            config: integrationRecord.config,
+            status: integrationRecord.status,
+            version: integrationRecord.version,
+            messages: integrationRecord.messages,
+            modules,
+        });
+
+        // 5. Complete async initialization and trigger update event
+        await integrationInstance.initialize();
+        await integrationInstance.send('ON_UPDATE', { config });
+
+        return mapIntegrationClassToIntegrationDTO(integrationInstance);
+    }
+}
+
+module.exports = { UpdateIntegration };