@friggframework/core 2.0.0-next.12 → 2.0.0-next.121

package/integrations/repositories/integration-mapping-repository.js

@@ -0,0 +1,185 @@
+const { prisma } = require('../../database/prisma');
+const { MappingAlreadyExistsError } = require('../../errors');
+const {
+    IntegrationMappingRepositoryInterface,
+} = require('./integration-mapping-repository-interface');
+
+/**
+ * Prisma-based Integration Mapping Repository
+ * Handles persistence of integration mappings used for data transformation
+ *
+ * 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
+ * - IntegrationMapping.findBy() → findFirst with where clause
+ * - IntegrationMapping.upsert() → Prisma upsert with unique constraint
+ * - mapping data stored in JSON field
+ */
+class IntegrationMappingRepository extends IntegrationMappingRepositoryInterface {
+    constructor(prismaClient = prisma) {
+        super();
+        this.prisma = prismaClient; // Allow injection for testing
+    }
+
+    /**
+     * Find mapping by integration ID and source ID
+     * Replaces: IntegrationMapping.findBy(integrationId, sourceId)
+     *
+     * @param {string} integrationId - The integration ID
+     * @param {string} sourceId - The source ID for lookup
+     * @returns {Promise<Object|null>} The mapping object or null
+     */
+    async findMappingBy(integrationId, sourceId) {
+        return await this.prisma.integrationMapping.findFirst({
+            where: {
+                integrationId,
+                sourceId,
+            },
+        });
+    }
+
+    /**
+     * Create or update a mapping
+     * Replaces: IntegrationMapping.upsert(integrationId, sourceId, mapping)
+     *
+     * @param {string} integrationId - The integration ID
+     * @param {string} sourceId - The source ID for lookup
+     * @param {Object} mapping - The mapping data
+     * @returns {Promise<Object>} The created or updated mapping document
+     */
+    async upsertMapping(integrationId, sourceId, mapping) {
+        return await this.prisma.integrationMapping.upsert({
+            where: {
+                integrationId_sourceId: {
+                    integrationId,
+                    sourceId,
+                },
+            },
+            update: {
+                mapping,
+            },
+            create: {
+                integrationId,
+                sourceId,
+                mapping,
+            },
+        });
+    }
+
+    /**
+     * Insert a mapping; fails if (integrationId, sourceId) already exists
+     *
+     * @param {string} integrationId - The integration ID
+     * @param {string} sourceId - The source ID
+     * @param {Object} mapping - The mapping data
+     * @returns {Promise<Object>} The created mapping document
+     * @throws {MappingAlreadyExistsError} If the pair already exists
+     */
+    async createMapping(integrationId, sourceId, mapping) {
+        try {
+            return await this.prisma.integrationMapping.create({
+                data: {
+                    integrationId,
+                    sourceId,
+                    mapping,
+                },
+            });
+        } catch (error) {
+            if (error.code === 'P2002') {
+                throw new MappingAlreadyExistsError(integrationId, sourceId, {
+                    cause: error,
+                });
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Find all mappings for an integration
+     * Replaces: IntegrationMapping.find({ integration: integrationId })
+     *
+     * @param {string} integrationId - The integration ID
+     * @returns {Promise<Array>} Array of mapping documents
+     */
+    async findMappingsByIntegration(integrationId) {
+        return await this.prisma.integrationMapping.findMany({
+            where: { integrationId },
+        });
+    }
+
+    /**
+     * Delete a mapping by integration and source ID
+     * Replaces: IntegrationMapping.deleteOne({ integration, sourceId })
+     *
+     * @param {string} integrationId - The integration ID
+     * @param {string} sourceId - The source ID
+     * @returns {Promise<Object>} The deletion result
+     */
+    async deleteMapping(integrationId, sourceId) {
+        try {
+            await this.prisma.integrationMapping.delete({
+                where: {
+                    integrationId_sourceId: {
+                        integrationId,
+                        sourceId,
+                    },
+                },
+            });
+            return { acknowledged: true, deletedCount: 1 };
+        } catch (error) {
+            if (error.code === 'P2025') {
+                // Record not found
+                return { acknowledged: true, deletedCount: 0 };
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Delete all mappings for an integration
+     * Replaces: IntegrationMapping.deleteMany({ integration: integrationId })
+     *
+     * @param {string} integrationId - The integration ID
+     * @returns {Promise<Object>} The deletion result
+     */
+    async deleteMappingsByIntegration(integrationId) {
+        const result = await this.prisma.integrationMapping.deleteMany({
+            where: { integrationId },
+        });
+
+        return {
+            acknowledged: true,
+            deletedCount: result.count,
+        };
+    }
+
+    /**
+     * Find mapping by ID
+     * @param {string} id - Mapping ID
+     * @returns {Promise<Object|null>} Mapping object or null
+     */
+    async findMappingById(id) {
+        return await this.prisma.integrationMapping.findUnique({
+            where: { id },
+        });
+    }
+
+    /**
+     * Update mapping by ID
+     * @param {string} id - Mapping ID
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object>} Updated mapping object
+     */
+    async updateMapping(id, updates) {
+        return await this.prisma.integrationMapping.update({
+            where: { id },
+            data: updates,
+        });
+    }
+}
+
+module.exports = { IntegrationMappingRepository };

package/integrations/repositories/integration-repository-documentdb.js

@@ -0,0 +1,354 @@
+const { prisma } = require('../../database/prisma');
+const {
+    toObjectId,
+    toObjectIdArray,
+    fromObjectId,
+    findMany,
+    findManyDrained,
+    findOne,
+    insertOne,
+    updateOne,
+    deleteOne,
+} = require('../../database/documentdb-utils');
+const {
+    IntegrationRepositoryInterface,
+} = require('./integration-repository-interface');
+const { validateConfigPatch } = require('./config-patch-shared');
+
+class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+    }
+
+    async findIntegrationsByUserId(userId) {
+        const objectId = toObjectId(userId);
+        const filter = objectId ? { userId: objectId } : {};
+        const records = await findMany(this.prisma, 'Integration', filter);
+        return records.map((doc) => this._mapIntegration(doc));
+    }
+
+    async findIntegrations({ type, status } = {}) {
+        const filter = {};
+        if (type) {
+            filter['config.type'] = type;
+        }
+        if (status) {
+            filter.status = status;
+        }
+        const records = await findMany(this.prisma, 'Integration', filter);
+        return records.map((doc) => this._mapIntegration(doc));
+    }
+
+    async findIntegrationsByEntityId(entityId) {
+        const objectId = toObjectId(entityId);
+        if (!objectId) return [];
+        const records = await findMany(this.prisma, 'Integration', {
+            entityIds: objectId,
+        });
+        return records.map((doc) => this._mapIntegration(doc));
+    }
+
+    async deleteIntegrationById(integrationId) {
+        const objectId = toObjectId(integrationId);
+        if (!objectId) return { acknowledged: true, deletedCount: 0 };
+        const result = await deleteOne(this.prisma, 'Integration', { _id: objectId });
+        const deleted = result?.n ?? 0;
+        return { acknowledged: true, deletedCount: deleted };
+    }
+
+    async findIntegrationByName(name) {
+        const doc = await findOne(this.prisma, 'Integration', { 'config.type': name });
+        if (!doc) {
+            throw new Error(`Integration with name ${name} not found`);
+        }
+        return this._mapIntegration(doc);
+    }
+
+    async findIntegrationById(id) {
+        const objectId = toObjectId(id);
+        if (!objectId) {
+            throw new Error(`Integration with id ${id} not found`);
+        }
+        const doc = await findOne(this.prisma, 'Integration', { _id: objectId });
+        if (!doc) {
+            throw new Error(`Integration with id ${id} not found`);
+        }
+        return this._mapIntegration(doc);
+    }
+
+    async updateIntegrationStatus(integrationId, status) {
+        const objectId = toObjectId(integrationId);
+        if (!objectId) return false;
+        await updateOne(
+            this.prisma,
+            'Integration',
+            { _id: objectId },
+            {
+                $set: { status, updatedAt: new Date() },
+            }
+        );
+        return true;
+    }
+
+    async updateIntegrationMessages(
+        integrationId,
+        messageType,
+        messageTitle,
+        messageBody,
+        messageTimestamp
+    ) {
+        const objectId = toObjectId(integrationId);
+        if (!objectId) {
+            throw new Error(`Integration ${integrationId} not found`);
+        }
+        const existing = await findOne(this.prisma, 'Integration', { _id: objectId });
+        if (!existing) {
+            throw new Error(`Integration ${integrationId} not found`);
+        }
+        const messages = this._extractMessages(existing);
+        const list = Array.isArray(messages[messageType]) ? [...messages[messageType]] : [];
+        list.push({
+            title: messageTitle ?? null,
+            message: messageBody,
+            timestamp: messageTimestamp,
+        });
+        const updatedMessages = { ...messages, [messageType]: list };
+        await updateOne(
+            this.prisma,
+            'Integration',
+            { _id: objectId },
+            {
+                $set: {
+                    messages: updatedMessages,
+                    errors: updatedMessages.errors ?? [],
+                    warnings: updatedMessages.warnings ?? [],
+                    info: updatedMessages.info ?? [],
+                    logs: updatedMessages.logs ?? [],
+                    updatedAt: new Date(),
+                },
+            }
+        );
+        return true;
+    }
+
+    async createIntegration(entities, userId, config) {
+        const now = new Date();
+        const document = {
+            userId: toObjectId(userId) || null,
+            config,
+            version: '0.0.0',
+            status: 'IN_CREATION',
+            entityIds: toObjectIdArray(entities),
+            messages: { errors: [], warnings: [], info: [], logs: [] },
+            errors: [],
+            warnings: [],
+            info: [],
+            logs: [],
+            createdAt: now,
+            updatedAt: now,
+        };
+        const insertedId = await insertOne(this.prisma, 'Integration', document);
+        const created = await findOne(this.prisma, 'Integration', { _id: insertedId });
+        if (!created) {
+            console.error('[IntegrationRepositoryDocumentDB] Integration not found after insert', {
+                insertedId: fromObjectId(insertedId),
+                userId,
+                config,
+            });
+            throw new Error(
+                'Failed to create integration: Document not found after insert. ' +
+                'This indicates a database consistency issue.'
+            );
+        }
+        return this._mapIntegration(created);
+    }
+
+    async addEntitiesToIntegration(integrationId, entityIds) {
+        const objectId = toObjectId(integrationId);
+        if (!objectId) return null;
+        const result = await updateOne(
+            this.prisma,
+            'Integration',
+            { _id: objectId },
+            {
+                $addToSet: { entityIds: { $each: toObjectIdArray(entityIds) } },
+                $set: { updatedAt: { $date: new Date().toISOString() } },
+            }
+        );
+        if (!result?.n) return null;
+        return this.findIntegrationById(integrationId);
+    }
+
+    async removeEntitiesFromIntegration(integrationId, entityIds) {
+        const objectId = toObjectId(integrationId);
+        if (!objectId) return null;
+        const result = await updateOne(
+            this.prisma,
+            'Integration',
+            { _id: objectId },
+            {
+                $pullAll: { entityIds: toObjectIdArray(entityIds) },
+                $set: { updatedAt: { $date: new Date().toISOString() } },
+            }
+        );
+        if (!result?.n) return null;
+        return this.findIntegrationById(integrationId);
+    }
+
+    async findIntegrationByUserId(userId) {
+        const objectId = toObjectId(userId);
+        if (!objectId) return null;
+        const doc = await findOne(this.prisma, 'Integration', { userId: objectId });
+        return doc ? this._mapIntegration(doc) : null;
+    }
+
+    async updateIntegrationConfig(integrationId, config) {
+        if (config === null || config === undefined) {
+            throw new Error('Config parameter is required');
+        }
+        const objectId = toObjectId(integrationId);
+        if (!objectId) {
+            throw new Error(`Integration with id ${integrationId} not found`);
+        }
+        await updateOne(
+            this.prisma,
+            'Integration',
+            { _id: objectId },
+            {
+                $set: {
+                    config,
+                    updatedAt: new Date(),
+                },
+            }
+        );
+        const updated = await findOne(this.prisma, 'Integration', { _id: objectId });
+        if (!updated) {
+            console.error('[IntegrationRepositoryDocumentDB] Integration not found after update', {
+                integrationId: fromObjectId(objectId),
+                config,
+            });
+            throw new Error(
+                'Failed to update integration: Document not found after update. ' +
+                'This indicates a database consistency issue.'
+            );
+        }
+        return this._mapIntegration(updated);
+    }
+
+    /**
+     * Atomically merge a patch into the existing config with a per-key
+     * $set (config.<k> for each patch key), then re-read to shape the
+     * return value — DocumentDB's raw update command doesn't return the
+     * post-update document directly.
+     *
+     * @param {string} integrationId - Integration ID
+     * @param {Object} patch - Keys to merge into the existing config
+     * @returns {Promise<Object>} Updated integration object
+     */
+    async patchIntegrationConfig(integrationId, patch) {
+        validateConfigPatch(patch);
+        const objectId = toObjectId(integrationId);
+        if (!objectId) {
+            throw new Error(`Integration with id ${integrationId} not found`);
+        }
+
+        const $set = { updatedAt: new Date() };
+        for (const [key, value] of Object.entries(patch)) {
+            $set[`config.${key}`] = value;
+        }
+
+        const result = await updateOne(
+            this.prisma,
+            'Integration',
+            { _id: objectId },
+            { $set }
+        );
+        if (result.writeErrors?.length) {
+            throw new Error(
+                `Failed to patch integration config: ${result.writeErrors[0].errmsg}`
+            );
+        }
+        if (!result.n) {
+            throw new Error(`Integration with id ${integrationId} not found`);
+        }
+
+        const updated = await findOne(this.prisma, 'Integration', { _id: objectId });
+        if (!updated) {
+            console.error('[IntegrationRepositoryDocumentDB] Integration not found after update', {
+                integrationId: fromObjectId(objectId),
+                patch,
+            });
+            throw new Error(
+                'Failed to update integration: Document not found after update. ' +
+                'This indicates a database consistency issue.'
+            );
+        }
+        return this._mapIntegration(updated);
+    }
+
+    // Drain the full cursor so a deployment-wide report is never truncated.
+    async findAllForReport({ status, userId } = {}) {
+        const filter = {};
+        if (status) filter.status = status;
+        if (userId !== undefined && userId !== null) {
+            const objectId = toObjectId(userId);
+            // Invalid userId means no matches — don't fall through to an unfiltered whole-deployment query.
+            if (!objectId) return [];
+            filter.userId = objectId;
+        }
+
+        const docs = await findManyDrained(this.prisma, 'Integration', filter);
+
+        return docs.map((doc) => {
+            const errors = this._extractReportErrors(doc);
+            return {
+                id: fromObjectId(doc?._id),
+                type: doc?.config?.type ?? null,
+                status: doc?.status ?? null,
+                userId: fromObjectId(doc?.userId) ?? null,
+                version: doc?.version ?? null,
+                errorCount: Array.isArray(errors) ? errors.length : 0,
+                moduleCount: Array.isArray(doc?.entityIds)
+                    ? doc.entityIds.length
+                    : 0,
+                createdAt: doc?.createdAt ?? null,
+                updatedAt: doc?.updatedAt ?? null,
+            };
+        });
+    }
+
+    _extractReportErrors(doc) {
+        if (Array.isArray(doc?.errors)) return doc.errors;
+        if (Array.isArray(doc?.messages?.errors)) return doc.messages.errors;
+        return [];
+    }
+
+    _mapIntegration(doc) {
+        const messages = this._extractMessages(doc);
+        return {
+            id: fromObjectId(doc?._id),
+            entitiesIds: (doc?.entityIds || []).map((value) => fromObjectId(value)),
+            userId: fromObjectId(doc?.userId),
+            config: doc?.config ?? null,
+            version: doc?.version ?? null,
+            status: doc?.status ?? null,
+            messages,
+            createdAt: doc?.createdAt ?? null,
+        };
+    }
+
+    _extractMessages(doc) {
+        const base = doc?.messages && typeof doc.messages === 'object' ? doc.messages : {};
+        return {
+            errors: base.errors ?? doc?.errors ?? [],
+            warnings: base.warnings ?? doc?.warnings ?? [],
+            info: base.info ?? doc?.info ?? [],
+            logs: base.logs ?? doc?.logs ?? [],
+        };
+    }
+}
+
+module.exports = { IntegrationRepositoryDocumentDB };
+
+

package/integrations/repositories/integration-repository-factory.js

@@ -0,0 +1,51 @@
+const { IntegrationRepositoryMongo } = require('./integration-repository-mongo');
+const { IntegrationRepositoryPostgres } = require('./integration-repository-postgres');
+const {
+    IntegrationRepositoryDocumentDB,
+} = require('./integration-repository-documentdb');
+const config = require('../../database/config');
+
+/**
+ * Integration Repository Factory
+ * Creates the appropriate repository adapter based on database type
+ *
+ * This implements the Factory pattern for Hexagonal Architecture:
+ * - Reads database type from app definition (backend/index.js)
+ * - Returns correct adapter (MongoDB or PostgreSQL)
+ * - Provides clear error for unsupported databases
+ *
+ * Usage:
+ * ```javascript
+ * const repository = createIntegrationRepository();
+ * ```
+ *
+ * @returns {IntegrationRepositoryInterface} Configured repository adapter
+ * @throws {Error} If database type is not supported
+ */
+function createIntegrationRepository() {
+    const dbType = config.DB_TYPE;
+
+    switch (dbType) {
+        case 'mongodb':
+            return new IntegrationRepositoryMongo();
+
+        case 'postgresql':
+            return new IntegrationRepositoryPostgres();
+
+        case 'documentdb':
+            return new IntegrationRepositoryDocumentDB();
+
+        default:
+            throw new Error(
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
+            );
+    }
+}
+
+module.exports = {
+    createIntegrationRepository,
+    // Export adapters for direct testing
+    IntegrationRepositoryMongo,
+    IntegrationRepositoryPostgres,
+    IntegrationRepositoryDocumentDB,
+};