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

package/database/index.js

@@ -1,25 +1,38 @@
+//todo: probably most of this file content can be removed
+
+/**
+ * Database Module Index
+ * 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 { mongoose } = require('./mongoose');
-const {
-    connectToDatabase,
-    disconnectFromDatabase,
-    createObjectId,
-} = require('./mongo');
 const { IndividualUser } = require('./models/IndividualUser');
 const { OrganizationUser } = require('./models/OrganizationUser');
-const { State } = require('./models/State');
-const { Token } = require('./models/Token');
 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,
-    connectToDatabase,
-    disconnectFromDatabase,
-    createObjectId,
     IndividualUser,
     OrganizationUser,
-    State,
-    Token,
     UserModel,
     WebsocketConnection,
+    // Prisma
+    prisma,
+    TokenRepository,
+    WebsocketConnectionRepository,
 };

package/database/models/WebsocketConnection.js

@@ -1,5 +1,8 @@
 const { mongoose } = require('../mongoose');
-const AWS = require('aws-sdk');
+const {
+    ApiGatewayManagementApiClient,
+    PostToConnectionCommand,
+} = require('@aws-sdk/client-apigatewaymanagementapi');
 
 const schema = new mongoose.Schema({
     connectionId: { type: mongoose.Schema.Types.String },
@@ -8,24 +11,27 @@ const schema = new mongoose.Schema({
 // 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 AWS.ApiGatewayManagementApi({
-                    apiVersion: '2018-11-29',
+                const apigwManagementApi = new ApiGatewayManagementApiClient({
                     endpoint: process.env.WEBSOCKET_API_ENDPOINT,
                 });
 
                 try {
-                    await apigwManagementApi
-                        .postToConnection({
-                            ConnectionId: conn.connectionId,
-                            Data: JSON.stringify(data),
-                        })
-                        .promise();
+                    const command = new PostToConnectionCommand({
+                        ConnectionId: conn.connectionId,
+                        Data: JSON.stringify(data),
+                    });
+                    await apigwManagementApi.send(command);
                 } catch (error) {
-                    if (error.statusCode === 410) {
+                    if (error.statusCode === 410 || error.$metadata?.httpStatusCode === 410) {
                         console.log(`Stale connection ${conn.connectionId}`);
                         await this.deleteOne({
                             connectionId: conn.connectionId,

package/database/models/readme.md

@@ -0,0 +1 @@
+// todo: we need to get rid of this entire models folder

package/database/prisma.js

@@ -0,0 +1,222 @@
+const {
+    createEncryptionExtension,
+} = require('./encryption/prisma-encryption-extension');
+const { registerCustomSchema } = require('./encryption/encryption-schema-registry');
+const { logger } = require('./encryption/logger');
+const { Cryptor } = require('../encrypt/Cryptor');
+const config = require('./config');
+
+/**
+ * Ensures DATABASE_URL is set for MongoDB connections
+ * Falls back to MONGO_URI if DATABASE_URL is not set
+ * Infrastructure layer concern - maps legacy MONGO_URI to Prisma's expected DATABASE_URL
+ * 
+ * Note: This should only be called when DB_TYPE is 'mongodb'
+ */
+function ensureMongoDbUrl() {
+    // If DATABASE_URL is already set, use it
+    if (process.env.DATABASE_URL && process.env.DATABASE_URL.trim()) {
+        return;
+    }
+
+    // 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;
+    }
+
+    // Neither is set - error
+    throw new Error(
+        'DATABASE_URL or MONGO_URI environment variable must be set for MongoDB'
+    );
+}
+
+function getEncryptionConfig() {
+    const STAGE = process.env.STAGE || process.env.NODE_ENV || 'development';
+    const shouldBypassEncryption = ['dev', 'test', 'local'].includes(STAGE);
+
+    if (shouldBypassEncryption) {
+        return { enabled: false };
+    }
+
+    const hasKMS =
+        process.env.KMS_KEY_ARN && process.env.KMS_KEY_ARN.trim() !== '';
+    const hasAES =
+        process.env.AES_KEY_ID && process.env.AES_KEY_ID.trim() !== '';
+
+    if (!hasKMS && !hasAES) {
+        logger.warn(
+            'No encryption keys configured (KMS_KEY_ARN or AES_KEY_ID). ' +
+            'Field-level encryption disabled. Set STAGE=production and configure keys to enable.'
+        );
+        return { enabled: false };
+    }
+
+    return {
+        enabled: true,
+        method: hasKMS ? 'kms' : 'aes',
+    };
+}
+
+/**
+ * Loads and registers custom encryption schema from appDefinition
+ * Gracefully handles cases where appDefinition is not available
+ */
+function loadCustomEncryptionSchema() {
+    try {
+        // Lazy require to avoid circular dependency issues
+        const path = require('node:path');
+        const { findNearestBackendPackageJson } = require('../utils');
+
+        const backendPackagePath = findNearestBackendPackageJson();
+        if (!backendPackagePath) {
+            return; // No backend found, skip custom schema
+        }
+
+        const backendDir = path.dirname(backendPackagePath);
+        const backendIndexPath = path.join(backendDir, 'index.js');
+
+        const backendModule = require(backendIndexPath);
+        const appDefinition = backendModule?.Definition;
+
+        if (!appDefinition) {
+            return; // No app definition found
+        }
+
+        const customSchema = appDefinition.encryption?.schema;
+
+        if (customSchema && Object.keys(customSchema).length > 0) {
+            registerCustomSchema(customSchema);
+        }
+    } catch (error) {
+        // Silently ignore errors - custom schema is optional
+        // This handles cases like:
+        // - Backend package.json not found (tests, standalone usage)
+        // - No appDefinition defined
+        // - No custom encryption schema specified
+        logger.debug('Could not load custom encryption schema:', error.message);
+    }
+}
+
+const prismaClientSingleton = () => {
+    let PrismaClient;
+
+    // Helper to try loading Prisma client from multiple locations
+    const loadPrismaClient = (dbType) => {
+        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 paths) {
+            try {
+                return require(path).PrismaClient;
+            } catch (err) {
+                // Continue to next path
+            }
+        }
+
+        throw new Error(
+            `Cannot find Prisma client for ${dbType}. Tried paths: ${paths.join(', ')}`
+        );
+    };
+
+    if (config.DB_TYPE === 'mongodb') {
+        // Ensure DATABASE_URL is set (fallback to MONGO_URI if needed)
+        ensureMongoDbUrl();
+        PrismaClient = loadPrismaClient('mongodb');
+    } else if (config.DB_TYPE === 'postgresql') {
+        PrismaClient = loadPrismaClient('postgresql');
+    } else {
+        throw new Error(
+            `Unsupported database type: ${config.DB_TYPE}. Supported values: 'mongodb', 'postgresql'`
+        );
+    }
+
+    let client = new PrismaClient({
+        log: process.env.PRISMA_LOG_LEVEL
+            ? process.env.PRISMA_LOG_LEVEL.split(',')
+            : ['error', 'warn'],
+        errorFormat: 'pretty',
+    });
+
+    const encryptionConfig = getEncryptionConfig();
+
+    if (encryptionConfig.enabled) {
+        try {
+            // Load custom encryption schema from appDefinition before creating extension
+            loadCustomEncryptionSchema();
+
+            const cryptor = new Cryptor({
+                shouldUseAws: encryptionConfig.method === 'kms',
+            });
+
+            client = client.$extends(
+                createEncryptionExtension({
+                    cryptor,
+                    enabled: true,
+                })
+            );
+
+            logger.info(
+                `Field-level encryption enabled using ${encryptionConfig.method.toUpperCase()}`
+            );
+        } catch (error) {
+            logger.error(
+                'Failed to initialize encryption extension:',
+                error
+            );
+            logger.warn('Continuing without encryption...');
+        }
+    } else {
+        logger.info('Field-level encryption disabled');
+    }
+
+    return client;
+};
+
+const globalForPrisma = global;
+
+// Lazy initialization - only create singleton when first accessed
+function getPrismaClient() {
+    if (!globalForPrisma._prismaInstance) {
+        globalForPrisma._prismaInstance = prismaClientSingleton();
+    }
+    return globalForPrisma._prismaInstance;
+}
+
+// Export a getter for lazy initialization
+const prisma = new Proxy({}, {
+    get(target, prop) {
+        return getPrismaClient()[prop];
+    }
+});
+
+async function disconnectPrisma() {
+    await getPrismaClient().$disconnect();
+}
+
+async function connectPrisma() {
+    await getPrismaClient().$connect();
+
+    // Initialize MongoDB schema - ensure all collections exist
+    // Only run for MongoDB/DocumentDB (not PostgreSQL)
+    // This prevents "Cannot create namespace in multi-document transaction" errors
+    if (config.DB_TYPE === 'mongodb') {
+        const { initializeMongoDBSchema } = require('./utils/mongodb-schema-init');
+        await initializeMongoDBSchema();
+    }
+
+    return getPrismaClient();
+}
+
+module.exports = {
+    prisma,
+    connectPrisma,
+    disconnectPrisma,
+    getEncryptionConfig,
+    ensureMongoDbUrl, // Exported for testing
+};

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

@@ -0,0 +1,43 @@
+const { HealthCheckRepositoryMongoDB } = require('./health-check-repository-mongodb');
+const { HealthCheckRepositoryPostgreSQL } = require('./health-check-repository-postgres');
+const config = require('../config');
+
+/**
+ * Factory function to create a health check repository for the configured database type.
+ * Requires explicit prismaClient injection to support IoC container patterns.
+ *
+ * @param {Object} options
+ * @param {Object} options.prismaClient - Prisma client instance (required for dependency injection)
+ * @returns {HealthCheckRepositoryInterface} Database-specific health check repository
+ * @throws {Error} If prismaClient is not provided
+ *
+ * @example
+ * const { prisma } = require('../prisma');
+ * const repository = createHealthCheckRepository({ prismaClient: prisma });
+ */
+function createHealthCheckRepository({ prismaClient } = {}) {
+    if (!prismaClient) {
+        throw new Error('prismaClient is required');
+    }
+
+    const dbType = config.DB_TYPE;
+
+    switch (dbType) {
+        case 'mongodb':
+            return new HealthCheckRepositoryMongoDB({ prismaClient });
+
+        case 'postgresql':
+            return new HealthCheckRepositoryPostgreSQL({ prismaClient });
+
+        default:
+            throw new Error(
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+            );
+    }
+}
+
+module.exports = {
+    createHealthCheckRepository,
+    HealthCheckRepositoryMongoDB,
+    HealthCheckRepositoryPostgreSQL,
+};

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

@@ -0,0 +1,87 @@
+/**
+ * Health Check Repository Interface
+ * Abstract base class defining the contract for health check 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, HealthCheckRepository has identical structure across MongoDB and PostgreSQL,
+ * so HealthCheckRepository serves both. This interface exists for consistency and
+ * future-proofing if database-specific implementations become needed.
+ *
+ * @abstract
+ */
+class HealthCheckRepositoryInterface {
+    /**
+     * Ping database to verify connectivity
+     *
+     * @param {number} maxTimeMS - Maximum time in milliseconds
+     * @returns {Promise<number>} Response time in milliseconds
+     * @abstract
+     */
+    async pingDatabase(maxTimeMS) {
+        throw new Error('Method pingDatabase must be implemented by subclass');
+    }
+
+    /**
+     * Save a test document
+     *
+     * @param {Object} TestModel - Prisma model
+     * @param {Object} data - Data to save
+     * @returns {Promise<Object>} Saved document
+     * @abstract
+     */
+    async saveTestDocument(TestModel, data) {
+        throw new Error('Method saveTestDocument must be implemented by subclass');
+    }
+
+    /**
+     * Find test document by ID
+     *
+     * @param {Object} TestModel - Prisma model
+     * @param {string|number} id - Document ID
+     * @returns {Promise<Object|null>} Document or null
+     * @abstract
+     */
+    async findTestDocumentById(TestModel, id) {
+        throw new Error('Method findTestDocumentById must be implemented by subclass');
+    }
+
+    /**
+     * Get raw document from collection
+     *
+     * @param {string} collectionName - Collection name
+     * @param {Object} filter - Filter criteria
+     * @returns {Promise<Object|null>} Raw document or null
+     * @abstract
+     */
+    async getRawDocumentFromCollection(collectionName, filter) {
+        throw new Error('Method getRawDocumentFromCollection must be implemented by subclass');
+    }
+
+    /**
+     * Delete test document
+     *
+     * @param {Object} TestModel - Prisma model
+     * @param {string|number} id - Document ID
+     * @returns {Promise<Object>} Deletion result
+     * @abstract
+     */
+    async deleteTestDocument(TestModel, id) {
+        throw new Error('Method deleteTestDocument must be implemented by subclass');
+    }
+
+    /**
+     * Get database connection state
+     *
+     * @returns {Promise<Object>} Connection state info
+     * @abstract
+     */
+    async getDatabaseConnectionState() {
+        throw new Error('Method getDatabaseConnectionState must be implemented by subclass');
+    }
+}
+
+module.exports = { HealthCheckRepositoryInterface };

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

@@ -0,0 +1,91 @@
+const { mongoose } = require('../mongoose');
+const {
+    HealthCheckRepositoryInterface,
+} = require('./health-check-repository-interface');
+
+class HealthCheckRepositoryMongoDB extends HealthCheckRepositoryInterface {
+    /**
+     * @param {Object} params
+     * @param {Object} params.prismaClient - Prisma client instance
+     */
+    constructor({ prismaClient }) {
+        super();
+        this.prisma = prismaClient;
+    }
+
+    /**
+     * @returns {Promise<{readyState: number, stateName: string, isConnected: boolean}>}
+     */
+    async getDatabaseConnectionState() {
+        let isConnected = false;
+        let stateName = 'unknown';
+        
+        try {
+            await this.prisma.$runCommandRaw({ ping: 1 });
+            isConnected = true;
+            stateName = 'connected';
+        } catch (error) {
+            stateName = 'disconnected';
+        }
+
+        return {
+            readyState: isConnected ? 1 : 0,
+            readyState: isConnected ? 1 : 0,
+            stateName,
+            isConnected,
+        };
+    }
+
+    async pingDatabase(maxTimeMS = 2000) {
+        const pingStart = Date.now();
+        
+        // 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) {
+        return await this.prisma.credential.create({
+            data: credentialData,
+        });
+    }
+
+    async findCredentialById(id) {
+        return await this.prisma.credential.findUnique({
+            where: { id },
+        });
+    }
+
+    /**
+     * @param {string} id
+     * @returns {Promise<Object|null>}
+     */
+    async getRawCredentialById(id) {
+        const { ObjectId } = require('mongodb');
+        return await mongoose.connection.db
+            .collection('Credential')
+            .findOne({ _id: new ObjectId(id) });
+    }
+
+    async deleteCredential(id) {
+        await this.prisma.credential.delete({
+            where: { id },
+        });
+    }
+}
+
+module.exports = { HealthCheckRepositoryMongoDB };

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

@@ -0,0 +1,82 @@
+const {
+    HealthCheckRepositoryInterface,
+} = require('./health-check-repository-interface');
+
+class HealthCheckRepositoryPostgreSQL extends HealthCheckRepositoryInterface {
+    /**
+     * @param {Object} params
+     * @param {Object} params.prismaClient - Prisma client instance
+     */
+    constructor({ prismaClient }) {
+        super();
+        this.prisma = prismaClient;
+    }
+
+    /**
+     * @returns {Promise<{readyState: number, stateName: string, isConnected: boolean}>}
+     */
+    async getDatabaseConnectionState() {
+        let isConnected = false;
+        let stateName = 'unknown';
+        
+        try {
+            await this.prisma.$queryRaw`SELECT 1`;
+            isConnected = true;
+            stateName = 'connected';
+        } catch (error) {
+            stateName = 'disconnected';
+        }
+
+        return {
+            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`;
+        return Date.now() - pingStart;
+    }
+
+    async createCredential(credentialData) {
+        return await this.prisma.credential.create({
+            data: credentialData,
+        });
+    }
+
+    async findCredentialById(id) {
+        return await this.prisma.credential.findUnique({
+            where: { id },
+        });
+    }
+
+    /**
+     * @param {string} id
+     * @returns {Promise<Object|null>}
+     */
+    async getRawCredentialById(id) {
+        const results = await this.prisma.$queryRaw`
+            SELECT * FROM "Credential" WHERE id = ${id}
+        `;
+
+        if (!results || results.length === 0) {
+            return null;
+        }
+
+        return results[0];
+    }
+
+    async deleteCredential(id) {
+        await this.prisma.credential.delete({
+            where: { id },
+        });
+    }
+}
+
+module.exports = { HealthCheckRepositoryPostgreSQL };