@friggframework/core 2.0.0--canary.405.1f6792c.0 → 2.0.0--canary.396.6862738.0

package/credential/credential-repository.js

@@ -0,0 +1,9 @@
+const { Credential } = require('../module-plugin');
+
+class CredentialRepository {
+    async findCredentialById(id) {
+        return Credential.findById(id);
+    }
+}
+
+module.exports = { CredentialRepository };

package/credential/use-cases/get-credential-for-user.js

@@ -0,0 +1,21 @@
+class GetCredentialForUser {
+    constructor({ credentialRepository }) {
+        this.credentialRepository = credentialRepository;
+    }
+
+    async execute(credentialId, userId) {
+        const credential = await this.credentialRepository.findCredentialById(credentialId);
+
+        if (!credential) {
+            throw new Error(`Credential with id ${credentialId} not found`);
+        }
+
+        if (credential.user.toString() !== userId.toString()) {
+            throw new Error(`Credential ${credentialId} does not belong to user ${userId}`);
+        }
+
+        return credential;
+    }
+}
+
+module.exports = { GetCredentialForUser };

package/encrypt/encrypt.js

@@ -17,6 +17,7 @@ const findOneEvents = [
 const shouldBypassEncryption = (STAGE) => {
     const defaultBypassStages = ['dev', 'test', 'local'];
     const bypassStageEnv = process.env.BYPASS_ENCRYPTION_STAGE;
+    // If the env is set to anything or an empty string, use the env. Otherwise, use the default array
     const useEnv = !String(bypassStageEnv) || !!bypassStageEnv;
     const bypassStages = useEnv
         ? bypassStageEnv.split(',').map((stage) => stage.trim())
@@ -24,15 +25,19 @@ const shouldBypassEncryption = (STAGE) => {
     return bypassStages.includes(STAGE);
 };
 
-function Encrypt(schema) {
+// The Mongoose plug-in function
+function Encrypt(schema, options) {
     const { STAGE, KMS_KEY_ARN, AES_KEY_ID } = process.env;
 
     if (shouldBypassEncryption(STAGE)) {
         return;
     }
 
-    const hasAES = AES_KEY_ID && AES_KEY_ID.trim() !== '';
-    const hasKMS = KMS_KEY_ARN && KMS_KEY_ARN.trim() !== '' && !hasAES;
+    if (KMS_KEY_ARN && AES_KEY_ID) {
+        throw new Error(
+            'Local and AWS encryption keys are both set in the environment.'
+        );
+    }
 
     const fields = Object.values(schema.paths)
         .map(({ path, options }) => (options.lhEncrypt === true ? path : ''))
@@ -43,17 +48,25 @@ function Encrypt(schema) {
     }
 
     const cryptor = new Cryptor({
-        shouldUseAws: hasKMS,
+        // Use AWS if the CMK is present
+        shouldUseAws: !!KMS_KEY_ARN,
+        // Find all the fields in the schema with lhEncrypt === true
         fields: fields,
     });
 
+    // ---------------------------------------------
+    // ### Encrypt fields before save/update/insert.
+    // ---------------------------------------------
+
     schema.pre('save', async function encryptionPreSave() {
+        // `this` will be a doc
         await cryptor.encryptFieldsInDocuments([this]);
     });
 
     schema.pre(
         'insertMany',
         async function encryptionPreInsertMany(_, docs, options) {
+            // `this` will be the model
             if (options?.rawResult) {
                 throw new Error(
                     'Raw result not supported for insertMany with Encrypt plugin'
@@ -65,14 +78,17 @@ function Encrypt(schema) {
     );
 
     schema.pre(updateOneEvents, async function encryptionPreUpdateOne() {
+        // `this` will be a query
         await cryptor.encryptFieldsInQuery(this);
     });
 
     schema.pre('updateMany', async function encryptionPreUpdateMany() {
+        // `this` will be a query
         cryptor.expectNotToUpdateManyEncrypted(this.getUpdate());
     });
 
     schema.pre('update', async function encryptionPreUpdate() {
+        // `this` will be a query
         const { multiple } = this.getOptions();
 
         if (multiple) {
@@ -83,11 +99,16 @@ function Encrypt(schema) {
         await cryptor.encryptFieldsInQuery(this);
     });
 
+    // --------------------------------------------
+    // ### Decrypt documents after they are loaded.
+    // --------------------------------------------
     schema.post('save', async function encryptionPreSave() {
+        // `this` will be a doc
         await cryptor.decryptFieldsInDocuments([this]);
     });
 
     schema.post(findOneEvents, async function encryptionPostFindOne(doc) {
+        // `this` will be a query
         const { rawResult } = this.getOptions();
 
         if (rawResult) {
@@ -98,10 +119,12 @@ function Encrypt(schema) {
     });
 
     schema.post('find', async function encryptionPostFind(docs) {
+        // `this` will be a query
         await cryptor.decryptFieldsInDocuments(docs);
     });
 
     schema.post('insertMany', async function encryptionPostInsertMany(docs) {
+        // `this` will be the model
         await cryptor.decryptFieldsInDocuments(docs);
     });
 }

package/handlers/app-definition-loader.js

@@ -0,0 +1,38 @@
+const { findNearestBackendPackageJson } = require('@friggframework/core/utils');
+const path = require('node:path');
+const fs = require('fs-extra');
+
+/**
+ * Loads the App definition from the nearest backend package
+ * @function loadAppDefinition
+ * @description Searches for the nearest backend package.json, loads the corresponding index.js file,
+ * and extracts the application definition containing integrations and user configuration.
+ * @returns {{integrations: Array<object>, userConfig: object | null}} An object containing the application definition.
+ * @throws {Error} Throws error if backend package.json cannot be found.
+ * @throws {Error} Throws error if index.js file cannot be found in the backend directory.
+ * @example
+ * const { integrations, userConfig } = loadAppDefinition();
+ * console.log(`Found ${integrations.length} integrations`);
+ */
+function loadAppDefinition() {
+    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 appDefinition = backendJsFile.Definition;
+
+    const { integrations = [], user: userConfig = null } = appDefinition;
+    return { integrations, userConfig };
+}
+
+module.exports = {
+    loadAppDefinition,
+}; 

package/handlers/app-handler-helpers.js

@@ -3,7 +3,6 @@ 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) => {
@@ -20,8 +19,6 @@ 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,24 +1,10 @@
-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 appDefinition = backendJsFile.Definition;
+const { Worker } = require('@friggframework/core');
+const { loadAppDefinition } = require('./app-definition-loader');
+const { IntegrationRepository } = require('../integrations/integration-repository');
+const { ModuleService } = require('../module-plugin/module-service');
+const { GetIntegrationInstance } = require('../integrations/use-cases/get-integration-instance');
 
-const backend = createFriggBackend(appDefinition);
 const loadRouterFromObject = (IntegrationClass, routerObject) => {
     const router = Router();
     const { path, method, event } = routerObject;
@@ -27,10 +13,10 @@ const loadRouterFromObject = (IntegrationClass, routerObject) => {
     );
     router[method.toLowerCase()](path, async (req, res, next) => {
         try {
-            const integration = new IntegrationClass({});
+            const integration = new IntegrationClass();
             await integration.loadModules();
             await integration.registerEventHandlers();
-            const result = await integration.send(event, {req, res, next});
+            const result = await integration.send(event, { req, res, next });
             res.json(result);
         } catch (error) {
             next(error);
@@ -39,29 +25,39 @@ const loadRouterFromObject = (IntegrationClass, routerObject) => {
 
     return router;
 };
-const createQueueWorker = (integrationClass, integrationFactory) => {
+
+//todo: this should be in a use case class
+const createQueueWorker = (integrationClass) => {
     class QueueWorker extends Worker {
         async _run(params, context) {
             try {
-                let instance;
+                let integrationInstance;
                 if (!params.integrationId) {
-                    instance = new integrationClass({});
-                    await instance.loadModules();
-                    // await instance.loadUserActions();
-                    await instance.registerEventHandlers();
+                    integrationInstance = new integrationClass();
+                    await integrationInstance.loadModules();
+                    await integrationInstance.registerEventHandlers();
                     console.log(
                         `${params.event} for ${integrationClass.Definition.name} integration with no integrationId`
                     );
                 } else {
-                    instance =
-                        await integrationFactory.getInstanceFromIntegrationId({
-                            integrationId: params.integrationId,
-                        });
+                    const { integrations: integrationClasses } = loadAppDefinition();
+                    const integrationRepository = new IntegrationRepository();
+                    const moduleService = new ModuleService();
+
+                    const getIntegrationInstance = new GetIntegrationInstance({
+                        integrationRepository,
+                        integrationClasses,
+                        moduleService,
+                    });
+
+                    // todo: are we going to have the userId available here?
+                    integrationInstance = await getIntegrationInstance.execute(params.integrationId, params.userId);
                     console.log(
-                        `${params.event} for ${instance.record.config.type} of integrationId: ${params.integrationId}`
+                        `${params.event} for ${integrationInstance.record.config.type} of integrationId: ${params.integrationId}`
                     );
                 }
-                const res = await instance.send(params.event, {
+
+                const res = await integrationInstance.send(params.event, {
                     data: params.data,
                     context,
                 });
@@ -79,7 +75,6 @@ const createQueueWorker = (integrationClass, integrationFactory) => {
 };
 
 module.exports = {
-    ...backend,
     loadRouterFromObject,
     createQueueWorker,
 };

package/handlers/routers/auth.js

@@ -1,26 +1,29 @@
 const { createIntegrationRouter } = require('@friggframework/core');
 const { createAppHandler } = require('./../app-handler-helpers');
-const { requireLoggedInUser } = require('./middleware/requireLoggedInUser');
 const {
-    moduleFactory,
-    integrationFactory,
-    IntegrationHelper,
-} = require('./../backend-utils');
+    loadAppDefinition,
+} = require('../app-definition-loader');
+const { UserRepository } = require('../../user/user-repository');
+const { GetUserFromBearerToken } = require('../../user/use-cases/get-user-from-bearer-token');
+
+const { userConfig } = loadAppDefinition();
+const userRepository = new UserRepository({ userConfig });
+const getUserFromBearerToken = new GetUserFromBearerToken({
+    userRepository,
+    userConfig,
+});
 
 const router = createIntegrationRouter({
-    factory: { moduleFactory, integrationFactory, IntegrationHelper },
-    requireLoggedInUser,
-    getUserId: (req) => req.user.getUserId(),
+    getUserFromBearerToken,
 });
 
 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, router };
+module.exports = { handler };

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

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

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

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

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

package/index.js

@@ -38,17 +38,13 @@ 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,
@@ -57,7 +53,6 @@ const {
     Requester,
     ModuleConstants,
     ModuleFactory,
-    Auther,
 } = require('./module-plugin/index');
 const utils = require('./utils');
 
@@ -109,11 +104,8 @@ module.exports = {
     IntegrationModel,
     Options,
     IntegrationMapping,
-    IntegrationFactory,
-    IntegrationHelper,
     checkRequiredParams,
     createIntegrationRouter,
-    createFriggBackend,
 
     // lambda
     TimeoutCatcher,
@@ -125,7 +117,6 @@ module.exports = {
 
     // module plugin
     Credential,
-    EntityManager,
     Entity,
     ModuleManager,
     ApiKeyRequester,
@@ -134,8 +125,6 @@ module.exports = {
     Requester,
     ModuleConstants,
     ModuleFactory,
-    Auther,
-
     // queues
     QueuerUtil,
 

package/integrations/index.js

@@ -2,18 +2,13 @@ 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
 };

package/integrations/integration-base.js

@@ -1,5 +1,6 @@
 const { IntegrationMapping } = require('./integration-mapping');
 const { Options } = require('./options');
+
 const constantsToBeMigrated = {
     defaultEvents: {
         ON_CREATE: 'ON_CREATE',
@@ -19,6 +20,7 @@ const constantsToBeMigrated = {
 };
 
 class IntegrationBase {
+
     static getOptionDetails() {
         const options = new Options({
             module: Object.values(this.Definition.modules)[0], // This is a placeholder until we revamp the frontend
@@ -26,6 +28,7 @@ class IntegrationBase {
         });
         return options.get();
     }
+
     /**
      * CHILDREN SHOULD SPECIFY A DEFINITION FOR THE INTEGRATION
      */
@@ -57,7 +60,7 @@ class IntegrationBase {
             const { definition } =
                 this.constructor.Definition.modules[moduleName];
             if (typeof definition.API === 'function') {
-                this[moduleName] = { api: new definition.API() };
+                this[moduleName] = { api: new definition.API({}) };
             } else {
                 throw new Error(
                     `Module ${moduleName} must be a function that extends IntegrationModule`
@@ -197,9 +200,9 @@ class IntegrationBase {
         return this.record;
     }
 
-    async onUpdate(params) {}
+    async onUpdate(params) { }
 
-    async onDelete(params) {}
+    async onDelete(params) { }
 
     async getConfigOptions() {
         const options = {
@@ -236,10 +239,10 @@ class IntegrationBase {
         const dynamicUserActions = await this.loadDynamicUserActions();
         const filteredDynamicActions = actionType
             ? Object.fromEntries(
-                  Object.entries(dynamicUserActions).filter(
-                      ([_, event]) => event.userActionType === actionType
-                  )
-              )
+                Object.entries(dynamicUserActions).filter(
+                    ([_, event]) => event.userActionType === actionType
+                )
+            )
             : dynamicUserActions;
         return { ...userActions, ...filteredDynamicActions };
     }

package/integrations/integration-repository.js

@@ -0,0 +1,44 @@
+const { IntegrationModel } = require('./integration-model');
+
+class IntegrationRepository {
+    async findIntegrationsByUserId(userId) {
+        const integrationRecords = await IntegrationModel.find({ user: userId }, '', { lean: true }).populate('entities');
+        return integrationRecords.map(integrationRecord => ({
+            id: integrationRecord._id,
+            entitiesIds: integrationRecord.entities.map(e => e._id),
+            userId: integrationRecord.user.toString(),
+            config: integrationRecord.config,
+            version: integrationRecord.version,
+            status: integrationRecord.status,
+            messages: integrationRecord.messages,
+        }));
+    }
+
+    async deleteIntegrationById(integrationId) {
+        return IntegrationModel.deleteOne({ _id: integrationId });
+    }
+
+    async findIntegrationById(id) {
+        const integrationRecord = await IntegrationModel.findById(id, '', { lean: true }).populate('entities');
+        return {
+            id: integrationRecord._id,
+            entitiesIds: integrationRecord.entities.map(e => e._id),
+            userId: integrationRecord.user.toString(),
+            config: integrationRecord.config,
+            version: integrationRecord.version,
+            status: integrationRecord.status,
+            messages: integrationRecord.messages,
+        }
+    }
+
+    async createIntegration(entities, userId, config) {
+        return IntegrationModel.create({
+            entities: entities,
+            user: userId,
+            config,
+            version: '0.0.0',
+        });
+    }
+}
+
+module.exports = { IntegrationRepository };