@friggframework/core 2.0.0-next.10 → 2.0.0-next.101

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

@@ -0,0 +1,227 @@
+const { prisma } = require('../../database/prisma');
+const {
+    IntegrationMappingRepositoryInterface,
+} = require('./integration-mapping-repository-interface');
+
+/**
+ * PostgreSQL Integration Mapping Repository Adapter
+ * Handles persistence of integration mappings used for data transformation
+ *
+ * PostgreSQL-specific characteristics:
+ * - Uses Int IDs with autoincrement
+ * - Requires ID conversion: String (app layer) ↔ Int (database)
+ * - All returned IDs are converted to strings for application layer consistency
+ */
+class IntegrationMappingRepositoryPostgres extends IntegrationMappingRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+    }
+
+    /**
+     * Convert string ID to integer for PostgreSQL queries
+     * @private
+     * @param {string|number|null|undefined} id - ID to convert
+     * @returns {number|null|undefined} Integer ID or null/undefined
+     * @throws {Error} If ID cannot be converted to integer
+     */
+    _stringToInt(id) {
+        if (id === null || id === undefined) return id;
+        const parsed = parseInt(id, 10);
+        if (isNaN(parsed)) {
+            throw new Error(`Invalid ID: ${id} cannot be converted to integer`);
+        }
+        return parsed;
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * Convert integer to string for application layer
+     * @private
+     * @param {number|null|undefined} id - Integer ID from database
+     * @returns {string|null|undefined} String ID or null/undefined
+     */
+    _intToString(id) {
+        if (id === null || id === undefined) return id;
+        return id.toString();
+    }
+
+    /**
+     * Legacy alias for _stringToInt (for backward compatibility)
+     * @private
+     */
+    _convertId(id) {
+        return this._stringToInt(id);
+    }
+
+    /**
+     * Convert mapping object IDs to strings
+     * @private
+     * @param {Object|null} mapping - Mapping object from database
+     * @returns {Object|null} Mapping with string IDs
+     */
+    _convertMappingIds(mapping) {
+        if (!mapping) return mapping;
+        return {
+            ...mapping,
+            id: this._intToString(mapping.id),
+            integrationId: this._intToString(mapping.integrationId),
+        };
+    }
+
+    /**
+     * Find mapping by integration ID and source ID
+     * Replaces: IntegrationMapping.findBy(integrationId, sourceId)
+     *
+     * @param {string} integrationId - The integration ID (string from application layer)
+     * @param {string} sourceId - The source ID for lookup
+     * @returns {Promise<Object|null>} The mapping object with string IDs or null
+     */
+    async findMappingBy(integrationId, sourceId) {
+        const mapping = await this.prisma.integrationMapping.findFirst({
+            where: {
+                integrationId: this._stringToInt(integrationId),
+                sourceId: this._toString(sourceId),
+            },
+        });
+        return this._convertMappingIds(mapping);
+    }
+
+    /**
+     * Create or update a mapping
+     * Replaces: IntegrationMapping.upsert(integrationId, sourceId, mapping)
+     *
+     * @param {string} integrationId - The integration ID (string from application layer)
+     * @param {string} sourceId - The source ID for lookup
+     * @param {Object} mapping - The mapping data
+     * @returns {Promise<Object>} The created or updated mapping document with string IDs
+     */
+    async upsertMapping(integrationId, sourceId, mapping) {
+        const result = await this.prisma.integrationMapping.upsert({
+            where: {
+                integrationId_sourceId: {
+                    integrationId: this._stringToInt(integrationId),
+                    sourceId: this._toString(sourceId),
+                },
+            },
+            update: {
+                mapping,
+            },
+            create: {
+                integrationId: this._stringToInt(integrationId),
+                sourceId: this._toString(sourceId),
+                mapping,
+            },
+        });
+        return this._convertMappingIds(result);
+    }
+
+    /**
+     * Find all mappings for an integration
+     * Replaces: IntegrationMapping.find({ integration: integrationId })
+     *
+     * @param {string} integrationId - The integration ID (string from application layer)
+     * @returns {Promise<Array>} Array of mapping documents with string IDs
+     */
+    async findMappingsByIntegration(integrationId) {
+        const intIntegrationId = this._convertId(integrationId);
+        const mappings = await this.prisma.integrationMapping.findMany({
+            where: { integrationId: intIntegrationId },
+        });
+        return mappings.map((m) => this._convertMappingIds(m));
+    }
+
+    /**
+     * Delete a mapping by integration and source ID
+     * Replaces: IntegrationMapping.deleteOne({ integration, sourceId })
+     *
+     * @param {string} integrationId - The integration ID (string from application layer)
+     * @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: this._stringToInt(integrationId),
+                        sourceId: this._toString(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 (string from application layer)
+     * @returns {Promise<Object>} The deletion result
+     */
+    async deleteMappingsByIntegration(integrationId) {
+        const intIntegrationId = this._convertId(integrationId);
+        const result = await this.prisma.integrationMapping.deleteMany({
+            where: { integrationId: intIntegrationId },
+        });
+
+        return {
+            acknowledged: true,
+            deletedCount: result.count,
+        };
+    }
+
+    /**
+     * Find mapping by ID
+     * @param {string} id - Mapping ID (string from application layer)
+     * @returns {Promise<Object|null>} Mapping object with string IDs or null
+     */
+    async findMappingById(id) {
+        const intId = this._convertId(id);
+        const mapping = await this.prisma.integrationMapping.findUnique({
+            where: { id: intId },
+        });
+        return this._convertMappingIds(mapping);
+    }
+
+    /**
+     * Update mapping by ID
+     * @param {string} id - Mapping ID (string from application layer)
+     * @param {Object} updates - Fields to update (with string IDs from application layer)
+     * @returns {Promise<Object>} Updated mapping object with string IDs
+     */
+    async updateMapping(id, updates) {
+        const intId = this._convertId(id);
+
+        // Convert integrationId if present in updates
+        const data = { ...updates };
+        if (data.integrationId !== undefined) {
+            data.integrationId = this._convertId(data.integrationId);
+        }
+
+        const mapping = await this.prisma.integrationMapping.update({
+            where: { id: intId },
+            data,
+        });
+        return this._convertMappingIds(mapping);
+    }
+}
+
+module.exports = { IntegrationMappingRepositoryPostgres };

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

@@ -0,0 +1,156 @@
+const { prisma } = require('../../database/prisma');
+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,
+            },
+        });
+    }
+
+    /**
+     * 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,284 @@
+const { prisma } = require('../../database/prisma');
+const {
+    toObjectId,
+    toObjectIdArray,
+    fromObjectId,
+    findMany,
+    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 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);
+    }
+
+    _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 };
+
+