@friggframework/core 2.0.0--canary.395.65f5f64.0 → 2.0.0--canary.398.24926ac.0

package/core/create-handler.js

@@ -34,7 +34,6 @@ const createHandler = (optionByName = {}) => {
             // Helps mongoose reuse the connection.  Lowers response times.
             context.callbackWaitsForEmptyEventLoop = false;
 
-            // todo: this should not be necessary anymore
             if (shouldUseDatabase) {
                 await connectToDatabase();
             }

package/database/models/WebsocketConnection.js

@@ -8,6 +8,11 @@ const schema = new mongoose.Schema({
 // Add a static method to get active connections
 schema.statics.getActiveConnections = async function () {
     try {
+        // Return empty array if websockets are not configured
+        if (!process.env.WEBSOCKET_API_ENDPOINT) {
+            return [];
+        }
+
         const connections = await this.find({}, 'connectionId');
         return connections.map((conn) => ({
             connectionId: conn.connectionId,

package/handlers/app-handler-helpers.js

@@ -3,6 +3,7 @@ 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) => {
@@ -19,6 +20,8 @@ const createApp = (applyMiddleware) => {
         })
     );
 
+    app.use(loadUserManager);
+
     if (applyMiddleware) applyMiddleware(app);
 
     // Handle sending error response and logging server errors to console

package/handlers/backend-utils.js

@@ -1,35 +1,36 @@
+const { createFriggBackend, Worker } = require('@friggframework/core');
+const { findNearestBackendPackageJson } = require('@friggframework/core/utils');
+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 { Worker } = require('@friggframework/core');
-const { IntegrationRepository } = require('../integrations/integration-repository');
-const { ModuleFactory } = require('../modules/module-factory');
-const { getModulesDefinitionFromIntegrationClasses } = require('../integrations/utils/map-integration-dto');
-const { ModuleRepository } = require('../modules/module-repository');
-const { GetIntegrationInstanceByDefinition } = require('../integrations/use-cases/get-integration-instance-by-definition');
+const appDefinition = backendJsFile.Definition;
 
+const backend = createFriggBackend(appDefinition);
 const loadRouterFromObject = (IntegrationClass, routerObject) => {
-
-    const integrationRepository = new IntegrationRepository();
-    const moduleRepository = new ModuleRepository();
-    const moduleFactory = new ModuleFactory({
-        moduleRepository,
-        moduleDefinitions: getModulesDefinitionFromIntegrationClasses([IntegrationClass]),
-    });
     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 getIntegrationInstanceByDefinition = new GetIntegrationInstanceByDefinition({
-                integrationRepository,
-                moduleFactory,
-                moduleRepository,
-            });
-            const integration = await getIntegrationInstanceByDefinition.execute(IntegrationClass);
-            const result = await integration.send(event, { req, res, next });
+            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);
@@ -38,29 +39,29 @@ const loadRouterFromObject = (IntegrationClass, routerObject) => {
 
     return router;
 };
-
-//todo: this should be in a use case class
-const createQueueWorker = (integrationClass) => {
+const createQueueWorker = (integrationClass, integrationFactory) => {
     class QueueWorker extends Worker {
-
-        integrationRepository = new IntegrationRepository();
-        moduleRepository = new ModuleRepository();
-        moduleFactory = new ModuleFactory({
-            moduleRepository: this.moduleRepository,
-            moduleDefinitions: getModulesDefinitionFromIntegrationClasses([integrationClass]),
-        });
-
         async _run(params, context) {
             try {
-                const getIntegrationInstanceByDefinition = new GetIntegrationInstanceByDefinition({
-                    integrationRepository: this.integrationRepository,
-                    moduleFactory: this.moduleFactory,
-                    moduleRepository: this.moduleRepository,
-                });
-
-                const integration = await getIntegrationInstanceByDefinition.execute(integrationClass);
-
-                const res = await integration.send(params.event, {
+                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 integrationFactory.getInstanceFromIntegrationId({
+                            integrationId: params.integrationId,
+                        });
+                    console.log(
+                        `${params.event} for ${instance.record.config.type} of integrationId: ${params.integrationId}`
+                    );
+                }
+                const res = await instance.send(params.event, {
                     data: params.data,
                     context,
                 });
@@ -78,6 +79,7 @@ const createQueueWorker = (integrationClass) => {
 };
 
 module.exports = {
+    ...backend,
     loadRouterFromObject,
     createQueueWorker,
 };

package/handlers/routers/auth.js

@@ -1,15 +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();
+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
+        `${process.env.FRONTEND_URI}/redirect/${
+            req.params.appId
         }?${new URLSearchParams(req.query)}`
     );
 });
 
 const handler = createAppHandler('HTTP Event: Auth', router);
 
-module.exports = { handler };
+module.exports = { handler, router };

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

@@ -1,18 +1,15 @@
 const { createAppHandler } = require('./../app-handler-helpers');
 const {
-    loadAppDefinition,
-} = require('../app-definition-loader');
+    integrationFactory,
+    loadRouterFromObject,
+} = require('./../backend-utils');
 const { Router } = require('express');
-const { loadRouterFromObject } = require('../backend-utils');
 
 const handlers = {};
-const { integrations: integrationClasses } = loadAppDefinition();
-
-//todo: this should be in a use case class
-for (const IntegrationClass of integrationClasses) {
+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) {

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

@@ -1,29 +1,10 @@
 const express = require('express');
 const { createAppHandler } = require('../app-handler-helpers');
 const { checkRequiredParams } = require('@friggframework/core');
-const { UserRepository } = require('../../user/user-repository');
-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 { User } = require('../backend-utils');
 const catchAsyncError = require('express-async-handler');
-const { loadAppDefinition } = require('../app-definition-loader');
 
 const router = express();
-const { userConfig } = loadAppDefinition();
-const userRepository = new UserRepository({ userConfig });
-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(
@@ -32,8 +13,8 @@ router.route('/user/login').post(
             'username',
             'password',
         ]);
-        const user = await loginUser.execute({ username, password });
-        const token = await createTokenForUserId.execute(user.getId(), 120);
+        const user = await User.loginUser({ username, password });
+        const token = await user.createUserToken(120);
         res.status(201);
         res.json({ token });
     })
@@ -45,12 +26,11 @@ router.route('/user/create').post(
             'username',
             'password',
         ]);
-
-        const user = await createIndividualUser.execute({
+        const user = await User.createIndividualUser({
             username,
             password,
         });
-        const token = await createTokenForUserId.execute(user.getId(), 120);
+        const token = await user.createUserToken(120);
         res.status(201);
         res.json({ token });
     })

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

@@ -1,12 +1,9 @@
 const { createHandler } = require('@friggframework/core');
-const { loadAppDefinition } = require('../app-definition-loader');
-const { createQueueWorker } = require('../backend-utils');
+const { integrationFactory, createQueueWorker } = require('../backend-utils');
 
 const handlers = {};
-const { integrations: integrationClasses } = loadAppDefinition();
-
-integrationClasses.forEach((IntegrationClass) => {
-    const defaultQueueWorker = createQueueWorker(IntegrationClass);
+integrationFactory.integrationClasses.forEach((IntegrationClass) => {
+    const defaultQueueWorker = createQueueWorker(IntegrationClass, integrationFactory);
 
     handlers[`${IntegrationClass.Definition.name}`] = {
         queueWorker: createHandler({

package/index.js

@@ -38,20 +38,27 @@ const {
     IntegrationModel,
     Options,
     IntegrationMapping,
+    IntegrationFactory,
+    IntegrationHelper,
     createIntegrationRouter,
     checkRequiredParams,
+    createFriggBackend,
 } = require('./integrations/index');
 const { TimeoutCatcher } = require('./lambda/index');
 const { debug, initDebugLog, flushDebugLog } = require('./logs/index');
 const {
     Credential,
+    EntityManager,
     Entity,
+    ModuleManager,
     ApiKeyRequester,
     BasicAuthRequester,
     OAuth2Requester,
     Requester,
     ModuleConstants,
-} = require('./modules/index');
+    ModuleFactory,
+    Auther,
+} = require('./module-plugin/index');
 const utils = require('./utils');
 
 // const {Sync } = require('./syncs/model');
@@ -102,8 +109,11 @@ module.exports = {
     IntegrationModel,
     Options,
     IntegrationMapping,
+    IntegrationFactory,
+    IntegrationHelper,
     checkRequiredParams,
     createIntegrationRouter,
+    createFriggBackend,
 
     // lambda
     TimeoutCatcher,
@@ -115,12 +125,17 @@ module.exports = {
 
     // module plugin
     Credential,
+    EntityManager,
     Entity,
+    ModuleManager,
     ApiKeyRequester,
     BasicAuthRequester,
     OAuth2Requester,
     Requester,
     ModuleConstants,
+    ModuleFactory,
+    Auther,
+
     // queues
     QueuerUtil,
 

package/integrations/create-frigg-backend.js

@@ -0,0 +1,31 @@
+const {IntegrationFactory, IntegrationHelper} = require('./integration-factory');
+const User = require('./integration-user');
+
+function createFriggBackend(appDefinition) {
+    const {integrations = [], user=null} = appDefinition
+    const integrationFactory = new IntegrationFactory(integrations);
+    if (user) {
+        if (user.usePassword) {
+            User.usePassword = true;
+        }
+        if (user.primary === 'organization') {
+            User.primary = User.OrganizationUser
+        }
+        if (user.individualUserRequired !== undefined) {
+            User.individualUserRequired = user.individualUserRequired
+        }
+        if (user.organizationUserRequired !== undefined) {
+            User.organizationUserRequired = user.organizationUserRequired
+        }
+
+    }
+    const backend = {
+        integrationFactory,
+        moduleFactory: integrationFactory.moduleFactory,
+        IntegrationHelper,
+        User: User
+    }
+    return backend
+}
+
+module.exports = { createFriggBackend }

package/integrations/index.js

@@ -2,13 +2,18 @@ const { IntegrationBase } = require('./integration-base');
 const { IntegrationModel } = require('./integration-model');
 const { Options } = require('./options');
 const { IntegrationMapping } = require('./integration-mapping');
+const { IntegrationFactory, IntegrationHelper } = require('./integration-factory');
 const { createIntegrationRouter, checkRequiredParams } = require('./integration-router');
+const { createFriggBackend } = require('./create-frigg-backend');
 
 module.exports = {
     IntegrationBase,
     IntegrationModel,
     Options,
     IntegrationMapping,
+    IntegrationFactory,
+    IntegrationHelper,
     createIntegrationRouter,
     checkRequiredParams,
+    createFriggBackend
 };