@friggframework/core 2.0.0--canary.522.cbd3d5a.0 → 2.0.0--canary.517.35ee143.0

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

@@ -31,21 +31,13 @@ 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,
@@ -57,52 +49,30 @@ 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;
     }
 
@@ -110,19 +80,9 @@ 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;
     }
@@ -136,4 +96,4 @@ class TestIntegrationRepository {
     }
 }
 
-module.exports = { TestIntegrationRepository };
+module.exports = { TestIntegrationRepository }; 

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

@@ -1,60 +1,56 @@
+// 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 === config.type
+                integrationClass.Definition.name ===
+                integrationRecord.config.type
         );
 
         if (!integrationClass) {
             throw new Error(
-                `No integration class found for type: ${config.type}`
+                `No integration class found for type: ${integrationRecord.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,9 +68,7 @@ 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}`);
@@ -85,15 +83,11 @@ 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(', ')}`
             );
         }
 
@@ -121,19 +115,14 @@ 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,11 +59,10 @@ 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(

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

@@ -1,7 +1,5 @@
 // Removed Integration wrapper - using IntegrationBase directly
-const {
-    mapIntegrationClassToIntegrationDTO,
-} = require('../utils/map-integration-dto');
+const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
 const Boom = require('@hapi/boom');
 
 /**
@@ -17,12 +15,8 @@ class GetIntegrationForUser {
      * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management.
      * @param {import('../../modules/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository - Repository for module and entity data operations.
      */
-    constructor({
-        integrationRepository,
-        integrationClasses,
-        moduleFactory,
-        moduleRepository,
-    }) {
+    constructor({ integrationRepository, integrationClasses, moduleFactory, moduleRepository }) {
+
         /**
          * @type {import('../integration-repository-interface').IntegrationRepositoryInterface}
          */
@@ -42,28 +36,19 @@ class GetIntegrationForUser {
      * @throws {Boom.forbidden} When user does not have access to the integration.
      */
     async execute(integrationId, userId) {
-        const integrationRecord =
-            await this.integrationRepository.findIntegrationById(integrationId);
-        const entities = await this.moduleRepository.findEntitiesByIds(
-            integrationRecord.entitiesIds
-        );
+        const integrationRecord = await this.integrationRepository.findIntegrationById(integrationId);
+        const entities = await this.moduleRepository.findEntitiesByIds(integrationRecord.entitiesIds);
 
         if (!integrationRecord) {
-            throw Boom.notFound(
-                `Integration with id of ${integrationId} does not exist`
-            );
+            throw Boom.notFound(`Integration with id of ${integrationId} does not exist`);
         }
 
         if (integrationRecord.userId.toString() !== userId.toString()) {
-            throw Boom.forbidden(
-                'User does not have access to this integration'
-            );
+            throw Boom.forbidden('User does not have access to this integration');
         }
 
         const integrationClass = this.integrationClasses.find(
-            (integrationClass) =>
-                integrationClass.Definition.name ===
-                integrationRecord.config.type
+            (integrationClass) => integrationClass.Definition.name === integrationRecord.config.type
         );
 
         const modules = [];
@@ -83,11 +68,11 @@ class GetIntegrationForUser {
             status: integrationRecord.status,
             version: integrationRecord.version,
             messages: integrationRecord.messages,
-            modules,
+            modules
         });
 
         return mapIntegrationClassToIntegrationDTO(integrationInstance);
     }
 }
 
-module.exports = { GetIntegrationForUser };
+module.exports = { GetIntegrationForUser }; 

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

@@ -14,6 +14,7 @@ class GetIntegrationInstanceByDefinition {
      * @param {import('../../modules/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository - Repository for module and entity data operations.
      */
     constructor({ integrationRepository, moduleFactory, moduleRepository }) {
+
         /**
          * @type {import('../integration-repository-interface').IntegrationRepositoryInterface}
          */
@@ -29,20 +30,13 @@ class GetIntegrationInstanceByDefinition {
      * @throws {Boom.notFound} When integration with the specified definition does not exist.
      */
     async execute(integrationClass) {
-        const integrationRecord =
-            await this.integrationRepository.findIntegrationByName(
-                integrationClass.Definition.name
-            );
+        const integrationRecord = await this.integrationRepository.findIntegrationByName(integrationClass.Definition.name);
 
         if (!integrationRecord) {
-            throw Boom.notFound(
-                `Integration with name of ${integrationClass.Definition.name} does not exist`
-            );
+            throw Boom.notFound(`Integration with name of ${integrationClass.Definition.name} does not exist`);
         }
 
-        const entities = await this.moduleRepository.findEntitiesByIds(
-            integrationRecord.entitiesIds
-        );
+        const entities = await this.moduleRepository.findEntitiesByIds(integrationRecord.entitiesIds);
 
         const modules = [];
         for (const entity of entities) {
@@ -61,13 +55,13 @@ class GetIntegrationInstanceByDefinition {
             status: integrationRecord.status,
             version: integrationRecord.version,
             messages: integrationRecord.messages,
-            modules,
+            modules
         });
 
         await integrationInstance.initialize();
 
-        return integrationInstance;
+        return integrationInstance
     }
 }
 
-module.exports = { GetIntegrationInstanceByDefinition };
+module.exports = { GetIntegrationInstanceByDefinition }; 

package/integrations/use-cases/get-integrations-for-user.js

@@ -71,10 +71,7 @@ class GetIntegrationsForUser {
                 config: integrationRecord.config,
                 status: integrationRecord.status,
                 version: integrationRecord.version,
-                messages: integrationRecord.messages || {
-                    errors: [],
-                    warnings: [],
-                },
+                messages: integrationRecord.messages || { errors: [], warnings: [] },
                 modules,
                 options: integrationClass.getOptionDetails(),
             };

package/integrations/use-cases/get-possible-integrations.js

@@ -24,4 +24,4 @@ class GetPossibleIntegrations {
     }
 }
 
-module.exports = { GetPossibleIntegrations };
+module.exports = { GetPossibleIntegrations };

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

@@ -1,14 +1,14 @@
 /**
  * GetProcess Use Case
- *
+ * 
  * Retrieves a process by ID with proper error handling.
  * Simple use case that delegates to repository.
- *
+ * 
  * Design Philosophy:
  * - Use cases provide consistent error handling
  * - Business logic layer between controllers and repositories
  * - Return null for not found vs throwing error (configurable)
- *
+ * 
  * @example
  * const getProcess = new GetProcess({ processRepository });
  * const process = await getProcess.execute(processId);
@@ -75,12 +75,13 @@ class GetProcess {
         }
 
         const processes = await Promise.all(
-            processIds.map((id) => this.execute(id))
+            processIds.map(id => this.execute(id))
         );
 
         // Filter out nulls (not found)
-        return processes.filter((p) => p !== null);
+        return processes.filter(p => p !== null);
     }
 }
 
 module.exports = { GetProcess };
+

package/integrations/use-cases/index.js

@@ -6,7 +6,6 @@ const { CreateProcess } = require('./create-process');
 const { UpdateProcessState } = require('./update-process-state');
 const { UpdateProcessMetrics } = require('./update-process-metrics');
 const { GetProcess } = require('./get-process');
-const { ExecuteProxyRequest } = require('./execute-proxy-request');
 
 module.exports = {
     GetIntegrationsForUser,
@@ -17,5 +16,4 @@ module.exports = {
     UpdateProcessState,
     UpdateProcessMetrics,
     GetProcess,
-    ExecuteProxyRequest,
-};
+}; 

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

@@ -1,5 +1,9 @@
 class LoadIntegrationContextUseCase {
-    constructor({ integrationRepository, moduleRepository, moduleFactory }) {
+    constructor({
+        integrationRepository,
+        moduleRepository,
+        moduleFactory,
+    }) {
         if (!integrationRepository) {
             throw new Error('integrationRepository is required');
         }

package/integrations/use-cases/update-process-state.js

@@ -1,20 +1,20 @@
 /**
  * UpdateProcessState Use Case
- *
+ * 
  * Updates the state of a process and optionally merges context updates.
  * Handles state transitions in the process state machine.
- *
+ * 
  * Design Philosophy:
  * - State transitions are explicit and tracked
  * - Context updates are merged (not replaced) to preserve data
  * - Repository handles persistence, use case handles business logic
- *
+ * 
  * State Machine (CRM Sync Example):
- * INITIALIZING → FETCHING_TOTAL → QUEUING_PAGES → PROCESSING_BATCHES →
+ * INITIALIZING → FETCHING_TOTAL → QUEUING_PAGES → PROCESSING_BATCHES → 
  * COMPLETING → COMPLETED
- *
+ * 
  * Any state can transition to ERROR on failure.
- *
+ * 
  * @example
  * const updateProcessState = new UpdateProcessState({ processRepository });
  * await updateProcessState.execute(processId, 'FETCHING_TOTAL', {
@@ -75,10 +75,7 @@ class UpdateProcessState {
 
         // Persist updates
         try {
-            const updatedProcess = await this.processRepository.update(
-                processId,
-                updates
-            );
+            const updatedProcess = await this.processRepository.update(processId, updates);
             return updatedProcess;
         } catch (error) {
             throw new Error(`Failed to update process state: ${error.message}`);
@@ -119,3 +116,4 @@ class UpdateProcessState {
 }
 
 module.exports = { UpdateProcessState };
+

package/integrations/utils/map-integration-dto.js

@@ -15,14 +15,11 @@ function mapIntegrationClassToIntegrationDTO(integration) {
         version: integration.version,
         messages: integration.messages,
         userActions: integration.userActions,
-        options:
-            integration.options ||
-            (typeof integration.getOptionDetails === 'function'
-                ? integration.getOptionDetails()
-                : null),
+        options: integration.options || (typeof integration.getOptionDetails === 'function' ? integration.getOptionDetails() : null),
     };
 }
 
+
 const getModulesDefinitionFromIntegrationClasses = (integrationClasses) => {
     return [
         ...new Set(
@@ -37,7 +34,4 @@ const getModulesDefinitionFromIntegrationClasses = (integrationClasses) => {
     ];
 };
 
-module.exports = {
-    mapIntegrationClassToIntegrationDTO,
-    getModulesDefinitionFromIntegrationClasses,
-};
+module.exports = { mapIntegrationClassToIntegrationDTO, getModulesDefinitionFromIntegrationClasses }; 

package/jest-setup.js

@@ -1,2 +1,2 @@
-const { globalSetup } = require('@friggframework/test');
+const {globalSetup} = require('@friggframework/test');
 module.exports = globalSetup;

package/jest-teardown.js

@@ -1,2 +1,2 @@
-const { globalTeardown } = require('@friggframework/test');
+const {globalTeardown} = require('@friggframework/test');
 module.exports = globalTeardown;

package/lambda/TimeoutCatcher.js

@@ -2,44 +2,42 @@ const isPositive = (n) => Number.isFinite(n) && n > 0;
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 class TimeoutCatcher {
-    constructor({ work, timeout, cleanUp = () => {}, cleanUpTime = 2_000 }) {
-        this.isFinished = false;
-        this.work = work;
-        this.cleanUp = cleanUp;
-        this.waitTime = timeout - cleanUpTime;
-
-        if (!isPositive(this.waitTime))
-            throw new Error(
-                'Wait time was not a positive number of milliseconds'
-            );
+  constructor({ work, timeout, cleanUp = () => {}, cleanUpTime = 2_000 }) {
+    this.isFinished = false;
+    this.work = work;
+    this.cleanUp = cleanUp;
+    this.waitTime = timeout - cleanUpTime;
+
+    if (!isPositive(this.waitTime))
+      throw new Error("Wait time was not a positive number of milliseconds");
+  }
+
+  async watch() {
+    try {
+      await Promise.race([this.doWork(), this.exitBeforeTimeout()]);
+      return true;
+    } catch (error) {
+      if (error.isSentinelTimeout) return false;
+      throw error;
     }
+  }
 
-    async watch() {
-        try {
-            await Promise.race([this.doWork(), this.exitBeforeTimeout()]);
-            return true;
-        } catch (error) {
-            if (error.isSentinelTimeout) return false;
-            throw error;
-        }
-    }
-
-    async doWork() {
-        await this.work();
-        this.isFinished = true;
-    }
+  async doWork() {
+    await this.work();
+    this.isFinished = true;
+  }
 
-    async exitBeforeTimeout() {
-        await sleep(this.waitTime);
+  async exitBeforeTimeout() {
+    await sleep(this.waitTime);
 
-        if (!this.isFinished) {
-            await this.cleanUp();
+    if (!this.isFinished) {
+      await this.cleanUp();
 
-            const error = new Error('Sentinel Timed Out');
-            error.isSentinelTimeout = true;
-            throw error;
-        }
+      const error = new Error("Sentinel Timed Out");
+      error.isSentinelTimeout = true;
+      throw error;
     }
+  }
 }
 
 module.exports = { TimeoutCatcher };

package/lambda/index.js

@@ -1,3 +1,3 @@
 const { TimeoutCatcher } = require('./TimeoutCatcher');
 
-module.exports = { TimeoutCatcher };
+module.exports = { TimeoutCatcher }

package/logs/index.js

@@ -1,7 +1,7 @@
-const { debug, initDebugLog, flushDebugLog } = require('./logger');
+const {debug, initDebugLog, flushDebugLog} = require('./logger');
 
 module.exports = {
     debug,
     initDebugLog,
-    flushDebugLog,
-};
+    flushDebugLog
+}