@friggframework/core 2.0.0--canary.397.e634da9.0 → 2.0.0--canary.398.ad248a6.0

package/modules/module-repository.js

@@ -1,107 +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;
-    }
-
-    async findEntity(filter) {
-        const entity = await Entity.findOne(filter, undefined, { lean: true }).populate('credential');
-        if (!entity) {
-            return null;
-        }
-
-        return {
-            id: entity._id.toString(),
-            accountId: entity.accountId,
-            credential: entity.credential,
-            userId: entity.user.toString(),
-            name: entity.name,
-            externalId: entity.externalId,
-            type: entity.__t,
-            moduleName: entity.moduleName,
-        };
-    }
-
-    async createEntity(entityData) {
-        const entity = await Entity.create(entityData);
-        await entity.populate('credential');
-
-        return {
-            id: entity._id.toString(),
-            accountId: entity.accountId,
-            credential: entity.credential,
-            userId: entity.user.toString(),
-            name: entity.name,
-            externalId: entity.externalId,
-            type: entity.__t,
-            moduleName: entity.moduleName,
-        };
-    }
-
-}
-
-module.exports = { ModuleRepository }; 

package/modules/module.js

@@ -1,221 +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 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 };

package/modules/use-cases/get-module.js

@@ -1,56 +0,0 @@
-const { Module } = require('../module');
-
-class GetModule {
-    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,
-        });
-
-        // todo: this properties should be methods in the Module class
-        return {
-            id: module.entity.id,
-            name: module.entity.name,
-            type: module.entity.moduleName,
-            moduleName: module.entity.moduleName,
-            credential: module.credential,
-            externalId: module.entity.externalId,
-            userId: module.entity.user.toString(),
-        }
-    }
-}
-
-module.exports = { GetModule };

package/modules/use-cases/process-authorization-callback.js

@@ -1,114 +0,0 @@
-const { Module } = require('../module');
-const { ModuleConstants } = require('../ModuleConstants');
-
-class ProcessAuthorizationCallback {
-    /**
-     * @param {Object} params - Configuration parameters.
-     * @param {import('../module-repository').ModuleRepository} params.moduleRepository - Repository for module data operations.
-     * @param {import('../../credential/credential-repository').CredentialRepository} params.credentialRepository - Repository for credential data operations.
-     * @param {Array<Object>} params.moduleDefinitions - Array of module definitions.
-     */
-    constructor({ moduleRepository, credentialRepository, moduleDefinitions }) {
-        this.moduleRepository = moduleRepository;
-        this.credentialRepository = credentialRepository;
-        this.moduleDefinitions = moduleDefinitions;
-    }
-
-    async execute(userId, entityType, params, credentialId = null) {
-        const moduleDefinition = this.moduleDefinitions.find((def) => {
-            return entityType === def.moduleName;
-        });
-
-        if (!moduleDefinition) {
-            throw new Error(
-                `Module definition not found for entity type: ${entityType}`
-            );
-        }
-
-        let credential = null;
-        let entity = null;
-
-        if (credentialId) {
-            credential = await this.credentialRepository.findCredentialById(credentialId);
-            if (!credential) {
-                throw new Error(`Credential ${credentialId} not found`);
-            }
-        }
-
-        const module = new Module({
-            userId,
-            entity,
-            definition: moduleDefinition,
-        });
-
-        let tokenResponse;
-        if (module.apiClass.requesterType === ModuleConstants.authType.oauth2) {
-            tokenResponse = await moduleDefinition.requiredAuthMethods.getToken(module.api, params);
-        } else {
-            tokenResponse = await moduleDefinition.requiredAuthMethods.setAuthParams(module.api, params);
-            await this.onTokenUpdate(module, moduleDefinition, userId);
-        }
-
-        const authRes = await module.testAuth();
-        if (!authRes) {
-            throw new Error('Authorization failed');
-        }
-
-        const entityDetails = await moduleDefinition.requiredAuthMethods.getEntityDetails(
-            module.api,
-            params,
-            tokenResponse,
-            userId
-        );
-
-        Object.assign(
-            entityDetails.details,
-            module.apiParamsFromEntity(module.api)
-        );
-
-        const persistedEntity = await this.findOrCreateEntity(entityDetails, entityType);
-
-        return {
-            credential_id: module.credential.id,
-            entity_id: persistedEntity.id,
-            type: module.getName(),
-        };
-    }
-
-    async onTokenUpdate(module, moduleDefinition, userId) {
-        const credentialDetails = await moduleDefinition.requiredAuthMethods.getCredentialDetails(
-            module.api,
-            userId
-        );
-
-        Object.assign(
-            credentialDetails.details,
-            module.apiParamsFromCredential(module.api)
-        );
-        credentialDetails.details.auth_is_valid = true;
-
-        await this.credentialRepository.upsertCredential(credentialDetails);
-    }
-
-    async findOrCreateEntity(entityDetails, entityType) {
-        const { identifiers, details } = entityDetails;
-
-        const existingEntity = await this.moduleRepository.findEntity({
-            externalId: identifiers.externalId,
-            user: identifiers.user,
-            __t: entityType
-        });
-
-        if (existingEntity) {
-            return existingEntity;
-        }
-
-        return await this.moduleRepository.createEntity({
-            ...identifiers,
-            ...details,
-            __t: entityType
-        });
-    }
-}
-
-module.exports = { ProcessAuthorizationCallback };