@friggframework/core 2.0.0-next.0 → 2.0.0-next.10

package/database/index.js

@@ -1,14 +1,15 @@
-const { mongoose} = require('./mongoose');
+const { mongoose } = require('./mongoose');
 const {
     connectToDatabase,
     disconnectFromDatabase,
     createObjectId,
 } = require('./mongo');
-const {IndividualUser} = require('./models/IndividualUser');
-const {OrganizationUser} = require('./models/OrganizationUser');
-const {State} = require('./models/State');
-const {Token} = require('./models/Token');
-const {UserModel} = require('./models/UserModel');
+const { IndividualUser } = require('./models/IndividualUser');
+const { OrganizationUser } = require('./models/OrganizationUser');
+const { State } = require('./models/State');
+const { Token } = require('./models/Token');
+const { UserModel } = require('./models/UserModel');
+const { WebsocketConnection } = require('./models/WebsocketConnection');
 
 module.exports = {
     mongoose,
@@ -19,5 +20,6 @@ module.exports = {
     OrganizationUser,
     State,
     Token,
-    UserModel
-}
+    UserModel,
+    WebsocketConnection,
+};

package/database/models/WebsocketConnection.js

@@ -0,0 +1,49 @@
+const { mongoose } = require('../mongoose');
+const AWS = require('aws-sdk');
+
+const schema = new mongoose.Schema({
+    connectionId: { type: mongoose.Schema.Types.String },
+});
+
+// Add a static method to get active connections
+schema.statics.getActiveConnections = async function () {
+    try {
+        const connections = await this.find({}, 'connectionId');
+        return connections.map((conn) => ({
+            connectionId: conn.connectionId,
+            send: async (data) => {
+                const apigwManagementApi = new AWS.ApiGatewayManagementApi({
+                    apiVersion: '2018-11-29',
+                    endpoint: process.env.WEBSOCKET_API_ENDPOINT,
+                });
+
+                try {
+                    await apigwManagementApi
+                        .postToConnection({
+                            ConnectionId: conn.connectionId,
+                            Data: JSON.stringify(data),
+                        })
+                        .promise();
+                } catch (error) {
+                    if (error.statusCode === 410) {
+                        console.log(`Stale connection ${conn.connectionId}`);
+                        await this.deleteOne({
+                            connectionId: conn.connectionId,
+                        });
+                    } else {
+                        throw error;
+                    }
+                }
+            },
+        }));
+    } catch (error) {
+        console.error('Error getting active connections:', error);
+        throw error;
+    }
+};
+
+const WebsocketConnection =
+    mongoose.models.WebsocketConnection ||
+    mongoose.model('WebsocketConnection', schema);
+
+module.exports = { WebsocketConnection };

package/handlers/app-handler-helpers.js

@@ -0,0 +1,57 @@
+const { createHandler, flushDebugLog } = require('@friggframework/core');
+const express = require('express');
+const bodyParser = require('body-parser');
+const cors = require('cors');
+const Boom = require('@hapi/boom');
+const loadUserManager = require('./routers/middleware/loadUser');
+const serverlessHttp = require('serverless-http');
+
+const createApp = (applyMiddleware) => {
+    const app = express();
+
+    app.use(bodyParser.json({ limit: '10mb' }));
+    app.use(bodyParser.urlencoded({ extended: true }));
+    app.use(
+        cors({
+            origin: '*',
+            credentials: true,
+        })
+    );
+
+    app.use(loadUserManager);
+
+    if (applyMiddleware) applyMiddleware(app);
+
+    // Handle sending error response and logging server errors to console
+    app.use((err, req, res, next) => {
+        const boomError = err.isBoom ? err : Boom.boomify(err);
+        const {
+            output: { statusCode = 500 },
+        } = boomError;
+
+        if (statusCode >= 500) {
+            flushDebugLog(boomError);
+            res.status(statusCode).json({ error: 'Internal Server Error' });
+        } else {
+            res.status(statusCode).json({ error: err.message });
+        }
+    });
+
+    return app;
+};
+
+function createAppHandler(eventName, router, shouldUseDatabase = true) {
+    const app = createApp((app) => {
+        app.use(router);
+    });
+    return createHandler({
+        eventName,
+        method: serverlessHttp(app),
+        shouldUseDatabase,
+    });
+}
+
+module.exports = {
+    createApp,
+    createAppHandler,
+};

package/handlers/backend-utils.js

@@ -0,0 +1,87 @@
+const { createFriggBackend, Worker } = require('@friggframework/core');
+const {
+    findNearestBackendPackageJson,
+} = require('../../devtools/frigg-cli/utils/backend-path');
+const path = require('node:path');
+const fs = require('fs-extra');
+
+const backendPath = findNearestBackendPackageJson();
+if (!backendPath) {
+    throw new Error('Could not find backend package.json');
+}
+
+const backendDir = path.dirname(backendPath);
+const backendFilePath = path.join(backendDir, 'index.js');
+if (!fs.existsSync(backendFilePath)) {
+    throw new Error('Could not find index.js');
+}
+
+const backendJsFile = require(backendFilePath);
+const { Router } = require('express');
+const appDefinition = backendJsFile.Definition;
+
+const backend = createFriggBackend(appDefinition);
+const loadRouterFromObject = (IntegrationClass, routerObject) => {
+    const router = Router();
+    const { path, method, event } = routerObject;
+    console.log(
+        `Registering ${method} ${path} for ${IntegrationClass.Definition.name}`
+    );
+    router[method.toLowerCase()](path, async (req, res, next) => {
+        try {
+            const integration = new IntegrationClass({});
+            await integration.loadModules();
+            await integration.registerEventHandlers();
+            const result = await integration.send(event, {req, res, next});
+            res.json(result);
+        } catch (error) {
+            next(error);
+        }
+    });
+
+    return router;
+};
+const createQueueWorker = (integrationClass) => {
+    class QueueWorker extends Worker {
+        async _run(params, context) {
+            try {
+                let instance;
+                if (!params.integrationId) {
+                    instance = new integrationClass({});
+                    await instance.loadModules();
+                    // await instance.loadUserActions();
+                    await instance.registerEventHandlers();
+                    console.log(
+                        `${params.event} for ${integrationClass.Definition.name} integration with no integrationId`
+                    );
+                } else {
+                    instance =
+                        await integrationClass.getInstanceFromIntegrationId({
+                            integrationId: params.integrationId,
+                        });
+                    console.log(
+                        `${params.event} for ${instance.integration.config.type} of integrationId: ${params.integrationId}`
+                    );
+                }
+                const res = await instance.send(params.event, {
+                    data: params.data,
+                    context,
+                });
+                return res;
+            } catch (error) {
+                console.error(
+                    `Error in ${params.event} for ${integrationClass.Definition.name}:`,
+                    error
+                );
+                throw error;
+            }
+        }
+    }
+    return QueueWorker;
+};
+
+module.exports = {
+    ...backend,
+    loadRouterFromObject,
+    createQueueWorker,
+};

package/handlers/routers/auth.js

@@ -0,0 +1,26 @@
+const { createIntegrationRouter } = require('@friggframework/core');
+const { createAppHandler } = require('./../app-handler-helpers');
+const { requireLoggedInUser } = require('./middleware/requireLoggedInUser');
+const {
+    moduleFactory,
+    integrationFactory,
+    IntegrationHelper,
+} = require('./../backend-utils');
+
+const router = createIntegrationRouter({
+    factory: { moduleFactory, integrationFactory, IntegrationHelper },
+    requireLoggedInUser,
+    getUserId: (req) => req.user.getUserId(),
+});
+
+router.route('/redirect/:appId').get((req, res) => {
+    res.redirect(
+        `${process.env.FRONTEND_URI}/redirect/${
+            req.params.appId
+        }?${new URLSearchParams(req.query)}`
+    );
+});
+
+const handler = createAppHandler('HTTP Event: Auth', router);
+
+module.exports = { handler, router };

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

@@ -0,0 +1,42 @@
+const { createAppHandler } = require('./../app-handler-helpers');
+const {
+    integrationFactory,
+    loadRouterFromObject,
+} = require('./../backend-utils');
+const { Router } = require('express');
+
+const handlers = {};
+for (const IntegrationClass of integrationFactory.integrationClasses) {
+    const router = Router();
+    const basePath = `/api/${IntegrationClass.Definition.name}-integration`;
+    
+    console.log(`\n│ Configuring routes for ${IntegrationClass.Definition.name} Integration:`);
+
+    for (const routeDef of IntegrationClass.Definition.routes) {
+        if (typeof routeDef === 'function') {
+            router.use(basePath, routeDef(IntegrationClass));
+            console.log(`│ ANY ${basePath}/* (function handler)`);
+        } else if (typeof routeDef === 'object') {
+            router.use(
+                basePath,
+                loadRouterFromObject(IntegrationClass, routeDef)
+            );
+            const method = (routeDef.method || 'ANY').toUpperCase();
+            const fullPath = `${basePath}${routeDef.path}`;
+            console.log(`│ ${method} ${fullPath}`);
+        } else if (routeDef instanceof express.Router) {
+            router.use(basePath, routeDef);
+            console.log(`│ ANY ${basePath}/* (express router)`);
+        }
+    }
+    console.log('│');
+
+    handlers[`${IntegrationClass.Definition.name}`] = {
+        handler: createAppHandler(
+            `HTTP Event: ${IntegrationClass.Definition.name}`,
+            router
+        ),
+    };
+}
+
+module.exports = { handlers };

package/handlers/routers/middleware/loadUser.js

@@ -0,0 +1,15 @@
+const catchAsyncError = require('express-async-handler');
+const { User } = require('../../backend-utils');
+
+module.exports = catchAsyncError(async (req, res, next) => {
+    const authorizationHeader = req.headers.authorization;
+
+    if (authorizationHeader) {
+        // Removes "Bearer " and trims
+        const token = authorizationHeader.split(' ')[1].trim();
+        // Load user for later middleware/routes to use
+        req.user = await User.newUser({ token });
+    }
+
+    return next();
+});

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);
+
+    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

@@ -7,7 +7,12 @@ const {
     getArrayParamAndVerifyParamType,
     getAndVerifyType,
 } = require('./assertions/index');
-const  { Delegate, Worker, loadInstalledModules, createHandler } = require('./core/index');
+const {
+    Delegate,
+    Worker,
+    loadInstalledModules,
+    createHandler,
+} = require('./core/index');
 const {
     mongoose,
     connectToDatabase,
@@ -17,7 +22,8 @@ const {
     OrganizationUser,
     State,
     Token,
-    UserModel
+    UserModel,
+    WebsocketConnection,
 } = require('./database/index');
 const { Encrypt, Cryptor } = require('./encrypt/encrypt');
 const {
@@ -26,7 +32,7 @@ const {
     HaltError,
     RequiredPropertyError,
     ParameterTypeError,
-} =  require('./errors/index');
+} = require('./errors/index');
 const {
     IntegrationBase,
     IntegrationModel,
@@ -36,14 +42,10 @@ const {
     IntegrationHelper,
     createIntegrationRouter,
     checkRequiredParams,
-    createFriggBackend
+    createFriggBackend,
 } = require('./integrations/index');
 const { TimeoutCatcher } = require('./lambda/index');
-const {
-    debug,
-    initDebugLog,
-    flushDebugLog
-} = require('./logs/index');
+const { debug, initDebugLog, flushDebugLog } = require('./logs/index');
 const {
     Credential,
     EntityManager,
@@ -55,11 +57,13 @@ const {
     Requester,
     ModuleConstants,
     ModuleFactory,
-    Auther
+    Auther,
 } = require('./module-plugin/index');
 
 // const {Sync } = require('./syncs/model');
 
+const { QueuerUtil } = require('./queues');
+
 module.exports = {
     // assertions
     expectShallowEqualDbObject,
@@ -69,11 +73,13 @@ module.exports = {
     getParamAndVerifyParamType,
     getArrayParamAndVerifyParamType,
     getAndVerifyType,
+
     // core
     Delegate,
     Worker,
     loadInstalledModules,
     createHandler,
+
     // database
     mongoose,
     connectToDatabase,
@@ -84,15 +90,19 @@ module.exports = {
     State,
     Token,
     UserModel,
+    WebsocketConnection,
+
     // encrypt
     Encrypt,
     Cryptor,
+
     // errors
     BaseError,
     FetchError,
     HaltError,
     RequiredPropertyError,
     ParameterTypeError,
+
     // integrations
     IntegrationBase,
     IntegrationModel,
@@ -103,12 +113,15 @@ module.exports = {
     checkRequiredParams,
     createIntegrationRouter,
     createFriggBackend,
+
     // lambda
     TimeoutCatcher,
+
     // logs
     debug,
     initDebugLog,
     flushDebugLog,
+
     // module plugin
     Credential,
     EntityManager,
@@ -120,5 +133,8 @@ module.exports = {
     Requester,
     ModuleConstants,
     ModuleFactory,
-    Auther
-}
+    Auther,
+
+    // queues
+    QueuerUtil,
+};