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

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

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

@@ -1,261 +0,0 @@
-/**
- * Dry-Run Repository Wrapper
- *
- * Wraps any repository to intercept write operations.
- * - READ operations pass through unchanged
- * - WRITE operations are logged but not executed
- *
- * Uses Proxy pattern for dynamic method interception
- */
-
-/**
- * Create a dry-run wrapper for any repository
- *
- * @param {Object} repository - The real repository to wrap
- * @param {Array} operationLog - Array to append logged operations
- * @param {string} modelName - Name of the model (for logging)
- * @returns {Proxy} Wrapped repository that logs write operations
- */
-function createDryRunWrapper(repository, operationLog, modelName) {
-    return new Proxy(repository, {
-        get(target, prop) {
-            const value = target[prop];
-
-            // Return non-function properties as-is
-            if (typeof value !== 'function') {
-                return value;
-            }
-
-            // Identify write operations by name pattern
-            const writePatterns = /^(create|update|delete|upsert|append|remove|insert|save)/i;
-            const isWrite = writePatterns.test(prop);
-
-            // Pass through read operations
-            if (!isWrite) {
-                return value.bind(target);
-            }
-
-            // Wrap write operation
-            return async (...args) => {
-                // Log the operation that WOULD have been performed
-                operationLog.push({
-                    operation: prop.toUpperCase(),
-                    model: modelName,
-                    method: prop,
-                    args: sanitizeArgs(args),
-                    timestamp: new Date().toISOString(),
-                    wouldExecute: `${modelName}.${prop}()`,
-                });
-
-                // For write operations, try to return existing data or mock data
-                // This helps scripts continue executing without errors
-
-                // For updates, try to return existing data
-                if (prop.includes('update') || prop.includes('upsert')) {
-                    // Try to extract ID from first argument
-                    const possibleId = args[0];
-                    let existing = null;
-
-                    if (possibleId && typeof possibleId === 'string') {
-                        // Try to find existing record
-                        const findMethod = getFindMethod(target, prop);
-                        if (findMethod) {
-                            try {
-                                existing = await findMethod.call(target, possibleId);
-                            } catch (err) {
-                                // Ignore errors, continue to mock
-                            }
-                        }
-                    }
-
-                    // Return merged data
-                    if (existing) {
-                        // Merge update data with existing
-                        return { ...existing, ...args[1], _dryRun: true };
-                    }
-
-                    // No existing data, return mock
-                    if (args[1]) {
-                        return { id: possibleId, ...args[1], _dryRun: true };
-                    }
-
-                    return { id: possibleId, _dryRun: true };
-                }
-
-                // For creates, return mock object with the data
-                if (prop.includes('create') || prop.includes('insert')) {
-                    const data = args[0] || {};
-                    return {
-                        id: `dry-run-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-                        ...data,
-                        _dryRun: true,
-                        createdAt: new Date().toISOString(),
-                    };
-                }
-
-                // For deletes, return success indication
-                if (prop.includes('delete') || prop.includes('remove')) {
-                    return { deletedCount: 1, _dryRun: true };
-                }
-
-                // Default: return mock success
-                return { success: true, _dryRun: true };
-            };
-        },
-    });
-}
-
-/**
- * Try to find a corresponding find method for an update operation
- * @param {Object} target - Repository target
- * @param {string} updateMethod - Update method name
- * @returns {Function|null} Find method or null
- */
-function getFindMethod(target, updateMethod) {
-    // Common patterns: updateIntegration -> findIntegrationById
-    const patterns = [
-        () => {
-            const match = updateMethod.match(/update(\w+)/i);
-            return match ? `find${match[1]}ById` : null;
-        },
-        () => {
-            const match = updateMethod.match(/update(\w+)/i);
-            return match ? `get${match[1]}ById` : null;
-        },
-        () => 'findById',
-        () => 'getById',
-    ];
-
-    for (const pattern of patterns) {
-        const methodName = pattern();
-        if (methodName && typeof target[methodName] === 'function') {
-            return target[methodName];
-        }
-    }
-
-    return null;
-}
-
-/**
- * Sanitize arguments for logging (remove sensitive data)
- * @param {Array} args - Function arguments
- * @returns {Array} Sanitized arguments
- */
-function sanitizeArgs(args) {
-    return args.map((arg) => {
-        if (arg === null || arg === undefined) {
-            return arg;
-        }
-
-        if (typeof arg !== 'object') {
-            return arg;
-        }
-
-        if (Array.isArray(arg)) {
-            return arg.map((item) => sanitizeArgs([item])[0]);
-        }
-
-        // Sanitize object - remove sensitive fields
-        const sanitized = {};
-        for (const [key, value] of Object.entries(arg)) {
-            const lowerKey = key.toLowerCase();
-
-            // Skip sensitive fields
-            if (
-                lowerKey.includes('password') ||
-                lowerKey.includes('token') ||
-                lowerKey.includes('secret') ||
-                lowerKey.includes('key') ||
-                lowerKey.includes('auth')
-            ) {
-                sanitized[key] = '[REDACTED]';
-                continue;
-            }
-
-            // Recursively sanitize nested objects
-            if (typeof value === 'object' && value !== null) {
-                sanitized[key] = sanitizeArgs([value])[0];
-            } else {
-                sanitized[key] = value;
-            }
-        }
-
-        return sanitized;
-    });
-}
-
-/**
- * Wrap AdminFriggCommands for dry-run mode
- *
- * @param {Object} realCommands - Real AdminFriggCommands instance
- * @param {Array} operationLog - Array to append logged operations
- * @returns {Object} Wrapped commands with dry-run repository wrappers
- */
-function wrapAdminFriggCommandsForDryRun(realCommands, operationLog) {
-    return new Proxy(realCommands, {
-        get(target, prop) {
-            const value = target[prop];
-
-            // Pass through non-functions
-            if (typeof value !== 'function') {
-                // For lazy-loaded repositories, wrap them
-                if (prop.endsWith('Repository') && value && typeof value === 'object') {
-                    const modelName = prop.replace('Repository', '');
-                    return createDryRunWrapper(
-                        value,
-                        operationLog,
-                        modelName.charAt(0).toUpperCase() + modelName.slice(1)
-                    );
-                }
-                return value;
-            }
-
-            // Identify write operations on the commands themselves
-            const writePatterns = /^(update|create|delete|append)/i;
-            const isWrite = writePatterns.test(prop);
-
-            if (!isWrite) {
-                // Read operations pass through
-                return value.bind(target);
-            }
-
-            // Wrap write operations
-            return async (...args) => {
-                operationLog.push({
-                    operation: prop.toUpperCase(),
-                    source: 'AdminFriggCommands',
-                    method: prop,
-                    args: sanitizeArgs(args),
-                    timestamp: new Date().toISOString(),
-                });
-
-                // For specific known methods, try to return sensible mocks
-                if (prop === 'updateIntegrationConfig') {
-                    const [integrationId] = args;
-                    const existing = await target.findIntegrationById(integrationId);
-                    return existing;
-                }
-
-                if (prop === 'updateIntegrationStatus') {
-                    const [integrationId] = args;
-                    const existing = await target.findIntegrationById(integrationId);
-                    return existing;
-                }
-
-                if (prop === 'updateCredential') {
-                    const [credentialId, updates] = args;
-                    return { id: credentialId, ...updates, _dryRun: true };
-                }
-
-                // Default mock
-                return { success: true, _dryRun: true };
-            };
-        },
-    });
-}
-
-module.exports = {
-    createDryRunWrapper,
-    wrapAdminFriggCommandsForDryRun,
-    sanitizeArgs,
-};