@friggframework/admin-scripts 2.0.0--canary.517.300ded3.0 → 2.0.0--canary.517.35ee143.0

package/src/application/__tests__/schedule-management-use-case.test.js

@@ -1,276 +0,0 @@
-const { ScheduleManagementUseCase } = require('../schedule-management-use-case');
-
-describe('ScheduleManagementUseCase', () => {
-    let useCase;
-    let mockCommands;
-    let mockSchedulerAdapter;
-    let mockScriptFactory;
-
-    beforeEach(() => {
-        mockCommands = {
-            getScheduleByScriptName: jest.fn(),
-            upsertSchedule: jest.fn(),
-            updateScheduleAwsInfo: jest.fn(),
-            deleteSchedule: jest.fn(),
-        };
-
-        mockSchedulerAdapter = {
-            createSchedule: jest.fn(),
-            deleteSchedule: jest.fn(),
-        };
-
-        mockScriptFactory = {
-            has: jest.fn(),
-            get: jest.fn(),
-        };
-
-        useCase = new ScheduleManagementUseCase({
-            commands: mockCommands,
-            schedulerAdapter: mockSchedulerAdapter,
-            scriptFactory: mockScriptFactory,
-        });
-    });
-
-    describe('getEffectiveSchedule', () => {
-        it('should return database schedule when override exists', async () => {
-            const dbSchedule = {
-                scriptName: 'test-script',
-                enabled: true,
-                cronExpression: '0 9 * * *',
-                timezone: 'UTC',
-            };
-
-            mockScriptFactory.has.mockReturnValue(true);
-            mockScriptFactory.get.mockReturnValue({ Definition: {} });
-            mockCommands.getScheduleByScriptName.mockResolvedValue(dbSchedule);
-
-            const result = await useCase.getEffectiveSchedule('test-script');
-
-            expect(result.source).toBe('database');
-            expect(result.schedule).toEqual(dbSchedule);
-        });
-
-        it('should return definition schedule when no database override', async () => {
-            const definitionSchedule = {
-                enabled: true,
-                cronExpression: '0 12 * * *',
-                timezone: 'America/New_York',
-            };
-
-            mockScriptFactory.has.mockReturnValue(true);
-            mockScriptFactory.get.mockReturnValue({
-                Definition: { schedule: definitionSchedule },
-            });
-            mockCommands.getScheduleByScriptName.mockResolvedValue(null);
-
-            const result = await useCase.getEffectiveSchedule('test-script');
-
-            expect(result.source).toBe('definition');
-            expect(result.schedule.enabled).toBe(true);
-            expect(result.schedule.cronExpression).toBe('0 12 * * *');
-        });
-
-        it('should return none when no schedule configured', async () => {
-            mockScriptFactory.has.mockReturnValue(true);
-            mockScriptFactory.get.mockReturnValue({ Definition: {} });
-            mockCommands.getScheduleByScriptName.mockResolvedValue(null);
-
-            const result = await useCase.getEffectiveSchedule('test-script');
-
-            expect(result.source).toBe('none');
-            expect(result.schedule.enabled).toBe(false);
-        });
-
-        it('should throw error when script not found', async () => {
-            mockScriptFactory.has.mockReturnValue(false);
-
-            await expect(useCase.getEffectiveSchedule('non-existent'))
-                .rejects.toThrow('Script "non-existent" not found');
-        });
-    });
-
-    describe('upsertSchedule', () => {
-        it('should create schedule and provision EventBridge when enabled', async () => {
-            const savedSchedule = {
-                scriptName: 'test-script',
-                enabled: true,
-                cronExpression: '0 12 * * *',
-                timezone: 'UTC',
-            };
-
-            mockScriptFactory.has.mockReturnValue(true);
-            mockCommands.upsertSchedule.mockResolvedValue(savedSchedule);
-            mockSchedulerAdapter.createSchedule.mockResolvedValue({
-                scheduleArn: 'arn:aws:scheduler:us-east-1:123:schedule/test',
-                scheduleName: 'frigg-script-test-script',
-            });
-            mockCommands.updateScheduleAwsInfo.mockResolvedValue({
-                ...savedSchedule,
-                awsScheduleArn: 'arn:aws:scheduler:us-east-1:123:schedule/test',
-            });
-
-            const result = await useCase.upsertSchedule('test-script', {
-                enabled: true,
-                cronExpression: '0 12 * * *',
-                timezone: 'UTC',
-            });
-
-            expect(result.success).toBe(true);
-            expect(result.schedule.scriptName).toBe('test-script');
-            expect(mockSchedulerAdapter.createSchedule).toHaveBeenCalledWith({
-                scriptName: 'test-script',
-                cronExpression: '0 12 * * *',
-                timezone: 'UTC',
-            });
-            expect(mockCommands.updateScheduleAwsInfo).toHaveBeenCalled();
-        });
-
-        it('should delete EventBridge schedule when disabling', async () => {
-            const existingSchedule = {
-                scriptName: 'test-script',
-                enabled: false,
-                cronExpression: null,
-                timezone: 'UTC',
-                awsScheduleArn: 'arn:aws:scheduler:us-east-1:123:schedule/test',
-            };
-
-            mockScriptFactory.has.mockReturnValue(true);
-            mockCommands.upsertSchedule.mockResolvedValue(existingSchedule);
-            mockSchedulerAdapter.deleteSchedule.mockResolvedValue();
-            mockCommands.updateScheduleAwsInfo.mockResolvedValue({
-                ...existingSchedule,
-                awsScheduleArn: null,
-            });
-
-            const result = await useCase.upsertSchedule('test-script', {
-                enabled: false,
-            });
-
-            expect(result.success).toBe(true);
-            expect(mockSchedulerAdapter.deleteSchedule).toHaveBeenCalledWith('test-script');
-        });
-
-        it('should handle scheduler errors gracefully', async () => {
-            const savedSchedule = {
-                scriptName: 'test-script',
-                enabled: true,
-                cronExpression: '0 12 * * *',
-                timezone: 'UTC',
-            };
-
-            mockScriptFactory.has.mockReturnValue(true);
-            mockCommands.upsertSchedule.mockResolvedValue(savedSchedule);
-            mockSchedulerAdapter.createSchedule.mockRejectedValue(
-                new Error('AWS Scheduler API error')
-            );
-
-            const result = await useCase.upsertSchedule('test-script', {
-                enabled: true,
-                cronExpression: '0 12 * * *',
-            });
-
-            // Should succeed with warning, not fail
-            expect(result.success).toBe(true);
-            expect(result.schedulerWarning).toBe('AWS Scheduler API error');
-        });
-
-        it('should throw error when script not found', async () => {
-            mockScriptFactory.has.mockReturnValue(false);
-
-            await expect(useCase.upsertSchedule('non-existent', { enabled: true }))
-                .rejects.toThrow('Script "non-existent" not found');
-        });
-
-        it('should throw error when enabled without cronExpression', async () => {
-            mockScriptFactory.has.mockReturnValue(true);
-
-            await expect(useCase.upsertSchedule('test-script', { enabled: true }))
-                .rejects.toThrow('cronExpression is required when enabled is true');
-        });
-    });
-
-    describe('deleteSchedule', () => {
-        it('should delete schedule and EventBridge rule', async () => {
-            const deletedSchedule = {
-                scriptName: 'test-script',
-                awsScheduleArn: 'arn:aws:scheduler:us-east-1:123:schedule/test',
-            };
-
-            mockScriptFactory.has.mockReturnValue(true);
-            mockScriptFactory.get.mockReturnValue({ Definition: {} });
-            mockCommands.deleteSchedule.mockResolvedValue({
-                deletedCount: 1,
-                deleted: deletedSchedule,
-            });
-            mockSchedulerAdapter.deleteSchedule.mockResolvedValue();
-
-            const result = await useCase.deleteSchedule('test-script');
-
-            expect(result.success).toBe(true);
-            expect(result.deletedCount).toBe(1);
-            expect(mockSchedulerAdapter.deleteSchedule).toHaveBeenCalledWith('test-script');
-        });
-
-        it('should not call scheduler when no AWS rule exists', async () => {
-            mockScriptFactory.has.mockReturnValue(true);
-            mockScriptFactory.get.mockReturnValue({ Definition: {} });
-            mockCommands.deleteSchedule.mockResolvedValue({
-                deletedCount: 1,
-                deleted: { scriptName: 'test-script' }, // No awsScheduleArn
-            });
-
-            const result = await useCase.deleteSchedule('test-script');
-
-            expect(result.success).toBe(true);
-            expect(mockSchedulerAdapter.deleteSchedule).not.toHaveBeenCalled();
-        });
-
-        it('should handle scheduler delete errors gracefully', async () => {
-            mockScriptFactory.has.mockReturnValue(true);
-            mockScriptFactory.get.mockReturnValue({ Definition: {} });
-            mockCommands.deleteSchedule.mockResolvedValue({
-                deletedCount: 1,
-                deleted: {
-                    scriptName: 'test-script',
-                    awsScheduleArn: 'arn:aws:scheduler:us-east-1:123:schedule/test',
-                },
-            });
-            mockSchedulerAdapter.deleteSchedule.mockRejectedValue(
-                new Error('AWS delete failed')
-            );
-
-            const result = await useCase.deleteSchedule('test-script');
-
-            expect(result.success).toBe(true);
-            expect(result.schedulerWarning).toBe('AWS delete failed');
-        });
-
-        it('should return effective schedule after deletion', async () => {
-            const definitionSchedule = {
-                enabled: true,
-                cronExpression: '0 6 * * *',
-            };
-
-            mockScriptFactory.has.mockReturnValue(true);
-            mockScriptFactory.get.mockReturnValue({
-                Definition: { schedule: definitionSchedule },
-            });
-            mockCommands.deleteSchedule.mockResolvedValue({
-                deletedCount: 1,
-                deleted: { scriptName: 'test-script' },
-            });
-
-            const result = await useCase.deleteSchedule('test-script');
-
-            expect(result.effectiveSchedule.source).toBe('definition');
-            expect(result.effectiveSchedule.enabled).toBe(true);
-        });
-
-        it('should throw error when script not found', async () => {
-            mockScriptFactory.has.mockReturnValue(false);
-
-            await expect(useCase.deleteSchedule('non-existent'))
-                .rejects.toThrow('Script "non-existent" not found');
-        });
-    });
-});

package/src/application/schedule-management-use-case.js

@@ -1,230 +0,0 @@
-/**
- * Schedule Management Use Case
- *
- * Application Layer - Hexagonal Architecture
- *
- * Orchestrates schedule management operations:
- * - Get effective schedule (DB override > Definition > none)
- * - Upsert schedule with EventBridge provisioning
- * - Delete schedule with EventBridge cleanup
- *
- * This use case encapsulates the business logic that was previously
- * embedded in the router, reducing cognitive complexity and improving testability.
- */
-class ScheduleManagementUseCase {
-    constructor({ commands, schedulerAdapter, scriptFactory }) {
-        this.commands = commands;
-        this.schedulerAdapter = schedulerAdapter;
-        this.scriptFactory = scriptFactory;
-    }
-
-    /**
-     * Validate that a script exists
-     * @private
-     */
-    _validateScriptExists(scriptName) {
-        if (!this.scriptFactory.has(scriptName)) {
-            const error = new Error(`Script "${scriptName}" not found`);
-            error.code = 'SCRIPT_NOT_FOUND';
-            throw error;
-        }
-    }
-
-    /**
-     * Get the definition schedule from a script class
-     * @private
-     */
-    _getDefinitionSchedule(scriptName) {
-        const scriptClass = this.scriptFactory.get(scriptName);
-        return scriptClass.Definition?.schedule || null;
-    }
-
-    /**
-     * Get effective schedule (DB override > Definition default > none)
-     */
-    async getEffectiveSchedule(scriptName) {
-        this._validateScriptExists(scriptName);
-
-        // Check database override first
-        const dbSchedule = await this.commands.getScheduleByScriptName(scriptName);
-        if (dbSchedule) {
-            return {
-                source: 'database',
-                schedule: dbSchedule,
-            };
-        }
-
-        // Check definition default
-        const definitionSchedule = this._getDefinitionSchedule(scriptName);
-        if (definitionSchedule?.enabled) {
-            return {
-                source: 'definition',
-                schedule: {
-                    scriptName,
-                    enabled: definitionSchedule.enabled,
-                    cronExpression: definitionSchedule.cronExpression,
-                    timezone: definitionSchedule.timezone || 'UTC',
-                },
-            };
-        }
-
-        // No schedule configured
-        return {
-            source: 'none',
-            schedule: {
-                scriptName,
-                enabled: false,
-            },
-        };
-    }
-
-    /**
-     * Create or update schedule with EventBridge provisioning
-     */
-    async upsertSchedule(scriptName, { enabled, cronExpression, timezone }) {
-        this._validateScriptExists(scriptName);
-        this._validateScheduleInput(enabled, cronExpression);
-
-        // Save to database
-        const schedule = await this.commands.upsertSchedule({
-            scriptName,
-            enabled,
-            cronExpression: cronExpression || null,
-            timezone: timezone || 'UTC',
-        });
-
-        // Provision/deprovision EventBridge
-        const schedulerResult = await this._syncEventBridgeSchedule(
-            scriptName,
-            enabled,
-            cronExpression,
-            timezone,
-            schedule.awsScheduleArn
-        );
-
-        return {
-            success: true,
-            schedule: {
-                ...schedule,
-                awsScheduleArn: schedulerResult.awsScheduleArn || schedule.awsScheduleArn,
-                awsScheduleName: schedulerResult.awsScheduleName || schedule.awsScheduleName,
-            },
-            ...(schedulerResult.warning && { schedulerWarning: schedulerResult.warning }),
-        };
-    }
-
-    /**
-     * Validate schedule input
-     * @private
-     */
-    _validateScheduleInput(enabled, cronExpression) {
-        if (typeof enabled !== 'boolean') {
-            const error = new Error('enabled must be a boolean');
-            error.code = 'INVALID_INPUT';
-            throw error;
-        }
-
-        if (enabled && !cronExpression) {
-            const error = new Error('cronExpression is required when enabled is true');
-            error.code = 'INVALID_INPUT';
-            throw error;
-        }
-    }
-
-    /**
-     * Sync EventBridge schedule based on enabled state
-     * @private
-     */
-    async _syncEventBridgeSchedule(scriptName, enabled, cronExpression, timezone, existingArn) {
-        const result = { awsScheduleArn: null, awsScheduleName: null, warning: null };
-
-        try {
-            if (enabled && cronExpression) {
-                // Create/update EventBridge schedule
-                const awsInfo = await this.schedulerAdapter.createSchedule({
-                    scriptName,
-                    cronExpression,
-                    timezone: timezone || 'UTC',
-                });
-
-                if (awsInfo?.scheduleArn) {
-                    await this.commands.updateScheduleAwsInfo(scriptName, {
-                        awsScheduleArn: awsInfo.scheduleArn,
-                        awsScheduleName: awsInfo.scheduleName,
-                    });
-                    result.awsScheduleArn = awsInfo.scheduleArn;
-                    result.awsScheduleName = awsInfo.scheduleName;
-                }
-            } else if (!enabled && existingArn) {
-                // Delete EventBridge schedule
-                await this.schedulerAdapter.deleteSchedule(scriptName);
-                await this.commands.updateScheduleAwsInfo(scriptName, {
-                    awsScheduleArn: null,
-                    awsScheduleName: null,
-                });
-            }
-        } catch (error) {
-            // Non-fatal: DB schedule is saved, AWS can be retried
-            result.warning = error.message;
-        }
-
-        return result;
-    }
-
-    /**
-     * Delete schedule override and cleanup EventBridge
-     */
-    async deleteSchedule(scriptName) {
-        this._validateScriptExists(scriptName);
-
-        // Delete from database
-        const deleteResult = await this.commands.deleteSchedule(scriptName);
-
-        // Cleanup EventBridge if needed
-        const schedulerWarning = await this._cleanupEventBridgeSchedule(
-            scriptName,
-            deleteResult.deleted?.awsScheduleArn
-        );
-
-        // Get effective schedule after deletion
-        const definitionSchedule = this._getDefinitionSchedule(scriptName);
-        const effectiveSchedule = definitionSchedule?.enabled
-            ? {
-                source: 'definition',
-                enabled: definitionSchedule.enabled,
-                cronExpression: definitionSchedule.cronExpression,
-                timezone: definitionSchedule.timezone || 'UTC',
-            }
-            : { source: 'none', enabled: false };
-
-        return {
-            success: true,
-            deletedCount: deleteResult.deletedCount,
-            message: deleteResult.deletedCount > 0
-                ? 'Schedule override removed'
-                : 'No schedule override found',
-            effectiveSchedule,
-            ...(schedulerWarning && { schedulerWarning }),
-        };
-    }
-
-    /**
-     * Cleanup EventBridge schedule if it exists
-     * @private
-     */
-    async _cleanupEventBridgeSchedule(scriptName, awsScheduleArn) {
-        if (!awsScheduleArn) {
-            return null;
-        }
-
-        try {
-            await this.schedulerAdapter.deleteSchedule(scriptName);
-            return null;
-        } catch (error) {
-            // Non-fatal: DB is cleaned up, AWS can be retried
-            return error.message;
-        }
-    }
-}
-
-module.exports = { ScheduleManagementUseCase };