@friggframework/core 2.0.0--canary.548.c8ae0ca.0 → 2.0.0--canary.545.c40eca4.0

package/integrations/tests/doubles/dummy-integration-class.js

@@ -1,8 +1,9 @@
 const { IntegrationBase } = require('../../integration-base');
+const { Options } = require('../../options');
 
 class DummyModule {
     static definition = {
-        getName: () => 'dummy'
+        getName: () => 'dummy',
     };
 }
 
@@ -11,21 +12,25 @@ class DummyIntegration extends IntegrationBase {
         name: 'dummy',
         version: '1.0.0',
         modules: {
-            dummy: DummyModule
+            dummy: DummyModule,
         },
         display: {
             label: 'Dummy Integration',
             description: 'A dummy integration for testing',
             detailsUrl: 'https://example.com',
-            icon: 'dummy-icon'
-        }
+            icon: 'dummy-icon',
+        },
     };
 
     static getOptionDetails() {
+        const options = new Options({
+            module: Object.values(this.Definition.modules)[0],
+            ...this.Definition,
+        });
         return {
             name: this.Definition.name,
             version: this.Definition.version,
-            display: this.Definition.display
+            ...options.get(),
         };
     }
 
@@ -41,11 +46,11 @@ class DummyIntegration extends IntegrationBase {
         };
 
         this.updateIntegrationStatus = {
-            execute: jest.fn().mockResolvedValue({})
+            execute: jest.fn().mockResolvedValue({}),
         };
 
         this.updateIntegrationMessages = {
-            execute: jest.fn().mockResolvedValue({})
+            execute: jest.fn().mockResolvedValue({}),
         };
     }
 
@@ -102,4 +107,72 @@ class DummyIntegration extends IntegrationBase {
     }
 }
 
-module.exports = { DummyIntegration }; 
+class DummyIntegrationWithGlobalEntity extends IntegrationBase {
+    static Definition = {
+        name: 'dummy-with-global',
+        version: '1.0.0',
+        modules: { dummy: DummyModule },
+        display: { label: 'Dummy With Global', description: 'Test' },
+        entities: {
+            sharedService: {
+                type: 'shared-api',
+                global: true,
+                required: true,
+            },
+        },
+    };
+
+    constructor(params) {
+        super(params);
+        this.sendSpy = jest.fn();
+        this.integrationRepository = {
+            updateIntegrationById: jest.fn().mockResolvedValue({}),
+            findIntegrationById: jest.fn().mockResolvedValue({}),
+        };
+        this.updateIntegrationStatus = { execute: jest.fn().mockResolvedValue({}) };
+        this.updateIntegrationMessages = { execute: jest.fn().mockResolvedValue({}) };
+    }
+
+    async loadDynamicUserActions() { return {}; }
+    async send(event, data) { this.sendSpy(event, data); return { event, data }; }
+    async initialize() { return; }
+    async onCreate() { return; }
+}
+
+class DummyIntegrationWithOptionalGlobalEntity extends IntegrationBase {
+    static Definition = {
+        name: 'dummy-with-optional-global',
+        version: '1.0.0',
+        modules: { dummy: DummyModule },
+        display: { label: 'Dummy With Optional Global', description: 'Test' },
+        entities: {
+            optionalService: {
+                type: 'optional-api',
+                global: true,
+                required: false,
+            },
+        },
+    };
+
+    constructor(params) {
+        super(params);
+        this.sendSpy = jest.fn();
+        this.integrationRepository = {
+            updateIntegrationById: jest.fn().mockResolvedValue({}),
+            findIntegrationById: jest.fn().mockResolvedValue({}),
+        };
+        this.updateIntegrationStatus = { execute: jest.fn().mockResolvedValue({}) };
+        this.updateIntegrationMessages = { execute: jest.fn().mockResolvedValue({}) };
+    }
+
+    async loadDynamicUserActions() { return {}; }
+    async send(event, data) { this.sendSpy(event, data); return { event, data }; }
+    async initialize() { return; }
+    async onCreate() { return; }
+}
+
+module.exports = {
+    DummyIntegration,
+    DummyIntegrationWithGlobalEntity,
+    DummyIntegrationWithOptionalGlobalEntity,
+};

package/integrations/tests/doubles/test-integration-repository.js

@@ -31,13 +31,21 @@ class TestIntegrationRepository {
     }
 
     async findIntegrationsByUserId(userId) {
-        const results = Array.from(this.store.values()).filter(r => r.userId === userId);
-        this.operationHistory.push({ operation: 'findByUserId', userId, count: results.length });
+        const results = Array.from(this.store.values()).filter(
+            (r) => r.userId === userId
+        );
+        this.operationHistory.push({
+            operation: 'findByUserId',
+            userId,
+            count: results.length,
+        });
         return results;
     }
 
     async findIntegrationByUserId(userId) {
-        const record = Array.from(this.store.values()).find((r) => r.userId === userId);
+        const record = Array.from(this.store.values()).find(
+            (r) => r.userId === userId
+        );
         this.operationHistory.push({
             operation: 'findSingleByUserId',
             userId,
@@ -49,30 +57,52 @@ class TestIntegrationRepository {
     async updateIntegrationMessages(id, type, title, body, timestamp) {
         const rec = this.store.get(id);
         if (!rec) {
-            this.operationHistory.push({ operation: 'updateMessages', id, success: false });
+            this.operationHistory.push({
+                operation: 'updateMessages',
+                id,
+                success: false,
+            });
             return false;
         }
         if (!rec.messages[type]) rec.messages[type] = [];
         rec.messages[type].push({ title, message: body, timestamp });
-        this.operationHistory.push({ operation: 'updateMessages', id, type, success: true });
+        this.operationHistory.push({
+            operation: 'updateMessages',
+            id,
+            type,
+            success: true,
+        });
         return true;
     }
 
     async updateIntegrationConfig(id, config) {
         const rec = this.store.get(id);
         if (!rec) {
-            this.operationHistory.push({ operation: 'updateConfig', id, success: false });
+            this.operationHistory.push({
+                operation: 'updateConfig',
+                id,
+                success: false,
+            });
             throw new Error(`Integration with id ${id} not found`);
         }
         rec.config = config;
-        this.operationHistory.push({ operation: 'updateConfig', id, success: true });
+        this.operationHistory.push({
+            operation: 'updateConfig',
+            id,
+            success: true,
+        });
         return rec;
     }
 
     async deleteIntegrationById(id) {
         const existed = this.store.has(id);
         const result = this.store.delete(id);
-        this.operationHistory.push({ operation: 'delete', id, existed, success: result });
+        this.operationHistory.push({
+            operation: 'delete',
+            id,
+            existed,
+            success: result,
+        });
         return result;
     }
 
@@ -80,9 +110,19 @@ class TestIntegrationRepository {
         const rec = this.store.get(id);
         if (rec) {
             rec.status = status;
-            this.operationHistory.push({ operation: 'updateStatus', id, status, success: true });
+            this.operationHistory.push({
+                operation: 'updateStatus',
+                id,
+                status,
+                success: true,
+            });
         } else {
-            this.operationHistory.push({ operation: 'updateStatus', id, status, success: false });
+            this.operationHistory.push({
+                operation: 'updateStatus',
+                id,
+                status,
+                success: false,
+            });
         }
         return !!rec;
     }
@@ -96,4 +136,4 @@ class TestIntegrationRepository {
     }
 }
 
-module.exports = { TestIntegrationRepository }; 
+module.exports = { TestIntegrationRepository };

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

@@ -1,56 +1,60 @@
-// Removed Integration wrapper - using IntegrationBase directly
 const {
     mapIntegrationClassToIntegrationDTO,
 } = require('../utils/map-integration-dto');
 
-/**
- * Use case for creating a new integration instance.
- * @class CreateIntegration
- */
 class CreateIntegration {
-    /**
-     * Creates a new CreateIntegration instance.
-     * @param {Object} params - Configuration parameters.
-     * @param {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface} params.integrationRepository - Repository for integration data operations.
-     * @param {import('../integration-classes').IntegrationClasses} 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 creation process.
-     * @async
-     * @param {string[]} entities - Array of entity IDs to associate with the integration.
-     * @param {string} userId - ID of the user creating the integration.
-     * @param {Object} config - Configuration object for the integration.
-     * @param {string} config.type - Type of integration to create.
-     * @returns {Promise<Object>} The created integration DTO.
-     * @throws {Error} When integration class is not found for the specified type.
-     */
     async execute(entities, userId, config) {
-        const integrationRecord =
-            await this.integrationRepository.createIntegration(
-                entities,
-                userId,
-                config
-            );
-
         const integrationClass = this.integrationClasses.find(
             (integrationClass) =>
-                integrationClass.Definition.name ===
-                integrationRecord.config.type
+                integrationClass.Definition.name === config.type
         );
 
         if (!integrationClass) {
             throw new Error(
-                `No integration class found for type: ${integrationRecord.config.type}`
+                `No integration class found for type: ${config.type}`
             );
         }
 
+        const allEntities = [...entities];
+
+        if (integrationClass.Definition?.entities) {
+            for (const [entityKey, entityConfig] of Object.entries(
+                integrationClass.Definition.entities
+            )) {
+                if (entityConfig.global === true) {
+                    const globalEntity =
+                        await this.moduleFactory.moduleRepository.findEntity({
+                            moduleName: entityConfig.type,
+                            isGlobal: true,
+                        });
+
+                    if (globalEntity && globalEntity.credential?.authIsValid) {
+                        allEntities.push(globalEntity.id.toString());
+                    } else if (entityConfig.required !== false) {
+                        const reason = !globalEntity
+                            ? 'not found'
+                            : 'exists but credential is invalid';
+                        throw new Error(
+                            `Required global entity "${entityConfig.type}" ${reason}. Admin must configure this entity first.`
+                        );
+                    }
+                }
+            }
+        }
+
+        const integrationRecord =
+            await this.integrationRepository.createIntegration(
+                allEntities,
+                userId,
+                config
+            );
+
         const modules = [];
         for (const entityId of integrationRecord.entitiesIds) {
             const moduleInstance = await this.moduleFactory.getModuleInstance(

package/integrations/use-cases/create-process.js

@@ -1,15 +1,15 @@
 /**
  * CreateProcess Use Case
- * 
+ *
  * Creates a new process record for tracking long-running operations.
  * Validates required fields and delegates persistence to the repository.
- * 
+ *
  * Design Philosophy:
  * - Use cases encapsulate business logic
  * - Validation happens at the use case layer
  * - Repositories handle only data access
  * - Process model is generic and reusable
- * 
+ *
  * @example
  * const createProcess = new CreateProcess({ processRepository });
  * const process = await createProcess.execute({
@@ -68,7 +68,9 @@ class CreateProcess {
 
         // Delegate to repository
         try {
-            const createdProcess = await this.processRepository.create(processToCreate);
+            const createdProcess = await this.processRepository.create(
+                processToCreate
+            );
             return createdProcess;
         } catch (error) {
             throw new Error(`Failed to create process: ${error.message}`);
@@ -83,11 +85,15 @@ class CreateProcess {
      */
     _validateProcessData(processData) {
         const requiredFields = ['userId', 'integrationId', 'name', 'type'];
-        const missingFields = requiredFields.filter(field => !processData[field]);
+        const missingFields = requiredFields.filter(
+            (field) => !processData[field]
+        );
 
         if (missingFields.length > 0) {
             throw new Error(
-                `Missing required fields for process creation: ${missingFields.join(', ')}`
+                `Missing required fields for process creation: ${missingFields.join(
+                    ', '
+                )}`
             );
         }
 
@@ -115,14 +121,19 @@ class CreateProcess {
         if (processData.results && typeof processData.results !== 'object') {
             throw new Error('results must be an object');
         }
-        if (processData.childProcesses && !Array.isArray(processData.childProcesses)) {
+        if (
+            processData.childProcesses &&
+            !Array.isArray(processData.childProcesses)
+        ) {
             throw new Error('childProcesses must be an array');
         }
-        if (processData.parentProcessId && typeof processData.parentProcessId !== 'string') {
+        if (
+            processData.parentProcessId &&
+            typeof processData.parentProcessId !== 'string'
+        ) {
             throw new Error('parentProcessId must be a string');
         }
     }
 }
 
 module.exports = { CreateProcess };
-

package/integrations/use-cases/delete-integration-for-user.js

@@ -59,10 +59,11 @@ class DeleteIntegrationForUser {
 
         for (const entityId of integrationRecord.entitiesIds) {
             try {
-                const moduleInstance = await this.moduleFactory.getModuleInstance(
-                    entityId,
-                    integrationRecord.userId
-                );
+                const moduleInstance =
+                    await this.moduleFactory.getModuleInstance(
+                        entityId,
+                        integrationRecord.userId
+                    );
                 modules.push(moduleInstance);
             } catch (error) {
                 console.error(