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

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,13 +75,12 @@ 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,6 +6,7 @@ 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,
@@ -16,4 +17,5 @@ module.exports = {
     UpdateProcessState,
     UpdateProcessMetrics,
     GetProcess,
-}; 
+    ExecuteProxyRequest,
+};

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

@@ -1,9 +1,5 @@
 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,7 +75,10 @@ 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}`);
@@ -116,4 +119,3 @@ class UpdateProcessState {
 }
 
 module.exports = { UpdateProcessState };
-

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

@@ -15,11 +15,14 @@ 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(
@@ -34,4 +37,7 @@ 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,42 +2,44 @@ 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");
-  }
-
-  async watch() {
-    try {
-      await Promise.race([this.doWork(), this.exitBeforeTimeout()]);
-      return true;
-    } catch (error) {
-      if (error.isSentinelTimeout) return false;
-      throw error;
+    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 doWork() {
-    await this.work();
-    this.isFinished = true;
-  }
+    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 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,
+};

package/modules/domain/entities/AuthorizationSession.js

@@ -0,0 +1,131 @@
+/**
+ * AuthorizationSession Entity
+ * Domain entity for multi-step authorization workflows
+ *
+ * Manages state for authentication flows that require multiple steps,
+ * such as OTP verification, multi-factor authentication, or progressive
+ * credential collection.
+ *
+ * @example
+ * const session = new AuthorizationSession({
+ *     sessionId: '550e8400-e29b-41d4-a716-446655440000',
+ *     userId: 'user123',
+ *     entityType: 'nagaris',
+ *     currentStep: 1,
+ *     maxSteps: 2,
+ *     stepData: { email: 'user@example.com' },
+ *     expiresAt: new Date(Date.now() + 15 * 60 * 1000)
+ * });
+ */
+class AuthorizationSession {
+    /**
+     * Create an authorization session
+     *
+     * @param {Object} params - Session parameters
+     * @param {string} params.sessionId - Unique session identifier (UUID)
+     * @param {string} params.userId - User ID who initiated the auth flow
+     * @param {string} params.entityType - Type of entity being authorized (module name)
+     * @param {number} [params.currentStep=1] - Current step in the auth flow
+     * @param {number} params.maxSteps - Total number of steps in the flow
+     * @param {Object} [params.stepData={}] - Accumulated data from previous steps
+     * @param {Date} params.expiresAt - Session expiration timestamp
+     * @param {boolean} [params.completed=false] - Whether auth flow is complete
+     * @param {Date} [params.createdAt=new Date()] - Session creation timestamp
+     * @param {Date} [params.updatedAt=new Date()] - Last update timestamp
+     */
+    constructor({
+        sessionId,
+        userId,
+        entityType,
+        currentStep = 1,
+        maxSteps,
+        stepData = {},
+        expiresAt,
+        completed = false,
+        createdAt = new Date(),
+        updatedAt = new Date(),
+    }) {
+        this.sessionId = sessionId;
+        this.userId = userId;
+        this.entityType = entityType;
+        this.currentStep = currentStep;
+        this.maxSteps = maxSteps;
+        this.stepData = stepData;
+        this.expiresAt = expiresAt;
+        this.completed = completed;
+        this.createdAt = createdAt;
+        this.updatedAt = updatedAt;
+
+        this.validate();
+    }
+
+    /**
+     * Validate session state
+     *
+     * @throws {Error} If validation fails
+     */
+    validate() {
+        if (!this.sessionId) {
+            throw new Error('Session ID is required');
+        }
+        if (!this.userId) {
+            throw new Error('User ID is required');
+        }
+        if (!this.entityType) {
+            throw new Error('Entity type is required');
+        }
+        if (this.currentStep < 1) {
+            throw new Error('Step must be >= 1');
+        }
+        if (this.currentStep > this.maxSteps) {
+            throw new Error('Current step cannot exceed max steps');
+        }
+        if (this.expiresAt < new Date()) {
+            throw new Error('Session has expired');
+        }
+    }
+
+    /**
+     * Advance to next step with new data
+     *
+     * @param {Object} newStepData - Data collected from current step
+     * @throws {Error} If session is already completed
+     */
+    advanceStep(newStepData) {
+        if (this.completed) {
+            throw new Error('Cannot advance completed session');
+        }
+
+        this.currentStep += 1;
+        this.stepData = { ...this.stepData, ...newStepData };
+        this.updatedAt = new Date();
+    }
+
+    /**
+     * Mark session as complete
+     */
+    markComplete() {
+        this.completed = true;
+        this.updatedAt = new Date();
+    }
+
+    /**
+     * Check if session has expired
+     *
+     * @returns {boolean} True if session is expired
+     */
+    isExpired() {
+        return this.expiresAt < new Date();
+    }
+
+    /**
+     * Check if session can advance to next step
+     *
+     * @returns {boolean} True if session can advance
+     */
+    canAdvance() {
+        return !this.completed && this.currentStep < this.maxSteps;
+    }
+}
+
+module.exports = { AuthorizationSession };

package/modules/domain/entities/index.js

@@ -0,0 +1,10 @@
+/**
+ * Domain Entities Index
+ * Export all domain entities for convenient importing
+ */
+
+const { AuthorizationSession } = require('./AuthorizationSession');
+
+module.exports = {
+    AuthorizationSession,
+};

package/modules/module.js

@@ -102,15 +102,10 @@ class Module extends Delegate {
             this.api,
             this.userId
         );
-        const apiParams = this.apiParamsFromCredential(this.api);
-
-        if (!apiParams.refresh_token && this.api.isRefreshable) {
-            console.warn(
-                `[Frigg] No refresh_token in apiParams for module ${this.name}.`
-            );
-        }
-
-        Object.assign(credentialDetails.details, apiParams);
+        Object.assign(
+            credentialDetails.details,
+            this.apiParamsFromCredential(this.api)
+        );
         credentialDetails.details.authIsValid = true;
 
         const persisted = await this.credentialRepository.upsertCredential(

package/modules/repositories/authorization-session-repository-factory.js

@@ -0,0 +1,53 @@
+const {
+    AuthorizationSessionRepositoryPostgres,
+} = require('./authorization-session-repository-postgres');
+
+/**
+ * Authorization Session Repository Factory
+ * Creates the appropriate repository adapter based on database type
+ *
+ * Database-specific implementations:
+ * - MongoDB: Uses String IDs (ObjectId), TTL index for auto-cleanup
+ * - PostgreSQL: Uses Int IDs, manual cleanup via deleteExpired()
+ *
+ * All repository methods return AuthorizationSession domain entities,
+ * ensuring application layer consistency regardless of database type.
+ *
+ * Environment Configuration:
+ * - DB_TYPE=mongodb (default) - Uses MongoDB adapter
+ * - DB_TYPE=postgresql - Uses PostgreSQL adapter
+ *
+ * @example
+ * ```javascript
+ * const repository = createAuthorizationSessionRepository();
+ * const session = await repository.findBySessionId(sessionId);
+ * ```
+ *
+ * @param {Object} [prismaClient] - Optional Prisma client for testing
+ * @returns {AuthorizationSessionRepositoryInterface} Configured repository adapter
+ * @throws {Error} If DB_TYPE is not supported
+ */
+function createAuthorizationSessionRepository(prismaClient) {
+    const dbType = process.env.DB_TYPE || 'mongodb';
+
+    switch (dbType) {
+        case 'mongodb':
+            const { AuthorizationSessionRepositoryMongo } = require('./authorization-session-repository-mongo');
+            return new AuthorizationSessionRepositoryMongo(prismaClient);
+
+        case 'postgresql':
+            return new AuthorizationSessionRepositoryPostgres(prismaClient);
+
+        default:
+            throw new Error(
+                `Unsupported DB_TYPE: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+            );
+    }
+}
+
+module.exports = {
+    createAuthorizationSessionRepository,
+    // Export adapters for direct testing
+    get AuthorizationSessionRepositoryMongo() { return require('./authorization-session-repository-mongo').AuthorizationSessionRepositoryMongo; },
+    AuthorizationSessionRepositoryPostgres,
+};

package/modules/repositories/authorization-session-repository-interface.js

@@ -0,0 +1,75 @@
+/**
+ * Authorization Session Repository Interface
+ * Abstract base class defining the contract for AuthorizationSession persistence adapters
+ *
+ * This follows the Port in Hexagonal Architecture:
+ * - Domain layer depends on this abstraction
+ * - Concrete adapters (MongoDB, PostgreSQL) implement this interface
+ * - Use cases receive repositories via dependency injection
+ *
+ * @abstract
+ */
+class AuthorizationSessionRepositoryInterface {
+    /**
+     * Create a new authorization session
+     *
+     * @param {import('../domain/entities/AuthorizationSession').AuthorizationSession} session - Session entity to create
+     * @returns {Promise<import('../domain/entities/AuthorizationSession').AuthorizationSession>} Created session
+     * @abstract
+     */
+    async create(session) {
+        throw new Error('Method create must be implemented by subclass');
+    }
+
+    /**
+     * Find session by session ID
+     *
+     * @param {string} sessionId - Unique session identifier
+     * @returns {Promise<import('../domain/entities/AuthorizationSession').AuthorizationSession|null>} Session entity or null if not found/expired
+     * @abstract
+     */
+    async findBySessionId(sessionId) {
+        throw new Error(
+            'Method findBySessionId must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find active session for user and entity type
+     * Returns the most recent active (non-completed, non-expired) session
+     *
+     * @param {string} userId - User ID
+     * @param {string} entityType - Entity type (module name)
+     * @returns {Promise<import('../domain/entities/AuthorizationSession').AuthorizationSession|null>} Session entity or null if not found
+     * @abstract
+     */
+    async findActiveSession(userId, entityType) {
+        throw new Error(
+            'Method findActiveSession must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Update existing session
+     *
+     * @param {import('../domain/entities/AuthorizationSession').AuthorizationSession} session - Session entity with updated data
+     * @returns {Promise<import('../domain/entities/AuthorizationSession').AuthorizationSession>} Updated session
+     * @abstract
+     */
+    async update(session) {
+        throw new Error('Method update must be implemented by subclass');
+    }
+
+    /**
+     * Delete expired sessions (cleanup operation)
+     * Should be called periodically to remove old sessions
+     *
+     * @returns {Promise<number>} Number of deleted sessions
+     * @abstract
+     */
+    async deleteExpired() {
+        throw new Error('Method deleteExpired must be implemented by subclass');
+    }
+}
+
+module.exports = { AuthorizationSessionRepositoryInterface };