@friggframework/core 2.0.0--canary.396.6862738.0 → 2.0.0--canary.397.c07f148.0

package/core/create-handler.js

@@ -34,6 +34,7 @@ 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/credential/credential-repository.js

@@ -1,9 +1,56 @@
-const { Credential } = require('../module-plugin');
+const { Credential } = require('../modules');
 
 class CredentialRepository {
     async findCredentialById(id) {
         return Credential.findById(id);
     }
+
+    async updateAuthenticationStatus(credentialId, authIsValid) {
+        return Credential.updateOne({ _id: credentialId }, { $set: { auth_is_valid: authIsValid } });
+    }
+
+    /**
+     * Permanently remove a credential document.
+     * @param {string} credentialId
+     * @returns {Promise<import('mongoose').DeleteResult>}
+     */
+    async deleteCredentialById(credentialId) {
+        return Credential.deleteOne({ _id: credentialId });
+    }
+
+    /**
+     * Create a new credential or update an existing one matching the identifiers.
+     * `credentialDetails` format: { identifiers: { ... }, details: { ... } }
+     * Identifiers are used in the query filter; details are merged into the document.
+     * @param {{identifiers: Object, details: Object}} credentialDetails
+     * @returns {Promise<Object>} The persisted credential (lean object)
+     */
+    async upsertCredential(credentialDetails) {
+        const { identifiers, details } = credentialDetails;
+        if (!identifiers) throw new Error('identifiers required to upsert credential');
+
+        const query = { ...identifiers };
+
+        const update = { $set: { ...details } };
+
+        const options = {
+            upsert: true,
+            new: true,
+            setDefaultsOnInsert: true,
+            lean: true,
+            strict: false,
+        };
+
+        const credential = await Credential.findOneAndUpdate(query, update, options);
+        return {
+            id: credential._id.toString(),
+            externalId: credential.externalId,
+            userId: credential.user.toString(),
+            auth_is_valid: credential.auth_is_valid,
+            access_token: credential.access_token,
+            refresh_token: credential.refresh_token,
+        }
+    }
 }
 
 module.exports = { CredentialRepository };

package/credential/use-cases/update-authentication-status.js

@@ -0,0 +1,15 @@
+class UpdateAuthenticationStatus {
+    constructor({ credentialRepository }) {
+        this.credentialRepository = credentialRepository;
+    }
+
+    /**
+     * @param {string} credentialId
+     * @param {boolean} authIsValid
+     */
+    async execute(credentialId, authIsValid) {
+        await this.credentialRepository.updateAuthenticationStatus(credentialId, authIsValid);
+    }
+}
+
+module.exports = { UpdateAuthenticationStatus };

package/handlers/backend-utils.js

@@ -1,21 +1,34 @@
 const { Router } = require('express');
 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 { 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 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 integration = new IntegrationClass();
-            await integration.loadModules();
-            await integration.registerEventHandlers();
+            const getIntegrationInstanceByDefinition = new GetIntegrationInstanceByDefinition({
+                integrationRepository,
+                moduleFactory,
+                moduleRepository,
+            });
+            const integration = await getIntegrationInstanceByDefinition.execute(IntegrationClass);
             const result = await integration.send(event, { req, res, next });
             res.json(result);
         } catch (error) {
@@ -29,35 +42,25 @@ const loadRouterFromObject = (IntegrationClass, routerObject) => {
 //todo: this should be in a use case class
 const createQueueWorker = (integrationClass) => {
     class QueueWorker extends Worker {
+
+        integrationRepository = new IntegrationRepository();
+        moduleRepository = new ModuleRepository();
+        moduleFactory = new ModuleFactory({
+            moduleRepository: this.moduleRepository,
+            moduleDefinitions: getModulesDefinitionFromIntegrationClasses([integrationClass]),
+        });
+
         async _run(params, context) {
             try {
-                let integrationInstance;
-                if (!params.integrationId) {
-                    integrationInstance = new integrationClass();
-                    await integrationInstance.loadModules();
-                    await integrationInstance.registerEventHandlers();
-                    console.log(
-                        `${params.event} for ${integrationClass.Definition.name} integration with no integrationId`
-                    );
-                } else {
-                    const { integrations: integrationClasses } = loadAppDefinition();
-                    const integrationRepository = new IntegrationRepository();
-                    const moduleService = new ModuleService();
-
-                    const getIntegrationInstance = new GetIntegrationInstance({
-                        integrationRepository,
-                        integrationClasses,
-                        moduleService,
-                    });
+                const getIntegrationInstanceByDefinition = new GetIntegrationInstanceByDefinition({
+                    integrationRepository: this.integrationRepository,
+                    moduleFactory: this.moduleFactory,
+                    moduleRepository: this.moduleRepository,
+                });
 
-                    // todo: are we going to have the userId available here?
-                    integrationInstance = await getIntegrationInstance.execute(params.integrationId, params.userId);
-                    console.log(
-                        `${params.event} for ${integrationInstance.record.config.type} of integrationId: ${params.integrationId}`
-                    );
-                }
+                const integration = await getIntegrationInstanceByDefinition.execute(integrationClass);
 
-                const res = await integrationInstance.send(params.event, {
+                const res = await integration.send(params.event, {
                     data: params.data,
                     context,
                 });

package/handlers/routers/auth.js

@@ -1,21 +1,7 @@
 const { createIntegrationRouter } = require('@friggframework/core');
 const { createAppHandler } = require('./../app-handler-helpers');
-const {
-    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({
-    getUserFromBearerToken,
-});
+const router = createIntegrationRouter();
 
 router.route('/redirect/:appId').get((req, res) => {
     res.redirect(

package/index.js

@@ -46,14 +46,12 @@ const { debug, initDebugLog, flushDebugLog } = require('./logs/index');
 const {
     Credential,
     Entity,
-    ModuleManager,
     ApiKeyRequester,
     BasicAuthRequester,
     OAuth2Requester,
     Requester,
     ModuleConstants,
-    ModuleFactory,
-} = require('./module-plugin/index');
+} = require('./modules/index');
 const utils = require('./utils');
 
 // const {Sync } = require('./syncs/model');
@@ -118,13 +116,11 @@ module.exports = {
     // module plugin
     Credential,
     Entity,
-    ModuleManager,
     ApiKeyRequester,
     BasicAuthRequester,
     OAuth2Requester,
     Requester,
     ModuleConstants,
-    ModuleFactory,
     // queues
     QueuerUtil,
 

package/integrations/integration-base.js

@@ -1,5 +1,8 @@
 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: {
@@ -21,6 +24,11 @@ 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
@@ -53,21 +61,7 @@ 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,
@@ -75,7 +69,31 @@ class IntegrationBase {
         };
     }
 
-    constructor(params) {
+    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 || {};
+
         this.defaultEvents = {
             [constantsToBeMigrated.defaultEvents.ON_CREATE]: {
                 type: constantsToBeMigrated.types.LIFE_CYCLE_EVENT,
@@ -110,7 +128,6 @@ class IntegrationBase {
                 handler: this.refreshActionOptions,
             },
         };
-        this.loadModules();
     }
 
     async send(event, object) {
@@ -124,7 +141,7 @@ class IntegrationBase {
 
     async validateConfig() {
         const configOptions = await this.getConfigOptions();
-        const currentConfig = this.record.config;
+        const currentConfig = this.getConfig();
         let needsConfig = false;
         for (const option of configOptions) {
             if (option.required) {
@@ -136,56 +153,59 @@ class IntegrationBase {
                     )
                 ) {
                     needsConfig = true;
-                    this.record.messages.warnings.push({
-                        title: 'Config Validation Error',
-                        message: `Missing required field of ${option.label}`,
-                        timestamp: Date.now(),
-                    });
+                    await this.updateIntegrationMessages.execute(
+                        this.id,
+                        'warnings',
+                        'Config Validation Error',
+                        `Missing required field of ${option.label}`,
+                        Date.now()
+                    );
                 }
             }
         }
         if (needsConfig) {
-            this.record.status = 'NEEDS_CONFIG';
-            await this.record.save();
+            await this.updateIntegrationStatus.execute(this.id, 'NEEDS_CONFIG');
         }
     }
 
     async testAuth() {
         let didAuthPass = true;
 
-        for (const module of Object.keys(IntegrationBase.Definition.modules)) {
+        for (const module of Object.keys(this.constructor.Definition.modules)) {
             try {
                 await this[module].testAuth();
             } catch {
                 didAuthPass = false;
-                this.record.messages.errors.push({
-                    title: 'Authentication Error',
-                    message: `There was an error with your ${this[
+                await this.updateIntegrationMessages.execute(
+                    this.id,
+                    'errors',
+                    'Authentication Error',
+                    `There was an error with your ${this[
                         module
                     ].constructor.getName()} Entity.
                 Please reconnect/re-authenticate, or reach out to Support for assistance.`,
-                    timestamp: Date.now(),
-                });
+                    Date.now()
+                );
             }
         }
 
         if (!didAuthPass) {
-            this.record.status = 'ERROR';
-            this.record.markModified('messages.error');
-            await this.record.save();
+            await this.updateIntegrationStatus.execute(this.id, 'ERROR');
         }
     }
 
     async getMapping(sourceId) {
-        return IntegrationMapping.findBy(this.record.id, sourceId);
+        // todo: this should be a use case
+        return IntegrationMapping.findBy(this.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.record.id,
+            this.id,
             sourceId,
             mapping
         );
@@ -194,10 +214,8 @@ class IntegrationBase {
     /**
      * CHILDREN CAN OVERRIDE THESE CONFIGURATION METHODS
      */
-    async onCreate(params) {
-        this.record.status = 'ENABLED';
-        await this.record.save();
-        return this.record;
+    async onCreate({ integrationId }) {
+        await this.updateIntegrationStatus.execute(integrationId, 'ENABLED');
     }
 
     async onUpdate(params) { }
@@ -262,6 +280,81 @@ 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 };

package/integrations/integration-repository.js

@@ -4,7 +4,7 @@ class IntegrationRepository {
     async findIntegrationsByUserId(userId) {
         const integrationRecords = await IntegrationModel.find({ user: userId }, '', { lean: true }).populate('entities');
         return integrationRecords.map(integrationRecord => ({
-            id: integrationRecord._id,
+            id: integrationRecord._id.toString(),
             entitiesIds: integrationRecord.entities.map(e => e._id),
             userId: integrationRecord.user.toString(),
             config: integrationRecord.config,
@@ -18,10 +18,23 @@ class IntegrationRepository {
         return IntegrationModel.deleteOne({ _id: integrationId });
     }
 
+    async findIntegrationByName(name) {
+        const integrationRecord = await IntegrationModel.findOne({ 'config.type': name }, '', { lean: true }).populate('entities');
+        return {
+            id: integrationRecord._id.toString(),
+            entitiesIds: integrationRecord.entities.map(e => e._id),
+            userId: integrationRecord.user.toString(),
+            config: integrationRecord.config,
+            version: integrationRecord.version,
+            status: integrationRecord.status,
+            messages: integrationRecord.messages,
+        };
+    }
+
     async findIntegrationById(id) {
         const integrationRecord = await IntegrationModel.findById(id, '', { lean: true }).populate('entities');
         return {
-            id: integrationRecord._id,
+            id: integrationRecord._id.toString(),
             entitiesIds: integrationRecord.entities.map(e => e._id),
             userId: integrationRecord.user.toString(),
             config: integrationRecord.config,
@@ -31,13 +44,36 @@ class IntegrationRepository {
         }
     }
 
+    async updateIntegrationStatus(integrationId, status) {
+        const integrationRecord = await IntegrationModel.updateOne({ _id: integrationId }, { status });
+        return integrationRecord.acknowledged;
+    }
+
+    async updateIntegrationMessages(integrationId, messageType, messageTitle, messageBody, messageTimestamp) {
+        const integrationRecord = await IntegrationModel.updateOne(
+            { _id: integrationId },
+            { $push: { [`messages.${messageType}`]: { title: messageTitle, message: messageBody, timestamp: messageTimestamp } } }
+        );
+        return integrationRecord.acknowledged;
+    }
+
     async createIntegration(entities, userId, config) {
-        return IntegrationModel.create({
+        const integrationRecord = await IntegrationModel.create({
             entities: entities,
             user: userId,
             config,
             version: '0.0.0',
         });
+
+        return {
+            id: integrationRecord._id.toString(),
+            entitiesIds: integrationRecord.entities.map(e => e._id),
+            userId: integrationRecord.user.toString(),
+            config: integrationRecord.config,
+            version: integrationRecord.version,
+            status: integrationRecord.status,
+            messages: integrationRecord.messages,
+        };
     }
 }