@friggframework/core 2.0.0--canary.397.fe6d7a2.0 → 2.0.0--canary.405.91dae19.0

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

package/integrations/integration-base.js

@@ -1,9 +1,5 @@
 const { IntegrationMapping } = require('./integration-mapping');
 const { Options } = require('./options');
-const { UpdateIntegrationStatus } = require('./use-cases/update-integration-status');
-const { IntegrationRepository } = require('./integration-repository');
-const { UpdateIntegrationMessages } = require('./use-cases/update-integration-messages');
-
 const constantsToBeMigrated = {
     defaultEvents: {
         ON_CREATE: 'ON_CREATE',
@@ -23,12 +19,6 @@ const constantsToBeMigrated = {
 };
 
 class IntegrationBase {
-
-    // todo: maybe we can pass this as Dependency Injection in the sub-class constructor
-    integrationRepository = new IntegrationRepository();
-    updateIntegrationStatus = new UpdateIntegrationStatus({ integrationRepository: this.integrationRepository });
-    updateIntegrationMessages = new UpdateIntegrationMessages({ integrationRepository: this.integrationRepository });
-
     static getOptionDetails() {
         const options = new Options({
             module: Object.values(this.Definition.modules)[0], // This is a placeholder until we revamp the frontend
@@ -36,7 +26,6 @@ class IntegrationBase {
         });
         return options.get();
     }
-
     /**
      * CHILDREN SHOULD SPECIFY A DEFINITION FOR THE INTEGRATION
      */
@@ -61,7 +50,21 @@ class IntegrationBase {
     static getCurrentVersion() {
         return this.Definition.version;
     }
-
+    loadModules() {
+        // Load all the modules defined in Definition.modules
+        const moduleNames = Object.keys(this.constructor.Definition.modules);
+        for (const moduleName of moduleNames) {
+            const { definition } =
+                this.constructor.Definition.modules[moduleName];
+            if (typeof definition.API === 'function') {
+                this[moduleName] = { api: new definition.API() };
+            } else {
+                throw new Error(
+                    `Module ${moduleName} must be a function that extends IntegrationModule`
+                );
+            }
+        }
+    }
     registerEventHandlers() {
         this.on = {
             ...this.defaultEvents,
@@ -69,31 +72,7 @@ class IntegrationBase {
         };
     }
 
-    constructor(params = {}) {
-        // Data from database record (when instantiated by use cases)
-        this.id = params.id;
-        this.userId = params.userId || params.integrationId; // fallback for legacy
-        this.entities = params.entities;
-        this.config = params.config;
-        this.status = params.status;
-        this.version = params.version;
-        this.messages = params.messages || { errors: [], warnings: [] };
-        
-        // Module instances (injected by factory)
-        this.modules = {};
-        if (params.modules) {
-            for (const mod of params.modules) {
-                const key = typeof mod.getName === 'function' ? mod.getName() : mod.name;
-                if (key) {
-                    this.modules[key] = mod;
-                    this[key] = mod; // Direct access (e.g., this.hubspot)
-                }
-            }
-        }
-
-        // Initialize events object (will be populated by child classes)
-        this.events = this.events || {};
-
+    constructor(params) {
         this.defaultEvents = {
             [constantsToBeMigrated.defaultEvents.ON_CREATE]: {
                 type: constantsToBeMigrated.types.LIFE_CYCLE_EVENT,
@@ -128,6 +107,7 @@ class IntegrationBase {
                 handler: this.refreshActionOptions,
             },
         };
+        this.loadModules();
     }
 
     async send(event, object) {
@@ -141,7 +121,7 @@ class IntegrationBase {
 
     async validateConfig() {
         const configOptions = await this.getConfigOptions();
-        const currentConfig = this.getConfig();
+        const currentConfig = this.record.config;
         let needsConfig = false;
         for (const option of configOptions) {
             if (option.required) {
@@ -153,59 +133,56 @@ class IntegrationBase {
                     )
                 ) {
                     needsConfig = true;
-                    await this.updateIntegrationMessages.execute(
-                        this.id,
-                        'warnings',
-                        'Config Validation Error',
-                        `Missing required field of ${option.label}`,
-                        Date.now()
-                    );
+                    this.record.messages.warnings.push({
+                        title: 'Config Validation Error',
+                        message: `Missing required field of ${option.label}`,
+                        timestamp: Date.now(),
+                    });
                 }
             }
         }
         if (needsConfig) {
-            await this.updateIntegrationStatus.execute(this.id, 'NEEDS_CONFIG');
+            this.record.status = 'NEEDS_CONFIG';
+            await this.record.save();
         }
     }
 
     async testAuth() {
         let didAuthPass = true;
 
-        for (const module of Object.keys(this.constructor.Definition.modules)) {
+        for (const module of Object.keys(IntegrationBase.Definition.modules)) {
             try {
                 await this[module].testAuth();
             } catch {
                 didAuthPass = false;
-                await this.updateIntegrationMessages.execute(
-                    this.id,
-                    'errors',
-                    'Authentication Error',
-                    `There was an error with your ${this[
+                this.record.messages.errors.push({
+                    title: 'Authentication Error',
+                    message: `There was an error with your ${this[
                         module
                     ].constructor.getName()} Entity.
                 Please reconnect/re-authenticate, or reach out to Support for assistance.`,
-                    Date.now()
-                );
+                    timestamp: Date.now(),
+                });
             }
         }
 
         if (!didAuthPass) {
-            await this.updateIntegrationStatus.execute(this.id, 'ERROR');
+            this.record.status = 'ERROR';
+            this.record.markModified('messages.error');
+            await this.record.save();
         }
     }
 
     async getMapping(sourceId) {
-        // todo: this should be a use case
-        return IntegrationMapping.findBy(this.id, sourceId);
+        return IntegrationMapping.findBy(this.record.id, sourceId);
     }
 
     async upsertMapping(sourceId, mapping) {
         if (!sourceId) {
             throw new Error(`sourceId must be set`);
         }
-        // todo: this should be a use case
         return await IntegrationMapping.upsert(
-            this.id,
+            this.record.id,
             sourceId,
             mapping
         );
@@ -214,13 +191,15 @@ class IntegrationBase {
     /**
      * CHILDREN CAN OVERRIDE THESE CONFIGURATION METHODS
      */
-    async onCreate({ integrationId }) {
-        await this.updateIntegrationStatus.execute(integrationId, 'ENABLED');
+    async onCreate(params) {
+        this.record.status = 'ENABLED';
+        await this.record.save();
+        return this.record;
     }
 
-    async onUpdate(params) { }
+    async onUpdate(params) {}
 
-    async onDelete(params) { }
+    async onDelete(params) {}
 
     async getConfigOptions() {
         const options = {
@@ -257,10 +236,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 };
     }
@@ -280,81 +259,6 @@ class IntegrationBase {
         };
         return options;
     }
-
-    // === Domain Methods (moved from Integration.js) ===
-    
-    getConfig() {
-        return this.config;
-    }
-
-    getModule(key) {
-        return this.modules[key];
-    }
-
-    setModule(key, module) {
-        this.modules[key] = module;
-        this[key] = module;
-    }
-
-    addError(error) {
-        if (!this.messages.errors) {
-            this.messages.errors = [];
-        }
-        this.messages.errors.push(error);
-        this.status = 'ERROR';
-    }
-
-    addWarning(warning) {
-        if (!this.messages.warnings) {
-            this.messages.warnings = [];
-        }
-        this.messages.warnings.push(warning);
-    }
-
-    isActive() {
-        return this.status === 'ENABLED' || this.status === 'ACTIVE';
-    }
-
-    needsConfiguration() {
-        return this.status === 'NEEDS_CONFIG';
-    }
-
-    hasErrors() {
-        return this.status === 'ERROR';
-    }
-
-    belongsToUser(userId) {
-        return this.userId.toString() === userId.toString();
-    }
-
-    async initialize() {
-        // Load dynamic user actions
-        try {
-            const additionalUserActions = await this.loadDynamicUserActions();
-            this.events = { ...this.events, ...additionalUserActions };
-        } catch (e) {
-            this.addError(e);
-        }
-
-        // Register event handlers
-        await this.registerEventHandlers();
-    }
-
-    getOptionDetails() {
-        const options = new Options({
-            module: Object.values(this.constructor.Definition.modules)[0],
-            ...this.constructor.Definition,
-        });
-        return options.get();
-    }
-
-    // Legacy method for backward compatibility
-    async loadModules() {
-        // This method was used in the old architecture for loading modules
-        // In the new architecture, modules are injected via constructor
-        // For backward compatibility, this is a no-op
-        return;
-    }
 }
 
 module.exports = { IntegrationBase };