@friggframework/core 2.0.0--canary.461.a0527a3.0 → 2.0.0--canary.461.4b9ba0b.0

package/database/config.js

@@ -18,7 +18,7 @@ function getDatabaseType() {
     if (process.env.DB_TYPE) {
         return process.env.DB_TYPE;
     }
-    
+
     // Fallback: Load app definition
     try {
         const path = require('node:path');

package/database/repositories/migration-status-repository-s3.js

@@ -0,0 +1,137 @@
+/**
+ * Migration Status Repository - S3 Storage
+ * 
+ * Infrastructure Layer - Hexagonal Architecture
+ * 
+ * Stores migration status in S3 to avoid chicken-and-egg dependency on User/Process tables.
+ * Initial database migrations can't use Process table (requires User FK which doesn't exist yet).
+ */
+
+const { S3Client, PutObjectCommand, GetObjectCommand } = require('@aws-sdk/client-s3');
+const { randomUUID } = require('crypto');
+
+class MigrationStatusRepositoryS3 {
+    /**
+     * @param {string} bucketName - S3 bucket name for migration status storage
+     * @param {S3Client} s3Client - Optional S3 client (for testing)
+     */
+    constructor(bucketName, s3Client = null) {
+        this.bucketName = bucketName;
+        this.s3Client = s3Client || new S3Client({ region: process.env.AWS_REGION || 'us-east-1' });
+    }
+
+    /**
+     * Build S3 key for migration status
+     * @param {string} migrationId - Migration identifier
+     * @param {string} stage - Deployment stage
+     * @returns {string} S3 key
+     */
+    _buildS3Key(migrationId, stage) {
+        return `migrations/${stage}/${migrationId}.json`;
+    }
+
+    /**
+     * Create new migration status record
+     * @param {Object} data - Migration data
+     * @param {string} [data.migrationId] - Migration ID (generates UUID if not provided)
+     * @param {string} data.stage - Deployment stage
+     * @param {string} [data.triggeredBy] - User or system that triggered migration
+     * @param {string} [data.triggeredAt] - ISO timestamp
+     * @returns {Promise<Object>} Created migration status
+     */
+    async create(data) {
+        const migrationId = data.migrationId || randomUUID();
+        const timestamp = data.triggeredAt || new Date().toISOString();
+
+        const status = {
+            migrationId,
+            stage: data.stage,
+            state: 'INITIALIZING',
+            progress: 0,
+            triggeredBy: data.triggeredBy || 'system',
+            triggeredAt: timestamp,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+
+        const key = this._buildS3Key(migrationId, data.stage);
+
+        await this.s3Client.send(
+            new PutObjectCommand({
+                Bucket: this.bucketName,
+                Key: key,
+                Body: JSON.stringify(status, null, 2),
+                ContentType: 'application/json',
+            })
+        );
+
+        return status;
+    }
+
+    /**
+     * Update existing migration status
+     * @param {Object} data - Update data
+     * @param {string} data.migrationId - Migration ID
+     * @param {string} data.stage - Deployment stage
+     * @param {string} [data.state] - New state
+     * @param {number} [data.progress] - Progress percentage (0-100)
+     * @param {string} [data.error] - Error message if failed
+     * @param {string} [data.completedAt] - Completion timestamp
+     * @returns {Promise<Object>} Updated migration status
+     */
+    async update(data) {
+        const key = this._buildS3Key(data.migrationId, data.stage);
+
+        // Get existing status
+        const existing = await this.get(data.migrationId, data.stage);
+
+        // Merge updates
+        const updated = {
+            ...existing,
+            ...data,
+            updatedAt: new Date().toISOString(),
+        };
+
+        await this.s3Client.send(
+            new PutObjectCommand({
+                Bucket: this.bucketName,
+                Key: key,
+                Body: JSON.stringify(updated, null, 2),
+                ContentType: 'application/json',
+            })
+        );
+
+        return updated;
+    }
+
+    /**
+     * Get migration status by ID
+     * @param {string} migrationId - Migration ID
+     * @param {string} stage - Deployment stage
+     * @returns {Promise<Object>} Migration status
+     * @throws {Error} If migration not found
+     */
+    async get(migrationId, stage) {
+        const key = this._buildS3Key(migrationId, stage);
+
+        try {
+            const response = await this.s3Client.send(
+                new GetObjectCommand({
+                    Bucket: this.bucketName,
+                    Key: key,
+                })
+            );
+
+            const body = await response.Body.transformToString();
+            return JSON.parse(body);
+        } catch (error) {
+            if (error.name === 'NoSuchKey') {
+                throw new Error(`Migration not found: ${migrationId}`);
+            }
+            throw error;
+        }
+    }
+}
+
+module.exports = { MigrationStatusRepositoryS3 };
+

package/database/repositories/migration-status-repository-s3.test.js

@@ -0,0 +1,158 @@
+/**
+ * Tests for Migration Status Repository (S3)
+ * 
+ * Tests S3-based storage for migration status tracking
+ * (avoids chicken-and-egg dependency on User/Process tables)
+ */
+
+const { MigrationStatusRepositoryS3 } = require('./migration-status-repository-s3');
+
+describe('MigrationStatusRepositoryS3', () => {
+    let repository;
+    let mockS3Client;
+
+    beforeEach(() => {
+        mockS3Client = {
+            send: jest.fn(),
+        };
+        repository = new MigrationStatusRepositoryS3('test-bucket', mockS3Client);
+    });
+
+    describe('create()', () => {
+        it('should create new migration status record in S3', async () => {
+            const migrationData = {
+                migrationId: 'migration-123',
+                stage: 'dev',
+                triggeredBy: 'admin',
+                triggeredAt: '2025-10-19T12:00:00Z',
+            };
+
+            mockS3Client.send.mockResolvedValue({});
+
+            const result = await repository.create(migrationData);
+
+            expect(result.migrationId).toBe('migration-123');
+            expect(result.state).toBe('INITIALIZING');
+            expect(mockS3Client.send).toHaveBeenCalled();
+        });
+
+        it('should generate UUID if migrationId not provided', async () => {
+            const migrationData = {
+                stage: 'dev',
+                triggeredBy: 'admin',
+                triggeredAt: '2025-10-19T12:00:00Z',
+            };
+
+            mockS3Client.send.mockResolvedValue({});
+
+            const result = await repository.create(migrationData);
+
+            expect(result.migrationId).toMatch(/^[a-f0-9-]{36}$/); // UUID format
+            expect(result.state).toBe('INITIALIZING');
+        });
+
+        it('should store status at correct S3 key', async () => {
+            const migrationData = {
+                migrationId: 'migration-123',
+                stage: 'dev',
+            };
+
+            mockS3Client.send.mockResolvedValue({});
+
+            await repository.create(migrationData);
+
+            const putCommand = mockS3Client.send.mock.calls[0][0];
+            expect(putCommand.input.Bucket).toBe('test-bucket');
+            expect(putCommand.input.Key).toBe('migrations/dev/migration-123.json');
+        });
+    });
+
+    describe('update()', () => {
+        it('should update existing migration status', async () => {
+            mockS3Client.send.mockResolvedValue({
+                Body: {
+                    transformToString: () => JSON.stringify({
+                        migrationId: 'migration-123',
+                        state: 'INITIALIZING',
+                        progress: 0,
+                    }),
+                },
+            });
+
+            const updateData = {
+                migrationId: 'migration-123',
+                stage: 'dev',
+                state: 'RUNNING',
+                progress: 50,
+            };
+
+            await repository.update(updateData);
+
+            expect(mockS3Client.send).toHaveBeenCalledTimes(2); // GET then PUT
+        });
+
+        it('should merge updates with existing data', async () => {
+            mockS3Client.send
+                .mockResolvedValueOnce({
+                    Body: {
+                        transformToString: () => JSON.stringify({
+                            migrationId: 'migration-123',
+                            state: 'INITIALIZING',
+                            progress: 0,
+                            triggeredAt: '2025-10-19T12:00:00Z',
+                        }),
+                    },
+                })
+                .mockResolvedValueOnce({});
+
+            await repository.update({
+                migrationId: 'migration-123',
+                stage: 'dev',
+                state: 'COMPLETED',
+                progress: 100,
+            });
+
+            const putCommand = mockS3Client.send.mock.calls[1][0];
+            const storedData = JSON.parse(putCommand.input.Body);
+            expect(storedData.triggeredAt).toBe('2025-10-19T12:00:00Z'); // Preserved
+            expect(storedData.state).toBe('COMPLETED'); // Updated
+        });
+    });
+
+    describe('get()', () => {
+        it('should retrieve migration status from S3', async () => {
+            const statusData = {
+                migrationId: 'migration-123',
+                state: 'COMPLETED',
+                progress: 100,
+            };
+
+            mockS3Client.send.mockResolvedValue({
+                Body: {
+                    transformToString: () => JSON.stringify(statusData),
+                },
+            });
+
+            const result = await repository.get('migration-123', 'dev');
+
+            expect(result).toEqual(statusData);
+            expect(mockS3Client.send).toHaveBeenCalled();
+        });
+
+        it('should throw error if migration not found', async () => {
+            mockS3Client.send.mockRejectedValue({ name: 'NoSuchKey' });
+
+            await expect(repository.get('nonexistent', 'dev')).rejects.toThrow(
+                'Migration not found'
+            );
+        });
+    });
+
+    describe('S3 Key Generation', () => {
+        it('should use consistent key format', () => {
+            const key = repository._buildS3Key('migration-123', 'production');
+            expect(key).toBe('migrations/production/migration-123.json');
+        });
+    });
+});
+

package/database/use-cases/get-migration-status-use-case.js

@@ -13,58 +13,54 @@
 class GetMigrationStatusUseCase {
     /**
      * @param {Object} dependencies
-     * @param {Object} dependencies.processRepository - Repository for process data access
+     * @param {Object} dependencies.migrationStatusRepository - Repository for migration status (S3)
      */
-    constructor({ processRepository }) {
-        if (!processRepository) {
-            throw new Error('processRepository dependency is required');
+    constructor({ migrationStatusRepository }) {
+        if (!migrationStatusRepository) {
+            throw new Error('migrationStatusRepository dependency is required');
         }
-        this.processRepository = processRepository;
+        this.migrationStatusRepository = migrationStatusRepository;
     }
 
     /**
      * Execute get migration status
      *
-     * @param {Object} params
-     * @param {string} params.processId - Process ID to retrieve
-     * @returns {Promise<Object>} Migration status with process details
-     * @throws {NotFoundError} If process not found
-     * @throws {Error} If process is not a migration process
+     * @param {string} migrationId - Migration ID to retrieve
+     * @param {string} [stage] - Deployment stage (defaults to env.STAGE)
+     * @returns {Promise<Object>} Migration status from S3
+     * @throws {NotFoundError} If migration not found
+     * @throws {ValidationError} If migrationId is invalid
      */
-    async execute({ processId }) {
+    async execute(migrationId, stage = null) {
         // Validation
-        if (!processId) {
-            throw new ValidationError('processId is required');
-        }
-
-        if (typeof processId !== 'string') {
-            throw new ValidationError('processId must be a string');
-        }
+        this._validateParams(migrationId);
 
-        // Get process from repository
-        const process = await this.processRepository.findById(processId);
+        const effectiveStage = stage || process.env.STAGE || 'production';
 
-        if (!process) {
-            throw new NotFoundError(`Migration process not found: ${processId}`);
+        // Get migration status from S3
+        try {
+            const migrationStatus = await this.migrationStatusRepository.get(migrationId, effectiveStage);
+            return migrationStatus;
+        } catch (error) {
+            if (error.message.includes('not found')) {
+                throw new NotFoundError(`Migration not found: ${migrationId}`);
+            }
+            throw error;
         }
+    }
 
-        // Verify this is a migration process
-        if (process.type !== 'DATABASE_MIGRATION') {
-            throw new Error(
-                `Process ${processId} is not a migration process (type: ${process.type})`
-            );
+    /**
+     * Validate parameters
+     * @private
+     */
+    _validateParams(migrationId) {
+        if (!migrationId) {
+            throw new ValidationError('migrationId is required');
         }
 
-        // Format response
-        return {
-            processId: process.id,
-            type: process.type,
-            state: process.state,
-            context: process.context || {},
-            results: process.results || {},
-            createdAt: process.createdAt,
-            updatedAt: process.updatedAt,
-        };
+        if (typeof migrationId !== 'string') {
+            throw new ValidationError('migrationId must be a string');
+        }
     }
 }
 

package/database/use-cases/get-migration-status-use-case.test.js

@@ -10,17 +10,17 @@ const {
 
 describe('GetMigrationStatusUseCase', () => {
     let useCase;
-    let mockProcessRepository;
+    let mockMigrationStatusRepository;
 
     beforeEach(() => {
         // Create mock repository
-        mockProcessRepository = {
-            findById: jest.fn(),
+        mockMigrationStatusRepository = {
+            get: jest.fn(),
         };
 
         // Create use case with mock
         useCase = new GetMigrationStatusUseCase({
-            processRepository: mockProcessRepository,
+            migrationStatusRepository: mockMigrationStatusRepository,
         });
     });
 
@@ -29,10 +29,10 @@ describe('GetMigrationStatusUseCase', () => {
     });
 
     describe('constructor', () => {
-        it('should throw error if processRepository not provided', () => {
+        it('should throw error if migrationStatusRepository not provided', () => {
             expect(() => {
                 new GetMigrationStatusUseCase({});
-            }).toThrow('processRepository dependency is required');
+            }).toThrow('migrationStatusRepository dependency is required');
         });
     });
 
@@ -56,25 +56,17 @@ describe('GetMigrationStatusUseCase', () => {
                 updatedAt: new Date('2025-10-18T10:30:02Z'),
             };
 
-            mockProcessRepository.findById.mockResolvedValue(mockProcess);
+            mockMigrationStatusRepository.get.mockResolvedValue(mockProcess);
 
-            const result = await useCase.execute({ processId: 'process-123' });
+            const result = await useCase.execute('migration-123', 'production');
 
-            expect(mockProcessRepository.findById).toHaveBeenCalledWith('process-123');
-            expect(result).toEqual({
-                processId: 'process-123',
-                type: 'DATABASE_MIGRATION',
-                state: 'COMPLETED',
-                context: mockProcess.context,
-                results: mockProcess.results,
-                createdAt: mockProcess.createdAt,
-                updatedAt: mockProcess.updatedAt,
-            });
+            expect(mockMigrationStatusRepository.get).toHaveBeenCalledWith('migration-123', 'production');
+            expect(result).toEqual(mockProcess); // S3 repository returns full status object
         });
 
-        it('should return migration status for RUNNING process', async () => {
+        it('should return migration status for RUNNING migration', async () => {
             const mockProcess = {
-                id: 'process-456',
+                migrationId: 'migration-456',
                 type: 'DATABASE_MIGRATION',
                 state: 'RUNNING',
                 context: {
@@ -87,109 +79,73 @@ describe('GetMigrationStatusUseCase', () => {
                 updatedAt: new Date('2025-10-18T10:30:00Z'),
             };
 
-            mockProcessRepository.findById.mockResolvedValue(mockProcess);
+            mockMigrationStatusRepository.get.mockResolvedValue(mockProcess);
 
-            const result = await useCase.execute({ processId: 'process-456' });
+            const result = await useCase.execute('migration-456', 'dev');
 
             expect(result.state).toBe('RUNNING');
             expect(result.context.dbType).toBe('mongodb');
         });
 
-        it('should return migration status for FAILED process', async () => {
-            const mockProcess = {
-                id: 'process-789',
-                type: 'DATABASE_MIGRATION',
+        it('should return migration status for FAILED migration', async () => {
+            const mockStatus = {
+                migrationId: 'migration-789',
+                stage: 'production',
                 state: 'FAILED',
-                context: {
-                    dbType: 'postgresql',
-                    stage: 'production',
-                    failedAt: '2025-10-18T10:30:00Z',
-                },
-                results: {
-                    error: 'Migration failed: syntax error',
-                    errorType: 'MigrationError',
-                },
-                createdAt: new Date('2025-10-18T10:29:55Z'),
-                updatedAt: new Date('2025-10-18T10:30:00Z'),
+                progress: 0,
+                error: 'Migration failed: syntax error',
+                triggeredBy: 'admin',
+                triggeredAt: '2025-10-18T10:29:55Z',
+                completedAt: '2025-10-18T10:30:00Z',
             };
 
-            mockProcessRepository.findById.mockResolvedValue(mockProcess);
+            mockMigrationStatusRepository.get.mockResolvedValue(mockStatus);
 
-            const result = await useCase.execute({ processId: 'process-789' });
+            const result = await useCase.execute('migration-789', 'production');
 
+            expect(mockMigrationStatusRepository.get).toHaveBeenCalledWith('migration-789', 'production');
             expect(result.state).toBe('FAILED');
-            expect(result.results.error).toContain('Migration failed');
+            expect(result.error).toContain('Migration failed');
         });
 
-        it('should handle empty context and results', async () => {
-            const mockProcess = {
-                id: 'process-999',
-                type: 'DATABASE_MIGRATION',
-                state: 'INITIALIZING',
-                createdAt: new Date(),
-                updatedAt: new Date(),
-            };
-
-            mockProcessRepository.findById.mockResolvedValue(mockProcess);
+        // Removed - already covered by "should return minimal migration status"
 
-            const result = await useCase.execute({ processId: 'process-999' });
-
-            expect(result.context).toEqual({});
-            expect(result.results).toEqual({});
-        });
-
-        it('should throw NotFoundError if process does not exist', async () => {
-            mockProcessRepository.findById.mockResolvedValue(null);
+        it('should throw NotFoundError if migration does not exist', async () => {
+            mockMigrationStatusRepository.get.mockRejectedValue(new Error('Migration not found: nonexistent-123'));
 
             await expect(
-                useCase.execute({ processId: 'nonexistent-123' })
+                useCase.execute('nonexistent-123', 'dev')
             ).rejects.toThrow(NotFoundError);
 
             await expect(
-                useCase.execute({ processId: 'nonexistent-123' })
-            ).rejects.toThrow('Migration process not found: nonexistent-123');
+                useCase.execute('nonexistent-123', 'dev')
+            ).rejects.toThrow('Migration not found');
         });
 
-        it('should throw error if process is not a migration process', async () => {
-            const nonMigrationProcess = {
-                id: 'process-999',
-                type: 'CRM_SYNC', // Not a migration
-                state: 'RUNNING',
-                context: {},
-                results: {},
-                createdAt: new Date(),
-                updatedAt: new Date(),
-            };
-
-            mockProcessRepository.findById.mockResolvedValue(nonMigrationProcess);
-
-            await expect(
-                useCase.execute({ processId: 'process-999' })
-            ).rejects.toThrow('Process process-999 is not a migration process (type: CRM_SYNC)');
-        });
+        // Removed: S3 repository only stores migrations, no type validation needed
 
-        it('should throw ValidationError if processId is missing', async () => {
+        it('should throw ValidationError if migrationId is missing', async () => {
             await expect(
-                useCase.execute({})
+                useCase.execute(null)
             ).rejects.toThrow(ValidationError);
 
             await expect(
-                useCase.execute({})
-            ).rejects.toThrow('processId is required');
+                useCase.execute(undefined)
+            ).rejects.toThrow('migrationId is required');
         });
 
-        it('should throw ValidationError if processId is not a string', async () => {
+        it('should throw ValidationError if migrationId is not a string', async () => {
             await expect(
-                useCase.execute({ processId: 123 })
-            ).rejects.toThrow('processId must be a string');
+                useCase.execute(123)
+            ).rejects.toThrow('migrationId must be a string');
         });
 
         it('should handle repository errors', async () => {
-            mockProcessRepository.findById.mockRejectedValue(new Error('Database connection failed'));
+            mockMigrationStatusRepository.get.mockRejectedValue(new Error('S3 connection failed'));
 
             await expect(
-                useCase.execute({ processId: 'process-123' })
-            ).rejects.toThrow('Database connection failed');
+                useCase.execute('migration-123', 'dev')
+            ).rejects.toThrow('S3 connection failed');
         });
     });
 

package/database/use-cases/trigger-database-migration-use-case.js

@@ -22,14 +22,14 @@ const { QueuerUtil } = require('../../queues/queuer-util');
 class TriggerDatabaseMigrationUseCase {
     /**
      * @param {Object} dependencies
-     * @param {Object} dependencies.processRepository - Repository for process data access
+     * @param {Object} dependencies.migrationStatusRepository - Repository for migration status (S3)
      * @param {Object} [dependencies.queuerUtil] - SQS utility (injectable for testing)
      */
-    constructor({ processRepository, queuerUtil = QueuerUtil }) {
-        if (!processRepository) {
-            throw new Error('processRepository dependency is required');
+    constructor({ migrationStatusRepository, queuerUtil = QueuerUtil }) {
+        if (!migrationStatusRepository) {
+            throw new Error('migrationStatusRepository dependency is required');
         }
-        this.processRepository = processRepository;
+        this.migrationStatusRepository = migrationStatusRepository;
         this.queuerUtil = queuerUtil;
     }
 
@@ -48,22 +48,14 @@ class TriggerDatabaseMigrationUseCase {
         // Validation
         this._validateParams({ userId, dbType, stage });
 
-        // Create Process record for tracking
-        const migrationProcess = await this.processRepository.create({
-            userId,
-            integrationId: null, // System operation, not tied to integration
-            name: 'database-migration',
-            type: 'DATABASE_MIGRATION',
-            state: 'INITIALIZING',
-            context: {
-                dbType,
-                stage,
-                triggeredAt: new Date().toISOString(),
-            },
-            results: {},
+        // Create migration status in S3 (no User table dependency)
+        const migrationStatus = await this.migrationStatusRepository.create({
+            stage: stage || process.env.STAGE || 'production',
+            triggeredBy: userId || 'system',
+            triggeredAt: new Date().toISOString(),
         });
 
-        console.log(`Created migration process: ${migrationProcess.id}`);
+        console.log(`Created migration status: ${migrationStatus.migrationId}`);
 
         // Get queue URL from environment
         const queueUrl = process.env.DB_MIGRATION_QUEUE_URL;
@@ -78,38 +70,37 @@ class TriggerDatabaseMigrationUseCase {
         try {
             await this.queuerUtil.send(
                 {
-                    processId: migrationProcess.id,
+                    migrationId: migrationStatus.migrationId,
                     dbType,
                     stage,
                 },
                 queueUrl
             );
 
-            console.log(`Sent migration job to queue for process: ${migrationProcess.id}`);
+            console.log(`Sent migration job to queue: ${migrationStatus.migrationId}`);
         } catch (error) {
             console.error(`Failed to send migration to queue:`, error);
 
-            // Update process state to FAILED
-            await this.processRepository.updateState(
-                migrationProcess.id,
-                'FAILED',
-                {
-                    error: 'Failed to queue migration job',
-                    errorDetails: error.message,
-                }
-            );
+            // Update migration status to FAILED
+            await this.migrationStatusRepository.update({
+                migrationId: migrationStatus.migrationId,
+                stage: migrationStatus.stage,
+                state: 'FAILED',
+                error: `Failed to queue migration: ${error.message}`,
+            });
 
             throw new Error(
                 `Failed to queue migration: ${error.message}`
             );
         }
 
-        // Return process info immediately (don't wait for migration completion)
+        // Return migration info immediately (don't wait for migration completion)
         return {
             success: true,
-            processId: migrationProcess.id,
-            state: migrationProcess.state,
-            statusUrl: `/db-migrate/${migrationProcess.id}`,
+            migrationId: migrationStatus.migrationId,
+            state: migrationStatus.state,
+            statusUrl: `/db-migrate/${migrationStatus.migrationId}`,
+            s3Key: `migrations/${migrationStatus.stage}/${migrationStatus.migrationId}.json`,
             message: 'Database migration queued successfully',
         };
     }
@@ -119,11 +110,8 @@ class TriggerDatabaseMigrationUseCase {
      * @private
      */
     _validateParams({ userId, dbType, stage }) {
-        if (!userId) {
-            throw new ValidationError('userId is required');
-        }
-
-        if (typeof userId !== 'string') {
+        // userId is optional for system migrations
+        if (userId && typeof userId !== 'string') {
             throw new ValidationError('userId must be a string');
         }
 

package/database/use-cases/trigger-database-migration-use-case.test.js

@@ -9,7 +9,7 @@ const {
 
 describe('TriggerDatabaseMigrationUseCase', () => {
     let useCase;
-    let mockProcessRepository;
+    let mockMigrationStatusRepository;
     let mockQueuerUtil;
     let originalEnv;
 
@@ -21,23 +21,18 @@ describe('TriggerDatabaseMigrationUseCase', () => {
         process.env.DB_MIGRATION_QUEUE_URL = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
 
         // Create mock repository
-        mockProcessRepository = {
+        mockMigrationStatusRepository = {
             create: jest.fn().mockResolvedValue({
-                id: 'process-123',
-                userId: 'user-456',
-                integrationId: null,
-                name: 'database-migration',
-                type: 'DATABASE_MIGRATION',
+                migrationId: 'migration-123',
+                stage: 'production',
                 state: 'INITIALIZING',
-                context: {
-                    dbType: 'postgresql',
-                    stage: 'production',
-                },
-                results: {},
-                createdAt: new Date(),
-                updatedAt: new Date(),
+                progress: 0,
+                triggeredBy: 'user-456',
+                triggeredAt: new Date().toISOString(),
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
             }),
-            updateState: jest.fn().mockResolvedValue(true),
+            update: jest.fn().mockResolvedValue(true),
         };
 
         // Create mock queuer util
@@ -47,7 +42,7 @@ describe('TriggerDatabaseMigrationUseCase', () => {
 
         // Create use case with mocks
         useCase = new TriggerDatabaseMigrationUseCase({
-            processRepository: mockProcessRepository,
+            migrationStatusRepository: mockMigrationStatusRepository,
             queuerUtil: mockQueuerUtil,
         });
     });
@@ -63,16 +58,16 @@ describe('TriggerDatabaseMigrationUseCase', () => {
     });
 
     describe('constructor', () => {
-        it('should throw error if processRepository not provided', () => {
+        it('should throw error if migrationStatusRepository not provided', () => {
             expect(() => {
                 new TriggerDatabaseMigrationUseCase({});
-            }).toThrow('processRepository dependency is required');
+            }).toThrow('migrationStatusRepository dependency is required');
         });
 
         it('should accept custom queuerUtil', () => {
             const customQueuer = { send: jest.fn() };
             const instance = new TriggerDatabaseMigrationUseCase({
-                processRepository: mockProcessRepository,
+                migrationStatusRepository: mockMigrationStatusRepository,
                 queuerUtil: customQueuer,
             });
 
@@ -88,24 +83,17 @@ describe('TriggerDatabaseMigrationUseCase', () => {
                 stage: 'production',
             });
 
-            // Verify process creation
-            expect(mockProcessRepository.create).toHaveBeenCalledWith({
-                userId: 'user-456',
-                integrationId: null,
-                name: 'database-migration',
-                type: 'DATABASE_MIGRATION',
-                state: 'INITIALIZING',
-                context: expect.objectContaining({
-                    dbType: 'postgresql',
-                    stage: 'production',
-                }),
-                results: {},
+            // Verify migration status creation (S3 repository interface)
+            expect(mockMigrationStatusRepository.create).toHaveBeenCalledWith({
+                stage: 'production',
+                triggeredBy: 'user-456',
+                triggeredAt: expect.any(String),
             });
 
             // Verify SQS message sent
             expect(mockQueuerUtil.send).toHaveBeenCalledWith(
                 {
-                    processId: 'process-123',
+                    migrationId: 'migration-123',
                     dbType: 'postgresql',
                     stage: 'production',
                 },
@@ -115,9 +103,10 @@ describe('TriggerDatabaseMigrationUseCase', () => {
             // Verify response
             expect(result).toEqual({
                 success: true,
-                processId: 'process-123',
+                migrationId: 'migration-123',
                 state: 'INITIALIZING',
-                statusUrl: '/db-migrate/process-123',
+                statusUrl: '/db-migrate/migration-123',
+                s3Key: expect.stringContaining('migrations/'),
                 message: 'Database migration queued successfully',
             });
         });
@@ -129,30 +118,27 @@ describe('TriggerDatabaseMigrationUseCase', () => {
                 stage: 'dev',
             });
 
-            expect(mockProcessRepository.create).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    context: expect.objectContaining({
-                        dbType: 'mongodb',
-                        stage: 'dev',
-                    }),
-                })
-            );
+            expect(mockMigrationStatusRepository.create).toHaveBeenCalledWith({
+                stage: 'dev',
+                triggeredBy: 'user-456',
+                triggeredAt: expect.any(String),
+            });
         });
 
-        it('should throw ValidationError if userId is missing', async () => {
-            await expect(
-                useCase.execute({
-                    dbType: 'postgresql',
-                    stage: 'production',
-                })
-            ).rejects.toThrow(ValidationError);
+        it('should allow userId to be omitted (system migrations)', async () => {
+            const result = await useCase.execute({
+                dbType: 'postgresql',
+                stage: 'production',
+            });
 
-            await expect(
-                useCase.execute({
-                    dbType: 'postgresql',
-                    stage: 'production',
-                })
-            ).rejects.toThrow('userId is required');
+            // Should use 'system' as triggeredBy when userId not provided
+            expect(mockMigrationStatusRepository.create).toHaveBeenCalledWith({
+                stage: 'production',
+                triggeredBy: 'system',
+                triggeredAt: expect.any(String),
+            });
+
+            expect(result.success).toBe(true);
         });
 
         it('should throw ValidationError if userId is not a string', async () => {
@@ -226,19 +212,18 @@ describe('TriggerDatabaseMigrationUseCase', () => {
                 })
             ).rejects.toThrow('Failed to queue migration: SQS unavailable');
 
-            // Verify process was marked as failed
-            expect(mockProcessRepository.updateState).toHaveBeenCalledWith(
-                'process-123',
-                'FAILED',
-                {
-                    error: 'Failed to queue migration job',
-                    errorDetails: 'SQS unavailable',
-                }
+            // Verify migration status was marked as failed
+            expect(mockMigrationStatusRepository.update).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    migrationId: 'migration-123',
+                    state: 'FAILED',
+                    error: expect.stringContaining('Failed to queue migration'),
+                })
             );
         });
 
-        it('should handle process creation failure', async () => {
-            mockProcessRepository.create.mockRejectedValue(new Error('Database error'));
+        it('should handle migration status creation failure', async () => {
+            mockMigrationStatusRepository.create.mockRejectedValue(new Error('S3 error'));
 
             await expect(
                 useCase.execute({
@@ -246,7 +231,7 @@ describe('TriggerDatabaseMigrationUseCase', () => {
                     dbType: 'postgresql',
                     stage: 'production',
                 })
-            ).rejects.toThrow('Database error');
+            ).rejects.toThrow('S3 error');
 
             // Should not attempt to send to queue if process creation fails
             expect(mockQueuerUtil.send).not.toHaveBeenCalled();

package/handlers/routers/db-migration.js

@@ -17,7 +17,7 @@
 
 const { Router } = require('express');
 const catchAsyncError = require('express-async-handler');
-const { ProcessRepositoryPostgres } = require('../../integrations/repositories/process-repository-postgres');
+const { MigrationStatusRepositoryS3 } = require('../../database/repositories/migration-status-repository-s3');
 const {
     TriggerDatabaseMigrationUseCase,
     ValidationError: TriggerValidationError,
@@ -31,14 +31,15 @@ const {
 const router = Router();
 
 // Dependency injection
-// Note: Migrations are PostgreSQL-only, so we directly use ProcessRepositoryPostgres
-// This avoids loading app definition (which requires integration classes)
-const processRepository = new ProcessRepositoryPostgres();
+// Use S3 repository to avoid User table dependency (chicken-and-egg problem)
+const bucketName = process.env.S3_BUCKET_NAME || process.env.MIGRATION_STATUS_BUCKET;
+const migrationStatusRepository = new MigrationStatusRepositoryS3(bucketName);
+
 const triggerMigrationUseCase = new TriggerDatabaseMigrationUseCase({
-    processRepository,
+    migrationStatusRepository,
     // Note: QueuerUtil is used directly in the use case (static utility)
 });
-const getStatusUseCase = new GetMigrationStatusUseCase({ processRepository });
+const getStatusUseCase = new GetMigrationStatusUseCase({ migrationStatusRepository });
 
 /**
  * Admin API key validation middleware
@@ -118,9 +119,9 @@ router.post(
 );
 
 /**
- * GET /db-migrate/:processId
+ * GET /db-migrate/:migrationId
  *
- * Get migration status by process ID
+ * Get migration status by migration ID
  *
  * Response (200 OK):
  * {
@@ -142,14 +143,15 @@ router.post(
  * }
  */
 router.get(
-    '/db-migrate/:processId',
+    '/db-migrate/:migrationId',
     catchAsyncError(async (req, res) => {
-        const { processId } = req.params;
+        const { migrationId } = req.params;
+        const stage = req.query.stage || process.env.STAGE || 'production';
 
-        console.log(`Migration status request: processId=${processId}`);
+        console.log(`Migration status request: migrationId=${migrationId}, stage=${stage}`);
 
         try {
-            const status = await getStatusUseCase.execute({ processId });
+            const status = await getStatusUseCase.execute(migrationId, stage);
 
             res.status(200).json(status);
         } catch (error) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.461.a0527a3.0",
+    "version": "2.0.0--canary.461.4b9ba0b.0",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
@@ -37,9 +37,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.461.a0527a3.0",
-        "@friggframework/prettier-config": "2.0.0--canary.461.a0527a3.0",
-        "@friggframework/test": "2.0.0--canary.461.a0527a3.0",
+        "@friggframework/eslint-config": "2.0.0--canary.461.4b9ba0b.0",
+        "@friggframework/prettier-config": "2.0.0--canary.461.4b9ba0b.0",
+        "@friggframework/test": "2.0.0--canary.461.4b9ba0b.0",
         "@prisma/client": "^6.17.0",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -79,5 +79,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "a0527a318705a351410471083bb6e5a6b6dc7165"
+    "gitHead": "4b9ba0be386a8d8c9af0398356f6644d41e89af6"
 }