@friggframework/core 2.0.0--canary.397.84ecb0e.0 → 2.0.0--canary.398.bdb6d27.0

package/integrations/use-cases/delete-integration-for-user.js

@@ -1,73 +0,0 @@
-const Boom = require('@hapi/boom');
-const { Integration } = require('../integration');
-
-/**
- * Use case for deleting an integration for a specific user.
- * @class DeleteIntegrationForUser
- */
-class DeleteIntegrationForUser {
-    /**
-     * Creates a new DeleteIntegrationForUser instance.
-     * @param {Object} params - Configuration parameters.
-     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data operations.
-     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes.
-     */
-    constructor({ integrationRepository, integrationClasses }) {
-
-        /**
-         * @type {import('../integration-repository').IntegrationRepository}
-         */
-        this.integrationRepository = integrationRepository;
-        this.integrationClasses = integrationClasses;
-    }
-
-    /**
-     * Executes the deletion of an integration for a user.
-     * @async
-     * @param {string} integrationId - ID of the integration to delete.
-     * @param {string} userId - ID of the user requesting the deletion.
-     * @returns {Promise<void>} Resolves when the integration is successfully deleted.
-     * @throws {Boom.notFound} When integration with the specified ID does not exist.
-     * @throws {Error} When the integration doesn't belong to the specified user.
-     */
-    async execute(integrationId, userId) {
-        const integrationRecord = await this.integrationRepository.findIntegrationById(integrationId);
-
-        if (!integrationRecord) {
-            throw Boom.notFound(
-                `Integration with id of ${integrationId} does not exist`
-            );
-        }
-
-        const integrationClass = this.integrationClasses.find(
-            (integrationClass) => integrationClass.Definition.name === integrationRecord.config.type
-        );
-
-        if (integrationRecord.userId !== userId) {
-            throw new Error(
-                `Integration ${integrationId} does not belong to User ${userId}`
-            );
-        }
-
-        const integrationInstance = new Integration({
-            id: integrationRecord.id,
-            userId: integrationRecord.userId,
-            entities: integrationRecord.entitiesIds,
-            config: integrationRecord.config,
-            status: integrationRecord.status,
-            version: integrationRecord.version,
-            messages: integrationRecord.messages,
-            integrationClass: integrationClass,
-            modules: [],
-        });
-
-        // 6. Complete async initialization (load dynamic actions, register handlers)
-        await integrationInstance.initialize();
-        await integrationInstance.send('ON_DELETE');
-
-        await this.integrationRepository.deleteIntegrationById(integrationId);
-
-    }
-}
-
-module.exports = { DeleteIntegrationForUser }; 

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

@@ -1,80 +0,0 @@
-const { Integration } = require('../integration');
-const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
-const Boom = require('@hapi/boom');
-
-/**
- * Use case for retrieving a single integration for a specific user.
- * @class GetIntegrationForUser
- */
-class GetIntegrationForUser {
-    /**
-     * Creates a new GetIntegrationForUser instance.
-     * @param {Object} params - Configuration parameters.
-     * @param {import('../integration-repository').IntegrationRepository} 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/module-repository').ModuleRepository} params.moduleRepository - Repository for module and entity data operations.
-     */
-    constructor({ integrationRepository, integrationClasses, moduleFactory, moduleRepository }) {
-
-        /**
-         * @type {import('../integration-repository').IntegrationRepository}
-         */
-        this.integrationRepository = integrationRepository;
-        this.integrationClasses = integrationClasses;
-        this.moduleFactory = moduleFactory;
-        this.moduleRepository = moduleRepository;
-    }
-
-    /**
-     * Executes the retrieval of a single integration for a user.
-     * @async
-     * @param {string} integrationId - ID of the integration to retrieve.
-     * @param {string} userId - ID of the user requesting the integration.
-     * @returns {Promise<Object>} The integration DTO for the specified user.
-     * @throws {Boom.notFound} When integration with the specified ID does not exist.
-     * @throws {Boom.forbidden} When user does not have access to the integration.
-     */
-    async execute(integrationId, userId) {
-        const integrationRecord = await this.integrationRepository.findIntegrationById(integrationId);
-        const entities = await this.moduleRepository.findEntitiesByIds(integrationRecord.entitiesIds);
-
-        if (!integrationRecord) {
-            throw Boom.notFound(`Integration with id of ${integrationId} does not exist`);
-        }
-
-        if (integrationRecord.userId.toString() !== userId.toString()) {
-            throw Boom.forbidden('User does not have access to this integration');
-        }
-
-        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 integrationInstance = new Integration({
-            id: integrationRecord._id,
-            userId: integrationRecord.userId,
-            entities: entities,
-            config: integrationRecord.config,
-            status: integrationRecord.status,
-            version: integrationRecord.version,
-            messages: integrationRecord.messages,
-            entityReference: integrationRecord.entityReference,
-            integrationClass: integrationClass,
-            modules
-        });
-
-        return mapIntegrationClassToIntegrationDTO(integrationInstance);
-    }
-}
-
-module.exports = { GetIntegrationForUser }; 

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

@@ -1,67 +0,0 @@
-const { Integration } = require('../integration');
-const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
-const Boom = require('@hapi/boom');
-
-/**
- * Use case for retrieving a single integration by definition.
- * @class GetIntegrationByDefinition
- */
-class GetIntegrationInstanceByDefinition {
-    /**
-     * Creates a new GetIntegrationByDefinition instance.
-     * @param {Object} params - Configuration parameters.
-     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data operations.
-     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management.
-     * @param {import('../../modules/module-repository').ModuleRepository} params.moduleRepository - Repository for module and entity data operations.
-     */
-    constructor({ integrationRepository, moduleFactory, moduleRepository }) {
-
-        /**
-         * @type {import('../integration-repository').IntegrationRepository}
-         */
-        this.integrationRepository = integrationRepository;
-        this.moduleFactory = moduleFactory;
-        this.moduleRepository = moduleRepository;
-    }
-
-    /**
-     * Executes the retrieval of a single integration by definition.
-     * @async
-     * @returns {Promise<Object>} The integration DTO for the specified definition.
-     * @throws {Boom.notFound} When integration with the specified definition does not exist.
-     */
-    async execute(definition) {
-        const integrationRecord = await this.integrationRepository.findIntegrationByName(definition.name);
-        const entities = await this.moduleRepository.findEntitiesByIds(integrationRecord.entitiesIds);
-
-        if (!integrationRecord) {
-            throw Boom.notFound(`Integration with name of ${definition.name} does not exist`);
-        }
-
-        const modules = [];
-        for (const entity of entities) {
-            const moduleInstance = await this.moduleFactory.getModuleInstance(
-                entity._id,
-                integrationRecord.userId
-            );
-            modules.push(moduleInstance);
-        }
-
-        const integrationInstance = new Integration({
-            id: integrationRecord._id,
-            userId: integrationRecord.userId,
-            entities: entities,
-            config: integrationRecord.config,
-            status: integrationRecord.status,
-            version: integrationRecord.version,
-            messages: integrationRecord.messages,
-            entityReference: integrationRecord.entityReference,
-            integrationClass: integrationClass,
-            modules
-        });
-
-        return integrationInstance
-    }
-}
-
-module.exports = { GetIntegrationInstanceByDefinition }; 

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

@@ -1,84 +0,0 @@
-const { Integration } = require('../integration');
-
-/**
- * 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('../integration-repository').IntegrationRepository} 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 Integration({
-            id: integrationRecord.id,
-            userId: integrationRecord.userId,
-            entities: integrationRecord.entitiesIds,
-            config: integrationRecord.config,
-            status: integrationRecord.status,
-            version: integrationRecord.version,
-            messages: integrationRecord.messages,
-            integrationClass: integrationClass,
-            modules
-        });
-
-
-        await integrationInstance.initialize();
-
-        return integrationInstance;
-    }
-}
-
-module.exports = { GetIntegrationInstance }; 

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

@@ -1,77 +0,0 @@
-const { Integration } = require('../integration');
-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('../integration-repository').IntegrationRepository} 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/module-repository').ModuleRepository} params.moduleRepository - Repository for module and entity data operations.
-     */
-    constructor({ integrationRepository, integrationClasses, moduleFactory, moduleRepository }) {
-
-        /**
-         * @type {import('../integration-repository').IntegrationRepository}
-         */
-        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 integrationInstance = new Integration({
-                id: integrationRecord.id,
-                userId: integrationRecord.userId,
-                entities: entities,
-                config: integrationRecord.config,
-                status: integrationRecord.status,
-                version: integrationRecord.version,
-                messages: integrationRecord.messages,
-                integrationClass: integrationClass,
-                modules
-            });
-
-            integrations.push(
-                mapIntegrationClassToIntegrationDTO(integrationInstance)
-            );
-
-        }
-
-        return integrations;
-    }
-}
-
-module.exports = { GetIntegrationsForUser }; 

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

@@ -1,27 +0,0 @@
-/**
- * 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/index.js

@@ -1,11 +0,0 @@
-const { GetIntegrationsForUser } = require('./get-integrations-for-user');
-const { DeleteIntegrationForUser } = require('./delete-integration-for-user');
-const { CreateIntegration } = require('./create-integration');
-const { GetIntegration } = require('./get-integration');
-
-module.exports = {
-    GetIntegrationsForUser,
-    DeleteIntegrationForUser,
-    CreateIntegration,
-    GetIntegration,
-}; 

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

@@ -1,31 +0,0 @@
-/**
- * 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('../integration-repository').IntegrationRepository} 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

@@ -1,28 +0,0 @@
-/**
- * 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('../integration-repository').IntegrationRepository} 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

@@ -1,92 +0,0 @@
-const { Integration } = require('../integration');
-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('../integration-repository').IntegrationRepository} 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 updated config
-        const integrationInstance = new Integration({
-            id: integrationRecord.id,
-            userId: integrationRecord.userId,
-            entities: integrationRecord.entitiesIds,
-            config: config,
-            status: integrationRecord.status,
-            version: integrationRecord.version,
-            messages: integrationRecord.messages,
-            integrationClass: integrationClass,
-            modules
-        });
-
-
-        // 6. Complete async initialization (load dynamic actions, register handlers)
-        await integrationInstance.initialize();
-        await integrationInstance.send('ON_UPDATE', { config });
-
-        return mapIntegrationClassToIntegrationDTO(integrationInstance);
-    }
-}
-
-module.exports = { UpdateIntegration }; 

package/integrations/utils/map-integration-dto.js

@@ -1,36 +0,0 @@
-/**
- * @param {import('../integration').Integration} integration
- * Convert an Integration domain instance to a plain DTO suitable for JSON responses.
- */
-function mapIntegrationClassToIntegrationDTO(integration) {
-    if (!integration) return null;
-
-    return {
-        id: integration.id,
-        userId: integration.userId,
-        entities: integration.entities,
-        config: integration.config,
-        status: integration.status,
-        version: integration.version,
-        messages: integration.messages,
-        userActions: integration.userActions,
-        options: integration.getOptionDetails(),
-    };
-}
-
-
-const getModulesDefinitionFromIntegrationClasses = (integrationClasses) => {
-    return [
-        ...new Set(
-            integrationClasses
-                .map((integration) =>
-                    Object.values(integration.Definition.modules).map(
-                        (module) => module.definition
-                    )
-                )
-                .flat()
-        ),
-    ];
-};
-
-module.exports = { mapIntegrationClassToIntegrationDTO, getModulesDefinitionFromIntegrationClasses }; 

package/modules/module-factory.js

@@ -1,54 +0,0 @@
-const { Module } = require('./module');
-
-/**
- * Acts as a factory for fully-hydrated domain Module instances.
- * Provides methods to retrieve and construct Module objects with their associated
- * entity and definition.
- */
-class ModuleFactory {
-    /**
-     * @param {Object} params - Configuration parameters.
-     * @param {import('./module-repository').ModuleRepository} params.moduleRepository - Repository for module data operations.
-     * @param {Array<Object>} params.moduleDefinitions - Array of module definitions.
-     */
-    constructor({ moduleRepository, moduleDefinitions }) {
-        this.moduleRepository = moduleRepository;
-        this.moduleDefinitions = moduleDefinitions;
-    }
-
-    async getModuleInstance(entityId, userId) {
-        const entity = await this.moduleRepository.findEntityById(
-            entityId,
-            userId
-        );
-
-        if (!entity) {
-            throw new Error(`Entity ${entityId} not found`);
-        }
-
-        if (entity.userId !== userId) {
-            throw new Error(
-                `Entity ${entityId} does not belong to user ${userId}`
-            );
-        }
-
-        const moduleName = entity.moduleName;
-        const moduleDefinition = this.moduleDefinitions.find((def) => {
-            return moduleName === def.modelName;
-        });
-
-        if (!moduleDefinition) {
-            throw new Error(
-                `Module definition not found for entity type: ${entityType}`
-            );
-        }
-
-        return new Module({
-            userId,
-            entity,
-            definition: moduleDefinition,
-        });
-    }
-}
-
-module.exports = { ModuleFactory };