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

package/credential/credential-router.js

@@ -1,262 +0,0 @@
-const express = require('express');
-const Boom = require('@hapi/boom');
-const catchAsyncError = require('express-async-handler');
-const {
-    createCredentialRepository,
-} = require('./repositories/credential-repository-factory');
-const {
-    createModuleRepository,
-} = require('../modules/repositories/module-repository-factory');
-const {
-    ListCredentialsForUser,
-} = require('./use-cases/list-credentials-for-user');
-const { GetCredentialForUser } = require('./use-cases/get-credential-for-user');
-const {
-    DeleteCredentialForUser,
-} = require('./use-cases/delete-credential-for-user');
-const { ReauthorizeCredential } = require('./use-cases/reauthorize-credential');
-
-/**
- * Boom Error Handler Middleware
- * Handles Boom errors and converts them to appropriate HTTP responses
- * @param {Error} err - Error object
- * @param {Request} req - Express request
- * @param {Response} res - Express response
- * @param {Function} next - Express next function
- */
-function boomErrorHandler(err, req, res, next) {
-    // Handle Boom errors
-    if (err.isBoom) {
-        return res.status(err.output.statusCode).json({
-            error: err.output.payload.message,
-            statusCode: err.output.statusCode,
-        });
-    }
-
-    // Handle generic errors (500)
-    console.error('Unexpected error:', err);
-    return res.status(500).json({
-        error: 'Internal server error',
-        statusCode: 500,
-    });
-}
-
-/**
- * Create Credential Router
- * Factory function that creates an Express router with credential management endpoints
- *
- * Endpoints:
- * - GET /api/credentials - List all credentials for authenticated user
- * - GET /api/credentials/:id - Get a single credential
- * - DELETE /api/credentials/:id - Delete a credential
- * - POST /api/credentials/:id/reauthorize - Reauthorize a credential
- *
- * Security:
- * - All endpoints require authentication (via authenticateUser middleware)
- * - Credentials are filtered to only belong to the authenticated user
- * - Sensitive data (tokens) are filtered from responses
- *
- * @returns {express.Router} Configured Express router
- */
-function createCredentialRouter() {
-    const router = express.Router();
-
-    // Load configuration and create repositories
-    const credentialRepository = createCredentialRepository();
-    const moduleRepository = createModuleRepository();
-
-    // Create credential use cases
-    const listCredentialsForUser = new ListCredentialsForUser({
-        credentialRepository,
-    });
-
-    const getCredentialForUser = new GetCredentialForUser({
-        credentialRepository,
-    });
-
-    const deleteCredentialForUser = new DeleteCredentialForUser({
-        credentialRepository,
-    });
-
-    const reauthorizeCredential = new ReauthorizeCredential({
-        credentialRepository,
-        moduleRepository,
-    });
-
-    /**
-     * Filter sensitive data from credential objects
-     * Removes tokens and other sensitive fields from credentials before sending to client
-     *
-     * @param {Object|Array} credentials - Credential(s) to filter
-     * @returns {Object|Array} Filtered credential(s)
-     */
-    function filterSensitiveData(credentials) {
-        const filter = (cred) => {
-            if (!cred) return cred;
-
-            // Create a copy without sensitive fields
-            const {
-                data,
-                access_token,
-                refresh_token,
-                id_token,
-                domain,
-                ...safeCredential
-            } = cred;
-
-            // Ensure we have timestamps in ISO format
-            if (
-                safeCredential.createdAt &&
-                !(safeCredential.createdAt instanceof Date)
-            ) {
-                safeCredential.createdAt = new Date(
-                    safeCredential.createdAt
-                ).toISOString();
-            }
-            if (
-                safeCredential.updatedAt &&
-                !(safeCredential.updatedAt instanceof Date)
-            ) {
-                safeCredential.updatedAt = new Date(
-                    safeCredential.updatedAt
-                ).toISOString();
-            }
-
-            return safeCredential;
-        };
-
-        return Array.isArray(credentials)
-            ? credentials.map(filter)
-            : filter(credentials);
-    }
-
-    // GET /api/credentials - List all credentials for authenticated user
-    router.get(
-        '/',
-        catchAsyncError(async (req, res) => {
-            // Expect authentication middleware to have set req.user
-            if (!req.user) {
-                throw Boom.unauthorized('Authentication required');
-            }
-            const userId =
-                typeof req.user.getId === 'function'
-                    ? req.user.getId()
-                    : req.user.id;
-
-            const credentials = await listCredentialsForUser.execute(userId);
-
-            // Filter out sensitive data before responding
-            const safeCredentials = filterSensitiveData(credentials);
-
-            res.json({ credentials: safeCredentials });
-        })
-    );
-
-    // GET /api/credentials/:id - Get a single credential
-    router.get(
-        '/:id',
-        catchAsyncError(async (req, res) => {
-            if (!req.user) {
-                throw Boom.unauthorized('Authentication required');
-            }
-            const userId =
-                typeof req.user.getId === 'function'
-                    ? req.user.getId()
-                    : req.user.id;
-            const credentialId = req.params.id;
-
-            const credential = await getCredentialForUser.execute(
-                credentialId,
-                userId
-            );
-
-            // Filter out sensitive data before responding
-            const safeCredential = filterSensitiveData(credential);
-
-            res.json(safeCredential);
-        })
-    );
-
-    // DELETE /api/credentials/:id - Delete a credential
-    router.delete(
-        '/:id',
-        catchAsyncError(async (req, res) => {
-            if (!req.user) {
-                throw Boom.unauthorized('Authentication required');
-            }
-            const userId =
-                typeof req.user.getId === 'function'
-                    ? req.user.getId()
-                    : req.user.id;
-            const credentialId = req.params.id;
-
-            const result = await deleteCredentialForUser.execute(
-                credentialId,
-                userId
-            );
-
-            // Check if deletion was successful
-            if (result.deletedCount === 0) {
-                throw Boom.internal('Failed to delete credential');
-            }
-
-            res.json({
-                success: true,
-                message: `Credential ${credentialId} deleted successfully`,
-            });
-        })
-    );
-
-    // POST /api/credentials/:id/reauthorize - Reauthorize a credential
-    router.post(
-        '/:id/reauthorize',
-        catchAsyncError(async (req, res) => {
-            if (!req.user) {
-                throw Boom.unauthorized('Authentication required');
-            }
-            const userId =
-                typeof req.user.getId === 'function'
-                    ? req.user.getId()
-                    : req.user.id;
-            const credentialId = req.params.id;
-
-            // Validate request body
-            if (!req.body.data) {
-                throw Boom.badRequest('data is required in request body');
-            }
-
-            // Get step and sessionId from request
-            const step = parseInt(req.body.step || '1', 10);
-            const sessionId = req.body.sessionId;
-
-            // Validate step is a positive integer
-            if (step < 1 || !Number.isInteger(step)) {
-                throw Boom.badRequest('step must be a positive integer');
-            }
-
-            // Validate sessionId is present for steps > 1
-            if (step > 1 && !sessionId) {
-                throw Boom.badRequest('sessionId is required for step > 1');
-            }
-
-            // Execute the reauthorization
-            const result = await reauthorizeCredential.execute(
-                credentialId,
-                userId,
-                req.body.data,
-                step,
-                sessionId
-            );
-
-            res.json(result);
-        })
-    );
-
-    // Boom error handler middleware
-    // Must be added after all routes to catch errors from handlers
-    router.use(boomErrorHandler);
-
-    return router;
-}
-
-module.exports = { createCredentialRouter, boomErrorHandler };

package/credential/use-cases/delete-credential-for-user.js

@@ -1,50 +0,0 @@
-const Boom = require('@hapi/boom');
-
-/**
- * Delete Credential For User Use Case
- * Removes a credential after verifying ownership
- *
- * Business Logic:
- * - Verify credential exists
- * - Verify credential belongs to user (authorization)
- * - Delete the credential
- * - Return success status
- */
-class DeleteCredentialForUser {
-    constructor({ credentialRepository }) {
-        this.credentialRepository = credentialRepository;
-    }
-
-    /**
-     * Execute the use case
-     * @param {string} credentialId - Credential ID
-     * @param {string} userId - User ID (for ownership verification)
-     * @returns {Promise<Object>} Deletion result { deletedCount: number }
-     */
-    async execute(credentialId, userId) {
-        // Check if credential exists
-        const credential = await this.credentialRepository.findCredentialById(
-            credentialId
-        );
-
-        if (!credential) {
-            throw Boom.notFound(`Credential ${credentialId} not found`);
-        }
-
-        // Verify ownership - compare as strings to handle both MongoDB and PostgreSQL
-        if (credential.userId.toString() !== userId.toString()) {
-            throw Boom.forbidden(
-                'You do not have permission to delete this credential'
-            );
-        }
-
-        // Delete the credential
-        const result = await this.credentialRepository.deleteCredentialById(
-            credentialId
-        );
-
-        return result;
-    }
-}
-
-module.exports = { DeleteCredentialForUser };

package/credential/use-cases/list-credentials-for-user.js

@@ -1,31 +0,0 @@
-/**
- * List Credentials For User Use Case
- * Retrieves all credentials belonging to a specific user
- *
- * Business Logic:
- * - Fetches credentials for the authenticated user
- * - Returns list of credentials (sensitive data filtered by handler)
- * - Repository returns an array when filtering by userId only
- */
-class ListCredentialsForUser {
-    constructor({ credentialRepository }) {
-        this.credentialRepository = credentialRepository;
-    }
-
-    /**
-     * Execute the use case
-     * @param {string} userId - User ID
-     * @returns {Promise<Array>} List of credentials (empty array if none found)
-     */
-    async execute(userId) {
-        const credentials = await this.credentialRepository.findCredential({
-            userId,
-        });
-
-        // Repository returns array for userId-only queries
-        // Ensure we always return an array (defensive programming)
-        return Array.isArray(credentials) ? credentials : [];
-    }
-}
-
-module.exports = { ListCredentialsForUser };

package/credential/use-cases/reauthorize-credential.js

@@ -1,103 +0,0 @@
-const Boom = require('@hapi/boom');
-
-/**
- * Reauthorize Credential Use Case
- * Re-authorizes an existing credential with new authentication data
- * Supports both single-step and multi-step authorization flows
- *
- * Business Logic:
- * - Verify credential exists and belongs to user
- * - Load the appropriate module for the credential type
- * - Process authorization callback (OAuth code, API keys, etc.)
- * - Update credential with new tokens
- * - Return success or next step requirements
- */
-class ReauthorizeCredential {
-    constructor({ credentialRepository, moduleRepository }) {
-        this.credentialRepository = credentialRepository;
-        this.moduleRepository = moduleRepository;
-    }
-
-    /**
-     * Execute the use case
-     * @param {string} credentialId - Credential ID to reauthorize
-     * @param {string} userId - User ID (for ownership verification)
-     * @param {Object} authData - Authorization data
-     * @param {number} [step=1] - Current step in multi-step flow
-     * @param {string} [sessionId] - Session ID for multi-step flows
-     * @returns {Promise<Object>} Success response or next step requirements
-     */
-    async execute(credentialId, userId, authData, step = 1, sessionId = null) {
-        // Check if credential exists
-        const credential = await this.credentialRepository.findCredentialById(
-            credentialId
-        );
-
-        if (!credential) {
-            throw Boom.notFound(`Credential ${credentialId} not found`);
-        }
-
-        // Verify ownership - compare as strings to handle both MongoDB and PostgreSQL
-        if (credential.userId.toString() !== userId.toString()) {
-            throw Boom.forbidden(
-                'You do not have permission to reauthorize this credential'
-            );
-        }
-
-        // Load the module for this credential type
-        const module = await this.moduleRepository.findModuleById(
-            credential.id
-        );
-
-        if (!module) {
-            throw Boom.badRequest(
-                `Module not found for credential type: ${
-                    credential.type || 'unknown'
-                }`
-            );
-        }
-
-        // Process the authorization callback
-        const result = await module.processAuthorizationCallback({
-            credentialId,
-            userId,
-            data: authData,
-            step,
-            sessionId,
-        });
-
-        // Multi-step flow - return next step requirements
-        if (result.step && result.step > 1) {
-            return {
-                step: result.step,
-                totalSteps: result.totalSteps,
-                sessionId: result.sessionId,
-                requirements: result.requirements,
-                message: result.message,
-            };
-        }
-
-        // Single-step or final step - update credential and return success
-        if (result.success) {
-            // Fetch the updated credential to get the new authIsValid status
-            const updatedCredential =
-                await this.credentialRepository.findCredentialById(
-                    credentialId
-                );
-
-            return {
-                success: true,
-                credential_id: credentialId,
-                authIsValid: updatedCredential?.authIsValid || true,
-                ...(result.message && { message: result.message }),
-            };
-        }
-
-        // If we get here, something unexpected happened
-        throw new Error(
-            'Authorization callback did not return expected result format'
-        );
-    }
-}
-
-module.exports = { ReauthorizeCredential };