@friggframework/devtools 2.0.0--canary.482.7be62db.0 → 2.0.0--canary.482.caa9000.0

package/infrastructure/domains/shared/utilities/base-definition-factory.js

@@ -224,7 +224,7 @@ function createBaseDefinition(
                 ],
                 packager: 'npm',
                 keepNames: true,
-                keepOutputDirectory: false,  // Clean up .esbuild directory after packaging
+                keepOutputDirectory: true,  // Keep .esbuild directory to prevent ENOENT errors during packaging
                 exclude: [
                     'aws-sdk',
                     '@aws-sdk/*',

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.7be62db.0",
+  "version": "2.0.0--canary.482.caa9000.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.7be62db.0",
-    "@friggframework/test": "2.0.0--canary.482.7be62db.0",
+    "@friggframework/schemas": "2.0.0--canary.482.caa9000.0",
+    "@friggframework/test": "2.0.0--canary.482.caa9000.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.7be62db.0",
-    "@friggframework/prettier-config": "2.0.0--canary.482.7be62db.0",
+    "@friggframework/eslint-config": "2.0.0--canary.482.caa9000.0",
+    "@friggframework/prettier-config": "2.0.0--canary.482.caa9000.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": "7be62db49f55502252f0139a12562832210f8a74"
+  "gitHead": "caa90009460831fdb4685c012c2cdf11b1df78de"
 }