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

package/integrations/use-cases/update-integration.js

@@ -1,81 +0,0 @@
-const { Integration } = require('../integration');
-const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
-
-
-class UpdateIntegration {
-
-    /**
-     * @class UpdateIntegration
-     * @description Use case for updating a single integration by ID and user.
-     * @param {Object} params
-     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data access
-     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes
-     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management
-     */
-    constructor({
-        integrationRepository,
-        integrationClasses,
-        moduleFactory,
-    }) {
-        this.integrationRepository = integrationRepository;
-        this.integrationClasses = integrationClasses;
-        this.moduleFactory = moduleFactory;
-    }
-
-    async execute(integrationId, userId, config) {
-        // 1. Get integration record from repository
-        const integrationRecord = await this.integrationRepository.findIntegrationById(integrationId);
-
-        if (!integrationRecord) {
-            throw new Error(`No integration found by the ID of ${integrationId}`);
-        }
-
-        // 2. Get the correct Integration class by type
-        const integrationClass = this.integrationClasses.find(
-            (integrationClass) => integrationClass.Definition.name === integrationRecord.config.type
-        );
-
-        if (!integrationClass) {
-            throw new Error(`No integration class found for type: ${integrationRecord.config.type}`);
-        }
-
-        if (integrationRecord.userId !== userId) {
-            throw new Error(
-                `Integration ${integrationId} does not belong to User ${userId}`
-            );
-        }
-
-
-        // 3. Load modules based on entity references
-        const modules = [];
-        for (const entityId of integrationRecord.entitiesIds) {
-            const moduleInstance = await this.moduleFactory.getModuleInstance(
-                entityId,
-                integrationRecord.userId
-            );
-            modules.push(moduleInstance);
-        }
-
-        // 4. Create the Integration domain entity with modules
-        const integrationInstance = new Integration({
-            id: integrationRecord.id,
-            userId: integrationRecord.userId,
-            entities: integrationRecord.entitiesIds,
-            config: integrationRecord.config,
-            status: integrationRecord.status,
-            version: integrationRecord.version,
-            messages: integrationRecord.messages,
-            integrationClass: integrationClass,
-            modules
-        });
-
-
-        // 6. Complete async initialization (load dynamic actions, register handlers)
-        await integrationInstance.initialize();
-        await integrationInstance.send('ON_UPDATE', { config });
-
-        return mapIntegrationClassToIntegrationDTO(integrationInstance);
-    }
-}
-
-module.exports = { UpdateIntegration }; 

package/integrations/utils/map-integration-dto.js

@@ -1,36 +0,0 @@
-/**
- * @param {import('../integration').Integration} integration
- * Convert an Integration domain instance to a plain DTO suitable for JSON responses.
- */
-function mapIntegrationClassToIntegrationDTO(integration) {
-    if (!integration) return null;
-
-    return {
-        id: integration.id,
-        userId: integration.userId,
-        entities: integration.entities,
-        config: integration.config,
-        status: integration.status,
-        version: integration.version,
-        messages: integration.messages,
-        userActions: integration.userActions,
-        options: integration.getOptionDetails(),
-    };
-}
-
-
-const getModulesDefinitionFromIntegrationClasses = (integrationClasses) => {
-    return [
-        ...new Set(
-            integrationClasses
-                .map((integration) =>
-                    Object.values(integration.Definition.modules).map(
-                        (module) => module.definition
-                    )
-                )
-                .flat()
-        ),
-    ];
-};
-
-module.exports = { mapIntegrationClassToIntegrationDTO, getModulesDefinitionFromIntegrationClasses }; 

package/modules/module-factory.js

@@ -1,54 +0,0 @@
-const { Module } = require('./module');
-
-/**
- * Acts as a factory for fully-hydrated domain Module instances.
- * Provides methods to retrieve and construct Module objects with their associated
- * entity and definition.
- */
-class ModuleFactory {
-    /**
-     * @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 getModuleInstance(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 moduleName = entity.moduleName;
-        const moduleDefinition = this.moduleDefinitions.find((def) => {
-            return moduleName === def.modelName;
-        });
-
-        if (!moduleDefinition) {
-            throw new Error(
-                `Module definition not found for entity type: ${entityType}`
-            );
-        }
-
-        return new Module({
-            userId,
-            entity,
-            definition: moduleDefinition,
-        });
-    }
-}
-
-module.exports = { ModuleFactory };

package/modules/module-repository.js

@@ -1,72 +0,0 @@
-const { Entity } = require('./entity');
-
-class ModuleRepository {
-    async findEntityById(entityId) {
-        const entity = await Entity.findById(entityId, undefined, { lean: true }).populate('credential');
-        if (!entity) {
-            throw new Error(`Entity ${entityId} not found`);
-        }
-
-        return {
-            id: entity._id,
-            accountId: entity.accountId,
-            credential: entity.credential,
-            userId: entity.user.toString(),
-            name: entity.name,
-            externalId: entity.externalId,
-            type: entity.__t,
-            moduleName: entity.moduleName,
-        };
-    }
-
-    async findEntitiesByUserId(userId) {
-        const entitiesRecords = await Entity.find(
-            { user: userId },
-            '',
-            { lean: true }
-        ).populate('credential');
-
-        return entitiesRecords.map(e => ({
-            id: e._id.toString(),
-            accountId: e.accountId,
-            credential: e.credential,
-            userId: e.user.toString(),
-            name: e.name,
-            externalId: e.externalId,
-            type: e.__t,
-            moduleName: e.moduleName,
-        }));
-    }
-
-    async findEntitiesByIds(entitiesIds) {
-        const entitiesRecords = await Entity.find(
-            { _id: { $in: entitiesIds } },
-            '',
-            { lean: true }
-        ).populate('credential');
-
-        return entitiesRecords.map(e => ({
-            id: e._id.toString(),
-            accountId: e.accountId,
-            credential: e.credential,
-            userId: e.user.toString(),
-            name: e.name,
-            externalId: e.externalId,
-            type: e.__t,
-            moduleName: e.moduleName,
-        }));
-    }
-
-    /**
-     * Remove the credential reference from an Entity document without loading a full Mongoose instance.
-     * Useful when a credential has been revoked/deleted (e.g. via Module.deauthorize).
-     * @param {string} entityId
-     * @returns {Promise<import('mongoose').UpdateWriteOpResult>}
-     */
-    async unsetCredential(entityId) {
-        const result = await Entity.updateOne({ _id: entityId }, { $unset: { credential: "" } });
-        return result.acknowledged;
-    }
-}
-
-module.exports = { ModuleRepository }; 

package/modules/module.js

@@ -1,251 +0,0 @@
-const { Delegate } = require('../core');
-const _ = require('lodash');
-const { flushDebugLog } = require('../logs');
-const { ModuleConstants } = require('./ModuleConstants');
-
-// todo: this class should be a Domain class, and the Delegate function is preventing us from
-// doing that, we probably have to get rid of the Delegate class as well as the event based 
-// calls since they go against the Domain Driven Design principles (eg. a domain class should not call repository methods or use cases)
-class Module extends Delegate {
-
-    //todo: entity should be replaced with actual entity properties
-    /**
-     * 
-     * @param {Object} params
-     * @param {Object} params.definition The definition of the Api Module
-     * @param {string} params.userId The user id
-     * @param {Object} params.entity The entity record from the database
-     */
-    constructor({ definition, userId = null, entity: entityObj = null }) {
-        super({ definition, userId, entity: entityObj });
-
-        this.validateDefinition(definition);
-
-        this.userId = userId;
-        this.entity = entityObj;
-        this.credential = entityObj?.credential;
-        this.definition = definition;
-        this.name = this.definition.moduleName;
-        this.modelName = this.definition.modelName;
-        this.apiClass = this.definition.API;
-
-        // Repository used for persistence operations related to credentials.
-        const { CredentialRepository } = require('../credential/credential-repository');
-        this.credentialRepository = new CredentialRepository();
-
-        // Repository responsible for entity persistence actions
-        const { ModuleRepository } = require('./module-repository');
-        this.moduleRepository = new ModuleRepository();
-
-        Object.assign(this, this.definition.requiredAuthMethods);
-
-        const apiParams = {
-            ...this.definition.env,
-            delegate: this,
-            ...this.apiParamsFromCredential(this.credential),
-            ...this.apiParamsFromEntity(this.entity),
-        };
-        this.api = new this.apiClass(apiParams);
-    }
-
-    getName() {
-        return this.name;
-    }
-
-    getEntityOptions() {
-        return this.definition.getEntityOptions()
-    }
-
-    async refreshEntityOptions(options) {
-        await this.definition.refreshEntityOptions(options);
-        return this.getEntityOptions();
-    }
-
-    apiParamsFromCredential(credential) {
-        return _.pick(credential, ...this.apiPropertiesToPersist?.credential);
-    }
-
-    apiParamsFromEntity(entity) {
-        return _.pick(entity, ...this.apiPropertiesToPersist?.entity);
-    }
-
-    async validateAuthorizationRequirements() {
-        const requirements = await this.getAuthorizationRequirements();
-        let valid = true;
-        if (
-            ['oauth1', 'oauth2'].includes(requirements.type) &&
-            !requirements.url
-        ) {
-            valid = false;
-        }
-        return valid;
-    }
-
-    async getAuthorizationRequirements(params) {
-        return this.api.getAuthorizationRequirements();
-    }
-
-    async testAuth() {
-        let validAuth = false;
-        try {
-            if (await this.testAuthRequest(this.api)) validAuth = true;
-        } catch (e) {
-            flushDebugLog(e);
-        }
-        return validAuth;
-    }
-
-    async processAuthorizationCallback(params) {
-        let tokenResponse;
-        if (this.apiClass.requesterType === ModuleConstants.authType.oauth2) {
-            tokenResponse = await this.getToken(this.api, params);
-        } else {
-            tokenResponse = await this.setAuthParams(this.api, params);
-            await this.onTokenUpdate();
-        }
-        const authRes = await this.testAuth();
-        if (!authRes) {
-            throw new Error('Authorization failed');
-        }
-        const entityDetails = await this.getEntityDetails(
-            this.api,
-            params,
-            tokenResponse,
-            this.userId
-        );
-        Object.assign(
-            entityDetails.details,
-            this.apiParamsFromEntity(this.api)
-        );
-        await this.findOrCreateEntity(entityDetails);
-        return {
-            credential_id: this.credential.id,
-            entity_id: this.entity.id,
-            type: this.getName(),
-        };
-    }
-
-    async onTokenUpdate() {
-        const credentialDetails = await this.getCredentialDetails(
-            this.api,
-            this.userId
-        );
-        Object.assign(
-            credentialDetails.details,
-            this.apiParamsFromCredential(this.api)
-        );
-        credentialDetails.details.auth_is_valid = true;
-
-        const persisted = await this.credentialRepository.upsertCredential(credentialDetails);
-        this.credential = persisted;
-    }
-
-    async receiveNotification(notifier, delegateString, object = null) {
-        if (delegateString === this.api.DLGT_TOKEN_UPDATE) {
-            await this.onTokenUpdate();
-        } else if (delegateString === this.api.DLGT_TOKEN_DEAUTHORIZED) {
-            await this.deauthorize();
-        } else if (delegateString === this.api.DLGT_INVALID_AUTH) {
-            await this.markCredentialsInvalid();
-        }
-    }
-
-    async markCredentialsInvalid() {
-        if (!this.credential) return;
-
-        // Persist flag change through repository – works even when the
-        // credential object is a plain JavaScript object (lean query).
-        const credentialId = this.credential._id || this.credential.id;
-        if (!credentialId) return;
-
-        await this.credentialRepository.updateAuthenticationStatus(
-            credentialId,
-            false
-        );
-
-        // Keep the in-memory snapshot consistent so that callers can read the
-        // updated state without another fetch.
-        this.credential.auth_is_valid = false;
-    }
-
-    async deauthorize() {
-        this.api = new this.apiClass();
-
-        // Remove persisted credential (if any)
-        if (this.entity?.credential) {
-            const credentialId =
-                this.entity.credential._id || this.entity.credential.id || this.entity.credential;
-
-            // Delete credential via repository
-            await this.credentialRepository.deleteCredentialById(credentialId);
-
-            // Unset credential reference on the Entity document
-            const entityId = this.entity._id || this.entity.id;
-            if (entityId) {
-                await this.moduleRepository.unsetCredential(entityId);
-            }
-
-            // Keep in-memory snapshot consistent
-            this.entity.credential = undefined;
-        }
-    }
-
-    // todo: check if all these props are still up to date
-    validateDefinition(definition) {
-        if (!definition) {
-            throw new Error('Module definition is required');
-        }
-        if (!definition.moduleName) {
-            throw new Error('Module definition requires moduleName');
-        }
-        if (!definition.API) {
-            throw new Error('Module definition requires API class');
-        }
-        if (!definition.requiredAuthMethods) {
-            throw new Error('Module definition requires requiredAuthMethods');
-        } else {
-            if (
-                definition.API.requesterType ===
-                ModuleConstants.authType.oauth2 &&
-                !definition.requiredAuthMethods.getToken
-            ) {
-                throw new Error(
-                    'Module definition requires requiredAuthMethods.getToken'
-                );
-            }
-            if (!definition.requiredAuthMethods.getEntityDetails) {
-                throw new Error(
-                    'Module definition requires requiredAuthMethods.getEntityDetails'
-                );
-            }
-            if (!definition.requiredAuthMethods.getCredentialDetails) {
-                throw new Error(
-                    'Module definition requires requiredAuthMethods.getCredentialDetails'
-                );
-            }
-            if (!definition.requiredAuthMethods.apiPropertiesToPersist) {
-                throw new Error(
-                    'Module definition requires requiredAuthMethods.apiPropertiesToPersist'
-                );
-            } else if (definition.Credential) {
-                for (const prop of definition.requiredAuthMethods
-                    .apiPropertiesToPersist?.credential) {
-                    if (
-                        !definition.Credential.schema.paths.hasOwnProperty(prop)
-                    ) {
-                        throw new Error(
-                            `Module definition requires Credential schema to have property ${prop}`
-                        );
-                    }
-                }
-            }
-            if (!definition.requiredAuthMethods.testAuthRequest) {
-                throw new Error(
-                    'Module definition requires requiredAuthMethods.testAuth'
-                );
-            }
-        }
-    }
-}
-
-module.exports = { Module }; 

package/modules/tests/doubles/test-module-factory.js

@@ -1,16 +0,0 @@
-class TestModuleFactory {
-    constructor() { }
-
-    async getModuleInstance(entityId, userId) {
-        // return minimal stub module with getName and api property
-        return {
-            getName() { return 'stubModule'; },
-            api: {},
-            entityId,
-            userId,
-            testAuth: async () => true,
-        };
-    }
-}
-
-module.exports = { TestModuleFactory }; 

package/modules/tests/doubles/test-module-repository.js

@@ -1,19 +0,0 @@
-class TestModuleRepository {
-    constructor() {
-        this.entities = new Map();
-    }
-
-    addEntity(entity) {
-        this.entities.set(entity.id, entity);
-    }
-
-    async findEntityById(id) {
-        return this.entities.get(id);
-    }
-
-    async findEntitiesByIds(ids) {
-        return ids.map((id) => this.entities.get(id));
-    }
-}
-
-module.exports = { TestModuleRepository }; 

package/modules/use-cases/get-entities-for-user.js

@@ -1,32 +0,0 @@
-const { Module } = require('../module');
-const { mapModuleClassToModuleDTO } = require('../utils/map-module-dto');
-
-class GetEntitiesForUser {
-    constructor({ moduleRepository, moduleDefinitions }) {
-        this.moduleRepository = moduleRepository;
-
-        this.definitionMap = new Map();
-        for (const definition of moduleDefinitions) {
-            this.definitionMap.set(definition.modelName, definition);
-        }
-    }
-
-    async execute(userId) {
-        const entities = await this.moduleRepository.findEntitiesByUserId(
-            userId
-        );
-
-        return entities.map((entity) => {
-            const definition = this.definitionMap.get(entity.moduleName);
-
-            const moduleInstance = new Module({
-                userId,
-                definition: definition,
-                entity: entity,
-            });
-            return mapModuleClassToModuleDTO(moduleInstance);
-        });
-    }
-}
-
-module.exports = { GetEntitiesForUser }; 

package/modules/use-cases/get-entity-options-by-id.js

@@ -1,58 +0,0 @@
-const { Module } = require('../module');
-
-class GetEntityOptionsById {
-    /**
-     * @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) {
-        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 entityOptions = await module.getEntityOptions();
-        return entityOptions;
-    }
-}
-
-module.exports = { GetEntityOptionsById };

package/modules/use-cases/get-entity-options-by-type.js

@@ -1,34 +0,0 @@
-const { Module } = require('../module');
-
-class GetEntityOptionsByType {
-    /**
-     * @param {Object} params
-     * @param {} params.moduleDefinitions
-     */
-    constructor({ moduleDefinitions }) {
-        this.moduleDefinitions = moduleDefinitions;
-    }
-
-    /**
-     * Retrieve a Module instance for a given user and entity/module type.
-     * @param {string} userId
-     * @param {string} type – human-readable module/entity type (e.g. "Hubspot")
-     */
-    async execute(userId, type) {
-        const moduleDefinition = this.moduleDefinitions.find(
-            (def) => def.getName() === type
-        );
-        if (!moduleDefinition) {
-            throw new Error(`Module definition not found for type: ${type}`);
-        }
-        const moduleInstance = new Module({
-            userId,
-            definition: moduleDefinition,
-        });
-
-        const entityOptions = await moduleInstance.getEntityOptions();
-        return entityOptions;
-    }
-}
-
-module.exports = { GetEntityOptionsByType };

package/modules/use-cases/get-module-instance-from-type.js

@@ -1,31 +0,0 @@
-const { Module } = require('../module');
-
-class GetModuleInstanceFromType {
-    /**
-     * @param {Object} params
-     * @param {} params.moduleDefinitions
-     */
-    constructor({ moduleDefinitions }) {
-        this.moduleDefinitions = moduleDefinitions;
-    }
-
-    /**
-     * Retrieve a Module instance for a given user and entity/module type.
-     * @param {string} userId
-     * @param {string} type – human-readable module/entity type (e.g. "Hubspot")
-     */
-    async execute(userId, type) {
-        const moduleDefinition = this.moduleDefinitions.find(
-            (def) => def.getName() === type
-        );
-        if (!moduleDefinition) {
-            throw new Error(`Module definition not found for type: ${type}`);
-        }
-        return new Module({
-            userId,
-            definition: moduleDefinition,
-        });
-    }
-}
-
-module.exports = { GetModuleInstanceFromType };