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

package/credential/repositories/credential-repository-postgres.js

@@ -0,0 +1,313 @@
+const { prisma } = require('../../database/prisma');
+const {
+    CredentialRepositoryInterface,
+} = require('./credential-repository-interface');
+
+/**
+ * PostgreSQL Credential Repository Adapter
+ * Handles OAuth credentials and API tokens persistence with PostgreSQL
+ *
+ * PostgreSQL-specific characteristics:
+ * - Uses Int IDs with autoincrement
+ * - Requires ID conversion: String (app layer) ↔ Int (database)
+ * - All returned IDs are converted to strings for application layer consistency
+ */
+class CredentialRepositoryPostgres extends CredentialRepositoryInterface {
+    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;
+    }
+
+    /**
+     * Find credential by ID
+     * Replaces: Credential.findById(id)
+     *
+     * @param {string} id - Credential ID (string from application layer)
+     * @returns {Promise<Object|null>} Credential object with string IDs or null
+     */
+    async findCredentialById(id) {
+        const intId = this._convertId(id);
+        const credential = await this.prisma.credential.findUnique({
+            where: { id: intId },
+        });
+
+        if (!credential) {
+            return null;
+        }
+
+        // Extract data from JSON field
+        const data = credential.data || {};
+
+        return {
+            _id: credential.id.toString(),
+            id: credential.id.toString(),
+            user: credential.userId?.toString(),
+            userId: credential.userId?.toString(),
+            externalId: credential.externalId,
+            authIsValid: credential.authIsValid,
+            ...data, // Spread OAuth tokens from JSON field
+        };
+    }
+
+    /**
+     * Update authentication status
+     * Replaces: Credential.updateOne({ _id: credentialId }, { $set: { authIsValid } })
+     *
+     * @param {string} credentialId - Credential ID (string from application layer)
+     * @param {boolean} authIsValid - Authentication validity status
+     * @returns {Promise<Object>} Update result
+     */
+    async updateAuthenticationStatus(credentialId, authIsValid) {
+        const intId = this._convertId(credentialId);
+        await this.prisma.credential.update({
+            where: { id: intId },
+            data: { authIsValid },
+        });
+
+        return { acknowledged: true, modifiedCount: 1 };
+    }
+
+    /**
+     * Permanently remove a credential document
+     * Replaces: Credential.deleteOne({ _id: credentialId })
+     *
+     * @param {string} credentialId - Credential ID (string from application layer)
+     * @returns {Promise<Object>} Deletion result
+     */
+    async deleteCredentialById(credentialId) {
+        try {
+            const intId = this._convertId(credentialId);
+            await this.prisma.credential.delete({
+                where: { id: intId },
+            });
+            return { acknowledged: true, deletedCount: 1 };
+        } catch (error) {
+            if (error.code === 'P2025') {
+                // Record not found
+                return { acknowledged: true, deletedCount: 0 };
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Create or update credential matching identifiers
+     * Replaces: Credential.findOneAndUpdate(query, update, { upsert: true })
+     *
+     * @param {{identifiers: Object, details: Object}} credentialDetails
+     * @returns {Promise<Object>} The persisted credential with string IDs
+     */
+    async upsertCredential(credentialDetails) {
+        const { identifiers, details } = credentialDetails;
+        if (!identifiers)
+            throw new Error('identifiers required to upsert credential');
+
+        if (!identifiers.user && !identifiers.userId) {
+            throw new Error('user or userId required in identifiers');
+        }
+        if (!identifiers.externalId) {
+            throw new Error(
+                'externalId required in identifiers to prevent credential collision. ' +
+                'When multiple credentials exist for the same user, both userId and externalId ' +
+                'are needed to uniquely identify which credential to update.'
+            );
+        }
+
+        const where = this._convertIdentifiersToWhere(identifiers);
+
+        const { user, externalId } = identifiers;
+
+        // Separate schema fields from dynamic OAuth data
+        const { authIsValid, ...oauthData } = details;
+
+        const existing = await this.prisma.credential.findFirst({ where });
+
+        if (existing) {
+            const mergedData = { ...(existing.data || {}), ...oauthData };
+
+            const updated = await this.prisma.credential.update({
+                where: { id: existing.id },
+                data: {
+                    userId: this._convertId(user || existing.userId),
+                    externalId:
+                        externalId !== undefined
+                            ? externalId
+                            : existing.externalId,
+                    authIsValid:
+                        authIsValid !== undefined
+                            ? authIsValid
+                            : existing.authIsValid,
+                    data: mergedData,
+                },
+            });
+
+            return {
+                id: updated.id.toString(),
+                externalId: updated.externalId,
+                userId: updated.userId?.toString(),
+                authIsValid: updated.authIsValid,
+                ...(updated.data || {}),
+            };
+        }
+
+        const created = await this.prisma.credential.create({
+            data: {
+                userId: this._convertId(user),
+                externalId,
+                authIsValid: authIsValid,
+                
+                data: oauthData,
+            },
+        });
+
+        return {
+            id: created.id.toString(),
+            externalId: created.externalId,
+            userId: created.userId?.toString(),
+            authIsValid: created.authIsValid,
+            ...(created.data || {}),
+        };
+    }
+
+    /**
+     * Find a credential by filter criteria
+     * Replaces: Credential.findOne(query)
+     *
+     * @param {Object} filter
+     * @param {string} [filter.userId] - User ID (string from application layer)
+     * @param {string} [filter.externalId] - External ID
+     * @param {string} [filter.credentialId] - Credential ID (string from application layer)
+     * @returns {Promise<Object|null>} Credential object with string IDs or null if not found
+     */
+    async findCredential(filter) {
+        const where = this._convertFilterToWhere(filter);
+
+        const credential = await this.prisma.credential.findFirst({
+            where,
+        });
+
+        if (!credential) {
+            return null;
+        }
+
+        const data = credential.data || {};
+
+        return {
+            id: credential.id.toString(),
+            userId: credential.userId?.toString(),
+            externalId: credential.externalId,
+            authIsValid: credential.authIsValid,
+            access_token: data.access_token,
+            refresh_token: data.refresh_token,
+            domain: data.domain,
+            ...data,
+        };
+    }
+
+    /**
+     * Update a credential by ID
+     * Replaces: Credential.findByIdAndUpdate(credentialId, { $set: updates })
+     *
+     * @param {string} credentialId - Credential ID (string from application layer)
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object|null>} Updated credential object with string IDs or null if not found
+     */
+    async updateCredential(credentialId, updates) {
+        // Get existing credential to merge OAuth data
+        const intId = this._convertId(credentialId);
+        const existing = await this.prisma.credential.findUnique({
+            where: { id: intId },
+        });
+
+        if (!existing) {
+            return null;
+        }
+
+        // Separate schema fields from OAuth data
+        const { user, authIsValid, ...oauthData } =
+            updates;
+
+        // Merge OAuth data with existing
+        const mergedData = { ...(existing.data || {}), ...oauthData };
+
+        const updated = await this.prisma.credential.update({
+            where: { id: intId },
+            data: {
+                userId: this._convertId(userId || user || existing.userId),
+                externalId:
+                    externalId !== undefined ? externalId : existing.externalId,
+                authIsValid:
+                    authIsValid !== undefined ? authIsValid : existing.authIsValid,
+                data: mergedData,
+            },
+        });
+
+        const data = updated.data || {};
+
+        return {
+            id: updated.id.toString(),
+            userId: updated.userId?.toString(),
+            externalId: updated.externalId,
+            authIsValid: updated.authIsValid,
+            access_token: data.access_token,
+            refresh_token: data.refresh_token,
+            domain: data.domain,
+            ...data,
+        };
+    }
+
+    /**
+     * Convert identifiers to Prisma where clause (converting IDs to Int)
+     * @private
+     * @param {Object} identifiers - Identifier fields
+     * @returns {Object} Prisma where clause with Int IDs
+     */
+    _convertIdentifiersToWhere(identifiers) {
+        const where = {};
+
+        if (identifiers.id) where.id = this._convertId(identifiers.id);
+        if (identifiers.user) where.userId = this._convertId(identifiers.user);
+        if (identifiers.userId)
+            where.userId = this._convertId(identifiers.userId);
+        if (identifiers.externalId) where.externalId = identifiers.externalId;
+
+        return where;
+    }
+
+    /**
+     * Convert filter to Prisma where clause (converting IDs to Int)
+     * @private
+     * @param {Object} filter - Filter criteria
+     * @returns {Object} Prisma where clause with Int IDs
+     */
+    _convertFilterToWhere(filter) {
+        const where = {};
+
+        if (filter.credentialId)
+            where.id = this._convertId(filter.credentialId);
+        if (filter.id) where.id = this._convertId(filter.id);
+        if (filter.user) where.userId = this._convertId(filter.user);
+        if (filter.userId) where.userId = this._convertId(filter.userId);
+        if (filter.externalId) where.externalId = filter.externalId;
+
+        return where;
+    }
+}
+
+module.exports = { CredentialRepositoryPostgres };

package/credential/repositories/credential-repository.js

@@ -0,0 +1,302 @@
+const { prisma } = require('../../database/prisma');
+const {
+    CredentialRepositoryInterface,
+} = require('./credential-repository-interface');
+
+/**
+ * Prisma-based Credential Repository
+ * Handles OAuth credentials and API tokens persistence
+ *
+ * Works identically for both MongoDB and PostgreSQL:
+ * - MongoDB: String IDs with @db.ObjectId
+ * - PostgreSQL: Integer IDs with auto-increment
+ * - Both use same query patterns (no many-to-many differences)
+ *
+ * Migration from Mongoose:
+ * - Constructor injection of Prisma client
+ * - Dynamic schema (strict: false) → JSON field (data)
+ * - All OAuth tokens stored in data JSON field
+ * - Mongoose field names → Prisma field names (user → userId)
+ */
+class CredentialRepository extends CredentialRepositoryInterface {
+    constructor(prismaClient = prisma) {
+        super();
+        this.prisma = prismaClient; // Allow injection for testing
+    }
+
+    /**
+     * Find credential by ID
+     * Replaces: Credential.findById(id)
+     *
+     * @param {string} id - Credential ID
+     * @returns {Promise<Object|null>} Credential object or null
+     */
+    async findCredentialById(id) {
+        const credential = await this.prisma.credential.findUnique({
+            where: { id },
+        });
+
+        if (!credential) {
+            return null;
+        }
+
+        // Extract data from JSON field
+        const data = credential.data || {};
+
+        return {
+            _id: credential.id,
+            id: credential.id,
+            user: credential.userId,
+            userId: credential.userId,
+            externalId: credential.externalId,
+            authIsValid: credential.authIsValid,
+            ...data, // Spread OAuth tokens from JSON field
+        };
+    }
+
+    /**
+     * Update authentication status
+     * Replaces: Credential.updateOne({ _id: credentialId }, { $set: { authIsValid } })
+     *
+     * @param {string} credentialId - Credential ID
+     * @param {boolean} authIsValid - Authentication validity status
+     * @returns {Promise<Object>} Update result
+     */
+    async updateAuthenticationStatus(credentialId, authIsValid) {
+        await this.prisma.credential.update({
+            where: { id: credentialId },
+            data: { authIsValid },
+        });
+
+        return { acknowledged: true, modifiedCount: 1 };
+    }
+
+    /**
+     * Permanently remove a credential document
+     * Replaces: Credential.deleteOne({ _id: credentialId })
+     *
+     * @param {string} credentialId - Credential ID
+     * @returns {Promise<Object>} Deletion result
+     */
+    async deleteCredentialById(credentialId) {
+        try {
+            await this.prisma.credential.delete({
+                where: { id: credentialId },
+            });
+            return { acknowledged: true, deletedCount: 1 };
+        } catch (error) {
+            if (error.code === 'P2025') {
+                // Record not found
+                return { acknowledged: true, deletedCount: 0 };
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Create or update credential matching identifiers
+     * Replaces: Credential.findOneAndUpdate(query, update, { upsert: true })
+     *
+     * @param {{identifiers: Object, details: Object}} credentialDetails
+     * @returns {Promise<Object>} The persisted credential
+     */
+    async upsertCredential(credentialDetails) {
+        const { identifiers, details } = credentialDetails;
+        if (!identifiers)
+            throw new Error('identifiers required to upsert credential');
+
+        // Build where clause from identifiers
+        const where = this._convertIdentifiersToWhere(identifiers);
+
+        // Separate schema fields from dynamic OAuth data
+        const {
+            user,
+            userId,
+            externalId,
+            authIsValid,
+            
+            ...oauthData
+        } = details;
+
+        // Find existing credential
+        const existing = await this.prisma.credential.findFirst({ where });
+
+        if (existing) {
+            // Update existing - merge OAuth data into existing data JSON
+            const mergedData = { ...(existing.data || {}), ...oauthData };
+
+            const updated = await this.prisma.credential.update({
+                where: { id: existing.id },
+                data: {
+                    userId: userId || user || existing.userId,
+                    externalId:
+                        externalId !== undefined
+                            ? externalId
+                            : existing.externalId,
+                    authIsValid:
+                        authIsValid !== undefined
+                            ? authIsValid
+                            : existing.authIsValid,
+                    data: mergedData,
+                },
+            });
+
+            return {
+                id: updated.id,
+                externalId: updated.externalId,
+                userId: updated.userId,
+                authIsValid: updated.authIsValid,
+                ...(updated.data || {}),
+            };
+        }
+
+        // Create new credential
+        const created = await this.prisma.credential.create({
+            data: {
+                userId: userId || user,
+                externalId,
+                authIsValid: authIsValid,
+                
+                data: oauthData,
+            },
+        });
+
+        return {
+            id: created.id,
+            externalId: created.externalId,
+            userId: created.userId,
+            authIsValid: created.authIsValid,
+            ...(created.data || {}),
+        };
+    }
+
+    /**
+     * Find a credential by filter criteria
+     * Replaces: Credential.findOne(query)
+     *
+     * @param {Object} filter
+     * @param {string} [filter.userId] - User ID
+     * @param {string} [filter.externalId] - External ID
+     * @param {string} [filter.credentialId] - Credential ID
+     * @returns {Promise<Object|null>} Credential object or null if not found
+     */
+    async findCredential(filter) {
+        const where = this._convertFilterToWhere(filter);
+
+        const credential = await this.prisma.credential.findFirst({
+            where,
+        });
+
+        if (!credential) {
+            return null;
+        }
+
+        const data = credential.data || {};
+
+        return {
+            id: credential.id,
+            userId: credential.userId,
+            externalId: credential.externalId,
+            authIsValid: credential.authIsValid,
+            access_token: data.access_token,
+            refresh_token: data.refresh_token,
+            domain: data.domain,
+            ...data,
+        };
+    }
+
+    /**
+     * Update a credential by ID
+     * Replaces: Credential.findByIdAndUpdate(credentialId, { $set: updates })
+     *
+     * @param {string} credentialId - Credential ID
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object|null>} Updated credential object or null if not found
+     */
+    async updateCredential(credentialId, updates) {
+        // Get existing credential to merge OAuth data
+        const existing = await this.prisma.credential.findUnique({
+            where: { id: credentialId },
+        });
+
+        if (!existing) {
+            return null;
+        }
+
+        // Separate schema fields from OAuth data
+        const {
+            user,
+            userId,
+            externalId,
+            authIsValid,
+            
+            ...oauthData
+        } = updates;
+
+        // Merge OAuth data with existing
+        const mergedData = { ...(existing.data || {}), ...oauthData };
+
+        const updated = await this.prisma.credential.update({
+            where: { id: credentialId },
+            data: {
+                userId: userId || user || existing.userId,
+                externalId:
+                    externalId !== undefined ? externalId : existing.externalId,
+                authIsValid:
+                    authIsValid !== undefined ? authIsValid : existing.authIsValid,
+                data: mergedData,
+            },
+        });
+
+        const data = updated.data || {};
+
+        return {
+            id: updated.id,
+            userId: updated.userId,
+            externalId: updated.externalId,
+            authIsValid: updated.authIsValid,
+            access_token: data.access_token,
+            refresh_token: data.refresh_token,
+            domain: data.domain,
+            ...data,
+        };
+    }
+
+    /**
+     * Convert identifiers to Prisma where clause
+     * @private
+     * @param {Object} identifiers - Identifier fields
+     * @returns {Object} Prisma where clause
+     */
+    _convertIdentifiersToWhere(identifiers) {
+        const where = {};
+
+        if (identifiers._id) where.id = identifiers._id;
+        if (identifiers.id) where.id = identifiers.id;
+        if (identifiers.user) where.userId = identifiers.user;
+        if (identifiers.userId) where.userId = identifiers.userId;
+        if (identifiers.externalId) where.externalId = identifiers.externalId;
+
+        return where;
+    }
+
+    /**
+     * Convert filter to Prisma where clause
+     * @private
+     * @param {Object} filter - Filter criteria
+     * @returns {Object} Prisma where clause
+     */
+    _convertFilterToWhere(filter) {
+        const where = {};
+
+        if (filter.credentialId) where.id = filter.credentialId;
+        if (filter.id) where.id = filter.id;
+        if (filter.user) where.userId = filter.user;
+        if (filter.userId) where.userId = filter.userId;
+        if (filter.externalId) where.externalId = filter.externalId;
+
+        return where;
+    }
+}
+
+module.exports = { CredentialRepository };

package/credential/use-cases/get-credential-for-user.js

@@ -0,0 +1,21 @@
+class GetCredentialForUser {
+    constructor({ credentialRepository }) {
+        this.credentialRepository = credentialRepository;
+    }
+
+    async execute(credentialId, userId) {
+        const credential = await this.credentialRepository.findCredentialById(credentialId);
+
+        if (!credential) {
+            throw new Error(`Credential with id ${credentialId} not found`);
+        }
+
+        if (credential.user.toString() !== userId.toString()) {
+            throw new Error(`Credential ${credentialId} does not belong to user ${userId}`);
+        }
+
+        return credential;
+    }
+}
+
+module.exports = { GetCredentialForUser };

package/credential/use-cases/update-authentication-status.js

@@ -0,0 +1,15 @@
+class UpdateAuthenticationStatus {
+    constructor({ credentialRepository }) {
+        this.credentialRepository = credentialRepository;
+    }
+
+    /**
+     * @param {string} credentialId
+     * @param {boolean} authIsValid
+     */
+    async execute(credentialId, authIsValid) {
+        await this.credentialRepository.updateAuthenticationStatus(credentialId, authIsValid);
+    }
+}
+
+module.exports = { UpdateAuthenticationStatus };