@friggframework/core 2.0.0--canary.490.883b991.0 → 2.0.0--canary.497.a3f25f9.0

package/associations/model.js

@@ -0,0 +1,54 @@
+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/core/create-handler.js

@@ -1,76 +1,21 @@
+// This line should be at the top of the webpacked output, so be sure to require createHandler first in any handlers.  "Soon" sourcemaps will be built into Node... after that, this package won't be needed.
+// REMOVING FOR NOW UNTIL WE ADD WEBPACK BACK IN
+// require('source-map-support').install();
+
 const { initDebugLog, flushDebugLog } = require('../logs');
 const { secretsToEnv } = require('./secrets-to-env');
 
-let databaseInitializer = null;
-let databaseInitialized = false;
-let databaseInitPromise = null;
-
-function setDatabaseInitializer(initializer) {
-    databaseInitializer = initializer;
-}
-
-function getDefaultDatabaseInitializer() {
-    if (!databaseInitializer) {
-        const { connectPrisma } = require('../database/prisma');
-        databaseInitializer = connectPrisma;
-    }
-    return databaseInitializer;
-}
-
-async function ensureDatabaseInitialized() {
-    if (databaseInitialized) {
-        return;
-    }
-    
-    if (!databaseInitPromise) {
-        databaseInitPromise = (async () => {
-            try {
-                const initializer = getDefaultDatabaseInitializer();
-                await initializer();
-                databaseInitialized = true;
-                console.log('✓ Database initialized successfully');
-            } catch (error) {
-                console.error('Failed to initialize database:', error.message);
-                databaseInitPromise = null;
-                throw error;
-            }
-        })();
-    }
-    
-    return databaseInitPromise;
-}
-
-/**
- * Creates a Lambda handler with database initialization.
- * 
- * Follows hexagonal architecture: database initialization is a port that can be injected.
- * Default adapter uses Prisma's connectPrisma(), which handles both PostgreSQL and MongoDB.
- * 
- * @param {Object} options
- * @param {string} options.eventName - Event name for logging
- * @param {boolean} options.isUserFacingResponse - Whether to hide error details (default: true)
- * @param {Function} options.method - The handler method to execute
- * @param {boolean} options.shouldUseDatabase - Whether to initialize database (default: true)
- * @param {Function} options.databaseInitializer - Optional custom database initializer
- * @returns {Function} Lambda handler
- */
 const createHandler = (optionByName = {}) => {
     const {
         eventName = 'Event',
         isUserFacingResponse = true,
         method,
-        shouldUseDatabase = true,
-        databaseInitializer: customInitializer = null,
     } = optionByName;
 
     if (!method) {
         throw new Error('Method is required for handler.');
     }
 
-    if (customInitializer) {
-        setDatabaseInitializer(customInitializer);
-    }
-
     return async (event, context) => {
         try {
             initDebugLog(eventName, event);
@@ -81,18 +26,18 @@ const createHandler = (optionByName = {}) => {
                 console.info(`${requestMethod} ${requestPath}`);
             }
 
+            // If enabled (i.e. if SECRET_ARN is set in process.env) Fetch secrets from AWS Secrets Manager, and set them as environment variables.
             await secretsToEnv();
 
-            if (shouldUseDatabase) {
-                await ensureDatabaseInitialized();
-            }
-
+            // Helps mongoose reuse the connection.  Lowers response times.
             context.callbackWaitsForEmptyEventLoop = false;
 
+            // Run the Lambda
             return await method(event, context);
         } catch (error) {
             flushDebugLog(error);
 
+            // Don't leak implementation details to end users.
             if (isUserFacingResponse) {
                 return {
                     statusCode: 500,
@@ -102,10 +47,14 @@ const createHandler = (optionByName = {}) => {
                 };
             }
 
+            // Handle server-to-server responses.
+
+            // Halt errors are logged but suceed and won't be retried.
             if (error.isHaltError === true) {
                 return;
             }
 
+            // Here we can just rethrow and let AWS build the response.
             throw error;
         }
     };

package/database/index.js

@@ -1,16 +1,38 @@
+//todo: probably most of this file content can be removed
+
 /**
  * Database Module Index
- * 
- * Exports Prisma client and repositories following hexagonal architecture.
- * Use repositories for data access - never access Prisma directly from domain layer.
+ * Exports Mongoose models and connection utilities
+ *
+ * Note: Frigg uses the Repository pattern for data access.
+ * Models are not meant to be used directly - use repositories instead:
+ * - SyncRepository (syncs/sync-repository.js)
+ * - IntegrationRepository (integrations/integration-repository.js)
+ * - CredentialRepository (credential/credential-repository.js)
+ * etc.
  */
 
-const { prisma, connectPrisma, disconnectPrisma } = require('./prisma');
 const { mongoose } = require('./mongoose');
+const { IndividualUser } = require('./models/IndividualUser');
+const { OrganizationUser } = require('./models/OrganizationUser');
+const { UserModel } = require('./models/UserModel');
+const { WebsocketConnection } = require('./models/WebsocketConnection');
+
+// Prisma exports
+const { prisma } = require('./prisma');
+const { TokenRepository } = require('../token/repositories/token-repository');
+const {
+    WebsocketConnectionRepository,
+} = require('../websocket/repositories/websocket-connection-repository');
 
 module.exports = {
+    mongoose,
+    IndividualUser,
+    OrganizationUser,
+    UserModel,
+    WebsocketConnection,
+    // Prisma
     prisma,
-    connectPrisma,
-    disconnectPrisma,
-    mongoose, // Still used for legacy ping operations in some health checks
+    TokenRepository,
+    WebsocketConnectionRepository,
 };

package/database/models/UserModel.js

@@ -0,0 +1,7 @@
+const { mongoose } = require('../mongoose');
+
+const schema = new mongoose.Schema({}, {timestamps: true})
+
+const UserModel = mongoose.models.User || mongoose.model('User',schema)
+
+module.exports = { UserModel: UserModel };

package/database/models/WebsocketConnection.js

@@ -0,0 +1,55 @@
+const { mongoose } = require('../mongoose');
+const {
+    ApiGatewayManagementApiClient,
+    PostToConnectionCommand,
+} = require('@aws-sdk/client-apigatewaymanagementapi');
+
+const schema = new mongoose.Schema({
+    connectionId: { type: mongoose.Schema.Types.String },
+});
+
+// Add a static method to get active connections
+schema.statics.getActiveConnections = async function () {
+    try {
+        // Return empty array if websockets are not configured
+        if (!process.env.WEBSOCKET_API_ENDPOINT) {
+            return [];
+        }
+
+        const connections = await this.find({}, 'connectionId');
+        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 this.deleteOne({
+                            connectionId: conn.connectionId,
+                        });
+                    } else {
+                        throw error;
+                    }
+                }
+            },
+        }));
+    } catch (error) {
+        console.error('Error getting active connections:', error);
+        throw error;
+    }
+};
+
+const WebsocketConnection =
+    mongoose.models.WebsocketConnection ||
+    mongoose.model('WebsocketConnection', schema);
+
+module.exports = { WebsocketConnection };

package/database/prisma.js

@@ -14,40 +14,22 @@ const config = require('./config');
  * Note: This should only be called when DB_TYPE is 'mongodb'
  */
 function ensureMongoDbUrl() {
-    let connectionString;
-    
+    // If DATABASE_URL is already set, use it
     if (process.env.DATABASE_URL && process.env.DATABASE_URL.trim()) {
-        connectionString = process.env.DATABASE_URL;
-    } else if (process.env.MONGO_URI && process.env.MONGO_URI.trim()) {
-        connectionString = process.env.MONGO_URI;
-        logger.debug('Using MONGO_URI as DATABASE_URL for MongoDB connection');
-    } else {
-        throw new Error(
-            'DATABASE_URL or MONGO_URI environment variable must be set for MongoDB'
-        );
+        return;
     }
-    
-    // Ensure readPreference=primary for transaction support
-    // MongoDB requires this for all operations within transactions
-    try {
-        const url = new URL(connectionString);
-        const params = url.searchParams;
-        
-        const existingReadPreference = params.get('readPreference');
-        if (existingReadPreference && existingReadPreference !== 'primary') {
-            params.set('readPreference', 'primary');
-            logger.debug(`Overrode readPreference from ${existingReadPreference} to primary for transaction support`);
-        } else if (!existingReadPreference) {
-            params.set('readPreference', 'primary');
-            logger.debug('Added readPreference=primary to MongoDB connection string for transaction support');
-        }
-        
-        connectionString = url.toString();
-    } catch (error) {
-        logger.warn('Failed to parse MongoDB connection string as URL, skipping readPreference configuration:', error.message);
+
+    // Fallback to MONGO_URI for backwards compatibility with DocumentDB deployments
+    if (process.env.MONGO_URI && process.env.MONGO_URI.trim()) {
+        process.env.DATABASE_URL = process.env.MONGO_URI;
+        logger.debug('Using MONGO_URI as DATABASE_URL for MongoDB connection');
+        return;
     }
-    
-    process.env.DATABASE_URL = connectionString;
+
+    // Neither is set - error
+    throw new Error(
+        'DATABASE_URL or MONGO_URI environment variable must be set for MongoDB'
+    );
 }
 
 function getEncryptionConfig() {
@@ -122,27 +104,14 @@ const prismaClientSingleton = () => {
 
     // Helper to try loading Prisma client from multiple locations
     const loadPrismaClient = (dbType) => {
-        const fs = require('fs');
-        const layerPath = `/opt/nodejs/node_modules/generated/prisma-${dbType}`;
-        
-        // Check if layer exists (when usePrismaLambdaLayer=true)
-        if (fs.existsSync(layerPath)) {
-            try {
-                return require(layerPath).PrismaClient;
-            } catch (err) {
-                // Layer exists but failed to load - fall through to bundled paths
-            }
-        }
-        
-        // Layer doesn't exist or failed - use bundled/local paths (when usePrismaLambdaLayer=false)
-        const localPaths = [
-            // Bundled with function (when usePrismaLambdaLayer=false)
-            `@friggframework/core/generated/prisma-${dbType}`,
-            // Local development (relative to core package)
+        const paths = [
+            // Lambda layer location (when using Prisma Lambda layer)
+            `/opt/nodejs/node_modules/generated/prisma-${dbType}`,
+            // Local development location (relative to core package)
             `../generated/prisma-${dbType}`,
         ];
 
-        for (const path of localPaths) {
+        for (const path of paths) {
             try {
                 return require(path).PrismaClient;
             } catch (err) {
@@ -151,8 +120,7 @@ const prismaClientSingleton = () => {
         }
 
         throw new Error(
-            `Cannot find Prisma client for ${dbType}. ` +
-            `Tried layer path: ${layerPath}, local paths: ${localPaths.join(', ')}`
+            `Cannot find Prisma client for ${dbType}. Tried paths: ${paths.join(', ')}`
         );
     };
 

package/database/repositories/health-check-repository-mongodb.js

@@ -2,7 +2,6 @@ const { mongoose } = require('../mongoose');
 const {
     HealthCheckRepositoryInterface,
 } = require('./health-check-repository-interface');
-const { removeUndefinedValues } = require('../utils/documentdb-compatibility');
 
 class HealthCheckRepositoryMongoDB extends HealthCheckRepositoryInterface {
     /**
@@ -30,30 +29,38 @@ class HealthCheckRepositoryMongoDB extends HealthCheckRepositoryInterface {
         }
 
         return {
+            readyState: isConnected ? 1 : 0,
             readyState: isConnected ? 1 : 0,
             stateName,
             isConnected,
         };
     }
 
-    /**
-     * @param {number} maxTimeMS
-     * @returns {Promise<number>} Response time in milliseconds
-     */
     async pingDatabase(maxTimeMS = 2000) {
         const pingStart = Date.now();
-        await this.prisma.$queryRaw`SELECT 1`.catch(() => {
-            return this.prisma.$runCommandRaw({ ping: 1 });
-        });
+        
+        // Create a timeout promise that rejects after maxTimeMS
+        const timeoutPromise = new Promise((_, reject) => 
+            setTimeout(() => reject(new Error('Database ping timeout')), maxTimeMS)
+        );
+        
+        // Race between the database ping and the timeout
+        await Promise.race([
+            prisma.$queryRaw`SELECT 1`.catch(() => {
+                // For MongoDB, use runCommandRaw instead
+                return prisma.$runCommandRaw({ ping: 1 });
+            }),
+            timeoutPromise
+        ]);
+        
+        return Date.now() - pingStart;
+    }
         return Date.now() - pingStart;
     }
 
     async createCredential(credentialData) {
-        // Remove undefined values to prevent Prisma from using $$REMOVE (DocumentDB unsupported)
-        const cleanedData = removeUndefinedValues(credentialData);
-        
         return await this.prisma.credential.create({
-            data: cleanedData,
+            data: credentialData,
         });
     }
 
@@ -68,17 +75,10 @@ class HealthCheckRepositoryMongoDB extends HealthCheckRepositoryInterface {
      * @returns {Promise<Object|null>}
      */
     async getRawCredentialById(id) {
-        const result = await this.prisma.$runCommandRaw({
-            find: 'Credential',
-            filter: { _id: { $oid: id } },
-            limit: 1,
-        });
-        
-        if (!result.cursor || !result.cursor.firstBatch || result.cursor.firstBatch.length === 0) {
-            return null;
-        }
-        
-        return result.cursor.firstBatch[0];
+        const { ObjectId } = require('mongodb');
+        return await mongoose.connection.db
+            .collection('Credential')
+            .findOne({ _id: new ObjectId(id) });
     }
 
     async deleteCredential(id) {

package/database/repositories/health-check-repository.js

@@ -0,0 +1,108 @@
+const { prisma } = require('../prisma');
+const { mongoose } = require('../mongoose');
+const {
+    HealthCheckRepositoryInterface,
+} = require('./health-check-repository-interface');
+
+/**
+ * Repository for Health Check database operations.
+ * Provides atomic database operations for health testing.
+ *
+ * Follows DDD/Hexagonal Architecture:
+ * - Infrastructure Layer (this repository)
+ * - Pure database operations only, no business logic
+ * - Used by Application Layer (Use Cases)
+ *
+ * Works identically for both MongoDB and PostgreSQL:
+ * - Uses Prisma for database operations
+ * - Encryption happens transparently via Prisma extension
+ * - Both MongoDB and PostgreSQL use same Prisma API
+ *
+ * Migration from Mongoose to Prisma:
+ * - Replaced Mongoose models with Prisma client
+ * - Uses Credential model for encryption testing
+ * - Maintains same method signatures for compatibility
+ */
+class HealthCheckRepository extends HealthCheckRepositoryInterface {
+    constructor() {
+        super();
+    }
+
+    /**
+     * Get database connection state
+     * @returns {Object} Object with readyState, stateName, and isConnected
+     */
+    getDatabaseConnectionState() {
+        const stateMap = {
+            0: 'disconnected',
+            1: 'connected',
+            2: 'connecting',
+            3: 'disconnecting',
+        };
+        const readyState = mongoose.connection.readyState;
+
+        return {
+            readyState,
+            stateName: stateMap[readyState],
+            isConnected: readyState === 1,
+        };
+    }
+
+    /**
+     * Ping the database to verify connectivity
+     * @param {number} maxTimeMS - Maximum time to wait for ping response
+     * @returns {Promise<number>} Response time in milliseconds
+     * @throws {Error} If database is not connected or ping fails
+     */
+    async pingDatabase(maxTimeMS = 2000) {
+        const pingStart = Date.now();
+        await mongoose.connection.db.admin().ping({ maxTimeMS });
+        return Date.now() - pingStart;
+    }
+
+    /**
+     * Create a test credential for encryption testing
+     * @param {Object} credentialData - Credential data to create
+     * @returns {Promise<Object>} Created credential
+     */
+    async createCredential(credentialData) {
+        return await prisma.credential.create({
+            data: credentialData,
+        });
+    }
+
+    /**
+     * Find a credential by ID
+     * @param {string} id - Credential ID
+     * @returns {Promise<Object|null>} Found credential or null
+     */
+    async findCredentialById(id) {
+        return await prisma.credential.findUnique({
+            where: { id },
+        });
+    }
+
+    /**
+     * Get raw credential from database bypassing Prisma encryption extension
+     * @param {string} id - Credential ID
+     * @returns {Promise<Object|null>} Raw credential from database
+     */
+    async getRawCredentialById(id) {
+        return await mongoose.connection.db
+            .collection('credentials')
+            .findOne({ _id: id });
+    }
+
+    /**
+     * Delete a credential by ID
+     * @param {string} id - Credential ID
+     * @returns {Promise<void>}
+     */
+    async deleteCredential(id) {
+        await prisma.credential.delete({
+            where: { id },
+        });
+    }
+}
+
+module.exports = { HealthCheckRepository };

package/database/utils/mongodb-collection-utils.js

@@ -5,14 +5,11 @@
  * handling the constraint that collections cannot be created inside
  * multi-document transactions.
  *
- * Uses Prisma's $runCommandRaw to send native MongoDB commands directly,
- * avoiding the need for mongoose connection.
- *
  * @see https://github.com/prisma/prisma/issues/8305
  * @see https://www.mongodb.com/docs/manual/core/transactions/#transactions-and-operations
  */
 
-const { prisma } = require('../prisma');
+const { mongoose } = require('../mongoose');
 
 /**
  * Ensures a MongoDB collection exists
@@ -21,9 +18,6 @@ const { prisma } = require('../prisma');
  * transactions. This function checks if a collection exists and creates it if needed,
  * preventing "Cannot create namespace in multi-document transaction" errors.
  *
- * Uses Prisma's $runCommandRaw to send native MongoDB commands, which works with
- * both MongoDB and DocumentDB.
- *
  * @param {string} collectionName - Name of the collection to ensure exists
  * @returns {Promise<void>}
  *
@@ -36,24 +30,23 @@ const { prisma } = require('../prisma');
  */
 async function ensureCollectionExists(collectionName) {
     try {
-        // Check if collection exists using Prisma's $runCommandRaw
-        const collections = await prisma.$runCommandRaw({
-            listCollections: 1,
-            filter: { name: collectionName }
-        });
+        const collections = await mongoose.connection.db
+            .listCollections({ name: collectionName })
+            .toArray();
 
-        if (collections.cursor.firstBatch.length === 0) {
-            // Collection doesn't exist, create it
-            await prisma.$runCommandRaw({
-                create: collectionName
-            });
-            console.log(`✓ Created collection: ${collectionName}`);
+        if (collections.length === 0) {
+            // Collection doesn't exist, create it outside of any transaction
+            await mongoose.connection.db.createCollection(collectionName);
+            console.log(`Created MongoDB collection: ${collectionName}`);
         }
     } catch (error) {
-        // Ignore "already exists" errors (code 48: NamespaceExists)
-        if (error.code !== 48 && error.codeName !== 'NamespaceExists') {
-            console.warn(`Warning: Could not ensure collection ${collectionName}:`, error.message);
+        // Collection might already exist due to race condition, or other error
+        // Log warning but don't fail - let subsequent operations handle errors
+        if (error.codeName === 'NamespaceExists') {
+            // This is expected in race conditions, silently continue
+            return;
         }
+        console.warn(`Error ensuring collection ${collectionName} exists:`, error.message);
     }
 }
 
@@ -80,12 +73,11 @@ async function ensureCollectionsExist(collectionNames) {
  */
 async function collectionExists(collectionName) {
     try {
-        const collections = await prisma.$runCommandRaw({
-            listCollections: 1,
-            filter: { name: collectionName }
-        });
+        const collections = await mongoose.connection.db
+            .listCollections({ name: collectionName })
+            .toArray();
 
-        return collections.cursor.firstBatch.length > 0;
+        return collections.length > 0;
     } catch (error) {
         console.error(`Error checking if collection ${collectionName} exists:`, error.message);
         return false;