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

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,
+};

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,

package/module-plugin/auther.js

@@ -25,15 +25,14 @@
 // 1. Add definition of expected params to API Class (or could just be credential?)
 // 2.
 
-
 const { Delegate } = require('../core');
 const { get } = require('../assertions');
 const _ = require('lodash');
-const {flushDebugLog} = require('../logs');
+const { flushDebugLog } = require('../logs');
 const { Credential } = require('./credential');
 const { Entity } = require('./entity');
 const { mongoose } = require('../database/mongoose');
-const {ModuleConstants} = require("./ModuleConstants");
+const { ModuleConstants } = require('./ModuleConstants');
 
 class Auther extends Delegate {
     static validateDefinition(definition) {
@@ -55,21 +54,35 @@ class Auther extends Delegate {
         if (!definition.requiredAuthMethods) {
             throw new Error('Auther definition requires requiredAuthMethods');
         } else {
-            if (definition.API.requesterType === ModuleConstants.authType.oauth2 &&
-                !definition.requiredAuthMethods.getToken) {
-                throw new Error('Auther definition requires requiredAuthMethods.getToken');
+            if (
+                definition.API.requesterType ===
+                    ModuleConstants.authType.oauth2 &&
+                !definition.requiredAuthMethods.getToken
+            ) {
+                throw new Error(
+                    'Auther definition requires requiredAuthMethods.getToken'
+                );
             }
             if (!definition.requiredAuthMethods.getEntityDetails) {
-                throw new Error('Auther definition requires requiredAuthMethods.getEntityDetails');
+                throw new Error(
+                    'Auther definition requires requiredAuthMethods.getEntityDetails'
+                );
             }
             if (!definition.requiredAuthMethods.getCredentialDetails) {
-                throw new Error('Auther definition requires requiredAuthMethods.getCredentialDetails');
+                throw new Error(
+                    'Auther definition requires requiredAuthMethods.getCredentialDetails'
+                );
             }
             if (!definition.requiredAuthMethods.apiPropertiesToPersist) {
-                throw new Error('Auther definition requires requiredAuthMethods.apiPropertiesToPersist');
-            } else if (definition.Credential){
-                for (const prop of definition.requiredAuthMethods.apiPropertiesToPersist?.credential) {
-                    if (!definition.Credential.schema.paths.hasOwnProperty(prop)) {
+                throw new Error(
+                    'Auther definition requires requiredAuthMethods.apiPropertiesToPersist'
+                );
+            } else if (definition.Credential) {
+                for (const prop of definition.requiredAuthMethods
+                    .apiPropertiesToPersist?.credential) {
+                    if (
+                        !definition.Credential.schema.paths.hasOwnProperty(prop)
+                    ) {
                         throw new Error(
                             `Auther definition requires Credential schema to have property ${prop}`
                         );
@@ -77,7 +90,9 @@ class Auther extends Delegate {
                 }
             }
             if (!definition.requiredAuthMethods.testAuthRequest) {
-                throw new Error('Auther definition requires requiredAuthMethods.testAuth');
+                throw new Error(
+                    'Auther definition requires requiredAuthMethods.testAuth'
+                );
             }
         }
     }
@@ -97,14 +112,17 @@ class Auther extends Delegate {
         this.name = definition.moduleName;
         this.modelName = definition.modelName;
         this.apiClass = definition.API;
-        this.CredentialModel = definition.Credential || this.getCredentialModel();
+        this.CredentialModel =
+            definition.Credential || this.getCredentialModel();
         this.EntityModel = definition.Entity || this.getEntityModel();
     }
 
     static async getInstance(params) {
         const instance = new this(params);
         if (params.entityId) {
-            instance.entity = await instance.EntityModel.findById(params.entityId);
+            instance.entity = await instance.EntityModel.findById(
+                params.entityId
+            );
             instance.credential = await instance.CredentialModel.findById(
                 instance.entity.credential
             );
@@ -132,7 +150,7 @@ class Auther extends Delegate {
     }
 
     static getEntityModelFromDefinition(definition) {
-        const partialModule = new this({definition});
+        const partialModule = new this({ definition });
         return partialModule.getEntityModel();
     }
 
@@ -151,30 +169,38 @@ class Auther extends Delegate {
     getEntityModel() {
         if (!this.EntityModel) {
             const prefix = this.modelName ?? _.upperFirst(this.getName());
-            const arrayToDefaultObject = (array, defaultValue) => _.mapValues(_.keyBy(array), () => defaultValue);
-            const schema = new mongoose.Schema(arrayToDefaultObject(this.apiPropertiesToPersist.entity, {
-                type: mongoose.Schema.Types.Mixed,
-                trim: true,
-            }));
+            const arrayToDefaultObject = (array, defaultValue) =>
+                _.mapValues(_.keyBy(array), () => defaultValue);
+            const schema = new mongoose.Schema(
+                arrayToDefaultObject(this.apiPropertiesToPersist.entity, {
+                    type: mongoose.Schema.Types.Mixed,
+                    trim: true,
+                })
+            );
             const name = `${prefix}Entity`;
             this.EntityModel =
-                Entity.discriminators?.[name] || Entity.discriminator(name, schema);
+                Entity.discriminators?.[name] ||
+                Entity.discriminator(name, schema);
         }
         return this.EntityModel;
     }
 
     getCredentialModel() {
         if (!this.CredentialModel) {
-            const arrayToDefaultObject = (array, defaultValue) => _.mapValues(_.keyBy(array), () => defaultValue);
-            const schema = new mongoose.Schema(arrayToDefaultObject(this.apiPropertiesToPersist.credential, {
-                type: mongoose.Schema.Types.Mixed,
-                trim: true,
-                lhEncrypt: true
-            }));
+            const arrayToDefaultObject = (array, defaultValue) =>
+                _.mapValues(_.keyBy(array), () => defaultValue);
+            const schema = new mongoose.Schema(
+                arrayToDefaultObject(this.apiPropertiesToPersist.credential, {
+                    type: mongoose.Schema.Types.Mixed,
+                    trim: true,
+                    lhEncrypt: true,
+                })
+            );
             const prefix = this.modelName ?? _.upperFirst(this.getName());
             const name = `${prefix}Credential`;
             this.CredentialModel =
-                Credential.discriminators?.[name] || Credential.discriminator(name, schema);
+                Credential.discriminators?.[name] ||
+                Credential.discriminator(name, schema);
         }
         return this.CredentialModel;
     }
@@ -197,7 +223,10 @@ class Auther extends Delegate {
     async validateAuthorizationRequirements() {
         const requirements = await this.getAuthorizationRequirements();
         let valid = true;
-        if (['oauth1', 'oauth2'].includes(requirements.type) && !requirements.url) {
+        if (
+            ['oauth1', 'oauth2'].includes(requirements.type) &&
+            !requirements.url
+        ) {
             valid = false;
         }
         return valid;
@@ -238,20 +267,32 @@ class Auther extends Delegate {
             throw new Error('Authorization failed');
         }
         const entityDetails = await this.getEntityDetails(
-            this.api, params, tokenResponse, this.userId
+            this.api,
+            params,
+            tokenResponse,
+            this.userId
+        );
+        Object.assign(
+            entityDetails.details,
+            this.apiParamsFromEntity(this.api)
         );
-        Object.assign(entityDetails.details, this.apiParamsFromEntity(this.api));
         await this.findOrCreateEntity(entityDetails);
         return {
             credential_id: this.credential.id,
             entity_id: this.entity.id,
             type: this.getName(),
-        }
+        };
     }
 
     async onTokenUpdate() {
-        const credentialDetails = await this.getCredentialDetails(this.api, this.userId);
-        Object.assign(credentialDetails.details, this.apiParamsFromCredential(this.api));
+        const credentialDetails = await this.getCredentialDetails(
+            this.api,
+            this.userId
+        );
+        Object.assign(
+            credentialDetails.details,
+            this.apiParamsFromCredential(this.api)
+        );
         credentialDetails.details.auth_is_valid = true;
         await this.updateOrCreateCredential(credentialDetails);
     }
@@ -259,11 +300,9 @@ class Auther extends Delegate {
     async receiveNotification(notifier, delegateString, object = null) {
         if (delegateString === this.api.DLGT_TOKEN_UPDATE) {
             await this.onTokenUpdate();
-        }
-        else if (delegateString === this.api.DLGT_TOKEN_DEAUTHORIZED) {
+        } else if (delegateString === this.api.DLGT_TOKEN_DEAUTHORIZED) {
             await this.deauthorize();
-        }
-        else if (delegateString === this.api.DLGT_INVALID_AUTH) {
+        } else if (delegateString === this.api.DLGT_INVALID_AUTH) {
             await this.markCredentialsInvalid();
         }
     }
@@ -286,10 +325,10 @@ class Auther extends Delegate {
         const search = await this.EntityModel.find(identifiers);
         if (search.length > 1) {
             throw new Error(
-                'Multiple entities found with the same identifiers: ' + JSON.stringify(identifiers)
+                'Multiple entities found with the same identifiers: ' +
+                    JSON.stringify(identifiers)
             );
-        }
-        else if (search.length === 0) {
+        } else if (search.length === 0) {
             this.entity = await this.EntityModel.create({
                 credential: this.credential.id,
                 ...details,
@@ -308,25 +347,27 @@ class Auther extends Delegate {
         const identifiers = get(credentialDetails, 'identifiers');
         const details = get(credentialDetails, 'details');
 
-        if (!this.credential){
-            const credentialSearch = await this.CredentialModel.find(identifiers);
+        if (!this.credential) {
+            const credentialSearch = await this.CredentialModel.find(
+                identifiers
+            );
             if (credentialSearch.length > 1) {
-                throw new Error(`Multiple credentials found with same identifiers: ${identifiers}`);
-            }
-            else if (credentialSearch.length === 1) {
+                throw new Error(
+                    `Multiple credentials found with same identifiers: ${identifiers}`
+                );
+            } else if (credentialSearch.length === 1) {
                 // found exactly one credential with these identifiers
                 this.credential = credentialSearch[0];
-            }
-            else {
+            } else {
                 // found no credential with these identifiers (match none for insert)
-                this.credential = {$exists: false};
+                this.credential = { $exists: false };
             }
         }
         // update credential or create if none was found
         this.credential = await this.CredentialModel.findOneAndUpdate(
-            {_id: this.credential},
-            {$set: {...identifiers, ...details}},
-            {useFindAndModify: true, new: true, upsert: true}
+            { _id: this.credential },
+            { $set: { ...identifiers, ...details } },
+            { useFindAndModify: true, new: true, upsert: true }
         );
     }
 
@@ -340,7 +381,9 @@ class Auther extends Delegate {
     async deauthorize() {
         this.api = new this.apiClass();
         if (this.entity?.credential) {
-            await this.CredentialModel.deleteOne({ _id: this.entity.credential });
+            await this.CredentialModel.deleteOne({
+                _id: this.entity.credential,
+            });
             this.entity.credential = undefined;
             await this.entity.save();
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/core",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0-next.1",
+  "version": "2.0.0-next.10",
   "dependencies": {
     "@hapi/boom": "^10.0.1",
     "aws-sdk": "^2.1200.0",
@@ -15,9 +15,9 @@
     "node-fetch": "^2.6.7"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0-next.1",
-    "@friggframework/prettier-config": "2.0.0-next.1",
-    "@friggframework/test": "2.0.0-next.1",
+    "@friggframework/eslint-config": "2.0.0-next.10",
+    "@friggframework/prettier-config": "2.0.0-next.10",
+    "@friggframework/test": "2.0.0-next.10",
     "@types/lodash": "^4.14.191",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "chai": "^4.3.6",
@@ -48,5 +48,5 @@
   },
   "homepage": "https://github.com/friggframework/frigg#readme",
   "description": "",
-  "gitHead": "44b619e288b23d879673518076cf9e4acacb3c71"
+  "gitHead": "67dc76e94c02c0074f7ff2d7292c4d2203bf3949"
 }