@friggframework/core 2.0.0-next.8 → 2.0.0-next.80

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

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/assertions/is-equal.js

@@ -1,17 +0,0 @@
-const expectShallowEqualDbObject = (modelObject, compareObject) => {
-    for (const key in compareObject) {
-        let objVal = modelObject[key];
-
-        if (objVal instanceof Date) {
-            objVal = objVal.toISOString();
-        } else if (objVal instanceof mongoose.Types.ObjectId) {
-            objVal = objVal._id.toString();
-        }
-
-        expect(compareObject[key]).toBe(objVal);
-    }
-};
-
-// TODO not sure how much this is needed, but could rewrite with _.isEqualWith for deep equality with custom checks.
-
-module.exports = { expectShallowEqualDbObject };

package/associations/model.js

@@ -1,54 +0,0 @@
-const mongoose = require("mongoose");
-
-const schema = new mongoose.Schema({
-  integration: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: "Integration",
-    required: true,
-  },
-  name: { type: String, required: true },
-  type: {
-    type: String,
-    enum: ["ONE_TO_MANY", "ONE_TO_ONE", "MANY_TO_ONE"],
-    required: true,
-  },
-  primaryObject: { type: String, required: true },
-  objects: [
-    {
-      entity: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Entity",
-        required: true,
-      },
-      objectType: { type: String, required: true },
-      objId: { type: String, required: true },
-      metadata: { type: Object, required: false },
-    },
-  ],
-});
-
-schema.statics({
-  addAssociation: async function (id, object) {
-    return this.update({ _id: id }, { $push: { objects: object } });
-  },
-  findAssociation: async function (name, dataIdentifierHash) {
-    const syncList = await this.list({
-      name: name,
-      "dataIdentifiers.hash": dataIdentifierHash,
-    });
-
-    if (syncList.length === 1) {
-      return syncList[0];
-    } else if (syncList.length === 0) {
-      return null;
-    } else {
-      throw new Error(
-        `there are multiple sync objects with the name ${name}, for entities [${entities}]`
-      );
-    }
-  },
-});
-
-const Association =
-  mongoose.models.Association || mongoose.model("Association", schema);
-module.exports = { Association };

package/database/models/IndividualUser.js

@@ -1,76 +0,0 @@
-const { mongoose } = require('../mongoose');
-const bcrypt = require('bcryptjs');
-const { UserModel: Parent } = require('./UserModel');
-
-const collectionName = 'IndividualUser';
-
-const schema = new mongoose.Schema({
-    email: { type: String },
-    username: { type: String, unique: true },
-    hashword: { type: String },
-    appUserId: { type: String },
-    organizationUser: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
-});
-
-schema.pre('save', async function () {
-    if (this.hashword) {
-        this.hashword = await bcrypt.hashSync(
-            this.hashword,
-            parseInt(this.schema.statics.decimals)
-        )
-    }
-})
-
-schema.static({
-    decimals: 10,
-    update: async function (id, options) {
-        if ('password' in options) {
-            options.hashword = await bcrypt.hashSync(
-                options.password,
-                parseInt(this.decimals)
-            );
-            delete options.password;
-        }
-        return this.findOneAndUpdate(
-            {_id: id},
-            options,
-            {new: true, useFindAndModify: true}
-        );
-    },
-    getUserByUsername: async function (username) {
-        let getByUser;
-        try{
-            getByUser = await this.find({username});
-        } catch (e) {
-            console.log('oops')
-        }
-
-        if (getByUser.length > 1) {
-            throw new Error(
-                'Unique username or email? Please reach out to our developers'
-            );
-        }
-
-        if (getByUser.length === 1) {
-            return getByUser[0];
-        }
-    },
-    getUserByAppUserId: async function (appUserId) {
-        const getByUser = await this.find({ appUserId });
-
-        if (getByUser.length > 1) {
-            throw new Error(
-                'Supposedly using a unique appUserId? Please reach out to our developers'
-            );
-        }
-
-
-        if (getByUser.length === 1) {
-            return getByUser[0];
-        }
-    }
-})
-
-const IndividualUser = Parent.discriminators?.IndividualUser || Parent.discriminator(collectionName, schema);
-
-module.exports = {IndividualUser};

package/database/models/OrganizationUser.js

@@ -1,29 +0,0 @@
-const { mongoose } = require('../mongoose');
-const { UserModel: Parent } = require('./UserModel');
-
-const collectionName = 'OrganizationUser';
-
-const schema = new mongoose.Schema({
-    appOrgId: { type: String, required: true, unique: true },
-    name: { type: String },
-});
-
-schema.static({
-    getUserByAppOrgId: async function (appOrgId) {
-        const getByUser = await this.find({ appOrgId });
-
-        if (getByUser.length > 1) {
-            throw new Error(
-                'Supposedly using a unique appOrgId? Please reach out to our developers'
-            );
-        }
-
-        if (getByUser.length === 1) {
-            return getByUser[0];
-        }
-    }
-})
-
-const OrganizationUser = Parent.discriminators?.OrganizationUser || Parent.discriminator(collectionName, schema);
-
-module.exports = {OrganizationUser};

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