@friggframework/core 2.0.0-next.8 → 2.0.0-next.81

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

@@ -0,0 +1,385 @@
+const { prisma } = require('../../database/prisma');
+const {
+    IntegrationRepositoryInterface,
+} = require('./integration-repository-interface');
+
+/**
+ * PostgreSQL Integration Repository Adapter
+ * Handles integration persistence using Prisma with PostgreSQL
+ *
+ * PostgreSQL-specific characteristics:
+ * - Uses nested relations for foreign keys (user, entities)
+ * - Uses Int IDs with autoincrement
+ * - Requires ID conversion: String (app layer) ↔ Int (database)
+ * - All returned IDs are converted to strings for application layer consistency
+ * - Implicit join tables for many-to-many relationships (_EntityToIntegration)
+ * - Uses connect/disconnect syntax for relations
+ */
+class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
+    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
+     */
+    _convertId(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 integration object IDs to strings
+     * @private
+     * @param {Object|null} integration - Integration object from database
+     * @returns {Object|null} Integration with string IDs
+     */
+    _convertIntegrationIds(integration) {
+        if (!integration) return integration;
+        return {
+            ...integration,
+            id: integration.id?.toString(),
+            userId: integration.userId?.toString(),
+            entities: integration.entities?.map(e => ({
+                ...e,
+                id: e.id?.toString(),
+                userId: e.userId?.toString(),
+                credentialId: e.credentialId?.toString()
+            }))
+        };
+    }
+
+    /**
+     * Find all integrations for a user
+     *
+     * @param {string} userId - User ID (string from application layer)
+     * @returns {Promise<Array>} Array of integration objects with string IDs
+     */
+    async findIntegrationsByUserId(userId) {
+        const intUserId = this._convertId(userId);
+        const integrations = await this.prisma.integration.findMany({
+            where: { userId: intUserId },
+            include: {
+                entities: true,
+            },
+        });
+
+        // Map to domain objects with string IDs
+        return integrations.map((integration) => {
+            const converted = this._convertIntegrationIds(integration);
+            return {
+                id: converted.id,
+                entitiesIds: converted.entities.map((e) => e.id),
+                userId: converted.userId,
+                config: converted.config,
+                version: converted.version,
+                status: converted.status,
+                messages: converted.messages,
+            };
+        });
+    }
+
+    /**
+     * Delete integration by ID
+     *
+     * @param {string} integrationId - Integration ID (string from application layer)
+     * @returns {Promise<Object>} Deletion result
+     */
+    async deleteIntegrationById(integrationId) {
+        const intId = this._convertId(integrationId);
+        await this.prisma.integration.delete({
+            where: { id: intId },
+        });
+
+        // Return Mongoose-compatible result
+        return { acknowledged: true, deletedCount: 1 };
+    }
+
+    /**
+     * Find integration by name
+     *
+     * @param {string} name - Integration type name
+     * @returns {Promise<Object>} Integration object with string IDs
+     */
+    async findIntegrationByName(name) {
+        const integration = await this.prisma.integration.findFirst({
+            where: {
+                config: {
+                    path: ['type'],
+                    equals: name,
+                },
+            },
+            include: {
+                entities: true,
+            },
+        });
+
+        if (!integration) {
+            throw new Error(`Integration with name ${name} not found`);
+        }
+
+        const converted = this._convertIntegrationIds(integration);
+        return {
+            id: converted.id,
+            entitiesIds: converted.entities.map((e) => e.id),
+            userId: converted.userId,
+            config: converted.config,
+            version: converted.version,
+            status: converted.status,
+            messages: converted.messages,
+        };
+    }
+
+    /**
+     * Find integration by ID
+     *
+     * @param {string} id - Integration ID (string from application layer)
+     * @returns {Promise<Object>} Integration object with string IDs
+     */
+    async findIntegrationById(id) {
+        const intId = this._convertId(id);
+        const integration = await this.prisma.integration.findUnique({
+            where: { id: intId },
+            include: {
+                entities: true,
+            },
+        });
+
+        if (!integration) {
+            throw new Error(`Integration with id ${id} not found`);
+        }
+
+        const converted = this._convertIntegrationIds(integration);
+        return {
+            id: converted.id,
+            entitiesIds: converted.entities.map((e) => e.id),
+            userId: converted.userId,
+            config: converted.config,
+            version: converted.version,
+            status: converted.status,
+            messages: converted.messages,
+        };
+    }
+
+    /**
+     * Update integration status
+     *
+     * @param {string} integrationId - Integration ID (string from application layer)
+     * @param {string} status - New status
+     * @returns {Promise<boolean>} Success indicator
+     */
+    async updateIntegrationStatus(integrationId, status) {
+        const intId = this._convertId(integrationId);
+        await this.prisma.integration.update({
+            where: { id: intId },
+            data: { status },
+        });
+
+        return true; // Mongoose compatibility
+    }
+
+    /**
+     * Update integration messages
+     *
+     * @param {string} integrationId - Integration ID (string from application layer)
+     * @param {string} messageType - Type of message (errors, warnings, info, logs)
+     * @param {string} messageTitle - Message title
+     * @param {string} messageBody - Message body
+     * @param {Date} messageTimestamp - Message timestamp
+     * @returns {Promise<boolean>} Success indicator
+     */
+    async updateIntegrationMessages(
+        integrationId,
+        messageType,
+        messageTitle,
+        messageBody,
+        messageTimestamp
+    ) {
+        const intId = this._convertId(integrationId);
+
+        // Get current integration
+        const integration = await this.prisma.integration.findUnique({
+            where: { id: intId },
+        });
+
+        if (!integration) {
+            throw new Error(`Integration ${integrationId} not found`);
+        }
+
+        // Parse existing messages (JSON field)
+        const messages = integration.messages || {};
+        const messageArray = Array.isArray(messages[messageType])
+            ? messages[messageType]
+            : [];
+
+        // Add new message
+        messageArray.push({
+            title: messageTitle,
+            message: messageBody,
+            timestamp: messageTimestamp,
+        });
+
+        // Update messages
+        await this.prisma.integration.update({
+            where: { id: intId },
+            data: {
+                [messageType]: messageArray,
+            },
+        });
+
+        return true; // Mongoose compatibility
+    }
+
+    /**
+     * Create a new integration
+     *
+     * PostgreSQL-specific: Uses nested relations with connect syntax
+     *
+     * @param {Array<string>} entities - Array of entity IDs (strings from application layer)
+     * @param {string} userId - User ID (string from application layer)
+     * @param {Object} config - Integration configuration
+     * @returns {Promise<Object>} Created integration object with string IDs
+     */
+    async createIntegration(entities, userId, config) {
+        const data = {
+            config,
+            version: '0.0.0',
+        };
+
+        // PostgreSQL: use nested relations with ID conversion
+        if (userId) {
+            data.user = { connect: { id: this._convertId(userId) } };
+        }
+        if (entities && entities.length > 0) {
+            data.entities = {
+                connect: entities.map((id) => ({ id: this._convertId(id) })),
+            };
+        }
+
+        const integration = await this.prisma.integration.create({
+            data,
+            include: {
+                entities: true,
+            },
+        });
+
+        const converted = this._convertIntegrationIds(integration);
+        return {
+            id: converted.id,
+            entitiesIds: converted.entities.map((e) => e.id),
+            userId: converted.userId,
+            config: converted.config,
+            version: converted.version,
+            status: converted.status,
+            messages: converted.messages,
+        };
+    }
+
+    /**
+     * Find integration by user ID (returns single integration)
+     *
+     * @param {string} userId - User ID (string from application layer)
+     * @returns {Promise<Object|null>} Integration object with string IDs or null
+     */
+    async findIntegrationByUserId(userId) {
+        const intUserId = this._convertId(userId);
+        const integration = await this.prisma.integration.findFirst({
+            where: { userId: intUserId },
+            include: {
+                entities: true,
+            },
+        });
+
+        if (!integration) {
+            return null;
+        }
+
+        const converted = this._convertIntegrationIds(integration);
+        return {
+            id: converted.id,
+            entitiesIds: converted.entities.map((e) => e.id),
+            userId: converted.userId,
+            config: converted.config,
+            version: converted.version,
+            status: converted.status,
+            messages: converted.messages,
+        };
+    }
+
+    /**
+     * Update integration configuration
+     *
+     * @param {string} integrationId - Integration ID (string from application layer)
+     * @param {Object} config - Updated configuration object
+     * @returns {Promise<Object>} Updated integration object with string IDs
+     */
+    async updateIntegrationConfig(integrationId, config) {
+        if (config === null || config === undefined) {
+            throw new Error('Config parameter is required');
+        }
+
+        const intId = this._convertId(integrationId);
+        const integration = await this.prisma.integration.update({
+            where: { id: intId },
+            data: { config },
+            include: {
+                entities: true,
+            },
+        });
+
+        const converted = this._convertIntegrationIds(integration);
+        return {
+            id: converted.id,
+            entitiesIds: converted.entities.map((e) => e.id),
+            userId: converted.userId,
+            config: converted.config,
+            version: converted.version,
+            status: converted.status,
+            messages: converted.messages,
+        };
+    }
+
+    /**
+     * Find all integrations whose entity set includes the given entity ID.
+     *
+     * @param {string|number} entityId - Entity ID (string from application layer)
+     * @returns {Promise<Array>} Array of integration objects with string IDs (possibly empty)
+     */
+    async findIntegrationsByEntityId(entityId) {
+        const intEntityId = this._convertId(entityId);
+        const integrations = await this.prisma.integration.findMany({
+            where: {
+                entities: {
+                    some: { id: intEntityId },
+                },
+            },
+            include: {
+                entities: true,
+            },
+        });
+
+        return integrations.map((integration) => {
+            const converted = this._convertIntegrationIds(integration);
+            return {
+                id: converted.id,
+                entitiesIds: converted.entities.map((e) => e.id),
+                userId: converted.userId,
+                config: converted.config,
+                version: converted.version,
+                status: converted.status,
+                messages: converted.messages,
+            };
+        });
+    }
+}
+
+module.exports = { IntegrationRepositoryPostgres };

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

@@ -0,0 +1,311 @@
+const { prisma } = require('../../database/prisma');
+const {
+    toObjectId,
+    fromObjectId,
+    findMany,
+    findOne,
+    insertOne,
+    updateOne,
+    deleteOne,
+} = require('../../database/documentdb-utils');
+const {
+    ProcessRepositoryInterface,
+} = require('./process-repository-interface');
+const {
+    DocumentDBEncryptionService,
+} = require('../../database/documentdb-encryption-service');
+const { validateOps } = require('./process-update-ops-shared');
+
+class ProcessRepositoryDocumentDB extends ProcessRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+        this.encryptionService = new DocumentDBEncryptionService();
+    }
+
+    async create(processData) {
+        const now = new Date();
+        const plainDocument = {
+            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 encryptedDocument = await this.encryptionService.encryptFields(
+            'Process',
+            plainDocument
+        );
+
+        const insertedId = await insertOne(
+            this.prisma,
+            'Process',
+            encryptedDocument
+        );
+
+        const created = await findOne(this.prisma, 'Process', {
+            _id: insertedId,
+        });
+        if (!created) {
+            console.error(
+                '[ProcessRepositoryDocumentDB] Process not found after insert',
+                {
+                    insertedId: fromObjectId(insertedId),
+                    processData: {
+                        userId: processData.userId,
+                        integrationId: processData.integrationId,
+                        name: processData.name,
+                        type: processData.type,
+                    },
+                }
+            );
+            throw new Error(
+                'Failed to create process: Document not found after insert. ' +
+                    'This indicates a database consistency issue.'
+            );
+        }
+        const decryptedProcess = await this.encryptionService.decryptFields(
+            'Process',
+            created
+        );
+        return this._mapProcess(decryptedProcess);
+    }
+
+    async findById(processId) {
+        const objectId = toObjectId(processId);
+        if (!objectId) return null;
+        const doc = await findOne(this.prisma, 'Process', { _id: objectId });
+        if (!doc) return null;
+
+        const decryptedProcess = await this.encryptionService.decryptFields(
+            'Process',
+            doc
+        );
+        return this._mapProcess(decryptedProcess);
+    }
+
+    async update(processId, updates) {
+        const objectId = toObjectId(processId);
+        if (!objectId) return null;
+
+        const existing = await findOne(this.prisma, 'Process', {
+            _id: objectId,
+        });
+        if (!existing) 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();
+
+        const encryptedUpdate = await this.encryptionService.encryptFields(
+            'Process',
+            updatePayload
+        );
+
+        await updateOne(
+            this.prisma,
+            'Process',
+            { _id: objectId },
+            { $set: encryptedUpdate }
+        );
+
+        const updated = await findOne(this.prisma, 'Process', {
+            _id: objectId,
+        });
+        if (!updated) {
+            console.error(
+                '[ProcessRepositoryDocumentDB] Process not found after update',
+                {
+                    processId: fromObjectId(objectId),
+                }
+            );
+            throw new Error(
+                'Failed to update process: Document not found after update. ' +
+                    'This indicates a database consistency issue.'
+            );
+        }
+        const decryptedProcess = await this.encryptionService.decryptFields(
+            'Process',
+            updated
+        );
+        return this._mapProcess(decryptedProcess);
+    }
+
+    /**
+     * Atomic process update — race-safe counterpart to `update()`.
+     *
+     * Uses DocumentDB's native $inc / $set / $push operators (Mongo-wire
+     * compatible) via findAndModify so increments, sets, and pushes land
+     * in one server-side write. Contention on the same document
+     * serializes at the DB level.
+     *
+     * DocumentDB compatibility notes:
+     *  - $inc: supported since v3.6.
+     *  - $set with dot-path: supported.
+     *  - $push with $each + negative $slice: supported since v4.0.
+     *    Clusters still on v3.6 must upgrade before using pushSlice.
+     *
+     * Process documents have no encrypted fields today; if that changes,
+     * the set-by-path payload here MUST route through
+     * `encryptionService.encryptFields` for any affected paths.
+     *
+     * @param {string} processId
+     * @param {import('./process-repository-interface').ProcessUpdateOps} ops
+     * @returns {Promise<Object|null>}
+     */
+    async applyProcessUpdate(processId, ops) {
+        const normalized = validateOps(ops);
+        const objectId = toObjectId(processId);
+
+        const update = {};
+        const $set = {};
+
+        if (Object.keys(normalized.increment).length > 0) {
+            update.$inc = { ...normalized.increment };
+        }
+        for (const [path, value] of Object.entries(normalized.set)) {
+            $set[path] = value;
+        }
+        if (normalized.newState !== null) {
+            $set.state = normalized.newState;
+        }
+        $set.updatedAt = new Date();
+        update.$set = $set;
+
+        if (Object.keys(normalized.pushSlice).length > 0) {
+            update.$push = {};
+            for (const [path, spec] of Object.entries(normalized.pushSlice)) {
+                update.$push[path] = {
+                    $each: spec.values,
+                    $slice: -spec.keepLast,
+                };
+            }
+        }
+
+        const result = await this.prisma.$runCommandRaw({
+            findAndModify: 'Process',
+            query: { _id: objectId },
+            update,
+            new: true,
+        });
+
+        const doc = result && result.value;
+        if (!doc) return null;
+        const decrypted = await this.encryptionService.decryptFields(
+            'Process',
+            doc
+        );
+        return this._mapProcess(decrypted);
+    }
+
+    async findByIntegrationAndType(integrationId, type) {
+        const integrationObjectId = toObjectId(integrationId);
+        const filter = {
+            integrationId: integrationObjectId,
+            type,
+        };
+        const docs = await findMany(this.prisma, 'Process', filter, {
+            sort: { createdAt: -1 },
+        });
+
+        const decryptedDocs = await Promise.all(
+            docs.map((doc) =>
+                this.encryptionService.decryptFields('Process', doc)
+            )
+        );
+
+        return decryptedDocs.map((doc) => this._mapProcess(doc));
+    }
+
+    async findActiveProcesses(
+        integrationId,
+        excludeStates = ['COMPLETED', 'ERROR']
+    ) {
+        const integrationObjectId = toObjectId(integrationId);
+        const filter = {
+            integrationId: integrationObjectId,
+            state: { $nin: excludeStates },
+        };
+        const docs = await findMany(this.prisma, 'Process', filter, {
+            sort: { createdAt: -1 },
+        });
+
+        const decryptedDocs = await Promise.all(
+            docs.map((doc) =>
+                this.encryptionService.decryptFields('Process', doc)
+            )
+        );
+
+        return decryptedDocs.map((doc) => this._mapProcess(doc));
+    }
+
+    async findByName(name) {
+        const doc = await findOne(
+            this.prisma,
+            'Process',
+            { name },
+            { sort: { createdAt: -1 } }
+        );
+        if (!doc) return null;
+
+        const decryptedProcess = await this.encryptionService.decryptFields(
+            'Process',
+            doc
+        );
+        return this._mapProcess(decryptedProcess);
+    }
+
+    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 };