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

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");
 

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

@@ -0,0 +1,137 @@
+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 { ClientSafeError } = require('../../errors');
+
+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 ClientSafeError(
+                'Invalid Token: Token does not exist',
+                401
+            );
+        }
+        const record = await findOne(this.prisma, 'Token', { _id: objectId });
+        if (!record) {
+            throw new ClientSafeError(
+                'Invalid Token: Token does not exist',
+                401
+            );
+        }
+        const isValid = await bcrypt.compare(tokenObj.token, record.token);
+        if (!isValid) {
+            throw new ClientSafeError(
+                'Invalid Token: Token does not match',
+                401
+            );
+        }
+        if (record.expires && new Date(record.expires) < new Date()) {
+            throw new ClientSafeError('Invalid Token: Token is expired', 401);
+        }
+        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

@@ -0,0 +1,40 @@
+const { TokenRepositoryMongo } = require('./token-repository-mongo');
+const { TokenRepositoryPostgres } = require('./token-repository-postgres');
+const {
+    TokenRepositoryDocumentDB,
+} = require('./token-repository-documentdb');
+const config = require('../../database/config');
+
+/**
+ * Token Repository Factory
+ * Creates the appropriate repository adapter based on database type
+ *
+ * @returns {TokenRepositoryInterface} Configured repository adapter
+ */
+function createTokenRepository() {
+    const dbType = config.DB_TYPE;
+
+    switch (dbType) {
+        case 'mongodb':
+            return new TokenRepositoryMongo();
+
+        case 'postgresql':
+            return new TokenRepositoryPostgres();
+
+        case 'documentdb':
+            return new TokenRepositoryDocumentDB();
+
+        default:
+            throw new Error(
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
+            );
+    }
+}
+
+module.exports = {
+    createTokenRepository,
+    // Export adapters for direct testing
+    TokenRepositoryMongo,
+    TokenRepositoryPostgres,
+    TokenRepositoryDocumentDB,
+};

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

@@ -0,0 +1,131 @@
+/**
+ * Token Repository Interface
+ * Abstract base class defining the contract for token persistence adapters
+ *
+ * This follows the Port in Hexagonal Architecture:
+ * - Domain layer depends on this abstraction
+ * - Concrete adapters implement this interface
+ * - Use cases receive repositories via dependency injection
+ *
+ * Note: Currently, Token model has identical structure across MongoDB and PostgreSQL,
+ * so TokenRepository serves both. This interface exists for consistency and
+ * future-proofing if database-specific implementations become needed.
+ *
+ * @abstract
+ */
+class TokenRepositoryInterface {
+    /**
+     * Create token with expiration
+     *
+     * @param {string|number} userId - User ID
+     * @param {string} rawToken - Raw unhashed token
+     * @param {number} minutes - Minutes until expiration
+     * @returns {Promise<Object>} Created token object
+     * @abstract
+     */
+    async createTokenWithExpire(userId, rawToken, minutes) {
+        throw new Error(
+            'Method createTokenWithExpire must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Validate and get token
+     *
+     * @param {Object} tokenObj - Token object with id and token
+     * @returns {Promise<Object>} Validated token object
+     * @abstract
+     */
+    async validateAndGetToken(tokenObj) {
+        throw new Error(
+            'Method validateAndGetToken must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find token by ID
+     *
+     * @param {string|number} tokenId - Token ID
+     * @returns {Promise<Object|null>} Token object or null
+     * @abstract
+     */
+    async findTokenById(tokenId) {
+        throw new Error('Method findTokenById must be implemented by subclass');
+    }
+
+    /**
+     * Find all tokens for a user
+     *
+     * @param {string|number} userId - User ID
+     * @returns {Promise<Array>} Array of token objects
+     * @abstract
+     */
+    async findTokensByUserId(userId) {
+        throw new Error(
+            'Method findTokensByUserId must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Delete token by ID
+     *
+     * @param {string|number} tokenId - Token ID
+     * @returns {Promise<boolean>} True if deleted
+     * @abstract
+     */
+    async deleteToken(tokenId) {
+        throw new Error('Method deleteToken must be implemented by subclass');
+    }
+
+    /**
+     * Delete expired tokens
+     *
+     * @returns {Promise<number>} Number of deleted tokens
+     * @abstract
+     */
+    async deleteExpiredTokens() {
+        throw new Error(
+            'Method deleteExpiredTokens must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Delete all tokens for a user
+     *
+     * @param {string|number} userId - User ID
+     * @returns {Promise<number>} Number of deleted tokens
+     * @abstract
+     */
+    async deleteTokensByUserId(userId) {
+        throw new Error(
+            'Method deleteTokensByUserId must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Create base64 buffer token
+     *
+     * @param {Object} token - Token object
+     * @param {string} rawToken - Raw token
+     * @returns {string} Base64 encoded token
+     */
+    createBase64BufferToken(token, rawToken) {
+        throw new Error(
+            'Method createBase64BufferToken must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Get JSON token from base64 buffer token
+     *
+     * @param {string} base64Token - Base64 encoded token
+     * @returns {Object} Decoded token object
+     */
+    getJSONTokenFromBase64BufferToken(base64Token) {
+        throw new Error(
+            'Method getJSONTokenFromBase64BufferToken must be implemented by subclass'
+        );
+    }
+}
+
+module.exports = { TokenRepositoryInterface };