@friggframework/core 2.0.0--canary.395.a6dcc5a.0 → 2.0.0--canary.395.de6bcdf.0

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

@@ -0,0 +1,314 @@
+const { LoadIntegrationContextUseCase } = require('./load-integration-context');
+const { IntegrationBase } = require('../integration-base');
+const { Module } = require('../../modules/module');
+const { ModuleFactory } = require('../../modules/module-factory');
+const { ModuleRepository } = require('../../modules/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: {
+                    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: {
+                    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({
+            integrationClass: TestIntegration,
+            integrationRepository: {},
+            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',
+                // No credential property
+            },
+        ];
+
+        const moduleRepository = {
+            findEntitiesByIds: jest.fn().mockResolvedValue(entities),
+            findEntityById: jest.fn().mockResolvedValue(entities[0]),
+        };
+
+        const moduleFactory = new ModuleFactory({
+            moduleRepository,
+            moduleDefinitions: [asanaDefinition],
+        });
+
+        const useCase = new LoadIntegrationContextUseCase({
+            integrationClass: TestIntegration,
+            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,77 @@
+const { IntegrationRepository } = require('../integration-repository');
+const { ModuleRepository } = require('../../modules/module-repository');
+const { ModuleFactory } = require('../../modules/module-factory');
+const { getModulesDefinitionFromIntegrationClasses } = require('../utils/map-integration-dto');
+
+class LoadIntegrationContextUseCase {
+    constructor({
+        integrationClass,
+        integrationRepository,
+        moduleRepository,
+        moduleFactory,
+    }) {
+        if (!integrationClass) {
+            throw new Error('integrationClass is required');
+        }
+
+        this.integrationClass = integrationClass;
+        this.integrationRepository = integrationRepository || new IntegrationRepository();
+        this.moduleRepository = moduleRepository || new ModuleRepository();
+
+        const moduleDefinitions = getModulesDefinitionFromIntegrationClasses([
+            integrationClass,
+        ]);
+
+        this.moduleFactory =
+            moduleFactory ||
+            new ModuleFactory({
+                moduleRepository: this.moduleRepository,
+                moduleDefinitions,
+            });
+    }
+
+    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/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/modules/index.js

@@ -5,6 +5,8 @@ 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 { ModuleRepository } = require('./module-repository');
 
 module.exports = {
     Credential,
@@ -14,4 +16,6 @@ module.exports = {
     OAuth2Requester,
     Requester,
     ModuleConstants,
+    ModuleFactory,
+    ModuleRepository,
 };

package/modules/module-factory.js

@@ -39,7 +39,7 @@ class ModuleFactory {
 
         if (!moduleDefinition) {
             throw new Error(
-                `Module definition not found for entity type: ${entityType}`
+                `Module definition not found for module: ${moduleName}`
             );
         }