@friggframework/core 2.0.0-next.41 → 2.0.0-next.42

package/modules/repositories/module-repository-interface.js

@@ -0,0 +1,129 @@
+/**
+ * Module Repository Interface
+ * Abstract base class defining the contract for Entity (module) persistence adapters
+ *
+ * This follows the Port in Hexagonal Architecture:
+ * - Domain layer depends on this abstraction
+ * - Concrete adapters implement this interface
+ * - Use cases receive repositories via dependency injection
+ *
+ * Note: Currently, Entity model has identical structure across MongoDB and PostgreSQL,
+ * so ModuleRepository serves both. This interface exists for consistency and
+ * future-proofing if database-specific implementations become needed.
+ *
+ * @abstract
+ */
+class ModuleRepositoryInterface {
+    /**
+     * Find entity by ID with credential
+     *
+     * @param {string|number} entityId - Entity ID
+     * @returns {Promise<Object>} Entity object
+     * @abstract
+     */
+    async findEntityById(entityId) {
+        throw new Error(
+            'Method findEntityById must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find all entities for a user
+     *
+     * @param {string|number} userId - User ID
+     * @returns {Promise<Array>} Array of entity objects
+     * @abstract
+     */
+    async findEntitiesByUserId(userId) {
+        throw new Error(
+            'Method findEntitiesByUserId must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find entities by IDs
+     *
+     * @param {Array<string|number>} entitiesIds - Array of entity IDs
+     * @returns {Promise<Array>} Array of entity objects
+     * @abstract
+     */
+    async findEntitiesByIds(entitiesIds) {
+        throw new Error(
+            'Method findEntitiesByIds must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find entities by user ID and module name
+     *
+     * @param {string|number} userId - User ID
+     * @param {string} moduleName - Module name
+     * @returns {Promise<Array>} Array of entity objects
+     * @abstract
+     */
+    async findEntitiesByUserIdAndModuleName(userId, moduleName) {
+        throw new Error(
+            'Method findEntitiesByUserIdAndModuleName must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Unset credential from entity
+     *
+     * @param {string|number} entityId - Entity ID
+     * @returns {Promise<Object>} Update result
+     * @abstract
+     */
+    async unsetCredential(entityId) {
+        throw new Error(
+            'Method unsetCredential must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find entity by filter
+     *
+     * @param {Object} filter - Filter criteria
+     * @returns {Promise<Object|null>} Entity object or null
+     * @abstract
+     */
+    async findEntity(filter) {
+        throw new Error('Method findEntity must be implemented by subclass');
+    }
+
+    /**
+     * Create a new entity
+     *
+     * @param {Object} entityData - Entity data
+     * @returns {Promise<Object>} Created entity object
+     * @abstract
+     */
+    async createEntity(entityData) {
+        throw new Error('Method createEntity must be implemented by subclass');
+    }
+
+    /**
+     * Update entity by ID
+     *
+     * @param {string|number} entityId - Entity ID to update
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object>} Updated entity object
+     * @abstract
+     */
+    async updateEntity(entityId, updates) {
+        throw new Error('Method updateEntity must be implemented by subclass');
+    }
+
+    /**
+     * Delete entity by ID
+     *
+     * @param {string|number} entityId - Entity ID to delete
+     * @returns {Promise<Object>} Deletion result
+     * @abstract
+     */
+    async deleteEntity(entityId) {
+        throw new Error('Method deleteEntity must be implemented by subclass');
+    }
+}
+
+module.exports = { ModuleRepositoryInterface };

package/modules/repositories/module-repository-mongo.js

@@ -0,0 +1,386 @@
+const { prisma } = require('../../database/prisma');
+const { ModuleRepositoryInterface } = require('./module-repository-interface');
+
+/**
+ * MongoDB Module Repository Adapter
+ * Handles Entity model operations for external service entities with MongoDB
+ *
+ * MongoDB-specific characteristics:
+ * - Uses String IDs (ObjectId)
+ * - No ID conversion needed (IDs are already strings)
+ * - entity.__t (discriminator) → entity.subType
+ */
+class ModuleRepositoryMongo extends ModuleRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+    }
+
+    /**
+     * Convert any value to string (handles null/undefined)
+     * @private
+     * @param {*} value - Value to convert
+     * @returns {string|null|undefined} String value or null/undefined
+     */
+    _toString(value) {
+        if (value === null || value === undefined) return value;
+        return String(value);
+    }
+
+    /**
+     * Fetch credential by ID separately to ensure encryption extension processes it
+     * This fixes the bug where credentials fetched via include bypass decryption
+     * @private
+     * @param {string|null|undefined} credentialId - Credential ID
+     * @returns {Promise<Object|null>} Decrypted credential or null
+     */
+    async _fetchCredential(credentialId) {
+        if (!credentialId) return null;
+
+        const credential = await this.prisma.credential.findUnique({
+            where: { id: credentialId },
+        });
+
+        return credential;
+    }
+
+    /**
+     * Fetch multiple credentials in bulk separately to ensure decryption
+     * More efficient than fetching one-by-one for arrays of entities
+     * @private
+     * @param {Array<string>} credentialIds - Array of credential IDs
+     * @returns {Promise<Map<string, Object>>} Map of credentialId -> credential object
+     */
+    async _fetchCredentialsBulk(credentialIds) {
+        if (!credentialIds || credentialIds.length === 0) {
+            return new Map();
+        }
+
+        const validIds = credentialIds.filter(id => id !== null && id !== undefined);
+
+        if (validIds.length === 0) {
+            return new Map();
+        }
+
+        const credentials = await this.prisma.credential.findMany({
+            where: { id: { in: validIds } },
+        });
+
+        const credentialMap = new Map();
+        for (const credential of credentials) {
+            credentialMap.set(credential.id, credential);
+        }
+
+        return credentialMap;
+    }
+
+    /**
+     * Find entity by ID with credential
+     * Replaces: Entity.findById(entityId).populate('credential')
+     *
+     * @param {string} entityId - Entity ID
+     * @returns {Promise<Object>} Entity object with string IDs
+     * @throws {Error} If entity not found
+     */
+    async findEntityById(entityId) {
+        const entity = await this.prisma.entity.findUnique({
+            where: { id: entityId },
+        });
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        const credential = await this._fetchCredential(entity.credentialId);
+
+        return {
+            id: entity.id,
+            accountId: entity.accountId,
+            credential,
+            userId: entity.userId,
+            name: entity.name,
+            externalId: entity.externalId,
+            type: entity.subType,
+            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 with string IDs
+     */
+    async findEntitiesByUserId(userId) {
+        const entities = await this.prisma.entity.findMany({
+            where: { userId },
+        });
+
+        const credentialIds = entities.map(e => e.credentialId).filter(Boolean);
+        const credentialMap = await this._fetchCredentialsBulk(credentialIds);
+
+        return entities.map((e) => ({
+            id: e.id,
+            accountId: e.accountId,
+            credential: credentialMap.get(e.credentialId) || null,
+            userId: e.userId,
+            name: e.name,
+            externalId: e.externalId,
+            type: e.subType,
+            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 with string IDs
+     */
+    async findEntitiesByIds(entitiesIds) {
+        const entities = await this.prisma.entity.findMany({
+            where: { id: { in: entitiesIds } },
+        });
+
+        const credentialIds = entities.map(e => e.credentialId).filter(Boolean);
+        const credentialMap = await this._fetchCredentialsBulk(credentialIds);
+
+        return entities.map((e) => ({
+            id: e.id,
+            accountId: e.accountId,
+            credential: credentialMap.get(e.credentialId) || null,
+            userId: e.userId,
+            name: e.name,
+            externalId: e.externalId,
+            type: e.subType,
+            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 with string IDs
+     */
+    async findEntitiesByUserIdAndModuleName(userId, moduleName) {
+        const entities = await this.prisma.entity.findMany({
+            where: {
+                userId,
+                moduleName,
+            },
+        });
+
+        const credentialIds = entities.map(e => e.credentialId).filter(Boolean);
+        const credentialMap = await this._fetchCredentialsBulk(credentialIds);
+
+        return entities.map((e) => ({
+            id: e.id,
+            accountId: e.accountId,
+            credential: credentialMap.get(e.credentialId) || null,
+            userId: e.userId,
+            name: e.name,
+            externalId: e.externalId,
+            type: e.subType,
+            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 with string IDs or null
+     */
+    async findEntity(filter) {
+        const where = this._convertFilterToWhere(filter);
+        const entity = await this.prisma.entity.findFirst({
+            where,
+        });
+
+        if (!entity) {
+            return null;
+        }
+
+        const credential = await this._fetchCredential(entity.credentialId);
+
+        return {
+            id: entity.id,
+            accountId: entity.accountId,
+            credential,
+            userId: entity.userId,
+            name: entity.name,
+            externalId: entity.externalId,
+            type: entity.subType,
+            moduleName: entity.moduleName,
+        };
+    }
+
+    /**
+     * Create a new entity
+     * Replaces: Entity.create(entityData)
+     *
+     * @param {Object} entityData - Entity data
+     * @returns {Promise<Object>} Created entity object with string IDs
+     */
+    async createEntity(entityData) {
+        const data = {
+            userId: entityData.user || entityData.userId,
+            credentialId: entityData.credential || entityData.credentialId,
+            subType: entityData.type || entityData.subType,
+            name: entityData.name,
+            moduleName: entityData.moduleName,
+            externalId: entityData.externalId,
+            accountId: entityData.accountId,
+        };
+
+        const entity = await this.prisma.entity.create({
+            data,
+        });
+
+        const credential = await this._fetchCredential(entity.credentialId);
+
+        return {
+            id: entity.id,
+            accountId: entity.accountId,
+            credential,
+            userId: entity.userId,
+            name: entity.name,
+            externalId: entity.externalId,
+            type: entity.subType,
+            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 with string IDs or null if not found
+     */
+    async updateEntity(entityId, updates) {
+        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.type !== undefined) data.subType = updates.type;
+        if (updates.subType !== undefined) data.subType = updates.subType;
+        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,
+            });
+
+            const credential = await this._fetchCredential(entity.credentialId);
+
+            return {
+                id: entity.id,
+                accountId: entity.accountId,
+                credential,
+                userId: entity.userId,
+                name: entity.name,
+                externalId: entity.externalId,
+                type: entity.subType,
+                moduleName: entity.moduleName,
+            };
+        } catch (error) {
+            if (error.code === 'P2025') {
+                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 = this._toString(filter.externalId);
+        if (filter.subType) where.subType = filter.subType;
+
+        return where;
+    }
+}
+
+module.exports = { ModuleRepositoryMongo };