@friggframework/admin-scripts 2.0.0--canary.517.41839c5.0

package/src/adapters/__tests__/local-scheduler-adapter.test.js

@@ -0,0 +1,325 @@
+const { LocalSchedulerAdapter } = require('../local-scheduler-adapter');
+const { SchedulerAdapter } = require('../scheduler-adapter');
+
+describe('LocalSchedulerAdapter', () => {
+    let adapter;
+
+    beforeEach(() => {
+        adapter = new LocalSchedulerAdapter();
+    });
+
+    afterEach(() => {
+        adapter.clear();
+    });
+
+    describe('Inheritance', () => {
+        it('should extend SchedulerAdapter', () => {
+            expect(adapter).toBeInstanceOf(SchedulerAdapter);
+        });
+
+        it('should have correct adapter name', () => {
+            expect(adapter.getName()).toBe('local-cron');
+        });
+    });
+
+    describe('createSchedule()', () => {
+        it('should create a schedule with required fields', async () => {
+            const config = {
+                scriptName: 'test-script',
+                cronExpression: '0 0 * * *',
+            };
+
+            const result = await adapter.createSchedule(config);
+
+            expect(result).toEqual({
+                scheduleName: 'test-script',
+                scheduleArn: 'local:schedule:test-script',
+            });
+            expect(adapter.size).toBe(1);
+        });
+
+        it('should create a schedule with all optional fields', async () => {
+            const config = {
+                scriptName: 'test-script',
+                cronExpression: '0 0 * * *',
+                timezone: 'America/New_York',
+                input: { key: 'value' },
+            };
+
+            const result = await adapter.createSchedule(config);
+
+            expect(result).toEqual({
+                scheduleName: 'test-script',
+                scheduleArn: 'local:schedule:test-script',
+            });
+
+            const schedule = await adapter.getSchedule('test-script');
+            expect(schedule.ScheduleExpressionTimezone).toBe('America/New_York');
+            expect(JSON.parse(schedule.Target.Input).params).toEqual({ key: 'value' });
+        });
+
+        it('should default timezone to UTC', async () => {
+            const config = {
+                scriptName: 'test-script',
+                cronExpression: '0 0 * * *',
+            };
+
+            await adapter.createSchedule(config);
+            const schedule = await adapter.getSchedule('test-script');
+
+            expect(schedule.ScheduleExpressionTimezone).toBe('UTC');
+        });
+
+        it('should enable schedule by default', async () => {
+            const config = {
+                scriptName: 'test-script',
+                cronExpression: '0 0 * * *',
+            };
+
+            await adapter.createSchedule(config);
+            const schedule = await adapter.getSchedule('test-script');
+
+            expect(schedule.State).toBe('ENABLED');
+        });
+
+        it('should update existing schedule if created again', async () => {
+            const config1 = {
+                scriptName: 'test-script',
+                cronExpression: '0 0 * * *',
+            };
+
+            const config2 = {
+                scriptName: 'test-script',
+                cronExpression: '0 12 * * *',
+            };
+
+            await adapter.createSchedule(config1);
+            expect(adapter.size).toBe(1);
+
+            await adapter.createSchedule(config2);
+            expect(adapter.size).toBe(1); // Still only 1 schedule
+
+            const schedule = await adapter.getSchedule('test-script');
+            expect(schedule.ScheduleExpression).toBe('0 12 * * *');
+        });
+    });
+
+    describe('deleteSchedule()', () => {
+        it('should delete an existing schedule', async () => {
+            await adapter.createSchedule({
+                scriptName: 'test-script',
+                cronExpression: '0 0 * * *',
+            });
+
+            expect(adapter.size).toBe(1);
+
+            await adapter.deleteSchedule('test-script');
+
+            expect(adapter.size).toBe(0);
+        });
+
+        it('should not throw error when deleting non-existent schedule', async () => {
+            await expect(adapter.deleteSchedule('non-existent')).resolves.toBeUndefined();
+        });
+
+        it('should clear intervals if they exist', async () => {
+            await adapter.createSchedule({
+                scriptName: 'test-script',
+                cronExpression: '0 0 * * *',
+            });
+
+            // Simulate an interval
+            const intervalId = setInterval(() => {}, 1000);
+            adapter.intervals.set('test-script', intervalId);
+
+            await adapter.deleteSchedule('test-script');
+
+            expect(adapter.intervals.has('test-script')).toBe(false);
+            expect(adapter.size).toBe(0);
+        });
+    });
+
+    describe('setScheduleEnabled()', () => {
+        beforeEach(async () => {
+            await adapter.createSchedule({
+                scriptName: 'test-script',
+                cronExpression: '0 0 * * *',
+            });
+        });
+
+        it('should disable a schedule', async () => {
+            await adapter.setScheduleEnabled('test-script', false);
+
+            const schedule = await adapter.getSchedule('test-script');
+            expect(schedule.State).toBe('DISABLED');
+        });
+
+        it('should enable a schedule', async () => {
+            await adapter.setScheduleEnabled('test-script', false);
+            await adapter.setScheduleEnabled('test-script', true);
+
+            const schedule = await adapter.getSchedule('test-script');
+            expect(schedule.State).toBe('ENABLED');
+        });
+
+        it('should throw error if schedule not found', async () => {
+            await expect(
+                adapter.setScheduleEnabled('non-existent', true)
+            ).rejects.toThrow('Schedule for script "non-existent" not found');
+        });
+
+        it('should update the updatedAt timestamp', async () => {
+            const schedule1 = await adapter.getSchedule('test-script');
+            const originalUpdatedAt = schedule1.LastModificationDate;
+
+            // Wait a bit to ensure timestamp changes
+            await new Promise((resolve) => setTimeout(resolve, 10));
+
+            await adapter.setScheduleEnabled('test-script', false);
+
+            const schedule2 = await adapter.getSchedule('test-script');
+            expect(schedule2.LastModificationDate.getTime()).toBeGreaterThan(
+                originalUpdatedAt.getTime()
+            );
+        });
+    });
+
+    describe('listSchedules()', () => {
+        it('should return empty array when no schedules exist', async () => {
+            const schedules = await adapter.listSchedules();
+
+            expect(schedules).toEqual([]);
+        });
+
+        it('should return all schedules', async () => {
+            await adapter.createSchedule({
+                scriptName: 'script-1',
+                cronExpression: '0 0 * * *',
+            });
+
+            await adapter.createSchedule({
+                scriptName: 'script-2',
+                cronExpression: '0 12 * * *',
+            });
+
+            await adapter.createSchedule({
+                scriptName: 'script-3',
+                cronExpression: '0 18 * * *',
+            });
+
+            const schedules = await adapter.listSchedules();
+
+            expect(schedules).toHaveLength(3);
+            expect(schedules.map((s) => s.scriptName)).toContain('script-1');
+            expect(schedules.map((s) => s.scriptName)).toContain('script-2');
+            expect(schedules.map((s) => s.scriptName)).toContain('script-3');
+        });
+
+        it('should include all schedule properties', async () => {
+            await adapter.createSchedule({
+                scriptName: 'test-script',
+                cronExpression: '0 0 * * *',
+                timezone: 'America/New_York',
+                input: { key: 'value' },
+            });
+
+            const schedules = await adapter.listSchedules();
+
+            expect(schedules[0]).toMatchObject({
+                scriptName: 'test-script',
+                cronExpression: '0 0 * * *',
+                timezone: 'America/New_York',
+                input: { key: 'value' },
+                enabled: true,
+            });
+            expect(schedules[0]).toHaveProperty('createdAt');
+            expect(schedules[0]).toHaveProperty('updatedAt');
+        });
+    });
+
+    describe('getSchedule()', () => {
+        beforeEach(async () => {
+            await adapter.createSchedule({
+                scriptName: 'test-script',
+                cronExpression: '0 0 * * *',
+                timezone: 'America/New_York',
+                input: { key: 'value' },
+            });
+        });
+
+        it('should return schedule details', async () => {
+            const schedule = await adapter.getSchedule('test-script');
+
+            expect(schedule.Name).toBe('test-script');
+            expect(schedule.State).toBe('ENABLED');
+            expect(schedule.ScheduleExpression).toBe('0 0 * * *');
+            expect(schedule.ScheduleExpressionTimezone).toBe('America/New_York');
+        });
+
+        it('should include target configuration', async () => {
+            const schedule = await adapter.getSchedule('test-script');
+
+            const targetInput = JSON.parse(schedule.Target.Input);
+            expect(targetInput).toEqual({
+                scriptName: 'test-script',
+                trigger: 'SCHEDULED',
+                params: { key: 'value' },
+            });
+        });
+
+        it('should include creation and modification dates', async () => {
+            const schedule = await adapter.getSchedule('test-script');
+
+            expect(schedule.CreationDate).toBeInstanceOf(Date);
+            expect(schedule.LastModificationDate).toBeInstanceOf(Date);
+        });
+
+        it('should throw error if schedule not found', async () => {
+            await expect(adapter.getSchedule('non-existent')).rejects.toThrow(
+                'Schedule for script "non-existent" not found'
+            );
+        });
+    });
+
+    describe('Utility methods', () => {
+        it('clear() should remove all schedules', async () => {
+            await adapter.createSchedule({
+                scriptName: 'script-1',
+                cronExpression: '0 0 * * *',
+            });
+
+            await adapter.createSchedule({
+                scriptName: 'script-2',
+                cronExpression: '0 12 * * *',
+            });
+
+            expect(adapter.size).toBe(2);
+
+            adapter.clear();
+
+            expect(adapter.size).toBe(0);
+        });
+
+        it('size should return number of schedules', async () => {
+            expect(adapter.size).toBe(0);
+
+            await adapter.createSchedule({
+                scriptName: 'script-1',
+                cronExpression: '0 0 * * *',
+            });
+
+            expect(adapter.size).toBe(1);
+
+            await adapter.createSchedule({
+                scriptName: 'script-2',
+                cronExpression: '0 12 * * *',
+            });
+
+            expect(adapter.size).toBe(2);
+
+            await adapter.deleteSchedule('script-1');
+
+            expect(adapter.size).toBe(1);
+        });
+    });
+});

package/src/adapters/__tests__/scheduler-adapter-factory.test.js

@@ -0,0 +1,257 @@
+const {
+    createSchedulerAdapter,
+    detectSchedulerAdapterType,
+} = require('../scheduler-adapter-factory');
+const { AWSSchedulerAdapter } = require('../aws-scheduler-adapter');
+const { LocalSchedulerAdapter } = require('../local-scheduler-adapter');
+
+// Mock AWS SDK to prevent actual AWS calls
+jest.mock('@aws-sdk/client-scheduler', () => ({
+    SchedulerClient: jest.fn(() => ({
+        send: jest.fn(),
+    })),
+    CreateScheduleCommand: jest.fn(),
+    DeleteScheduleCommand: jest.fn(),
+    GetScheduleCommand: jest.fn(),
+    UpdateScheduleCommand: jest.fn(),
+    ListSchedulesCommand: jest.fn(),
+}));
+
+describe('Scheduler Adapter Factory', () => {
+    let originalEnv;
+
+    beforeAll(() => {
+        originalEnv = { ...process.env };
+    });
+
+    beforeEach(() => {
+        // Reset environment variables
+        delete process.env.SCHEDULER_ADAPTER;
+        delete process.env.STAGE;
+        delete process.env.NODE_ENV;
+    });
+
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+
+    describe('createSchedulerAdapter()', () => {
+        it('should create local adapter by default', () => {
+            const adapter = createSchedulerAdapter();
+
+            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
+            expect(adapter.getName()).toBe('local-cron');
+        });
+
+        it('should create local adapter when explicitly specified', () => {
+            const adapter = createSchedulerAdapter({ type: 'local' });
+
+            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
+        });
+
+        it('should create AWS adapter when type is "aws"', () => {
+            const adapter = createSchedulerAdapter({ type: 'aws' });
+
+            expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
+            expect(adapter.getName()).toBe('aws-eventbridge-scheduler');
+        });
+
+        it('should create AWS adapter when type is "eventbridge"', () => {
+            const adapter = createSchedulerAdapter({ type: 'eventbridge' });
+
+            expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
+        });
+
+        it('should use SCHEDULER_ADAPTER env variable', () => {
+            process.env.SCHEDULER_ADAPTER = 'aws';
+
+            const adapter = createSchedulerAdapter();
+
+            expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
+        });
+
+        it('should allow explicit type to override env variable', () => {
+            process.env.SCHEDULER_ADAPTER = 'aws';
+
+            const adapter = createSchedulerAdapter({ type: 'local' });
+
+            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
+        });
+
+        it('should handle case-insensitive type values', () => {
+            const adapter1 = createSchedulerAdapter({ type: 'AWS' });
+            const adapter2 = createSchedulerAdapter({ type: 'LOCAL' });
+            const adapter3 = createSchedulerAdapter({ type: 'EventBridge' });
+
+            expect(adapter1).toBeInstanceOf(AWSSchedulerAdapter);
+            expect(adapter2).toBeInstanceOf(LocalSchedulerAdapter);
+            expect(adapter3).toBeInstanceOf(AWSSchedulerAdapter);
+        });
+
+        it('should pass AWS configuration to AWS adapter', () => {
+            const config = {
+                type: 'aws',
+                region: 'eu-west-1',
+                targetLambdaArn: 'arn:aws:lambda:eu-west-1:123456789012:function:test',
+                scheduleGroupName: 'custom-group',
+            };
+
+            const adapter = createSchedulerAdapter(config);
+
+            expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
+            expect(adapter.region).toBe('eu-west-1');
+            expect(adapter.targetLambdaArn).toBe('arn:aws:lambda:eu-west-1:123456789012:function:test');
+            expect(adapter.scheduleGroupName).toBe('custom-group');
+        });
+
+        it('should ignore AWS config for local adapter', () => {
+            const config = {
+                type: 'local',
+                region: 'eu-west-1', // This should be ignored
+            };
+
+            const adapter = createSchedulerAdapter(config);
+
+            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
+            expect(adapter.region).toBeUndefined();
+        });
+
+        it('should handle unknown adapter type by creating local adapter', () => {
+            const adapter = createSchedulerAdapter({ type: 'unknown-type' });
+
+            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
+        });
+    });
+
+    describe('detectSchedulerAdapterType()', () => {
+        it('should return "local" by default', () => {
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('local');
+        });
+
+        it('should return env SCHEDULER_ADAPTER when set', () => {
+            process.env.SCHEDULER_ADAPTER = 'aws';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('aws');
+        });
+
+        it('should return "aws" for production stage', () => {
+            process.env.STAGE = 'production';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('aws');
+        });
+
+        it('should return "aws" for prod stage', () => {
+            process.env.STAGE = 'prod';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('aws');
+        });
+
+        it('should return "aws" for staging stage', () => {
+            process.env.STAGE = 'staging';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('aws');
+        });
+
+        it('should return "aws" for stage stage', () => {
+            process.env.STAGE = 'stage';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('aws');
+        });
+
+        it('should handle case-insensitive stage values', () => {
+            process.env.STAGE = 'PRODUCTION';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('aws');
+        });
+
+        it('should return "local" for dev stage', () => {
+            process.env.STAGE = 'dev';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('local');
+        });
+
+        it('should return "local" for development stage', () => {
+            process.env.STAGE = 'development';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('local');
+        });
+
+        it('should return "local" for test stage', () => {
+            process.env.STAGE = 'test';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('local');
+        });
+
+        it('should return "local" for local stage', () => {
+            process.env.STAGE = 'local';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('local');
+        });
+
+        it('should use NODE_ENV as fallback for STAGE', () => {
+            delete process.env.STAGE;
+            process.env.NODE_ENV = 'production';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('aws');
+        });
+
+        it('should prioritize explicit SCHEDULER_ADAPTER over auto-detection', () => {
+            process.env.SCHEDULER_ADAPTER = 'local';
+            process.env.STAGE = 'production';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('local');
+        });
+    });
+
+    describe('Integration with createSchedulerAdapter', () => {
+        it('should auto-detect and create AWS adapter in production', () => {
+            process.env.STAGE = 'production';
+
+            const adapter = createSchedulerAdapter();
+
+            expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
+        });
+
+        it('should auto-detect and create local adapter in development', () => {
+            process.env.STAGE = 'development';
+
+            const adapter = createSchedulerAdapter();
+
+            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
+        });
+
+        it('should allow explicit override of auto-detection', () => {
+            process.env.STAGE = 'production';
+
+            const adapter = createSchedulerAdapter({ type: 'local' });
+
+            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
+        });
+    });
+});

package/src/adapters/__tests__/scheduler-adapter.test.js

@@ -0,0 +1,103 @@
+const { SchedulerAdapter } = require('../scheduler-adapter');
+
+describe('SchedulerAdapter', () => {
+    let adapter;
+
+    beforeEach(() => {
+        adapter = new SchedulerAdapter();
+    });
+
+    describe('Abstract base class', () => {
+        it('should throw error for getName()', () => {
+            expect(() => adapter.getName()).toThrow(
+                'SchedulerAdapter.getName() must be implemented'
+            );
+        });
+
+        it('should throw error for createSchedule()', async () => {
+            await expect(adapter.createSchedule({})).rejects.toThrow(
+                'SchedulerAdapter.createSchedule() must be implemented'
+            );
+        });
+
+        it('should throw error for deleteSchedule()', async () => {
+            await expect(adapter.deleteSchedule('test')).rejects.toThrow(
+                'SchedulerAdapter.deleteSchedule() must be implemented'
+            );
+        });
+
+        it('should throw error for setScheduleEnabled()', async () => {
+            await expect(adapter.setScheduleEnabled('test', true)).rejects.toThrow(
+                'SchedulerAdapter.setScheduleEnabled() must be implemented'
+            );
+        });
+
+        it('should throw error for listSchedules()', async () => {
+            await expect(adapter.listSchedules()).rejects.toThrow(
+                'SchedulerAdapter.listSchedules() must be implemented'
+            );
+        });
+
+        it('should throw error for getSchedule()', async () => {
+            await expect(adapter.getSchedule('test')).rejects.toThrow(
+                'SchedulerAdapter.getSchedule() must be implemented'
+            );
+        });
+    });
+
+    describe('Inheritance', () => {
+        it('should be extendable by concrete implementations', () => {
+            class TestSchedulerAdapter extends SchedulerAdapter {
+                getName() {
+                    return 'test-adapter';
+                }
+
+                async createSchedule(config) {
+                    return { scheduleName: config.scriptName };
+                }
+
+                async deleteSchedule(scriptName) {
+                    return;
+                }
+
+                async setScheduleEnabled(scriptName, enabled) {
+                    return;
+                }
+
+                async listSchedules() {
+                    return [];
+                }
+
+                async getSchedule(scriptName) {
+                    return { scriptName };
+                }
+            }
+
+            const testAdapter = new TestSchedulerAdapter();
+
+            expect(testAdapter).toBeInstanceOf(SchedulerAdapter);
+            expect(testAdapter.getName()).toBe('test-adapter');
+        });
+
+        it('should require all abstract methods to be implemented', async () => {
+            class IncompleteAdapter extends SchedulerAdapter {
+                getName() {
+                    return 'incomplete';
+                }
+                // Missing other methods
+            }
+
+            const incomplete = new IncompleteAdapter();
+
+            // Should work for implemented method
+            expect(incomplete.getName()).toBe('incomplete');
+
+            // Should throw for missing methods
+            await expect(incomplete.createSchedule({})).rejects.toThrow();
+            await expect(incomplete.deleteSchedule('test')).rejects.toThrow();
+            await expect(incomplete.setScheduleEnabled('test', true)).rejects.toThrow();
+            await expect(incomplete.listSchedules()).rejects.toThrow();
+            await expect(incomplete.getSchedule('test')).rejects.toThrow();
+        });
+    });
+});