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

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

@@ -0,0 +1,135 @@
+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');
+
+class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+    }
+
+    async findMappingBy(integrationId, sourceId) {
+        const filter = this._compositeFilter(integrationId, sourceId);
+        const doc = await findOne(this.prisma, 'IntegrationMapping', filter);
+        return doc ? this._mapMapping(doc) : null;
+    }
+
+    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) {
+            await updateOne(
+                this.prisma,
+                'IntegrationMapping',
+                { _id: existing._id },
+                {
+                    $set: {
+                        mapping,
+                        updatedAt: now,
+                    },
+                }
+            );
+            const updated = await findOne(this.prisma, 'IntegrationMapping', { _id: existing._id });
+            return this._mapMapping(updated);
+        }
+
+        const document = {
+            integrationId: toObjectId(integrationId),
+            sourceId: sourceId === null || sourceId === undefined ? null : String(sourceId),
+            mapping,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const insertedId = await insertOne(this.prisma, 'IntegrationMapping', document);
+        const created = await findOne(this.prisma, 'IntegrationMapping', { _id: insertedId });
+        return this._mapMapping(created);
+    }
+
+    async findMappingsByIntegration(integrationId) {
+        const filter = {};
+        const integrationObjectId = toObjectId(integrationId);
+        if (integrationObjectId) filter.integrationId = integrationObjectId;
+        const docs = await findMany(this.prisma, 'IntegrationMapping', filter);
+        return docs.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) {
+        const integrationObjectId = toObjectId(integrationId);
+        if (!integrationObjectId) {
+            return { acknowledged: true, deletedCount: 0 };
+        }
+        const result = await deleteMany(this.prisma, 'IntegrationMapping', {
+            integrationId: integrationObjectId,
+        });
+        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 });
+        return doc ? this._mapMapping(doc) : null;
+    }
+
+    async updateMapping(id, updates) {
+        const objectId = toObjectId(id);
+        if (!objectId) return null;
+        await updateOne(
+            this.prisma,
+            'IntegrationMapping',
+            { _id: objectId },
+            {
+                $set: {
+                    ...updates,
+                    updatedAt: new Date(),
+                },
+            }
+        );
+        const updated = await findOne(this.prisma, 'IntegrationMapping', { _id: objectId });
+        return updated ? this._mapMapping(updated) : null;
+    }
+
+    _compositeFilter(integrationId, sourceId) {
+        const filter = {};
+        const integrationObjectId = toObjectId(integrationId);
+        if (integrationObjectId) filter.integrationId = integrationObjectId;
+        if (sourceId !== undefined) {
+            filter.sourceId = sourceId === null ? null : String(sourceId);
+        }
+        return filter;
+    }
+
+    _mapMapping(doc) {
+        return {
+            id: fromObjectId(doc?._id),
+            integrationId: fromObjectId(doc?.integrationId),
+            sourceId: doc?.sourceId ?? null,
+            mapping: doc?.mapping ?? null,
+        };
+    }
+}
+
+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,189 @@
+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 });
+        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 });
+        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,
 };

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

@@ -0,0 +1,141 @@
+const { prisma } = require('../../database/prisma');
+const {
+    toObjectId,
+    fromObjectId,
+    findMany,
+    findOne,
+    insertOne,
+    updateOne,
+    deleteOne,
+} = require('../../database/documentdb-utils');
+const { ProcessRepositoryInterface } = require('./process-repository-interface');
+
+class ProcessRepositoryDocumentDB extends ProcessRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+    }
+
+    async create(processData) {
+        const now = new Date();
+        const document = {
+            userId: toObjectId(processData.userId),
+            integrationId: toObjectId(processData.integrationId),
+            name: processData.name,
+            type: processData.type,
+            state: processData.state || 'INITIALIZING',
+            context: processData.context || {},
+            results: processData.results || {},
+            childProcesses: (processData.childProcesses || []).map((id) => toObjectId(id)).filter(Boolean),
+            parentProcessId: processData.parentProcessId ? toObjectId(processData.parentProcessId) : null,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const insertedId = await insertOne(this.prisma, 'Process', document);
+        const created = await findOne(this.prisma, 'Process', { _id: insertedId });
+        return this._mapProcess(created);
+    }
+
+    async findById(processId) {
+        const objectId = toObjectId(processId);
+        if (!objectId) return null;
+        const doc = await findOne(this.prisma, 'Process', { _id: objectId });
+        return doc ? this._mapProcess(doc) : null;
+    }
+
+    async update(processId, updates) {
+        const objectId = toObjectId(processId);
+        if (!objectId) return null;
+        const updatePayload = {};
+        if (updates.state !== undefined) updatePayload.state = updates.state;
+        if (updates.context !== undefined) updatePayload.context = updates.context;
+        if (updates.results !== undefined) updatePayload.results = updates.results;
+        if (updates.childProcesses !== undefined) {
+            updatePayload.childProcesses = (updates.childProcesses || []).map((id) => toObjectId(id)).filter(Boolean);
+        }
+        if (updates.parentProcessId !== undefined) {
+            updatePayload.parentProcessId = updates.parentProcessId ? toObjectId(updates.parentProcessId) : null;
+        }
+        updatePayload.updatedAt = new Date();
+        await updateOne(
+            this.prisma,
+            'Process',
+            { _id: objectId },
+            { $set: updatePayload }
+        );
+        const updated = await findOne(this.prisma, 'Process', { _id: objectId });
+        return updated ? this._mapProcess(updated) : null;
+    }
+
+    async findByIntegrationAndType(integrationId, type) {
+        const integrationObjectId = toObjectId(integrationId);
+        const filter = {
+            integrationId: integrationObjectId,
+            type,
+        };
+        const docs = await findMany(this.prisma, 'Process', filter, {
+            sort: { createdAt: -1 },
+        });
+        return docs.map((doc) => this._mapProcess(doc));
+    }
+
+    async findActiveProcesses(integrationId, excludeStates = ['COMPLETED', 'ERROR']) {
+        const integrationObjectId = toObjectId(integrationId);
+        const pipeline = [
+            {
+                $match: {
+                    integrationId: integrationObjectId,
+                },
+            },
+            {
+                $match: {
+                    state: { $nin: excludeStates },
+                },
+            },
+            { $sort: { createdAt: -1 } },
+        ];
+        const docs = await this.prisma.$runCommandRaw({
+            aggregate: 'Process',
+            pipeline,
+            cursor: {},
+        }).then((res) => res?.cursor?.firstBatch || []);
+        return docs.map((doc) => this._mapProcess(doc));
+    }
+
+    async findByName(name) {
+        const doc = await findOne(
+            this.prisma,
+            'Process',
+            { name },
+            { sort: { createdAt: -1 } }
+        );
+        return doc ? this._mapProcess(doc) : null;
+    }
+
+    async deleteById(processId) {
+        const objectId = toObjectId(processId);
+        if (!objectId) return;
+        await deleteOne(this.prisma, 'Process', { _id: objectId });
+    }
+
+    _mapProcess(doc) {
+        return {
+            id: fromObjectId(doc?._id),
+            userId: fromObjectId(doc?.userId),
+            integrationId: fromObjectId(doc?.integrationId),
+            name: doc?.name ?? null,
+            type: doc?.type ?? null,
+            state: doc?.state ?? null,
+            context: doc?.context ?? {},
+            results: doc?.results ?? {},
+            childProcesses: (doc?.childProcesses || []).map((id) => fromObjectId(id)),
+            parentProcessId: doc?.parentProcessId ? fromObjectId(doc.parentProcessId) : null,
+            createdAt: doc?.createdAt ? new Date(doc.createdAt) : null,
+            updatedAt: doc?.updatedAt ? new Date(doc.updatedAt) : null,
+        };
+    }
+}
+
+module.exports = { ProcessRepositoryDocumentDB };
+
+

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

@@ -1,5 +1,8 @@
 const { ProcessRepositoryMongo } = require('./process-repository-mongo');
 const { ProcessRepositoryPostgres } = require('./process-repository-postgres');
+const {
+    ProcessRepositoryDocumentDB,
+} = require('./process-repository-documentdb');
 const config = require('../../database/config');
 
 /**
@@ -30,9 +33,12 @@ function createProcessRepository() {
         case 'postgresql':
             return new ProcessRepositoryPostgres();
 
+        case 'documentdb':
+            return new ProcessRepositoryDocumentDB();
+
         default:
             throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
             );
     }
 }
@@ -42,5 +48,6 @@ module.exports = {
     // Export adapters for direct testing
     ProcessRepositoryMongo,
     ProcessRepositoryPostgres,
+    ProcessRepositoryDocumentDB,
 };