@friggframework/core 2.0.0--canary.395.65f5f64.0 → 2.0.0--canary.398.24926ac.0

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

@@ -1,82 +0,0 @@
-// 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('../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 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

@@ -1,76 +0,0 @@
-// 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('../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 integrationClass({
-                id: integrationRecord.id,
-                userId: integrationRecord.userId,
-                entities: entities,
-                config: integrationRecord.config,
-                status: integrationRecord.status,
-                version: integrationRecord.version,
-                messages: integrationRecord.messages,
-                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,91 +0,0 @@
-// Removed Integration wrapper - using IntegrationBase directly
-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 integrationClass({
-            id: integrationRecord.id,
-            userId: integrationRecord.userId,
-            entities: integrationRecord.entitiesIds,
-            config: config,
-            status: integrationRecord.status,
-            version: integrationRecord.version,
-            messages: integrationRecord.messages,
-            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.moduleName;
-        });
-
-        if (!moduleDefinition) {
-            throw new Error(
-                `Module definition not found for entity type: ${entityType}`
-            );
-        }
-
-        return new Module({
-            userId,
-            entity,
-            definition: moduleDefinition,
-        });
-    }
-}
-
-module.exports = { ModuleFactory };

package/modules/module-repository.js

@@ -1,107 +0,0 @@
-const { Entity } = require('./entity');
-
-class ModuleRepository {
-    async findEntityById(entityId) {
-        const entity = await Entity.findById(entityId, undefined, { lean: true }).populate('credential');
-        if (!entity) {
-            throw new Error(`Entity ${entityId} not found`);
-        }
-
-        return {
-            id: entity._id,
-            accountId: entity.accountId,
-            credential: entity.credential,
-            userId: entity.user.toString(),
-            name: entity.name,
-            externalId: entity.externalId,
-            type: entity.__t,
-            moduleName: entity.moduleName,
-        };
-    }
-
-    async findEntitiesByUserId(userId) {
-        const entitiesRecords = await Entity.find(
-            { user: userId },
-            '',
-            { lean: true }
-        ).populate('credential');
-
-        return entitiesRecords.map(e => ({
-            id: e._id.toString(),
-            accountId: e.accountId,
-            credential: e.credential,
-            userId: e.user.toString(),
-            name: e.name,
-            externalId: e.externalId,
-            type: e.__t,
-            moduleName: e.moduleName,
-        }));
-    }
-
-    async findEntitiesByIds(entitiesIds) {
-        const entitiesRecords = await Entity.find(
-            { _id: { $in: entitiesIds } },
-            '',
-            { lean: true }
-        ).populate('credential');
-
-        return entitiesRecords.map(e => ({
-            id: e._id.toString(),
-            accountId: e.accountId,
-            credential: e.credential,
-            userId: e.user.toString(),
-            name: e.name,
-            externalId: e.externalId,
-            type: e.__t,
-            moduleName: e.moduleName,
-        }));
-    }
-
-    /**
-     * Remove the credential reference from an Entity document without loading a full Mongoose instance.
-     * Useful when a credential has been revoked/deleted (e.g. via Module.deauthorize).
-     * @param {string} entityId
-     * @returns {Promise<import('mongoose').UpdateWriteOpResult>}
-     */
-    async unsetCredential(entityId) {
-        const result = await Entity.updateOne({ _id: entityId }, { $unset: { credential: "" } });
-        return result.acknowledged;
-    }
-
-    async findEntity(filter) {
-        const entity = await Entity.findOne(filter, undefined, { lean: true }).populate('credential');
-        if (!entity) {
-            return null;
-        }
-
-        return {
-            id: entity._id.toString(),
-            accountId: entity.accountId,
-            credential: entity.credential,
-            userId: entity.user.toString(),
-            name: entity.name,
-            externalId: entity.externalId,
-            type: entity.__t,
-            moduleName: entity.moduleName,
-        };
-    }
-
-    async createEntity(entityData) {
-        const entity = await Entity.create(entityData);
-        await entity.populate('credential');
-
-        return {
-            id: entity._id.toString(),
-            accountId: entity.accountId,
-            credential: entity.credential,
-            userId: entity.user.toString(),
-            name: entity.name,
-            externalId: entity.externalId,
-            type: entity.__t,
-            moduleName: entity.moduleName,
-        };
-    }
-
-}
-
-module.exports = { ModuleRepository };