@friggframework/devtools 2.0.0--canary.482.6216503.0 → 2.0.0--canary.482.fcb9803.0

package/infrastructure/create-frigg-infrastructure.js

@@ -1,66 +1,146 @@
 const path = require('path');
 const fs = require('fs-extra');
+const crypto = require('crypto');
 const { composeServerlessDefinition } = require('./infrastructure-composer');
 const { findNearestBackendPackageJson } = require('@friggframework/core');
 
-// Memoization cache to prevent duplicate infrastructure composition
-// when serverless framework loads configuration multiple times
-let cachedInfrastructure = null;
-let isComposing = false;
+// Filesystem-based cache to persist across osls require cache clears
+const getCachePath = (backendDir) => {
+    return path.join(backendDir, '.frigg-infrastructure-cache.json');
+};
+
+const getLockPath = (backendDir) => {
+    return path.join(backendDir, '.frigg-infrastructure-lock');
+};
+
+// Check if process is still running
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
 
 async function createFriggInfrastructure() {
-    // Return cached infrastructure if already composed
-    if (cachedInfrastructure) {
-        console.log('✓ Using cached infrastructure definition (already composed)');
-        return cachedInfrastructure;
+    const backendPath = findNearestBackendPackageJson();
+    if (!backendPath) {
+        throw new Error('Could not find backend package.json');
     }
 
-    // Wait if another call is currently composing
-    if (isComposing) {
-        console.log('⏳ Infrastructure composition in progress - waiting...');
-        // Poll every 100ms until composition completes
-        while (isComposing) {
-            await new Promise(resolve => setTimeout(resolve, 100));
-        }
-        // Return the newly cached infrastructure
-        return cachedInfrastructure;
+    const backendDir = path.dirname(backendPath);
+    const backendFilePath = path.join(backendDir, 'index.js');
+    if (!fs.existsSync(backendFilePath)) {
+        throw new Error('Could not find index.js');
     }
 
-    // Mark as composing to prevent concurrent composition
-    isComposing = true;
+    const cachePath = getCachePath(backendDir);
+    const lockPath = getLockPath(backendDir);
 
-    try {
-        const backendPath = findNearestBackendPackageJson();
-        if (!backendPath) {
-            throw new Error('Could not find backend package.json');
+    // Check for cached infrastructure (filesystem-based for osls require cache clearing)
+    if (fs.existsSync(cachePath)) {
+        try {
+            const cached = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+            // Verify cache is still valid (less than 60 seconds old)
+            if (Date.now() - cached.timestamp < 60000) {
+                console.log('✓ Using filesystem-cached infrastructure definition');
+                return cached.definition;
+            } else {
+                console.log('⚠️ Cache expired (> 60s), recomposing...');
+                fs.removeSync(cachePath);
+            }
+        } catch (error) {
+            console.log('⚠️ Invalid cache file, recomposing...', error.message);
+            fs.removeSync(cachePath);
         }
+    }
+
+    // Check for active composition process
+    if (fs.existsSync(lockPath)) {
+        const lockPid = parseInt(fs.readFileSync(lockPath, 'utf-8').trim(), 10);
+
+        if (isProcessRunning(lockPid)) {
+            console.log(`⏳ Another composition (PID ${lockPid}) in progress - waiting...`);
+
+            // Wait up to 30 seconds for the other process to complete
+            for (let i = 0; i < 30; i++) {
+                await new Promise(resolve => setTimeout(resolve, 1000));
 
-        const backendDir = path.dirname(backendPath);
-        const backendFilePath = path.join(backendDir, 'index.js');
-        if (!fs.existsSync(backendFilePath)) {
-            throw new Error('Could not find index.js');
+                // Check if cache was created by other process
+                if (fs.existsSync(cachePath)) {
+                    try {
+                        const cached = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+                        console.log('✓ Using infrastructure composed by concurrent process');
+                        return cached.definition;
+                    } catch (error) {
+                        // Cache file corrupted, continue to compose ourselves
+                        break;
+                    }
+                }
+
+                // Check if process died
+                if (!isProcessRunning(lockPid)) {
+                    console.log(`⚠ Composition process ${lockPid} terminated - cleaning up stale lock`);
+                    fs.removeSync(lockPath);
+                    break;
+                }
+            }
+        } else {
+            // Stale lock file
+            console.log(`⚠️ Stale lock file detected (PID ${lockPid} not running) - cleaning up`);
+            fs.removeSync(lockPath);
         }
+    }
+
+    // Create lock file with current process PID
+    try {
+        fs.writeFileSync(lockPath, process.pid.toString());
+    } catch (error) {
+        console.warn('⚠ Could not create lock file:', error.message);
+    }
 
+    try {
         const backend = require(backendFilePath);
         const appDefinition = backend.Definition;
 
-        // const serverlessTemplate = require(path.resolve(
-        //     __dirname,
-        //     './serverless-template.js'
-        // ));
         const definition = await composeServerlessDefinition(
             appDefinition,
         );
 
-        // Cache the composed infrastructure
-        cachedInfrastructure = {
-            ...definition,
-        };
+        // Write cache to filesystem (persists across osls require cache clears)
+        try {
+            fs.writeFileSync(cachePath, JSON.stringify({
+                timestamp: Date.now(),
+                definition
+            }));
+            console.log('✓ Infrastructure definition cached to filesystem');
+        } catch (error) {
+            console.warn('⚠ Could not write cache file:', error.message);
+        }
 
-        return cachedInfrastructure;
+        return definition;
+    } catch (error) {
+        // Clean up partial cache on error
+        if (fs.existsSync(cachePath)) {
+            try {
+                fs.removeSync(cachePath);
+            } catch (cleanupError) {
+                console.warn('⚠ Could not clean failed cache:', cleanupError.message);
+            }
+        }
+
+        console.error('✗ Failed to compose infrastructure:', error.message);
+        throw error;
     } finally {
-        // Always clear composing flag
-        isComposing = false;
+        // Always remove lock file when done (success or failure)
+        if (fs.existsSync(lockPath)) {
+            try {
+                fs.removeSync(lockPath);
+            } catch (error) {
+                console.warn('⚠ Could not remove lock file:', error.message);
+            }
+        }
     }
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.482.6216503.0",
+  "version": "2.0.0--canary.482.fcb9803.0",
   "dependencies": {
     "@aws-sdk/client-ec2": "^3.835.0",
     "@aws-sdk/client-kms": "^3.835.0",
@@ -12,8 +12,8 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/schemas": "2.0.0--canary.482.6216503.0",
-    "@friggframework/test": "2.0.0--canary.482.6216503.0",
+    "@friggframework/schemas": "2.0.0--canary.482.fcb9803.0",
+    "@friggframework/test": "2.0.0--canary.482.fcb9803.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -35,8 +35,8 @@
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.482.6216503.0",
-    "@friggframework/prettier-config": "2.0.0--canary.482.6216503.0",
+    "@friggframework/eslint-config": "2.0.0--canary.482.fcb9803.0",
+    "@friggframework/prettier-config": "2.0.0--canary.482.fcb9803.0",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
@@ -68,5 +68,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "6216503a031bf84cdd718845e8116fb13cda1533"
+  "gitHead": "fcb98034ee94170352938e83dd718b0e93dbf6e3"
 }