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

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/load-integration-context-full.test.js

@@ -0,0 +1,329 @@
+jest.mock('../../database/config', () => ({
+    DB_TYPE: 'mongodb',
+    getDatabaseType: jest.fn(() => 'mongodb'),
+    PRISMA_LOG_LEVEL: 'error,warn',
+    PRISMA_QUERY_LOGGING: false,
+}));
+
+const { LoadIntegrationContextUseCase } = require('./load-integration-context');
+const { IntegrationBase } = require('../integration-base');
+const { createIntegrationRepository } = require('../repositories/integration-repository-factory');
+const { Module } = require('../../modules/module');
+const { ModuleFactory } = require('../../modules/module-factory');
+const { ModuleRepository } = require('../../modules/repositories/module-repository');
+
+// Mock OAuth2 API class that extends requester pattern
+class MockAsanaApi {
+    constructor(params) {
+        // Capture all injected params
+        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.delegate = params.delegate;
+    }
+
+    async getFolders() {
+        if (!this.access_token) {
+            throw new Error('No access token');
+        }
+        return {
+            folders: ['Marketing', 'Development', 'Design'],
+            usedToken: this.access_token
+        };
+    }
+
+    async listProjects() {
+        return {
+            projects: ['Q1 Launch', 'Website Redesign'],
+            clientId: this.client_id
+        };
+    }
+
+    getAuthorizationRequirements() {
+        return { type: 'oauth2', url: this.redirect_uri };
+    }
+}
+
+MockAsanaApi.requesterType = 'oauth2';
+
+class MockFrontifyApi {
+    constructor(params) {
+        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;
+    }
+
+    async listBrands() {
+        return {
+            brands: ['Main Brand', 'Sub Brand'],
+            domain: this.domain,
+            token: this.access_token
+        };
+    }
+
+    async searchAssets(query) {
+        return {
+            query,
+            assets: ['logo.svg', 'guidelines.pdf'],
+            clientSecret: this.client_secret ? 'hidden' : null
+        };
+    }
+
+    getAuthorizationRequirements() {
+        return { type: 'oauth2', url: this.redirect_uri };
+    }
+}
+
+MockFrontifyApi.requesterType = 'oauth2';
+
+// Module definitions with env variables
+const asanaDefinition = {
+    moduleName: 'asana',
+    modelName: 'Asana',
+    API: MockAsanaApi,
+    requiredAuthMethods: {
+        getToken: async () => {},
+        getEntityDetails: async () => {},
+        getCredentialDetails: async () => {},
+        apiPropertiesToPersist: {
+            credential: ['access_token', 'refresh_token'],
+            entity: [],
+        },
+        testAuthRequest: async () => true,
+    },
+    env: {
+        client_id: 'ASANA_CLIENT_ID_FROM_ENV',
+        client_secret: 'ASANA_SECRET_FROM_ENV',
+        redirect_uri: 'https://app.example.com/auth/asana',
+        scope: 'default',
+    },
+};
+
+const frontifyDefinition = {
+    moduleName: 'frontify',
+    modelName: 'Frontify',
+    API: MockFrontifyApi,
+    requiredAuthMethods: {
+        getToken: async () => {},
+        getEntityDetails: async () => {},
+        getCredentialDetails: async () => {},
+        apiPropertiesToPersist: {
+            credential: ['access_token', 'refresh_token'],
+            entity: ['domain'],
+        },
+        testAuthRequest: async () => true,
+    },
+    env: {
+        client_id: 'FRONTIFY_CLIENT_ID_FROM_ENV',
+        client_secret: 'FRONTIFY_SECRET_FROM_ENV',
+        redirect_uri: 'https://app.example.com/auth/frontify',
+        scope: 'read write',
+    },
+};
+
+// Integration class similar to AsanaIntegration
+class TestIntegration extends IntegrationBase {
+    static Definition = {
+        name: 'test-integration',
+        version: '1.0.0',
+        modules: {
+            asana: {
+                definition: asanaDefinition,
+            },
+            frontify: {
+                definition: frontifyDefinition,
+            },
+        },
+    };
+
+    async performBusinessLogic() {
+        // After hydration, this method can use API modules
+        const folders = await this.asana.api.getFolders();
+        const brands = await this.frontify.api.listBrands();
+        return { folders, brands };
+    }
+}
+
+describe('LoadIntegrationContextUseCase - Full Rounded Test', () => {
+    it('should load integration with working API modules that have env vars and credentials', async () => {
+        // Setup: Create entities with credentials (simulating DB records)
+        const entities = [
+            {
+                id: 'entity-asana-123',
+                moduleName: 'asana',
+                userId: 'user-789',
+                credential: {
+                    data: {
+                        access_token: 'asana_access_token_xyz',
+                        refresh_token: 'asana_refresh_token_abc',
+                    },
+                },
+            },
+            {
+                id: 'entity-frontify-456',
+                moduleName: 'frontify',
+                userId: 'user-789',
+                domain: 'customer.frontify.com',
+                credential: {
+                    data: {
+                        access_token: 'frontify_access_token_uvw',
+                        refresh_token: 'frontify_refresh_token_def',
+                    },
+                },
+            },
+        ];
+
+        // Mock repositories
+        const moduleRepository = {
+            findEntitiesByIds: jest.fn().mockResolvedValue(entities),
+            findEntityById: jest.fn().mockImplementation((id) =>
+                Promise.resolve(entities.find(e => e.id === id))
+            ),
+        };
+
+        // Create module factory with definitions
+        const moduleFactory = new ModuleFactory({
+            moduleRepository,
+            moduleDefinitions: [asanaDefinition, frontifyDefinition],
+        });
+
+        // Create the use case
+        const useCase = new LoadIntegrationContextUseCase({
+            integrationRepository: createIntegrationRepository(),
+            moduleRepository,
+            moduleFactory,
+        });
+
+        // Execute: Load integration context
+        const integrationRecord = {
+            id: 'integration-999',
+            userId: 'user-789',
+            entitiesIds: ['entity-asana-123', 'entity-frontify-456'],
+            status: 'active',
+            config: { someConfig: true },
+        };
+
+        const context = await useCase.execute({ integrationRecord });
+
+        // Verify: Context has modules
+        expect(context.modules).toHaveLength(2);
+
+        // Create integration instance and hydrate it
+        const integration = new TestIntegration();
+        integration.setIntegrationRecord(context);
+
+        // Verify: Integration has modules attached
+        expect(integration.asana).toBeDefined();
+        expect(integration.frontify).toBeDefined();
+        expect(integration.modules.asana).toBe(integration.asana);
+        expect(integration.modules.frontify).toBe(integration.frontify);
+
+        // CRITICAL TEST: Verify API instances have env vars from definition
+        expect(integration.asana.api.client_id).toBe('ASANA_CLIENT_ID_FROM_ENV');
+        expect(integration.asana.api.client_secret).toBe('ASANA_SECRET_FROM_ENV');
+        expect(integration.asana.api.redirect_uri).toBe('https://app.example.com/auth/asana');
+        expect(integration.asana.api.scope).toBe('default');
+
+        expect(integration.frontify.api.client_id).toBe('FRONTIFY_CLIENT_ID_FROM_ENV');
+        expect(integration.frontify.api.client_secret).toBe('FRONTIFY_SECRET_FROM_ENV');
+        expect(integration.frontify.api.redirect_uri).toBe('https://app.example.com/auth/frontify');
+        expect(integration.frontify.api.scope).toBe('read write');
+
+        // CRITICAL TEST: Verify API instances have credentials from entities
+        expect(integration.asana.api.access_token).toBe('asana_access_token_xyz');
+        expect(integration.asana.api.refresh_token).toBe('asana_refresh_token_abc');
+
+        expect(integration.frontify.api.access_token).toBe('frontify_access_token_uvw');
+        expect(integration.frontify.api.refresh_token).toBe('frontify_refresh_token_def');
+        expect(integration.frontify.api.domain).toBe('customer.frontify.com');
+
+        // CRITICAL TEST: Can call API methods successfully
+        const folders = await integration.asana.api.getFolders();
+        expect(folders.folders).toEqual(['Marketing', 'Development', 'Design']);
+        expect(folders.usedToken).toBe('asana_access_token_xyz');
+
+        const projects = await integration.asana.api.listProjects();
+        expect(projects.projects).toEqual(['Q1 Launch', 'Website Redesign']);
+        expect(projects.clientId).toBe('ASANA_CLIENT_ID_FROM_ENV');
+
+        const brands = await integration.frontify.api.listBrands();
+        expect(brands.brands).toEqual(['Main Brand', 'Sub Brand']);
+        expect(brands.domain).toBe('customer.frontify.com');
+        expect(brands.token).toBe('frontify_access_token_uvw');
+
+        const assets = await integration.frontify.api.searchAssets('logo');
+        expect(assets.query).toBe('logo');
+        expect(assets.assets).toEqual(['logo.svg', 'guidelines.pdf']);
+        expect(assets.clientSecret).toBe('hidden'); // Verifies secret exists
+
+        // CRITICAL TEST: Business logic methods can use hydrated APIs
+        const businessResult = await integration.performBusinessLogic();
+        expect(businessResult.folders.folders).toEqual(['Marketing', 'Development', 'Design']);
+        expect(businessResult.brands.brands).toEqual(['Main Brand', 'Sub Brand']);
+
+        // Verify the complete chain: env → Module → API → Integration
+        console.log('\n✅ Full Integration Test Results:');
+        console.log('  ENV vars injected: ✓');
+        console.log('  Credentials injected: ✓');
+        console.log('  API methods callable: ✓');
+        console.log('  Business logic works: ✓');
+    });
+
+    it('should handle missing credentials gracefully', async () => {
+        // Entity without credentials
+        const entities = [
+            {
+                id: 'entity-no-creds',
+                moduleName: 'asana',
+                userId: 'user-123',
+                credential: {
+                    data: {
+                        // Empty credential data - no access_token
+                    },
+                },
+            },
+        ];
+
+        const moduleRepository = {
+            findEntitiesByIds: jest.fn().mockResolvedValue(entities),
+            findEntityById: jest.fn().mockResolvedValue(entities[0]),
+        };
+
+        const moduleFactory = new ModuleFactory({
+            moduleRepository,
+            moduleDefinitions: [asanaDefinition],
+        });
+
+        const useCase = new LoadIntegrationContextUseCase({
+            integrationRepository: createIntegrationRepository(),
+            moduleRepository,
+            moduleFactory,
+        });
+
+        const context = await useCase.execute({
+            integrationRecord: {
+                id: 'integration-1',
+                userId: 'user-123',
+                entitiesIds: ['entity-no-creds'],
+            },
+        });
+
+        const integration = new TestIntegration();
+        integration.setIntegrationRecord(context);
+
+        // Should have module with env vars but no credentials
+        expect(integration.asana).toBeDefined();
+        expect(integration.asana.api.client_id).toBe('ASANA_CLIENT_ID_FROM_ENV');
+        expect(integration.asana.api.access_token).toBeUndefined();
+
+        // API method should fail without token
+        await expect(integration.asana.api.getFolders()).rejects.toThrow('No access token');
+    });
+});

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

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

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

@@ -0,0 +1,114 @@
+const { LoadIntegrationContextUseCase } = require('./load-integration-context');
+
+class FakeIntegration {}
+FakeIntegration.Definition = {
+    name: 'fake',
+    modules: {},
+};
+
+describe('LoadIntegrationContextUseCase', () => {
+    it('throws when neither integrationId nor integrationRecord resolve to a record', async () => {
+        const integrationRepository = {
+            findIntegrationById: jest.fn().mockResolvedValue(null),
+        };
+
+        const useCase = new LoadIntegrationContextUseCase({
+            integrationClass: FakeIntegration,
+            integrationRepository,
+            moduleRepository: { findEntitiesByIds: jest.fn() },
+            moduleFactory: { getModuleInstance: jest.fn() },
+        });
+
+        await expect(
+            useCase.execute({ integrationId: 'missing-id' })
+        ).rejects.toMatchObject({
+            message: 'Integration record not found',
+            code: 'INTEGRATION_RECORD_NOT_FOUND',
+        });
+    });
+
+    it('returns record with empty entities/modules when no entity ids provided', async () => {
+        const integrationRecord = {
+            id: 'integration-1',
+            userId: 'user-1',
+            entitiesIds: [],
+        };
+
+        const moduleRepository = { findEntitiesByIds: jest.fn() };
+        const moduleFactory = { getModuleInstance: jest.fn() };
+
+        const useCase = new LoadIntegrationContextUseCase({
+            integrationClass: FakeIntegration,
+            integrationRepository: {},
+            moduleRepository,
+            moduleFactory,
+        });
+
+        const result = await useCase.execute({ integrationRecord });
+
+        expect(result).toEqual({
+            record: {
+                ...integrationRecord,
+                entities: [],
+            },
+            modules: [],
+        });
+        expect(moduleRepository.findEntitiesByIds).not.toHaveBeenCalled();
+        expect(moduleFactory.getModuleInstance).not.toHaveBeenCalled();
+    });
+
+    it('hydrates modules and entities when entity ids are provided', async () => {
+        const integrationRecord = {
+            id: 'integration-2',
+            userId: 'user-2',
+            entitiesIds: ['entity-1', 'entity-2'],
+        };
+
+        const entities = [
+            { id: 'entity-1', name: 'First Entity' },
+            { id: 'entity-2', name: 'Second Entity' },
+        ];
+
+        const modules = [{ name: 'module-1' }, { name: 'module-2' }];
+
+        const moduleRepository = {
+            findEntitiesByIds: jest.fn().mockResolvedValue(entities),
+        };
+        const moduleFactory = {
+            getModuleInstance: jest
+                .fn()
+                .mockResolvedValueOnce(modules[0])
+                .mockResolvedValueOnce(modules[1]),
+        };
+
+        const useCase = new LoadIntegrationContextUseCase({
+            integrationClass: FakeIntegration,
+            integrationRepository: {},
+            moduleRepository,
+            moduleFactory,
+        });
+
+        const result = await useCase.execute({ integrationRecord });
+
+        expect(moduleRepository.findEntitiesByIds).toHaveBeenCalledWith(
+            integrationRecord.entitiesIds
+        );
+        expect(moduleFactory.getModuleInstance).toHaveBeenNthCalledWith(
+            1,
+            'entity-1',
+            integrationRecord.userId
+        );
+        expect(moduleFactory.getModuleInstance).toHaveBeenNthCalledWith(
+            2,
+            'entity-2',
+            integrationRecord.userId
+        );
+        expect(result).toEqual({
+            record: {
+                ...integrationRecord,
+                entities,
+            },
+            modules,
+        });
+    });
+});

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

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

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

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