@friggframework/core 2.0.0--canary.490.dfd8df5.0 → 2.0.0--canary.490.1d4d68c.0

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

@@ -1,216 +0,0 @@
-const { prisma } = require('../../database/prisma');
-const bcrypt = require('bcryptjs');
-const { TokenRepositoryInterface } = require('./token-repository-interface');
-const { BaseRepositoryMongoDB } = require('../../database/repositories/base-repository-mongodb');
-
-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();
-        
-        // Use MongoDB base repository for DocumentDB compatibility
-        const mongoBase = new BaseRepositoryMongoDB({ prismaClient: prisma });
-        this.prisma = mongoBase.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/user/repositories/user-repository-mongo.js

@@ -1,295 +0,0 @@
-const bcrypt = require('bcryptjs');
-const { prisma } = require('../../database/prisma');
-const {
-    createTokenRepository,
-} = require('../../token/repositories/token-repository-factory');
-const { UserRepositoryInterface } = require('./user-repository-interface');
-const { BaseRepositoryMongoDB } = require('../../database/repositories/base-repository-mongodb');
-
-/**
- * MongoDB User Repository Adapter
- * Handles user operations with discriminator pattern support
- *
- * MongoDB-specific characteristics:
- * - Uses String IDs (ObjectId)
- * - No ID conversion needed (IDs are already strings)
- * - IndividualUser/OrganizationUser discriminators → User model with type field
- */
-class UserRepositoryMongo extends UserRepositoryInterface {
-    constructor() {
-        super();
-        
-        // Use MongoDB base repository for DocumentDB compatibility
-        const mongoBase = new BaseRepositoryMongoDB({ prismaClient: prisma });
-        this.prisma = mongoBase.prisma;
-        this.tokenRepository = createTokenRepository();
-    }
-
-    /**
-     * Get session token from base64 buffer token
-     * Delegates to TokenRepository
-     *
-     * @param {string} token - Base64 buffer token
-     * @returns {Promise<Object>} Session token object with string IDs
-     */
-    async getSessionToken(token) {
-        const jsonToken =
-            this.tokenRepository.getJSONTokenFromBase64BufferToken(token);
-        const sessionToken = await this.tokenRepository.validateAndGetToken(
-            jsonToken
-        );
-        return sessionToken;
-    }
-
-    /**
-     * Find organization user by ID
-     * Replaces: OrganizationUser.findById(userId)
-     *
-     * @param {string} userId - User ID
-     * @returns {Promise<Object|null>} User object with string IDs or null
-     */
-    async findOrganizationUserById(userId) {
-        return await this.prisma.user.findFirst({
-            where: {
-                id: userId,
-                type: 'ORGANIZATION',
-            },
-        });
-    }
-
-    /**
-     * Find individual user by ID
-     * Replaces: IndividualUser.findById(userId)
-     *
-     * @param {string} userId - User ID
-     * @returns {Promise<Object|null>} User object with string IDs or null
-     */
-    async findIndividualUserById(userId) {
-        return await this.prisma.user.findFirst({
-            where: {
-                id: userId,
-                type: 'INDIVIDUAL',
-            },
-        });
-    }
-
-    /**
-     * Create token with expiration
-     * Delegates to TokenRepository
-     *
-     * @param {string} userId - User ID
-     * @param {string} rawToken - Raw unhashed token
-     * @param {number} minutes - Minutes until expiration (default 120)
-     * @returns {Promise<string>} Base64 buffer token
-     */
-    async createToken(userId, rawToken, minutes = 120) {
-        const createdToken = await this.tokenRepository.createTokenWithExpire(
-            userId,
-            rawToken,
-            minutes
-        );
-        return this.tokenRepository.createBase64BufferToken(
-            createdToken,
-            rawToken
-        );
-    }
-
-    /**
-     * Create individual user
-     * Replaces: IndividualUser.create(params)
-     *
-     * @param {Object} params - User creation parameters
-     * @param {string} [params.hashword] - Plain text password (will be bcrypt hashed automatically)
-     * @returns {Promise<Object>} Created user object with string IDs
-     */
-    async createIndividualUser(params) {
-        const data = {
-            type: 'INDIVIDUAL',
-            email: params.email,
-            username: params.username,
-            appUserId: params.appUserId,
-            organizationId: params.organization || params.organizationId,
-        };
-
-        if (
-            params.hashword !== undefined &&
-            params.hashword !== null &&
-            params.hashword !== ''
-        ) {
-            if (typeof params.hashword !== 'string') {
-                throw new Error('Password must be a string');
-            }
-
-            // Prevent double-hashing: bcrypt hashes start with $2a$ or $2b$
-            if (params.hashword.startsWith('$2')) {
-                throw new Error(
-                    'Password appears to be already hashed. Pass plain text password only.'
-                );
-            }
-
-            data.hashword = await bcrypt.hash(params.hashword, 10);
-        }
-
-        return await this.prisma.user.create({ data });
-    }
-
-    /**
-     * Create organization user
-     * Replaces: OrganizationUser.create(params)
-     *
-     * @param {Object} params - Organization creation parameters
-     * @returns {Promise<Object>} Created organization object with string IDs
-     */
-    async createOrganizationUser(params) {
-        return await this.prisma.user.create({
-            data: {
-                type: 'ORGANIZATION',
-                appOrgId: params.appOrgId,
-                name: params.name,
-            },
-        });
-    }
-
-    /**
-     * Find individual user by username
-     * Replaces: IndividualUser.findOne({ username })
-     *
-     * @param {string} username - Username to search for
-     * @returns {Promise<Object|null>} User object with string IDs or null
-     */
-    async findIndividualUserByUsername(username) {
-        return await this.prisma.user.findFirst({
-            where: {
-                type: 'INDIVIDUAL',
-                username,
-            },
-        });
-    }
-
-    /**
-     * Find individual user by app user ID
-     * Replaces: IndividualUser.getUserByAppUserId(appUserId)
-     *
-     * @param {string} appUserId - App user ID to search for
-     * @returns {Promise<Object|null>} User object with string IDs or null
-     */
-    async findIndividualUserByAppUserId(appUserId) {
-        return await this.prisma.user.findFirst({
-            where: {
-                type: 'INDIVIDUAL',
-                appUserId,
-            },
-        });
-    }
-
-    /**
-     * Find organization user by app org ID
-     * Replaces: OrganizationUser.getUserByAppOrgId(appOrgId)
-     *
-     * @param {string} appOrgId - App organization ID to search for
-     * @returns {Promise<Object|null>} User object with string IDs or null
-     */
-    async findOrganizationUserByAppOrgId(appOrgId) {
-        return await this.prisma.user.findFirst({
-            where: {
-                type: 'ORGANIZATION',
-                appOrgId,
-            },
-        });
-    }
-
-    /**
-     * Find user by ID (any type)
-     * @param {string} userId - User ID
-     * @returns {Promise<Object|null>} User object with string IDs or null
-     */
-    async findUserById(userId) {
-        return await this.prisma.user.findUnique({
-            where: { id: userId },
-        });
-    }
-
-    /**
-     * Find individual user by email
-     * @param {string} email - Email to search for
-     * @returns {Promise<Object|null>} User object with string IDs or null
-     */
-    async findIndividualUserByEmail(email) {
-        return await this.prisma.user.findFirst({
-            where: {
-                type: 'INDIVIDUAL',
-                email,
-            },
-        });
-    }
-
-    /**
-     * Update individual user
-     * @param {string} userId - User ID
-     * @param {Object} updates - Fields to update
-     * @param {string} [updates.hashword] - Plain text password (will be bcrypt hashed automatically)
-     * @returns {Promise<Object>} Updated user object with string IDs
-     */
-    async updateIndividualUser(userId, updates) {
-        const data = { ...updates };
-
-        if (
-            data.hashword !== undefined &&
-            data.hashword !== null &&
-            data.hashword !== ''
-        ) {
-            if (typeof data.hashword !== 'string') {
-                throw new Error('Password must be a string');
-            }
-
-            // Prevent double-hashing: bcrypt hashes start with $2a$ or $2b$
-            if (data.hashword.startsWith('$2')) {
-                throw new Error(
-                    'Password appears to be already hashed. Pass plain text password only.'
-                );
-            }
-
-            data.hashword = await bcrypt.hash(data.hashword, 10);
-        }
-
-        return await this.prisma.user.update({
-            where: { id: userId },
-            data,
-        });
-    }
-
-    /**
-     * Update organization user
-     * @param {string} userId - User ID
-     * @param {Object} updates - Fields to update
-     * @returns {Promise<Object>} Updated user object with string IDs
-     */
-    async updateOrganizationUser(userId, updates) {
-        return await this.prisma.user.update({
-            where: { id: userId },
-            data: updates,
-        });
-    }
-
-    /**
-     * Delete user by ID
-     * @param {string} userId - User ID to delete
-     * @returns {Promise<boolean>} True if deleted successfully
-     */
-    async deleteUser(userId) {
-        try {
-            await this.prisma.user.delete({
-                where: { id: userId },
-            });
-            return true;
-        } catch (error) {
-            if (error.code === 'P2025') {
-                // Record not found
-                return false;
-            }
-            throw error;
-        }
-    }
-}
-
-module.exports = { UserRepositoryMongo };

package/websocket/repositories/websocket-connection-repository-mongo.js

@@ -1,160 +0,0 @@
-const { prisma } = require('../../database/prisma');
-const {
-    ApiGatewayManagementApiClient,
-    PostToConnectionCommand,
-} = require('@aws-sdk/client-apigatewaymanagementapi');
-const {
-    WebsocketConnectionRepositoryInterface,
-} = require('./websocket-connection-repository-interface');
-const { BaseRepositoryMongoDB } = require('../../database/repositories/base-repository-mongodb');
-
-/**
- * MongoDB WebSocket Connection Repository Adapter
- * Handles persistence of active WebSocket connections
- *
- * MongoDB-specific characteristics:
- * - Uses String IDs (ObjectId)
- * - No ID conversion needed (IDs are already strings)
- * - AWS API Gateway Management API integration preserved
- */
-class WebsocketConnectionRepositoryMongo extends WebsocketConnectionRepositoryInterface {
-    constructor() {
-        super();
-        
-        // Use MongoDB base repository for DocumentDB compatibility
-        const mongoBase = new BaseRepositoryMongoDB({ prismaClient: prisma });
-        this.prisma = mongoBase.prisma;
-    }
-
-    /**
-     * Create a new WebSocket connection record
-     * Replaces: WebsocketConnection.create({ connectionId })
-     *
-     * @param {string} connectionId - The WebSocket connection ID
-     * @returns {Promise<Object>} The created connection record with string IDs
-     */
-    async createConnection(connectionId) {
-        return await this.prisma.websocketConnection.create({
-            data: { connectionId },
-        });
-    }
-
-    /**
-     * Delete a WebSocket connection record
-     * Replaces: WebsocketConnection.deleteOne({ connectionId })
-     *
-     * @param {string} connectionId - The WebSocket connection ID to delete
-     * @returns {Promise<Object>} The deletion result
-     */
-    async deleteConnection(connectionId) {
-        try {
-            await this.prisma.websocketConnection.delete({
-                where: { connectionId },
-            });
-            return { acknowledged: true, deletedCount: 1 };
-        } catch (error) {
-            if (error.code === 'P2025') {
-                // Record not found
-                return { acknowledged: true, deletedCount: 0 };
-            }
-            throw error;
-        }
-    }
-
-    /**
-     * Get all active WebSocket connections with send capability
-     * Replaces: WebsocketConnection.getActiveConnections()
-     *
-     * @returns {Promise<Array>} Array of active connection objects with send capability
-     */
-    async getActiveConnections() {
-        try {
-            // Return empty array if websockets are not configured
-            if (!process.env.WEBSOCKET_API_ENDPOINT) {
-                return [];
-            }
-
-            const connections = await this.prisma.websocketConnection.findMany({
-                select: { connectionId: true },
-            });
-
-            return connections.map((conn) => ({
-                connectionId: conn.connectionId,
-                send: async (data) => {
-                    const apigwManagementApi = new ApiGatewayManagementApiClient({
-                        endpoint: process.env.WEBSOCKET_API_ENDPOINT,
-                    });
-
-                    try {
-                        const command = new PostToConnectionCommand({
-                            ConnectionId: conn.connectionId,
-                            Data: JSON.stringify(data),
-                        });
-                        await apigwManagementApi.send(command);
-                    } catch (error) {
-                        if (error.statusCode === 410 || error.$metadata?.httpStatusCode === 410) {
-                            console.log(
-                                `Stale connection ${conn.connectionId}`
-                            );
-                            // Delete stale connection
-                            await this.prisma.websocketConnection.deleteMany({
-                                where: { connectionId: conn.connectionId },
-                            });
-                        } else {
-                            throw error;
-                        }
-                    }
-                },
-            }));
-        } catch (error) {
-            console.error('Error getting active connections:', error);
-            throw error;
-        }
-    }
-
-    /**
-     * Find a connection by connection ID
-     * Replaces: WebsocketConnection.findOne({ connectionId })
-     *
-     * @param {string} connectionId - The WebSocket connection ID
-     * @returns {Promise<Object|null>} The connection record with string IDs or null
-     */
-    async findConnection(connectionId) {
-        return await this.prisma.websocketConnection.findFirst({
-            where: { connectionId },
-        });
-    }
-
-    /**
-     * Find connection by internal ID
-     * @param {string} id - The internal connection ID
-     * @returns {Promise<Object|null>} The connection record with string IDs or null
-     */
-    async findConnectionById(id) {
-        return await this.prisma.websocketConnection.findUnique({
-            where: { id },
-        });
-    }
-
-    /**
-     * Get all connections
-     * @returns {Promise<Array>} Array of all connection records with string IDs
-     */
-    async getAllConnections() {
-        return await this.prisma.websocketConnection.findMany();
-    }
-
-    /**
-     * Delete all connections
-     * @returns {Promise<Object>} The deletion result
-     */
-    async deleteAllConnections() {
-        const result = await this.prisma.websocketConnection.deleteMany();
-        return {
-            acknowledged: true,
-            deletedCount: result.count,
-        };
-    }
-}
-
-module.exports = { WebsocketConnectionRepositoryMongo };