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

package/utils/backend-path.js

@@ -0,0 +1,38 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const PACKAGE_JSON = 'package.json';
+
+function findNearestBackendPackageJson() {
+    let currentDir = process.cwd();
+    
+    // First check if we're in production by looking for package.json in the current directory
+    const rootPackageJson = path.join(currentDir, PACKAGE_JSON);
+    if (fs.existsSync(rootPackageJson)) {
+        // In production environment, check for index.js in the same directory
+        const indexJs = path.join(currentDir, 'index.js');
+        if (fs.existsSync(indexJs)) {
+            return rootPackageJson;
+        }
+    }
+
+    // If not found at root or not in production, look for it in the backend directory
+    while (currentDir !== path.parse(currentDir).root) {
+        const packageJsonPath = path.join(currentDir, 'backend', PACKAGE_JSON);
+        if (fs.existsSync(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+
+function validateBackendPath(backendPath) {
+    if (!backendPath) {
+        throw new Error('Could not find a backend package.json file.');
+    }
+}
+
+module.exports = {
+    findNearestBackendPackageJson,
+    validateBackendPath,
+}; 

package/utils/index.js

@@ -0,0 +1,6 @@
+const { findNearestBackendPackageJson, validateBackendPath } = require('./backend-path');
+
+module.exports = {
+    findNearestBackendPackageJson,
+    validateBackendPath,
+};

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

@@ -0,0 +1,119 @@
+const { prisma } = require('../../database/prisma');
+const {
+    ApiGatewayManagementApiClient,
+    PostToConnectionCommand,
+} = require('@aws-sdk/client-apigatewaymanagementapi');
+const {
+    toObjectId,
+    fromObjectId,
+    findMany,
+    findOne,
+    insertOne,
+    deleteOne,
+    deleteMany,
+} = require('../../database/documentdb-utils');
+const {
+    WebsocketConnectionRepositoryInterface,
+} = require('./websocket-connection-repository-interface');
+
+class WebsocketConnectionRepositoryDocumentDB extends WebsocketConnectionRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+    }
+
+    async createConnection(connectionId) {
+        const now = new Date();
+        const document = {
+            connectionId,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const insertedId = await insertOne(this.prisma, 'WebsocketConnection', document);
+        const created = await findOne(this.prisma, 'WebsocketConnection', { _id: insertedId });
+        return this._mapConnection(created);
+    }
+
+    async deleteConnection(connectionId) {
+        const result = await deleteOne(this.prisma, 'WebsocketConnection', { connectionId });
+        const deleted = result?.n ?? 0;
+        return { acknowledged: true, deletedCount: deleted };
+    }
+
+    async getActiveConnections() {
+        if (!process.env.WEBSOCKET_API_ENDPOINT) {
+            return [];
+        }
+
+        const connections = await findMany(
+            this.prisma,
+            'WebsocketConnection',
+            {},
+            { projection: { connectionId: 1 } }
+        );
+
+        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}`);
+                        await deleteMany(this.prisma, 'WebsocketConnection', {
+                            connectionId: conn.connectionId,
+                        });
+                    } else {
+                        throw error;
+                    }
+                }
+            },
+        }));
+    }
+
+    async findConnection(connectionId) {
+        const doc = await findOne(this.prisma, 'WebsocketConnection', { connectionId });
+        return doc ? this._mapConnection(doc) : null;
+    }
+
+    async findConnectionById(id) {
+        const objectId = toObjectId(id);
+        if (!objectId) return null;
+        const doc = await findOne(this.prisma, 'WebsocketConnection', { _id: objectId });
+        return doc ? this._mapConnection(doc) : null;
+    }
+
+    async getAllConnections() {
+        const docs = await findMany(this.prisma, 'WebsocketConnection');
+        return docs.map((doc) => this._mapConnection(doc));
+    }
+
+    async deleteAllConnections() {
+        const result = await deleteMany(this.prisma, 'WebsocketConnection', {});
+        const deleted = result?.n ?? 0;
+        return {
+            acknowledged: true,
+            deletedCount: deleted,
+        };
+    }
+
+    _mapConnection(doc) {
+        if (!doc) return null;
+        return {
+            id: fromObjectId(doc._id),
+            connectionId: doc.connectionId,
+        };
+    }
+}
+
+module.exports = { WebsocketConnectionRepositoryDocumentDB };
+
+

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

@@ -0,0 +1,44 @@
+const {
+    WebsocketConnectionRepositoryMongo,
+} = require('./websocket-connection-repository-mongo');
+const {
+    WebsocketConnectionRepositoryPostgres,
+} = require('./websocket-connection-repository-postgres');
+const {
+    WebsocketConnectionRepositoryDocumentDB,
+} = require('./websocket-connection-repository-documentdb');
+const config = require('../../database/config');
+
+/**
+ * Websocket Connection Repository Factory
+ * Creates the appropriate repository adapter based on database type
+ *
+ * @returns {WebsocketConnectionRepositoryInterface} Configured repository adapter
+ */
+function createWebsocketConnectionRepository() {
+    const dbType = config.DB_TYPE;
+
+    switch (dbType) {
+        case 'mongodb':
+            return new WebsocketConnectionRepositoryMongo();
+
+        case 'postgresql':
+            return new WebsocketConnectionRepositoryPostgres();
+
+        case 'documentdb':
+            return new WebsocketConnectionRepositoryDocumentDB();
+
+        default:
+            throw new Error(
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
+            );
+    }
+}
+
+module.exports = {
+    createWebsocketConnectionRepository,
+    // Export adapters for direct testing
+    WebsocketConnectionRepositoryMongo,
+    WebsocketConnectionRepositoryPostgres,
+    WebsocketConnectionRepositoryDocumentDB,
+};

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

@@ -0,0 +1,106 @@
+/**
+ * Websocket Connection Repository Interface
+ * Abstract base class defining the contract for websocket connection 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, WebsocketConnection model has identical structure across MongoDB and PostgreSQL,
+ * so WebsocketConnectionRepository serves both. This interface exists for consistency and
+ * future-proofing if database-specific implementations become needed.
+ *
+ * @abstract
+ */
+class WebsocketConnectionRepositoryInterface {
+    /**
+     * Create a new websocket connection
+     *
+     * @param {string} connectionId - Connection ID
+     * @returns {Promise<Object>} Created connection object
+     * @abstract
+     */
+    async createConnection(connectionId) {
+        throw new Error(
+            'Method createConnection must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Delete a websocket connection
+     *
+     * @param {string} connectionId - Connection ID
+     * @returns {Promise<Object>} Deletion result
+     * @abstract
+     */
+    async deleteConnection(connectionId) {
+        throw new Error(
+            'Method deleteConnection must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Get active connections
+     *
+     * @returns {Promise<Array>} Array of active connection objects
+     * @abstract
+     */
+    async getActiveConnections() {
+        throw new Error(
+            'Method getActiveConnections must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find connection by connection ID
+     *
+     * @param {string} connectionId - Connection ID
+     * @returns {Promise<Object|null>} Connection object or null
+     * @abstract
+     */
+    async findConnection(connectionId) {
+        throw new Error(
+            'Method findConnection must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find connection by database ID
+     *
+     * @param {string|number} id - Database ID
+     * @returns {Promise<Object|null>} Connection object or null
+     * @abstract
+     */
+    async findConnectionById(id) {
+        throw new Error(
+            'Method findConnectionById must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Get all connections
+     *
+     * @returns {Promise<Array>} Array of all connection objects
+     * @abstract
+     */
+    async getAllConnections() {
+        throw new Error(
+            'Method getAllConnections must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Delete all connections
+     *
+     * @returns {Promise<Object>} Deletion result
+     * @abstract
+     */
+    async deleteAllConnections() {
+        throw new Error(
+            'Method deleteAllConnections must be implemented by subclass'
+        );
+    }
+}
+
+module.exports = { WebsocketConnectionRepositoryInterface };

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

@@ -0,0 +1,156 @@
+const { prisma } = require('../../database/prisma');
+const {
+    ApiGatewayManagementApiClient,
+    PostToConnectionCommand,
+} = require('@aws-sdk/client-apigatewaymanagementapi');
+const {
+    WebsocketConnectionRepositoryInterface,
+} = require('./websocket-connection-repository-interface');
+
+/**
+ * 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();
+        this.prisma = 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 };

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

@@ -0,0 +1,196 @@
+const { prisma } = require('../../database/prisma');
+const {
+    ApiGatewayManagementApiClient,
+    PostToConnectionCommand,
+} = require('@aws-sdk/client-apigatewaymanagementapi');
+const {
+    WebsocketConnectionRepositoryInterface,
+} = require('./websocket-connection-repository-interface');
+
+/**
+ * PostgreSQL WebSocket Connection Repository Adapter
+ * Handles persistence of active WebSocket connections
+ *
+ * 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 WebsocketConnectionRepositoryPostgres extends WebsocketConnectionRepositoryInterface {
+    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 connection object IDs to strings
+     * @private
+     * @param {Object|null} connection - Connection object from database
+     * @returns {Object|null} Connection with string IDs
+     */
+    _convertConnectionIds(connection) {
+        if (!connection) return connection;
+        return {
+            ...connection,
+            id: connection.id?.toString(),
+        };
+    }
+
+    /**
+     * 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) {
+        const connection = await this.prisma.websocketConnection.create({
+            data: { connectionId },
+        });
+        return this._convertConnectionIds(connection);
+    }
+
+    /**
+     * Delete a WebSocket connection record
+     * Replaces: WebsocketConnection.deleteOne({ connectionId })
+     *
+     * Note: connectionId is a string field in schema, not the primary key,
+     * so no conversion needed here.
+     *
+     * @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 })
+     *
+     * Note: connectionId is a string field, not the primary key
+     *
+     * @param {string} connectionId - The WebSocket connection ID
+     * @returns {Promise<Object|null>} The connection record with string IDs or null
+     */
+    async findConnection(connectionId) {
+        const connection = await this.prisma.websocketConnection.findFirst({
+            where: { connectionId },
+        });
+        return this._convertConnectionIds(connection);
+    }
+
+    /**
+     * Find connection by internal ID
+     * @param {string} id - The internal connection ID (string from application layer)
+     * @returns {Promise<Object|null>} The connection record with string IDs or null
+     */
+    async findConnectionById(id) {
+        const intId = this._convertId(id);
+        const connection = await this.prisma.websocketConnection.findUnique({
+            where: { id: intId },
+        });
+        return this._convertConnectionIds(connection);
+    }
+
+    /**
+     * Get all connections
+     * @returns {Promise<Array>} Array of all connection records with string IDs
+     */
+    async getAllConnections() {
+        const connections = await this.prisma.websocketConnection.findMany();
+        return connections.map((conn) => this._convertConnectionIds(conn));
+    }
+
+    /**
+     * 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 = { WebsocketConnectionRepositoryPostgres };