@friggframework/core 2.0.0--canary.419.8343c27.0 → 2.0.0--canary.425.06986ff.0

package/database/mongo.js

@@ -5,16 +5,14 @@
 const { Encrypt } = require('../encrypt');
 const { mongoose } = require('./mongoose');
 const { debug, flushDebugLog } = require('../logs');
-const { findNearestBackendPackageJson } = require('../utils');
-const path = require('path');
-const fs = require('fs');
 
 mongoose.plugin(Encrypt);
 mongoose.set('applyPluginsToDiscriminators', true); // Needed for LHEncrypt
 
-// Load app definition to check for DocumentDB configuration
-let appDefinition = {};
-let mongoConfig = {
+// 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
@@ -30,133 +28,9 @@ const connectToDatabase = async () => {
         return;
     }
 
-    console.log('🔗 Connecting to database...');
-
-    // Load appDefinition inside the function
-    try {
-        console.log(
-            '🔍 Loading app definition for DocumentDB configuration...'
-        );
-
-        const backendPath = findNearestBackendPackageJson();
-        if (!backendPath) {
-            throw new Error('Could not find backend package.json');
-        }
-
-        const backendDir = path.dirname(backendPath);
-        const backendFilePath = path.join(backendDir, 'index.js');
-        if (!fs.existsSync(backendFilePath)) {
-            throw new Error('Could not find index.js');
-        }
-
-        const backend = require(backendFilePath);
-        appDefinition = backend.Definition;
-
-        console.log('📁 AppDefinition content:', JSON.stringify(appDefinition));
-
-        // Add DocumentDB TLS configuration if enabled
-        if (appDefinition.database?.documentDB?.enable === true) {
-            console.log('📄 DocumentDB configuration detected, enabling TLS');
-            console.log('📁 Current working directory:', process.cwd());
-            console.log(
-                '📋 App definition database config:',
-                JSON.stringify(appDefinition.database, null, 2)
-            );
-
-            mongoConfig.tls = true;
-
-            // Set TLS CA file path if specified
-            if (appDefinition.database.documentDB.tlsCAFile) {
-                const tlsCAFile = appDefinition.database.documentDB.tlsCAFile;
-
-                // Basic safety: reject obviously dangerous paths
-                if (tlsCAFile.includes('..') || path.isAbsolute(tlsCAFile)) {
-                    console.warn(
-                        '⚠️  Rejecting potentially unsafe tlsCAFile path:',
-                        tlsCAFile
-                    );
-                } else {
-                    const tlsCAFilePath = path.resolve(
-                        process.cwd(),
-                        tlsCAFile
-                    );
-
-                    console.log('📄 DocumentDB TLS CA file configured:');
-                    console.log('   📎 Original path:', tlsCAFile);
-                    console.log('   📎 Resolved path:', tlsCAFilePath);
-                    console.log(
-                        '   📄 File exists:',
-                        fs.existsSync(tlsCAFilePath)
-                    );
-
-                    // Only set tlsCAFile if the file actually exists
-                    if (fs.existsSync(tlsCAFilePath)) {
-                        mongoConfig.tlsCAFile = tlsCAFilePath;
-                        console.log('✅ TLS CA file configured successfully');
-                    } else {
-                        throw new Error(
-                            `TLS CA file not found at ${tlsCAFilePath}`
-                        );
-                    }
-
-                    // Debug directory listing (only in development)
-                    if (process.env.NODE_ENV !== 'production') {
-                        try {
-                            console.log('📁 Current directory contents:');
-                            fs.readdirSync(process.cwd()).forEach((item) => {
-                                const stats = fs.statSync(
-                                    path.join(process.cwd(), item)
-                                );
-                                console.log(
-                                    `   ${
-                                        stats.isDirectory() ? '📁' : '📄'
-                                    } ${item}`
-                                );
-                            });
-
-                            const securityDir = path.join(
-                                process.cwd(),
-                                'security'
-                            );
-                            if (fs.existsSync(securityDir)) {
-                                console.log('📁 Security directory contents:');
-                                fs.readdirSync(securityDir).forEach((item) => {
-                                    console.log(`   📄 ${item}`);
-                                });
-                            } else {
-                                console.log(
-                                    '❌ Security directory does not exist at:',
-                                    securityDir
-                                );
-                            }
-                        } catch (error) {
-                            console.log(
-                                '❌ Error listing directory contents:',
-                                error.message
-                            );
-                        }
-                    }
-                }
-            }
-        } else {
-            console.log(
-                '📄 DocumentDB not enabled, using standard MongoDB configuration'
-            );
-        }
-    } catch (error) {
-        console.error('❌ Error loading app definition:', error.message);
-        debug(
-            'Could not load app definition for DocumentDB configuration:',
-            error.message
-        );
-    }
-
-    console.log('🔗 MongoDB URI:', process.env.MONGO_URI ? 'SET' : 'NOT SET');
-    console.log('🔧 Final mongoConfig:', JSON.stringify(mongoConfig, null, 2));
-
     debug('=> using new database connection');
     await mongoose.connect(process.env.MONGO_URI, mongoConfig);
-    debug('Connection state:', mongoose.STATES[mongoose.connection.readyState]);
+    debug('Connection state:',  mongoose.STATES[mongoose.connection.readyState]);
     mongoose.connection.on('error', (error) => flushDebugLog(error));
 };
 

package/handlers/routers/health.js

@@ -9,19 +9,18 @@ const router = Router();
 
 const validateApiKey = (req, res, next) => {
     const apiKey = req.headers['x-api-key'];
-
+    
     if (req.path === '/health') {
         return next();
     }
-
+    
     if (!apiKey || apiKey !== process.env.HEALTH_API_KEY) {
-        console.error('Unauthorized access attempt to health endpoint');
         return res.status(401).json({
             status: 'error',
-            message: 'Unauthorized',
+            message: 'Unauthorized'
         });
     }
-
+    
     next();
 };
 
@@ -31,7 +30,7 @@ const checkExternalAPI = (url, timeout = 5000) => {
     return new Promise((resolve) => {
         const protocol = url.startsWith('https:') ? https : http;
         const startTime = Date.now();
-
+        
         try {
             const request = protocol.get(url, { timeout }, (res) => {
                 const responseTime = Date.now() - startTime;
@@ -39,7 +38,7 @@ const checkExternalAPI = (url, timeout = 5000) => {
                     status: 'healthy',
                     statusCode: res.statusCode,
                     responseTime,
-                    reachable: res.statusCode < 500,
+                    reachable: res.statusCode < 500
                 });
             });
 
@@ -48,7 +47,7 @@ const checkExternalAPI = (url, timeout = 5000) => {
                     status: 'unhealthy',
                     error: error.message,
                     responseTime: Date.now() - startTime,
-                    reachable: false,
+                    reachable: false
                 });
             });
 
@@ -58,7 +57,7 @@ const checkExternalAPI = (url, timeout = 5000) => {
                     status: 'timeout',
                     error: 'Request timeout',
                     responseTime: timeout,
-                    reachable: false,
+                    reachable: false
                 });
             });
         } catch (error) {
@@ -66,7 +65,7 @@ const checkExternalAPI = (url, timeout = 5000) => {
                 status: 'error',
                 error: error.message,
                 responseTime: Date.now() - startTime,
-                reachable: false,
+                reachable: false
             });
         }
     });
@@ -77,14 +76,14 @@ const getDatabaseState = () => {
         0: 'disconnected',
         1: 'connected',
         2: 'connecting',
-        3: 'disconnecting',
+        3: 'disconnecting'
     };
     const readyState = mongoose.connection.readyState;
-
+    
     return {
         readyState,
         stateName: stateMap[readyState],
-        isConnected: readyState === 1,
+        isConnected: readyState === 1
     };
 };
 
@@ -92,7 +91,7 @@ const checkDatabaseHealth = async () => {
     const { stateName, isConnected } = getDatabaseState();
     const result = {
         status: isConnected ? 'healthy' : 'unhealthy',
-        state: stateName,
+        state: stateName
     };
 
     if (isConnected) {
@@ -105,20 +104,19 @@ const checkDatabaseHealth = async () => {
 };
 
 const getEncryptionConfiguration = () => {
-    const { STAGE, BYPASS_ENCRYPTION_STAGE, KMS_KEY_ARN, AES_KEY_ID } =
-        process.env;
-
+    const { STAGE, BYPASS_ENCRYPTION_STAGE, KMS_KEY_ARN, AES_KEY_ID } = process.env;
+    
     const defaultBypassStages = ['dev', 'test', 'local'];
     const useEnv = BYPASS_ENCRYPTION_STAGE !== undefined;
     const bypassStages = useEnv
         ? BYPASS_ENCRYPTION_STAGE.split(',').map((s) => s.trim())
         : defaultBypassStages;
-
+    
     const isBypassed = bypassStages.includes(STAGE);
     const hasAES = AES_KEY_ID && AES_KEY_ID.trim() !== '';
     const hasKMS = KMS_KEY_ARN && KMS_KEY_ARN.trim() !== '' && !hasAES;
     const mode = hasAES ? 'aes' : hasKMS ? 'kms' : 'none';
-
+    
     return {
         stage: STAGE || null,
         isBypassed,
@@ -130,33 +128,41 @@ const getEncryptionConfiguration = () => {
 
 const createTestEncryptionModel = () => {
     const { Encrypt } = require('./../../encrypt');
-
-    const testSchema = new mongoose.Schema(
-        {
-            testSecret: { type: String, lhEncrypt: true },
-            normalField: { type: String },
-            nestedSecret: {
-                value: { type: String, lhEncrypt: true },
-            },
-        },
-        { timestamps: false }
-    );
+    
+    const testSchema = new mongoose.Schema({
+        testSecret: { type: String, lhEncrypt: true },
+        normalField: { type: String },
+        nestedSecret: {
+            value: { type: String, lhEncrypt: true }
+        }
+    }, { timestamps: false });
 
     testSchema.plugin(Encrypt);
+    
+    return mongoose.models.TestEncryption || 
+        mongoose.model('TestEncryption', testSchema);
+};
 
-    return (
-        mongoose.models.TestEncryption ||
-        mongoose.model('TestEncryption', testSchema)
-    );
+const createTestDocument = async (TestModel) => {
+    const testData = {
+        testSecret: 'This is a secret value that should be encrypted',
+        normalField: 'This is a normal field that should not be encrypted',
+        nestedSecret: {
+            value: 'This is a nested secret that should be encrypted'
+        }
+    };
+
+    const testDoc = new TestModel(testData);
+    await testDoc.save();
+    
+    return { testDoc, testData };
 };
 
 const verifyDecryption = (retrievedDoc, originalData) => {
-    return (
-        retrievedDoc &&
+    return retrievedDoc && 
         retrievedDoc.testSecret === originalData.testSecret &&
         retrievedDoc.normalField === originalData.normalField &&
-        retrievedDoc.nestedSecret?.value === originalData.nestedSecret.value
-    );
+        retrievedDoc.nestedSecret?.value === originalData.nestedSecret.value;
 };
 
 const verifyEncryptionInDatabase = async (testDoc, originalData, TestModel) => {
@@ -165,144 +171,84 @@ const verifyEncryptionInDatabase = async (testDoc, originalData, TestModel) => {
         .collection(collectionName)
         .findOne({ _id: testDoc._id });
 
-    const secretIsEncrypted =
-        rawDoc &&
-        typeof rawDoc.testSecret === 'string' &&
-        rawDoc.testSecret.includes(':') &&
+    const secretIsEncrypted = rawDoc && 
+        typeof rawDoc.testSecret === 'string' && 
+        rawDoc.testSecret.includes(':') && 
         rawDoc.testSecret !== originalData.testSecret;
-
-    const nestedIsEncrypted =
-        rawDoc?.nestedSecret?.value &&
+    
+    const nestedIsEncrypted = rawDoc?.nestedSecret?.value && 
         typeof rawDoc.nestedSecret.value === 'string' &&
-        rawDoc.nestedSecret.value.includes(':') &&
+        rawDoc.nestedSecret.value.includes(':') && 
         rawDoc.nestedSecret.value !== originalData.nestedSecret.value;
-
-    const normalNotEncrypted =
-        rawDoc && rawDoc.normalField === originalData.normalField;
+    
+    const normalNotEncrypted = rawDoc && 
+        rawDoc.normalField === originalData.normalField;
 
     return {
         secretIsEncrypted,
         nestedIsEncrypted,
-        normalNotEncrypted,
+        normalNotEncrypted
     };
 };
 
 const evaluateEncryptionTestResults = (decryptionWorks, encryptionResults) => {
-    const { secretIsEncrypted, nestedIsEncrypted, normalNotEncrypted } =
-        encryptionResults;
-
-    if (
-        decryptionWorks &&
-        secretIsEncrypted &&
-        nestedIsEncrypted &&
-        normalNotEncrypted
-    ) {
+    const { secretIsEncrypted, nestedIsEncrypted, normalNotEncrypted } = encryptionResults;
+    
+    if (decryptionWorks && secretIsEncrypted && nestedIsEncrypted && normalNotEncrypted) {
         return {
             status: 'enabled',
-            testResult: 'Encryption and decryption verified successfully',
+            testResult: 'Encryption and decryption verified successfully'
         };
     }
-
+    
     if (decryptionWorks && (!secretIsEncrypted || !nestedIsEncrypted)) {
         return {
             status: 'unhealthy',
-            testResult: 'Fields are not being encrypted in database',
+            testResult: 'Fields are not being encrypted in database'
         };
     }
-
+    
     if (decryptionWorks && !normalNotEncrypted) {
         return {
             status: 'unhealthy',
-            testResult: 'Normal fields are being incorrectly encrypted',
+            testResult: 'Normal fields are being incorrectly encrypted'
         };
     }
-
+    
     return {
         status: 'unhealthy',
-        testResult: 'Decryption failed or data mismatch',
+        testResult: 'Decryption failed or data mismatch'
     };
 };
 
-const withTimeout = (promise, ms, errorMessage) => {
-    return Promise.race([
-        promise,
-        new Promise((_, reject) =>
-            setTimeout(() => reject(new Error(errorMessage)), ms)
-        ),
-    ]);
-};
-
 const testEncryption = async () => {
-    // eslint-disable-next-line no-console
-    console.log('Starting encryption test');
     const TestModel = createTestEncryptionModel();
-    // eslint-disable-next-line no-console
-    console.log('Test model created');
-
-    const testData = {
-        testSecret: 'This is a secret value that should be encrypted',
-        normalField: 'This is a normal field that should not be encrypted',
-        nestedSecret: {
-            value: 'This is a nested secret that should be encrypted',
-        },
-    };
-
-    const testDoc = new TestModel(testData);
-    await withTimeout(testDoc.save(), 5000, 'Save operation timed out');
-    // eslint-disable-next-line no-console
-    console.log('Test document saved');
-
+    const { testDoc, testData } = await createTestDocument(TestModel);
+    
     try {
-        const retrievedDoc = await withTimeout(
-            TestModel.findById(testDoc._id),
-            5000,
-            'Find operation timed out'
-        );
-        // eslint-disable-next-line no-console
-        console.log('Test document retrieved');
+        const retrievedDoc = await TestModel.findById(testDoc._id);
         const decryptionWorks = verifyDecryption(retrievedDoc, testData);
-        const encryptionResults = await withTimeout(
-            verifyEncryptionInDatabase(testDoc, testData, TestModel),
-            5000,
-            'Database verification timed out'
-        );
-        // eslint-disable-next-line no-console
-        console.log('Encryption verification completed');
-
-        const evaluation = evaluateEncryptionTestResults(
-            decryptionWorks,
-            encryptionResults
-        );
-
+        const encryptionResults = await verifyEncryptionInDatabase(testDoc, testData, TestModel);
+        
+        const evaluation = evaluateEncryptionTestResults(decryptionWorks, encryptionResults);
+        
         return {
             ...evaluation,
-            encryptionWorks: decryptionWorks,
+            encryptionWorks: decryptionWorks
         };
     } finally {
-        await withTimeout(
-            TestModel.deleteOne({ _id: testDoc._id }),
-            5000,
-            'Delete operation timed out'
-        );
-        // eslint-disable-next-line no-console
-        console.log('Test document deleted');
+        await TestModel.deleteOne({ _id: testDoc._id });
     }
 };
 
 const checkEncryptionHealth = async () => {
     const config = getEncryptionConfiguration();
-
+    
     if (config.isBypassed || config.mode === 'none') {
-        // eslint-disable-next-line no-console
-        console.log('Encryption check bypassed:', {
-            stage: config.stage,
-            mode: config.mode,
-        });
-
-        const testResult = config.isBypassed
-            ? 'Encryption bypassed for this stage'
+        const testResult = config.isBypassed 
+            ? 'Encryption bypassed for this stage' 
             : 'No encryption keys configured';
-
+        
         return {
             status: 'disabled',
             mode: config.mode,
@@ -312,14 +258,14 @@ const checkEncryptionHealth = async () => {
             encryptionWorks: false,
             debug: {
                 hasKMS: config.hasKMS,
-                hasAES: config.hasAES,
-            },
+                hasAES: config.hasAES
+            }
         };
     }
 
     try {
         const testResults = await testEncryption();
-
+        
         return {
             ...testResults,
             mode: config.mode,
@@ -327,8 +273,8 @@ const checkEncryptionHealth = async () => {
             stage: config.stage,
             debug: {
                 hasKMS: config.hasKMS,
-                hasAES: config.hasAES,
-            },
+                hasAES: config.hasAES
+            }
         };
     } catch (error) {
         return {
@@ -340,8 +286,8 @@ const checkEncryptionHealth = async () => {
             encryptionWorks: false,
             debug: {
                 hasKMS: config.hasKMS,
-                hasAES: config.hasAES,
-            },
+                hasAES: config.hasAES
+            }
         };
     }
 };
@@ -349,28 +295,25 @@ const checkEncryptionHealth = async () => {
 const checkExternalAPIs = async () => {
     const apis = [
         { name: 'github', url: 'https://api.github.com/status' },
-        { name: 'npm', url: 'https://registry.npmjs.org' },
+        { name: 'npm', url: 'https://registry.npmjs.org' }
     ];
 
     const results = await Promise.all(
-        apis.map((api) =>
-            checkExternalAPI(api.url).then((result) => ({
-                name: api.name,
-                ...result,
-            }))
+        apis.map(api => 
+            checkExternalAPI(api.url).then(result => ({ name: api.name, ...result }))
         )
     );
-
+    
     const apiStatuses = {};
     let allReachable = true;
-
+    
     results.forEach(({ name, ...checkResult }) => {
         apiStatuses[name] = checkResult;
         if (!checkResult.reachable) {
             allReachable = false;
         }
     });
-
+    
     return { apiStatuses, allReachable };
 };
 
@@ -378,7 +321,7 @@ const checkIntegrations = () => {
     const moduleTypes = Array.isArray(moduleFactory.moduleTypes)
         ? moduleFactory.moduleTypes
         : [];
-
+    
     const integrationTypes = Array.isArray(integrationFactory.integrationTypes)
         ? integrationFactory.integrationTypes
         : [];
@@ -402,7 +345,7 @@ const buildHealthCheckResponse = (startTime) => {
         status: 'healthy',
         timestamp: new Date().toISOString(),
         checks: {},
-        calculateResponseTime: () => Date.now() - startTime,
+        calculateResponseTime: () => Date.now() - startTime
     };
 };
 
@@ -410,15 +353,13 @@ router.get('/health', async (_req, res) => {
     const status = {
         status: 'ok',
         timestamp: new Date().toISOString(),
-        service: 'frigg-core-api',
+        service: 'frigg-core-api'
     };
 
     res.status(200).json(status);
 });
 
 router.get('/health/detailed', async (_req, res) => {
-    // eslint-disable-next-line no-console
-    console.log('Starting detailed health check');
     const startTime = Date.now();
     const response = buildHealthCheckResponse(startTime);
 
@@ -428,16 +369,12 @@ router.get('/health/detailed', async (_req, res) => {
         if (!dbState.isConnected) {
             response.status = 'unhealthy';
         }
-        // eslint-disable-next-line no-console
-        console.log('Database check completed:', response.checks.database);
     } catch (error) {
         response.checks.database = {
             status: 'unhealthy',
-            error: error.message,
+            error: error.message
         };
         response.status = 'unhealthy';
-        // eslint-disable-next-line no-console
-        console.log('Database check error:', error.message);
     }
 
     try {
@@ -445,16 +382,12 @@ router.get('/health/detailed', async (_req, res) => {
         if (response.checks.encryption.status === 'unhealthy') {
             response.status = 'unhealthy';
         }
-        // eslint-disable-next-line no-console
-        console.log('Encryption check completed:', response.checks.encryption);
     } catch (error) {
         response.checks.encryption = {
             status: 'unhealthy',
-            error: error.message,
+            error: error.message
         };
         response.status = 'unhealthy';
-        // eslint-disable-next-line no-console
-        console.log('Encryption check error:', error.message);
     }
 
     const { apiStatuses, allReachable } = await checkExternalAPIs();
@@ -462,24 +395,15 @@ router.get('/health/detailed', async (_req, res) => {
     if (!allReachable) {
         response.status = 'unhealthy';
     }
-    // eslint-disable-next-line no-console
-    console.log('External APIs check completed:', response.checks.externalApis);
 
     try {
         response.checks.integrations = checkIntegrations();
-        // eslint-disable-next-line no-console
-        console.log(
-            'Integrations check completed:',
-            response.checks.integrations
-        );
     } catch (error) {
         response.checks.integrations = {
             status: 'unhealthy',
-            error: error.message,
+            error: error.message
         };
         response.status = 'unhealthy';
-        // eslint-disable-next-line no-console
-        console.log('Integrations check error:', error.message);
     }
 
     response.responseTime = response.calculateResponseTime();
@@ -487,27 +411,19 @@ router.get('/health/detailed', async (_req, res) => {
 
     const statusCode = response.status === 'healthy' ? 200 : 503;
     res.status(statusCode).json(response);
-
-    // eslint-disable-next-line no-console
-    console.log(
-        'Final health status:',
-        response.status,
-        'Response time:',
-        response.responseTime
-    );
 });
 
 router.get('/health/live', (_req, res) => {
     res.status(200).json({
         status: 'alive',
-        timestamp: new Date().toISOString(),
+        timestamp: new Date().toISOString()
     });
 });
 
 router.get('/health/ready', async (_req, res) => {
     const dbState = getDatabaseState();
     const isDbReady = dbState.isConnected;
-
+    
     let areModulesReady = false;
     try {
         const moduleTypes = Array.isArray(moduleFactory.moduleTypes)
@@ -525,11 +441,11 @@ router.get('/health/ready', async (_req, res) => {
         timestamp: new Date().toISOString(),
         checks: {
             database: isDbReady,
-            modules: areModulesReady,
-        },
+            modules: areModulesReady
+        }
     });
 });
 
 const handler = createAppHandler('HTTP Event: Health', router);
 
-module.exports = { handler, router };
+module.exports = { handler, router };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/core",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.419.8343c27.0",
+  "version": "2.0.0--canary.425.06986ff.0",
   "dependencies": {
     "@hapi/boom": "^10.0.1",
     "aws-sdk": "^2.1200.0",
@@ -22,9 +22,9 @@
     "uuid": "^9.0.1"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.419.8343c27.0",
-    "@friggframework/prettier-config": "2.0.0--canary.419.8343c27.0",
-    "@friggframework/test": "2.0.0--canary.419.8343c27.0",
+    "@friggframework/eslint-config": "2.0.0--canary.425.06986ff.0",
+    "@friggframework/prettier-config": "2.0.0--canary.425.06986ff.0",
+    "@friggframework/test": "2.0.0--canary.425.06986ff.0",
     "@types/lodash": "4.17.15",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "chai": "^4.3.6",
@@ -56,5 +56,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "8343c27a69423f9186421c9caf188399e56bbf67"
+  "gitHead": "06986fff8607c98e3157e5a219716c53276b065e"
 }