@friggframework/core 2.0.0-next.6 → 2.0.0-next.61

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

@@ -0,0 +1,240 @@
+const { prisma } = require('../../database/prisma');
+const {
+    toObjectId,
+    fromObjectId,
+    findMany,
+    findOne,
+    insertOne,
+    updateOne,
+    deleteOne,
+} = require('../../database/documentdb-utils');
+const { SyncRepositoryInterface } = require('./sync-repository-interface');
+
+class SyncRepositoryDocumentDB extends SyncRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+    }
+
+    async getSyncObject(name, dataIdentifier, entity) {
+        const pipeline = [
+            {
+                $match: {
+                    name,
+                    dataIdentifiers: {
+                        $elemMatch: {
+                            idData: dataIdentifier,
+                            entityId: toObjectId(entity),
+                        },
+                    },
+                },
+            },
+            {
+                $limit: 2,
+            },
+        ];
+
+        const result = await this.prisma.$runCommandRaw({
+            aggregate: 'Sync',
+            pipeline,
+            cursor: {},
+        });
+
+        const syncList = result?.cursor?.firstBatch || [];
+
+        if (syncList.length === 1) {
+            const doc = syncList[0];
+            return this._mapSync(doc);
+        } else if (syncList.length === 0) {
+            return null;
+        }
+        throw new Error(
+            `There are multiple sync objects with the name ${name}, for entities [${syncList[0]?.entities}] [${syncList[1]?.entities}]`
+        );
+    }
+
+    async upsertSync(filter, syncData) {
+        const query = this._convertFilter(filter);
+        const existing = await findOne(this.prisma, 'Sync', query);
+
+        const now = new Date();
+        const documentData = this._prepareSyncData(syncData, now);
+
+        if (existing) {
+            await updateOne(
+                this.prisma,
+                'Sync',
+                { _id: existing._id },
+                {
+                    $set: documentData,
+                }
+            );
+            const updated = await findOne(this.prisma, 'Sync', { _id: existing._id });
+            return this._mapSync(updated);
+        }
+
+        const insertedId = await insertOne(this.prisma, 'Sync', {
+            ...documentData,
+            createdAt: now,
+        });
+        const created = await findOne(this.prisma, 'Sync', { _id: insertedId });
+        return this._mapSync(created);
+    }
+
+    async updateSync(id, updates) {
+        const objectId = toObjectId(id);
+        if (!objectId) return null;
+        const documentData = this._prepareSyncData(updates, new Date());
+        await updateOne(
+            this.prisma,
+            'Sync',
+            { _id: objectId },
+            {
+                $set: documentData,
+            }
+        );
+        const updated = await findOne(this.prisma, 'Sync', { _id: objectId });
+        return updated ? this._mapSync(updated) : null;
+    }
+
+    async addDataIdentifier(syncId, dataIdentifier) {
+        const syncObjectId = toObjectId(syncId);
+        if (!syncObjectId) return null;
+        const doc = await findOne(this.prisma, 'Sync', { _id: syncObjectId });
+        if (!doc) return null;
+
+        const identifiers = Array.isArray(doc.dataIdentifiers) ? [...doc.dataIdentifiers] : [];
+        identifiers.push({
+            syncId: syncObjectId,
+            entityId: toObjectId(dataIdentifier.entity),
+            idData: dataIdentifier.id,
+            hash: dataIdentifier.hash,
+            createdAt: new Date(),
+        });
+
+        await updateOne(
+            this.prisma,
+            'Sync',
+            { _id: syncObjectId },
+            {
+                $set: {
+                    dataIdentifiers: identifiers,
+                    updatedAt: new Date(),
+                },
+            }
+        );
+
+        const updated = await findOne(this.prisma, 'Sync', { _id: syncObjectId });
+        return updated ? this._mapSync(updated) : null;
+    }
+
+    getEntityObjIdForEntityIdFromObject(syncObj, entityId) {
+        if (!syncObj || !Array.isArray(syncObj.dataIdentifiers)) {
+            throw new Error('Sync object must include dataIdentifiers');
+        }
+
+        const entry = syncObj.dataIdentifiers.find(
+            (identifier) => fromObjectId(identifier.entityId) === String(entityId)
+        );
+
+        if (entry) {
+            return entry.idData;
+        }
+
+        throw new Error(
+            `Sync object ${syncObj.id} does not contain a data identifier for entity ${entityId}`
+        );
+    }
+
+    async findSyncs(filter) {
+        const query = this._convertFilter(filter);
+        const docs = await findMany(this.prisma, 'Sync', query);
+        return docs.map((doc) => this._mapSync(doc));
+    }
+
+    async findOneSync(filter) {
+        const query = this._convertFilter(filter);
+        const doc = await findOne(this.prisma, 'Sync', query);
+        return doc ? this._mapSync(doc) : null;
+    }
+
+    async deleteSync(id) {
+        const objectId = toObjectId(id);
+        if (!objectId) return { acknowledged: true, deletedCount: 0 };
+        const result = await deleteOne(this.prisma, 'Sync', { _id: objectId });
+        const deleted = result?.n ?? 0;
+        return { acknowledged: true, deletedCount: deleted };
+    }
+
+    _convertFilter(filter = {}) {
+        const query = { ...filter };
+        if (filter._id || filter.id) {
+            const idObj = toObjectId(filter._id || filter.id);
+            if (idObj) query._id = idObj;
+            delete query._id;
+            delete query.id;
+        }
+        if (filter.integrationId) {
+            query.integrationId = toObjectId(filter.integrationId);
+        }
+        if (filter.entities) {
+            query.entityIds = (filter.entities || []).map((id) => toObjectId(id)).filter(Boolean);
+            delete query.entities;
+        }
+        return query;
+    }
+
+    _prepareSyncData(data = {}, timestamp) {
+        const prepared = {};
+        if (data.integrationId !== undefined) {
+            prepared.integrationId = toObjectId(data.integrationId);
+        }
+        if (data.entities !== undefined || data.entityIds !== undefined) {
+            const list = data.entities !== undefined ? data.entities : data.entityIds;
+            prepared.entityIds = (list || []).map((id) => toObjectId(id)).filter(Boolean);
+        }
+        if (data.hash !== undefined) prepared.hash = data.hash;
+        if (data.name !== undefined) prepared.name = data.name;
+        if (data.context !== undefined) prepared.context = data.context;
+        if (data.results !== undefined) prepared.results = data.results;
+        if (timestamp) prepared.updatedAt = timestamp;
+        if (data.dataIdentifiers !== undefined) {
+            prepared.dataIdentifiers = (data.dataIdentifiers || []).map((identifier) => ({
+                syncId: toObjectId(identifier.syncId),
+                entityId: toObjectId(identifier.entityId),
+                idData: identifier.idData,
+                hash: identifier.hash,
+                createdAt: identifier.createdAt ? new Date(identifier.createdAt) : new Date(),
+            }));
+        }
+        return prepared;
+    }
+
+    _mapSync(doc) {
+        if (!doc) return null;
+        return {
+            id: fromObjectId(doc._id),
+            integrationId: doc.integrationId ? fromObjectId(doc.integrationId) : null,
+            entities: Array.isArray(doc.entityIds)
+                ? doc.entityIds.map((id) => fromObjectId(id))
+                : [],
+            entityIds: Array.isArray(doc.entityIds)
+                ? doc.entityIds.map((id) => fromObjectId(id))
+                : [],
+            hash: doc.hash ?? null,
+            name: doc.name ?? null,
+            dataIdentifiers: Array.isArray(doc.dataIdentifiers)
+                ? doc.dataIdentifiers.map((identifier) => ({
+                      syncId: identifier.syncId ? fromObjectId(identifier.syncId) : null,
+                      entityId: identifier.entityId ? fromObjectId(identifier.entityId) : null,
+                      idData: identifier.idData,
+                      hash: identifier.hash,
+                  }))
+                : [],
+        };
+    }
+}
+
+module.exports = { SyncRepositoryDocumentDB };
+
+

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

@@ -0,0 +1,43 @@
+const { SyncRepositoryMongo } = require('./sync-repository-mongo');
+const { SyncRepositoryPostgres } = require('./sync-repository-postgres');
+const { SyncRepositoryDocumentDB } = require('./sync-repository-documentdb');
+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();
+
+        case 'documentdb':
+            return new SyncRepositoryDocumentDB();
+
+        default:
+            throw new Error(
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
+            );
+    }
+}
+
+module.exports = {
+    createSyncRepository,
+    // Export adapters for direct testing
+    SyncRepositoryMongo,
+    SyncRepositoryPostgres,
+    SyncRepositoryDocumentDB,
+};

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 };