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

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

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

@@ -0,0 +1,161 @@
+const { prisma } = require('../../database/prisma');
+const {
+    ApiGatewayManagementApiClient,
+    PostToConnectionCommand,
+} = require('@aws-sdk/client-apigatewaymanagementapi');
+const {
+    WebsocketConnectionRepositoryInterface,
+} = require('./websocket-connection-repository-interface');
+
+/**
+ * Prisma-based WebSocket Connection Repository
+ * Handles persistence of active WebSocket connections
+ *
+ * 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
+ * - Static method getActiveConnections() → Instance method
+ * - AWS API Gateway Management API integration preserved
+ */
+class WebsocketConnectionRepository extends WebsocketConnectionRepositoryInterface {
+    constructor(prismaClient = prisma) {
+        super();
+        this.prisma = prismaClient; // Allow injection for testing
+    }
+
+    /**
+     * Create a new WebSocket connection record
+     * Replaces: WebsocketConnection.create({ connectionId })
+     *
+     * @param {string} connectionId - The WebSocket connection ID
+     * @returns {Promise<Object>} The created connection record
+     */
+    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 ID
+     * Replaces: WebsocketConnection.findOne({ connectionId })
+     *
+     * @param {string} connectionId - The WebSocket connection ID
+     * @returns {Promise<Object|null>} The connection record 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 or null
+     */
+    async findConnectionById(id) {
+        return await this.prisma.websocketConnection.findUnique({
+            where: { id },
+        });
+    }
+
+    /**
+     * Get all connections
+     * @returns {Promise<Array>} Array of all connection records
+     */
+    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 = { WebsocketConnectionRepository };

package/database/models/State.js

@@ -1,9 +0,0 @@
-const { mongoose } = require('../mongoose');
-
-const schema = new mongoose.Schema({
-  state: { type: mongoose.Schema.Types.Mixed }
-});
-
-const State = mongoose.models.State || mongoose.model('State', schema);
-
-module.exports = { State };

package/database/models/Token.js

@@ -1,70 +0,0 @@
-const { mongoose } = require('../mongoose');
-const bcrypt = require('bcryptjs');
-
-const collectionName = 'Token';
-const decimals = 10;
-
-const schema = new mongoose.Schema({
-    token: { type: String, required: true },
-    created: { type: Date, default: Date.now },
-    expires: { type: Date },
-    user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
-});
-
-schema.static({
-    createTokenWithExpire: async function (userId, rawToken, minutes) {
-        // Create user token
-        let tokenHash = await bcrypt.hashSync(rawToken, parseInt(decimals));
-
-        let session = {
-            token: tokenHash,
-            expires: new Date(Date.now() + minutes * 60000).toISOString(),
-            user: userId,
-        };
-
-        return this.create(session);
-    },
-    // Takes in a token object and  that has been created in the database and the raw token value.
-    // Returns a json of just the token and id to return to the browser
-    createJSONToken: function (token, rawToken) {
-        let returnArr = {
-            id: token.id,
-            token: rawToken,
-        };
-        return JSON.stringify(returnArr);
-    },
-    // Takes in a token object and  that has been created in the database and the raw token value.
-    // Returns a base64 buffer of just the token and id to return to the browser
-    createBase64BufferToken: function (token, rawToken) {
-        let jsonVal = Token.createJSONToken(token, rawToken);
-        return Buffer.from(jsonVal).toString('base64');
-    },
-    getJSONTokenFromBase64BufferToken: function (buffer) {
-        let tokenStr = Buffer.from(buffer.trim(), 'base64').toString('ascii');
-        return JSON.parse(tokenStr);
-    },
-
-    // Takes in a JSON Token with id and token in it and verifies the token
-    // is valid from the database. If it is not va
-    validateAndGetTokenFromJSONToken: async function (tokenObj) {
-        let sessionToken = await this.findById(tokenObj.id);
-        if (sessionToken) {
-            if (
-                !(await bcrypt.compareSync(tokenObj.token, sessionToken.token))
-            ) {
-                throw new Error('Invalid Token: Token does not match');
-            }
-            if (new Date(sessionToken.expires) < new Date()) {
-                throw new Error('Invalid Token: Token is expired');
-            }
-
-            return sessionToken;
-        } else {
-            throw new Error('Invalid Token: Token does not exist');
-        }
-    }
-})
-
-const Token = mongoose.models.Token || mongoose.model(collectionName, schema);
-
-module.exports = { Token };

package/database/mongo.js

@@ -1,45 +0,0 @@
-// Best Practices Connecting from AWS Lambda:
-// https://dev.to/adnanrahic/building-a-serverless-rest-api-with-nodejs-and-mongodb-43db
-// https://mongoosejs.com/docs/lambda.html
-// https://www.mongodb.com/blog/post/optimizing-aws-lambda-performance-with-mongodb-atlas-and-nodejs
-const { Encrypt } = require('../encrypt');
-const { mongoose } = require('./mongoose');
-const { debug, flushDebugLog } = require('../logs');
-
-mongoose.plugin(Encrypt);
-mongoose.set('applyPluginsToDiscriminators', true); // Needed for LHEncrypt
-
-// Buffering means mongoose will queue up operations if it gets
-// With serverless, better to fail fast if not connected.
-// disconnected from MongoDB and send them when it reconnects.
-const mongoConfig = {
-    useNewUrlParser: true,
-    bufferCommands: false, // Disable mongoose buffering
-    autoCreate: false, // Disable because auto creation does not work without buffering
-    useUnifiedTopology: true,
-    serverSelectionTimeoutMS: 5000,
-};
-
-const checkIsConnected = () => mongoose.connection?.readyState > 0;
-
-const connectToDatabase = async () => {
-    if (checkIsConnected()) {
-        debug('=> using existing database connection');
-        return;
-    }
-
-    debug('=> using new database connection');
-    await mongoose.connect(process.env.MONGO_URI, mongoConfig);
-    debug('Connection state:',  mongoose.STATES[mongoose.connection.readyState]);
-    mongoose.connection.on('error', (error) => flushDebugLog(error));
-};
-
-const disconnectFromDatabase = async () => mongoose.disconnect();
-
-const createObjectId = () => new mongoose.Types.ObjectId();
-
-module.exports = {
-    connectToDatabase,
-    disconnectFromDatabase,
-    createObjectId,
-};

package/encrypt/Cryptor.test.js

@@ -1,32 +0,0 @@
-const { Cryptor } = require('./Cryptor');
-
-describe('Cryptor', () => {
-    describe('Permutations', () => {
-        it('calculates permutations correctly', async () => {
-            // Given a nested field, we want all possible paths that could access it.
-            const cryptor = new Cryptor({ fields: ['a.b.c.d', 'e'] });
-            expect(cryptor.permutationsByField).toEqual({
-                'a.b.c.d': [
-                    ['a', 'b', 'c', 'd'],
-                    ['a', 'b', 'c.d'],
-                    ['a', 'b.c', 'd'],
-                    ['a', 'b.c.d'],
-                    ['a.b', 'c', 'd'],
-                    ['a.b', 'c.d'],
-                    ['a.b.c', 'd'],
-                    ['a.b.c.d'],
-                ],
-                e: [['e']],
-            });
-        });
-    });
-
-    describe('Keys', () => {
-        it('raises error on missing environment', () => {
-            const cryptor = new Cryptor({ fields: ['a.b.c.d', 'e'] });
-            expect(cryptor.getKeyFromEnvironment).toThrow(
-                'No encryption key found with ID "undefined"'
-            );
-        });
-    });
-});

package/encrypt/encrypt.js

@@ -1,132 +0,0 @@
-const { Cryptor } = require('./Cryptor');
-
-const updateOneEvents = [
-    'updateOne',
-    'replaceOne',
-    'findOneAndUpdate',
-    'findOneAndReplace',
-];
-const findOneEvents = [
-    'findOne',
-    'findOneAndDelete',
-    'findOneAndRemove',
-    'findOneAndUpdate',
-    'findOneAndReplace',
-];
-
-const shouldBypassEncryption = (STAGE) => {
-    const defaultBypassStages = ['dev', 'test', 'local'];
-    const bypassStageEnv = process.env.BYPASS_ENCRYPTION_STAGE;
-    // If the env is set to anything or an empty string, use the env. Otherwise, use the default array
-    const useEnv = !String(bypassStageEnv) || !!bypassStageEnv;
-    const bypassStages = useEnv
-        ? bypassStageEnv.split(',').map((stage) => stage.trim())
-        : defaultBypassStages;
-    return bypassStages.includes(STAGE);
-};
-
-// The Mongoose plug-in function
-function Encrypt(schema, options) {
-    const { STAGE, KMS_KEY_ARN, AES_KEY_ID } = process.env;
-
-    if (shouldBypassEncryption(STAGE)) {
-        return;
-    }
-
-    if (KMS_KEY_ARN && AES_KEY_ID) {
-        throw new Error(
-            'Local and AWS encryption keys are both set in the environment.'
-        );
-    }
-
-    const fields = Object.values(schema.paths)
-        .map(({ path, options }) => (options.lhEncrypt === true ? path : ''))
-        .filter(Boolean);
-
-    if (!fields.length) {
-        return;
-    }
-
-    const cryptor = new Cryptor({
-        // Use AWS if the CMK is present
-        shouldUseAws: !!KMS_KEY_ARN,
-        // Find all the fields in the schema with lhEncrypt === true
-        fields: fields,
-    });
-
-    // ---------------------------------------------
-    // ### Encrypt fields before save/update/insert.
-    // ---------------------------------------------
-
-    schema.pre('save', async function encryptionPreSave() {
-        // `this` will be a doc
-        await cryptor.encryptFieldsInDocuments([this]);
-    });
-
-    schema.pre(
-        'insertMany',
-        async function encryptionPreInsertMany(_, docs, options) {
-            // `this` will be the model
-            if (options?.rawResult) {
-                throw new Error(
-                    'Raw result not supported for insertMany with Encrypt plugin'
-                );
-            }
-
-            await cryptor.encryptFieldsInDocuments(docs);
-        }
-    );
-
-    schema.pre(updateOneEvents, async function encryptionPreUpdateOne() {
-        // `this` will be a query
-        await cryptor.encryptFieldsInQuery(this);
-    });
-
-    schema.pre('updateMany', async function encryptionPreUpdateMany() {
-        // `this` will be a query
-        cryptor.expectNotToUpdateManyEncrypted(this.getUpdate());
-    });
-
-    schema.pre('update', async function encryptionPreUpdate() {
-        // `this` will be a query
-        const { multiple } = this.getOptions();
-
-        if (multiple) {
-            cryptor.expectNotToUpdateManyEncrypted(this.getUpdate());
-            return;
-        }
-
-        await cryptor.encryptFieldsInQuery(this);
-    });
-
-    // --------------------------------------------
-    // ### Decrypt documents after they are loaded.
-    // --------------------------------------------
-    schema.post('save', async function encryptionPreSave() {
-        // `this` will be a doc
-        await cryptor.decryptFieldsInDocuments([this]);
-    });
-
-    schema.post(findOneEvents, async function encryptionPostFindOne(doc) {
-        // `this` will be a query
-        const { rawResult } = this.getOptions();
-
-        if (rawResult) {
-            return;
-        }
-
-        await cryptor.decryptFieldsInDocuments([doc]);
-    });
-
-    schema.post('find', async function encryptionPostFind(docs) {
-        // `this` will be a query
-        await cryptor.decryptFieldsInDocuments(docs);
-    });
-
-    schema.post('insertMany', async function encryptionPostInsertMany(docs) {
-        // `this` will be the model
-        await cryptor.decryptFieldsInDocuments(docs);
-    });
-}
-
-module.exports = { Encrypt };