@friggframework/core 2.0.0-next.3 → 2.0.0-next.31

package/handlers/routers/middleware/requireLoggedInUser.js

@@ -0,0 +1,12 @@
+const Boom = require('@hapi/boom');
+
+// CheckLoggedIn Middleware
+const requireLoggedInUser = (req, res, next) => {
+    if (!req.user || !req.user.isLoggedIn()) {
+        throw Boom.unauthorized('Invalid Token');
+    }
+
+    next();
+};
+
+module.exports = { requireLoggedInUser };

package/handlers/routers/user.js

@@ -0,0 +1,41 @@
+const express = require('express');
+const { createAppHandler } = require('../app-handler-helpers');
+const { checkRequiredParams } = require('@friggframework/core');
+const { User } = require('../backend-utils');
+const catchAsyncError = require('express-async-handler');
+
+const router = express();
+
+// define the login endpoint
+router.route('/user/login').post(
+    catchAsyncError(async (req, res) => {
+        const { username, password } = checkRequiredParams(req.body, [
+            'username',
+            'password',
+        ]);
+        const user = await User.loginUser({ username, password });
+        const token = await user.createUserToken(120);
+        res.status(201);
+        res.json({ token });
+    })
+);
+
+router.route('/user/create').post(
+    catchAsyncError(async (req, res) => {
+        const { username, password } = checkRequiredParams(req.body, [
+            'username',
+            'password',
+        ]);
+        const user = await User.createIndividualUser({
+            username,
+            password,
+        });
+        const token = await user.createUserToken(120);
+        res.status(201);
+        res.json({ token });
+    })
+);
+
+const handler = createAppHandler('HTTP Event: User', router);
+
+module.exports = { handler, router };

package/handlers/routers/websocket.js

@@ -0,0 +1,55 @@
+const { createHandler } = require('@friggframework/core');
+const { WebsocketConnection } = require('@friggframework/core');
+
+const handleWebSocketConnection = async (event, context) => {
+    // Handle different WebSocket events
+    switch (event.requestContext.eventType) {
+        case 'CONNECT':
+            // Handle new connection
+            try {
+                const connectionId = event.requestContext.connectionId;
+                await WebsocketConnection.create({ connectionId });
+                console.log(`Stored new connection: ${connectionId}`);
+                return { statusCode: 200, body: 'Connected.' };
+            } catch (error) {
+                console.error('Error storing connection:', error);
+                return { statusCode: 500, body: 'Error connecting.' };
+            }
+
+        case 'DISCONNECT':
+            // Handle disconnection
+            try {
+                const connectionId = event.requestContext.connectionId;
+                await WebsocketConnection.deleteOne({ connectionId });
+                console.log(`Removed connection: ${connectionId}`);
+                return { statusCode: 200, body: 'Disconnected.' };
+            } catch (error) {
+                console.error('Error removing connection:', error);
+                return { statusCode: 500, body: 'Error disconnecting.' };
+            }
+
+        case 'MESSAGE':
+            // Handle incoming message
+            const message = JSON.parse(event.body);
+            console.log('Received message:', message);
+
+            // Process the message and send a response
+            const responseMessage = { message: 'Message received' };
+            return {
+                statusCode: 200,
+                body: JSON.stringify(responseMessage),
+            };
+
+        default:
+            return { statusCode: 400, body: 'Unhandled event type.' };
+    }
+};
+
+const handler = createHandler({
+    eventName: 'WebSocket Event',
+    method: handleWebSocketConnection,
+    shouldUseDatabase: true, // Set to true as we're using the database
+    isUserFacingResponse: true, // This is a server-to-server response
+});
+
+module.exports = { handler };

package/handlers/workers/integration-defined-workers.js

@@ -0,0 +1,24 @@
+const { createHandler } = require('@friggframework/core');
+const { integrationFactory, createQueueWorker } = require('../backend-utils');
+
+const handlers = {};
+integrationFactory.integrationClasses.forEach((IntegrationClass) => {
+    const defaultQueueWorker = createQueueWorker(IntegrationClass, integrationFactory);
+
+    handlers[`${IntegrationClass.Definition.name}`] = {
+        queueWorker: createHandler({
+            eventName: `Queue Worker for ${IntegrationClass.Definition.name}`,
+            isUserFacingResponse: false,
+            method: async (event, context) => {
+                const worker = new defaultQueueWorker();
+                await worker.run(event, context);
+                return {
+                    message: 'Successfully processed the Generic Queue Worker',
+                    input: event,
+                };
+            },
+        }),
+    };
+});
+
+module.exports = { handlers };

package/index.js

@@ -59,6 +59,7 @@ const {
     ModuleFactory,
     Auther,
 } = require('./module-plugin/index');
+const utils = require('./utils');
 
 // const {Sync } = require('./syncs/model');
 
@@ -137,4 +138,7 @@ module.exports = {
 
     // queues
     QueuerUtil,
+
+    // utils
+    ...utils,
 };

package/integrations/integration-router.js

@@ -7,7 +7,11 @@ function createIntegrationRouter(params) {
     const router = get(params, 'router', express());
     const factory = get(params, 'factory');
     const getUserId = get(params, 'getUserId', (req) => null);
-    const requireLoggedInUser = get(params, 'requireLoggedInUser', (req, res, next) => next());
+    const requireLoggedInUser = get(
+        params,
+        'requireLoggedInUser',
+        (req, res, next) => next()
+    );
 
     router.all('/api/entities*', requireLoggedInUser);
     router.all('/api/authorize', requireLoggedInUser);
@@ -43,22 +47,23 @@ function checkRequiredParams(params, requiredKeys) {
 }
 
 function setIntegrationRoutes(router, factory, getUserId) {
-    const {moduleFactory, integrationFactory, IntegrationHelper} = factory;
+    const { moduleFactory, integrationFactory, IntegrationHelper } = factory;
     router.route('/api/integrations').get(
         catchAsyncError(async (req, res) => {
             const results = await integrationFactory.getIntegrationOptions();
-            results.entities.authorized = await moduleFactory.getEntitiesForUser(
-                getUserId(req)
-            );
-            results.integrations = await IntegrationHelper.getIntegrationsForUserId(
-                getUserId(req)
-            );
+            results.entities.authorized =
+                await moduleFactory.getEntitiesForUser(getUserId(req));
+            results.integrations =
+                await IntegrationHelper.getIntegrationsForUserId(
+                    getUserId(req)
+                );
 
             for (const integrationRecord of results.integrations) {
-                const integration = await integrationFactory.getInstanceFromIntegrationId({
-                    integrationId: integrationRecord.id,
-                    userId: getUserId(req),
-                });
+                const integration =
+                    await integrationFactory.getInstanceFromIntegrationId({
+                        integrationId: integrationRecord.id,
+                        userId: getUserId(req),
+                    });
                 integrationRecord.userActions = integration.userActions;
             }
             res.json(results);
@@ -75,21 +80,22 @@ function setIntegrationRoutes(router, factory, getUserId) {
             get(params.config, 'type');
 
             // create integration
-            const integration =
-                await integrationFactory.createIntegration(
-                    params.entities,
-                    getUserId(req),
-                    params.config,
-                );
+            const integration = await integrationFactory.createIntegration(
+                params.entities,
+                getUserId(req),
+                params.config
+            );
 
             // post integration initialization
             debug(
                 `Calling onCreate on the ${integration?.constructor?.Config?.name} Integration with no arguments`
             );
-            await integration.onCreate();
+            await integration.send('ON_CREATE', {});
 
             res.status(201).json(
-                await IntegrationHelper.getFormattedIntegration(integration.record)
+                await IntegrationHelper.getFormattedIntegration(
+                    integration.record
+                )
             );
         })
     );
@@ -108,19 +114,19 @@ function setIntegrationRoutes(router, factory, getUserId) {
                 `Calling onUpdate on the ${integration?.constructor?.Config?.name} Integration arguments: `,
                 params
             );
-            await integration.onUpdate(params);
+            await integration.send('ON_UPDATE', params);
 
             res.json(
-                await IntegrationHelper.getFormattedIntegration(integration.record)
+                await IntegrationHelper.getFormattedIntegration(
+                    integration.record
+                )
             );
         })
     );
 
     router.route('/api/integrations/:integrationId').delete(
         catchAsyncError(async (req, res) => {
-            const params = checkRequiredParams(req.params, [
-                'integrationId',
-            ]);
+            const params = checkRequiredParams(req.params, ['integrationId']);
             const integration =
                 await integrationFactory.getInstanceFromIntegrationId({
                     userId: getUserId(req),
@@ -128,9 +134,9 @@ function setIntegrationRoutes(router, factory, getUserId) {
                 });
 
             debug(
-                `Calling onUpdate on the ${integration?.constructor?.Config?.name} Integration with no arguments`
+                `Calling onUpdate on the ${integration?.constructor?.Definition?.name} Integration with no arguments`
             );
-            await integration.onDelete();
+            await integration.send('ON_DELETE');
             await IntegrationHelper.deleteIntegrationForUserById(
                 getUserId(req),
                 params.integrationId
@@ -142,79 +148,101 @@ function setIntegrationRoutes(router, factory, getUserId) {
 
     router.route('/api/integrations/:integrationId/config/options').get(
         catchAsyncError(async (req, res) => {
-            const params = checkRequiredParams(req.params, [
-                'integrationId',
-            ]);
+            const params = checkRequiredParams(req.params, ['integrationId']);
             const integration =
                 await integrationFactory.getInstanceFromIntegrationId(params);
-            res.json(await integration.getConfigOptions());
+            res.json(await integration.send('GET_CONFIG_OPTIONS'));
         })
     );
 
-    router.route('/api/integrations/:integrationId/config/options/refresh').post(
-        catchAsyncError(async (req, res) => {
-            const params = checkRequiredParams(req.params, [
-                'integrationId',
-            ]);
-            const integration =
-                await integrationFactory.getInstanceFromIntegrationId(params);
-
-            res.json(
-                await integration.refreshConfigOptions(req.body)
-            );
-        })
-    );
-
-    router.route('/api/integrations/:integrationId/actions/:actionId/options').get(
+    router
+        .route('/api/integrations/:integrationId/config/options/refresh')
+        .post(
+            catchAsyncError(async (req, res) => {
+                const params = checkRequiredParams(req.params, [
+                    'integrationId',
+                ]);
+                const integration =
+                    await integrationFactory.getInstanceFromIntegrationId(
+                        params
+                    );
+
+                res.json(
+                    await integration.send('REFRESH_CONFIG_OPTIONS', req.body)
+                );
+            })
+        );
+    router.route('/api/integrations/:integrationId/actions').all(
         catchAsyncError(async (req, res) => {
-            const params = checkRequiredParams(req.params, [
-                'integrationId',
-                'actionId'
-            ]);
+            const params = checkRequiredParams(req.params, ['integrationId']);
             const integration =
                 await integrationFactory.getInstanceFromIntegrationId(params);
-
-            res.json(
-                await integration.getActionOptions(params.actionId)
-            );
+            res.json(await integration.send('GET_USER_ACTIONS', req.body));
         })
     );
 
-    router.route('/api/integrations/:integrationId/actions/:actionId/options/refresh').post(
-        catchAsyncError(async (req, res) => {
-            const params = checkRequiredParams(req.params, [
-                'integrationId',
-                'actionId'
-            ]);
-            const integration =
-                await integrationFactory.getInstanceFromIntegrationId(params);
+    router
+        .route('/api/integrations/:integrationId/actions/:actionId/options')
+        .all(
+            catchAsyncError(async (req, res) => {
+                const params = checkRequiredParams(req.params, [
+                    'integrationId',
+                    'actionId',
+                ]);
+                const integration =
+                    await integrationFactory.getInstanceFromIntegrationId(
+                        params
+                    );
+
+                res.json(
+                    await integration.send('GET_USER_ACTION_OPTIONS', {
+                        actionId: params.actionId,
+                        data: req.body,
+                    })
+                );
+            })
+        );
 
-            res.json(
-                await integration.refreshActionOptions(params.actionId, req.body)
-            );
-        })
-    );
+    router
+        .route(
+            '/api/integrations/:integrationId/actions/:actionId/options/refresh'
+        )
+        .post(
+            catchAsyncError(async (req, res) => {
+                const params = checkRequiredParams(req.params, [
+                    'integrationId',
+                    'actionId',
+                ]);
+                const integration =
+                    await integrationFactory.getInstanceFromIntegrationId(
+                        params
+                    );
+
+                res.json(
+                    await integration.send('REFRESH_USER_ACTION_OPTIONS', {
+                        actionId: params.actionId,
+                        data: req.body,
+                    })
+                );
+            })
+        );
 
     router.route('/api/integrations/:integrationId/actions/:actionId').post(
         catchAsyncError(async (req, res) => {
             const params = checkRequiredParams(req.params, [
                 'integrationId',
-                'actionId'
+                'actionId',
             ]);
             const integration =
                 await integrationFactory.getInstanceFromIntegrationId(params);
 
-            res.json(
-                await integration.notify(params.actionId, req.body)
-            );
+            res.json(await integration.send(params.actionId, req.body));
         })
     );
 
     router.route('/api/integrations/:integrationId').get(
         catchAsyncError(async (req, res) => {
-            const params = checkRequiredParams(req.params, [
-                'integrationId',
-            ]);
+            const params = checkRequiredParams(req.params, ['integrationId']);
             const integration = await IntegrationHelper.getIntegrationById(
                 params.integrationId
             );
@@ -231,13 +259,12 @@ function setIntegrationRoutes(router, factory, getUserId) {
 
     router.route('/api/integrations/:integrationId/test-auth').get(
         catchAsyncError(async (req, res) => {
-            const params = checkRequiredParams(req.params, [
-                'integrationId',
-            ]);
-            const instance = await integrationFactory.getInstanceFromIntegrationId({
-                userId: getUserId(req),
-                integrationId: params.integrationId,
-            });
+            const params = checkRequiredParams(req.params, ['integrationId']);
+            const instance =
+                await integrationFactory.getInstanceFromIntegrationId({
+                    userId: getUserId(req),
+                    integrationId: params.integrationId,
+                });
 
             if (!instance) {
                 throw Boom.notFound();
@@ -260,7 +287,7 @@ function setIntegrationRoutes(router, factory, getUserId) {
 }
 
 function setEntityRoutes(router, factory, getUserId) {
-    const {moduleFactory, IntegrationHelper} = factory;
+    const { moduleFactory, IntegrationHelper } = factory;
     const getModuleInstance = async (req, entityType) => {
         if (!moduleFactory.checkIsValidType(entityType)) {
             throw Boom.badRequest(
@@ -269,14 +296,15 @@ function setEntityRoutes(router, factory, getUserId) {
                 )}`
             );
         }
-        return await moduleFactory.getInstanceFromTypeName(entityType, getUserId(req));
+        return await moduleFactory.getInstanceFromTypeName(
+            entityType,
+            getUserId(req)
+        );
     };
 
     router.route('/api/authorize').get(
         catchAsyncError(async (req, res) => {
-            const params = checkRequiredParams(req.query, [
-                'entityType',
-            ]);
+            const params = checkRequiredParams(req.query, ['entityType']);
             const module = await getModuleInstance(req, params.entityType);
             const areRequirementsValid =
                 module.validateAuthorizationRequirements();
@@ -330,11 +358,9 @@ function setEntityRoutes(router, factory, getUserId) {
                 null,
                 null,
                 getUserId(req)
-            )
-
-            res.json(
-                await module.findOrCreateEntity(entityDetails)
             );
+
+            res.json(await module.findOrCreateEntity(entityDetails));
         })
     );
 
@@ -349,9 +375,7 @@ function setEntityRoutes(router, factory, getUserId) {
                 throw Boom.forbidden('Credential does not belong to user');
             }
 
-            const params = checkRequiredParams(req.query, [
-                'entityType',
-            ]);
+            const params = checkRequiredParams(req.query, ['entityType']);
             const module = await getModuleInstance(req, params.entityType);
 
             res.json(await module.getEntityOptions());
@@ -384,7 +408,7 @@ function setEntityRoutes(router, factory, getUserId) {
                     ],
                 });
             } else {
-                res.json({status: 'ok'});
+                res.json({ status: 'ok' });
             }
         })
     );
@@ -409,7 +433,7 @@ function setEntityRoutes(router, factory, getUserId) {
         catchAsyncError(async (req, res) => {
             const params = checkRequiredParams(req.params, [
                 'entityId',
-                getUserId(req)
+                getUserId(req),
             ]);
             const module = await moduleFactory.getModuleInstanceFromEntityId(
                 params.entityId,
@@ -428,7 +452,7 @@ function setEntityRoutes(router, factory, getUserId) {
         catchAsyncError(async (req, res) => {
             const params = checkRequiredParams(req.params, [
                 'entityId',
-                getUserId(req)
+                getUserId(req),
             ]);
             const module = await moduleFactory.getModuleInstanceFromEntityId(
                 params.entityId,

package/integrations/options.js

@@ -1,6 +1,5 @@
 const { RequiredPropertyError } = require('../errors');
 const { get, getAndVerifyType } = require('../assertions');
-const { ModuleManager } = require('../module-plugin');
 
 class Options {
     constructor(params) {
@@ -18,7 +17,7 @@ class Options {
         }
 
         this.display = {};
-        this.display.name = get(params.display, 'name');
+        this.display.name = get(params.display, 'label');
         this.display.description = get(params.display, 'description');
         this.display.detailsUrl = get(params.display, 'detailsUrl');
         this.display.icon = get(params.display, 'icon');
@@ -26,7 +25,7 @@ class Options {
 
     get() {
         return {
-            type: this.module.getName(),
+            type: this.module.definition.getName(),
 
             // Flag for if the User can configure any settings
             hasUserConfig: this.hasUserConfig,