@friggframework/core 2.0.0-next.41 → 2.0.0-next.42

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

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

@@ -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/jest-global-setup-noop.js

@@ -0,0 +1,3 @@
+module.exports = async function noopGlobalSetup() {
+    // No global setup required for unit tests.
+};

package/jest-global-teardown-noop.js

@@ -0,0 +1,3 @@
+module.exports = async function noopGlobalTeardown() {
+    // No global teardown required for unit tests.
+};

package/{module-plugin → modules}/entity.js

@@ -13,6 +13,7 @@ const schema = new mongoose.Schema(
             required: false,
         },
         name: { type: String },
+        moduleName: { type: String },
         externalId: { type: String },
     },
     { timestamps: true }

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,56 @@
+// todo: remove this file
+
+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('./repositories/module-repository-interface').ModuleRepositoryInterface} 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 module: ${moduleName}`
+            );
+        }
+
+        return new Module({
+            userId,
+            entity,
+            definition: moduleDefinition,
+        });
+    }
+}
+
+module.exports = { ModuleFactory };

package/modules/module-hydration.test.js

@@ -0,0 +1,205 @@
+jest.mock('../database/config', () => ({
+    DB_TYPE: 'mongodb',
+    getDatabaseType: jest.fn(() => 'mongodb'),
+    PRISMA_LOG_LEVEL: 'error,warn',
+    PRISMA_QUERY_LOGGING: false,
+}));
+
+const { Module } = require('./module');
+const { ModuleFactory } = require('./module-factory');
+
+// Mock OAuth2Requester base class
+class MockOAuth2Api {
+    constructor(params) {
+        // Capture all params passed to API constructor
+        this.client_id = params.client_id;
+        this.client_secret = params.client_secret;
+        this.redirect_uri = params.redirect_uri;
+        this.scope = params.scope;
+        this.access_token = params.access_token;
+        this.refresh_token = params.refresh_token;
+        this.domain = params.domain;
+        this.delegate = params.delegate;
+    }
+
+    // Mock API methods
+    async listProjects() {
+        if (!this.access_token) {
+            throw new Error('No access token provided');
+        }
+        return { projects: ['project1', 'project2'] };
+    }
+
+    async getFolders() {
+        if (!this.access_token) {
+            throw new Error('No access token provided');
+        }
+        return { folders: ['folder1', 'folder2'] };
+    }
+
+    getAuthorizationRequirements() {
+        return { type: 'oauth2', url: 'https://example.com/oauth' };
+    }
+}
+
+MockOAuth2Api.requesterType = 'oauth2';
+
+// Mock module definition
+const mockModuleDefinition = {
+    moduleName: 'testmodule',
+    modelName: 'TestModule',
+    API: MockOAuth2Api,
+    requiredAuthMethods: {
+        getToken: async () => {},
+        getEntityDetails: async () => {},
+        getCredentialDetails: async () => {},
+        apiPropertiesToPersist: {
+            credential: ['access_token', 'refresh_token'],
+            entity: ['domain'],
+        },
+        testAuthRequest: async () => true,
+    },
+    env: {
+        client_id: 'test_client_id',
+        client_secret: 'test_client_secret',
+        redirect_uri: 'https://test.com/redirect',
+        scope: 'read write',
+    },
+};
+
+describe('Module Hydration', () => {
+    describe('Module API instantiation', () => {
+        it('should create API instance with merged env and credential params', () => {
+            const entity = {
+                id: 'entity-1',
+                moduleName: 'testmodule',
+                domain: 'test.domain.com',
+                credential: {
+                    data: {
+                        access_token: 'test_access_token',
+                        refresh_token: 'test_refresh_token',
+                    },
+                },
+            };
+
+            const module = new Module({
+                definition: mockModuleDefinition,
+                userId: 'user-1',
+                entity,
+            });
+
+            // Verify module properties
+            expect(module.name).toBe('testmodule');
+            expect(module.api).toBeDefined();
+
+            // Verify API was instantiated with correct params
+            expect(module.api.client_id).toBe('test_client_id');
+            expect(module.api.client_secret).toBe('test_client_secret');
+            expect(module.api.redirect_uri).toBe('https://test.com/redirect');
+            expect(module.api.scope).toBe('read write');
+            expect(module.api.access_token).toBe('test_access_token');
+            expect(module.api.refresh_token).toBe('test_refresh_token');
+            expect(module.api.domain).toBe('test.domain.com');
+        });
+
+        it('should allow API methods to be called with credentials', async () => {
+            const entity = {
+                id: 'entity-1',
+                moduleName: 'testmodule',
+                credential: {
+                    data: {
+                        access_token: 'valid_token',
+                        refresh_token: 'valid_refresh_token',
+                    },
+                },
+            };
+
+            const module = new Module({
+                definition: mockModuleDefinition,
+                userId: 'user-1',
+                entity,
+            });
+
+            // Test that API methods work with credentials
+            const projects = await module.api.listProjects();
+            expect(projects).toEqual({ projects: ['project1', 'project2'] });
+
+            const folders = await module.api.getFolders();
+            expect(folders).toEqual({ folders: ['folder1', 'folder2'] });
+        });
+
+        it('should handle missing credentials gracefully', () => {
+            const entity = {
+                id: 'entity-1',
+                moduleName: 'testmodule',
+                credential: {
+                    data: {
+                        // Empty credential data - no access_token
+                    },
+                },
+            };
+
+            const module = new Module({
+                definition: mockModuleDefinition,
+                userId: 'user-1',
+                entity,
+            });
+
+            // API should still be created with env params only
+            expect(module.api).toBeDefined();
+            expect(module.api.client_id).toBe('test_client_id');
+            expect(module.api.access_token).toBeUndefined();
+        });
+    });
+
+    describe('ModuleFactory', () => {
+        it('should create module instance from entity and definition', async () => {
+            const entity = {
+                id: 'entity-1',
+                moduleName: 'testmodule',
+                userId: 'user-1',
+                credential: {
+                    data: {
+                        access_token: 'factory_token',
+                    },
+                },
+            };
+
+            const moduleRepository = {
+                findEntityById: jest.fn().mockResolvedValue(entity),
+            };
+
+            const factory = new ModuleFactory({
+                moduleRepository,
+                moduleDefinitions: [mockModuleDefinition],
+            });
+
+            const module = await factory.getModuleInstance('entity-1', 'user-1');
+
+            expect(module).toBeDefined();
+            expect(module.api).toBeDefined();
+            expect(module.api.access_token).toBe('factory_token');
+        });
+
+        it('should throw error if module definition not found', async () => {
+            const entity = {
+                id: 'entity-1',
+                moduleName: 'unknownmodule',
+                userId: 'user-1',
+            };
+
+            const moduleRepository = {
+                findEntityById: jest.fn().mockResolvedValue(entity),
+            };
+
+            const factory = new ModuleFactory({
+                moduleRepository,
+                moduleDefinitions: [mockModuleDefinition],
+            });
+
+            await expect(
+                factory.getModuleInstance('entity-1', 'user-1')
+            ).rejects.toThrow('Module definition not found for module: unknownmodule');
+        });
+    });
+});

package/modules/module.js

@@ -0,0 +1,221 @@
+const { Delegate } = require('../core');
+const _ = require('lodash');
+const { flushDebugLog } = require('../logs');
+const { ModuleConstants } = require('./ModuleConstants');
+const {
+    createCredentialRepository,
+} = require('../credential/repositories/credential-repository-factory');
+const {
+    createModuleRepository,
+} = require('./repositories/module-repository-factory');
+
+// todo: this class should be a Domain class, and the Delegate function is preventing us from
+// doing that, we probably have to get rid of the Delegate class as well as the event based
+// calls since they go against the Domain Driven Design principles (eg. a domain class should not call repository methods or use cases)
+class Module extends Delegate {
+    //todo: entity should be replaced with actual entity properties
+    /**
+     *
+     * @param {Object} params
+     * @param {Object} params.definition The definition of the Api Module
+     * @param {string} params.userId The user id
+     * @param {Object} params.entity The entity record from the database
+     */
+    constructor({ definition, userId = null, entity: entityObj = null }) {
+        super({ definition, userId, entity: entityObj });
+
+        this.validateDefinition(definition);
+
+        this.userId = userId;
+        this.entity = entityObj;
+        this.credential = entityObj?.credential;
+        this.definition = definition;
+        this.name = this.definition.moduleName;
+        this.modelName = this.definition.modelName;
+        this.apiClass = this.definition.API;
+
+        this.credentialRepository = createCredentialRepository();
+        this.moduleRepository = createModuleRepository();
+
+        Object.assign(this, this.definition.requiredAuthMethods);
+
+        const apiParams = {
+            ...this.definition.env,
+            delegate: this,
+            ...this.apiParamsFromCredential(this.credential.data), // todo: check if this works for mongo as well
+            ...this.apiParamsFromEntity(this.entity),
+        };
+        this.api = new this.apiClass(apiParams);
+    }
+
+    getName() {
+        return this.name;
+    }
+
+    getEntityOptions() {
+        return this.definition.getEntityOptions();
+    }
+
+    async refreshEntityOptions(options) {
+        await this.definition.refreshEntityOptions(options);
+        return this.getEntityOptions();
+    }
+
+    apiParamsFromCredential(credential) {
+        return _.pick(credential, ...this.apiPropertiesToPersist?.credential);
+    }
+
+    apiParamsFromEntity(entity) {
+        return _.pick(entity, ...this.apiPropertiesToPersist?.entity);
+    }
+
+    validateAuthorizationRequirements() {
+        const requirements = this.getAuthorizationRequirements();
+        let valid = true;
+        if (
+            ['oauth1', 'oauth2'].includes(requirements.type) &&
+            !requirements.url
+        ) {
+            valid = false;
+        }
+        return valid;
+    }
+
+    getAuthorizationRequirements(params) {
+        return this.api.getAuthorizationRequirements();
+    }
+
+    async testAuth() {
+        let validAuth = false;
+        try {
+            if (await this.testAuthRequest(this.api)) validAuth = true;
+        } catch (e) {
+            flushDebugLog(e);
+        }
+        return validAuth;
+    }
+
+    async onTokenUpdate() {
+        const credentialDetails = await this.getCredentialDetails(
+            this.api,
+            this.userId
+        );
+        Object.assign(
+            credentialDetails.details,
+            this.apiParamsFromCredential(this.api)
+        );
+        credentialDetails.details.authIsValid = true;
+
+        const persisted = await this.credentialRepository.upsertCredential(
+            credentialDetails
+        );
+        this.credential = persisted;
+    }
+
+    async receiveNotification(notifier, delegateString, object = null) {
+        if (delegateString === this.api.DLGT_TOKEN_UPDATE) {
+            await this.onTokenUpdate();
+        } else if (delegateString === this.api.DLGT_TOKEN_DEAUTHORIZED) {
+            await this.deauthorize();
+        } else if (delegateString === this.api.DLGT_INVALID_AUTH) {
+            await this.markCredentialsInvalid();
+        }
+    }
+
+    async markCredentialsInvalid() {
+        if (!this.credential) return;
+
+        if (!this.credential.id) return;
+
+        await this.credentialRepository.updateAuthenticationStatus(
+            this.credential.id,
+            false
+        );
+
+        // Keep the in-memory snapshot consistent so that callers can read the
+        // updated state without another fetch.
+        this.credential.authIsValid = false;
+    }
+
+    async deauthorize() {
+        //todo: Check if this is correct, we're instantiating a new api without params (credentials, tokens, etc...)
+        this.api = new this.apiClass();
+
+        // Remove persisted credential (if any)
+        if (this.entity?.credential) {
+            const credentialId =
+                this.entity.credential.id || this.entity.credential;
+
+            // Delete credential via repository
+            await this.credentialRepository.deleteCredentialById(credentialId);
+
+            // Unset credential reference on the Entity document
+            const entityId = this.entity.id;
+            if (entityId) {
+                await this.moduleRepository.unsetCredential(entityId);
+            }
+
+            // Keep in-memory snapshot consistent
+            this.entity.credential = undefined;
+        }
+    }
+
+    // todo: check if all these props are still up to date
+    validateDefinition(definition) {
+        if (!definition) {
+            throw new Error('Module definition is required');
+        }
+        if (!definition.moduleName) {
+            throw new Error('Module definition requires moduleName');
+        }
+        if (!definition.API) {
+            throw new Error('Module definition requires API class');
+        }
+        if (!definition.requiredAuthMethods) {
+            throw new Error('Module definition requires requiredAuthMethods');
+        } else {
+            if (
+                definition.API.requesterType ===
+                    ModuleConstants.authType.oauth2 &&
+                !definition.requiredAuthMethods.getToken
+            ) {
+                throw new Error(
+                    'Module definition requires requiredAuthMethods.getToken'
+                );
+            }
+            if (!definition.requiredAuthMethods.getEntityDetails) {
+                throw new Error(
+                    'Module definition requires requiredAuthMethods.getEntityDetails'
+                );
+            }
+            if (!definition.requiredAuthMethods.getCredentialDetails) {
+                throw new Error(
+                    'Module definition requires requiredAuthMethods.getCredentialDetails'
+                );
+            }
+            if (!definition.requiredAuthMethods.apiPropertiesToPersist) {
+                throw new Error(
+                    'Module definition requires requiredAuthMethods.apiPropertiesToPersist'
+                );
+            } else if (definition.Credential) {
+                for (const prop of definition.requiredAuthMethods
+                    .apiPropertiesToPersist?.credential) {
+                    if (
+                        !definition.Credential.schema.paths.hasOwnProperty(prop)
+                    ) {
+                        throw new Error(
+                            `Module definition requires Credential schema to have property ${prop}`
+                        );
+                    }
+                }
+            }
+            if (!definition.requiredAuthMethods.testAuthRequest) {
+                throw new Error(
+                    'Module definition requires requiredAuthMethods.testAuth'
+                );
+            }
+        }
+    }
+}
+
+module.exports = { Module };

package/modules/repositories/module-repository-factory.js

@@ -0,0 +1,33 @@
+const { ModuleRepositoryMongo } = require('./module-repository-mongo');
+const { ModuleRepositoryPostgres } = require('./module-repository-postgres');
+const config = require('../../database/config');
+
+/**
+ * Module Repository Factory
+ * Creates the appropriate repository adapter based on database type
+ *
+ * @returns {ModuleRepositoryInterface} Configured repository adapter
+ */
+function createModuleRepository() {
+    const dbType = config.DB_TYPE;
+
+    switch (dbType) {
+        case 'mongodb':
+            return new ModuleRepositoryMongo();
+
+        case 'postgresql':
+            return new ModuleRepositoryPostgres();
+
+        default:
+            throw new Error(
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+            );
+    }
+}
+
+module.exports = {
+    createModuleRepository,
+    // Export adapters for direct testing
+    ModuleRepositoryMongo,
+    ModuleRepositoryPostgres,
+};