@friggframework/core 2.0.0-next.5 → 2.0.0-next.50

package/syncs/repositories/sync-repository-factory.js

@@ -0,0 +1,38 @@
+const { SyncRepositoryMongo } = require('./sync-repository-mongo');
+const { SyncRepositoryPostgres } = require('./sync-repository-postgres');
+const config = require('../../database/config');
+
+/**
+ * Sync Repository Factory
+ * Creates the appropriate repository adapter based on database type
+ *
+ * Usage:
+ * ```javascript
+ * const repository = createSyncRepository();
+ * ```
+ *
+ * @returns {SyncRepositoryInterface} Configured repository adapter
+ */
+function createSyncRepository() {
+    const dbType = config.DB_TYPE;
+
+    switch (dbType) {
+        case 'mongodb':
+            return new SyncRepositoryMongo();
+
+        case 'postgresql':
+            return new SyncRepositoryPostgres();
+
+        default:
+            throw new Error(
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+            );
+    }
+}
+
+module.exports = {
+    createSyncRepository,
+    // Export adapters for direct testing
+    SyncRepositoryMongo,
+    SyncRepositoryPostgres,
+};

package/syncs/repositories/sync-repository-interface.js

@@ -0,0 +1,109 @@
+/**
+ * Sync Repository Interface
+ * Abstract base class defining the contract for sync persistence adapters
+ *
+ * This follows the Port in Hexagonal Architecture:
+ * - Domain layer depends on this abstraction
+ * - Concrete adapters (MongoDB, PostgreSQL) implement this interface
+ * - Use cases receive repositories via dependency injection
+ *
+ * @abstract
+ */
+class SyncRepositoryInterface {
+    /**
+     * Get a sync object by name, data identifier, and entity
+     *
+     * @param {string} name - The sync object name
+     * @param {Object} dataIdentifier - The data identifier object
+     * @param {string|number} entity - The entity ID
+     * @returns {Promise<Object|null>} The sync object or null
+     * @abstract
+     */
+    async getSyncObject(name, dataIdentifier, entity) {
+        throw new Error('Method getSyncObject must be implemented by subclass');
+    }
+
+    /**
+     * Create or update a sync object
+     *
+     * @param {Object} filter - Filter criteria for finding existing sync
+     * @param {Object} syncData - Sync data to create/update
+     * @returns {Promise<Object>} The created or updated sync object
+     * @abstract
+     */
+    async upsertSync(filter, syncData) {
+        throw new Error('Method upsertSync must be implemented by subclass');
+    }
+
+    /**
+     * Update a sync object by ID
+     *
+     * @param {string|number} id - The sync object ID
+     * @param {Object} updates - Updates to apply
+     * @returns {Promise<Object>} The updated sync object
+     * @abstract
+     */
+    async updateSync(id, updates) {
+        throw new Error('Method updateSync must be implemented by subclass');
+    }
+
+    /**
+     * Add a data identifier to a sync object
+     *
+     * @param {string|number} syncId - The sync object ID
+     * @param {Object} dataIdentifier - The data identifier to add
+     * @returns {Promise<Object>} The updated sync object
+     * @abstract
+     */
+    async addDataIdentifier(syncId, dataIdentifier) {
+        throw new Error('Method addDataIdentifier must be implemented by subclass');
+    }
+
+    /**
+     * Get entity object ID for entity ID from sync object
+     * This is a pure helper method (no database access)
+     *
+     * @param {Object} syncObj - The sync object
+     * @param {string|number} entityId - The entity ID
+     * @returns {Object} The entity object ID
+     * @abstract
+     */
+    getEntityObjIdForEntityIdFromObject(syncObj, entityId) {
+        throw new Error('Method getEntityObjIdForEntityIdFromObject must be implemented by subclass');
+    }
+
+    /**
+     * Find sync objects by filter
+     *
+     * @param {Object} filter - Filter criteria
+     * @returns {Promise<Array>} Array of sync objects
+     * @abstract
+     */
+    async findSyncs(filter) {
+        throw new Error('Method findSyncs must be implemented by subclass');
+    }
+
+    /**
+     * Find one sync object by filter
+     *
+     * @param {Object} filter - Filter criteria
+     * @returns {Promise<Object|null>} The sync object or null
+     * @abstract
+     */
+    async findOneSync(filter) {
+        throw new Error('Method findOneSync must be implemented by subclass');
+    }
+
+    /**
+     * Delete a sync object by ID
+     *
+     * @param {string|number} id - The sync object ID
+     * @returns {Promise<Object>} The deletion result
+     * @abstract
+     */
+    async deleteSync(id) {
+        throw new Error('Method deleteSync must be implemented by subclass');
+    }
+}
+
+module.exports = { SyncRepositoryInterface };

package/syncs/repositories/sync-repository-mongo.js

@@ -0,0 +1,239 @@
+const { prisma } = require('../../database/prisma');
+const { SyncRepositoryInterface } = require('./sync-repository-interface');
+
+/**
+ * MongoDB Sync Repository Adapter
+ * Handles sync persistence using Prisma with MongoDB
+ *
+ * MongoDB-specific characteristics:
+ * - Uses scalar fields for entity relations (entityIds)
+ * - IDs are strings with @db.ObjectId
+ * - Arrays used for many-to-many relationships
+ *
+ * Migration from Mongoose:
+ * - Mongoose static methods → Repository instance methods
+ * - Mongoose populate() → Prisma include
+ * - Nested arrays → Separate DataIdentifier model
+ */
+class SyncRepositoryMongo extends SyncRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+    }
+
+    /**
+     * Get a sync object by name, data identifier, and entity
+     * Replaces: Sync.getSyncObject(name, dataIdentifier, entity)
+     *
+     * @param {string} name - The sync object name
+     * @param {Object} dataIdentifier - The data identifier object
+     * @param {string} entity - The entity ID (MongoDB ObjectId)
+     * @returns {Promise<Object|null>} The sync object or null
+     */
+    async getSyncObject(name, dataIdentifier, entity) {
+        const syncList = await this.prisma.sync.findMany({
+            where: {
+                name,
+                dataIdentifiers: {
+                    some: {
+                        idData: dataIdentifier,
+                        entityId: entity,
+                    },
+                },
+            },
+            include: {
+                entities: true,
+                dataIdentifiers: {
+                    include: {
+                        entity: true,
+                    },
+                },
+            },
+        });
+
+        if (syncList.length === 1) {
+            return syncList[0];
+        } else if (syncList.length === 0) {
+            return null;
+        } else {
+            throw new Error(
+                `There are multiple sync objects with the name ${name}, for entities [${syncList[0].entities}] [${syncList[1].entities}]`
+            );
+        }
+    }
+
+    /**
+     * Create or update a sync object
+     * Replaces: Sync.upsert(filter, syncData)
+     *
+     * @param {Object} filter - Filter criteria for finding existing sync
+     * @param {Object} syncData - Sync data to create/update
+     * @returns {Promise<Object>} The created or updated sync object
+     */
+    async upsertSync(filter, syncData) {
+        // Find existing sync
+        const where = this._convertFilterToWhere(filter);
+        const existing = await this.prisma.sync.findFirst({ where });
+
+        if (existing) {
+            // Update existing
+            return await this.prisma.sync.update({
+                where: { id: existing.id },
+                data: syncData,
+            });
+        }
+
+        // Create new
+        return await this.prisma.sync.create({
+            data: syncData,
+        });
+    }
+
+    /**
+     * Update a sync object by ID
+     * Replaces: Sync.update({ _id: id }, updates)
+     *
+     * @param {string} id - The sync object ID
+     * @param {Object} updates - Updates to apply
+     * @returns {Promise<Object>} The updated sync object
+     */
+    async updateSync(id, updates) {
+        return await this.prisma.sync.update({
+            where: { id },
+            data: updates,
+        });
+    }
+
+    /**
+     * Add a data identifier to a sync object
+     * Replaces: Sync.addDataIdentifier(syncId, dataIdentifier)
+     *
+     * @param {string} syncId - The sync object ID
+     * @param {Object} dataIdentifier - The data identifier to add
+     * @returns {Promise<Object>} The updated sync object
+     */
+    async addDataIdentifier(syncId, dataIdentifier) {
+        // In Prisma, we create a new DataIdentifier record linked to the Sync
+        await this.prisma.dataIdentifier.create({
+            data: {
+                syncId,
+                entityId: dataIdentifier.entity,
+                idData: dataIdentifier.id,
+                hash: dataIdentifier.hash,
+            },
+        });
+
+        // Return updated sync object
+        return await this.prisma.sync.findUnique({
+            where: { id: syncId },
+            include: {
+                dataIdentifiers: true,
+            },
+        });
+    }
+
+    /**
+     * Get entity object ID for entity ID from sync object
+     * Replaces: Sync.getEntityObjIdForEntityIdFromObject(syncObj, entityId)
+     *
+     * This is a pure helper method (no database access)
+     *
+     * @param {Object} syncObj - The sync object
+     * @param {string} entityId - The entity ID
+     * @returns {Object} The entity object ID
+     */
+    getEntityObjIdForEntityIdFromObject(syncObj, entityId) {
+        if (!syncObj.dataIdentifiers) {
+            throw new Error('Sync object must include dataIdentifiers');
+        }
+
+        for (let dataIdentifier of syncObj.dataIdentifiers) {
+            if (dataIdentifier.entityId === entityId) {
+                return dataIdentifier.idData;
+            }
+        }
+
+        throw new Error(
+            `Sync object ${syncObj.id} does not contain a data identifier for entity ${entityId}`
+        );
+    }
+
+    /**
+     * Find sync objects by filter
+     * Replaces: Sync.find(filter)
+     *
+     * @param {Object} filter - Filter criteria
+     * @returns {Promise<Array>} Array of sync objects
+     */
+    async findSyncs(filter) {
+        const where = this._convertFilterToWhere(filter);
+        return await this.prisma.sync.findMany({
+            where,
+            include: {
+                entities: true,
+                dataIdentifiers: {
+                    include: {
+                        entity: true,
+                    },
+                },
+            },
+        });
+    }
+
+    /**
+     * Find one sync object by filter
+     * Replaces: Sync.findOne(filter)
+     *
+     * @param {Object} filter - Filter criteria
+     * @returns {Promise<Object|null>} The sync object or null
+     */
+    async findOneSync(filter) {
+        const where = this._convertFilterToWhere(filter);
+        return await this.prisma.sync.findFirst({
+            where,
+            include: {
+                entities: true,
+                dataIdentifiers: {
+                    include: {
+                        entity: true,
+                    },
+                },
+            },
+        });
+    }
+
+    /**
+     * Delete a sync object by ID
+     * Replaces: Sync.deleteOne({ _id: id })
+     *
+     * @param {string} id - The sync object ID
+     * @returns {Promise<Object>} The deletion result
+     */
+    async deleteSync(id) {
+        // Prisma will cascade delete dataIdentifiers automatically
+        return await this.prisma.sync.delete({
+            where: { id },
+        });
+    }
+
+    /**
+     * Convert Mongoose-style filter to Prisma where clause
+     * @private
+     * @param {Object} filter - Mongoose filter
+     * @returns {Object} Prisma where clause
+     */
+    _convertFilterToWhere(filter) {
+        const where = {};
+
+        // Handle _id field (Mongoose uses _id, Prisma uses id)
+        if (filter._id) {
+            where.id = filter._id;
+            delete filter._id;
+        }
+
+        // Copy remaining filters
+        return { ...where, ...filter };
+    }
+}
+
+module.exports = { SyncRepositoryMongo };

package/syncs/repositories/sync-repository-postgres.js

@@ -0,0 +1,319 @@
+const { prisma } = require('../../database/prisma');
+const { SyncRepositoryInterface } = require('./sync-repository-interface');
+
+/**
+ * PostgreSQL Sync Repository Adapter
+ * Handles sync persistence using Prisma with PostgreSQL
+ *
+ * PostgreSQL-specific characteristics:
+ * - Uses implicit join tables for entity relations (_EntityToSync)
+ * - Uses Int IDs with autoincrement
+ * - Requires ID conversion: String (app layer) ↔ Int (database)
+ * - All returned IDs are converted to strings for application layer consistency
+ * - Uses connect/disconnect syntax for relations
+ */
+class SyncRepositoryPostgres extends SyncRepositoryInterface {
+    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 sync object IDs to strings
+     * @private
+     * @param {Object|null} sync - Sync object from database
+     * @returns {Object|null} Sync with string IDs
+     */
+    _convertSyncIds(sync) {
+        if (!sync) return sync;
+        return {
+            ...sync,
+            id: sync.id?.toString(),
+            integrationId: sync.integrationId?.toString(),
+            entities: sync.entities?.map(e => ({
+                ...e,
+                id: e.id?.toString(),
+                userId: e.userId?.toString(),
+                credentialId: e.credentialId?.toString()
+            })),
+            dataIdentifiers: sync.dataIdentifiers?.map(di => ({
+                ...di,
+                id: di.id?.toString(),
+                syncId: di.syncId?.toString(),
+                entityId: di.entityId?.toString(),
+                entity: di.entity ? {
+                    ...di.entity,
+                    id: di.entity.id?.toString(),
+                    userId: di.entity.userId?.toString(),
+                    credentialId: di.entity.credentialId?.toString()
+                } : di.entity
+            }))
+        };
+    }
+
+    /**
+     * Get a sync object by name, data identifier, and entity
+     *
+     * @param {string} name - The sync object name
+     * @param {Object} dataIdentifier - The data identifier object
+     * @param {string} entity - The entity ID (string from application layer)
+     * @returns {Promise<Object|null>} The sync object with string IDs or null
+     */
+    async getSyncObject(name, dataIdentifier, entity) {
+        const intEntityId = this._convertId(entity);
+        const syncList = await this.prisma.sync.findMany({
+            where: {
+                name,
+                dataIdentifiers: {
+                    some: {
+                        idData: dataIdentifier,
+                        entityId: intEntityId,
+                    },
+                },
+            },
+            include: {
+                entities: true,
+                dataIdentifiers: {
+                    include: {
+                        entity: true,
+                    },
+                },
+            },
+        });
+
+        if (syncList.length === 1) {
+            return this._convertSyncIds(syncList[0]);
+        } else if (syncList.length === 0) {
+            return null;
+        } else {
+            throw new Error(
+                `There are multiple sync objects with the name ${name}, for entities [${syncList[0].entities}] [${syncList[1].entities}]`
+            );
+        }
+    }
+
+    /**
+     * Create or update a sync object
+     *
+     * @param {Object} filter - Filter criteria for finding existing sync
+     * @param {Object} syncData - Sync data to create/update (with string IDs from application layer)
+     * @returns {Promise<Object>} The created or updated sync object with string IDs
+     */
+    async upsertSync(filter, syncData) {
+        // Find existing sync
+        const where = this._convertFilterToWhere(filter);
+        const existing = await this.prisma.sync.findFirst({ where });
+
+        // Convert IDs in syncData if present
+        const convertedData = { ...syncData };
+        if (convertedData.integrationId) {
+            convertedData.integrationId = this._convertId(convertedData.integrationId);
+        }
+
+        if (existing) {
+            // Update existing
+            const updated = await this.prisma.sync.update({
+                where: { id: existing.id },
+                data: convertedData,
+            });
+            return this._convertSyncIds(updated);
+        }
+
+        // Create new
+        const created = await this.prisma.sync.create({
+            data: convertedData,
+        });
+        return this._convertSyncIds(created);
+    }
+
+    /**
+     * Update a sync object by ID
+     *
+     * @param {string} id - The sync object ID (string from application layer)
+     * @param {Object} updates - Updates to apply (with string IDs from application layer)
+     * @returns {Promise<Object>} The updated sync object with string IDs
+     */
+    async updateSync(id, updates) {
+        const intId = this._convertId(id);
+
+        // Convert IDs in updates if present
+        const convertedUpdates = { ...updates };
+        if (convertedUpdates.integrationId) {
+            convertedUpdates.integrationId = this._convertId(convertedUpdates.integrationId);
+        }
+
+        const updated = await this.prisma.sync.update({
+            where: { id: intId },
+            data: convertedUpdates,
+        });
+        return this._convertSyncIds(updated);
+    }
+
+    /**
+     * Add a data identifier to a sync object
+     *
+     * @param {string} syncId - The sync object ID (string from application layer)
+     * @param {Object} dataIdentifier - The data identifier to add (with string entity ID)
+     * @returns {Promise<Object>} The updated sync object with string IDs
+     */
+    async addDataIdentifier(syncId, dataIdentifier) {
+        const intSyncId = this._convertId(syncId);
+        const intEntityId = this._convertId(dataIdentifier.entity);
+
+        // In Prisma, we create a new DataIdentifier record linked to the Sync
+        await this.prisma.dataIdentifier.create({
+            data: {
+                syncId: intSyncId,
+                entityId: intEntityId,
+                idData: dataIdentifier.id,
+                hash: dataIdentifier.hash,
+            },
+        });
+
+        // Return updated sync object
+        const sync = await this.prisma.sync.findUnique({
+            where: { id: intSyncId },
+            include: {
+                dataIdentifiers: true,
+            },
+        });
+        return this._convertSyncIds(sync);
+    }
+
+    /**
+     * Get entity object ID for entity ID from sync object
+     *
+     * This is a pure helper method (no database access)
+     *
+     * @param {Object} syncObj - The sync object (with string IDs from application layer)
+     * @param {string} entityId - The entity ID (string from application layer)
+     * @returns {Object} The entity object ID
+     */
+    getEntityObjIdForEntityIdFromObject(syncObj, entityId) {
+        if (!syncObj.dataIdentifiers) {
+            throw new Error('Sync object must include dataIdentifiers');
+        }
+
+        for (let dataIdentifier of syncObj.dataIdentifiers) {
+            // Compare string IDs (both should be strings at this point)
+            if (dataIdentifier.entityId === entityId) {
+                return dataIdentifier.idData;
+            }
+        }
+
+        throw new Error(
+            `Sync object ${syncObj.id} does not contain a data identifier for entity ${entityId}`
+        );
+    }
+
+    /**
+     * Find sync objects by filter
+     *
+     * @param {Object} filter - Filter criteria (with string IDs from application layer)
+     * @returns {Promise<Array>} Array of sync objects with string IDs
+     */
+    async findSyncs(filter) {
+        const where = this._convertFilterToWhere(filter);
+        const syncs = await this.prisma.sync.findMany({
+            where,
+            include: {
+                entities: true,
+                dataIdentifiers: {
+                    include: {
+                        entity: true,
+                    },
+                },
+            },
+        });
+        return syncs.map(sync => this._convertSyncIds(sync));
+    }
+
+    /**
+     * Find one sync object by filter
+     *
+     * @param {Object} filter - Filter criteria (with string IDs from application layer)
+     * @returns {Promise<Object|null>} The sync object with string IDs or null
+     */
+    async findOneSync(filter) {
+        const where = this._convertFilterToWhere(filter);
+        const sync = await this.prisma.sync.findFirst({
+            where,
+            include: {
+                entities: true,
+                dataIdentifiers: {
+                    include: {
+                        entity: true,
+                    },
+                },
+            },
+        });
+        return this._convertSyncIds(sync);
+    }
+
+    /**
+     * Delete a sync object by ID
+     *
+     * @param {string} id - The sync object ID (string from application layer)
+     * @returns {Promise<Object>} The deletion result with string IDs
+     */
+    async deleteSync(id) {
+        const intId = this._convertId(id);
+        // Prisma will cascade delete dataIdentifiers automatically
+        const deleted = await this.prisma.sync.delete({
+            where: { id: intId },
+        });
+        return this._convertSyncIds(deleted);
+    }
+
+    /**
+     * Convert Mongoose-style filter to Prisma where clause (converting IDs to Int)
+     * @private
+     * @param {Object} filter - Mongoose filter (with string IDs from application layer)
+     * @returns {Object} Prisma where clause (with Int IDs for PostgreSQL)
+     */
+    _convertFilterToWhere(filter) {
+        const where = {};
+
+        // Handle _id field (Mongoose uses _id, Prisma uses id)
+        if (filter._id) {
+            where.id = this._convertId(filter._id);
+        }
+
+        // Handle id field
+        if (filter.id) {
+            where.id = this._convertId(filter.id);
+        }
+
+        // Handle integrationId field
+        if (filter.integrationId) {
+            where.integrationId = this._convertId(filter.integrationId);
+        }
+
+        // Handle integration field (Mongoose uses integration, Prisma uses integrationId)
+        if (filter.integration) {
+            where.integrationId = this._convertId(filter.integration);
+        }
+
+        // Copy non-ID fields
+        const { _id, id, integrationId, integration, ...rest } = filter;
+        return { ...where, ...rest };
+    }
+}
+
+module.exports = { SyncRepositoryPostgres };

package/syncs/sync.js

@@ -1,5 +1,4 @@
 const md5 = require("md5");
-const ModuleManager = require('../module-plugin');
 const { debug } = require("packages/logs");
 const { get } = require("packages/assertions");