@friggframework/admin-scripts 2.0.0--canary.522.cbd3d5a.0 → 2.0.0--canary.517.21b69ac.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/dry-run-http-interceptor.js

@@ -1,296 +0,0 @@
-/**
- * Dry-Run HTTP Interceptor
- *
- * Creates a mock HTTP client that logs requests instead of executing them.
- * Used to intercept API module calls during dry-run.
- */
-
-/**
- * Sanitize headers to remove authentication tokens
- * @param {Object} headers - HTTP headers
- * @returns {Object} Sanitized headers
- */
-function sanitizeHeaders(headers) {
-    if (!headers || typeof headers !== 'object') {
-        return {};
-    }
-
-    const safe = { ...headers };
-
-    // Remove common auth headers
-    const sensitiveHeaders = [
-        'authorization',
-        'Authorization',
-        'x-api-key',
-        'X-API-Key',
-        'x-auth-token',
-        'X-Auth-Token',
-        'api-key',
-        'API-Key',
-        'apikey',
-        'ApiKey',
-        'token',
-        'Token',
-    ];
-
-    for (const header of sensitiveHeaders) {
-        if (safe[header]) {
-            safe[header] = '[REDACTED]';
-        }
-    }
-
-    return safe;
-}
-
-/**
- * Detect service name from base URL
- * @param {string} baseURL - Base URL of the API
- * @returns {string} Service name
- */
-function detectService(baseURL) {
-    if (!baseURL) return 'unknown';
-
-    const url = baseURL.toLowerCase();
-
-    // CRM Systems
-    if (url.includes('hubspot') || url.includes('hubapi')) return 'HubSpot';
-    if (url.includes('salesforce')) return 'Salesforce';
-    if (url.includes('pipedrive')) return 'Pipedrive';
-    if (url.includes('zoho')) return 'Zoho CRM';
-    if (url.includes('attio')) return 'Attio';
-
-    // Communication
-    if (url.includes('slack')) return 'Slack';
-    if (url.includes('discord')) return 'Discord';
-    if (url.includes('teams.microsoft')) return 'Microsoft Teams';
-
-    // Project Management
-    if (url.includes('asana')) return 'Asana';
-    if (url.includes('monday')) return 'Monday.com';
-    if (url.includes('trello')) return 'Trello';
-    if (url.includes('clickup')) return 'ClickUp';
-
-    // Storage
-    if (url.includes('googleapis.com/drive')) return 'Google Drive';
-    if (url.includes('dropbox')) return 'Dropbox';
-    if (url.includes('box.com')) return 'Box';
-
-    // Email & Marketing
-    if (url.includes('sendgrid')) return 'SendGrid';
-    if (url.includes('mailchimp')) return 'Mailchimp';
-    if (url.includes('gmail')) return 'Gmail';
-
-    // Accounting
-    if (url.includes('quickbooks')) return 'QuickBooks';
-    if (url.includes('xero')) return 'Xero';
-
-    // Other
-    if (url.includes('stripe')) return 'Stripe';
-    if (url.includes('shopify')) return 'Shopify';
-    if (url.includes('github')) return 'GitHub';
-    if (url.includes('gitlab')) return 'GitLab';
-
-    return 'unknown';
-}
-
-/**
- * Sanitize request data to remove sensitive information
- * @param {*} data - Request data
- * @returns {*} Sanitized data
- */
-function sanitizeData(data) {
-    if (data === null || data === undefined) {
-        return data;
-    }
-
-    if (typeof data !== 'object') {
-        return data;
-    }
-
-    if (Array.isArray(data)) {
-        return data.map(sanitizeData);
-    }
-
-    const sanitized = {};
-    for (const [key, value] of Object.entries(data)) {
-        const lowerKey = key.toLowerCase();
-
-        // Check if this is a leaf node that should be redacted
-        const isSensitiveField =
-            lowerKey === 'password' ||
-            lowerKey === 'token' ||
-            lowerKey === 'secret' ||
-            lowerKey === 'apikey' ||
-            lowerKey.endsWith('password') ||
-            lowerKey.endsWith('token') ||
-            lowerKey.endsWith('secret') ||
-            lowerKey.endsWith('key') && !lowerKey.endsWith('publickey');
-
-        // Only redact if it's a primitive value (not an object/array)
-        if (isSensitiveField && typeof value !== 'object') {
-            sanitized[key] = '[REDACTED]';
-            continue;
-        }
-
-        // Recursively sanitize nested objects
-        if (typeof value === 'object' && value !== null) {
-            sanitized[key] = sanitizeData(value);
-        } else {
-            sanitized[key] = value;
-        }
-    }
-
-    return sanitized;
-}
-
-/**
- * Create a dry-run HTTP client
- *
- * @param {Array} operationLog - Array to append logged HTTP requests
- * @returns {Object} Mock HTTP client compatible with axios interface
- */
-function createDryRunHttpClient(operationLog) {
-    /**
-     * Mock HTTP request handler
-     * @param {Object} config - Request configuration
-     * @returns {Promise<Object>} Mock response
-     */
-    const mockRequest = async (config) => {
-        // Build full URL
-        let fullUrl = config.url;
-        if (config.baseURL && !config.url.startsWith('http')) {
-            fullUrl = `${config.baseURL}${config.url.startsWith('/') ? '' : '/'}${config.url}`;
-        }
-
-        // Log the request that WOULD have been made
-        const logEntry = {
-            operation: 'HTTP_REQUEST',
-            method: (config.method || 'GET').toUpperCase(),
-            url: fullUrl,
-            baseURL: config.baseURL,
-            path: config.url,
-            service: detectService(config.baseURL || fullUrl),
-            headers: sanitizeHeaders(config.headers),
-            timestamp: new Date().toISOString(),
-        };
-
-        // Include request data for write operations
-        if (config.data && ['POST', 'PUT', 'PATCH'].includes(logEntry.method)) {
-            logEntry.data = sanitizeData(config.data);
-        }
-
-        // Include query params
-        if (config.params) {
-            logEntry.params = sanitizeData(config.params);
-        }
-
-        operationLog.push(logEntry);
-
-        // Return mock response
-        return {
-            status: 200,
-            statusText: 'OK (Dry-Run)',
-            data: {
-                _dryRun: true,
-                _message: 'This is a dry-run mock response',
-                _wouldHaveExecuted: `${logEntry.method} ${fullUrl}`,
-                _service: logEntry.service,
-            },
-            headers: {
-                'content-type': 'application/json',
-                'x-dry-run': 'true',
-            },
-            config,
-        };
-    };
-
-    // Return axios-compatible interface
-    return {
-        request: mockRequest,
-        get: (url, config = {}) => mockRequest({ ...config, method: 'GET', url }),
-        post: (url, data, config = {}) => mockRequest({ ...config, method: 'POST', url, data }),
-        put: (url, data, config = {}) => mockRequest({ ...config, method: 'PUT', url, data }),
-        patch: (url, data, config = {}) =>
-            mockRequest({ ...config, method: 'PATCH', url, data }),
-        delete: (url, config = {}) => mockRequest({ ...config, method: 'DELETE', url }),
-        head: (url, config = {}) => mockRequest({ ...config, method: 'HEAD', url }),
-        options: (url, config = {}) => mockRequest({ ...config, method: 'OPTIONS', url }),
-
-        // Axios-specific properties
-        defaults: {
-            headers: {
-                common: {},
-                get: {},
-                post: {},
-                put: {},
-                patch: {},
-                delete: {},
-            },
-        },
-
-        // Interceptors (no-op in dry-run)
-        interceptors: {
-            request: { use: () => {}, eject: () => {} },
-            response: { use: () => {}, eject: () => {} },
-        },
-    };
-}
-
-/**
- * Inject dry-run HTTP client into an integration instance
- *
- * @param {Object} integrationInstance - Integration instance from integrationFactory
- * @param {Object} dryRunHttpClient - Dry-run HTTP client
- */
-function injectDryRunHttpClient(integrationInstance, dryRunHttpClient) {
-    if (!integrationInstance) {
-        return;
-    }
-
-    // Inject into primary API module
-    if (integrationInstance.primary?.api) {
-        injectIntoApiModule(integrationInstance.primary.api, dryRunHttpClient);
-    }
-
-    // Inject into target API module
-    if (integrationInstance.target?.api) {
-        injectIntoApiModule(integrationInstance.target.api, dryRunHttpClient);
-    }
-}
-
-/**
- * Inject dry-run HTTP client into an API module
- * @param {Object} apiModule - API module instance
- * @param {Object} dryRunHttpClient - Dry-run HTTP client
- */
-function injectIntoApiModule(apiModule, dryRunHttpClient) {
-    // Common property names for HTTP clients in API modules
-    const httpClientProps = [
-        '_httpClient',
-        'httpClient',
-        'client',
-        'axios',
-        'request',
-        'api',
-        'http',
-    ];
-
-    for (const prop of httpClientProps) {
-        if (apiModule[prop] && typeof apiModule[prop] === 'object') {
-            apiModule[prop] = dryRunHttpClient;
-        }
-    }
-
-    // Also check if the API module itself has request methods
-    if (typeof apiModule.request === 'function') {
-        Object.assign(apiModule, dryRunHttpClient);
-    }
-}
-
-module.exports = {
-    createDryRunHttpClient,
-    injectDryRunHttpClient,
-    sanitizeHeaders,
-    sanitizeData,
-    detectService,
-};