@friggframework/devtools 2.0.0-next.6 → 2.0.0-next.61

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

@@ -0,0 +1,321 @@
+/**
+ * Tests for MigrationBuilder
+ */
+
+const { MigrationBuilder } = require('./migration-builder');
+
+describe('MigrationBuilder', () => {
+    let builder;
+    let originalEnv;
+
+    beforeEach(() => {
+        builder = new MigrationBuilder();
+        originalEnv = { ...process.env };
+    });
+
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+
+    describe('shouldExecute', () => {
+        it('should return true for PostgreSQL by default', () => {
+            const appDef = {
+                database: {},
+            };
+
+            expect(builder.shouldExecute(appDef)).toBe(true);
+        });
+
+        it('should return true when PostgreSQL is explicitly enabled', () => {
+            const appDef = {
+                database: {
+                    postgres: {
+                        enable: true,
+                    },
+                },
+            };
+
+            expect(builder.shouldExecute(appDef)).toBe(true);
+        });
+
+        it('should return false when PostgreSQL is explicitly disabled', () => {
+            const appDef = {
+                database: {
+                    postgres: {
+                        enable: false,
+                    },
+                },
+            };
+
+            expect(builder.shouldExecute(appDef)).toBe(false);
+        });
+
+        it('should return false in local mode', () => {
+            process.env.FRIGG_SKIP_AWS_DISCOVERY = 'true';
+
+            const appDef = {
+                database: {
+                    postgres: {
+                        enable: true,
+                    },
+                },
+            };
+
+            expect(builder.shouldExecute(appDef)).toBe(false);
+        });
+
+        it('should return true for MongoDB-only (defaults to PostgreSQL)', () => {
+            const appDef = {
+                database: {
+                    mongodb: {
+                        enable: true,
+                    },
+                },
+            };
+
+            expect(builder.shouldExecute(appDef)).toBe(true);
+        });
+    });
+
+    describe('getDependencies', () => {
+        it('should have no dependencies', () => {
+            expect(builder.getDependencies()).toEqual([]);
+        });
+    });
+
+    describe('validate', () => {
+        it('should always return valid', () => {
+            const appDef = {
+                database: {
+                    postgres: {
+                        enable: true,
+                    },
+                },
+            };
+
+            const result = builder.validate(appDef);
+
+            expect(result.valid).toBe(true);
+            expect(result.errors).toEqual([]);
+        });
+    });
+
+    describe('build', () => {
+        it('should create SQS queue resource', async () => {
+            const appDef = {
+                database: {
+                    postgres: {
+                        enable: true,
+                    },
+                },
+            };
+
+            const result = await builder.build(appDef, {});
+
+            expect(result.resources.DbMigrationQueue).toBeDefined();
+            expect(result.resources.DbMigrationQueue.Type).toBe('AWS::SQS::Queue');
+            expect(result.resources.DbMigrationQueue.Properties.QueueName).toBe(
+                '${self:service}-${self:provider.stage}-DbMigrationQueue'
+            );
+            expect(result.resources.DbMigrationQueue.Properties.VisibilityTimeout).toBe(900);
+        });
+
+        it('should create S3 migration status bucket', async () => {
+            const appDef = {
+                database: {
+                    postgres: {
+                        enable: true,
+                    },
+                },
+            };
+
+            const result = await builder.build(appDef, {});
+
+            expect(result.resources.FriggMigrationStatusBucket).toBeDefined();
+            expect(result.resources.FriggMigrationStatusBucket.Type).toBe('AWS::S3::Bucket');
+            expect(result.resources.FriggMigrationStatusBucket.DeletionPolicy).toBe('Retain');
+            expect(result.resources.FriggMigrationStatusBucket.Properties.VersioningConfiguration.Status).toBe('Enabled');
+        });
+
+        it('should add queue URL to environment', async () => {
+            const appDef = {
+                database: {
+                    postgres: {
+                        enable: true,
+                    },
+                },
+            };
+
+            const result = await builder.build(appDef, {});
+
+            expect(result.environment.DB_MIGRATION_QUEUE_URL).toEqual({
+                Ref: 'DbMigrationQueue',
+            });
+        });
+
+        it('should add SQS IAM permissions', async () => {
+            const appDef = {
+                database: {
+                    postgres: {
+                        enable: true,
+                    },
+                },
+            };
+
+            const result = await builder.build(appDef, {});
+
+            expect(result.iamStatements).toContainEqual({
+                Effect: 'Allow',
+                Action: [
+                    'sqs:SendMessage',
+                    'sqs:GetQueueUrl',
+                    'sqs:GetQueueAttributes',
+                ],
+                Resource: { 'Fn::GetAtt': ['DbMigrationQueue', 'Arn'] },
+            });
+        });
+
+        it('should add S3 IAM permissions including ListBucket', async () => {
+            const appDef = {
+                database: {
+                    postgres: {
+                        enable: true,
+                    },
+                },
+            };
+
+            const result = await builder.build(appDef, {});
+
+            // Should have object-level permissions
+            expect(result.iamStatements).toContainEqual(
+                expect.objectContaining({
+                    Effect: 'Allow',
+                    Action: expect.arrayContaining([
+                        's3:PutObject',
+                        's3:GetObject',
+                        's3:DeleteObject',
+                    ]),
+                    Resource: expect.objectContaining({
+                        'Fn::Join': expect.anything(),
+                    }),
+                })
+            );
+
+            // Should have bucket-level ListBucket permission (needed to check if objects exist)
+            expect(result.iamStatements).toContainEqual(
+                expect.objectContaining({
+                    Effect: 'Allow',
+                    Action: ['s3:ListBucket'],
+                    Resource: { 'Fn::GetAtt': ['FriggMigrationStatusBucket', 'Arn'] },
+                })
+            );
+        });
+
+        it('should create dbMigrationRouter function definition', async () => {
+            const appDef = {
+                database: {
+                    postgres: {
+                        enable: true,
+                    },
+                },
+            };
+
+            const result = await builder.build(appDef, {});
+
+            expect(result.functions.dbMigrationRouter).toBeDefined();
+            expect(result.functions.dbMigrationRouter.handler).toBe(
+                'node_modules/@friggframework/core/handlers/routers/db-migration.handler'
+            );
+            expect(result.functions.dbMigrationRouter.skipEsbuild).toBe(true);
+            expect(result.functions.dbMigrationRouter.timeout).toBe(30);
+            expect(result.functions.dbMigrationRouter.memorySize).toBe(512);
+            expect(result.functions.dbMigrationRouter.events).toHaveLength(3);
+            expect(result.functions.dbMigrationRouter.events).toContainEqual({
+                httpApi: { path: '/db-migrate/status', method: 'GET' },
+            });
+            expect(result.functions.dbMigrationRouter.events).toContainEqual({
+                httpApi: { path: '/db-migrate', method: 'POST' },
+            });
+            expect(result.functions.dbMigrationRouter.events).toContainEqual({
+                httpApi: { path: '/db-migrate/{processId}', method: 'GET' },
+            });
+        });
+
+        it('should create dbMigrationWorker function definition', async () => {
+            const appDef = {
+                database: {
+                    postgres: {
+                        enable: true,
+                    },
+                },
+            };
+
+            const result = await builder.build(appDef, {});
+
+            expect(result.functions.dbMigrationWorker).toBeDefined();
+            expect(result.functions.dbMigrationWorker.handler).toBe(
+                'node_modules/@friggframework/core/handlers/workers/db-migration.handler'
+            );
+            expect(result.functions.dbMigrationWorker.skipEsbuild).toBe(true);
+            expect(result.functions.dbMigrationWorker.reservedConcurrency).toBe(1);
+            expect(result.functions.dbMigrationWorker.timeout).toBe(900);
+            expect(result.functions.dbMigrationWorker.memorySize).toBe(1024);
+            expect(result.functions.dbMigrationWorker.layers).toEqual([{ Ref: 'PrismaLambdaLayer' }]);
+            expect(result.functions.dbMigrationWorker.events).toHaveLength(1);
+            expect(result.functions.dbMigrationWorker.events[0].sqs).toEqual({
+                arn: { 'Fn::GetAtt': ['DbMigrationQueue', 'Arn'] },
+                batchSize: 1,
+            });
+        });
+
+        it('should add WORKER_FUNCTION_NAME to router environment', async () => {
+            const appDef = {
+                database: {
+                    postgres: {
+                        enable: true,
+                    },
+                },
+            };
+
+            const result = await builder.build(appDef, {});
+
+            expect(result.functions.dbMigrationRouter.environment.WORKER_FUNCTION_NAME).toEqual({
+                Ref: 'DbMigrationWorkerLambdaFunction',
+            });
+        });
+    });
+
+    describe('getName', () => {
+        it('should return 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/database/migration-resolver.js

@@ -0,0 +1,163 @@
+/**
+ * Migration Resource Resolver
+ *
+ * Resolves migration resource ownership based on user intent and discovered resources.
+ *
+ * Migration resources:
+ * - S3 bucket for migration status tracking
+ * - SQS queue for migration jobs
+ *
+ * Ownership Resolution Logic:
+ * - User sets 'stack' → Create resources in CloudFormation stack
+ * - User sets 'external' → Use existing resources (discovered)
+ * - User sets 'auto' (or unspecified):
+ *   - If resources found in stack → Use stack resources (STACK)
+ *   - If resources found externally → Use external resources (EXTERNAL)
+ *   - If nothing found → Create in stack (STACK)
+ */
+
+const BaseResourceResolver = require('../shared/base-resolver');
+const { ResourceOwnership } = require('../shared/types');
+
+class MigrationResourceResolver extends BaseResourceResolver {
+    constructor() {
+        super();
+    }
+
+    /**
+     * Resolve S3 migration status bucket ownership
+     * @param {Object} appDefinition - Application definition
+     * @param {Object} discovery - Structured discovery result
+     * @returns {Object} Ownership decision with metadata
+     */
+    resolveBucket(appDefinition, discovery) {
+        // Get user intent from app definition
+        const userIntent = appDefinition.migration?.ownership?.bucket || ResourceOwnership.AUTO;
+
+        // Check if bucket exists in CloudFormation stack
+        const inStack = this.isInStack('FriggMigrationStatusBucket', discovery);
+
+        if (userIntent === ResourceOwnership.STACK) {
+            // Explicit: Create/manage in stack
+            const stackResource = inStack ? this.findInStack('FriggMigrationStatusBucket', discovery) : null;
+            return this.createStackDecision(
+                stackResource?.physicalId || null,
+                inStack ? 'Found FriggMigrationStatusBucket in CloudFormation stack' : 'Will create FriggMigrationStatusBucket in stack'
+            );
+        }
+
+        if (userIntent === ResourceOwnership.EXTERNAL) {
+            // Explicit: Use external bucket
+            const external = this.findExternal('AWS::S3::Bucket', discovery);
+            if (!external) {
+                throw new Error(
+                    'ownership.bucket=external but no S3 bucket discovered. ' +
+                    'Provide migrationStatusBucket in discoveredResources or set ownership.bucket=stack'
+                );
+            }
+            return this.createExternalDecision(
+                external.physicalId,
+                'Using external S3 bucket per ownership.bucket=external'
+            );
+        }
+
+        // AUTO resolution
+        if (inStack) {
+            const stackResource = this.findInStack('FriggMigrationStatusBucket', discovery);
+            return this.createStackDecision(
+                stackResource.physicalId,
+                'Found FriggMigrationStatusBucket in CloudFormation stack'
+            );
+        }
+
+        // Check for external bucket
+        const external = this.findExternal('AWS::S3::Bucket', discovery);
+        if (external) {
+            return this.createExternalDecision(
+                external.physicalId,
+                'Found external S3 bucket via discovery'
+            );
+        }
+
+        // No bucket found - create in stack
+        return this.createStackDecision(
+            null,
+            'No existing migration bucket - will create in stack'
+        );
+    }
+
+    /**
+     * Resolve SQS migration queue ownership
+     * @param {Object} appDefinition - Application definition
+     * @param {Object} discovery - Structured discovery result
+     * @returns {Object} Ownership decision with metadata
+     */
+    resolveQueue(appDefinition, discovery) {
+        // Get user intent from app definition
+        const userIntent = appDefinition.migration?.ownership?.queue || ResourceOwnership.AUTO;
+
+        // Check if queue exists in CloudFormation stack
+        const inStack = this.isInStack('DbMigrationQueue', discovery);
+
+        if (userIntent === ResourceOwnership.STACK) {
+            // Explicit: Create/manage in stack
+            const stackResource = inStack ? this.findInStack('DbMigrationQueue', discovery) : null;
+            return this.createStackDecision(
+                stackResource?.physicalId || null,
+                inStack ? 'Found DbMigrationQueue in CloudFormation stack' : 'Will create DbMigrationQueue in stack'
+            );
+        }
+
+        if (userIntent === ResourceOwnership.EXTERNAL) {
+            // Explicit: Use external queue
+            const external = this.findExternal('AWS::SQS::Queue', discovery);
+            if (!external) {
+                throw new Error(
+                    'ownership.queue=external but no SQS queue discovered. ' +
+                    'Provide migrationQueueUrl in discoveredResources or set ownership.queue=stack'
+                );
+            }
+            return this.createExternalDecision(
+                external.physicalId,
+                'Using external SQS queue per ownership.queue=external'
+            );
+        }
+
+        // AUTO resolution
+        if (inStack) {
+            const stackResource = this.findInStack('DbMigrationQueue', discovery);
+            return this.createStackDecision(
+                stackResource.physicalId,
+                'Found DbMigrationQueue in CloudFormation stack'
+            );
+        }
+
+        // Check for external queue
+        const external = this.findExternal('AWS::SQS::Queue', discovery);
+        if (external) {
+            return this.createExternalDecision(
+                external.physicalId,
+                'Found external SQS queue via discovery'
+            );
+        }
+
+        // No queue found - create in stack
+        return this.createStackDecision(
+            null,
+            'No existing migration queue - will create in stack'
+        );
+    }
+
+    /**
+     * Resolve all migration resources
+     * Convenience method for resolving all migration resource ownership
+     */
+    resolveAll(appDefinition, discovery) {
+        return {
+            bucket: this.resolveBucket(appDefinition, discovery),
+            queue: this.resolveQueue(appDefinition, discovery),
+        };
+    }
+}
+
+module.exports = { MigrationResourceResolver };