@friggframework/core 2.0.0-next.41 → 2.0.0-next.43

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

@@ -0,0 +1,33 @@
+const { TokenRepositoryMongo } = require('./token-repository-mongo');
+const { TokenRepositoryPostgres } = require('./token-repository-postgres');
+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();
+
+        default:
+            throw new Error(
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+            );
+    }
+}
+
+module.exports = {
+    createTokenRepository,
+    // Export adapters for direct testing
+    TokenRepositoryMongo,
+    TokenRepositoryPostgres,
+};

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

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

@@ -0,0 +1,212 @@
+const { prisma } = require('../../database/prisma');
+const bcrypt = require('bcryptjs');
+const { TokenRepositoryInterface } = require('./token-repository-interface');
+
+const BCRYPT_ROUNDS = 10;
+
+/**
+ * MongoDB Token Repository Adapter
+ * Handles persistence of authentication tokens with bcrypt hashing
+ *
+ * MongoDB-specific characteristics:
+ * - Uses String IDs (ObjectId)
+ * - No ID conversion needed (IDs are already strings)
+ * - Bcrypt hashing handled in repository layer
+ */
+class TokenRepositoryMongo extends TokenRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+    }
+
+    /**
+     * Create a token with expiration
+     * Replaces: Token.createTokenWithExpire(userId, rawToken, minutes)
+     *
+     * @param {string} userId - The user ID
+     * @param {string} rawToken - The raw (unhashed) token string
+     * @param {number} minutes - Minutes until expiration
+     * @returns {Promise<Object>} The created token record with string IDs
+     */
+    async createTokenWithExpire(userId, rawToken, minutes) {
+        // Hash the token with bcrypt
+        const tokenHash = await bcrypt.hash(rawToken, BCRYPT_ROUNDS);
+
+        // Calculate expiration time
+        const expires = new Date(Date.now() + minutes * 60000);
+
+        return await this.prisma.token.create({
+            data: {
+                token: tokenHash,
+                expires,
+                userId,
+            },
+        });
+    }
+
+    /**
+     * Validate and retrieve token from JSON token object
+     * Replaces: Token.validateAndGetTokenFromJSONToken(tokenObj)
+     *
+     * @param {Object} tokenObj - Object with id and token properties
+     * @returns {Promise<Object>} The validated token record with string IDs
+     * @throws {Error} If token is invalid, expired, or doesn't exist
+     */
+    async validateAndGetToken(tokenObj) {
+        const sessionToken = await this.prisma.token.findUnique({
+            where: { id: tokenObj.id },
+        });
+
+        if (!sessionToken) {
+            throw new Error('Invalid Token: Token does not exist');
+        }
+
+        // Verify token hash matches
+        const isValid = await bcrypt.compare(
+            tokenObj.token,
+            sessionToken.token
+        );
+        if (!isValid) {
+            throw new Error('Invalid Token: Token does not match');
+        }
+
+        // Check if token is expired
+        if (
+            sessionToken.expires &&
+            new Date(sessionToken.expires) < new Date()
+        ) {
+            throw new Error('Invalid Token: Token is expired');
+        }
+
+        return sessionToken;
+    }
+
+    /**
+     * Find a token by ID
+     * Replaces: Token.findById(tokenId)
+     *
+     * @param {string} tokenId - The token ID
+     * @returns {Promise<Object|null>} The token record with string IDs or null
+     */
+    async findTokenById(tokenId) {
+        return await this.prisma.token.findUnique({
+            where: { id: tokenId },
+        });
+    }
+
+    /**
+     * Find tokens by user ID
+     * Replaces: Token.find({ user: userId })
+     *
+     * @param {string} userId - The user ID
+     * @returns {Promise<Array>} Array of token records with string IDs
+     */
+    async findTokensByUserId(userId) {
+        return await this.prisma.token.findMany({
+            where: { userId },
+        });
+    }
+
+    /**
+     * Delete a token by ID
+     * Replaces: Token.deleteOne({ _id: tokenId })
+     *
+     * @param {string} tokenId - The token ID
+     * @returns {Promise<Object>} The deletion result
+     */
+    async deleteToken(tokenId) {
+        try {
+            await this.prisma.token.delete({
+                where: { id: tokenId },
+            });
+            return { acknowledged: true, deletedCount: 1 };
+        } catch (error) {
+            if (error.code === 'P2025') {
+                // Record not found
+                return { acknowledged: true, deletedCount: 0 };
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Delete expired tokens
+     * Replaces: Token.deleteMany({ expires: { $lt: new Date() } })
+     *
+     * @returns {Promise<Object>} The deletion result with count
+     */
+    async deleteExpiredTokens() {
+        const result = await this.prisma.token.deleteMany({
+            where: {
+                expires: {
+                    lt: new Date(),
+                },
+            },
+        });
+
+        return {
+            acknowledged: true,
+            deletedCount: result.count,
+        };
+    }
+
+    /**
+     * Delete all tokens for a user
+     * Replaces: Token.deleteMany({ user: userId })
+     *
+     * @param {string} userId - The user ID
+     * @returns {Promise<Object>} The deletion result
+     */
+    async deleteTokensByUserId(userId) {
+        const result = await this.prisma.token.deleteMany({
+            where: { userId },
+        });
+
+        return {
+            acknowledged: true,
+            deletedCount: result.count,
+        };
+    }
+
+    /**
+     * Create JSON token string from token object and raw token
+     * Replaces: Token.createJSONToken(token, rawToken)
+     *
+     * @param {Object} token - The token record
+     * @param {string} rawToken - The raw token string
+     * @returns {string} JSON string with id and token
+     */
+    createJSONToken(token, rawToken) {
+        return JSON.stringify({
+            id: token.id,
+            token: rawToken,
+        });
+    }
+
+    /**
+     * Create base64 encoded buffer token
+     * Replaces: Token.createBase64BufferToken(token, rawToken)
+     *
+     * @param {Object} token - The token record
+     * @param {string} rawToken - The raw token string
+     * @returns {string} Base64 encoded token
+     */
+    createBase64BufferToken(token, rawToken) {
+        const jsonVal = this.createJSONToken(token, rawToken);
+        return Buffer.from(jsonVal).toString('base64');
+    }
+
+    /**
+     * Parse JSON token from base64 buffer
+     * Replaces: Token.getJSONTokenFromBase64BufferToken(buffer)
+     *
+     * @param {string} buffer - Base64 encoded token string
+     * @returns {Object} Parsed token object with id and token
+     */
+    getJSONTokenFromBase64BufferToken(buffer) {
+        const tokenStr = Buffer.from(buffer.trim(), 'base64').toString('ascii');
+        return JSON.parse(tokenStr);
+    }
+}
+
+module.exports = { TokenRepositoryMongo };

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

@@ -0,0 +1,257 @@
+const { prisma } = require('../../database/prisma');
+const bcrypt = require('bcryptjs');
+const { TokenRepositoryInterface } = require('./token-repository-interface');
+
+const BCRYPT_ROUNDS = 10;
+
+/**
+ * PostgreSQL Token Repository Adapter
+ * Handles persistence of authentication tokens with bcrypt hashing
+ *
+ * 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 TokenRepositoryPostgres extends TokenRepositoryInterface {
+    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 token object IDs to strings
+     * @private
+     * @param {Object|null} token - Token object from database
+     * @returns {Object|null} Token with string IDs
+     */
+    _convertTokenIds(token) {
+        if (!token) return token;
+        return {
+            ...token,
+            id: token.id?.toString(),
+            userId: token.userId?.toString(),
+        };
+    }
+
+    /**
+     * Create a token with expiration
+     * Replaces: Token.createTokenWithExpire(userId, rawToken, minutes)
+     *
+     * @param {string} userId - The user ID (string from application layer)
+     * @param {string} rawToken - The raw (unhashed) token string
+     * @param {number} minutes - Minutes until expiration
+     * @returns {Promise<Object>} The created token record with string IDs
+     */
+    async createTokenWithExpire(userId, rawToken, minutes) {
+        // Hash the token with bcrypt
+        const tokenHash = await bcrypt.hash(rawToken, BCRYPT_ROUNDS);
+
+        // Calculate expiration time
+        const expires = new Date(Date.now() + minutes * 60000);
+
+        const token = await this.prisma.token.create({
+            data: {
+                token: tokenHash,
+                expires,
+                userId: this._convertId(userId),
+            },
+        });
+
+        return this._convertTokenIds(token);
+    }
+
+    /**
+     * Validate and retrieve token from JSON token object
+     * Replaces: Token.validateAndGetTokenFromJSONToken(tokenObj)
+     *
+     * @param {Object} tokenObj - Object with id and token properties (id as string from app layer)
+     * @returns {Promise<Object>} The validated token record with string IDs
+     * @throws {Error} If token is invalid, expired, or doesn't exist
+     */
+    async validateAndGetToken(tokenObj) {
+        const intId = this._convertId(tokenObj.id);
+        const sessionToken = await this.prisma.token.findUnique({
+            where: { id: intId },
+        });
+
+        if (!sessionToken) {
+            throw new Error('Invalid Token: Token does not exist');
+        }
+
+        // Verify token hash matches
+        const isValid = await bcrypt.compare(
+            tokenObj.token,
+            sessionToken.token
+        );
+        if (!isValid) {
+            throw new Error('Invalid Token: Token does not match');
+        }
+
+        // Check if token is expired
+        if (
+            sessionToken.expires &&
+            new Date(sessionToken.expires) < new Date()
+        ) {
+            throw new Error('Invalid Token: Token is expired');
+        }
+
+        return this._convertTokenIds(sessionToken);
+    }
+
+    /**
+     * Find a token by ID
+     * Replaces: Token.findById(tokenId)
+     *
+     * @param {string} tokenId - The token ID (string from application layer)
+     * @returns {Promise<Object|null>} The token record with string IDs or null
+     */
+    async findTokenById(tokenId) {
+        const intId = this._convertId(tokenId);
+        const token = await this.prisma.token.findUnique({
+            where: { id: intId },
+        });
+        return this._convertTokenIds(token);
+    }
+
+    /**
+     * Find tokens by user ID
+     * Replaces: Token.find({ user: userId })
+     *
+     * @param {string} userId - The user ID (string from application layer)
+     * @returns {Promise<Array>} Array of token records with string IDs
+     */
+    async findTokensByUserId(userId) {
+        const intUserId = this._convertId(userId);
+        const tokens = await this.prisma.token.findMany({
+            where: { userId: intUserId },
+        });
+        return tokens.map((token) => this._convertTokenIds(token));
+    }
+
+    /**
+     * Delete a token by ID
+     * Replaces: Token.deleteOne({ _id: tokenId })
+     *
+     * @param {string} tokenId - The token ID (string from application layer)
+     * @returns {Promise<Object>} The deletion result
+     */
+    async deleteToken(tokenId) {
+        try {
+            const intId = this._convertId(tokenId);
+            await this.prisma.token.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;
+        }
+    }
+
+    /**
+     * Delete expired tokens
+     * Replaces: Token.deleteMany({ expires: { $lt: new Date() } })
+     *
+     * @returns {Promise<Object>} The deletion result with count
+     */
+    async deleteExpiredTokens() {
+        const result = await this.prisma.token.deleteMany({
+            where: {
+                expires: {
+                    lt: new Date(),
+                },
+            },
+        });
+
+        return {
+            acknowledged: true,
+            deletedCount: result.count,
+        };
+    }
+
+    /**
+     * Delete all tokens for a user
+     * Replaces: Token.deleteMany({ user: userId })
+     *
+     * @param {string} userId - The user ID (string from application layer)
+     * @returns {Promise<Object>} The deletion result
+     */
+    async deleteTokensByUserId(userId) {
+        const intUserId = this._convertId(userId);
+        const result = await this.prisma.token.deleteMany({
+            where: { userId: intUserId },
+        });
+
+        return {
+            acknowledged: true,
+            deletedCount: result.count,
+        };
+    }
+
+    /**
+     * Create JSON token string from token object and raw token
+     * Replaces: Token.createJSONToken(token, rawToken)
+     *
+     * Note: Token ID is already a string at this point (from _convertTokenIds),
+     * so no conversion needed here.
+     *
+     * @param {Object} token - The token record (with string IDs)
+     * @param {string} rawToken - The raw token string
+     * @returns {string} JSON string with id and token
+     */
+    createJSONToken(token, rawToken) {
+        return JSON.stringify({
+            id: token.id,
+            token: rawToken,
+        });
+    }
+
+    /**
+     * Create base64 encoded buffer token
+     * Replaces: Token.createBase64BufferToken(token, rawToken)
+     *
+     * @param {Object} token - The token record (with string IDs)
+     * @param {string} rawToken - The raw token string
+     * @returns {string} Base64 encoded token
+     */
+    createBase64BufferToken(token, rawToken) {
+        const jsonVal = this.createJSONToken(token, rawToken);
+        return Buffer.from(jsonVal).toString('base64');
+    }
+
+    /**
+     * Parse JSON token from base64 buffer
+     * Replaces: Token.getJSONTokenFromBase64BufferToken(buffer)
+     *
+     * Note: Parsed token ID will be a string, which is correct for application layer
+     *
+     * @param {string} buffer - Base64 encoded token string
+     * @returns {Object} Parsed token object with id and token (id as string)
+     */
+    getJSONTokenFromBase64BufferToken(buffer) {
+        const tokenStr = Buffer.from(buffer.trim(), 'base64').toString('ascii');
+        return JSON.parse(tokenStr);
+    }
+}
+
+module.exports = { TokenRepositoryPostgres };