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

package/modules/use-cases/get-authorization-requirements.js

@@ -1,110 +0,0 @@
-/**
- * Get Authorization Requirements Use Case
- * Business logic for retrieving authorization requirements for a specific step
- *
- * Responsibilities:
- * - Find module definition for entity type
- * - Determine step count (single vs multi-step)
- * - Retrieve step-specific requirements (jsonSchema, uiSchema, etc.)
- * - Return structured requirements for frontend rendering
- *
- * Supports both single-step and multi-step modules:
- * - Single-step: Uses getAuthorizationRequirements() (legacy)
- * - Multi-step: Uses getAuthRequirementsForStep(step) (new)
- *
- * @example
- * ```javascript
- * const useCase = new GetAuthorizationRequirementsUseCase({
- *     moduleDefinitions: [{ moduleName: 'nagaris', definition: NagarisDefinition }]
- * });
- *
- * // Get requirements for step 1
- * const reqs = await useCase.execute('nagaris', 1);
- * // Returns: { type: 'email', data: { jsonSchema, uiSchema }, step: 1, totalSteps: 2, isMultiStep: true }
- *
- * // Get requirements for step 2
- * const reqs = await useCase.execute('nagaris', 2);
- * // Returns: { type: 'otp', data: { jsonSchema, uiSchema }, step: 2, totalSteps: 2, isMultiStep: true }
- * ```
- */
-class GetAuthorizationRequirementsUseCase {
-    /**
-     * @param {Object} params - Dependencies
-     * @param {Array<Object>} params.moduleDefinitions - Array of module definitions with structure: { moduleName, definition }
-     */
-    constructor({ moduleDefinitions }) {
-        if (!moduleDefinitions || !Array.isArray(moduleDefinitions)) {
-            throw new Error('moduleDefinitions array is required');
-        }
-        this.moduleDefinitions = moduleDefinitions;
-    }
-
-    /**
-     * Get authorization requirements for a specific step
-     *
-     * @param {string} entityType - Entity type (module name)
-     * @param {number} [step=1] - Step number (1-indexed)
-     * @returns {Promise<Object>} Requirements object with schema and metadata
-     * @throws {Error} If module not found or step invalid
-     */
-    async execute(entityType, step = 1) {
-        // Validate inputs
-        if (!entityType) {
-            throw new Error('entityType is required');
-        }
-        if (!step || step < 1) {
-            throw new Error('step must be >= 1');
-        }
-
-        // Find module definition
-        const moduleDefinition = this.moduleDefinitions.find(
-            (def) => def.moduleName === entityType
-        );
-
-        if (!moduleDefinition) {
-            throw new Error(`Module definition not found: ${entityType}`);
-        }
-
-        const ModuleDefinition = moduleDefinition.definition;
-
-        // Determine step count (multi-step vs single-step)
-        const stepCount = ModuleDefinition.getAuthStepCount
-            ? ModuleDefinition.getAuthStepCount()
-            : 1;
-
-        // Validate requested step doesn't exceed max steps
-        if (step > stepCount) {
-            throw new Error(
-                `Step ${step} exceeds maximum steps (${stepCount}) for ${entityType}`
-            );
-        }
-
-        // Get requirements for this specific step
-        let requirements;
-
-        if (ModuleDefinition.getAuthRequirementsForStep) {
-            // Multi-step module - use step-specific method
-            requirements = await ModuleDefinition.getAuthRequirementsForStep(
-                step
-            );
-        } else if (step === 1) {
-            // Single-step module (legacy) - use standard method
-            requirements =
-                await ModuleDefinition.getAuthorizationRequirements();
-        } else {
-            throw new Error(
-                `Module ${entityType} does not support step ${step}`
-            );
-        }
-
-        // Return enriched requirements with metadata
-        return {
-            ...requirements,
-            step,
-            totalSteps: stepCount,
-            isMultiStep: stepCount > 1,
-        };
-    }
-}
-
-module.exports = { GetAuthorizationRequirementsUseCase };

package/modules/use-cases/get-module-entity-by-id.js

@@ -1,16 +0,0 @@
-/**
- * GetModuleEntityById Use Case
- * Retrieves a module entity by its ID
- */
-class GetModuleEntityById {
-    constructor({ moduleRepository }) {
-        this.moduleRepository = moduleRepository;
-    }
-
-    async execute(entityId) {
-        const entity = await this.moduleRepository.findEntityById(entityId);
-        return entity;
-    }
-}
-
-module.exports = { GetModuleEntityById };

package/modules/use-cases/process-authorization-step.js

@@ -1,160 +0,0 @@
-/**
- * Process Authorization Step Use Case
- * Business logic for processing individual steps in multi-step authorization workflows
- *
- * Responsibilities:
- * - Load and validate authorization session
- * - Verify step sequence and user ownership
- * - Delegate to module's step processing logic
- * - Update session state and persist changes
- * - Return next step requirements or completion data
- *
- * @example
- * ```javascript
- * const useCase = new ProcessAuthorizationStepUseCase({
- *     authSessionRepository: createAuthorizationSessionRepository(),
- *     moduleDefinitions: [{ moduleName: 'nagaris', definition: NagarisDefinition, apiClass: NagarisApi }]
- * });
- *
- * // Process step 1 (email submission)
- * const result = await useCase.execute('session-id', 'user123', 1, { email: 'user@example.com' });
- * // Returns: { nextStep: 2, sessionId, requirements: {...}, message: 'OTP sent to email' }
- *
- * // Process step 2 (OTP verification)
- * const result = await useCase.execute('session-id', 'user123', 2, { email: 'user@example.com', otp: '123456' });
- * // Returns: { completed: true, authData: {...}, sessionId }
- * ```
- */
-class ProcessAuthorizationStepUseCase {
-    /**
-     * @param {Object} params - Dependencies
-     * @param {import('../repositories/authorization-session-repository-interface').AuthorizationSessionRepositoryInterface} params.authSessionRepository - Session repository
-     * @param {Array<Object>} params.moduleDefinitions - Array of module definitions with structure: { moduleName, definition, apiClass }
-     */
-    constructor({ authSessionRepository, moduleDefinitions }) {
-        if (!authSessionRepository) {
-            throw new Error('authSessionRepository is required');
-        }
-        if (!moduleDefinitions || !Array.isArray(moduleDefinitions)) {
-            throw new Error('moduleDefinitions array is required');
-        }
-        this.authSessionRepository = authSessionRepository;
-        this.moduleDefinitions = moduleDefinitions;
-    }
-
-    /**
-     * Process a single step of multi-step authorization
-     *
-     * @param {string} sessionId - Unique session identifier
-     * @param {string} userId - User ID (for security validation)
-     * @param {number} step - Current step number being processed
-     * @param {Object} stepData - Data submitted for this step
-     * @returns {Promise<Object>} Result object with nextStep info or completion data
-     * @throws {Error} If session not found, validation fails, or step processing fails
-     */
-    async execute(sessionId, userId, step, stepData) {
-        // Validate inputs
-        if (!sessionId) {
-            throw new Error('sessionId is required');
-        }
-        if (!userId) {
-            throw new Error('userId is required');
-        }
-        if (!step || step < 1) {
-            throw new Error('step must be >= 1');
-        }
-        if (!stepData || typeof stepData !== 'object') {
-            throw new Error('stepData object is required');
-        }
-
-        // Load session from repository
-        const session = await this.authSessionRepository.findBySessionId(
-            sessionId
-        );
-
-        if (!session) {
-            throw new Error('Authorization session not found or expired');
-        }
-
-        // Security: Verify session belongs to this user
-        if (session.userId !== userId) {
-            throw new Error('Session does not belong to this user');
-        }
-
-        // Verify session hasn't expired (double-check beyond repository filter)
-        if (session.isExpired()) {
-            throw new Error('Authorization session has expired');
-        }
-
-        // Validate step sequence - prevent skipping steps
-        // Allow step 1 to be re-submitted (restart flow), otherwise must be sequential
-        if (session.currentStep !== step && step !== 1) {
-            throw new Error(
-                `Expected step ${session.currentStep}, received step ${step}`
-            );
-        }
-
-        // Find module definition for this entity type
-        const moduleDefinition = this.moduleDefinitions.find(
-            (def) => def.moduleName === session.entityType
-        );
-
-        if (!moduleDefinition) {
-            throw new Error(
-                `Module definition not found: ${session.entityType}`
-            );
-        }
-
-        // Get module's Definition class
-        const ModuleDefinition = moduleDefinition.definition;
-
-        // Validate module supports multi-step auth
-        if (!ModuleDefinition.processAuthorizationStep) {
-            throw new Error(
-                `Module ${session.entityType} does not support multi-step authorization`
-            );
-        }
-
-        // Create API instance for this step
-        const ApiClass = moduleDefinition.apiClass;
-        const api = new ApiClass({ userId });
-
-        // Delegate to module's step processing logic
-        const result = await ModuleDefinition.processAuthorizationStep(
-            api,
-            step,
-            stepData,
-            session.stepData // Pass accumulated data from previous steps
-        );
-
-        // Handle final step completion
-        if (result.completed) {
-            session.markComplete();
-            await this.authSessionRepository.update(session);
-
-            return {
-                completed: true,
-                authData: result.authData,
-                sessionId,
-            };
-        }
-
-        // Handle intermediate step - advance session
-        session.advanceStep(result.stepData || {});
-        await this.authSessionRepository.update(session);
-
-        // Get requirements for next step
-        const nextRequirements =
-            await ModuleDefinition.getAuthRequirementsForStep(result.nextStep);
-
-        return {
-            nextStep: result.nextStep,
-            totalSteps: session.maxSteps,
-            sessionId,
-            requirements: nextRequirements,
-            message: result.message || undefined,
-        };
-    }
-}
-
-module.exports = { ProcessAuthorizationStepUseCase };

package/modules/use-cases/start-authorization-session.js

@@ -1,86 +0,0 @@
-const crypto = require('crypto');
-const {
-    AuthorizationSession,
-} = require('../domain/entities/AuthorizationSession');
-
-/**
- * Start Authorization Session Use Case
- * Business logic for initiating multi-step authorization workflows
- *
- * Responsibilities:
- * - Generate unique session identifiers
- * - Set appropriate session expiration (15 minutes)
- * - Create and persist new authorization session
- * - Validate input parameters
- *
- * @example
- * ```javascript
- * const useCase = new StartAuthorizationSessionUseCase({
- *     authSessionRepository: createAuthorizationSessionRepository()
- * });
- *
- * const session = await useCase.execute('user123', 'nagaris', 2);
- * // Returns new AuthorizationSession ready for step 1
- * ```
- */
-class StartAuthorizationSessionUseCase {
-    /**
-     * @param {Object} params - Dependencies
-     * @param {import('../repositories/authorization-session-repository-interface').AuthorizationSessionRepositoryInterface} params.authSessionRepository - Session repository
-     */
-    constructor({ authSessionRepository }) {
-        if (!authSessionRepository) {
-            throw new Error('authSessionRepository is required');
-        }
-        this.authSessionRepository = authSessionRepository;
-    }
-
-    /**
-     * Start a new multi-step authorization session
-     *
-     * @param {string} userId - User ID initiating the auth flow
-     * @param {string} entityType - Type of entity being authorized (module name)
-     * @param {number} maxSteps - Total number of steps in the auth flow
-     * @returns {Promise<import('../domain/entities/AuthorizationSession').AuthorizationSession>} Created session
-     * @throws {Error} If validation fails
-     */
-    async execute(userId, entityType, maxSteps) {
-        // Validate inputs
-        if (!userId) {
-            throw new Error('userId is required');
-        }
-        if (!entityType) {
-            throw new Error('entityType is required');
-        }
-        if (!maxSteps || maxSteps < 1) {
-            throw new Error('maxSteps must be >= 1');
-        }
-
-        // Generate cryptographically secure session ID
-        const sessionId = crypto.randomUUID();
-
-        // Set 15 minute expiration (configurable via env in future)
-        const expirationMinutes = parseInt(
-            process.env.AUTH_SESSION_EXPIRY_MINUTES || '15',
-            10
-        );
-        const expiresAt = new Date(Date.now() + expirationMinutes * 60 * 1000);
-
-        // Create domain entity
-        const session = new AuthorizationSession({
-            sessionId,
-            userId,
-            entityType,
-            currentStep: 1,
-            maxSteps,
-            stepData: {},
-            expiresAt,
-            completed: false,
-        });
-
-        // Persist to database
-        return await this.authSessionRepository.create(session);
-    }
-}
-
-module.exports = { StartAuthorizationSessionUseCase };

package/modules/use-cases/update-module-entity.js

@@ -1,27 +0,0 @@
-/**
- * UpdateModuleEntity Use Case
- * Updates a module entity with new data
- */
-class UpdateModuleEntity {
-    constructor({ moduleRepository }) {
-        this.moduleRepository = moduleRepository;
-    }
-
-    async execute(entityId, updates) {
-        const entity = await this.moduleRepository.findEntityById(entityId);
-
-        if (!entity) {
-            throw new Error(`Entity not found: ${entityId}`);
-        }
-
-        // Update the entity using repository method
-        const updatedEntity = await this.moduleRepository.updateEntity(
-            entityId,
-            updates
-        );
-
-        return updatedEntity;
-    }
-}
-
-module.exports = { UpdateModuleEntity };