@friggframework/devtools 2.0.0--canary.482.c063a2a.0 → 2.0.0--canary.482.411f36e.0

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

@@ -13,11 +13,16 @@ const { buildPrismaLayer } = require('../../../scripts/build-prisma-layer');
 
 /**
  * Ensure Prisma Lambda Layer exists
- * 
+ *
  * Automatically builds the layer if it doesn't exist.
  * 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
+ * - Uses .build-complete marker file to track successful builds
+ * - Prevents race conditions during concurrent infrastructure composition
+ * - Cleans incomplete builds before retry
+ *
  * @param {Object} databaseConfig - Database configuration from app definition
  * @returns {Promise<void>}
  * @throws {Error} If layer build fails
@@ -25,14 +30,43 @@ const { buildPrismaLayer } = require('../../../scripts/build-prisma-layer');
 async function ensurePrismaLayerExists(databaseConfig = {}) {
     const projectRoot = process.cwd();
     const layerPath = path.join(projectRoot, 'layers/prisma');
+    const completionMarkerPath = path.join(layerPath, '.build-complete');
 
-    // Check if layer already exists
-    if (fs.existsSync(layerPath)) {
+    // Check if build is complete (marker exists)
+    if (fs.existsSync(completionMarkerPath)) {
         console.log('✓ Prisma Lambda Layer already exists at', layerPath);
         return;
     }
 
-    // Layer doesn't exist - build it automatically
+    // Check if incomplete build exists (directory without marker)
+    if (fs.existsSync(layerPath)) {
+        console.log('⚠ Incomplete Prisma layer detected - cleaning...');
+        try {
+            fs.rmSync(layerPath, { recursive: true, force: true });
+            console.log('✓ Cleaned incomplete build');
+        } catch (cleanupError) {
+            // EBUSY error means another process might be building
+            if (cleanupError.code === 'EBUSY' || cleanupError.message.includes('EBUSY')) {
+                console.warn('⏳ Could not clean (EBUSY) - waiting for concurrent build...', cleanupError.message);
+
+                // Wait 1 second and check if concurrent process completed
+                await new Promise(resolve => setTimeout(resolve, 1000));
+
+                // Check if concurrent build completed
+                if (fs.existsSync(completionMarkerPath)) {
+                    console.log('✓ Concurrent build completed');
+                    return;
+                }
+
+                // Concurrent build didn't complete, proceed with our build
+                console.log('⚠ Concurrent build incomplete, proceeding with rebuild');
+            } else {
+                throw cleanupError;
+            }
+        }
+    }
+
+    // Build layer
     console.log('📦 Prisma Lambda Layer not found - building automatically...');
     console.log('   Building MINIMAL layer (runtime only, NO CLI)');
     console.log('   CLI is packaged separately in dbMigrate function');
@@ -41,8 +75,24 @@ async function ensurePrismaLayerExists(databaseConfig = {}) {
     try {
         // Build layer WITHOUT CLI (runtime only for minimal size)
         await buildPrismaLayer(databaseConfig);
+
+        // Create completion marker
+        fs.writeFileSync(
+            completionMarkerPath,
+            `Build completed: ${new Date().toISOString()}\nNode: ${process.version}\nPlatform: ${process.platform}\n`
+        );
+
         console.log('✓ Prisma Lambda Layer built successfully (~10-15MB)\n');
     } catch (error) {
+        // Clean up partial build on failure
+        if (fs.existsSync(layerPath)) {
+            try {
+                fs.rmSync(layerPath, { recursive: true, force: true });
+            } catch (cleanupError) {
+                console.warn('⚠ Could not clean failed build:', cleanupError.message);
+            }
+        }
+
         console.error('✗ Failed to build Prisma Lambda Layer:', error.message);
         console.error('  You may need to run: npm install @friggframework/core\n');
         throw error;

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

@@ -16,6 +16,33 @@ jest.mock('../../../scripts/build-prisma-layer', () => ({
 
 const { buildPrismaLayer } = require('../../../scripts/build-prisma-layer');
 
+// Helper to mock fs methods for different scenarios
+const mockFs = {
+    completedBuild: () => {
+        fs.existsSync = jest.fn((path) => {
+            if (path.endsWith('.build-complete')) return true;
+            if (path.endsWith('layers/prisma')) return true;
+            return false;
+        });
+        fs.writeFileSync = jest.fn();
+        fs.rmSync = jest.fn();
+    },
+    incompleteBuild: () => {
+        fs.existsSync = jest.fn((path) => {
+            if (path.endsWith('.build-complete')) return false;
+            if (path.endsWith('layers/prisma')) return true;
+            return false;
+        });
+        fs.writeFileSync = jest.fn();
+        fs.rmSync = jest.fn();
+    },
+    noBuild: () => {
+        fs.existsSync = jest.fn().mockReturnValue(false);
+        fs.writeFileSync = jest.fn();
+        fs.rmSync = jest.fn();
+    },
+};
+
 describe('Prisma Layer Manager', () => {
     let originalCwd;
 
@@ -31,11 +58,15 @@ describe('Prisma Layer Manager', () => {
 
     describe('ensurePrismaLayerExists()', () => {
         it('should skip build if layer already exists', async () => {
-            fs.existsSync = jest.fn().mockReturnValue(true);
+            fs.existsSync = jest.fn((path) => {
+                // Completion marker exists
+                if (path.endsWith('.build-complete')) return true;
+                return false;
+            });
 
             await ensurePrismaLayerExists();
 
-            expect(fs.existsSync).toHaveBeenCalledWith('/project/layers/prisma');
+            expect(fs.existsSync).toHaveBeenCalledWith('/project/layers/prisma/.build-complete');
             expect(buildPrismaLayer).not.toHaveBeenCalled();
         });
 
@@ -79,11 +110,15 @@ describe('Prisma Layer Manager', () => {
 
         it('should use correct layer path relative to project root', async () => {
             process.cwd = jest.fn().mockReturnValue('/custom/project/path');
-            fs.existsSync = jest.fn().mockReturnValue(true);
+            fs.existsSync = jest.fn((path) => {
+                // Completion marker exists
+                if (path.endsWith('.build-complete')) return true;
+                return false;
+            });
 
             await ensurePrismaLayerExists();
 
-            expect(fs.existsSync).toHaveBeenCalledWith('/custom/project/path/layers/prisma');
+            expect(fs.existsSync).toHaveBeenCalledWith('/custom/project/path/layers/prisma/.build-complete');
         });
 
         it('should log success when layer already exists', async () => {
@@ -133,6 +168,121 @@ describe('Prisma Layer Manager', () => {
 
             consoleErrorSpy.mockRestore();
         });
+
+        describe('Concurrent Build Protection', () => {
+            it('should skip build if completion marker exists (TDD)', async () => {
+                mockFs.completedBuild();
+
+                await ensurePrismaLayerExists();
+
+                expect(fs.existsSync).toHaveBeenCalledWith('/project/layers/prisma/.build-complete');
+                expect(buildPrismaLayer).not.toHaveBeenCalled();
+            });
+
+            it('should clean and rebuild if directory exists without completion marker (TDD)', async () => {
+                mockFs.incompleteBuild();
+                buildPrismaLayer.mockResolvedValue();
+
+                await ensurePrismaLayerExists();
+
+                // Should clean incomplete build
+                expect(fs.rmSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma',
+                    { recursive: true, force: true }
+                );
+                // Should rebuild
+                expect(buildPrismaLayer).toHaveBeenCalled();
+                // Should create completion marker
+                expect(fs.writeFileSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-complete',
+                    expect.any(String)
+                );
+            });
+
+            it('should create completion marker after successful build (TDD)', async () => {
+                mockFs.noBuild();
+                buildPrismaLayer.mockResolvedValue();
+
+                await ensurePrismaLayerExists();
+
+                expect(fs.writeFileSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-complete',
+                    expect.any(String)
+                );
+            });
+
+            it('should clean up partial build on failure (TDD)', async () => {
+                mockFs.noBuild();
+                buildPrismaLayer.mockRejectedValue(new Error('Build failed'));
+                fs.existsSync = jest.fn((path) => {
+                    // After build starts, directory exists
+                    if (path.endsWith('layers/prisma')) return true;
+                    return false;
+                });
+
+                await expect(ensurePrismaLayerExists()).rejects.toThrow('Build failed');
+
+                expect(fs.rmSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma',
+                    { recursive: true, force: true }
+                );
+            });
+
+            it('should handle cleanup errors gracefully and attempt rebuild (TDD)', async () => {
+                mockFs.incompleteBuild();
+                fs.rmSync = jest.fn().mockImplementation(() => {
+                    throw new Error('EBUSY: resource busy');
+                });
+                buildPrismaLayer.mockResolvedValue();
+
+                const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+
+                await ensurePrismaLayerExists();
+
+                // Should log warning about cleanup failure
+                expect(consoleWarnSpy).toHaveBeenCalledWith(
+                    expect.stringContaining('Could not clean'),
+                    expect.any(String)
+                );
+                // Should still attempt to build
+                expect(buildPrismaLayer).toHaveBeenCalled();
+
+                consoleWarnSpy.mockRestore();
+            });
+
+            it('should wait and check for concurrent process completion (TDD)', async () => {
+                jest.useFakeTimers();
+                mockFs.incompleteBuild();
+
+                // First cleanup fails
+                fs.rmSync = jest.fn().mockImplementation(() => {
+                    throw new Error('EBUSY: resource busy');
+                });
+
+                // After 1 second, completion marker appears (concurrent process finished)
+                let callCount = 0;
+                fs.existsSync = jest.fn((path) => {
+                    callCount++;
+                    if (path.endsWith('.build-complete')) {
+                        return callCount > 2; // Appears after setTimeout
+                    }
+                    if (path.endsWith('layers/prisma')) return true;
+                    return false;
+                });
+
+                const promise = ensurePrismaLayerExists();
+
+                // Fast-forward through the wait
+                jest.advanceTimersByTime(1000);
+
+                await promise;
+
+                // Should not rebuild (concurrent process completed)
+                expect(buildPrismaLayer).not.toHaveBeenCalled();
+
+                jest.useRealTimers();
+            });
+        });
     });
 });
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.482.c063a2a.0",
+  "version": "2.0.0--canary.482.411f36e.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.c063a2a.0",
-    "@friggframework/test": "2.0.0--canary.482.c063a2a.0",
+    "@friggframework/schemas": "2.0.0--canary.482.411f36e.0",
+    "@friggframework/test": "2.0.0--canary.482.411f36e.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.c063a2a.0",
-    "@friggframework/prettier-config": "2.0.0--canary.482.c063a2a.0",
+    "@friggframework/eslint-config": "2.0.0--canary.482.411f36e.0",
+    "@friggframework/prettier-config": "2.0.0--canary.482.411f36e.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": "c063a2aaaaae0e4eaac6338f6adc250cf46b9103"
+  "gitHead": "411f36e107a200d437a085479c514d7bd9fd981d"
 }