@friggframework/core 2.0.0--canary.397.3862908.0 → 2.0.0--canary.398.e2147f7.0

package/module-plugin/module-factory.js

@@ -0,0 +1,61 @@
+const { Entity } = require('./entity');
+const { Auther } = require('./auther');
+
+class ModuleFactory {
+    constructor(...params) {
+        this.moduleDefinitions = params;
+        this.moduleTypes = this.moduleDefinitions.map((def) => def.moduleName);
+    }
+
+    async getEntitiesForUser(userId) {
+        let results = [];
+        for (const moduleDefinition of this.moduleDefinitions) {
+            const moduleInstance = await Auther.getInstance({
+                userId,
+                definition: moduleDefinition,
+            });
+            const list = await moduleInstance.getEntitiesForUserId(userId);
+            results.push(...list);
+        }
+        return results;
+    }
+
+    checkIsValidType(entityType) {
+        return this.moduleTypes.includes(entityType);
+    }
+
+    getModuleDefinitionFromTypeName(typeName) {
+        return;
+    }
+
+    async getModuleInstanceFromEntityId(entityId, userId) {
+        const entity = await Entity.findById(entityId);
+        const moduleDefinition = this.moduleDefinitions.find(
+            (def) =>
+                entity.toJSON()['__t'] ===
+                Auther.getEntityModelFromDefinition(def).modelName
+        );
+        if (!moduleDefinition) {
+            throw new Error(
+                'Module definition not found for entity type: ' + entity['__t']
+            );
+        }
+        return await Auther.getInstance({
+            userId,
+            entityId,
+            definition: moduleDefinition,
+        });
+    }
+
+    async getInstanceFromTypeName(typeName, userId) {
+        const moduleDefinition = this.moduleDefinitions.find(
+            (def) => def.getName() === typeName
+        );
+        return await Auther.getInstance({
+            userId,
+            definition: moduleDefinition,
+        });
+    }
+}
+
+module.exports = { ModuleFactory };

package/{modules → module-plugin}/test/mock-api/api.js

@@ -1,5 +1,5 @@
-const { get } = require('../../../assertions');
-const { OAuth2Requester } = require('../..');
+const { get } = require('../../assertions');
+const { OAuth2Requester } = require('../../module-plugin');
 
 class Api extends OAuth2Requester {
     constructor(params) {
@@ -23,12 +23,7 @@ class Api extends OAuth2Requester {
         return this.authorizationUri;
     }
 
-    getAuthorizationRequirements() {
-        return {
-            url: this.getAuthUri(),
-            type: 'oauth2',
-        };
-    }
+
 }
 
 module.exports = { Api };

package/{modules → module-plugin}/test/mock-api/definition.js

@@ -1,23 +1,19 @@
 require('dotenv').config();
-const { Api } = require('./api');
-const { get } = require('../../../assertions');
-const config = { name: 'anapi' }
+const {Api} = require('./api');
+const {get} = require('../../assertions');
+const config = {name: 'anapi'}
 
 const Definition = {
     API: Api,
-    getAuthorizationRequirements: () => ({
-        url: 'http://localhost:3000/redirect/anapi',
-        type: 'oauth2',
-    }),
-    getName: function () { return config.name },
+    getName: function() {return config.name},
     moduleName: config.name,
     modelName: 'AnApi',
     requiredAuthMethods: {
-        getToken: async function (api, params) {
+        getToken: async function(api, params){
             const code = get(params.data, 'code');
             return api.getTokenFromCode(code);
         },
-        getEntityDetails: async function (api, callbackParams, tokenResponse, userId) {
+        getEntityDetails: async function(api, callbackParams, tokenResponse, userId) {
             const userDetails = await api.getUserDetails();
             return {
                 identifiers: { externalId: userDetails.portalId, user: userId },
@@ -30,14 +26,14 @@ const Definition = {
             ],
             entity: [],
         },
-        getCredentialDetails: async function (api, userId) {
+        getCredentialDetails: async function(api, userId) {
             const userDetails = await api.getUserDetails();
             return {
                 identifiers: { externalId: userDetails.portalId, user: userId },
                 details: {}
             };
         },
-        testAuthRequest: async function (api) {
+        testAuthRequest: async function(api){
             return api.getUserDetails()
         },
     },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/core",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.397.3862908.0",
+  "version": "2.0.0--canary.398.e2147f7.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.397.3862908.0",
-    "@friggframework/prettier-config": "2.0.0--canary.397.3862908.0",
-    "@friggframework/test": "2.0.0--canary.397.3862908.0",
+    "@friggframework/eslint-config": "2.0.0--canary.398.e2147f7.0",
+    "@friggframework/prettier-config": "2.0.0--canary.398.e2147f7.0",
+    "@friggframework/test": "2.0.0--canary.398.e2147f7.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": "3862908989603188a6c3a404d456f4349c84e54b"
+  "gitHead": "e2147f7f03122a5daa917429ba610c1a7c6ef819"
 }

package/types/integrations/index.d.ts

@@ -1,6 +1,7 @@
 declare module "@friggframework/integrations" {
   import { Delegate, IFriggDelegate } from "@friggframework/core";
   import { Model } from "mongoose";
+  import { EntityManager } from "@friggframework/module-plugin";
 
   export class Integration extends Model {
     entities: any[];
@@ -18,7 +19,8 @@ declare module "@friggframework/integrations" {
 
   export class IntegrationManager
     extends Delegate
-    implements IFriggIntegrationManager {
+    implements IFriggIntegrationManager
+  {
     integration: Integration;
     primaryInstance: any;
     targetInstance: any;
@@ -54,6 +56,7 @@ declare module "@friggframework/integrations" {
       entities: { id: string; user: any },
       userId: string,
       config: any,
+      EntityManager: EntityManager
     ): Promise<any>;
 
     static getFormattedIntegration(
@@ -113,7 +116,8 @@ declare module "@friggframework/integrations" {
   }
 
   export class IntegrationConfigManager
-    implements IFriggIntegrationConfigManager {
+    implements IFriggIntegrationConfigManager
+  {
     options: IntegrationOptions[];
     primary: any;
 

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

@@ -9,7 +9,21 @@ declare module "@friggframework/module-plugin" {
     externalId: string;
   }
 
-  interface IFriggEntityManager { }
+  export class EntityManager implements IFriggEntityManager {
+    static primaryEntityClass: any;
+    static entityManagerClasses: any[];
+    static entityTypes: string[];
+    static getEntitiesForUser(userId: string): Promise<any[]>;
+    static checkIsValidType(entityType: string): boolean;
+    static getEntityManagerClass(entityType?: string): any;
+
+    static getEntityManagerInstanceFromEntityId(
+      entityId: string,
+      userId: string
+    ): Promise<any>;
+  }
+
+  interface IFriggEntityManager {}
 
   export class Entity extends Model {
     credentialId: string;
@@ -124,7 +138,8 @@ declare module "@friggframework/module-plugin" {
 
   export class ApiKeyRequester
     extends Requester
-    implements IFriggApiKeyRequester {
+    implements IFriggApiKeyRequester
+  {
     API_KEY_NAME: string;
     API_KEY_VALUE: any;
 
@@ -145,7 +160,8 @@ declare module "@friggframework/module-plugin" {
 
   export class BasicAuthRequester
     extends Requester
-    implements IFriggBasicAuthRequester {
+    implements IFriggBasicAuthRequester
+  {
     password: string;
     username: string;
 
@@ -173,7 +189,8 @@ declare module "@friggframework/module-plugin" {
 
   export class OAuth2Requester
     extends Requester
-    implements IFriggOAuth2Requester {
+    implements IFriggOAuth2Requester
+  {
     DLGT_TOKEN_DEAUTHORIZED: string;
     DLGT_TOKEN_UPDATE: string;
     accessTokenExpire: any;

package/credential/credential-repository.js

@@ -1,42 +0,0 @@
-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 };
-
-        return Credential.findOneAndUpdate(query, update, options);
-    }
-}
-
-module.exports = { CredentialRepository };

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

@@ -1,21 +0,0 @@
-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/credential/use-cases/update-authentication-status.js

@@ -1,15 +0,0 @@
-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/app-definition-loader.js

@@ -1,38 +0,0 @@
-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/integrations/integration-repository.js

@@ -1,67 +0,0 @@
-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 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) {
-        const integrationRecord = await IntegrationModel.create({
-            entities: entities,
-            user: userId,
-            config,
-            version: '0.0.0',
-        });
-
-        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,
-        };
-    }
-}
-
-module.exports = { IntegrationRepository };

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;
-
-        // Preserve the provided Module instances (array). We'll attach them
-        // as keyed modules after the behaviour instance is created so that
-        // `this.hubspot`, `this.salesforce`, etc. reference the fully-
-        // initialised objects with credentials.
-        this._moduleInstances = Array.isArray(modules) ? modules : [];
-
-        // Normalised map of modules keyed by module name (filled later)
-        this.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 || {};
-
-            // -----------------------------------------------------------------
-            // Inject the real Module instances (with credentials) so that any
-            // behaviour code accessing `this.<moduleName>.api` hits the
-            // correctly authenticated requester created by ModuleFactory.
-            // -----------------------------------------------------------------
-            for (const mod of this._moduleInstances) {
-                const key = typeof mod.getName === 'function' ? mod.getName() : mod.name;
-                if (!key) continue;
-                this.setModule(key, mod);
-            }
-
-            // `undefined` errors for methods like `loadDynamicUserActions` that
-            // may be invoked inside default event-handlers.
-            let proto = Object.getPrototypeOf(this.behavior);
-            while (proto && proto !== Object.prototype) {
-                for (const key of Object.getOwnPropertyNames(proto)) {
-                    if (key === 'constructor') continue;
-                    if (typeof proto[key] === 'function' && this[key] === undefined) {
-                        this[key] = proto[key].bind(this.behavior);
-                    }
-                }
-                proto = Object.getPrototypeOf(proto);
-            }
-        }
-    }
-
-    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
-
-    getConfig() {
-        return this.config;
-    }
-
-    // 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();
-    }
-}
-
-module.exports = { Integration };

package/integrations/tests/doubles/dummy-integration-class.js

@@ -1,11 +0,0 @@
-const { IntegrationBase } = require('../../integration-base');
-
-class DummyIntegration extends IntegrationBase {
-    static Definition = {
-        name: 'dummy',
-        version: '1.0.0',
-        modules: {},
-    };
-}
-
-module.exports = { DummyIntegration };