@friggframework/core 2.0.0--canary.545.ccb5010.0 → 2.0.0--canary.549.b074651.0

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

@@ -1,217 +0,0 @@
-const { prisma } = require('../../database/prisma');
-const {
-    ProcessRepositoryInterface,
-} = require('./process-repository-interface');
-
-/**
- * PostgreSQL Process Repository Adapter
- * Handles process persistence using Prisma with PostgreSQL
- *
- * PostgreSQL-specific characteristics:
- * - Uses foreign key constraints for relations
- * - JSONB type for context and results (efficient querying)
- * - Array type for childProcesses references
- * - Transactional support available if needed
- *
- * Design Philosophy:
- * - Same interface as MongoDB repository
- * - Prisma abstracts away most database-specific details
- * - Minor differences in JSON handling internally managed by Prisma
- */
-class ProcessRepositoryPostgres extends ProcessRepositoryInterface {
-    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;
-    }
-
-    /**
-     * Create a new process record
-     * @param {Object} processData - Process data to create
-     * @returns {Promise<Object>} Created process record
-     */
-    async create(processData) {
-        const process = await this.prisma.process.create({
-            data: {
-                userId: this._convertId(processData.userId),
-                integrationId: this._convertId(processData.integrationId),
-                name: processData.name,
-                type: processData.type,
-                state: processData.state || 'INITIALIZING',
-                context: processData.context || {},
-                results: processData.results || {},
-                parentProcessId: this._convertId(processData.parentProcessId),
-            },
-        });
-
-        return this._toPlainObject(process);
-    }
-
-    /**
-     * Find a process by ID
-     * @param {string} processId - Process ID to find
-     * @returns {Promise<Object|null>} Process record or null if not found
-     */
-    async findById(processId) {
-        const process = await this.prisma.process.findUnique({
-            where: { id: this._convertId(processId) },
-        });
-
-        return process ? this._toPlainObject(process) : null;
-    }
-
-    /**
-     * Update a process record
-     * @param {string} processId - Process ID to update
-     * @param {Object} updates - Fields to update
-     * @returns {Promise<Object>} Updated process record
-     */
-    async update(processId, updates) {
-        // Prepare update data, excluding undefined values
-        const updateData = {};
-
-        if (updates.state !== undefined) {
-            updateData.state = updates.state;
-        }
-        if (updates.context !== undefined) {
-            updateData.context = updates.context;
-        }
-        if (updates.results !== undefined) {
-            updateData.results = updates.results;
-        }
-        if (updates.parentProcessId !== undefined) {
-            updateData.parentProcessId = this._convertId(
-                updates.parentProcessId
-            );
-        }
-
-        const process = await this.prisma.process.update({
-            where: { id: this._convertId(processId) },
-            data: updateData,
-        });
-
-        return this._toPlainObject(process);
-    }
-
-    /**
-     * Find processes by integration and type
-     * @param {string} integrationId - Integration ID
-     * @param {string} type - Process type
-     * @returns {Promise<Array>} Array of process records
-     */
-    async findByIntegrationAndType(integrationId, type) {
-        const processes = await this.prisma.process.findMany({
-            where: {
-                integrationId: this._convertId(integrationId),
-                type,
-            },
-            orderBy: {
-                createdAt: 'desc',
-            },
-        });
-
-        return processes.map((p) => this._toPlainObject(p));
-    }
-
-    /**
-     * Find active processes (not in excluded states)
-     * @param {string} integrationId - Integration ID
-     * @param {string[]} [excludeStates=['COMPLETED', 'ERROR']] - States to exclude
-     * @returns {Promise<Array>} Array of active process records
-     */
-    async findActiveProcesses(
-        integrationId,
-        excludeStates = ['COMPLETED', 'ERROR']
-    ) {
-        const processes = await this.prisma.process.findMany({
-            where: {
-                integrationId: this._convertId(integrationId),
-                state: {
-                    notIn: excludeStates,
-                },
-            },
-            orderBy: {
-                createdAt: 'desc',
-            },
-        });
-
-        return processes.map((p) => this._toPlainObject(p));
-    }
-
-    /**
-     * Find a process by name (most recent)
-     * @param {string} name - Process name
-     * @returns {Promise<Object|null>} Most recent process with given name, or null
-     */
-    async findByName(name) {
-        const process = await this.prisma.process.findFirst({
-            where: { name },
-            orderBy: {
-                createdAt: 'desc',
-            },
-        });
-
-        return process ? this._toPlainObject(process) : null;
-    }
-
-    /**
-     * Delete a process by ID
-     * @param {string} processId - Process ID to delete
-     * @returns {Promise<void>}
-     */
-    async deleteById(processId) {
-        await this.prisma.process.delete({
-            where: { id: this._convertId(processId) },
-        });
-    }
-
-    /**
-     * Convert Prisma model to plain JavaScript object
-     * Ensures consistent API across repository implementations
-     * @private
-     * @param {Object} process - Prisma process model
-     * @returns {Object} Plain process object
-     */
-    _toPlainObject(process) {
-        return {
-            id: String(process.id),
-            userId: String(process.userId),
-            integrationId: String(process.integrationId),
-            name: process.name,
-            type: process.type,
-            state: process.state,
-            context: process.context,
-            results: process.results,
-            childProcesses: Array.isArray(process.childProcesses)
-                ? process.childProcesses.length > 0 &&
-                  typeof process.childProcesses[0] === 'object' &&
-                  process.childProcesses[0] !== null
-                    ? process.childProcesses.map((child) => String(child.id))
-                    : process.childProcesses
-                : [],
-            parentProcessId:
-                process.parentProcessId !== null
-                    ? String(process.parentProcessId)
-                    : null,
-            createdAt: process.createdAt,
-            updatedAt: process.updatedAt,
-        };
-    }
-}
-
-module.exports = { ProcessRepositoryPostgres };

package/integrations/tests/doubles/dummy-integration-class.js

@@ -1,178 +0,0 @@
-const { IntegrationBase } = require('../../integration-base');
-const { Options } = require('../../options');
-
-class DummyModule {
-    static definition = {
-        getName: () => 'dummy',
-    };
-}
-
-class DummyIntegration extends IntegrationBase {
-    static Definition = {
-        name: 'dummy',
-        version: '1.0.0',
-        modules: {
-            dummy: DummyModule,
-        },
-        display: {
-            label: 'Dummy Integration',
-            description: 'A dummy integration for testing',
-            detailsUrl: 'https://example.com',
-            icon: 'dummy-icon',
-        },
-    };
-
-    static getOptionDetails() {
-        const options = new Options({
-            module: Object.values(this.Definition.modules)[0],
-            ...this.Definition,
-        });
-        return {
-            name: this.Definition.name,
-            version: this.Definition.version,
-            ...options.get(),
-        };
-    }
-
-    constructor(params) {
-        super(params);
-        this.sendSpy = jest.fn();
-        this.eventCallHistory = [];
-        this.events = {};
-
-        this.integrationRepository = {
-            updateIntegrationById: jest.fn().mockResolvedValue({}),
-            findIntegrationById: jest.fn().mockResolvedValue({}),
-        };
-
-        this.updateIntegrationStatus = {
-            execute: jest.fn().mockResolvedValue({}),
-        };
-
-        this.updateIntegrationMessages = {
-            execute: jest.fn().mockResolvedValue({}),
-        };
-    }
-
-    async loadDynamicUserActions() {
-        return {};
-    }
-
-    async send(event, data) {
-        this.sendSpy(event, data);
-        this.eventCallHistory.push({ event, data, timestamp: Date.now() });
-        if (event === 'ON_UPDATE') {
-            await this.onUpdate(data);
-        }
-        return { event, data };
-    }
-
-    async initialize() {
-        return;
-    }
-
-    async onCreate({ integrationId }) {
-        return;
-    }
-
-    async onUpdate(params) {
-        this.config = this._deepMerge(this.config, params.config);
-    }
-
-    _deepMerge(target, source) {
-        const result = { ...target };
-        for (const key of Object.keys(source)) {
-            if (
-                source[key] !== null &&
-                typeof source[key] === 'object' &&
-                !Array.isArray(source[key]) &&
-                target[key] !== null &&
-                typeof target[key] === 'object' &&
-                !Array.isArray(target[key])
-            ) {
-                result[key] = this._deepMerge(target[key], source[key]);
-            } else {
-                result[key] = source[key];
-            }
-        }
-        return result;
-    }
-
-    async onDelete(params) {
-        return;
-    }
-
-    getConfig() {
-        return this.config || {};
-    }
-}
-
-class DummyIntegrationWithGlobalEntity extends IntegrationBase {
-    static Definition = {
-        name: 'dummy-with-global',
-        version: '1.0.0',
-        modules: { dummy: DummyModule },
-        display: { label: 'Dummy With Global', description: 'Test' },
-        entities: {
-            sharedService: {
-                type: 'shared-api',
-                global: true,
-                required: true,
-            },
-        },
-    };
-
-    constructor(params) {
-        super(params);
-        this.sendSpy = jest.fn();
-        this.integrationRepository = {
-            updateIntegrationById: jest.fn().mockResolvedValue({}),
-            findIntegrationById: jest.fn().mockResolvedValue({}),
-        };
-        this.updateIntegrationStatus = { execute: jest.fn().mockResolvedValue({}) };
-        this.updateIntegrationMessages = { execute: jest.fn().mockResolvedValue({}) };
-    }
-
-    async loadDynamicUserActions() { return {}; }
-    async send(event, data) { this.sendSpy(event, data); return { event, data }; }
-    async initialize() { return; }
-    async onCreate() { return; }
-}
-
-class DummyIntegrationWithOptionalGlobalEntity extends IntegrationBase {
-    static Definition = {
-        name: 'dummy-with-optional-global',
-        version: '1.0.0',
-        modules: { dummy: DummyModule },
-        display: { label: 'Dummy With Optional Global', description: 'Test' },
-        entities: {
-            optionalService: {
-                type: 'optional-api',
-                global: true,
-                required: false,
-            },
-        },
-    };
-
-    constructor(params) {
-        super(params);
-        this.sendSpy = jest.fn();
-        this.integrationRepository = {
-            updateIntegrationById: jest.fn().mockResolvedValue({}),
-            findIntegrationById: jest.fn().mockResolvedValue({}),
-        };
-        this.updateIntegrationStatus = { execute: jest.fn().mockResolvedValue({}) };
-        this.updateIntegrationMessages = { execute: jest.fn().mockResolvedValue({}) };
-    }
-
-    async loadDynamicUserActions() { return {}; }
-    async send(event, data) { this.sendSpy(event, data); return { event, data }; }
-    async initialize() { return; }
-    async onCreate() { return; }
-}
-
-module.exports = {
-    DummyIntegration,
-    DummyIntegrationWithGlobalEntity,
-    DummyIntegrationWithOptionalGlobalEntity,
-};

package/integrations/tests/doubles/test-integration-repository.js

@@ -1,139 +0,0 @@
-const { v4: uuid } = require('uuid');
-
-class TestIntegrationRepository {
-    constructor() {
-        this.store = new Map();
-        this.operationHistory = [];
-    }
-
-    async createIntegration(entities, userId, config) {
-        const id = uuid();
-        const record = {
-            id,
-            _id: id,
-            entitiesIds: entities,
-            userId: userId,
-            config,
-            version: '0.0.0',
-            status: 'NEW',
-            messages: {},
-        };
-        this.store.set(id, record);
-        this.operationHistory.push({ operation: 'create', id, userId, config });
-        return record;
-    }
-
-    async findIntegrationById(id) {
-        const rec = this.store.get(id);
-        this.operationHistory.push({ operation: 'findById', id, found: !!rec });
-        if (!rec) return null;
-        return rec;
-    }
-
-    async findIntegrationsByUserId(userId) {
-        const results = Array.from(this.store.values()).filter(
-            (r) => r.userId === userId
-        );
-        this.operationHistory.push({
-            operation: 'findByUserId',
-            userId,
-            count: results.length,
-        });
-        return results;
-    }
-
-    async findIntegrationByUserId(userId) {
-        const record = Array.from(this.store.values()).find(
-            (r) => r.userId === userId
-        );
-        this.operationHistory.push({
-            operation: 'findSingleByUserId',
-            userId,
-            found: !!record,
-        });
-        return record || null;
-    }
-
-    async updateIntegrationMessages(id, type, title, body, timestamp) {
-        const rec = this.store.get(id);
-        if (!rec) {
-            this.operationHistory.push({
-                operation: 'updateMessages',
-                id,
-                success: false,
-            });
-            return false;
-        }
-        if (!rec.messages[type]) rec.messages[type] = [];
-        rec.messages[type].push({ title, message: body, timestamp });
-        this.operationHistory.push({
-            operation: 'updateMessages',
-            id,
-            type,
-            success: true,
-        });
-        return true;
-    }
-
-    async updateIntegrationConfig(id, config) {
-        const rec = this.store.get(id);
-        if (!rec) {
-            this.operationHistory.push({
-                operation: 'updateConfig',
-                id,
-                success: false,
-            });
-            throw new Error(`Integration with id ${id} not found`);
-        }
-        rec.config = config;
-        this.operationHistory.push({
-            operation: 'updateConfig',
-            id,
-            success: true,
-        });
-        return rec;
-    }
-
-    async deleteIntegrationById(id) {
-        const existed = this.store.has(id);
-        const result = this.store.delete(id);
-        this.operationHistory.push({
-            operation: 'delete',
-            id,
-            existed,
-            success: result,
-        });
-        return result;
-    }
-
-    async updateIntegrationStatus(id, status) {
-        const rec = this.store.get(id);
-        if (rec) {
-            rec.status = status;
-            this.operationHistory.push({
-                operation: 'updateStatus',
-                id,
-                status,
-                success: true,
-            });
-        } else {
-            this.operationHistory.push({
-                operation: 'updateStatus',
-                id,
-                status,
-                success: false,
-            });
-        }
-        return !!rec;
-    }
-
-    getOperationHistory() {
-        return [...this.operationHistory];
-    }
-
-    clearHistory() {
-        this.operationHistory = [];
-    }
-}
-
-module.exports = { TestIntegrationRepository };

package/integrations/use-cases/create-integration.js

@@ -1,87 +0,0 @@
-const {
-    mapIntegrationClassToIntegrationDTO,
-} = require('../utils/map-integration-dto');
-
-class CreateIntegration {
-    constructor({ integrationRepository, integrationClasses, moduleFactory }) {
-        this.integrationRepository = integrationRepository;
-        this.integrationClasses = integrationClasses;
-        this.moduleFactory = moduleFactory;
-    }
-
-    async execute(entities, userId, config) {
-        const integrationClass = this.integrationClasses.find(
-            (integrationClass) =>
-                integrationClass.Definition.name === config.type
-        );
-
-        if (!integrationClass) {
-            throw new Error(
-                `No integration class found for type: ${config.type}`
-            );
-        }
-
-        const allEntities = [...entities];
-
-        if (integrationClass.Definition?.entities) {
-            for (const [entityKey, entityConfig] of Object.entries(
-                integrationClass.Definition.entities
-            )) {
-                if (entityConfig.global === true) {
-                    const globalEntity =
-                        await this.moduleFactory.moduleRepository.findEntity({
-                            moduleName: entityConfig.type,
-                            isGlobal: true,
-                        });
-
-                    if (globalEntity && globalEntity.credential?.authIsValid) {
-                        allEntities.push(globalEntity.id.toString());
-                    } else if (entityConfig.required !== false) {
-                        const reason = !globalEntity
-                            ? 'not found'
-                            : 'exists but credential is invalid';
-                        throw new Error(
-                            `Required global entity "${entityConfig.type}" ${reason}. Admin must configure this entity first.`
-                        );
-                    }
-                }
-            }
-        }
-
-        const integrationRecord =
-            await this.integrationRepository.createIntegration(
-                allEntities,
-                userId,
-                config
-            );
-
-        const modules = [];
-        for (const entityId of integrationRecord.entitiesIds) {
-            const moduleInstance = await this.moduleFactory.getModuleInstance(
-                entityId,
-                integrationRecord.userId
-            );
-            modules.push(moduleInstance);
-        }
-
-        const integrationInstance = new integrationClass({
-            id: integrationRecord.id,
-            userId: integrationRecord.userId,
-            entities: integrationRecord.entitiesIds,
-            config: integrationRecord.config,
-            status: integrationRecord.status,
-            version: integrationRecord.version,
-            messages: integrationRecord.messages,
-            modules,
-        });
-
-        await integrationInstance.initialize();
-        await integrationInstance.send('ON_CREATE', {
-            integrationId: integrationRecord.id,
-        });
-
-        return mapIntegrationClassToIntegrationDTO(integrationInstance);
-    }
-}
-
-module.exports = { CreateIntegration };