@friggframework/devtools 2.0.0--canary.490.a8050a4.0 → 2.0.0--canary.499.2ef107f.0

package/frigg-cli/deploy-command/index.js

@@ -284,13 +284,8 @@ async function deployCommand(options) {
 
     console.log('\n✓ Deployment completed successfully!');
 
-    // Run post-deployment health check (unless disabled)
-    // Can be disabled via:
-    // 1. CLI flag: --skip-doctor
-    // 2. AppDefinition: deployment.skipPostDeploymentHealthCheck: true
-    const skipHealthCheck = options.skipDoctor || appDefinition?.deployment?.skipPostDeploymentHealthCheck;
-    
-    if (!skipHealthCheck) {
+    // Run post-deployment health check (unless --skip-doctor)
+    if (!options.skipDoctor) {
         const stackName = getStackName(appDefinition, options);
 
         if (stackName) {
@@ -300,8 +295,7 @@ async function deployCommand(options) {
             console.log('   Run "frigg doctor <stack-name>" manually to check stack health');
         }
     } else {
-        const reason = options.skipDoctor ? '--skip-doctor flag' : 'deployment.skipPostDeploymentHealthCheck: true';
-        console.log(`\n⏭️  Skipping post-deployment health check (${reason})`);
+        console.log('\n⏭️  Skipping post-deployment health check (--skip-doctor)');
     }
 }
 

package/infrastructure/README.md

@@ -257,34 +257,6 @@ aws lambda get-function-configuration \
   --query 'Layers[*].Arn'
 ```
 
-**Disabling Prisma Layer (Bundle with Functions):**
-
-By default, Frigg uses a Lambda Layer for Prisma. You can disable this and bundle Prisma directly with each function:
-
-```javascript
-const appDefinition = {
-    name: 'my-app',
-    usePrismaLambdaLayer: false,  // Bundle Prisma with each function
-    integrations: [{ Definition: { name: 'asana' } }],
-};
-```
-
-**When to disable the Prisma Layer:**
-
--   ✅ CI/CD IAM user lacks `lambda:PublishLayerVersion` permission
--   ✅ Deploying to environments with Lambda layer restrictions
--   ✅ Prefer simpler deployment without layer management
--   ✅ Debugging Prisma client loading issues
-
-**Trade-offs:**
-
-| Mode | Function Size | Deploy Speed | IAM Permissions Required |
-|------|--------------|--------------|-------------------------|
-| **Layer (default)** | ~45MB per function | Faster (layer cached) | `lambda:PublishLayerVersion` |
-| **Bundled** | ~80MB per function | Slower (Prisma uploaded 5x) | None (layer-related) |
-
-**Note:** When `usePrismaLambdaLayer: false`, Prisma client automatically detects the bundled location at runtime. No additional configuration needed.
-
 ## Usage Examples
 
 ### Basic Deployment

package/infrastructure/domains/database/migration-builder.js

@@ -57,9 +57,6 @@ class MigrationBuilder extends InfrastructureBuilder {
         // Backwards compatibility: Translate old schema to new ownership schema
         appDefinition = this.translateLegacyConfig(appDefinition, discoveredResources);
 
-        // Determine if using Prisma Lambda Layer
-        const usePrismaLayer = appDefinition.usePrismaLambdaLayer !== false;
-
         const result = {
             functions: {}, // Lambda function definitions
             resources: {},
@@ -79,7 +76,7 @@ class MigrationBuilder extends InfrastructureBuilder {
         console.log(`     Queue: ${decisions.queue.ownership} - ${decisions.queue.reason}`);
 
         // Build resources based on ownership decisions
-        await this.buildFromDecisions(decisions, appDefinition, discoveredResources, result, usePrismaLayer);
+        await this.buildFromDecisions(decisions, appDefinition, discoveredResources, result);
 
         console.log(`[${this.name}] ✅ Migration infrastructure configuration completed`);
         return result;
@@ -210,7 +207,7 @@ class MigrationBuilder extends InfrastructureBuilder {
     /**
      * Build migration resources based on ownership decisions
      */
-    async buildFromDecisions(decisions, appDefinition, discoveredResources, result, usePrismaLayer = true) {
+    async buildFromDecisions(decisions, appDefinition, discoveredResources, result) {
         // Determine if we need to create resources or use existing ones
         const shouldCreateBucket = decisions.bucket.ownership === ResourceOwnership.STACK;
         const shouldCreateQueue = decisions.queue.ownership === ResourceOwnership.STACK;
@@ -218,12 +215,12 @@ class MigrationBuilder extends InfrastructureBuilder {
         if (shouldCreateBucket && shouldCreateQueue && !decisions.bucket.physicalId && !decisions.queue.physicalId) {
             // Create all new migration infrastructure
             console.log('  → Creating new migration infrastructure in stack');
-            await this.createMigrationInfrastructure(appDefinition, result, usePrismaLayer);
+            await this.createMigrationInfrastructure(appDefinition, result);
         } else if ((decisions.bucket.ownership === ResourceOwnership.STACK && decisions.bucket.physicalId) ||
                    (decisions.queue.ownership === ResourceOwnership.STACK && decisions.queue.physicalId)) {
             // Resources exist in stack - add definitions (CloudFormation idempotency)
             console.log('  → Adding migration definitions to template (existing in stack)');
-            await this.createMigrationInfrastructure(appDefinition, result, usePrismaLayer);
+            await this.createMigrationInfrastructure(appDefinition, result);
         } else {
             // Use external resources
             console.log('  → Using external migration resources');
@@ -235,21 +232,18 @@ class MigrationBuilder extends InfrastructureBuilder {
      * Create Lambda function definitions for database migrations
      * Based on refactor/add-better-support-for-commands branch implementation
      */
-    async createFunctionDefinitions(result, usePrismaLayer = true) {
+    async createFunctionDefinitions(result) {
         console.log('  🔍 DEBUG: createFunctionDefinitions called');
         console.log('  🔍 DEBUG: result.functions is:', typeof result.functions, result.functions);
         // Migration WORKER package config (needs Prisma CLI WASM files)
         const migrationWorkerPackageConfig = {
             individually: true,
             exclude: [
-                // Conditionally exclude Prisma (only if using layer)
-                ...(usePrismaLayer ? [
-                    // Exclude Prisma runtime client - it's in the Lambda Layer
-                    'node_modules/@prisma/client/**',
-                    'node_modules/.prisma/**',
-                    'node_modules/@friggframework/core/generated/**',
-                    // But KEEP node_modules/prisma/** (the CLI with WASM)
-                ] : []),
+                // Exclude Prisma runtime client - it's in the Lambda Layer
+                'node_modules/@prisma/client/**',
+                'node_modules/.prisma/**',
+                'node_modules/@friggframework/core/generated/**',
+                // But KEEP node_modules/prisma/** (the CLI with WASM)
 
                 // Exclude ALL nested node_modules
                 'node_modules/**/node_modules/**',
@@ -428,7 +422,7 @@ class MigrationBuilder extends InfrastructureBuilder {
         console.log('  🔍 DEBUG: About to create dbMigrationWorker...');
         result.functions.dbMigrationWorker = {
             handler: 'node_modules/@friggframework/core/handlers/workers/db-migration.handler',
-            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }), // Conditionally use layer
+            layers: [{ Ref: 'PrismaLambdaLayer' }], // Use layer for Prisma client runtime
             skipEsbuild: true,
             timeout: 900, // 15 minutes for long migrations
             memorySize: 1024, // Extra memory for Prisma operations
@@ -490,12 +484,12 @@ class MigrationBuilder extends InfrastructureBuilder {
      * Create migration infrastructure CloudFormation resources
      * Creates S3 bucket, SQS queue, and Lambda function definitions
      */
-    async createMigrationInfrastructure(appDefinition, result, usePrismaLayer = true) {
+    async createMigrationInfrastructure(appDefinition, result) {
         console.log('  🔍 DEBUG: createMigrationInfrastructure called');
         console.log('  🔍 DEBUG: result object before createFunctionDefinitions:', Object.keys(result));
 
         // Create Lambda function definitions first (they reference the queue)
-        await this.createFunctionDefinitions(result, usePrismaLayer);
+        await this.createFunctionDefinitions(result);
 
         console.log('  🔍 DEBUG: result.functions after createFunctionDefinitions:', Object.keys(result.functions || {}));
 

package/infrastructure/domains/database/migration-builder.test.js

@@ -290,62 +290,5 @@ describe('MigrationBuilder', () => {
             expect(builder.getName()).toBe('MigrationBuilder');
         });
     });
-
-    describe('usePrismaLayer configuration', () => {
-        it('should include Prisma layer in migration worker when usePrismaLayer=true (default)', async () => {
-            const appDef = {
-                database: {
-                    postgres: { enable: true },
-                },
-                usePrismaLambdaLayer: true,
-            };
-
-            const result = await builder.build(appDef, {});
-
-            expect(result.functions.dbMigrationWorker.layers).toEqual([{ Ref: 'PrismaLambdaLayer' }]);
-            
-            // Prisma client should be excluded from package (but not CLI)
-            expect(result.functions.dbMigrationWorker.package.exclude).toEqual(
-                expect.arrayContaining([
-                    'node_modules/@prisma/client/**',
-                    'node_modules/.prisma/**',
-                    'node_modules/@friggframework/core/generated/**',
-                ])
-            );
-        });
-
-        it('should NOT include Prisma layer when usePrismaLayer=false', async () => {
-            const appDef = {
-                database: {
-                    postgres: { enable: true },
-                },
-                usePrismaLambdaLayer: false,
-            };
-
-            const result = await builder.build(appDef, {});
-
-            expect(result.functions.dbMigrationWorker.layers).toBeUndefined();
-        });
-
-        it('should bundle Prisma CLI with migration worker when usePrismaLayer=false', async () => {
-            const appDef = {
-                database: {
-                    postgres: { enable: true },
-                },
-                usePrismaLambdaLayer: false,
-            };
-
-            const result = await builder.build(appDef, {});
-
-            // Prisma should NOT be excluded from package (will be bundled)
-            expect(result.functions.dbMigrationWorker.package.exclude).not.toEqual(
-                expect.arrayContaining([
-                    'node_modules/@prisma/client/**',
-                    'node_modules/.prisma/**',
-                    'node_modules/@friggframework/core/generated/**',
-                ])
-            );
-        });
-    });
 });
 

package/infrastructure/domains/integration/integration-builder.js

@@ -62,9 +62,6 @@ class IntegrationBuilder extends InfrastructureBuilder {
         console.log(`\n[${this.name}] Configuring integrations...`);
         console.log(`  Processing ${appDefinition.integrations.length} integrations...`);
 
-        // Determine if using Prisma Lambda Layer
-        const usePrismaLayer = appDefinition.usePrismaLambdaLayer !== false;
-
         const result = {
             functions: {},
             resources: {},
@@ -90,7 +87,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
         });
 
         // Build resources based on ownership decisions
-        await this.buildFromDecisions(decisions, appDefinition, result, usePrismaLayer);
+        await this.buildFromDecisions(decisions, appDefinition, result);
 
         console.log(`[${this.name}] ✅ Integration configuration completed`);
         return result;
@@ -145,7 +142,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
     /**
      * Build integration resources based on ownership decisions
      */
-    async buildFromDecisions(decisions, appDefinition, result, usePrismaLayer = true) {
+    async buildFromDecisions(decisions, appDefinition, result) {
         // Create InternalErrorQueue if ownership = STACK
         const shouldCreateInternalErrorQueue = decisions.internalErrorQueue.ownership === ResourceOwnership.STACK;
 
@@ -158,7 +155,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
         }
 
         // Create Lambda function definitions and queue resources for each integration
-        const functionPackageConfig = this.createFunctionPackageConfig(usePrismaLayer);
+        const functionPackageConfig = this.createFunctionPackageConfig();
 
         for (const integration of appDefinition.integrations) {
             const integrationName = integration.Definition.name;
@@ -167,7 +164,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
             console.log(`\n    Adding integration: ${integrationName}`);
 
             // Create Lambda function definitions (serverless template code)
-            await this.createFunctionDefinitions(integration, functionPackageConfig, result, usePrismaLayer);
+            await this.createFunctionDefinitions(integration, functionPackageConfig, result);
 
             // Create or reference SQS queue based on ownership decision
             const shouldCreateQueue = queueDecision.ownership === ResourceOwnership.STACK;
@@ -185,20 +182,18 @@ class IntegrationBuilder extends InfrastructureBuilder {
     /**
      * Create function package exclusion configuration
      */
-    createFunctionPackageConfig(usePrismaLayer = true) {
+    createFunctionPackageConfig() {
         return {
             exclude: [
                 // Exclude AWS SDK (provided by Lambda runtime)
                 'node_modules/aws-sdk/**',
                 'node_modules/@aws-sdk/**',
 
-                // Conditionally exclude Prisma (only if using Lambda Layer)
-                ...(usePrismaLayer ? [
-                    'node_modules/@prisma/**',
-                    'node_modules/.prisma/**',
-                    'node_modules/prisma/**',
-                    'node_modules/@friggframework/core/generated/**',
-                ] : []),
+                // Exclude Prisma (provided via Lambda Layer)
+                'node_modules/@prisma/**',
+                'node_modules/.prisma/**',
+                'node_modules/prisma/**',
+                'node_modules/@friggframework/core/generated/**',
 
                 // Exclude ALL nested node_modules
                 'node_modules/**/node_modules/**',
@@ -254,7 +249,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
      * Create Lambda function definitions for an integration
      * These are serverless framework template function definitions
      */
-    async createFunctionDefinitions(integration, functionPackageConfig, result, usePrismaLayer = true) {
+    async createFunctionDefinitions(integration, functionPackageConfig, result) {
         const integrationName = integration.Definition.name;
 
         // Add webhook handler if enabled (BEFORE catch-all proxy route)
@@ -266,9 +261,9 @@ class IntegrationBuilder extends InfrastructureBuilder {
 
             result.functions[webhookFunctionName] = {
                 handler: `node_modules/@friggframework/core/handlers/routers/integration-webhook-routers.handlers.${integrationName}Webhook.handler`,
-                ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),
                 skipEsbuild: true,  // Nested exports in node_modules - skip esbuild bundling
                 package: functionPackageConfig,
+                layers: [{ Ref: 'PrismaLambdaLayer' }],  // Webhook handlers need Prisma for credential lookups
                 events: [
                     {
                         httpApi: {
@@ -290,9 +285,9 @@ class IntegrationBuilder extends InfrastructureBuilder {
         // Create HTTP API handler for integration (catch-all route AFTER webhooks)
         result.functions[integrationName] = {
             handler: `node_modules/@friggframework/core/handlers/routers/integration-defined-routers.handlers.${integrationName}.handler`,
-            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),
             skipEsbuild: true,  // Nested exports in node_modules - skip esbuild bundling
             package: functionPackageConfig,
+            layers: [{ Ref: 'PrismaLambdaLayer' }],  // HTTP handlers need Prisma for integration queries
             events: [
                 {
                     httpApi: {
@@ -308,9 +303,9 @@ class IntegrationBuilder extends InfrastructureBuilder {
         const queueWorkerName = `${integrationName}QueueWorker`;
         result.functions[queueWorkerName] = {
             handler: `node_modules/@friggframework/core/handlers/workers/integration-defined-workers.handlers.${integrationName}.queueWorker`,
-            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),
             skipEsbuild: true,  // Nested exports in node_modules - skip esbuild bundling
             package: functionPackageConfig,
+            layers: [{ Ref: 'PrismaLambdaLayer' }],  // Queue workers need Prisma for database operations
             reservedConcurrency: 5,
             events: [
                 {

package/infrastructure/domains/integration/integration-builder.test.js

@@ -589,5 +589,79 @@ describe('IntegrationBuilder', () => {
             expect(result.functions.testWebhook.package.exclude).toContain('node_modules/@prisma/**');
         });
     });
+
+    describe('Prisma Layer Configuration', () => {
+        it('should attach Prisma Lambda layer to queue worker functions', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'hubspot' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            // Queue workers need Prisma layer for database operations
+            expect(result.functions.hubspotQueueWorker.layers).toEqual([
+                { Ref: 'PrismaLambdaLayer' }
+            ]);
+        });
+
+        it('should attach Prisma layer to multiple queue workers', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'hubspot' } },
+                    { Definition: { name: 'salesforce' } },
+                    { Definition: { name: 'slack' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.hubspotQueueWorker.layers).toEqual([
+                { Ref: 'PrismaLambdaLayer' }
+            ]);
+            expect(result.functions.salesforceQueueWorker.layers).toEqual([
+                { Ref: 'PrismaLambdaLayer' }
+            ]);
+            expect(result.functions.slackQueueWorker.layers).toEqual([
+                { Ref: 'PrismaLambdaLayer' }
+            ]);
+        });
+
+        it('should attach Prisma layer to HTTP handlers for database access', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'stripe' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            // HTTP handlers also need Prisma for integration queries
+            expect(result.functions.stripe.layers).toEqual([
+                { Ref: 'PrismaLambdaLayer' }
+            ]);
+        });
+
+        it('should attach Prisma layer to webhook handlers', async () => {
+            const appDefinition = {
+                integrations: [
+                    {
+                        Definition: {
+                            name: 'hubspot',
+                            webhooks: true,
+                        }
+                    },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            // Webhook handlers need Prisma for credential lookups
+            expect(result.functions.hubspotWebhook.layers).toEqual([
+                { Ref: 'PrismaLambdaLayer' }
+            ]);
+        });
+    });
 });
 

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

@@ -16,20 +16,18 @@ const { buildEnvironment } = require('../environment-builder');
  * Frigg applications need, including:
  * - Core Lambda functions (auth, user, health, dbMigrate)
  * - Error handling infrastructure (SQS, SNS, CloudWatch)
- * - Prisma Lambda Layer (optional, controlled by usePrismaLayer)
+ * - Prisma Lambda Layer
  * - Base plugins and esbuild configuration
  * 
  * @param {Object} AppDefinition - Application definition
  * @param {Object} appEnvironmentVars - Environment variables from app definition
  * @param {Object} discoveredResources - AWS resources discovered during build
- * @param {boolean} usePrismaLayer - Whether to use Prisma Lambda Layer (default true)
  * @returns {Object} Base serverless definition
  */
 function createBaseDefinition(
     AppDefinition,
     appEnvironmentVars,
-    discoveredResources,
-    usePrismaLayer = true
+    discoveredResources
 ) {
     const region = process.env.AWS_REGION || 'us-east-1';
 
@@ -44,13 +42,11 @@ function createBaseDefinition(
                 : []),
         ],
         exclude: [
-            // Conditionally exclude Prisma (only if using Lambda Layer)
-            ...(usePrismaLayer ? [
-                'node_modules/@prisma/**',
-                'node_modules/.prisma/**',
-                'node_modules/prisma/**',
-                'node_modules/@friggframework/core/generated/**',
-            ] : []),
+            // Exclude Prisma (provided via Lambda Layer)
+            'node_modules/@prisma/**',
+            'node_modules/.prisma/**',
+            'node_modules/prisma/**',
+            'node_modules/@friggframework/core/generated/**',
 
             // Exclude AWS SDK (provided by Lambda runtime)
             'node_modules/aws-sdk/**',
@@ -222,12 +218,9 @@ function createBaseDefinition(
                 external: [
                     '@aws-sdk/*',
                     'aws-sdk',
-                    // Conditionally mark Prisma as external (only if using layer)
-                    ...(usePrismaLayer ? [
-                        '@prisma/client',
-                        'prisma',
-                        '.prisma/*',
-                    ] : []),
+                    '@prisma/client',
+                    'prisma',
+                    '.prisma/*',
                 ],
                 packager: 'npm',
                 keepNames: true,
@@ -235,11 +228,8 @@ function createBaseDefinition(
                 exclude: [
                     'aws-sdk',
                     '@aws-sdk/*',
-                    // Conditionally exclude Prisma (only if using layer)
-                    ...(usePrismaLayer ? [
-                        '@prisma/client',
-                        'prisma',
-                    ] : []),
+                    '@prisma/client',
+                    'prisma',
                 ],
             },
             'serverless-offline': {
@@ -262,7 +252,7 @@ function createBaseDefinition(
         functions: {
             auth: {
                 handler: 'node_modules/@friggframework/core/handlers/routers/auth.handler',
-                ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),
+                layers: [{ Ref: 'PrismaLambdaLayer' }],
                 skipEsbuild: true,  // Handlers in node_modules don't need bundling
                 package: skipEsbuildPackageConfig,
                 events: [
@@ -278,14 +268,14 @@ function createBaseDefinition(
             },
             user: {
                 handler: 'node_modules/@friggframework/core/handlers/routers/user.handler',
-                ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),
+                layers: [{ Ref: 'PrismaLambdaLayer' }],
                 skipEsbuild: true,  // Handlers in node_modules don't need bundling
                 package: skipEsbuildPackageConfig,
                 events: [{ httpApi: { path: '/user/{proxy+}', method: 'ANY' } }],
             },
             health: {
                 handler: 'node_modules/@friggframework/core/handlers/routers/health.handler',
-                ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),
+                layers: [{ Ref: 'PrismaLambdaLayer' }],
                 skipEsbuild: true,  // Handlers in node_modules don't need bundling
                 package: skipEsbuildPackageConfig,
                 events: [
@@ -296,7 +286,7 @@ function createBaseDefinition(
             // Note: dbMigrate removed - MigrationBuilder now handles migration infrastructure
             // See: packages/devtools/infrastructure/domains/database/migration-builder.js
         },
-        layers: usePrismaLayer ? {
+        layers: {
             prisma: {
                 path: 'layers/prisma',
                 name: '${self:service}-prisma-${sls:stage}',
@@ -304,7 +294,7 @@ function createBaseDefinition(
                 compatibleRuntimes: ['nodejs20.x', 'nodejs22.x'],
                 retain: false,
             },
-        } : {},
+        },
         resources: {
             Resources: {
                 InternalErrorQueue: {

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

@@ -243,79 +243,6 @@ describe('Base Definition Factory', () => {
             expect(result.useDotenv).toBeDefined();
             expect(typeof result.useDotenv).toBe('boolean');
         });
-
-        describe('usePrismaLayer configuration', () => {
-            it('should include Prisma layer by default (usePrismaLayer=true)', () => {
-                const result = createBaseDefinition({}, {}, {}, true);
-
-                // Layer definition should exist
-                expect(result.layers.prisma).toBeDefined();
-                expect(result.layers.prisma.path).toBe('layers/prisma');
-
-                // Functions should reference the layer
-                expect(result.functions.auth.layers).toEqual([{ Ref: 'PrismaLambdaLayer' }]);
-                expect(result.functions.user.layers).toEqual([{ Ref: 'PrismaLambdaLayer' }]);
-                expect(result.functions.health.layers).toEqual([{ Ref: 'PrismaLambdaLayer' }]);
-
-                // Prisma should be excluded from packages
-                expect(result.functions.auth.package.exclude).toEqual(
-                    expect.arrayContaining([
-                        'node_modules/@prisma/**',
-                        'node_modules/.prisma/**',
-                        'node_modules/prisma/**',
-                        'node_modules/@friggframework/core/generated/**',
-                    ])
-                );
-
-                // Prisma should be external in esbuild
-                expect(result.custom.esbuild.external).toContain('@prisma/client');
-                expect(result.custom.esbuild.external).toContain('prisma');
-                expect(result.custom.esbuild.exclude).toContain('@prisma/client');
-                expect(result.custom.esbuild.exclude).toContain('prisma');
-            });
-
-            it('should NOT include Prisma layer when usePrismaLayer=false', () => {
-                const result = createBaseDefinition({}, {}, {}, false);
-
-                // Layer definition should NOT exist
-                expect(result.layers).toEqual({});
-
-                // Functions should NOT have layer references
-                expect(result.functions.auth.layers).toBeUndefined();
-                expect(result.functions.user.layers).toBeUndefined();
-                expect(result.functions.health.layers).toBeUndefined();
-            });
-
-            it('should bundle Prisma with functions when usePrismaLayer=false', () => {
-                const result = createBaseDefinition({}, {}, {}, false);
-
-                // Prisma should NOT be excluded from packages
-                expect(result.functions.auth.package.exclude).not.toEqual(
-                    expect.arrayContaining([
-                        'node_modules/@prisma/**',
-                        'node_modules/.prisma/**',
-                        'node_modules/prisma/**',
-                        'node_modules/@friggframework/core/generated/**',
-                    ])
-                );
-
-                // Prisma should NOT be external in esbuild
-                expect(result.custom.esbuild.external).not.toContain('@prisma/client');
-                expect(result.custom.esbuild.external).not.toContain('prisma');
-                expect(result.custom.esbuild.external).not.toContain('.prisma/*');
-                expect(result.custom.esbuild.exclude).not.toContain('@prisma/client');
-                expect(result.custom.esbuild.exclude).not.toContain('prisma');
-            });
-
-            it('should default to usePrismaLayer=true when parameter not provided', () => {
-                // Call without 4th parameter
-                const result = createBaseDefinition({}, {}, {});
-
-                // Should behave as if usePrismaLayer=true
-                expect(result.layers.prisma).toBeDefined();
-                expect(result.functions.auth.layers).toEqual([{ Ref: 'PrismaLambdaLayer' }]);
-            });
-        });
     });
 });
 

package/infrastructure/infrastructure-composer.js

@@ -32,15 +32,8 @@ const { validateAndCleanPlugins, validatePackagingConfiguration } = require('./d
 const composeServerlessDefinition = async (AppDefinition) => {
     console.log('🏗️  Composing serverless definition with domain builders...');
 
-    // Determine if using Prisma Lambda Layer (default true)
-    const usePrismaLayer = AppDefinition.usePrismaLambdaLayer !== false;
-
-    // Ensure Prisma layer exists only if using layer mode
-    if (usePrismaLayer) {
-        await ensurePrismaLayerExists(AppDefinition.database || {});
-    } else {
-        console.log('📦 Skipping Prisma Lambda Layer (usePrismaLambdaLayer=false - will bundle with functions)');
-    }
+    // Ensure Prisma layer exists (minimal, runtime only)
+    await ensurePrismaLayerExists(AppDefinition.database || {});
 
     // Create orchestrator with all domain builders
     const orchestrator = new BuilderOrchestrator([
@@ -62,8 +55,7 @@ const composeServerlessDefinition = async (AppDefinition) => {
     const definition = createBaseDefinition(
         AppDefinition,
         appEnvironmentVars,
-        discoveredResources,
-        usePrismaLayer
+        discoveredResources
     );
 
     // Merge builder results into definition

package/infrastructure/scripts/build-prisma-layer.js

@@ -10,8 +10,8 @@
  * The CLI is only needed for migrations and is packaged separately with the dbMigrate function.
  *
  * The layer is configured based on AppDefinition database settings:
- * - PostgreSQL: Includes PostgreSQL client + query engine only
- * - MongoDB: Includes MongoDB client + query engine only (if needed)
+ * - PostgreSQL: Includes PostgreSQL client + query engine + migrations
+ * - MongoDB: Includes MongoDB client + query engine + migrations (if needed)
  * - Defaults to PostgreSQL only if not specified
  *
  * Usage:
@@ -22,7 +22,11 @@
  *   layers/prisma/nodejs/node_modules/
  *   ├── @prisma/client (runtime only, ~10-15MB)
  *   ├── generated/prisma-postgresql (if PostgreSQL enabled)
+ *   │   ├── schema.prisma
+ *   │   └── migrations/
  *   └── generated/prisma-mongodb (if MongoDB enabled)
+ *       ├── schema.prisma
+ *       └── migrations/
  *
  * See: LAMBDA-LAYER-PRISMA.md for complete documentation
  */
@@ -85,6 +89,27 @@ function getGeneratedClientPackages(databaseConfig = {}) {
     return packages;
 }
 
+function getMigrationsPackages(clientPackages) {
+    return clientPackages.map(pkg => ({
+        dbType: pkg.replace('generated/prisma-', ''),
+        clientPackage: pkg
+    }));
+}
+
+function getMigrationSourcePath(searchPaths, dbType) {
+    for (const searchPath of searchPaths) {
+        const candidatePath = path.join(searchPath, `prisma-${dbType}`, 'migrations');
+        if (fs.existsSync(candidatePath)) {
+            return candidatePath;
+        }
+    }
+    return null;
+}
+
+function getMigrationDestinationPath(layerNodeModules, clientPackage) {
+    return path.join(layerNodeModules, clientPackage, 'migrations');
+}
+
 // Configuration
 // Script runs from integration project root (e.g., backend/)
 // and reads Prisma packages from @friggframework/core
@@ -299,11 +324,47 @@ async function copyPrismaPackages(clientPackages) {
     logSuccess(`Copied ${copiedCount} generated client packages from @friggframework/core`);
 }
 
+async function copyMigrations(clientPackages) {
+    logStep(5, 'Copying migrations from @friggframework/core');
+
+    const workspaceNodeModules = path.join(path.dirname(CORE_PACKAGE_PATH), '..');
+    const searchPaths = [
+        path.join(CORE_PACKAGE_PATH, 'node_modules'),
+        path.join(PROJECT_ROOT, 'node_modules'),
+        workspaceNodeModules,
+        CORE_PACKAGE_PATH,
+    ];
+
+    const migrations = getMigrationsPackages(clientPackages);
+    let copiedCount = 0;
+
+    for (const { dbType, clientPackage } of migrations) {
+        const sourcePath = getMigrationSourcePath(searchPaths, dbType);
+
+        if (sourcePath) {
+            const destPath = getMigrationDestinationPath(LAYER_NODE_MODULES, clientPackage);
+            await fs.copy(sourcePath, destPath, { dereference: true });
+            
+            const fromLocation = sourcePath.includes('@friggframework/core/prisma')
+                ? 'core package'
+                : 'workspace';
+            logSuccess(`Copied migrations for ${dbType} (from ${fromLocation})`);
+            copiedCount++;
+        } else {
+            logWarning(`Migrations not found for ${dbType} - this may cause migration failures`);
+        }
+    }
+
+    if (copiedCount > 0) {
+        logSuccess(`Copied migrations for ${copiedCount} database ${copiedCount === 1 ? 'type' : 'types'}`);
+    }
+}
+
 /**
  * Remove unnecessary files to reduce layer size
  */
 async function removeUnnecessaryFiles() {
-    logStep(5, 'Removing unnecessary files (source maps, docs, tests)');
+    logStep(6, 'Removing unnecessary files (source maps, docs, tests)');
 
     let removedCount = 0;
     let totalSize = 0;
@@ -341,7 +402,7 @@ async function removeUnnecessaryFiles() {
  * Remove non-rhel engine binaries to reduce layer size
  */
 async function removeNonRhelBinaries() {
-    logStep(6, 'Removing non-rhel engine binaries');
+    logStep(7, 'Removing non-rhel engine binaries');
 
     let removedCount = 0;
     let totalSize = 0;
@@ -380,7 +441,7 @@ async function removeNonRhelBinaries() {
  * @param {Array} expectedClients - List of client packages that should have binaries
  */
 async function verifyRhelBinaries(expectedClients) {
-    logStep(7, 'Verifying rhel-openssl-3.0.x binaries are present');
+    logStep(8, 'Verifying rhel-openssl-3.0.x binaries are present');
 
     try {
         const findCmd = `find "${LAYER_NODE_MODULES}" -name "*rhel-openssl-3.0.x*" 2>/dev/null || true`;
@@ -414,7 +475,7 @@ async function verifyRhelBinaries(expectedClients) {
  * @param {Array} clientPackages - Generated client packages that were included
  */
 async function verifyLayerStructure(clientPackages) {
-    logStep(8, 'Verifying layer structure (runtime only)');
+    logStep(9, 'Verifying layer structure (runtime only)');
 
     const requiredPaths = [
         '@prisma/client/runtime',
@@ -426,6 +487,11 @@ async function verifyLayerStructure(clientPackages) {
         requiredPaths.push(`${pkg}/schema.prisma`);
     }
 
+    // Add migrations directory for each included client
+    for (const pkg of clientPackages) {
+        requiredPaths.push(`${pkg}/migrations/migration_lock.toml`);
+    }
+
     // Verify CLI is NOT present (keeps layer small)
     const forbiddenPaths = [
         'prisma/build',
@@ -463,7 +529,7 @@ async function verifyLayerStructure(clientPackages) {
  * Calculate and display final layer size
  */
 async function displayLayerSummary() {
-    logStep(9, 'Layer build summary');
+    logStep(10, 'Layer build summary');
 
     const layerSizeMB = getDirectorySize(LAYER_OUTPUT_PATH);
 
@@ -514,6 +580,7 @@ async function buildPrismaLayer(databaseConfig = {}) {
         await createLayerStructure();
         await installPrismaPackages();              // Install runtime client only (NO CLI)
         await copyPrismaPackages(clientPackages);   // Copy generated clients from core
+        await copyMigrations(clientPackages);       // Copy migrations from core
         await removeUnnecessaryFiles();             // Remove source maps, docs, tests (37MB+)
         await removeNonRhelBinaries();              // Remove non-Linux binaries
         await verifyRhelBinaries(clientPackages);   // Verify query engines present
@@ -550,4 +617,10 @@ if (require.main === module) {
         .catch(() => process.exit(1));
 }
 
-module.exports = { buildPrismaLayer, getGeneratedClientPackages };
+module.exports = { 
+    buildPrismaLayer, 
+    getGeneratedClientPackages,
+    getMigrationsPackages,
+    getMigrationSourcePath,
+    getMigrationDestinationPath
+};

package/infrastructure/scripts/build-prisma-layer.test.js

@@ -3,7 +3,12 @@
  * Validates database client selection logic
  */
 
-const { getGeneratedClientPackages } = require('./build-prisma-layer');
+const { 
+    getGeneratedClientPackages,
+    getMigrationsPackages,
+    getMigrationSourcePath,
+    getMigrationDestinationPath
+} = require('./build-prisma-layer');
 
 // Mock the log function
 jest.mock('./build-prisma-layer', () => {
@@ -11,6 +16,9 @@ jest.mock('./build-prisma-layer', () => {
     return {
         ...actual,
         getGeneratedClientPackages: actual.getGeneratedClientPackages,
+        getMigrationsPackages: actual.getMigrationsPackages,
+        getMigrationSourcePath: actual.getMigrationSourcePath,
+        getMigrationDestinationPath: actual.getMigrationDestinationPath,
     };
 });
 
@@ -99,4 +107,48 @@ describe('getGeneratedClientPackages()', () => {
     });
 });
 
+describe('getMigrationsPackages()', () => {
+    it('should extract database types from client packages', () => {
+        const clientPackages = ['generated/prisma-postgresql', 'generated/prisma-mongodb'];
+        const migrations = getMigrationsPackages(clientPackages);
 
+        expect(migrations).toEqual([
+            { dbType: 'postgresql', clientPackage: 'generated/prisma-postgresql' },
+            { dbType: 'mongodb', clientPackage: 'generated/prisma-mongodb' }
+        ]);
+    });
+
+    it('should handle single client package', () => {
+        const clientPackages = ['generated/prisma-postgresql'];
+        const migrations = getMigrationsPackages(clientPackages);
+
+        expect(migrations).toEqual([
+            { dbType: 'postgresql', clientPackage: 'generated/prisma-postgresql' }
+        ]);
+    });
+
+    it('should handle empty array', () => {
+        const migrations = getMigrationsPackages([]);
+        expect(migrations).toEqual([]);
+    });
+});
+
+describe('getMigrationSourcePath()', () => {
+    it('should return correct source path for database type', () => {
+        const searchPaths = ['/workspace/packages/core'];
+        const dbType = 'postgresql';
+        
+        const sourcePath = getMigrationSourcePath(searchPaths, dbType);
+        expect(sourcePath).toBe('/workspace/packages/core/prisma-postgresql/migrations');
+    });
+});
+
+describe('getMigrationDestinationPath()', () => {
+    it('should return correct destination path for client package', () => {
+        const layerNodeModules = '/layers/prisma/nodejs/node_modules';
+        const clientPackage = 'generated/prisma-postgresql';
+        
+        const destPath = getMigrationDestinationPath(layerNodeModules, clientPackage);
+        expect(destPath).toBe('/layers/prisma/nodejs/node_modules/generated/prisma-postgresql/migrations');
+    });
+});

package/infrastructure/scripts/verify-prisma-layer.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+
+const PROJECT_ROOT = process.cwd();
+const LAYER_PATH = path.join(PROJECT_ROOT, 'layers/prisma/nodejs/node_modules');
+
+async function verifyLayerStructure() {
+    console.log('Verifying Prisma layer structure...\n');
+
+    const checks = [
+        {
+            name: 'PostgreSQL schema',
+            path: 'generated/prisma-postgresql/schema.prisma'
+        },
+        {
+            name: 'PostgreSQL migrations directory',
+            path: 'generated/prisma-postgresql/migrations'
+        },
+        {
+            name: 'PostgreSQL migration_lock.toml',
+            path: 'generated/prisma-postgresql/migrations/migration_lock.toml'
+        },
+        {
+            name: '@prisma/client runtime',
+            path: '@prisma/client/runtime'
+        }
+    ];
+
+    let allPassed = true;
+
+    for (const check of checks) {
+        const fullPath = path.join(LAYER_PATH, check.path);
+        const exists = await fs.pathExists(fullPath);
+        
+        if (exists) {
+            console.log(`✓ ${check.name}`);
+        } else {
+            console.log(`✗ ${check.name} (missing)`);
+            allPassed = false;
+        }
+    }
+
+    console.log('\n');
+
+    if (allPassed) {
+        console.log('✓ All checks passed!');
+        const migrationsPath = path.join(LAYER_PATH, 'generated/prisma-postgresql/migrations');
+        const migrationFiles = await fs.readdir(migrationsPath);
+        console.log(`\nFound ${migrationFiles.length} items in migrations directory:`);
+        migrationFiles.forEach(file => {
+            console.log(`  - ${file}`);
+        });
+        return 0;
+    } else {
+        console.log('✗ Some checks failed!');
+        return 1;
+    }
+}
+
+if (require.main === module) {
+    verifyLayerStructure()
+        .then(code => process.exit(code))
+        .catch(err => {
+            console.error('Error:', err.message);
+            process.exit(1);
+        });
+}
+
+module.exports = { verifyLayerStructure };
+

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.490.a8050a4.0",
+  "version": "2.0.0--canary.499.2ef107f.0",
   "bin": {
     "frigg": "./frigg-cli/index.js"
   },
@@ -16,9 +16,9 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/core": "2.0.0--canary.490.a8050a4.0",
-    "@friggframework/schemas": "2.0.0--canary.490.a8050a4.0",
-    "@friggframework/test": "2.0.0--canary.490.a8050a4.0",
+    "@friggframework/core": "2.0.0--canary.499.2ef107f.0",
+    "@friggframework/schemas": "2.0.0--canary.499.2ef107f.0",
+    "@friggframework/test": "2.0.0--canary.499.2ef107f.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -46,8 +46,8 @@
     "validate-npm-package-name": "^5.0.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.490.a8050a4.0",
-    "@friggframework/prettier-config": "2.0.0--canary.490.a8050a4.0",
+    "@friggframework/eslint-config": "2.0.0--canary.499.2ef107f.0",
+    "@friggframework/prettier-config": "2.0.0--canary.499.2ef107f.0",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
@@ -79,5 +79,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a8050a4942d1756d6b981b2eb05ef002a638ce02"
+  "gitHead": "2ef107f34b011aef53330f9c5e4f79316c8fcf3b"
 }

package/layers/prisma/.build-complete

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