@friggframework/admin-scripts 2.0.0--canary.517.f04156f.0 → 2.0.0--canary.517.300ded3.0

package/src/application/__tests__/dry-run-repository-wrapper.test.js

@@ -1,257 +0,0 @@
-const { createDryRunWrapper, wrapAdminFriggCommandsForDryRun, sanitizeArgs } = require('../dry-run-repository-wrapper');
-
-describe('Dry-Run Repository Wrapper', () => {
-    describe('createDryRunWrapper', () => {
-        let mockRepository;
-        let operationLog;
-
-        beforeEach(() => {
-            operationLog = [];
-            mockRepository = {
-                // Read operations
-                findById: jest.fn(async (id) => ({ id, name: 'Test Entity' })),
-                findAll: jest.fn(async () => [{ id: '1' }, { id: '2' }]),
-                getStatus: jest.fn(() => 'active'),
-
-                // Write operations
-                create: jest.fn(async (data) => ({ id: 'new-id', ...data })),
-                update: jest.fn(async (id, data) => ({ id, ...data })),
-                delete: jest.fn(async (id) => ({ deletedCount: 1 })),
-                updateStatus: jest.fn(async (id, status) => ({ id, status })),
-            };
-        });
-
-        test('should pass through read operations unchanged', async () => {
-            const wrapped = createDryRunWrapper(mockRepository, operationLog, 'TestModel');
-
-            // Call read operations
-            const byId = await wrapped.findById('123');
-            const all = await wrapped.findAll();
-            const status = wrapped.getStatus();
-
-            // Verify original methods were called
-            expect(mockRepository.findById).toHaveBeenCalledWith('123');
-            expect(mockRepository.findAll).toHaveBeenCalled();
-            expect(mockRepository.getStatus).toHaveBeenCalled();
-
-            // Verify results match
-            expect(byId).toEqual({ id: '123', name: 'Test Entity' });
-            expect(all).toHaveLength(2);
-            expect(status).toBe('active');
-
-            // No operations should be logged
-            expect(operationLog).toHaveLength(0);
-        });
-
-        test('should intercept and log write operations', async () => {
-            const wrapped = createDryRunWrapper(mockRepository, operationLog, 'TestModel');
-
-            // Call write operations
-            await wrapped.create({ name: 'New Entity' });
-            await wrapped.update('123', { name: 'Updated' });
-            await wrapped.delete('456');
-
-            // Original write methods should NOT be called
-            expect(mockRepository.create).not.toHaveBeenCalled();
-            expect(mockRepository.update).not.toHaveBeenCalled();
-            expect(mockRepository.delete).not.toHaveBeenCalled();
-
-            // All operations should be logged
-            expect(operationLog).toHaveLength(3);
-
-            expect(operationLog[0]).toMatchObject({
-                operation: 'CREATE',
-                model: 'TestModel',
-                method: 'create',
-            });
-
-            expect(operationLog[1]).toMatchObject({
-                operation: 'UPDATE',
-                model: 'TestModel',
-                method: 'update',
-            });
-
-            expect(operationLog[2]).toMatchObject({
-                operation: 'DELETE',
-                model: 'TestModel',
-                method: 'delete',
-            });
-        });
-
-        test('should return mock data for create operations', async () => {
-            const wrapped = createDryRunWrapper(mockRepository, operationLog, 'TestModel');
-
-            const result = await wrapped.create({ name: 'Test', value: 42 });
-
-            expect(result).toMatchObject({
-                name: 'Test',
-                value: 42,
-                _dryRun: true,
-            });
-
-            expect(result.id).toMatch(/^dry-run-/);
-            expect(result.createdAt).toBeDefined();
-        });
-
-        test('should return mock data for update operations', async () => {
-            const wrapped = createDryRunWrapper(mockRepository, operationLog, 'TestModel');
-
-            const result = await wrapped.update('123', { status: 'inactive' });
-
-            expect(result).toMatchObject({
-                id: '123',
-                status: 'inactive',
-                _dryRun: true,
-            });
-        });
-
-        test('should return mock data for delete operations', async () => {
-            const wrapped = createDryRunWrapper(mockRepository, operationLog, 'TestModel');
-
-            const result = await wrapped.delete('123');
-
-            expect(result).toEqual({
-                deletedCount: 1,
-                _dryRun: true,
-            });
-        });
-
-        test('should try to return existing data for updates when possible', async () => {
-            const wrapped = createDryRunWrapper(mockRepository, operationLog, 'TestModel');
-
-            const result = await wrapped.updateStatus('123', 'inactive');
-
-            // Should attempt to read existing data
-            expect(mockRepository.findById).toHaveBeenCalledWith('123');
-
-            // If found, should return existing merged with updates
-            expect(result.id).toBe('123');
-        });
-    });
-
-    describe('sanitizeArgs', () => {
-        test('should redact sensitive fields in objects', () => {
-            const args = [
-                {
-                    id: '123',
-                    password: 'secret123',
-                    token: 'abc-def-ghi',
-                    apiKey: 'sk_live_123',
-                    name: 'Test User',
-                },
-            ];
-
-            const sanitized = sanitizeArgs(args);
-
-            expect(sanitized[0]).toEqual({
-                id: '123',
-                password: '[REDACTED]',
-                token: '[REDACTED]',
-                apiKey: '[REDACTED]',
-                name: 'Test User',
-            });
-        });
-
-        test('should handle nested objects', () => {
-            const args = [
-                {
-                    user: {
-                        name: 'Test',
-                        credentials: {
-                            password: 'secret',
-                            apiToken: 'token123',
-                        },
-                    },
-                },
-            ];
-
-            const sanitized = sanitizeArgs(args);
-
-            expect(sanitized[0].user.name).toBe('Test');
-            expect(sanitized[0].user.credentials.password).toBe('[REDACTED]');
-            expect(sanitized[0].user.credentials.apiToken).toBe('[REDACTED]');
-        });
-
-        test('should handle arrays', () => {
-            const args = [
-                [
-                    { id: '1', token: 'abc' },
-                    { id: '2', secret: 'xyz' },
-                ],
-            ];
-
-            const sanitized = sanitizeArgs(args);
-
-            expect(sanitized[0][0].token).toBe('[REDACTED]');
-            expect(sanitized[0][1].secret).toBe('[REDACTED]');
-        });
-
-        test('should preserve primitives', () => {
-            const args = ['string', 123, true, null, undefined];
-            const sanitized = sanitizeArgs(args);
-
-            expect(sanitized).toEqual(['string', 123, true, null, undefined]);
-        });
-    });
-
-    describe('wrapAdminFriggCommandsForDryRun', () => {
-        let mockCommands;
-        let operationLog;
-
-        beforeEach(() => {
-            operationLog = [];
-            mockCommands = {
-                // Read operations
-                findIntegrationById: jest.fn(async (id) => ({ id, status: 'active' })),
-                listIntegrations: jest.fn(async () => []),
-
-                // Write operations
-                updateIntegrationConfig: jest.fn(async (id, config) => ({ id, config })),
-                updateIntegrationStatus: jest.fn(async (id, status) => ({ id, status })),
-                updateCredential: jest.fn(async (id, updates) => ({ id, ...updates })),
-
-                // Other methods
-                log: jest.fn(),
-            };
-        });
-
-        test('should pass through read operations', async () => {
-            const wrapped = wrapAdminFriggCommandsForDryRun(mockCommands, operationLog);
-
-            const integration = await wrapped.findIntegrationById('123');
-            const list = await wrapped.listIntegrations();
-
-            expect(mockCommands.findIntegrationById).toHaveBeenCalledWith('123');
-            expect(mockCommands.listIntegrations).toHaveBeenCalled();
-
-            expect(integration.id).toBe('123');
-            expect(operationLog).toHaveLength(0);
-        });
-
-        test('should intercept write operations', async () => {
-            const wrapped = wrapAdminFriggCommandsForDryRun(mockCommands, operationLog);
-
-            await wrapped.updateIntegrationConfig('123', { setting: 'value' });
-            await wrapped.updateIntegrationStatus('456', 'inactive');
-
-            expect(mockCommands.updateIntegrationConfig).not.toHaveBeenCalled();
-            expect(mockCommands.updateIntegrationStatus).not.toHaveBeenCalled();
-
-            expect(operationLog).toHaveLength(2);
-            expect(operationLog[0].operation).toBe('UPDATEINTEGRATIONCONFIG');
-            expect(operationLog[1].operation).toBe('UPDATEINTEGRATIONSTATUS');
-        });
-
-        test('should return existing data for known update methods', async () => {
-            const wrapped = wrapAdminFriggCommandsForDryRun(mockCommands, operationLog);
-
-            const result = await wrapped.updateIntegrationConfig('123', { new: 'config' });
-
-            // Should have tried to fetch existing
-            expect(mockCommands.findIntegrationById).toHaveBeenCalledWith('123');
-
-            // Should return existing data
-            expect(result.id).toBe('123');
-        });
-    });
-});

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