@friggframework/core 2.0.0--canary.398.a314355.0 → 2.0.0--canary.397.4957a89.0

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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,77 @@
+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

@@ -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/index.js

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,31 @@
+/**
+ * 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

@@ -0,0 +1,28 @@
+/**
+ * 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

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,36 @@
+/**
+ * @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/{module-plugin → modules}/index.js

@@ -1,25 +1,17 @@
 const { Credential } = require('./credential');
-const { EntityManager } = require('./entity-manager');
 const { Entity } = require('./entity');
-const { ModuleManager } = require('./manager');
 const { ApiKeyRequester } = require('./requester/api-key');
 const { BasicAuthRequester } = require('./requester/basic');
 const { OAuth2Requester } = require('./requester/oauth-2');
 const { Requester } = require('./requester/requester');
 const { ModuleConstants } = require('./ModuleConstants');
-const { ModuleFactory } = require('./module-factory');
-const { Auther } = require('./auther');
 
 module.exports = {
     Credential,
-    EntityManager,
     Entity,
-    ModuleManager,
     ApiKeyRequester,
     BasicAuthRequester,
     OAuth2Requester,
     Requester,
     ModuleConstants,
-    ModuleFactory,
-    Auther
 };

package/modules/module-factory.js

@@ -0,0 +1,54 @@
+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 };

package/modules/module-repository.js

@@ -0,0 +1,107 @@
+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 };