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

package/modules/use-cases/refresh-entity-options.js

@@ -0,0 +1,58 @@
+const { Module } = require('../module');
+
+class RefreshEntityOptions {
+    /**
+     * @param {Object} params
+     * @param {import('../module-repository').ModuleRepository} params.moduleRepository
+     * @param {} params.moduleDefinitions
+     */
+    constructor({ moduleRepository, moduleDefinitions }) {
+        this.moduleRepository = moduleRepository;
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    /**
+     * Retrieve a Module instance for a given user and entity/module type.
+     * @param {string} userId
+     * @param {string} entityId
+     */
+    async execute(entityId, userId, options) {
+        const entity = await this.moduleRepository.findEntityById(
+            entityId,
+            userId
+        );
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        if (entity.userId !== userId) {
+            throw new Error(
+                `Entity ${entityId} does not belong to user ${userId}`
+            );
+        }
+
+        const entityType = entity.type;
+        const moduleDefinition = this.moduleDefinitions.find((def) => {
+            const modelName = Module.getEntityModelFromDefinition(def).modelName;
+            return entityType === modelName;
+        });
+
+        if (!moduleDefinition) {
+            throw new Error(
+                `Module definition not found for entity type: ${entityType}`
+            );
+        }
+
+        const module = new Module({
+            userId,
+            entity,
+            definition: moduleDefinition,
+        });
+
+        await module.refreshEntityOptions(options);
+        return module.getEntityOptions();
+    }
+}
+
+module.exports = { RefreshEntityOptions };

package/modules/use-cases/test-module-auth.js

@@ -0,0 +1,54 @@
+const { Module } = require('../module');
+
+class TestModuleAuth {
+    /**
+ * @param {Object} params - Configuration parameters.
+ * @param {import('./module-repository').ModuleRepository} params.moduleRepository - Repository for module data operations.
+ * @param {Array<Object>} params.moduleDefinitions - Array of module definitions.
+ */
+    constructor({ moduleRepository, moduleDefinitions }) {
+        this.moduleRepository = moduleRepository;
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    async execute(entityId, userId) {
+        const entity = await this.moduleRepository.findEntityById(
+            entityId,
+            userId
+        );
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        if (entity.userId !== userId) {
+            throw new Error(
+                `Entity ${entityId} does not belong to user ${userId}`
+            );
+        }
+
+        const entityType = entity.type;
+        const moduleDefinition = this.moduleDefinitions.find((def) => {
+            const modelName = Module.getEntityModelFromDefinition(def).modelName;
+            return entityType === modelName;
+        });
+
+        if (!moduleDefinition) {
+            throw new Error(
+                `Module definition not found for entity type: ${entityType}`
+            );
+        }
+
+        const module = new Module({
+            userId,
+            entity,
+            definition: moduleDefinition,
+        });
+
+        const testAuthResponse = await module.testAuth();
+
+        return testAuthResponse;
+    }
+}
+
+module.exports = { TestModuleAuth };

package/{module-plugin → modules}/utils/map-module-dto.js

@@ -6,7 +6,7 @@ function mapModuleClassToModuleDTO(moduleInstance) {
     if (!moduleInstance) return null;
 
     return {
-        id: moduleInstance.entity._id.toString(),
+        id: moduleInstance.entity.id,
         name: moduleInstance.name,
         userId: moduleInstance.userId,
         entity: moduleInstance.entity,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/core",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.396.6862738.0",
+  "version": "2.0.0--canary.397.c07f148.0",
   "dependencies": {
     "@hapi/boom": "^10.0.1",
     "aws-sdk": "^2.1200.0",
@@ -22,9 +22,9 @@
     "uuid": "^9.0.1"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.396.6862738.0",
-    "@friggframework/prettier-config": "2.0.0--canary.396.6862738.0",
-    "@friggframework/test": "2.0.0--canary.396.6862738.0",
+    "@friggframework/eslint-config": "2.0.0--canary.397.c07f148.0",
+    "@friggframework/prettier-config": "2.0.0--canary.397.c07f148.0",
+    "@friggframework/test": "2.0.0--canary.397.c07f148.0",
     "@types/lodash": "4.17.15",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "chai": "^4.3.6",
@@ -53,5 +53,5 @@
   },
   "homepage": "https://github.com/friggframework/frigg#readme",
   "description": "",
-  "gitHead": "6862738f1b370d1bb37353809b30586267e7deb0"
+  "gitHead": "c07f148505b5831d3f8be581529be9f0e18b5934"
 }

package/syncs/sync.js

@@ -1,5 +1,4 @@
 const md5 = require("md5");
-const ModuleManager = require('../module-plugin');
 const { debug } = require("packages/logs");
 const { get } = require("packages/assertions");
 

package/types/module-plugin/index.d.ts

@@ -20,42 +20,7 @@ declare module "@friggframework/module-plugin" {
   }
 
   export type MappedEntity = Entity & { id: string; type: any };
-  export class ModuleManager extends Delegate implements IFriggModuleManager {
-    static Entity: Entity;
-    static Credential: Credential;
 
-    constructor(params: { userId: string });
-
-    static getName(): any;
-    static getInstance(params: any): Promise<any>;
-    static getEntitiesForUserId(userId: string): Promise<MappedEntity[]>;
-
-    batchCreateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
-    batchUpdateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
-    findOrCreateEntity(params: any): Promise<any>;
-    getAllSyncObjects(SyncClass: any): Promise<any>;
-    getAuthorizationRequirements(params: any): Promise<any>;
-    getEntityId(): Promise<string>;
-    getEntityOptions(): Promise<any>;
-    markCredentialsInvalid(): Promise<Credential>;
-    processAuthorizationCallback(params: any): Promise<any>;
-    testAuth(params: any): Promise<any>;
-    validateAuthorizationRequirements(): Promise<boolean>;
-  }
-
-  interface IFriggModuleManager extends IFriggDelegate {
-    getEntityId(): Promise<string>;
-    validateAuthorizationRequirements(): Promise<boolean>;
-    getAuthorizationRequirements(params: any): Promise<any>;
-    testAuth(params: any): Promise<any>;
-    processAuthorizationCallback(params: any): Promise<any>;
-    getEntityOptions(): Promise<any>;
-    findOrCreateEntity(params: any): Promise<any>;
-    getAllSyncObjects(SyncClass: any): Promise<any>;
-    batchCreateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
-    batchUpdateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
-    markCredentialsInvalid(): Promise<Credential>;
-  }
 
   export class Requester implements IFriggRequester {
     DLGT_INVALID_AUTH: string;

package/types/syncs/index.d.ts

@@ -28,7 +28,6 @@ declare module "@friggframework/syncs/manager" {
     confirmCreate(
       syncObj: Sync,
       createdId: string,
-      moduleManager: any
     ): Promise<any>;
     confirmUpdate(syncObj: Sync): Promise<any>;
     createSyncDBObject(objArr: any[], entities: any[]): Promise<any>;
@@ -50,7 +49,6 @@ declare module "@friggframework/syncs/manager" {
     confirmCreate(
       syncObj: Sync,
       createdId: string,
-      moduleManager: any
     ): Promise<any>;
     confirmUpdate(syncObj: Sync): Promise<any>;
   }

package/integrations/integration.js

@@ -1,233 +0,0 @@
-const { Options } = require('./options');
-
-/**
- * Integration (Domain Aggregate-Root)
- * ----------------------------------
- * This class represents a *configured* integration instance at runtime. It is
- * deliberately split into **two layers**:
- *   1.  A *data snapshot* of the persisted record (id, userId, config, etc.).
- *   2.  A *behaviour* object: a concrete class supplied by the app developer
- *       that extends `IntegrationBase` and implements event handlers, user
- *       actions, custom routes, etc.
- *
- * The two layers are glued together via a **JavaScript `Proxy`**.  When a
- * property is requested on an `Integration` instance we:
- *   • Check if the property exists on the wrapper itself (data-layer).
- *   • Fallback to the behaviour instance (logic-layer).
- *   • If the value is a function we `.bind(this)` so that the function's
- *     `this` always points to the *wrapper* – giving it access to both data
- *     and behaviour transparently.
- *
- * This means you can treat a hydrated Integration as if it *were* the custom
- * class:
- *
- * ```js
- * const integration = await getIntegration.execute(id, userId);
- * // `send` actually lives on IntegrationBase but is accessible here
- * const actions = await integration.send('GET_USER_ACTIONS');
- * ```
- *
- * A corollary benefit is that **circular references stay internal**: the heavy
- * `Module → Api → delegate` graph is never exposed when we later serialise the
- * object to JSON – we map it to a DTO first.
- */
-
-/**
- * Integration Domain Entity
- * Represents a configured integration with its data and behavior
- * Uses the strategy pattern to delegate behavior to the integration class
- * This is the main class that is used to interact with integrations
- */
-class Integration {
-    constructor({
-        id,
-        userId,
-        entities,
-        config,
-        status,
-        version,
-        messages,
-        integrationClass,
-        modules = {}
-    }) {
-        // Data from record
-        this.id = id;
-        this.userId = userId;
-        this.entities = entities;
-        this.config = config;
-        this.status = status;
-        this.version = version;
-        this.messages = messages;
-
-        // Integration behavior (strategy pattern)
-        this.integrationClass = integrationClass;
-
-        // Loaded modules
-        this.modules = modules;
-
-        // Initialize basic behavior (sync parts only)
-        this._initializeBasicBehavior();
-
-        // --- Behaviour delegation via Proxy --------------------------------
-        // The Proxy merges the *data layer* (this wrapper) with the *behaviour
-        // layer* (custom IntegrationBase subclass).  Consumers don't have to
-        // know (or care) where a method/property is defined.
-        return new Proxy(this, {
-            get(target, prop) {
-                // First, check if property exists on Integration entity
-                if (prop in target) {
-                    return target[prop];
-                }
-
-                // Then, check if it exists on the behavior instance
-                if (target.behavior && prop in target.behavior) {
-                    const value = target.behavior[prop];
-
-                    // If it's a function, bind the context to the Integration entity
-                    if (typeof value === 'function') {
-                        return value.bind(target);
-                    }
-
-                    return value;
-                }
-
-                // Return undefined for non-existent properties
-                return undefined;
-            }
-        });
-    }
-
-    _initializeBasicBehavior() {
-        // Initialize basic behavior (sync parts only)
-        if (this.integrationClass) {
-            // Create instance for behavior delegation
-            this.behavior = new this.integrationClass({
-                userId: this.userId,
-                integrationId: this.id
-            });
-
-            // Copy events
-            this.events = this.behavior.events || {};
-            this.defaultEvents = this.behavior.defaultEvents || {};
-
-
-            // Expose behaviour instance methods directly on the wrapper so that
-            // early-bound handlers (created before behaviour existed) can still
-            // access them without falling back through the Proxy. This prevents
-            // `undefined` errors for methods like `loadDynamicUserActions` that
-            // may be invoked inside default event-handlers.
-            const proto = Object.getPrototypeOf(this.behavior);
-            for (const key of Object.getOwnPropertyNames(proto)) {
-                if (key === 'constructor') continue;
-                if (typeof proto[key] === 'function' && this[key] === undefined) {
-                    // Bind to behaviour so internal `this` remains correct.
-                    this[key] = proto[key].bind(this.behavior);
-                }
-            }
-        }
-    }
-
-    async initialize() {
-        // Complete async initialization
-        if (this.behavior) {
-            // 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();
-        }
-    }
-
-    // Core methods that should always be on Integration entity
-    // These override any behavior methods with the same name
-
-    // Module access helpers
-    getModule(key) {
-        return this.modules[key];
-    }
-
-    setModule(key, module) {
-        this.modules[key] = module;
-        // Also set on behavior for backward compatibility
-        if (this.behavior) {
-            this.behavior[key] = module;
-        }
-    }
-
-    // State management
-    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);
-    }
-
-    // Domain methods
-    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();
-    }
-
-    // Get the underlying behavior instance (useful for debugging or special cases)
-    getBehavior() {
-        return this.behavior;
-    }
-
-    // Check if a method exists (either on entity or behavior)
-    hasMethod(methodName) {
-        return methodName in this || (this.behavior && methodName in this.behavior);
-    }
-
-    getOptionDetails() {
-        const options = new Options({
-            module: Object.values(this.integrationClass.Definition.modules)[0], // This is a placeholder until we revamp the frontend
-            ...this.integrationClass.Definition,
-        });
-        return options.get();
-    }
-
-    /**
-     * Custom JSON serializer to prevent circular references (e.g. Module → Api → delegate)
-     * and to keep API responses lightweight.
-     * Only primitive, serialisable data needed by clients is returned.
-     */
-    toJSON() {
-        return {
-            id: this.id,
-            userId: this.userId,
-            entities: this.entities,
-            config: this.config,
-            status: this.status,
-            version: this.version,
-            messages: this.messages,
-            // Expose userActions if they were loaded/attached elsewhere
-            userActions: this.userActions,
-        };
-    }
-}
-
-module.exports = { Integration }; 

package/integrations/test/integration-base.test.js

@@ -1,144 +0,0 @@
-const _ = require('lodash');
-const { mongoose } = require('../../database/mongoose');
-const { expect } = require('chai');
-const { IntegrationBase } = require("../integration-base");
-const {Credential} = require('../../module-plugin/credential');
-const {Entity} = require('../../module-plugin/entity');
-const { IntegrationMapping } = require('../integration-mapping')
-const {IntegrationModel} = require("../integration-model");
-
-describe(`Should fully test the IntegrationBase Class`, () => {
-    let integrationRecord;
-    let userId;
-    const integration = new IntegrationBase;
-
-    beforeAll(async () => {
-        await mongoose.connect(process.env.MONGO_URI);
-        userId = new mongoose.Types.ObjectId();
-        const credential = await Credential.findOneAndUpdate(
-            {
-                user: this.userId,
-            },
-            { $set: { user: this.userId } },
-            {
-                new: true,
-                upsert: true,
-                setDefaultsOnInsert: true,
-            }
-        );
-        const entity1 = await Entity.findOneAndUpdate(
-            {
-                user: this.userId,
-            },
-            {
-                $set: {
-                    credential: credential.id,
-                    user: userId,
-                },
-            },
-            {
-                new: true,
-                upsert: true,
-                setDefaultsOnInsert: true,
-            }
-        );
-        const entity2 = await Entity.findOneAndUpdate(
-            {
-                user: userId,
-            },
-            {
-                $set: {
-                    credential: credential.id,
-                    user: userId,
-                },
-            },
-            {
-                new: true,
-                upsert: true,
-                setDefaultsOnInsert: true,
-            }
-        );
-        integrationRecord = await IntegrationModel.create({
-            entities: [entity1, entity2],
-            user: userId
-        });
-        integration.record = integrationRecord;
-    });
-
-    afterAll(async () => {
-        await Entity.deleteMany();
-        await Credential.deleteMany();
-        await IntegrationMapping.deleteMany();
-        await IntegrationModel.deleteMany();
-        await mongoose.disconnect();
-    });
-
-    beforeEach(() => {
-        integration.record = integrationRecord;
-    })
-
-    describe('getIntegrationMapping()', () => {
-        it('should return null if not found', async () => {
-            const mappings = await integration.getMapping('badId');
-            expect(mappings).to.be.null;
-        });
-
-        it('should return if valid ids', async () => {
-            await integration.upsertMapping('validId', {});
-            const mapping = await integration.getMapping('validId');
-            expect(mapping).to.eql({})
-        });
-    })
-
-    describe('upsertIntegrationMapping()', () => {
-        it('should throw error if sourceId is null', async () => {
-            try {
-                await integration.upsertMapping( null, {});
-                fail('should have thrown error')
-            } catch(err) {
-                expect(err.message).to.contain('sourceId must be set');
-            }
-        });
-
-        it('should return for empty mapping', async () => {
-            const mapping = await integration.upsertMapping( 'validId2', {});
-            expect(_.pick(mapping, ['integration', 'sourceId', 'mapping'])).to.eql({
-                integration: integrationRecord._id,
-                sourceId: 'validId2',
-                mapping: {}
-            })
-        });
-
-        it('should return for filled mapping', async () => {
-            const mapping = await integration.upsertMapping('validId3', {
-                name: 'someName',
-                value: 5
-            });
-            expect(_.pick(mapping, ['integration', 'sourceId', 'mapping'])).to.eql({
-                integration: integrationRecord._id,
-                sourceId: 'validId3',
-                mapping: {
-                    name: 'someName',
-                    value: 5
-                }
-            })
-        });
-
-        it('should allow upserting to same id', async () => {
-            await integration.upsertMapping('validId4', {});
-            const mapping = await integration.upsertMapping('validId4', {
-                name: 'trustMe',
-                thisWorks: true,
-            });
-            expect(_.pick(mapping, ['integration', 'sourceId', 'mapping'])).to.eql({
-                integration: integrationRecord._id,
-                sourceId: 'validId4',
-                mapping: {
-                    name: 'trustMe',
-                    thisWorks: true,
-                }
-            })
-        });
-    })
-
-});