@friggframework/core 2.0.0-next.53 → 2.0.0-next.55

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

@@ -0,0 +1,280 @@
+const { prisma } = require('../../database/prisma');
+const {
+    toObjectId,
+    fromObjectId,
+    findMany,
+    findOne,
+    insertOne,
+    updateOne,
+    deleteOne,
+    deleteMany,
+} = require('../../database/documentdb-utils');
+const {
+    IntegrationMappingRepositoryInterface,
+} = require('./integration-mapping-repository-interface');
+const {
+    DocumentDBEncryptionService,
+} = require('../../database/documentdb-encryption-service');
+class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+        this.encryptionService = new DocumentDBEncryptionService();
+    }
+
+    async findMappingBy(integrationId, sourceId) {
+        const filter = this._compositeFilter(integrationId, sourceId);
+        const doc = await findOne(this.prisma, 'IntegrationMapping', filter);
+        if (!doc) return null;
+
+        const decryptedMapping = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            doc
+        );
+        return this._mapMapping(decryptedMapping);
+    }
+
+    async upsertMapping(integrationId, sourceId, mapping) {
+        const filter = this._compositeFilter(integrationId, sourceId);
+        const existing = await findOne(
+            this.prisma,
+            'IntegrationMapping',
+            filter
+        );
+        const now = new Date();
+
+        if (existing) {
+            const decryptedExisting =
+                await this.encryptionService.decryptFields(
+                    'IntegrationMapping',
+                    existing
+                );
+
+            const updateDocument = {
+                mapping,
+                updatedAt: now,
+            };
+
+            const encryptedUpdate = await this.encryptionService.encryptFields(
+                'IntegrationMapping',
+                { mapping: updateDocument.mapping }
+            );
+
+            await updateOne(
+                this.prisma,
+                'IntegrationMapping',
+                { _id: existing._id },
+                {
+                    $set: {
+                        mapping: encryptedUpdate.mapping,
+                        updatedAt: updateDocument.updatedAt,
+                    },
+                }
+            );
+
+            const updated = await findOne(this.prisma, 'IntegrationMapping', {
+                _id: existing._id,
+            });
+            if (!updated) {
+                console.error(
+                    '[IntegrationMappingRepositoryDocumentDB] Mapping not found after update',
+                    {
+                        mappingId: fromObjectId(existing._id),
+                        integrationId,
+                        sourceId,
+                    }
+                );
+                throw new Error(
+                    'Failed to update mapping: Document not found after update. ' +
+                        'This indicates a database consistency issue.'
+                );
+            }
+            const decryptedMapping = await this.encryptionService.decryptFields(
+                'IntegrationMapping',
+                updated
+            );
+            return this._mapMapping(decryptedMapping);
+        }
+
+        const plainDocument = {
+            integrationId: integrationId,
+            sourceId:
+                sourceId === null || sourceId === undefined
+                    ? null
+                    : String(sourceId),
+            mapping,
+            createdAt: now,
+            updatedAt: now,
+        };
+
+        const encryptedDocument = await this.encryptionService.encryptFields(
+            'IntegrationMapping',
+            plainDocument
+        );
+
+        const insertedId = await insertOne(
+            this.prisma,
+            'IntegrationMapping',
+            encryptedDocument
+        );
+
+        const created = await findOne(this.prisma, 'IntegrationMapping', {
+            _id: insertedId,
+        });
+        if (!created) {
+            console.error(
+                '[IntegrationMappingRepositoryDocumentDB] Mapping not found after insert',
+                {
+                    insertedId: fromObjectId(insertedId),
+                    integrationId,
+                    sourceId,
+                }
+            );
+            throw new Error(
+                'Failed to create mapping: Document not found after insert. ' +
+                    'This indicates a database consistency issue.'
+            );
+        }
+        const decryptedMapping = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            created
+        );
+        return this._mapMapping(decryptedMapping);
+    }
+
+    async findMappingsByIntegration(integrationId) {
+        const filter = {};
+        if (integrationId) filter.integrationId = integrationId;
+        const docs = await findMany(this.prisma, 'IntegrationMapping', filter);
+
+        const decryptedDocs = await Promise.all(
+            docs.map((doc) =>
+                this.encryptionService.decryptFields('IntegrationMapping', doc)
+            )
+        );
+
+        return decryptedDocs.map((doc) => this._mapMapping(doc));
+    }
+
+    async deleteMapping(integrationId, sourceId) {
+        const filter = this._compositeFilter(integrationId, sourceId);
+        const result = await deleteOne(
+            this.prisma,
+            'IntegrationMapping',
+            filter
+        );
+        const deleted = result?.n ?? 0;
+        return { acknowledged: true, deletedCount: deleted };
+    }
+
+    async deleteMappingsByIntegration(integrationId) {
+        if (!integrationId) {
+            return { acknowledged: true, deletedCount: 0 };
+        }
+        const result = await deleteMany(this.prisma, 'IntegrationMapping', {
+            integrationId: integrationId,
+        });
+        const deleted = result?.n ?? 0;
+        return { acknowledged: true, deletedCount: deleted };
+    }
+
+    async findMappingById(id) {
+        const objectId = toObjectId(id);
+        if (!objectId) return null;
+        const doc = await findOne(this.prisma, 'IntegrationMapping', {
+            _id: objectId,
+        });
+        if (!doc) return null;
+
+        const decryptedMapping = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            doc
+        );
+        return this._mapMapping(decryptedMapping);
+    }
+
+    async updateMapping(id, updates) {
+        const objectId = toObjectId(id);
+        if (!objectId) return null;
+
+        const existing = await findOne(this.prisma, 'IntegrationMapping', {
+            _id: objectId,
+        });
+        if (!existing) return null;
+
+        const decryptedExisting = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            existing
+        );
+
+        const mergedMapping =
+            updates.mapping !== undefined
+                ? updates.mapping
+                : decryptedExisting.mapping;
+
+        const updateDocument = {
+            ...updates,
+            updatedAt: new Date(),
+        };
+
+        if (mergedMapping !== undefined) {
+            const encryptedUpdate = await this.encryptionService.encryptFields(
+                'IntegrationMapping',
+                { mapping: mergedMapping }
+            );
+            updateDocument.mapping = encryptedUpdate.mapping;
+        }
+
+        await updateOne(
+            this.prisma,
+            'IntegrationMapping',
+            { _id: objectId },
+            {
+                $set: updateDocument,
+            }
+        );
+
+        const updated = await findOne(this.prisma, 'IntegrationMapping', {
+            _id: objectId,
+        });
+        if (!updated) {
+            console.error(
+                '[IntegrationMappingRepositoryDocumentDB] Mapping not found after update',
+                {
+                    mappingId: fromObjectId(objectId),
+                }
+            );
+            throw new Error(
+                'Failed to update mapping: Document not found after update. ' +
+                    'This indicates a database consistency issue.'
+            );
+        }
+        const decryptedMapping = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            updated
+        );
+        return this._mapMapping(decryptedMapping);
+    }
+
+    _compositeFilter(integrationId, sourceId) {
+        const filter = {};
+        if (integrationId) filter.integrationId = integrationId;
+        if (sourceId !== undefined) {
+            filter.sourceId = sourceId === null ? null : String(sourceId);
+        }
+        return filter;
+    }
+
+    _mapMapping(doc) {
+        return {
+            id: fromObjectId(doc?._id),
+            integrationId: doc?.integrationId ?? null,
+            sourceId: doc?.sourceId ?? null,
+            mapping: doc?.mapping ?? null,
+            createdAt: doc?.createdAt,
+            updatedAt: doc?.updatedAt,
+        };
+    }
+}
+
+module.exports = { IntegrationMappingRepositoryDocumentDB };

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

@@ -4,6 +4,9 @@ const {
 const {
     IntegrationMappingRepositoryPostgres,
 } = require('./integration-mapping-repository-postgres');
+const {
+    IntegrationMappingRepositoryDocumentDB,
+} = require('./integration-mapping-repository-documentdb');
 const config = require('../../database/config');
 
 /**
@@ -35,9 +38,12 @@ function createIntegrationMappingRepository() {
         case 'postgresql':
             return new IntegrationMappingRepositoryPostgres();
 
+        case 'documentdb':
+            return new IntegrationMappingRepositoryDocumentDB();
+
         default:
             throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
             );
     }
 }
@@ -47,4 +53,5 @@ module.exports = {
     // Export adapters for direct testing
     IntegrationMappingRepositoryMongo,
     IntegrationMappingRepositoryPostgres,
+    IntegrationMappingRepositoryDocumentDB,
 };

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

@@ -0,0 +1,210 @@
+const { prisma } = require('../../database/prisma');
+const {
+    toObjectId,
+    toObjectIdArray,
+    fromObjectId,
+    findMany,
+    findOne,
+    insertOne,
+    updateOne,
+    deleteOne,
+} = require('../../database/documentdb-utils');
+const {
+    IntegrationRepositoryInterface,
+} = require('./integration-repository-interface');
+
+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 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: 'ENABLED',
+            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);
+    }
+
+    _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,
+        };
+    }
+
+    _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

@@ -1,5 +1,8 @@
 const { IntegrationRepositoryMongo } = require('./integration-repository-mongo');
 const { IntegrationRepositoryPostgres } = require('./integration-repository-postgres');
+const {
+    IntegrationRepositoryDocumentDB,
+} = require('./integration-repository-documentdb');
 const config = require('../../database/config');
 
 /**
@@ -29,9 +32,12 @@ function createIntegrationRepository() {
         case 'postgresql':
             return new IntegrationRepositoryPostgres();
 
+        case 'documentdb':
+            return new IntegrationRepositoryDocumentDB();
+
         default:
             throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
             );
     }
 }
@@ -41,4 +47,5 @@ module.exports = {
     // Export adapters for direct testing
     IntegrationRepositoryMongo,
     IntegrationRepositoryPostgres,
+    IntegrationRepositoryDocumentDB,
 };