@friggframework/core 2.0.0--canary.425.2d58c19.0 → 2.0.0--canary.427.c8ff14b.0

package/handlers/routers/health.js

@@ -9,18 +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) {
         return res.status(401).json({
             status: 'error',
-            message: 'Unauthorized'
+            message: 'Unauthorized',
         });
     }
-    
+
     next();
 };
 
@@ -30,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;
@@ -38,7 +38,7 @@ const checkExternalAPI = (url, timeout = 5000) => {
                     status: 'healthy',
                     statusCode: res.statusCode,
                     responseTime,
-                    reachable: res.statusCode < 500
+                    reachable: res.statusCode < 500,
                 });
             });
 
@@ -47,7 +47,7 @@ const checkExternalAPI = (url, timeout = 5000) => {
                     status: 'unhealthy',
                     error: error.message,
                     responseTime: Date.now() - startTime,
-                    reachable: false
+                    reachable: false,
                 });
             });
 
@@ -57,7 +57,7 @@ const checkExternalAPI = (url, timeout = 5000) => {
                     status: 'timeout',
                     error: 'Request timeout',
                     responseTime: timeout,
-                    reachable: false
+                    reachable: false,
                 });
             });
         } catch (error) {
@@ -65,7 +65,7 @@ const checkExternalAPI = (url, timeout = 5000) => {
                 status: 'error',
                 error: error.message,
                 responseTime: Date.now() - startTime,
-                reachable: false
+                reachable: false,
             });
         }
     });
@@ -76,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,
     };
 };
 
@@ -91,7 +91,7 @@ const checkDatabaseHealth = async () => {
     const { stateName, isConnected } = getDatabaseState();
     const result = {
         status: isConnected ? 'healthy' : 'unhealthy',
-        state: stateName
+        state: stateName,
     };
 
     if (isConnected) {
@@ -104,19 +104,20 @@ 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,
@@ -128,19 +129,24 @@ 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) => {
@@ -148,21 +154,71 @@ const createTestDocument = async (TestModel) => {
         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'
-        }
+            value: 'This is a nested secret that should be encrypted',
+        },
     };
 
+    console.log('🔧 Creating test document with encryption...');
     const testDoc = new TestModel(testData);
-    await testDoc.save();
-    
-    return { testDoc, testData };
+
+    // Add timeout and detailed error logging
+    const savePromise = testDoc.save();
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(
+            () =>
+                reject(new Error('Save operation timed out after 30 seconds')),
+            30000
+        );
+    });
+
+    try {
+        console.log('💾 Attempting to save document...');
+        const startTime = Date.now();
+
+        await Promise.race([savePromise, timeoutPromise]);
+
+        const duration = Date.now() - startTime;
+        console.log(`✅ Document saved successfully in ${duration}ms`);
+
+        return { testDoc, testData };
+    } catch (error) {
+        console.error('❌ Save operation failed:', {
+            errorName: error.name,
+            errorMessage: error.message,
+            errorStack: error.stack,
+            mongooseConnectionState: testDoc.db.readyState,
+            modelName: TestModel.modelName,
+        });
+
+        // Try to get more details about the connection
+        if (mongoose.connection && mongoose.connection.db) {
+            try {
+                const admin = mongoose.connection.db.admin();
+                const serverStatus = await admin.serverStatus();
+                console.log('📊 DocumentDB Server Status:', {
+                    version: serverStatus.version,
+                    uptime: serverStatus.uptime,
+                    connections: serverStatus.connections,
+                });
+            } catch (statusError) {
+                console.error(
+                    '❌ Could not get server status:',
+                    statusError.message
+                );
+            }
+        }
+
+        throw error;
+    }
 };
 
 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) => {
@@ -171,70 +227,85 @@ 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 testEncryption = async () => {
     const TestModel = createTestEncryptionModel();
     const { testDoc, testData } = await createTestDocument(TestModel);
-    
+
     try {
         const retrievedDoc = await TestModel.findById(testDoc._id);
         const decryptionWorks = verifyDecryption(retrievedDoc, testData);
-        const encryptionResults = await verifyEncryptionInDatabase(testDoc, testData, TestModel);
-        
-        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 TestModel.deleteOne({ _id: testDoc._id });
@@ -243,12 +314,12 @@ const testEncryption = async () => {
 
 const checkEncryptionHealth = async () => {
     const config = getEncryptionConfiguration();
-    
+
     if (config.isBypassed || config.mode === 'none') {
-        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,
@@ -258,14 +329,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,
@@ -273,8 +344,8 @@ const checkEncryptionHealth = async () => {
             stage: config.stage,
             debug: {
                 hasKMS: config.hasKMS,
-                hasAES: config.hasAES
-            }
+                hasAES: config.hasAES,
+            },
         };
     } catch (error) {
         return {
@@ -286,8 +357,8 @@ const checkEncryptionHealth = async () => {
             encryptionWorks: false,
             debug: {
                 hasKMS: config.hasKMS,
-                hasAES: config.hasAES
-            }
+                hasAES: config.hasAES,
+            },
         };
     }
 };
@@ -295,25 +366,28 @@ 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 };
 };
 
@@ -321,7 +395,7 @@ const checkIntegrations = () => {
     const moduleTypes = Array.isArray(moduleFactory.moduleTypes)
         ? moduleFactory.moduleTypes
         : [];
-    
+
     const integrationTypes = Array.isArray(integrationFactory.integrationTypes)
         ? integrationFactory.integrationTypes
         : [];
@@ -345,7 +419,7 @@ const buildHealthCheckResponse = (startTime) => {
         status: 'healthy',
         timestamp: new Date().toISOString(),
         checks: {},
-        calculateResponseTime: () => Date.now() - startTime
+        calculateResponseTime: () => Date.now() - startTime,
     };
 };
 
@@ -353,7 +427,7 @@ 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);
@@ -372,7 +446,7 @@ router.get('/health/detailed', async (_req, res) => {
     } catch (error) {
         response.checks.database = {
             status: 'unhealthy',
-            error: error.message
+            error: error.message,
         };
         response.status = 'unhealthy';
     }
@@ -385,7 +459,7 @@ router.get('/health/detailed', async (_req, res) => {
     } catch (error) {
         response.checks.encryption = {
             status: 'unhealthy',
-            error: error.message
+            error: error.message,
         };
         response.status = 'unhealthy';
     }
@@ -401,7 +475,7 @@ router.get('/health/detailed', async (_req, res) => {
     } catch (error) {
         response.checks.integrations = {
             status: 'unhealthy',
-            error: error.message
+            error: error.message,
         };
         response.status = 'unhealthy';
     }
@@ -416,14 +490,14 @@ router.get('/health/detailed', async (_req, res) => {
 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)
@@ -441,11 +515,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.425.2d58c19.0",
+  "version": "2.0.0--canary.427.c8ff14b.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.425.2d58c19.0",
-    "@friggframework/prettier-config": "2.0.0--canary.425.2d58c19.0",
-    "@friggframework/test": "2.0.0--canary.425.2d58c19.0",
+    "@friggframework/eslint-config": "2.0.0--canary.427.c8ff14b.0",
+    "@friggframework/prettier-config": "2.0.0--canary.427.c8ff14b.0",
+    "@friggframework/test": "2.0.0--canary.427.c8ff14b.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": "2d58c196b068fafce914e0fc631d72a30b745f31"
+  "gitHead": "c8ff14b4f6c1a21bd6c254ad12f1c9963b0374db"
 }