@friggframework/core 2.0.0-next.11 → 2.0.0-next.110

package/handlers/routers/integration-webhook-routers.js

@@ -0,0 +1,80 @@
+const { createAppHandler } = require('./../app-handler-helpers');
+const { loadAppDefinition } = require('../app-definition-loader');
+const { Router } = require('express');
+const {
+    IntegrationEventDispatcher,
+} = require('../integration-event-dispatcher');
+
+const handlers = {};
+const { integrations: integrationClasses } = loadAppDefinition();
+
+// `webhooks.received` is counted at the DB-connected ON_WEBHOOK dispatch (see
+// usage-rollup-subscriber), not in this DB-free receipt handler.
+
+for (const IntegrationClass of integrationClasses) {
+    const webhookConfig = IntegrationClass.Definition.webhooks;
+
+    // Skip if webhooks not enabled
+    if (
+        !webhookConfig ||
+        (typeof webhookConfig === 'object' && !webhookConfig.enabled)
+    ) {
+        continue;
+    }
+
+    const router = Router();
+    const basePath = `/api/${IntegrationClass.Definition.name}-integration/webhooks`;
+
+    console.log(
+        `\n│ Configuring webhook routes for ${IntegrationClass.Definition.name}:`
+    );
+
+    // General webhook route (no integration ID)
+    router.post(basePath, async (req, res, next) => {
+        try {
+            const integrationInstance = new IntegrationClass();
+            const dispatcher = new IntegrationEventDispatcher(
+                integrationInstance
+            );
+            await dispatcher.dispatchHttp({
+                event: 'WEBHOOK_RECEIVED',
+                req,
+                res,
+                next,
+            });
+        } catch (error) {
+            next(error);
+        }
+    });
+    console.log(`│ POST ${basePath}`);
+
+    // Integration-specific webhook route (with integration ID)
+    router.post(`${basePath}/:integrationId`, async (req, res, next) => {
+        try {
+            const integrationInstance = new IntegrationClass();
+            const dispatcher = new IntegrationEventDispatcher(
+                integrationInstance
+            );
+            await dispatcher.dispatchHttp({
+                event: 'WEBHOOK_RECEIVED',
+                req,
+                res,
+                next,
+            });
+        } catch (error) {
+            next(error);
+        }
+    });
+    console.log(`│ POST ${basePath}/:integrationId`);
+    console.log('│');
+
+    handlers[`${IntegrationClass.Definition.name}Webhook`] = {
+        handler: createAppHandler(
+            `HTTP Event: ${IntegrationClass.Definition.name} Webhook`,
+            router,
+            false // shouldUseDatabase = false
+        ),
+    };
+}
+
+module.exports = { handlers };

package/handlers/routers/user.js

@@ -1,10 +1,31 @@
 const express = require('express');
 const { createAppHandler } = require('../app-handler-helpers');
 const { checkRequiredParams } = require('@friggframework/core');
-const { User } = require('../backend-utils');
+const {
+    createUserRepository,
+} = require('../../user/repositories/user-repository-factory');
+const {
+    CreateIndividualUser,
+} = require('../../user/use-cases/create-individual-user');
+const { LoginUser } = require('../../user/use-cases/login-user');
+const {
+    CreateTokenForUserId,
+} = require('../../user/use-cases/create-token-for-user-id');
 const catchAsyncError = require('express-async-handler');
+const { loadAppDefinition } = require('../app-definition-loader');
 
 const router = express();
+const { userConfig } = loadAppDefinition();
+const userRepository = createUserRepository();
+const createIndividualUser = new CreateIndividualUser({
+    userRepository,
+    userConfig,
+});
+const loginUser = new LoginUser({
+    userRepository,
+    userConfig,
+});
+const createTokenForUserId = new CreateTokenForUserId({ userRepository });
 
 // define the login endpoint
 router.route('/user/login').post(
@@ -13,8 +34,8 @@ router.route('/user/login').post(
             'username',
             'password',
         ]);
-        const user = await User.loginUser({ username, password });
-        const token = await user.createUserToken(120);
+        const user = await loginUser.execute({ username, password });
+        const token = await createTokenForUserId.execute(user.getId(), 120);
         res.status(201);
         res.json({ token });
     })
@@ -26,11 +47,12 @@ router.route('/user/create').post(
             'username',
             'password',
         ]);
-        const user = await User.createIndividualUser({
+
+        const user = await createIndividualUser.execute({
             username,
             password,
         });
-        const token = await user.createUserToken(120);
+        const token = await createTokenForUserId.execute(user.getId(), 120);
         res.status(201);
         res.json({ token });
     })

package/handlers/routers/websocket.js

@@ -1,5 +1,7 @@
 const { createHandler } = require('@friggframework/core');
-const { WebsocketConnection } = require('@friggframework/core');
+const { createWebsocketConnectionRepository } = require('../../database/websocket-connection-repository-factory');
+
+const websocketConnectionRepository = createWebsocketConnectionRepository();
 
 const handleWebSocketConnection = async (event, context) => {
     // Handle different WebSocket events
@@ -8,7 +10,7 @@ const handleWebSocketConnection = async (event, context) => {
             // Handle new connection
             try {
                 const connectionId = event.requestContext.connectionId;
-                await WebsocketConnection.create({ connectionId });
+                await websocketConnectionRepository.createConnection(connectionId);
                 console.log(`Stored new connection: ${connectionId}`);
                 return { statusCode: 200, body: 'Connected.' };
             } catch (error) {
@@ -20,7 +22,7 @@ const handleWebSocketConnection = async (event, context) => {
             // Handle disconnection
             try {
                 const connectionId = event.requestContext.connectionId;
-                await WebsocketConnection.deleteOne({ connectionId });
+                await websocketConnectionRepository.deleteConnection(connectionId);
                 console.log(`Removed connection: ${connectionId}`);
                 return { statusCode: 200, body: 'Disconnected.' };
             } catch (error) {

package/handlers/use-cases/check-external-apis-health-use-case.js

@@ -0,0 +1,81 @@
+const https = require('https');
+const http = require('http');
+
+class CheckExternalApisHealthUseCase {
+    constructor({ apis = null } = {}) {
+        this.apis = apis || [
+            { name: 'github', url: 'https://api.github.com/status' },
+            { name: 'npm', url: 'https://registry.npmjs.org' },
+        ];
+    }
+
+    async execute() {
+        const results = await Promise.all(
+            this.apis.map((api) =>
+                this._checkExternalAPI(api.url).then((result) => ({
+                    name: api.name,
+                    ...result,
+                }))
+            )
+        );
+
+        const apiStatuses = {};
+        let allReachable = true;
+
+        results.forEach(({ name, ...checkResult }) => {
+            apiStatuses[name] = checkResult;
+            if (!checkResult.reachable) {
+                allReachable = false;
+            }
+        });
+
+        return { apiStatuses, allReachable };
+    }
+
+    _checkExternalAPI(url, timeout = 5000) {
+        return new Promise((resolve) => {
+            const protocol = url.startsWith('https:') ? https : http;
+            const startTime = Date.now();
+
+            try {
+                const request = protocol.get(url, { timeout }, (res) => {
+                    const responseTime = Date.now() - startTime;
+                    resolve({
+                        status: 'healthy',
+                        statusCode: res.statusCode,
+                        responseTime,
+                        reachable: res.statusCode < 500,
+                    });
+                });
+
+                request.on('error', (error) => {
+                    resolve({
+                        status: 'unhealthy',
+                        error: error.message,
+                        responseTime: Date.now() - startTime,
+                        reachable: false,
+                    });
+                });
+
+                request.on('timeout', () => {
+                    request.destroy();
+                    resolve({
+                        status: 'timeout',
+                        error: 'Request timeout',
+                        responseTime: timeout,
+                        reachable: false,
+                    });
+                });
+            } catch (error) {
+                resolve({
+                    status: 'error',
+                    error: error.message,
+                    responseTime: Date.now() - startTime,
+                    reachable: false,
+                });
+            }
+        });
+    }
+}
+
+module.exports = { CheckExternalApisHealthUseCase };

package/handlers/use-cases/check-integrations-health-use-case.js

@@ -0,0 +1,44 @@
+class CheckIntegrationsHealthUseCase {
+    constructor({ moduleFactory, integrationClasses }) {
+        this.moduleFactory = moduleFactory;
+        this.integrationClasses = integrationClasses;
+    }
+
+    execute() {
+        const moduleDefinitions = (this.moduleFactory && this.moduleFactory.moduleDefinitions)
+            ? this.moduleFactory.moduleDefinitions
+            : [];
+
+        const integrationClasses = Array.isArray(this.integrationClasses)
+            ? this.integrationClasses
+            : [];
+
+        // Extract module names from definitions
+        const moduleTypes = Array.isArray(moduleDefinitions)
+            ? moduleDefinitions.map(def => def.moduleName || def.name || def.label || 'Unknown')
+            : [];
+
+        // Extract integration names from classes
+        const integrationNames = integrationClasses.map(IntegrationClass => {
+            try {
+                return IntegrationClass.Definition?.name || IntegrationClass.name || 'Unknown';
+            } catch {
+                return 'Unknown';
+            }
+        });
+
+        return {
+            status: 'healthy',
+            modules: {
+                count: moduleTypes.length,
+                available: moduleTypes,
+            },
+            integrations: {
+                count: integrationNames.length,
+                available: integrationNames,
+            },
+        };
+    }
+}
+
+module.exports = { CheckIntegrationsHealthUseCase };