@friggframework/devtools 2.0.0-next.53 → 2.0.0-next.55

package/infrastructure/README.md

@@ -257,6 +257,34 @@ aws lambda get-function-configuration \
   --query 'Layers[*].Arn'
 ```
 
+**Disabling Prisma Layer (Bundle with Functions):**
+
+By default, Prisma ships via a Lambda Layer. You can disable the layer and bundle Prisma directly with each Lambda:
+
+```javascript
+const appDefinition = {
+    name: 'my-app',
+    usePrismaLambdaLayer: false, // Bundle Prisma with each function
+    integrations: [{ Definition: { name: 'asana' } }],
+};
+```
+
+**When to disable the Prisma Layer:**
+
+-   ✅ Your CI/CD IAM user lacks `lambda:PublishLayerVersion`
+-   ✅ Deploying to an AWS region/account with Lambda layer restrictions
+-   ✅ Troubleshooting Prisma client loading issues
+-   ✅ You prefer a simpler deployment artifact (no shared layer management)
+
+**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 per function) | None (layer-related) |
+
+> ℹ️ When `usePrismaLambdaLayer: false`, Prisma stays inside each bundle and the runtime automatically loads the correct binary. No extra configuration is required.
+
 ## Usage Examples
 
 ### Basic Deployment

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

@@ -57,6 +57,8 @@ class MigrationBuilder extends InfrastructureBuilder {
         // Backwards compatibility: Translate old schema to new ownership schema
         appDefinition = this.translateLegacyConfig(appDefinition, discoveredResources);
 
+        const usePrismaLayer = appDefinition.usePrismaLambdaLayer !== false;
+
         const result = {
             functions: {}, // Lambda function definitions
             resources: {},
@@ -76,7 +78,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);
+        await this.buildFromDecisions(decisions, appDefinition, discoveredResources, result, usePrismaLayer);
 
         console.log(`[${this.name}] ✅ Migration infrastructure configuration completed`);
         return result;
@@ -207,7 +209,7 @@ class MigrationBuilder extends InfrastructureBuilder {
     /**
      * Build migration resources based on ownership decisions
      */
-    async buildFromDecisions(decisions, appDefinition, discoveredResources, result) {
+    async buildFromDecisions(decisions, appDefinition, discoveredResources, result, usePrismaLayer = true) {
         // 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;
@@ -215,16 +217,16 @@ 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);
+            await this.createMigrationInfrastructure(appDefinition, result, usePrismaLayer);
         } 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);
+            await this.createMigrationInfrastructure(appDefinition, result, usePrismaLayer);
         } else {
             // Use external resources
             console.log('  → Using external migration resources');
-            await this.useExternalMigrationResources(decisions, appDefinition, result);
+            await this.useExternalMigrationResources(decisions, appDefinition, result, usePrismaLayer);
         }
     }
 
@@ -232,17 +234,19 @@ class MigrationBuilder extends InfrastructureBuilder {
      * Create Lambda function definitions for database migrations
      * Based on refactor/add-better-support-for-commands branch implementation
      */
-    async createFunctionDefinitions(result) {
+    async createFunctionDefinitions(result, usePrismaLayer = true) {
         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: [
-                // Exclude Prisma runtime client - it's in the Lambda Layer
-                'node_modules/@prisma/client/**',
-                'node_modules/.prisma/**',
-                'node_modules/@friggframework/core/generated/**',
+                // Exclude Prisma runtime client when using Lambda Layer (but keep CLI folder)
+                ...(usePrismaLayer ? [
+                    '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
@@ -328,13 +332,15 @@ class MigrationBuilder extends InfrastructureBuilder {
         const migrationRouterPackageConfig = {
             individually: true,
             exclude: [
-                // Exclude Prisma runtime client - it's in the Lambda Layer
-                'node_modules/@prisma/client/**',
-                'node_modules/.prisma/**',
-                'node_modules/@friggframework/core/generated/**',
+                // Exclude Prisma runtime client when using Lambda Layer
+                ...(usePrismaLayer ? [
+                    'node_modules/@prisma/client/**',
+                    'node_modules/.prisma/**',
+                    'node_modules/@friggframework/core/generated/**',
+                ] : []),
 
-                // Router doesn't need Prisma CLI at all
-                'node_modules/prisma/**',
+                // Router only skips Prisma CLI if Lambda Layer is enabled
+                ...(usePrismaLayer ? ['node_modules/prisma/**'] : []),
 
                 // Exclude ALL nested node_modules
                 'node_modules/**/node_modules/**',
@@ -422,7 +428,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',
-            layers: [{ Ref: 'PrismaLambdaLayer' }], // Use layer for Prisma client runtime
+            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),
             skipEsbuild: true,
             timeout: 900, // 15 minutes for long migrations
             memorySize: 1024, // Extra memory for Prisma operations
@@ -484,12 +490,12 @@ class MigrationBuilder extends InfrastructureBuilder {
      * Create migration infrastructure CloudFormation resources
      * Creates S3 bucket, SQS queue, and Lambda function definitions
      */
-    async createMigrationInfrastructure(appDefinition, result) {
+    async createMigrationInfrastructure(appDefinition, result, usePrismaLayer = true) {
         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);
+        await this.createFunctionDefinitions(result, usePrismaLayer);
 
         console.log('  🔍 DEBUG: result.functions after createFunctionDefinitions:', Object.keys(result.functions || {}));
 
@@ -614,7 +620,7 @@ class MigrationBuilder extends InfrastructureBuilder {
      * Use external migration resources (S3 bucket and SQS queue)
      * Only references external resources - Lambda functions are defined in serverless.yml
      */
-    async useExternalMigrationResources(decisions, appDefinition, result) {
+    async useExternalMigrationResources(decisions, appDefinition, result, usePrismaLayer = true) {
         // Reference external bucket
         const bucketName = decisions.bucket.physicalId;
         if (!bucketName) {

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

@@ -290,5 +290,32 @@ describe('MigrationBuilder', () => {
             expect(builder.getName()).toBe('MigrationBuilder');
         });
     });
+
+    describe('usePrismaLayer configuration', () => {
+        const baseAppDefinition = {
+            database: {
+                postgres: { enable: true },
+            },
+        };
+
+        it('includes Prisma layer by default', async () => {
+            const result = await builder.build(baseAppDefinition, {});
+            expect(result.functions.dbMigrationWorker.layers).toEqual([{ Ref: 'PrismaLambdaLayer' }]);
+        });
+
+        it('omits Prisma layer when disabled', async () => {
+            const appDef = { ...baseAppDefinition, usePrismaLambdaLayer: false };
+            const result = await builder.build(appDef, {});
+            expect(result.functions.dbMigrationWorker.layers).toBeUndefined();
+        });
+
+        it('bundles Prisma runtime when layer disabled', async () => {
+            const appDef = { ...baseAppDefinition, usePrismaLambdaLayer: false };
+            const result = await builder.build(appDef, {});
+            expect(result.functions.dbMigrationWorker.package.exclude).not.toEqual(
+                expect.arrayContaining(['node_modules/@prisma/client/**'])
+            );
+        });
+    });
 });
 

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

@@ -62,6 +62,8 @@ class IntegrationBuilder extends InfrastructureBuilder {
         console.log(`\n[${this.name}] Configuring integrations...`);
         console.log(`  Processing ${appDefinition.integrations.length} integrations...`);
 
+        const usePrismaLayer = appDefinition.usePrismaLambdaLayer !== false;
+
         const result = {
             functions: {},
             resources: {},
@@ -87,7 +89,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
         });
 
         // Build resources based on ownership decisions
-        await this.buildFromDecisions(decisions, appDefinition, result);
+        await this.buildFromDecisions(decisions, appDefinition, result, usePrismaLayer);
 
         console.log(`[${this.name}] ✅ Integration configuration completed`);
         return result;
@@ -142,7 +144,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
     /**
      * Build integration resources based on ownership decisions
      */
-    async buildFromDecisions(decisions, appDefinition, result) {
+    async buildFromDecisions(decisions, appDefinition, result, usePrismaLayer = true) {
         // Create InternalErrorQueue if ownership = STACK
         const shouldCreateInternalErrorQueue = decisions.internalErrorQueue.ownership === ResourceOwnership.STACK;
 
@@ -155,7 +157,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
         }
 
         // Create Lambda function definitions and queue resources for each integration
-        const functionPackageConfig = this.createFunctionPackageConfig();
+        const functionPackageConfig = this.createFunctionPackageConfig(usePrismaLayer);
 
         for (const integration of appDefinition.integrations) {
             const integrationName = integration.Definition.name;
@@ -164,7 +166,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
             console.log(`\n    Adding integration: ${integrationName}`);
 
             // Create Lambda function definitions (serverless template code)
-            await this.createFunctionDefinitions(integration, functionPackageConfig, result);
+            await this.createFunctionDefinitions(integration, functionPackageConfig, result, usePrismaLayer);
 
             // Create or reference SQS queue based on ownership decision
             const shouldCreateQueue = queueDecision.ownership === ResourceOwnership.STACK;
@@ -182,7 +184,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
     /**
      * Create function package exclusion configuration
      */
-    createFunctionPackageConfig() {
+    createFunctionPackageConfig(usePrismaLayer = true) {
         return {
             exclude: [
                 // Exclude AWS SDK (provided by Lambda runtime)
@@ -190,10 +192,12 @@ class IntegrationBuilder extends InfrastructureBuilder {
                 'node_modules/@aws-sdk/**',
 
                 // Exclude Prisma (provided via Lambda Layer)
-                'node_modules/@prisma/**',
-                'node_modules/.prisma/**',
-                'node_modules/prisma/**',
-                'node_modules/@friggframework/core/generated/**',
+                ...(usePrismaLayer ? [
+                    'node_modules/@prisma/**',
+                    'node_modules/.prisma/**',
+                    'node_modules/prisma/**',
+                    'node_modules/@friggframework/core/generated/**',
+                ] : []),
 
                 // Exclude ALL nested node_modules
                 'node_modules/**/node_modules/**',
@@ -249,7 +253,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
      * Create Lambda function definitions for an integration
      * These are serverless framework template function definitions
      */
-    async createFunctionDefinitions(integration, functionPackageConfig, result) {
+    async createFunctionDefinitions(integration, functionPackageConfig, result, usePrismaLayer = true) {
         const integrationName = integration.Definition.name;
 
         // Add webhook handler if enabled (BEFORE catch-all proxy route)
@@ -263,7 +267,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
                 handler: `node_modules/@friggframework/core/handlers/routers/integration-webhook-routers.handlers.${integrationName}Webhook.handler`,
                 skipEsbuild: true,  // Nested exports in node_modules - skip esbuild bundling
                 package: functionPackageConfig,
-                layers: [{ Ref: 'PrismaLambdaLayer' }],  // Webhook handlers need Prisma for credential lookups
+                ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),  // Webhook handlers need Prisma for credential lookups
                 events: [
                     {
                         httpApi: {
@@ -287,7 +291,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
             handler: `node_modules/@friggframework/core/handlers/routers/integration-defined-routers.handlers.${integrationName}.handler`,
             skipEsbuild: true,  // Nested exports in node_modules - skip esbuild bundling
             package: functionPackageConfig,
-            layers: [{ Ref: 'PrismaLambdaLayer' }],  // HTTP handlers need Prisma for integration queries
+            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),  // HTTP handlers need Prisma for integration queries
             events: [
                 {
                     httpApi: {
@@ -305,7 +309,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
             handler: `node_modules/@friggframework/core/handlers/workers/integration-defined-workers.handlers.${integrationName}.queueWorker`,
             skipEsbuild: true,  // Nested exports in node_modules - skip esbuild bundling
             package: functionPackageConfig,
-            layers: [{ Ref: 'PrismaLambdaLayer' }],  // Queue workers need Prisma for database operations
+            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),  // Queue workers need Prisma for database operations
             reservedConcurrency: 5,
             events: [
                 {

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

@@ -662,6 +662,29 @@ describe('IntegrationBuilder', () => {
                 { Ref: 'PrismaLambdaLayer' }
             ]);
         });
+
+        it('should not attach Prisma layer when usePrismaLambdaLayer=false', async () => {
+            const appDefinition = {
+                usePrismaLambdaLayer: false,
+                integrations: [
+                    {
+                        Definition: {
+                            name: 'asana',
+                            webhooks: true,
+                        },
+                    },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.asana.layers).toBeUndefined();
+            expect(result.functions.asanaQueueWorker.layers).toBeUndefined();
+            expect(result.functions.asanaWebhook.layers).toBeUndefined();
+            expect(result.functions.asana.package.exclude).not.toEqual(
+                expect.arrayContaining(['node_modules/@prisma/**'])
+            );
+        });
     });
 });