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

package/handlers/routers/admin.js

@@ -0,0 +1,474 @@
+const express = require('express');
+const router = express.Router();
+const { createAppHandler } = require('./../app-handler-helpers');
+const { requireAdmin } = require('./middleware/requireAdmin');
+const catchAsyncError = require('express-async-handler');
+const bcrypt = require('bcryptjs');
+const {
+    createUserRepository,
+} = require('../../user/repositories/user-repository-factory');
+const { loadAppDefinition } = require('../app-definition-loader');
+const {
+    createModuleRepository,
+} = require('../../modules/repositories/module-repository-factory');
+const {
+    GetModuleEntityById,
+} = require('../../modules/use-cases/get-module-entity-by-id');
+const {
+    UpdateModuleEntity,
+} = require('../../modules/use-cases/update-module-entity');
+const {
+    DeleteModuleEntity,
+} = require('../../modules/use-cases/delete-module-entity');
+const {
+    CreateTokenForUserId,
+} = require('../../user/use-cases/create-token-for-user-id');
+const { DeleteUser } = require('../../user/use-cases/delete-user');
+
+// Lazy-initialized repositories and use cases (deferred until first request)
+let _userRepository,
+    _moduleRepository,
+    _getModuleEntityById,
+    _updateModuleEntity,
+    _deleteModuleEntity,
+    _createTokenForUserId,
+    _deleteUser;
+
+function ensureInitialized() {
+    if (!_userRepository) {
+        const { userConfig } = loadAppDefinition();
+        _userRepository = createUserRepository({ userConfig });
+        _moduleRepository = createModuleRepository();
+        _getModuleEntityById = new GetModuleEntityById({
+            moduleRepository: _moduleRepository,
+        });
+        _updateModuleEntity = new UpdateModuleEntity({
+            moduleRepository: _moduleRepository,
+        });
+        _deleteModuleEntity = new DeleteModuleEntity({
+            moduleRepository: _moduleRepository,
+        });
+        _createTokenForUserId = new CreateTokenForUserId({
+            userRepository: _userRepository,
+        });
+        _deleteUser = new DeleteUser({ userRepository: _userRepository });
+    }
+}
+
+// Lazy initialization middleware — runs once on first request
+router.use((req, res, next) => {
+    ensureInitialized();
+    next();
+});
+
+// Debug logging
+router.use((req, res, next) => {
+    console.log(
+        `[Admin Router] ${req.method} ${req.path} | Original URL: ${req.originalUrl}`
+    );
+    next();
+});
+
+// Apply admin API key auth middleware to all admin routes
+router.use(requireAdmin);
+
+/**
+ * USER MANAGEMENT ENDPOINTS
+ */
+
+/**
+ * GET /api/admin/users
+ * List all users with pagination
+ */
+router.get(
+    '/api/admin/users',
+    catchAsyncError(async (req, res) => {
+        const {
+            page = 1,
+            limit = 50,
+            sortBy = 'createdAt',
+            sortOrder = 'desc',
+        } = req.query;
+        const skip = (parseInt(page) - 1) * parseInt(limit);
+
+        // Build sort object
+        const sort = {};
+        sort[sortBy] = sortOrder === 'desc' ? -1 : 1;
+
+        // Use repository to get users
+        const users = await _userRepository.findAllUsers({
+            skip,
+            limit: parseInt(limit),
+            sort,
+            excludeFields: ['-hashword'], // Exclude password hash
+        });
+
+        const totalCount = await _userRepository.countUsers();
+
+        res.json({
+            users,
+            pagination: {
+                page: parseInt(page),
+                limit: parseInt(limit),
+                total: totalCount,
+                pages: Math.ceil(totalCount / parseInt(limit)),
+            },
+        });
+    })
+);
+
+/**
+ * GET /api/admin/users/search
+ * Search users by username or email
+ */
+router.get(
+    '/api/admin/users/search',
+    catchAsyncError(async (req, res) => {
+        const {
+            q,
+            page = 1,
+            limit = 50,
+            sortBy = 'createdAt',
+            sortOrder = 'desc',
+        } = req.query;
+
+        if (!q) {
+            return res.status(400).json({
+                status: 'error',
+                message: 'Search query parameter "q" is required',
+            });
+        }
+
+        const skip = (parseInt(page) - 1) * parseInt(limit);
+
+        // Build sort object
+        const sort = {};
+        sort[sortBy] = sortOrder === 'desc' ? -1 : 1;
+
+        // Use repository to search users
+        const users = await _userRepository.searchUsers({
+            query: q,
+            skip,
+            limit: parseInt(limit),
+            sort,
+            excludeFields: ['-hashword'],
+        });
+
+        const totalCount = await _userRepository.countUsersBySearchQuery(q);
+
+        res.json({
+            users,
+            pagination: {
+                page: parseInt(page),
+                limit: parseInt(limit),
+                total: totalCount,
+                pages: Math.ceil(totalCount / parseInt(limit)),
+            },
+        });
+    })
+);
+
+/**
+ * POST /api/admin/users
+ * Create a new user (admin only)
+ * Admin-specific features:
+ * - Can create users with custom roles
+ * - Can set verified status
+ * - Can assign to organizations
+ * - No email verification required
+ */
+router.post(
+    '/api/admin/users',
+    catchAsyncError(async (req, res) => {
+        const {
+            username,
+            email,
+            password,
+            type = 'INDIVIDUAL',
+            appUserId,
+            organizationId,
+            verified = true, // Admins can create pre-verified users
+        } = req.body;
+
+        // Validate required fields
+        if (!username || !email || !password) {
+            return res.status(400).json({
+                status: 'error',
+                message: 'Username, email, and password are required',
+            });
+        }
+
+        // Check if user already exists
+        const existingUser = await _userRepository.findIndividualUserByUsername(
+            username
+        );
+        if (existingUser) {
+            return res.status(409).json({
+                status: 'error',
+                message: 'User with this username already exists',
+            });
+        }
+
+        const existingEmail = await _userRepository.findIndividualUserByEmail(
+            email
+        );
+        if (existingEmail) {
+            return res.status(409).json({
+                status: 'error',
+                message: 'User with this email already exists',
+            });
+        }
+
+        // Hash password (using bcryptjs which is already imported)
+        const hashword = await bcrypt.hash(password, 10);
+
+        // Create user with admin-specified attributes
+        const userData = {
+            username,
+            email,
+            hashword,
+            type,
+        };
+
+        // Add optional fields if provided
+        if (appUserId) userData.appUserId = appUserId;
+        if (organizationId) userData.organizationId = organizationId;
+
+        const user = await _userRepository.createIndividualUser(userData);
+
+        // Remove sensitive fields
+        const userObj = user.toObject ? user.toObject() : user;
+        delete userObj.hashword;
+
+        res.status(201).json({
+            user: userObj,
+            message: 'User created successfully by admin',
+        });
+    })
+);
+
+/**
+ * GET /api/admin/users/:userId
+ * Get a specific user by ID
+ */
+router.get(
+    '/api/admin/users/:userId',
+    catchAsyncError(async (req, res) => {
+        const { userId } = req.params;
+
+        const user = await _userRepository.findUserById(userId);
+
+        if (!user) {
+            return res.status(404).json({
+                status: 'error',
+                message: 'User not found',
+            });
+        }
+
+        // Remove sensitive fields
+        const userObj = user.toObject ? user.toObject() : user;
+        delete userObj.hashword;
+
+        res.json({ user: userObj });
+    })
+);
+
+/**
+ * POST /api/admin/users/:userId/impersonate
+ * Generate a token for a user without requiring password (admin impersonation)
+ * Allows admins to login as any user for support/testing purposes
+ */
+router.post(
+    '/api/admin/users/:userId/impersonate',
+    catchAsyncError(async (req, res) => {
+        const { userId } = req.params;
+        const { expiresInMinutes = 120 } = req.body;
+
+        // Find the user
+        const user = await _userRepository.findUserById(userId);
+
+        if (!user) {
+            return res.status(404).json({
+                status: 'error',
+                message: 'User not found',
+            });
+        }
+
+        // Generate token without password verification
+        const token = await _createTokenForUserId.execute(
+            userId,
+            expiresInMinutes
+        );
+
+        res.json({
+            token,
+            message: `Impersonating user: ${user.username || user.email}`,
+            expiresInMinutes,
+        });
+    })
+);
+
+/**
+ * DELETE /api/admin/users/:userId
+ * Delete a user by ID (admin only)
+ * IMPORTANT: This is a destructive operation - use with caution
+ */
+router.delete(
+    '/api/admin/users/:userId',
+    catchAsyncError(async (req, res) => {
+        const { userId } = req.params;
+
+        // Execute delete user use case
+        await _deleteUser.execute(userId);
+
+        res.status(204).send();
+    })
+);
+
+/**
+ * GLOBAL ENTITY MANAGEMENT ENDPOINTS
+ */
+
+/**
+ * GET /api/admin/entities
+ * List all global entities
+ */
+router.get(
+    '/api/admin/entities',
+    catchAsyncError(async (req, res) => {
+        const { type, status } = req.query;
+
+        const query = { isGlobal: true };
+        if (type) query.type = type;
+        if (status) query.status = status;
+
+        const entities = await _moduleRepository.findEntitiesBy(query);
+
+        res.json({ entities });
+    })
+);
+
+/**
+ * GET /api/admin/entities/:entityId
+ * Get a specific global entity
+ */
+router.get(
+    '/api/admin/entities/:entityId',
+    catchAsyncError(async (req, res) => {
+        const { entityId } = req.params;
+
+        const entity = await _getModuleEntityById.execute(entityId);
+
+        if (!entity || !entity.isGlobal) {
+            return res.status(404).json({
+                status: 'error',
+                message: 'Global entity not found',
+            });
+        }
+
+        res.json({ entity });
+    })
+);
+
+/**
+ * POST /api/admin/entities
+ * Create a new global entity
+ */
+router.post(
+    '/api/admin/entities',
+    catchAsyncError(async (req, res) => {
+        const { type, ...entityData } = req.body;
+
+        if (!type) {
+            return res.status(400).json({
+                status: 'error',
+                message: 'Entity type is required',
+            });
+        }
+
+        // Create entity with isGlobal flag
+        const entity = await _moduleRepository.createEntity({
+            ...entityData,
+            type,
+            isGlobal: true,
+            status: 'connected',
+        });
+
+        res.status(201).json({ entity });
+    })
+);
+
+/**
+ * PUT /api/admin/entities/:entityId
+ * Update a global entity
+ */
+router.put(
+    '/api/admin/entities/:entityId',
+    catchAsyncError(async (req, res) => {
+        const { entityId } = req.params;
+
+        const entity = await _updateModuleEntity.execute(entityId, req.body);
+
+        if (!entity) {
+            return res.status(404).json({
+                status: 'error',
+                message: 'Global entity not found',
+            });
+        }
+
+        res.json({ entity });
+    })
+);
+
+/**
+ * DELETE /api/admin/entities/:entityId
+ * Delete a global entity
+ */
+router.delete(
+    '/api/admin/entities/:entityId',
+    catchAsyncError(async (req, res) => {
+        const { entityId } = req.params;
+
+        await _deleteModuleEntity.execute(entityId);
+
+        res.status(204).send();
+    })
+);
+
+/**
+ * POST /api/admin/entities/:entityId/test
+ * Test connection for a global entity
+ */
+router.post(
+    '/api/admin/entities/:entityId/test',
+    catchAsyncError(async (req, res) => {
+        const { entityId } = req.params;
+
+        const entity = await _getModuleEntityById.execute(entityId);
+
+        if (!entity || !entity.isGlobal) {
+            return res.status(404).json({
+                status: 'error',
+                message: 'Global entity not found',
+            });
+        }
+
+        // Test the entity connection
+        try {
+            // This would use a TestModuleAuth use case
+            res.json({
+                status: 'success',
+                message: 'Entity connection test successful',
+            });
+        } catch (error) {
+            res.status(500).json({
+                status: 'error',
+                message: `Entity connection test failed: ${error.message}`,
+            });
+        }
+    })
+);
+
+const handler = createAppHandler('HTTP Event: Admin', router);
+
+module.exports = { handler, router };

package/handlers/routers/auth.js

@@ -1,15 +1,57 @@
 const { createIntegrationRouter } = require('@friggframework/core');
 const { createAppHandler } = require('./../app-handler-helpers');
+const { requireLoggedInUser } = require('./middleware/requireLoggedInUser');
+const { loadAppDefinition } = require('../app-definition-loader');
 
-const router = createIntegrationRouter();
+let _router;
+let _handler;
 
-router.route('/api/integrations/redirect/:appId').get((req, res) => {
-    res.redirect(
-        `${process.env.FRONTEND_URI}/redirect/${req.params.appId
-        }?${new URLSearchParams(req.query)}`
-    );
-});
+function ensureRouter() {
+    if (!_router) {
+        _router = createIntegrationRouter();
 
-const handler = createAppHandler('HTTP Event: Auth', router);
+        _router
+            .route('/api/integrations/redirect/:appId')
+            .get((req, res) => {
+                res.redirect(
+                    `${process.env.FRONTEND_URI}/redirect/${
+                        req.params.appId
+                    }?${new URLSearchParams(req.query)}`
+                );
+            });
 
-module.exports = { handler };
+        // Integration settings endpoint
+        _router
+            .route('/config/integration-settings')
+            .get(requireLoggedInUser, (req, res) => {
+                const appDefinition = loadAppDefinition();
+
+                const settings = {
+                    autoProvisioningEnabled:
+                        appDefinition.integration
+                            ?.autoProvisioningEnabled ?? true,
+                    credentialReuseStrategy:
+                        appDefinition.integration
+                            ?.credentialReuseStrategy ?? 'shared',
+                    allowUserManagedEntities:
+                        appDefinition.integration
+                            ?.allowUserManagedEntities ?? true,
+                };
+
+                res.json(settings);
+            });
+    }
+    return _router;
+}
+
+module.exports = {
+    get router() {
+        return ensureRouter();
+    },
+    get handler() {
+        if (!_handler) {
+            _handler = createAppHandler('HTTP Event: Auth', ensureRouter());
+        }
+        return _handler;
+    },
+};

package/handlers/routers/db-migration.handler.js

@@ -3,14 +3,14 @@
  *
  * Minimal Lambda wrapper that avoids loading core/index.js
  * (which would try to load user/** modules excluded from migration packages)
- * 
+ *
  * This handler is intentionally simpler than health.handler.js to avoid dependencies.
  */
 
 const serverlessHttp = require('serverless-http');
 const express = require('express');
 const cors = require('cors');
-const dbMigrationRouter = require('./db-migration');
+const { router: dbMigrationRouter } = require('./db-migration');
 
 // Create minimal Express app
 const app = express();
@@ -26,4 +26,3 @@ app.use((err, req, res, next) => {
 
 // Export as .handler property (Lambda config: db-migration.handler)
 module.exports.handler = serverlessHttp(app);
-