@friggframework/core 2.0.0-next.8 → 2.0.0-next.81

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

@@ -0,0 +1,205 @@
+/**
+ * UpdateProcessMetrics Use Case
+ *
+ * Updates process metrics atomically via
+ * `processRepository.applyProcessUpdate`. This is the race-safe
+ * replacement for the original read-modify-write implementation — the
+ * long-standing TODO about lost updates under concurrent writers is
+ * now resolved.
+ *
+ * Split into two phases:
+ *
+ *   1. Atomic phase — counters and bounded error history. Uses
+ *      $inc / $push+$slice (Mongo/DocumentDB) or jsonb_set with
+ *      arithmetic expressions (Postgres) in a single UPDATE ... RETURNING
+ *      so concurrent callers serialize at the DB layer.
+ *
+ *   2. Derived-fields phase — duration, recordsPerSecond,
+ *      estimatedCompletion. Computed from the post-atomic snapshot and
+ *      written via the legacy (non-atomic) `update()` method.
+ *      Intentionally best-effort: under concurrent writers they reflect
+ *      "whichever handler wrote last" — the same semantics they had
+ *      before and all they've ever guaranteed. Preserved for backward
+ *      compatibility with consumers (UI, WebSocket listeners).
+ *
+ * Optionally broadcasts progress via WebSocket service if provided.
+ *
+ * @example
+ * const updateMetrics = new UpdateProcessMetrics({ processRepository, websocketService });
+ * await updateMetrics.execute(processId, {
+ *   processed: 100,
+ *   success: 95,
+ *   errors: 5,
+ *   errorDetails: [{ contactId: 'abc', error: 'Missing email', timestamp: '...' }]
+ * });
+ */
+class UpdateProcessMetrics {
+    /**
+     * @param {Object} params
+     * @param {ProcessRepositoryInterface} params.processRepository - Repository for process data access
+     * @param {Object} [params.websocketService] - Optional WebSocket service for progress broadcasting
+     */
+    constructor({ processRepository, websocketService }) {
+        if (!processRepository) {
+            throw new Error('processRepository is required');
+        }
+        this.processRepository = processRepository;
+        this.websocketService = websocketService;
+    }
+
+    /**
+     * Execute the use case to update process metrics
+     * @param {string} processId - Process ID to update
+     * @param {Object} metricsUpdate - Metrics to add/update
+     * @param {number} [metricsUpdate.processed=0] - Records processed in this batch
+     * @param {number} [metricsUpdate.success=0] - Successful records
+     * @param {number} [metricsUpdate.errors=0] - Failed records
+     * @param {Array} [metricsUpdate.errorDetails=[]] - Error details array
+     * @returns {Promise<Object>} Updated process record
+     * @throws {Error} If process not found or update fails
+     */
+    async execute(processId, metricsUpdate) {
+        if (!processId || typeof processId !== 'string') {
+            throw new Error('processId must be a non-empty string');
+        }
+        if (!metricsUpdate || typeof metricsUpdate !== 'object') {
+            throw new Error('metricsUpdate must be an object');
+        }
+
+        // Phase 1: atomic increments + bounded error history.
+        const increment = {};
+        const processed = metricsUpdate.processed || 0;
+        const success = metricsUpdate.success || 0;
+        const errors = metricsUpdate.errors || 0;
+        if (processed) increment['context.processedRecords'] = processed;
+        if (success) increment['results.aggregateData.totalSynced'] = success;
+        if (errors) increment['results.aggregateData.totalFailed'] = errors;
+
+        const pushSlice = {};
+        if (
+            Array.isArray(metricsUpdate.errorDetails) &&
+            metricsUpdate.errorDetails.length > 0
+        ) {
+            pushSlice['results.aggregateData.errors'] = {
+                values: metricsUpdate.errorDetails,
+                keepLast: 100,
+            };
+        }
+
+        const hasAtomicWork =
+            Object.keys(increment).length > 0 ||
+            Object.keys(pushSlice).length > 0;
+
+        let updatedProcess;
+        try {
+            if (hasAtomicWork) {
+                updatedProcess = await this.processRepository.applyProcessUpdate(
+                    processId,
+                    { increment, pushSlice }
+                );
+            } else {
+                // All-zero update (e.g., empty batch) — nothing to persist;
+                // just read current state for the derived-fields pass.
+                updatedProcess = await this.processRepository.findById(
+                    processId
+                );
+            }
+        } catch (error) {
+            throw new Error(
+                `Failed to update process metrics: ${error.message}`
+            );
+        }
+
+        if (!updatedProcess) {
+            throw new Error(`Process not found: ${processId}`);
+        }
+
+        // Phase 2: derived metrics (non-atomic, best-effort). Preserved
+        // for backward compatibility — these were always stale under
+        // concurrent writers even before this refactor.
+        const context = updatedProcess.context || {};
+        const results = updatedProcess.results || { aggregateData: {} };
+        if (!results.aggregateData) results.aggregateData = {};
+
+        if (context.processedRecords > 0 || context.totalRecords > 0) {
+            const startTime = new Date(
+                context.startTime || updatedProcess.createdAt
+            );
+            const elapsed = Date.now() - startTime.getTime();
+            results.aggregateData.duration = elapsed;
+
+            if (elapsed > 0 && context.processedRecords > 0) {
+                results.aggregateData.recordsPerSecond =
+                    context.processedRecords / (elapsed / 1000);
+            } else {
+                results.aggregateData.recordsPerSecond = 0;
+            }
+
+            if (context.totalRecords > 0 && context.processedRecords > 0) {
+                const remaining =
+                    context.totalRecords - context.processedRecords;
+                if (results.aggregateData.recordsPerSecond > 0) {
+                    const etaMs =
+                        (remaining / results.aggregateData.recordsPerSecond) *
+                        1000;
+                    const eta = new Date(Date.now() + etaMs);
+                    context.estimatedCompletion = eta.toISOString();
+                }
+            }
+
+            try {
+                updatedProcess = await this.processRepository.update(
+                    processId,
+                    { context, results }
+                );
+            } catch (error) {
+                // Derived-field write failures are NON-FATAL — atomic
+                // counters from phase 1 already landed. Log and return the
+                // post-atomic snapshot.
+                console.error(
+                    '[UpdateProcessMetrics] derived-fields write failed (non-fatal):',
+                    error.message
+                );
+            }
+        }
+
+        if (this.websocketService) {
+            await this._broadcastProgress(updatedProcess);
+        }
+
+        return updatedProcess;
+    }
+
+    /**
+     * Broadcast progress update via WebSocket
+     * @private
+     */
+    async _broadcastProgress(process) {
+        try {
+            const context = process.context || {};
+            const results = process.results || { aggregateData: {} };
+            const aggregateData = results.aggregateData || {};
+
+            await this.websocketService.broadcast({
+                type: 'PROCESS_PROGRESS',
+                data: {
+                    processId: process.id,
+                    processName: process.name,
+                    processType: process.type,
+                    state: process.state,
+                    processed: context.processedRecords || 0,
+                    total: context.totalRecords || 0,
+                    successCount: aggregateData.totalSynced || 0,
+                    errorCount: aggregateData.totalFailed || 0,
+                    recordsPerSecond: aggregateData.recordsPerSecond || 0,
+                    estimatedCompletion: context.estimatedCompletion || null,
+                    timestamp: new Date().toISOString(),
+                },
+            });
+        } catch (error) {
+            console.error('Failed to broadcast process progress:', error);
+        }
+    }
+}
+
+module.exports = { UpdateProcessMetrics };

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

@@ -0,0 +1,158 @@
+/**
+ * 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 → 
+ * COMPLETING → COMPLETED
+ * 
+ * Any state can transition to ERROR on failure.
+ * 
+ * @example
+ * const updateProcessState = new UpdateProcessState({ processRepository });
+ * await updateProcessState.execute(processId, 'FETCHING_TOTAL', {
+ *   currentPage: 1,
+ *   pagination: { pageSize: 100 }
+ * });
+ */
+class UpdateProcessState {
+    /**
+     * @param {Object} params
+     * @param {ProcessRepositoryInterface} params.processRepository - Repository for process data access
+     */
+    constructor({ processRepository }) {
+        if (!processRepository) {
+            throw new Error('processRepository is required');
+        }
+        this.processRepository = processRepository;
+    }
+
+    /**
+     * Execute the use case to update process state
+     * @param {string} processId - Process ID to update
+     * @param {string} newState - New state value
+     * @param {Object} [contextUpdates={}] - Context fields to merge
+     * @returns {Promise<Object>} Updated process record
+     * @throws {Error} If process not found or update fails
+     */
+    async execute(processId, newState, contextUpdates = {}) {
+        // Validate inputs
+        if (!processId || typeof processId !== 'string') {
+            throw new Error('processId must be a non-empty string');
+        }
+        if (!newState || typeof newState !== 'string') {
+            throw new Error('newState must be a non-empty string');
+        }
+        if (contextUpdates && typeof contextUpdates !== 'object') {
+            throw new Error('contextUpdates must be an object');
+        }
+
+        // Route through the atomic path when the repo supports it AND we
+        // have context keys to set. The atomic path writes the state
+        // column + the context field-sets in one DB round trip without
+        // read-modify-write, so a concurrent counter bump from
+        // UpdateProcessMetrics can't clobber our flags (e.g. `fetchDone`)
+        // or vice versa.
+        //
+        // Each context update key becomes a `set` at path
+        // `context.<key>` — matching the prior semantics of a shallow
+        // top-level merge (sub-objects were and still are replaced
+        // whole, not deep-merged).
+        const hasContextKeys =
+            contextUpdates && Object.keys(contextUpdates).length > 0;
+
+        if (
+            hasContextKeys &&
+            typeof this.processRepository.applyProcessUpdate === 'function'
+        ) {
+            const set = {};
+            for (const [key, value] of Object.entries(contextUpdates)) {
+                set[`context.${key}`] = value;
+            }
+            try {
+                const updated = await this.processRepository.applyProcessUpdate(
+                    processId,
+                    { set, newState }
+                );
+                if (!updated) {
+                    throw new Error(`Process not found: ${processId}`);
+                }
+                return updated;
+            } catch (error) {
+                throw new Error(
+                    `Failed to update process state: ${error.message}`
+                );
+            }
+        }
+
+        // Legacy path (no contextUpdates or repo lacks applyProcessUpdate):
+        // preserve the original read-merge-write semantics for backward
+        // compatibility with any custom repos. Wrap the full read+write
+        // in try/catch so a findById error surfaces under the same
+        // "Failed to update process state" message as a write failure.
+        try {
+            const process = await this.processRepository.findById(processId);
+            if (!process) {
+                throw new Error(`Process not found: ${processId}`);
+            }
+
+            const updates = { state: newState };
+            if (hasContextKeys) {
+                updates.context = {
+                    ...process.context,
+                    ...contextUpdates,
+                };
+            }
+
+            return await this.processRepository.update(processId, updates);
+        } catch (error) {
+            // Re-throw "Process not found" as-is; wrap other errors.
+            if (error.message && error.message.startsWith('Process not found')) {
+                throw error;
+            }
+            throw new Error(`Failed to update process state: ${error.message}`);
+        }
+    }
+
+    /**
+     * Helper method to update state without context changes
+     * @param {string} processId - Process ID to update
+     * @param {string} newState - New state value
+     * @returns {Promise<Object>} Updated process record
+     */
+    async updateStateOnly(processId, newState) {
+        return this.execute(processId, newState, {});
+    }
+
+    /**
+     * Helper method to update context without changing state
+     * @param {string} processId - Process ID to update
+     * @param {Object} contextUpdates - Context fields to merge
+     * @returns {Promise<Object>} Updated process record
+     */
+    async updateContextOnly(processId, contextUpdates) {
+        const process = await this.processRepository.findById(processId);
+        if (!process) {
+            throw new Error(`Process not found: ${processId}`);
+        }
+
+        const updates = {
+            context: {
+                ...process.context,
+                ...contextUpdates,
+            },
+        };
+
+        return this.processRepository.update(processId, updates);
+    }
+}
+
+module.exports = { UpdateProcessState };
+

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

@@ -0,0 +1,37 @@
+/**
+ * @param {import('../integration').Integration} integration
+ * Convert an Integration domain instance to a plain DTO suitable for JSON responses.
+ * Can also accept a plain object with an 'options' property to avoid unnecessary instantiation.
+ */
+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.options || (typeof integration.getOptionDetails === 'function' ? integration.getOptionDetails() : null),
+    };
+}
+
+
+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/logs/logger.js

@@ -1,5 +1,4 @@
 const util = require('util');
-const aws = require('aws-sdk');
 
 // Except in some outlier circumstances, for example steam or event error handlers, this should be the only place that calls `console.*`.  That way, this file can be modified to log everything properly on a variety of platforms because all the logging code is here in one place.
 /* eslint-disable no-console */
@@ -7,9 +6,6 @@ const aws = require('aws-sdk');
 const logs = [];
 let flushCalled = false;
 
-// Log AWS SDK calls
-aws.config.logger = { log: debug };
-
 function debug(...messages) {
     if (messages.length) {
         const date = new Date();

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

@@ -1,25 +1,15 @@
-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 };