@friggframework/devtools 2.0.0--canary.461.849e166.0 → 2.0.0--canary.474.aa465e4.0

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 };

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

@@ -0,0 +1,337 @@
+const { MigrationResourceResolver } = require('./migration-resolver');
+const { ResourceOwnership, createEmptyDiscoveryResult } = require('../shared/types');
+
+describe('MigrationResourceResolver', () => {
+    let resolver;
+
+    beforeEach(() => {
+        resolver = new MigrationResourceResolver();
+    });
+
+    describe('resolveBucket', () => {
+        describe('Explicit ownership intent', () => {
+            it('should respect ownership.bucket=stack when specified', () => {
+                const appDefinition = {
+                    migration: {
+                        ownership: { bucket: 'stack' }
+                    }
+                };
+                const discovery = createEmptyDiscoveryResult();
+
+                const decision = resolver.resolveBucket(appDefinition, discovery);
+
+                expect(decision.ownership).toBe(ResourceOwnership.STACK);
+                expect(decision.physicalId).toBeNull();
+                expect(decision.reason).toContain('Will create FriggMigrationStatusBucket in stack');
+            });
+
+            it('should respect ownership.bucket=external when bucket discovered', () => {
+                const appDefinition = {
+                    migration: {
+                        ownership: { bucket: 'external' }
+                    }
+                };
+                const discovery = createEmptyDiscoveryResult();
+                discovery.external.push({
+                    physicalId: 'my-migration-bucket',
+                    resourceType: 'AWS::S3::Bucket',
+                    source: 'aws-discovery'
+                });
+
+                const decision = resolver.resolveBucket(appDefinition, discovery);
+
+                expect(decision.ownership).toBe(ResourceOwnership.EXTERNAL);
+                expect(decision.physicalId).toBe('my-migration-bucket');
+                expect(decision.reason).toContain('external');
+            });
+
+            it('should error when ownership.bucket=external but no bucket discovered', () => {
+                const appDefinition = {
+                    migration: {
+                        ownership: { bucket: 'external' }
+                    }
+                };
+                const discovery = createEmptyDiscoveryResult();
+
+                expect(() => resolver.resolveBucket(appDefinition, discovery))
+                    .toThrow('ownership.bucket=external but no S3 bucket discovered');
+            });
+        });
+
+        describe('Auto resolution (ownership.bucket=auto)', () => {
+            it('should use stack bucket when found in CloudFormation', () => {
+                const appDefinition = {
+                    migration: {
+                        ownership: { bucket: 'auto' }
+                    }
+                };
+                const discovery = createEmptyDiscoveryResult();
+                discovery.fromCloudFormation = true;
+                discovery.stackManaged.push({
+                    logicalId: 'FriggMigrationStatusBucket',
+                    physicalId: 'stack-migration-bucket',
+                    resourceType: 'AWS::S3::Bucket'
+                });
+
+                const decision = resolver.resolveBucket(appDefinition, discovery);
+
+                expect(decision.ownership).toBe(ResourceOwnership.STACK);
+                expect(decision.physicalId).toBe('stack-migration-bucket');
+                expect(decision.reason).toContain('Found FriggMigrationStatusBucket in CloudFormation stack');
+            });
+
+            it('should use external bucket when found via discovery', () => {
+                const appDefinition = {
+                    migration: {
+                        ownership: { bucket: 'auto' }
+                    }
+                };
+                const discovery = createEmptyDiscoveryResult();
+                discovery.external.push({
+                    physicalId: 'external-migration-bucket',
+                    resourceType: 'AWS::S3::Bucket',
+                    source: 'aws-discovery'
+                });
+
+                const decision = resolver.resolveBucket(appDefinition, discovery);
+
+                expect(decision.ownership).toBe(ResourceOwnership.EXTERNAL);
+                expect(decision.physicalId).toBe('external-migration-bucket');
+                expect(decision.reason).toContain('Found external S3 bucket via discovery');
+            });
+
+            it('should create new bucket when none found', () => {
+                const appDefinition = {
+                    migration: {
+                        ownership: { bucket: 'auto' }
+                    }
+                };
+                const discovery = createEmptyDiscoveryResult();
+
+                const decision = resolver.resolveBucket(appDefinition, discovery);
+
+                expect(decision.ownership).toBe(ResourceOwnership.STACK);
+                expect(decision.physicalId).toBeNull();
+                expect(decision.reason).toContain('No existing migration bucket - will create in stack');
+            });
+        });
+
+        describe('Default behavior (no ownership specified)', () => {
+            it('should default to auto resolution', () => {
+                const appDefinition = {};
+                const discovery = createEmptyDiscoveryResult();
+
+                const decision = resolver.resolveBucket(appDefinition, discovery);
+
+                expect(decision.ownership).toBe(ResourceOwnership.STACK);
+                expect(decision.reason).toContain('No existing migration bucket - will create in stack');
+            });
+        });
+    });
+
+    describe('resolveQueue', () => {
+        describe('Explicit ownership intent', () => {
+            it('should respect ownership.queue=stack when specified', () => {
+                const appDefinition = {
+                    migration: {
+                        ownership: { queue: 'stack' }
+                    }
+                };
+                const discovery = createEmptyDiscoveryResult();
+
+                const decision = resolver.resolveQueue(appDefinition, discovery);
+
+                expect(decision.ownership).toBe(ResourceOwnership.STACK);
+                expect(decision.physicalId).toBeNull();
+                expect(decision.reason).toContain('Will create DbMigrationQueue in stack');
+            });
+
+            it('should respect ownership.queue=external when queue discovered', () => {
+                const appDefinition = {
+                    migration: {
+                        ownership: { queue: 'external' }
+                    }
+                };
+                const discovery = createEmptyDiscoveryResult();
+                discovery.external.push({
+                    physicalId: 'https://sqs.us-east-1.amazonaws.com/123456789/my-migration-queue',
+                    resourceType: 'AWS::SQS::Queue',
+                    source: 'aws-discovery'
+                });
+
+                const decision = resolver.resolveQueue(appDefinition, discovery);
+
+                expect(decision.ownership).toBe(ResourceOwnership.EXTERNAL);
+                expect(decision.physicalId).toBe('https://sqs.us-east-1.amazonaws.com/123456789/my-migration-queue');
+                expect(decision.reason).toContain('external');
+            });
+
+            it('should error when ownership.queue=external but no queue discovered', () => {
+                const appDefinition = {
+                    migration: {
+                        ownership: { queue: 'external' }
+                    }
+                };
+                const discovery = createEmptyDiscoveryResult();
+
+                expect(() => resolver.resolveQueue(appDefinition, discovery))
+                    .toThrow('ownership.queue=external but no SQS queue discovered');
+            });
+        });
+
+        describe('Auto resolution (ownership.queue=auto)', () => {
+            it('should use stack queue when found in CloudFormation', () => {
+                const appDefinition = {
+                    migration: {
+                        ownership: { queue: 'auto' }
+                    }
+                };
+                const discovery = createEmptyDiscoveryResult();
+                discovery.fromCloudFormation = true;
+                discovery.stackManaged.push({
+                    logicalId: 'DbMigrationQueue',
+                    physicalId: 'https://sqs.us-east-1.amazonaws.com/123456789/stack-migration-queue',
+                    resourceType: 'AWS::SQS::Queue'
+                });
+
+                const decision = resolver.resolveQueue(appDefinition, discovery);
+
+                expect(decision.ownership).toBe(ResourceOwnership.STACK);
+                expect(decision.physicalId).toBe('https://sqs.us-east-1.amazonaws.com/123456789/stack-migration-queue');
+                expect(decision.reason).toContain('Found DbMigrationQueue in CloudFormation stack');
+            });
+
+            it('should use external queue when found via discovery', () => {
+                const appDefinition = {
+                    migration: {
+                        ownership: { queue: 'auto' }
+                    }
+                };
+                const discovery = createEmptyDiscoveryResult();
+                discovery.external.push({
+                    physicalId: 'https://sqs.us-east-1.amazonaws.com/123456789/external-migration-queue',
+                    resourceType: 'AWS::SQS::Queue',
+                    source: 'aws-discovery'
+                });
+
+                const decision = resolver.resolveQueue(appDefinition, discovery);
+
+                expect(decision.ownership).toBe(ResourceOwnership.EXTERNAL);
+                expect(decision.physicalId).toBe('https://sqs.us-east-1.amazonaws.com/123456789/external-migration-queue');
+                expect(decision.reason).toContain('Found external SQS queue via discovery');
+            });
+
+            it('should create new queue when none found', () => {
+                const appDefinition = {
+                    migration: {
+                        ownership: { queue: 'auto' }
+                    }
+                };
+                const discovery = createEmptyDiscoveryResult();
+
+                const decision = resolver.resolveQueue(appDefinition, discovery);
+
+                expect(decision.ownership).toBe(ResourceOwnership.STACK);
+                expect(decision.physicalId).toBeNull();
+                expect(decision.reason).toContain('No existing migration queue - will create in stack');
+            });
+        });
+    });
+
+    describe('resolveAll', () => {
+        it('should return decisions for all migration resources', () => {
+            const appDefinition = {
+                database: {
+                    postgres: {
+                        enable: true
+                    }
+                }
+            };
+            const discovery = createEmptyDiscoveryResult();
+
+            const decisions = resolver.resolveAll(appDefinition, discovery);
+
+            expect(decisions).toHaveProperty('bucket');
+            expect(decisions).toHaveProperty('queue');
+            expect(decisions.bucket.ownership).toBe(ResourceOwnership.STACK);
+            expect(decisions.queue.ownership).toBe(ResourceOwnership.STACK);
+        });
+    });
+
+    describe('Real-world scenarios', () => {
+        it('should handle managementMode=managed scenario (create resources)', () => {
+            // In managed mode, we want to create resources in stack
+            const appDefinition = {
+                managementMode: 'managed',
+                migration: {
+                    ownership: { bucket: 'stack', queue: 'stack' }
+                }
+            };
+            const discovery = createEmptyDiscoveryResult();
+
+            const decisions = resolver.resolveAll(appDefinition, discovery);
+
+            expect(decisions.bucket.ownership).toBe(ResourceOwnership.STACK);
+            expect(decisions.bucket.physicalId).toBeNull();
+            expect(decisions.queue.ownership).toBe(ResourceOwnership.STACK);
+            expect(decisions.queue.physicalId).toBeNull();
+        });
+
+        it('should handle existing stack resources (reuse)', () => {
+            // Stack already has migration resources from previous deployment
+            const appDefinition = {
+                migration: {
+                    ownership: { bucket: 'auto', queue: 'auto' }
+                }
+            };
+            const discovery = createEmptyDiscoveryResult();
+            discovery.fromCloudFormation = true;
+            discovery.stackManaged.push({
+                logicalId: 'FriggMigrationStatusBucket',
+                physicalId: 'my-stack-bucket',
+                resourceType: 'AWS::S3::Bucket'
+            });
+            discovery.stackManaged.push({
+                logicalId: 'DbMigrationQueue',
+                physicalId: 'https://sqs.us-east-1.amazonaws.com/123/my-queue',
+                resourceType: 'AWS::SQS::Queue'
+            });
+
+            const decisions = resolver.resolveAll(appDefinition, discovery);
+
+            expect(decisions.bucket.ownership).toBe(ResourceOwnership.STACK);
+            expect(decisions.bucket.physicalId).toBe('my-stack-bucket');
+            expect(decisions.queue.ownership).toBe(ResourceOwnership.STACK);
+            expect(decisions.queue.physicalId).toBe('https://sqs.us-east-1.amazonaws.com/123/my-queue');
+        });
+
+        it('should handle shared migration resources scenario', () => {
+            // Using shared infrastructure migration resources
+            const appDefinition = {
+                managementMode: 'managed',
+                vpcIsolation: 'shared',
+                migration: {
+                    ownership: { bucket: 'auto', queue: 'auto' }
+                }
+            };
+            const discovery = createEmptyDiscoveryResult();
+            discovery.external.push({
+                physicalId: 'shared-migration-bucket',
+                resourceType: 'AWS::S3::Bucket',
+                source: 'aws-discovery'
+            });
+            discovery.external.push({
+                physicalId: 'https://sqs.us-east-1.amazonaws.com/123/shared-queue',
+                resourceType: 'AWS::SQS::Queue',
+                source: 'aws-discovery'
+            });
+
+            const decisions = resolver.resolveAll(appDefinition, discovery);
+
+            expect(decisions.bucket.ownership).toBe(ResourceOwnership.EXTERNAL);
+            expect(decisions.bucket.physicalId).toBe('shared-migration-bucket');
+            expect(decisions.queue.ownership).toBe(ResourceOwnership.EXTERNAL);
+            expect(decisions.queue.physicalId).toBe('https://sqs.us-east-1.amazonaws.com/123/shared-queue');
+        });
+    });
+});