@friggframework/devtools 2.0.0--canary.482.563eae6.0 → 2.0.0--canary.482.217a30b.0

package/infrastructure/create-frigg-infrastructure.js

@@ -3,32 +3,65 @@ const fs = require('fs-extra');
 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;
+
 async function createFriggInfrastructure() {
-    const backendPath = findNearestBackendPackageJson();
-    if (!backendPath) {
-        throw new Error('Could not find backend package.json');
+    // Return cached infrastructure if already composed
+    if (cachedInfrastructure) {
+        console.log('✓ Using cached infrastructure definition (already composed)');
+        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');
+    // 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 backend = require(backendFilePath);
-    const appDefinition = backend.Definition;
+    // Mark as composing to prevent concurrent composition
+    isComposing = true;
+
+    try {
+        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 serverlessTemplate = require(path.resolve(
-    //     __dirname,
-    //     './serverless-template.js'
-    // ));
-    const definition = await composeServerlessDefinition(
-        appDefinition,
-    );
+        const backend = require(backendFilePath);
+        const appDefinition = backend.Definition;
 
-    return {
-        ...definition,
-    };
+        // const serverlessTemplate = require(path.resolve(
+        //     __dirname,
+        //     './serverless-template.js'
+        // ));
+        const definition = await composeServerlessDefinition(
+            appDefinition,
+        );
+
+        // Cache the composed infrastructure
+        cachedInfrastructure = {
+            ...definition,
+        };
+
+        return cachedInfrastructure;
+    } finally {
+        // Always clear composing flag
+        isComposing = false;
+    }
 }
 
 module.exports = { createFriggInfrastructure };

package/infrastructure/domains/shared/utilities/prisma-layer-manager.js

@@ -11,6 +11,21 @@ const path = require('path');
 const fs = require('fs');
 const { buildPrismaLayer } = require('../../../scripts/build-prisma-layer');
 
+/**
+ * Check if a process is still running
+ * @param {number} pid - Process ID to check
+ * @returns {boolean} True if process is running
+ */
+function isProcessRunning(pid) {
+    try {
+        // Signal 0 checks if process exists without killing it
+        process.kill(pid, 0);
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
 /**
  * Ensure Prisma Lambda Layer exists
  *
@@ -18,10 +33,11 @@ const { buildPrismaLayer } = require('../../../scripts/build-prisma-layer');
  * The layer contains ONLY the Prisma runtime client (minimal, ~10-15MB).
  * Prisma CLI is bundled separately in the dbMigrate function.
  *
- * Domain Concept: Build Completion State
+ * Domain Concept: Build Completion State & Process Locking
  * - Uses .build-complete marker file to track successful builds
- * - Prevents race conditions during concurrent infrastructure composition
- * - Cleans incomplete builds before retry
+ * - Uses .build-lock PID file to prevent concurrent builds
+ * - Waits for active builds to complete before starting new one
+ * - Cleans stale locks and incomplete builds before retry
  *
  * @param {Object} databaseConfig - Database configuration from app definition
  * @returns {Promise<void>}
@@ -31,6 +47,7 @@ async function ensurePrismaLayerExists(databaseConfig = {}) {
     const projectRoot = process.cwd();
     const layerPath = path.join(projectRoot, 'layers/prisma');
     const completionMarkerPath = path.join(layerPath, '.build-complete');
+    const lockFilePath = path.join(layerPath, '.build-lock');
 
     // Check if build is complete (marker exists)
     if (fs.existsSync(completionMarkerPath)) {
@@ -38,22 +55,50 @@ async function ensurePrismaLayerExists(databaseConfig = {}) {
         return;
     }
 
-    // Check if incomplete build exists (directory without marker)
-    if (fs.existsSync(layerPath)) {
-        console.log('⚠ Incomplete Prisma layer detected');
+    // Check for active build process
+    if (fs.existsSync(lockFilePath)) {
+        const lockPid = parseInt(fs.readFileSync(lockFilePath, 'utf-8').trim(), 10);
+
+        if (isProcessRunning(lockPid)) {
+            console.log(`⏳ Another build process (PID ${lockPid}) is active - waiting...`);
+
+            // Wait up to 60 seconds for the other process to complete
+            for (let i = 0; i < 60; i++) {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+
+                // Check if build completed
+                if (fs.existsSync(completionMarkerPath)) {
+                    console.log('✓ Concurrent build completed successfully');
+                    return;
+                }
+
+                // Check if process died
+                if (!isProcessRunning(lockPid)) {
+                    console.log(`⚠ Build process ${lockPid} terminated - cleaning up stale lock`);
+                    fs.rmSync(lockFilePath, { force: true });
+                    break;
+                }
+            }
 
-        // Wait briefly to see if another process completes the build
-        console.log('⏳ Checking if concurrent build is in progress...');
-        await new Promise(resolve => setTimeout(resolve, 1000));
+            // Timeout - check one final time
+            if (fs.existsSync(completionMarkerPath)) {
+                console.log('✓ Concurrent build completed');
+                return;
+            }
 
-        // Check if concurrent build completed while we waited
-        if (fs.existsSync(completionMarkerPath)) {
-            console.log('✓ Concurrent build completed');
-            return;
+            // Still locked after 60s - remove stale lock
+            console.log('⚠ Build timeout - removing stale lock and rebuilding');
+            fs.rmSync(lockFilePath, { force: true });
+        } else {
+            // Stale lock file (process not running)
+            console.log(`⚠ Stale lock file detected (PID ${lockPid} not running) - cleaning up`);
+            fs.rmSync(lockFilePath, { force: true });
         }
+    }
 
-        // Incomplete build still exists - will be cleaned by buildPrismaLayer()
-        console.log('⚠ Proceeding with rebuild (buildPrismaLayer will clean incomplete build)');
+    // Check if incomplete build exists (directory without marker)
+    if (fs.existsSync(layerPath) && !fs.existsSync(completionMarkerPath)) {
+        console.log('⚠ Incomplete Prisma layer detected - will be cleaned by buildPrismaLayer()');
     }
 
     // Build layer
@@ -62,6 +107,16 @@ async function ensurePrismaLayerExists(databaseConfig = {}) {
     console.log('   CLI is packaged separately in dbMigrate function');
     console.log('   This may take a minute on first deployment.\n');
 
+    // Create lock file with current process PID
+    try {
+        if (!fs.existsSync(layerPath)) {
+            fs.mkdirSync(layerPath, { recursive: true });
+        }
+        fs.writeFileSync(lockFilePath, process.pid.toString());
+    } catch (error) {
+        console.warn('⚠ Could not create lock file:', error.message);
+    }
+
     try {
         // Build layer WITHOUT CLI (runtime only for minimal size)
         await buildPrismaLayer(databaseConfig);
@@ -86,6 +141,15 @@ async function ensurePrismaLayerExists(databaseConfig = {}) {
         console.error('✗ Failed to build Prisma Lambda Layer:', error.message);
         console.error('  You may need to run: npm install @friggframework/core\n');
         throw error;
+    } finally {
+        // Always remove lock file when done (success or failure)
+        if (fs.existsSync(lockFilePath)) {
+            try {
+                fs.rmSync(lockFilePath, { force: true });
+            } catch (error) {
+                console.warn('⚠ Could not remove lock file:', error.message);
+            }
+        }
     }
 }
 

package/infrastructure/domains/shared/utilities/prisma-layer-manager.test.js

@@ -179,6 +179,144 @@ describe('Prisma Layer Manager', () => {
                 expect(buildPrismaLayer).not.toHaveBeenCalled();
             });
 
+            it('should wait for active build process to complete (TDD)', async () => {
+                jest.useFakeTimers();
+
+                // Mock active lock file with running process
+                const activePid = 12345;
+                let completionMarkerExists = false;
+                fs.existsSync = jest.fn((path) => {
+                    if (path.endsWith('.build-complete')) return completionMarkerExists;
+                    if (path.endsWith('.build-lock')) return true;
+                    if (path.endsWith('layers/prisma')) return true;
+                    return false;
+                });
+                fs.readFileSync = jest.fn().mockReturnValue(activePid.toString());
+                fs.writeFileSync = jest.fn();
+                fs.rmSync = jest.fn();
+
+                // Mock process.kill to simulate running process, then completion
+                let killCallCount = 0;
+                const originalKill = process.kill;
+                process.kill = jest.fn((pid, signal) => {
+                    killCallCount++;
+                    if (killCallCount >= 3) {
+                        // After 3 seconds, build completes
+                        completionMarkerExists = true;
+                    }
+                    return true; // Process is running
+                });
+
+                const promise = ensurePrismaLayerExists();
+
+                // Fast-forward through the wait loop
+                for (let i = 0; i < 5; i++) {
+                    jest.advanceTimersByTime(1000);
+                    await Promise.resolve();
+                }
+
+                await promise;
+
+                // Should not rebuild (waited for concurrent build)
+                expect(buildPrismaLayer).not.toHaveBeenCalled();
+
+                process.kill = originalKill;
+                jest.useRealTimers();
+            });
+
+            it('should clean stale lock file if process not running (TDD)', async () => {
+                // Mock stale lock file (process not running)
+                fs.existsSync = jest.fn((path) => {
+                    if (path.endsWith('.build-complete')) return false;
+                    if (path.endsWith('.build-lock')) return true;
+                    if (path.endsWith('layers/prisma')) return false;
+                    return false;
+                });
+                fs.readFileSync = jest.fn().mockReturnValue('99999');
+                fs.writeFileSync = jest.fn();
+                fs.mkdirSync = jest.fn();
+                fs.rmSync = jest.fn();
+
+                // Mock process.kill to throw (process not running)
+                const originalKill = process.kill;
+                process.kill = jest.fn(() => {
+                    throw new Error('ESRCH');
+                });
+
+                buildPrismaLayer.mockResolvedValue();
+
+                await ensurePrismaLayerExists();
+
+                // Should remove stale lock
+                expect(fs.rmSync).toHaveBeenCalledWith('/project/layers/prisma/.build-lock', { force: true });
+                // Should proceed with build
+                expect(buildPrismaLayer).toHaveBeenCalled();
+
+                process.kill = originalKill;
+            });
+
+            it('should create and remove lock file during build (TDD)', async () => {
+                // Mock to simulate successful build flow
+                fs.existsSync = jest.fn((path) => {
+                    // Completion marker doesn't exist initially
+                    if (path.endsWith('.build-complete')) return false;
+                    // Lock file exists in finally block (after writeFileSync)
+                    if (path.endsWith('.build-lock')) return true;
+                    // Directory doesn't exist initially
+                    if (path.endsWith('layers/prisma')) return false;
+                    return false;
+                });
+                fs.writeFileSync = jest.fn();
+                fs.mkdirSync = jest.fn();
+                fs.rmSync = jest.fn();
+                buildPrismaLayer.mockResolvedValue();
+
+                await ensurePrismaLayerExists();
+
+                // Should create directory for lock file
+                expect(fs.mkdirSync).toHaveBeenCalledWith('/project/layers/prisma', { recursive: true });
+
+                // Should create lock file with PID
+                expect(fs.writeFileSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-lock',
+                    expect.any(String)
+                );
+
+                // Should create completion marker
+                expect(fs.writeFileSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-complete',
+                    expect.any(String)
+                );
+
+                // Should remove lock file in finally block
+                expect(fs.rmSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-lock',
+                    { force: true }
+                );
+            });
+
+            it('should remove lock file even if build fails (TDD)', async () => {
+                mockFs.noBuild();
+                fs.mkdirSync = jest.fn();
+                buildPrismaLayer.mockRejectedValue(new Error('Build failed'));
+
+                // After failure, directory exists
+                fs.existsSync = jest.fn((path) => {
+                    if (path.endsWith('.build-complete')) return false;
+                    if (path.endsWith('.build-lock')) return true;
+                    if (path.endsWith('layers/prisma')) return true;
+                    return false;
+                });
+
+                await expect(ensurePrismaLayerExists()).rejects.toThrow('Build failed');
+
+                // Should remove lock file in finally block
+                expect(fs.rmSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-lock',
+                    { force: true }
+                );
+            });
+
             it('should wait and rebuild if directory exists without completion marker (TDD)', async () => {
                 jest.useFakeTimers();
                 mockFs.incompleteBuild();
@@ -258,29 +396,46 @@ describe('Prisma Layer Manager', () => {
             it('should detect when concurrent process completes during wait (TDD)', async () => {
                 jest.useFakeTimers();
 
-                // After 1 second, completion marker appears (concurrent process finished)
-                let callCount = 0;
+                // Simulate lock file existing with completion happening during wait
+                let completionMarkerExists = false;
+                let lockFileExists = true;
                 fs.existsSync = jest.fn((path) => {
-                    callCount++;
-                    if (path.endsWith('.build-complete')) {
-                        return callCount > 2; // Appears after setTimeout
-                    }
+                    if (path.endsWith('.build-complete')) return completionMarkerExists;
+                    if (path.endsWith('.build-lock')) return lockFileExists;
                     if (path.endsWith('layers/prisma')) return true;
                     return false;
                 });
+                fs.readFileSync = jest.fn().mockReturnValue('12345');
                 fs.writeFileSync = jest.fn();
                 fs.rmSync = jest.fn();
 
+                // Mock process.kill to simulate active process
+                let killCallCount = 0;
+                const originalKill = process.kill;
+                process.kill = jest.fn((pid, signal) => {
+                    killCallCount++;
+                    if (killCallCount >= 3) {
+                        // After 3 checks, build completes
+                        completionMarkerExists = true;
+                        lockFileExists = false;
+                    }
+                    return true; // Process is running
+                });
+
                 const promise = ensurePrismaLayerExists();
 
-                // Fast-forward through the wait
-                jest.advanceTimersByTime(1000);
+                // Fast-forward through the wait loop
+                for (let i = 0; i < 5; i++) {
+                    jest.advanceTimersByTime(1000);
+                    await Promise.resolve();
+                }
 
                 await promise;
 
                 // Should not rebuild (concurrent process completed)
                 expect(buildPrismaLayer).not.toHaveBeenCalled();
 
+                process.kill = originalKill;
                 jest.useRealTimers();
             });
         });

package/layers/prisma/.build-complete

@@ -0,0 +1,3 @@
+Build completed: 2025-10-31T04:18:27.501Z
+Node: v23.5.0
+Platform: darwin

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.482.563eae6.0",
+  "version": "2.0.0--canary.482.217a30b.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.563eae6.0",
-    "@friggframework/test": "2.0.0--canary.482.563eae6.0",
+    "@friggframework/schemas": "2.0.0--canary.482.217a30b.0",
+    "@friggframework/test": "2.0.0--canary.482.217a30b.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.563eae6.0",
-    "@friggframework/prettier-config": "2.0.0--canary.482.563eae6.0",
+    "@friggframework/eslint-config": "2.0.0--canary.482.217a30b.0",
+    "@friggframework/prettier-config": "2.0.0--canary.482.217a30b.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": "563eae6ba575d187ac24202d571fe7b8b462f398"
+  "gitHead": "217a30b7d081d55d1606685312b468a2a2a1ed25"
 }