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

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

@@ -1,5 +1,6 @@
 const { SyncRepositoryMongo } = require('./sync-repository-mongo');
 const { SyncRepositoryPostgres } = require('./sync-repository-postgres');
+const { SyncRepositoryDocumentDB } = require('./sync-repository-documentdb');
 const config = require('../../database/config');
 
 /**
@@ -23,9 +24,12 @@ function createSyncRepository() {
         case 'postgresql':
             return new SyncRepositoryPostgres();
 
+        case 'documentdb':
+            return new SyncRepositoryDocumentDB();
+
         default:
             throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
             );
     }
 }
@@ -35,4 +39,5 @@ module.exports = {
     // Export adapters for direct testing
     SyncRepositoryMongo,
     SyncRepositoryPostgres,
+    SyncRepositoryDocumentDB,
 };

package/token/repositories/token-repository-documentdb.js

@@ -0,0 +1,125 @@
+const { prisma } = require('../../database/prisma');
+const bcrypt = require('bcryptjs');
+const {
+    toObjectId,
+    fromObjectId,
+    findMany,
+    findOne,
+    insertOne,
+    deleteOne,
+    deleteMany,
+} = require('../../database/documentdb-utils');
+const { TokenRepositoryInterface } = require('./token-repository-interface');
+
+const BCRYPT_ROUNDS = 10;
+
+class TokenRepositoryDocumentDB extends TokenRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+    }
+
+    async createTokenWithExpire(userId, rawToken, minutes) {
+        const tokenHash = await bcrypt.hash(rawToken, BCRYPT_ROUNDS);
+        const expires = new Date(Date.now() + minutes * 60000);
+        const now = new Date();
+        const document = {
+            token: tokenHash,
+            expires,
+            userId: toObjectId(userId),
+            created: now,
+        };
+        const insertedId = await insertOne(this.prisma, 'Token', document);
+        const created = await findOne(this.prisma, 'Token', { _id: insertedId });
+        return this._mapToken(created);
+    }
+
+    async validateAndGetToken(tokenObj) {
+        const objectId = toObjectId(tokenObj.id);
+        if (!objectId) {
+            throw new Error('Invalid Token: Token does not exist');
+        }
+        const record = await findOne(this.prisma, 'Token', { _id: objectId });
+        if (!record) {
+            throw new Error('Invalid Token: Token does not exist');
+        }
+        const isValid = await bcrypt.compare(tokenObj.token, record.token);
+        if (!isValid) {
+            throw new Error('Invalid Token: Token does not match');
+        }
+        if (record.expires && new Date(record.expires) < new Date()) {
+            throw new Error('Invalid Token: Token is expired');
+        }
+        return this._mapToken(record);
+    }
+
+    async findTokenById(tokenId) {
+        const objectId = toObjectId(tokenId);
+        if (!objectId) return null;
+        const record = await findOne(this.prisma, 'Token', { _id: objectId });
+        return record ? this._mapToken(record) : null;
+    }
+
+    async findTokensByUserId(userId) {
+        const objectId = toObjectId(userId);
+        const filter = objectId ? { userId: objectId } : {};
+        const records = await findMany(this.prisma, 'Token', filter);
+        return records.map((record) => this._mapToken(record));
+    }
+
+    async deleteToken(tokenId) {
+        const objectId = toObjectId(tokenId);
+        if (!objectId) return { acknowledged: true, deletedCount: 0 };
+        const result = await deleteOne(this.prisma, 'Token', { _id: objectId });
+        const deleted = result?.n ?? 0;
+        return { acknowledged: true, deletedCount: deleted };
+    }
+
+    async deleteExpiredTokens() {
+        const result = await deleteMany(this.prisma, 'Token', {
+            expires: { $lt: new Date() },
+        });
+        const deleted = result?.n ?? 0;
+        return { acknowledged: true, deletedCount: deleted };
+    }
+
+    async deleteTokensByUserId(userId) {
+        const objectId = toObjectId(userId);
+        if (!objectId) return { acknowledged: true, deletedCount: 0 };
+        const result = await deleteMany(this.prisma, 'Token', { userId: objectId });
+        const deleted = result?.n ?? 0;
+        return { acknowledged: true, deletedCount: deleted };
+    }
+
+    createJSONToken(token, rawToken) {
+        return JSON.stringify({
+            id: token.id,
+            token: rawToken,
+        });
+    }
+
+    createBase64BufferToken(token, rawToken) {
+        const jsonVal = this.createJSONToken(token, rawToken);
+        return Buffer.from(jsonVal).toString('base64');
+    }
+
+    getJSONTokenFromBase64BufferToken(buffer) {
+        const tokenStr = Buffer.from(buffer.trim(), 'base64').toString('ascii');
+        return JSON.parse(tokenStr);
+    }
+
+    _mapToken(record) {
+        if (!record) return null;
+        return {
+            id: fromObjectId(record._id),
+            token: record.token,
+            expires: record.expires ? new Date(record.expires) : null,
+            userId: fromObjectId(record.userId),
+            created: record.created ? new Date(record.created) : null,
+        };
+    }
+}
+
+module.exports = { TokenRepositoryDocumentDB };
+
+

package/token/repositories/token-repository-factory.js

@@ -1,5 +1,8 @@
 const { TokenRepositoryMongo } = require('./token-repository-mongo');
 const { TokenRepositoryPostgres } = require('./token-repository-postgres');
+const {
+    TokenRepositoryDocumentDB,
+} = require('./token-repository-documentdb');
 const config = require('../../database/config');
 
 /**
@@ -18,9 +21,12 @@ function createTokenRepository() {
         case 'postgresql':
             return new TokenRepositoryPostgres();
 
+        case 'documentdb':
+            return new TokenRepositoryDocumentDB();
+
         default:
             throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
             );
     }
 }
@@ -30,4 +36,5 @@ module.exports = {
     // Export adapters for direct testing
     TokenRepositoryMongo,
     TokenRepositoryPostgres,
+    TokenRepositoryDocumentDB,
 };