@friggframework/core 2.0.0-next.40 → 2.0.0-next.42

package/handlers/routers/websocket.js

@@ -1,5 +1,7 @@
 const { createHandler } = require('@friggframework/core');
-const { WebsocketConnection } = require('@friggframework/core');
+const { createWebsocketConnectionRepository } = require('../../database/websocket-connection-repository-factory');
+
+const websocketConnectionRepository = createWebsocketConnectionRepository();
 
 const handleWebSocketConnection = async (event, context) => {
     // Handle different WebSocket events
@@ -8,7 +10,7 @@ const handleWebSocketConnection = async (event, context) => {
             // Handle new connection
             try {
                 const connectionId = event.requestContext.connectionId;
-                await WebsocketConnection.create({ connectionId });
+                await websocketConnectionRepository.createConnection(connectionId);
                 console.log(`Stored new connection: ${connectionId}`);
                 return { statusCode: 200, body: 'Connected.' };
             } catch (error) {
@@ -20,7 +22,7 @@ const handleWebSocketConnection = async (event, context) => {
             // Handle disconnection
             try {
                 const connectionId = event.requestContext.connectionId;
-                await WebsocketConnection.deleteOne({ connectionId });
+                await websocketConnectionRepository.deleteConnection(connectionId);
                 console.log(`Removed connection: ${connectionId}`);
                 return { statusCode: 200, body: 'Disconnected.' };
             } catch (error) {

package/handlers/use-cases/check-external-apis-health-use-case.js

@@ -0,0 +1,81 @@
+const https = require('https');
+const http = require('http');
+
+class CheckExternalApisHealthUseCase {
+    constructor({ apis = null } = {}) {
+        this.apis = apis || [
+            { name: 'github', url: 'https://api.github.com/status' },
+            { name: 'npm', url: 'https://registry.npmjs.org' },
+        ];
+    }
+
+    async execute() {
+        const results = await Promise.all(
+            this.apis.map((api) =>
+                this._checkExternalAPI(api.url).then((result) => ({
+                    name: api.name,
+                    ...result,
+                }))
+            )
+        );
+
+        const apiStatuses = {};
+        let allReachable = true;
+
+        results.forEach(({ name, ...checkResult }) => {
+            apiStatuses[name] = checkResult;
+            if (!checkResult.reachable) {
+                allReachable = false;
+            }
+        });
+
+        return { apiStatuses, allReachable };
+    }
+
+    _checkExternalAPI(url, timeout = 5000) {
+        return new Promise((resolve) => {
+            const protocol = url.startsWith('https:') ? https : http;
+            const startTime = Date.now();
+
+            try {
+                const request = protocol.get(url, { timeout }, (res) => {
+                    const responseTime = Date.now() - startTime;
+                    resolve({
+                        status: 'healthy',
+                        statusCode: res.statusCode,
+                        responseTime,
+                        reachable: res.statusCode < 500,
+                    });
+                });
+
+                request.on('error', (error) => {
+                    resolve({
+                        status: 'unhealthy',
+                        error: error.message,
+                        responseTime: Date.now() - startTime,
+                        reachable: false,
+                    });
+                });
+
+                request.on('timeout', () => {
+                    request.destroy();
+                    resolve({
+                        status: 'timeout',
+                        error: 'Request timeout',
+                        responseTime: timeout,
+                        reachable: false,
+                    });
+                });
+            } catch (error) {
+                resolve({
+                    status: 'error',
+                    error: error.message,
+                    responseTime: Date.now() - startTime,
+                    reachable: false,
+                });
+            }
+        });
+    }
+}
+
+module.exports = { CheckExternalApisHealthUseCase };

package/handlers/use-cases/check-integrations-health-use-case.js

@@ -0,0 +1,32 @@
+class CheckIntegrationsHealthUseCase {
+    constructor({ moduleFactory, integrationFactory }) {
+        this.moduleFactory = moduleFactory;
+        this.integrationFactory = integrationFactory;
+    }
+
+    execute() {
+        const moduleTypes = Array.isArray(this.moduleFactory.moduleTypes)
+            ? this.moduleFactory.moduleTypes
+            : [];
+
+        const integrationTypes = Array.isArray(
+            this.integrationFactory.integrationTypes
+        )
+            ? this.integrationFactory.integrationTypes
+            : [];
+
+        return {
+            status: 'healthy',
+            modules: {
+                count: moduleTypes.length,
+                available: moduleTypes,
+            },
+            integrations: {
+                count: integrationTypes.length,
+                available: integrationTypes,
+            },
+        };
+    }
+}
+
+module.exports = { CheckIntegrationsHealthUseCase };

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

@@ -24,8 +24,26 @@ const {
     Token,
     UserModel,
     WebsocketConnection,
+    prisma,
+    TokenRepository,
+    WebsocketConnectionRepository,
 } = require('./database/index');
-const { Encrypt, Cryptor } = require('./encrypt/encrypt');
+const {
+    createUserRepository,
+    UserRepositoryMongo,
+    UserRepositoryPostgres,
+} = require('./user/repositories/user-repository-factory');
+
+const {
+    CredentialRepository,
+} = require('./credential/repositories/credential-repository');
+const {
+    ModuleRepository,
+} = require('./modules/repositories/module-repository');
+const {
+    IntegrationMappingRepository,
+} = require('./integrations/repositories/integration-mapping-repository');
+const { Cryptor } = require('./encrypt');
 const {
     BaseError,
     FetchError,
@@ -35,30 +53,25 @@ const {
 } = require('./errors/index');
 const {
     IntegrationBase,
-    IntegrationModel,
     Options,
-    IntegrationMapping,
-    IntegrationFactory,
-    IntegrationHelper,
     createIntegrationRouter,
     checkRequiredParams,
-    createFriggBackend,
+    getModulesDefinitionFromIntegrationClasses,
+    LoadIntegrationContextUseCase,
 } = 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,
     ModuleFactory,
-    Auther,
-} = require('./module-plugin/index');
+} = require('./modules/index');
+const application = require('./application');
 const utils = require('./utils');
 
 // const {Sync } = require('./syncs/model');
@@ -92,9 +105,15 @@ module.exports = {
     Token,
     UserModel,
     WebsocketConnection,
-
-    // encrypt
-    Encrypt,
+    prisma,
+    TokenRepository,
+    WebsocketConnectionRepository,
+    createUserRepository,
+    UserRepositoryMongo,
+    UserRepositoryPostgres,
+    CredentialRepository,
+    ModuleRepository,
+    IntegrationMappingRepository,
     Cryptor,
 
     // errors
@@ -106,14 +125,22 @@ module.exports = {
 
     // integrations
     IntegrationBase,
-    IntegrationModel,
     Options,
-    IntegrationMapping,
-    IntegrationFactory,
-    IntegrationHelper,
     checkRequiredParams,
     createIntegrationRouter,
-    createFriggBackend,
+    getModulesDefinitionFromIntegrationClasses,
+    LoadIntegrationContextUseCase,
+
+    // application - Command factories for integration developers
+    application,
+    createFriggCommands: application.createFriggCommands,
+    createIntegrationCommands: application.createIntegrationCommands,
+    createUserCommands: application.createUserCommands,
+    createEntityCommands: application.createEntityCommands,
+    createCredentialCommands: application.createCredentialCommands,
+    findIntegrationContextByExternalEntityId:
+        application.findIntegrationContextByExternalEntityId,
+    integrationCommands: application.integrationCommands,
 
     // lambda
     TimeoutCatcher,
@@ -125,17 +152,13 @@ module.exports = {
 
     // module plugin
     Credential,
-    EntityManager,
     Entity,
-    ModuleManager,
     ApiKeyRequester,
     BasicAuthRequester,
     OAuth2Requester,
     Requester,
     ModuleConstants,
     ModuleFactory,
-    Auther,
-
     // queues
     QueuerUtil,
 

package/integrations/index.js

@@ -1,19 +1,21 @@
 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');
+const {
+    createIntegrationRouter,
+    checkRequiredParams,
+} = require('./integration-router');
+const {
+    getModulesDefinitionFromIntegrationClasses,
+} = require('./utils/map-integration-dto');
+const {
+    LoadIntegrationContextUseCase,
+} = require('./use-cases/load-integration-context');
 
 module.exports = {
     IntegrationBase,
-    IntegrationModel,
     Options,
-    IntegrationMapping,
-    IntegrationFactory,
-    IntegrationHelper,
     createIntegrationRouter,
     checkRequiredParams,
-    createFriggBackend
+    getModulesDefinitionFromIntegrationClasses,
+    LoadIntegrationContextUseCase,
 };

package/integrations/integration-base.js

@@ -1,5 +1,17 @@
-const { IntegrationMapping } = require('./integration-mapping');
+const {
+    createIntegrationMappingRepository,
+} = require('./repositories/integration-mapping-repository-factory');
 const { Options } = require('./options');
+const {
+    UpdateIntegrationStatus,
+} = require('./use-cases/update-integration-status');
+const {
+    createIntegrationRepository,
+} = require('./repositories/integration-repository-factory');
+const {
+    UpdateIntegrationMessages,
+} = require('./use-cases/update-integration-messages');
+
 const constantsToBeMigrated = {
     defaultEvents: {
         ON_CREATE: 'ON_CREATE',
@@ -19,6 +31,16 @@ const constantsToBeMigrated = {
 };
 
 class IntegrationBase {
+    // todo: maybe we can pass this as Dependency Injection in the sub-class constructor
+    integrationRepository = createIntegrationRepository();
+    integrationMappingRepository = createIntegrationMappingRepository();
+    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
@@ -26,6 +48,7 @@ class IntegrationBase {
         });
         return options.get();
     }
+
     /**
      * CHILDREN SHOULD SPECIFY A DEFINITION FOR THE INTEGRATION
      */
@@ -50,29 +73,30 @@ 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`
-                );
-            }
+
+    // REMOVED: registerEventHandlers() - Event handling is now done by IntegrationEventDispatcher
+
+    constructor(params = {}) {
+        this.modules = {};
+        this.events = this.events || {};
+        this.messages = { errors: [], warnings: [] };
+        this._isHydrated = false;
+
+        if (params && Object.keys(params).length > 0) {
+            this.setIntegrationRecord({
+                record: {
+                    id: params.id,
+                    userId: params.userId,
+                    entities: params.entities,
+                    config: params.config,
+                    status: params.status,
+                    version: params.version,
+                    messages: params.messages,
+                },
+                modules: params.modules || [],
+            });
         }
-    }
-    registerEventHandlers() {
-        this.on = {
-            ...this.defaultEvents,
-            ...this.events,
-        };
-    }
 
-    constructor(params) {
         this.defaultEvents = {
             [constantsToBeMigrated.defaultEvents.ON_CREATE]: {
                 type: constantsToBeMigrated.types.LIFE_CYCLE_EVENT,
@@ -107,21 +131,90 @@ class IntegrationBase {
                 handler: this.refreshActionOptions,
             },
         };
-        this.loadModules();
     }
 
-    async send(event, object) {
-        if (!this.on[event]) {
-            throw new Error(
-                `Event ${event} is not defined in the Integration event object`
-            );
+    // todo: debate wether we want to keep this pattern to set the record or not.
+    /**
+     * Persist the database record and module instances onto this integration instance.
+     * Accepts either a plain object containing the persisted fields or an object with
+     * a `record` property plus a `modules` collection.
+     * @param {Object} payload
+     * @param {Object} [payload.record]
+     * @param {Array} [payload.modules]
+     */
+    setIntegrationRecord(payload = {}) {
+        if (!payload || Object.keys(payload).length === 0) {
+            throw new Error('setIntegrationRecord requires integration data');
+        }
+
+        const integrationRecord = payload.record;
+        const integrationModules = payload.modules ?? [];
+
+        if (!integrationRecord) {
+            throw new Error('Integration record not provided');
+        }
+
+        const { id, userId, entities, config, status, version, messages } =
+            integrationRecord;
+
+        this.id = id;
+        this.userId = userId;
+        this.entities = entities;
+        this.config = config;
+        this.status = status;
+        this.version = version;
+        this.messages = messages || { errors: [], warnings: [] };
+
+        this.modules = this._appendModules(integrationModules);
+
+        this.record = {
+            id: this.id,
+            userId: this.userId,
+            entities: this.entities,
+            config: this.config,
+            status: this.status,
+            version: this.version,
+            messages: this.messages,
+        };
+
+        this._isHydrated = Boolean(this.id);
+        return this;
+    }
+
+    get isHydrated() {
+        return this._isHydrated;
+    }
+
+    assertHydrated(message = 'Integration instance is not hydrated') {
+        if (!this.isHydrated) {
+            throw new Error(message);
+        }
+    }
+
+    /**
+     * Returns the modules as object with keys as module names.
+     * @private
+     * @param {Array} integrationModules - Array of module instances
+     * @returns {Object} The modules object
+     */
+    _appendModules(integrationModules) {
+        const modules = {};
+        for (const module of integrationModules) {
+            const key =
+                typeof module.getName === 'function'
+                    ? module.getName()
+                    : module.name;
+            if (key) {
+                modules[key] = module;
+                this[key] = module;
+            }
         }
-        return this.on[event].handler.call(this, object);
+        return modules;
     }
 
     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) {
@@ -133,56 +226,62 @@ 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: not sure we should call the repository directly from here
+        return this.integrationMappingRepository.findMappingBy(
+            this.id,
+            sourceId
+        );
     }
 
     async upsertMapping(sourceId, mapping) {
         if (!sourceId) {
             throw new Error(`sourceId must be set`);
         }
-        return await IntegrationMapping.upsert(
-            this.record.id,
+        // todo: not sure we should call the repository directly from here
+        return await this.integrationMappingRepository.upsertMapping(
+            this.id,
             sourceId,
             mapping
         );
@@ -191,10 +290,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) {}
@@ -259,6 +356,80 @@ 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);
+        }
+
+        // Event handlers are no longer registered here - handled by IntegrationEventDispatcher
+    }
+
+    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 };