@friggframework/core 2.0.0-next.6 → 2.0.0-next.60

package/modules/repositories/module-repository.js

@@ -0,0 +1,316 @@
+const { prisma } = require('../../database/prisma');
+const { ModuleRepositoryInterface } = require('./module-repository-interface');
+
+/**
+ * Prisma-based Module Repository
+ * Handles Entity model operations for external service entities
+ *
+ * Works identically for both MongoDB and PostgreSQL:
+ * - MongoDB: String IDs with @db.ObjectId
+ * - PostgreSQL: Integer IDs with auto-increment
+ * - Both use same query patterns (no many-to-many differences)
+ *
+ * Migration from Mongoose:
+ * - Constructor injection of Prisma client
+ * - populate('credential') → include: { credential: true }
+ * - Mongoose discriminator (__t) → moduleName field (module type: salesforce, hubspot, etc.)
+ * - _id → id conversion automatic in Prisma
+ */
+class ModuleRepository extends ModuleRepositoryInterface {
+    constructor(prismaClient = prisma) {
+        super();
+        this.prisma = prismaClient; // Allow injection for testing
+    }
+
+    /**
+     * Find entity by ID with credential
+     * Replaces: Entity.findById(entityId).populate('credential')
+     *
+     * @param {string} entityId - Entity ID
+     * @returns {Promise<Object>} Entity object
+     * @throws {Error} If entity not found
+     */
+    async findEntityById(entityId) {
+        const entity = await this.prisma.entity.findUnique({
+            where: { id: entityId },
+            include: { credential: true },
+        });
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        return {
+            id: entity.id,
+            accountId: entity.accountId,
+            credential: entity.credential,
+            userId: entity.userId,
+            name: entity.name,
+            externalId: entity.externalId,
+            moduleName: entity.moduleName,
+        };
+    }
+
+    /**
+     * Find all entities for a user
+     * Replaces: Entity.find({ user: userId }).populate('credential')
+     *
+     * @param {string} userId - User ID
+     * @returns {Promise<Array>} Array of entity objects
+     */
+    async findEntitiesByUserId(userId) {
+        const entities = await this.prisma.entity.findMany({
+            where: { userId },
+            include: { credential: true },
+        });
+
+        return entities.map((e) => ({
+            id: e.id,
+            accountId: e.accountId,
+            credential: e.credential,
+            userId: e.userId,
+            name: e.name,
+            externalId: e.externalId,
+            moduleName: e.moduleName,
+        }));
+    }
+
+    /**
+     * Find entities by array of IDs
+     * Replaces: Entity.find({ _id: { $in: entitiesIds } }).populate('credential')
+     *
+     * @param {Array<string>} entitiesIds - Array of entity IDs
+     * @returns {Promise<Array>} Array of entity objects
+     */
+    async findEntitiesByIds(entitiesIds) {
+        const entities = await this.prisma.entity.findMany({
+            where: { id: { in: entitiesIds } },
+            include: { credential: true },
+        });
+
+        return entities.map((e) => ({
+            id: e.id,
+            accountId: e.accountId,
+            credential: e.credential,
+            userId: e.userId,
+            name: e.name,
+            externalId: e.externalId,
+            moduleName: e.moduleName,
+        }));
+    }
+
+    /**
+     * Find entities by user ID and module name
+     * Replaces: Entity.find({ user: userId, moduleName: moduleName }).populate('credential')
+     *
+     * @param {string} userId - User ID
+     * @param {string} moduleName - Module name
+     * @returns {Promise<Array>} Array of entity objects
+     */
+    async findEntitiesByUserIdAndModuleName(userId, moduleName) {
+        const entities = await this.prisma.entity.findMany({
+            where: {
+                userId,
+                moduleName,
+            },
+            include: { credential: true },
+        });
+
+        return entities.map((e) => ({
+            id: e.id,
+            accountId: e.accountId,
+            credential: e.credential,
+            userId: e.userId,
+            name: e.name,
+            externalId: e.externalId,
+            moduleName: e.moduleName,
+        }));
+    }
+
+    /**
+     * Remove credential reference from entity
+     * Replaces: Entity.updateOne({ _id: entityId }, { $unset: { credential: "" } })
+     *
+     * @param {string} entityId - Entity ID
+     * @returns {Promise<boolean>} Success indicator
+     */
+    async unsetCredential(entityId) {
+        await this.prisma.entity.update({
+            where: { id: entityId },
+            data: { credentialId: null },
+        });
+
+        return true;
+    }
+
+    /**
+     * Find entity by filter criteria
+     * Replaces: Entity.findOne(filter).populate('credential')
+     *
+     * @param {Object} filter - Filter criteria
+     * @returns {Promise<Object|null>} Entity object or null
+     */
+    async findEntity(filter) {
+        const where = this._convertFilterToWhere(filter);
+        const entity = await this.prisma.entity.findFirst({
+            where,
+            include: { credential: true },
+        });
+
+        if (!entity) {
+            return null;
+        }
+
+        return {
+            id: entity.id,
+            accountId: entity.accountId,
+            credential: entity.credential,
+            userId: entity.userId,
+            name: entity.name,
+            externalId: entity.externalId,
+            moduleName: entity.moduleName,
+        };
+    }
+
+    /**
+     * Create a new entity
+     * Replaces: Entity.create(entityData)
+     *
+     * @param {Object} entityData - Entity data
+     * @returns {Promise<Object>} Created entity object
+     */
+    async createEntity(entityData) {
+        // Convert Mongoose-style fields to Prisma
+        const data = {
+            userId: entityData.user || entityData.userId,
+            credentialId: entityData.credential || entityData.credentialId,
+            name: entityData.name,
+            moduleName: entityData.moduleName,
+            externalId: entityData.externalId,
+            accountId: entityData.accountId,
+        };
+
+        const entity = await this.prisma.entity.create({
+            data,
+            include: { credential: true },
+        });
+
+        return {
+            id: entity.id,
+            accountId: entity.accountId,
+            credential: entity.credential,
+            userId: entity.userId,
+            name: entity.name,
+            externalId: entity.externalId,
+            moduleName: entity.moduleName,
+        };
+    }
+
+    /**
+     * Update an entity by ID
+     * Replaces: Entity.findByIdAndUpdate(entityId, updates, { new: true })
+     *
+     * @param {string} entityId - Entity ID to update
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object|null>} Updated entity object or null if not found
+     */
+    async updateEntity(entityId, updates) {
+        // Convert Mongoose-style fields to Prisma
+        const data = {};
+        if (updates.user !== undefined) data.userId = updates.user;
+        if (updates.userId !== undefined) data.userId = updates.userId;
+        if (updates.credential !== undefined)
+            data.credentialId = updates.credential;
+        if (updates.credentialId !== undefined)
+            data.credentialId = updates.credentialId;
+        if (updates.name !== undefined) data.name = updates.name;
+        if (updates.moduleName !== undefined)
+            data.moduleName = updates.moduleName;
+        if (updates.externalId !== undefined)
+            data.externalId = updates.externalId;
+        if (updates.accountId !== undefined) data.accountId = updates.accountId;
+
+        try {
+            const entity = await this.prisma.entity.update({
+                where: { id: entityId },
+                data,
+                include: { credential: true },
+            });
+
+            return {
+                id: entity.id,
+                accountId: entity.accountId,
+                credential: entity.credential,
+                userId: entity.userId,
+                name: entity.name,
+                externalId: entity.externalId,
+                moduleName: entity.moduleName,
+            };
+        } catch (error) {
+            if (error.code === 'P2025') {
+                // Record not found
+                return null;
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Delete an entity by ID
+     * Replaces: Entity.deleteOne({ _id: entityId })
+     *
+     * @param {string} entityId - Entity ID to delete
+     * @returns {Promise<boolean>} True if deleted successfully
+     */
+    async deleteEntity(entityId) {
+        try {
+            await this.prisma.entity.delete({
+                where: { id: entityId },
+            });
+            return true;
+        } catch (error) {
+            if (error.code === 'P2025') {
+                // Record not found
+                return false;
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Convert Mongoose-style filter to Prisma where clause
+     * @private
+     * @param {Object} filter - Mongoose filter
+     * @returns {Object} Prisma where clause
+     */
+    _convertFilterToWhere(filter) {
+        const where = {};
+
+        // Handle _id field (Mongoose uses _id, Prisma uses id)
+        if (filter._id) {
+            where.id = filter._id;
+        }
+
+        // Handle user field (Mongoose uses user, Prisma uses userId)
+        if (filter.user) {
+            where.userId = filter.user;
+        }
+
+        // Handle credential field (Mongoose uses credential, Prisma uses credentialId)
+        if (filter.credential) {
+            where.credentialId = filter.credential;
+        }
+
+        // Copy other fields directly
+        if (filter.id) where.id = filter.id;
+        if (filter.userId) where.userId = filter.userId;
+        if (filter.credentialId) where.credentialId = filter.credentialId;
+        if (filter.name) where.name = filter.name;
+        if (filter.moduleName) where.moduleName = filter.moduleName;
+        if (filter.externalId) where.externalId = filter.externalId;
+
+        return where;
+    }
+}
+
+module.exports = { ModuleRepository };

package/modules/requester/api-key.js

@@ -0,0 +1,52 @@
+const { Requester } = require('./requester');
+const { get } = require('../../assertions');
+const { ModuleConstants } = require('../ModuleConstants');
+
+
+class ApiKeyRequester extends Requester {
+
+    static requesterType = ModuleConstants.authType.apiKey;
+
+    constructor(params) {
+        super(params);
+        this.requesterType = 'apiKey';
+
+        // Use snake_case convention consistent with OAuth2Requester and BasicAuthRequester
+        this.api_key_name = get(params, 'api_key_name', 'key');
+        this.api_key = get(params, 'api_key', null);
+
+        // Backward compatibility: support old naming convention
+        if (!this.api_key && params.API_KEY_VALUE) {
+            this.api_key = params.API_KEY_VALUE;
+        }
+        if (!this.api_key_name && params.API_KEY_NAME) {
+            this.api_key_name = params.API_KEY_NAME;
+        }
+    }
+
+    async addAuthHeaders(headers) {
+        if (this.api_key) {
+            headers[this.api_key_name] = this.api_key;
+        }
+        return headers;
+    }
+
+    isAuthenticated() {
+        return (
+            this.api_key !== null &&
+            this.api_key !== undefined &&
+            typeof this.api_key === 'string' &&
+            this.api_key.trim().length > 0
+        );
+    }
+
+    setApiKey(api_key) {
+        this.api_key = api_key;
+    }
+
+    setApiKeyName(api_key_name) {
+        this.api_key_name = api_key_name;
+    }
+}
+
+module.exports = { ApiKeyRequester };

package/{module-plugin → modules}/requester/requester.js

@@ -108,6 +108,7 @@ class Requester extends Delegate {
     }
 
     async _post(options, stringify = true) {
+        console.log('options', options);
         const fetchOptions = {
             method: 'POST',
             credentials: 'include',

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

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

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

@@ -1,19 +1,23 @@
 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,
-    getName: function() {return config.name},
+    getAuthorizationRequirements: () => ({
+        url: 'http://localhost:3000/redirect/anapi',
+        type: 'oauth2',
+    }),
+    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 },
@@ -26,14 +30,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/modules/tests/doubles/test-module-factory.js

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,39 @@
+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));
+    }
+
+    async findEntity(filter) {
+        if (!filter || typeof filter !== 'object') {
+            return null;
+        }
+
+        if (filter.id && this.entities.has(filter.id)) {
+            return this.entities.get(filter.id);
+        }
+
+        if (filter.externalId) {
+            for (const entity of this.entities.values()) {
+                if (entity.externalId === filter.externalId) {
+                    return entity;
+                }
+            }
+        }
+
+        return null;
+    }
+}
+
+module.exports = { TestModuleRepository }; 

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

@@ -0,0 +1,32 @@
+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.moduleName, 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

@@ -0,0 +1,71 @@
+const { Module } = require('../module');
+
+class GetEntityOptionsById {
+    /**
+     * @param {Object} params
+     * @param {import('../repositories/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository
+     * @param {} params.moduleDefinitions
+     */
+    constructor({ moduleRepository, moduleDefinitions }) {
+        this.moduleRepository = moduleRepository;
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    /**
+     * Retrieve entity options for a given entity
+     *
+     * @param {string|number} entityId - Entity ID to retrieve options for
+     * @param {string|number|import('../../user/user').User} userIdOrUser - User ID or User object for validation
+     * @returns {Promise<Object>} Entity options
+     */
+    async execute(entityId, userIdOrUser) {
+        // Support both userId (backward compatible) and User object (new pattern)
+        const userId = typeof userIdOrUser === 'object' && userIdOrUser?.getId
+            ? userIdOrUser.getId()
+            : userIdOrUser;
+
+        const entity = await this.moduleRepository.findEntityById(
+            entityId,
+            userId
+        );
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        // Validate entity ownership
+        const isOwned = typeof userIdOrUser === 'object' && userIdOrUser?.ownsUserId
+            ? userIdOrUser.ownsUserId(entity.userId)
+            : entity.userId?.toString() === userId?.toString();
+
+        if (!isOwned) {
+            throw new Error(
+                `Entity ${entityId} does not belong to user ${userId}`
+            );
+        }
+
+        const entityType = entity.moduleName;
+        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

@@ -0,0 +1,34 @@
+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

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