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

package/src/application/__tests__/admin-script-base.test.js

@@ -0,0 +1,273 @@
+const { AdminScriptBase } = require('../admin-script-base');
+
+describe('AdminScriptBase', () => {
+    describe('Static Definition pattern', () => {
+        it('should have a default Definition', () => {
+            expect(AdminScriptBase.Definition).toBeDefined();
+            expect(AdminScriptBase.Definition.name).toBe('Script Name');
+            expect(AdminScriptBase.Definition.version).toBe('0.0.0');
+            expect(AdminScriptBase.Definition.description).toBe(
+                'What this script does'
+            );
+            expect(AdminScriptBase.Definition.source).toBe('USER_DEFINED');
+        });
+
+        it('should allow child classes to override Definition', () => {
+            class TestScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'test-script',
+                    version: '1.0.0',
+                    description: 'A test script',
+                    source: 'BUILTIN',
+                    inputSchema: { type: 'object' },
+                    outputSchema: { type: 'object' },
+                    schedule: {
+                        enabled: true,
+                        cronExpression: 'cron(0 12 * * ? *)',
+                    },
+                    config: {
+                        timeout: 600000,
+                        maxRetries: 3,
+                        requiresIntegrationFactory: true,
+                    },
+                    display: {
+                        label: 'Test Script',
+                        description: 'For testing',
+                        category: 'testing',
+                    },
+                };
+            }
+
+            expect(TestScript.Definition.name).toBe('test-script');
+            expect(TestScript.Definition.version).toBe('1.0.0');
+            expect(TestScript.Definition.description).toBe('A test script');
+            expect(TestScript.Definition.source).toBe('BUILTIN');
+            expect(TestScript.Definition.schedule.enabled).toBe(true);
+            expect(TestScript.Definition.config.timeout).toBe(600000);
+        });
+    });
+
+    describe('Static methods', () => {
+        it('getName() should return the script name', () => {
+            class TestScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'my-script',
+                    version: '1.0.0',
+                    description: 'test',
+                };
+            }
+
+            expect(TestScript.getName()).toBe('my-script');
+        });
+
+        it('getCurrentVersion() should return the version', () => {
+            class TestScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'my-script',
+                    version: '2.3.1',
+                    description: 'test',
+                };
+            }
+
+            expect(TestScript.getCurrentVersion()).toBe('2.3.1');
+        });
+
+        it('getDefinition() should return the full Definition', () => {
+            class TestScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'my-script',
+                    version: '1.0.0',
+                    description: 'test',
+                    source: 'USER_DEFINED',
+                };
+            }
+
+            const definition = TestScript.getDefinition();
+            expect(definition).toEqual({
+                name: 'my-script',
+                version: '1.0.0',
+                description: 'test',
+                source: 'USER_DEFINED',
+            });
+        });
+    });
+
+    describe('Constructor', () => {
+        it('should initialize with default values', () => {
+            const script = new AdminScriptBase();
+
+            expect(script.executionId).toBeNull();
+            expect(script.logs).toEqual([]);
+            expect(script._startTime).toBeNull();
+            expect(script.integrationFactory).toBeNull();
+        });
+
+        it('should accept executionId parameter', () => {
+            const script = new AdminScriptBase({ executionId: 'exec_123' });
+
+            expect(script.executionId).toBe('exec_123');
+        });
+
+        it('should accept integrationFactory parameter', () => {
+            const mockFactory = { mock: true };
+            const script = new AdminScriptBase({
+                integrationFactory: mockFactory,
+            });
+
+            expect(script.integrationFactory).toBe(mockFactory);
+        });
+
+        it('should accept both executionId and integrationFactory', () => {
+            const mockFactory = { mock: true };
+            const script = new AdminScriptBase({
+                executionId: 'exec_456',
+                integrationFactory: mockFactory,
+            });
+
+            expect(script.executionId).toBe('exec_456');
+            expect(script.integrationFactory).toBe(mockFactory);
+        });
+    });
+
+    describe('execute()', () => {
+        it('should throw error when not implemented by subclass', async () => {
+            const script = new AdminScriptBase();
+
+            await expect(script.execute({}, {})).rejects.toThrow(
+                'AdminScriptBase.execute() must be implemented by subclass'
+            );
+        });
+
+        it('should allow child classes to implement execute()', async () => {
+            class TestScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'test',
+                    version: '1.0.0',
+                    description: 'test',
+                };
+
+                async execute(frigg, params) {
+                    return { result: 'success', params };
+                }
+            }
+
+            const script = new TestScript();
+            const frigg = {};
+            const params = { foo: 'bar' };
+
+            const result = await script.execute(frigg, params);
+
+            expect(result.result).toBe('success');
+            expect(result.params).toEqual({ foo: 'bar' });
+        });
+    });
+
+    describe('Logging methods', () => {
+        it('log() should create log entry with timestamp', () => {
+            const script = new AdminScriptBase();
+            const beforeTime = new Date().toISOString();
+
+            const entry = script.log('info', 'Test message', { key: 'value' });
+
+            const afterTime = new Date().toISOString();
+
+            expect(entry.level).toBe('info');
+            expect(entry.message).toBe('Test message');
+            expect(entry.data).toEqual({ key: 'value' });
+            expect(entry.timestamp).toBeDefined();
+            expect(entry.timestamp >= beforeTime).toBe(true);
+            expect(entry.timestamp <= afterTime).toBe(true);
+        });
+
+        it('log() should add entry to logs array', () => {
+            const script = new AdminScriptBase();
+
+            script.log('info', 'First');
+            script.log('error', 'Second');
+            script.log('warn', 'Third');
+
+            const logs = script.getLogs();
+
+            expect(logs).toHaveLength(3);
+            expect(logs[0].message).toBe('First');
+            expect(logs[1].message).toBe('Second');
+            expect(logs[2].message).toBe('Third');
+        });
+
+        it('log() should default data to empty object', () => {
+            const script = new AdminScriptBase();
+
+            const entry = script.log('info', 'No data');
+
+            expect(entry.data).toEqual({});
+        });
+
+        it('getLogs() should return logs array', () => {
+            const script = new AdminScriptBase();
+
+            script.log('info', 'Message 1');
+            script.log('error', 'Message 2');
+
+            const logs = script.getLogs();
+
+            expect(logs).toHaveLength(2);
+            expect(logs[0].level).toBe('info');
+            expect(logs[1].level).toBe('error');
+        });
+
+        it('clearLogs() should empty logs array', () => {
+            const script = new AdminScriptBase();
+
+            script.log('info', 'Message 1');
+            script.log('info', 'Message 2');
+            expect(script.getLogs()).toHaveLength(2);
+
+            script.clearLogs();
+
+            expect(script.getLogs()).toHaveLength(0);
+        });
+    });
+
+    describe('Integration with child classes', () => {
+        it('should support full lifecycle', async () => {
+            class MyScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'my-script',
+                    version: '1.0.0',
+                    description: 'My test script',
+                    config: {
+                        requiresIntegrationFactory: true,
+                    },
+                };
+
+                async execute(frigg, params) {
+                    this.log('info', 'Starting execution');
+                    this.log('debug', 'Processing', params);
+
+                    if (this.integrationFactory) {
+                        this.log('info', 'Integration factory available');
+                    }
+
+                    return { processed: true };
+                }
+            }
+
+            const mockFactory = { getInstanceById: jest.fn() };
+            const script = new MyScript({
+                executionId: 'exec_789',
+                integrationFactory: mockFactory,
+            });
+
+            const frigg = {};
+            const result = await script.execute(frigg, { test: 'data' });
+
+            expect(result).toEqual({ processed: true });
+
+            const logs = script.getLogs();
+            expect(logs).toHaveLength(3);
+            expect(logs[0].message).toBe('Starting execution');
+            expect(logs[1].message).toBe('Processing');
+            expect(logs[2].message).toBe('Integration factory available');
+        });
+    });
+});

package/src/application/__tests__/dry-run-http-interceptor.test.js

@@ -0,0 +1,313 @@
+const {
+    createDryRunHttpClient,
+    injectDryRunHttpClient,
+    sanitizeHeaders,
+    sanitizeData,
+    detectService,
+} = require('../dry-run-http-interceptor');
+
+describe('Dry-Run HTTP Interceptor', () => {
+    describe('sanitizeHeaders', () => {
+        test('should redact authorization headers', () => {
+            const headers = {
+                'Content-Type': 'application/json',
+                Authorization: 'Bearer secret-token',
+                'X-API-Key': 'api-key-123',
+                'User-Agent': 'frigg/1.0',
+            };
+
+            const sanitized = sanitizeHeaders(headers);
+
+            expect(sanitized['Content-Type']).toBe('application/json');
+            expect(sanitized['User-Agent']).toBe('frigg/1.0');
+            expect(sanitized.Authorization).toBe('[REDACTED]');
+            expect(sanitized['X-API-Key']).toBe('[REDACTED]');
+        });
+
+        test('should handle case variations', () => {
+            const headers = {
+                authorization: 'Bearer token',
+                Authorization: 'Bearer token',
+                'x-api-key': 'key1',
+                'X-API-Key': 'key2',
+            };
+
+            const sanitized = sanitizeHeaders(headers);
+
+            expect(sanitized.authorization).toBe('[REDACTED]');
+            expect(sanitized.Authorization).toBe('[REDACTED]');
+            expect(sanitized['x-api-key']).toBe('[REDACTED]');
+            expect(sanitized['X-API-Key']).toBe('[REDACTED]');
+        });
+
+        test('should handle null/undefined', () => {
+            expect(sanitizeHeaders(null)).toEqual({});
+            expect(sanitizeHeaders(undefined)).toEqual({});
+            expect(sanitizeHeaders({})).toEqual({});
+        });
+    });
+
+    describe('detectService', () => {
+        test('should detect CRM services', () => {
+            expect(detectService('https://api.hubapi.com')).toBe('HubSpot');
+            expect(detectService('https://login.salesforce.com')).toBe('Salesforce');
+            expect(detectService('https://api.pipedrive.com')).toBe('Pipedrive');
+            expect(detectService('https://api.attio.com')).toBe('Attio');
+        });
+
+        test('should detect communication services', () => {
+            expect(detectService('https://slack.com/api')).toBe('Slack');
+            expect(detectService('https://discord.com/api')).toBe('Discord');
+            expect(detectService('https://graph.teams.microsoft.com')).toBe('Microsoft Teams');
+        });
+
+        test('should detect project management tools', () => {
+            expect(detectService('https://app.asana.com/api')).toBe('Asana');
+            expect(detectService('https://api.monday.com')).toBe('Monday.com');
+            expect(detectService('https://api.trello.com')).toBe('Trello');
+        });
+
+        test('should return unknown for unrecognized services', () => {
+            expect(detectService('https://example.com/api')).toBe('unknown');
+            expect(detectService(null)).toBe('unknown');
+            expect(detectService(undefined)).toBe('unknown');
+        });
+
+        test('should be case insensitive', () => {
+            expect(detectService('HTTPS://API.HUBSPOT.COM')).toBe('HubSpot');
+            expect(detectService('https://API.SLACK.COM')).toBe('Slack');
+        });
+    });
+
+    describe('sanitizeData', () => {
+        test('should redact sensitive fields', () => {
+            const data = {
+                name: 'Test User',
+                email: 'test@example.com',
+                password: 'secret123',
+                apiToken: 'token-abc',
+                authKey: 'key-xyz',
+            };
+
+            const sanitized = sanitizeData(data);
+
+            expect(sanitized.name).toBe('Test User');
+            expect(sanitized.email).toBe('test@example.com');
+            expect(sanitized.password).toBe('[REDACTED]');
+            expect(sanitized.apiToken).toBe('[REDACTED]');
+            expect(sanitized.authKey).toBe('[REDACTED]');
+        });
+
+        test('should handle nested objects', () => {
+            const data = {
+                user: {
+                    name: 'Test',
+                    credentials: {
+                        password: 'secret',
+                        token: 'abc123',
+                    },
+                },
+            };
+
+            const sanitized = sanitizeData(data);
+
+            expect(sanitized.user.name).toBe('Test');
+            expect(sanitized.user.credentials.password).toBe('[REDACTED]');
+            expect(sanitized.user.credentials.token).toBe('[REDACTED]');
+        });
+
+        test('should handle arrays', () => {
+            const data = [
+                { id: '1', password: 'secret1' },
+                { id: '2', apiKey: 'key2' },
+            ];
+
+            const sanitized = sanitizeData(data);
+
+            expect(sanitized[0].id).toBe('1');
+            expect(sanitized[0].password).toBe('[REDACTED]');
+            expect(sanitized[1].apiKey).toBe('[REDACTED]');
+        });
+
+        test('should preserve primitives', () => {
+            expect(sanitizeData('string')).toBe('string');
+            expect(sanitizeData(123)).toBe(123);
+            expect(sanitizeData(true)).toBe(true);
+            expect(sanitizeData(null)).toBe(null);
+            expect(sanitizeData(undefined)).toBe(undefined);
+        });
+    });
+
+    describe('createDryRunHttpClient', () => {
+        let operationLog;
+
+        beforeEach(() => {
+            operationLog = [];
+        });
+
+        test('should log GET requests', async () => {
+            const client = createDryRunHttpClient(operationLog);
+
+            const response = await client.get('/contacts', {
+                baseURL: 'https://api.hubapi.com',
+                headers: { Authorization: 'Bearer token' },
+            });
+
+            expect(operationLog).toHaveLength(1);
+            expect(operationLog[0]).toMatchObject({
+                operation: 'HTTP_REQUEST',
+                method: 'GET',
+                url: 'https://api.hubapi.com/contacts',
+                service: 'HubSpot',
+            });
+
+            expect(operationLog[0].headers.Authorization).toBe('[REDACTED]');
+            expect(response.data._dryRun).toBe(true);
+        });
+
+        test('should log POST requests with data', async () => {
+            const client = createDryRunHttpClient(operationLog);
+
+            const postData = {
+                name: 'John Doe',
+                email: 'john@example.com',
+                password: 'secret123',
+            };
+
+            await client.post('/users', postData, {
+                baseURL: 'https://api.example.com',
+            });
+
+            expect(operationLog).toHaveLength(1);
+            expect(operationLog[0].method).toBe('POST');
+            expect(operationLog[0].data.name).toBe('John Doe');
+            expect(operationLog[0].data.email).toBe('john@example.com');
+            expect(operationLog[0].data.password).toBe('[REDACTED]');
+        });
+
+        test('should log PUT requests', async () => {
+            const client = createDryRunHttpClient(operationLog);
+
+            await client.put('/users/123', { status: 'active' }, {
+                baseURL: 'https://api.example.com',
+            });
+
+            expect(operationLog).toHaveLength(1);
+            expect(operationLog[0].method).toBe('PUT');
+            expect(operationLog[0].data.status).toBe('active');
+        });
+
+        test('should log PATCH requests', async () => {
+            const client = createDryRunHttpClient(operationLog);
+
+            await client.patch('/users/123', { name: 'Updated' });
+
+            expect(operationLog).toHaveLength(1);
+            expect(operationLog[0].method).toBe('PATCH');
+        });
+
+        test('should log DELETE requests', async () => {
+            const client = createDryRunHttpClient(operationLog);
+
+            await client.delete('/users/123', {
+                baseURL: 'https://api.example.com',
+            });
+
+            expect(operationLog).toHaveLength(1);
+            expect(operationLog[0].method).toBe('DELETE');
+        });
+
+        test('should return mock response', async () => {
+            const client = createDryRunHttpClient(operationLog);
+
+            const response = await client.get('/test');
+
+            expect(response.status).toBe(200);
+            expect(response.statusText).toContain('Dry-Run');
+            expect(response.data._dryRun).toBe(true);
+            expect(response.headers['x-dry-run']).toBe('true');
+        });
+
+        test('should include query params in log', async () => {
+            const client = createDryRunHttpClient(operationLog);
+
+            await client.get('/search', {
+                baseURL: 'https://api.example.com',
+                params: { q: 'test', limit: 10 },
+            });
+
+            expect(operationLog[0].params).toEqual({ q: 'test', limit: 10 });
+        });
+    });
+
+    describe('injectDryRunHttpClient', () => {
+        let operationLog;
+        let dryRunClient;
+
+        beforeEach(() => {
+            operationLog = [];
+            dryRunClient = createDryRunHttpClient(operationLog);
+        });
+
+        test('should inject into primary API module', () => {
+            const integrationInstance = {
+                primary: {
+                    api: {
+                        _httpClient: { get: jest.fn() },
+                    },
+                },
+            };
+
+            injectDryRunHttpClient(integrationInstance, dryRunClient);
+
+            expect(integrationInstance.primary.api._httpClient).toBe(dryRunClient);
+        });
+
+        test('should inject into target API module', () => {
+            const integrationInstance = {
+                target: {
+                    api: {
+                        _httpClient: { get: jest.fn() },
+                    },
+                },
+            };
+
+            injectDryRunHttpClient(integrationInstance, dryRunClient);
+
+            expect(integrationInstance.target.api._httpClient).toBe(dryRunClient);
+        });
+
+        test('should inject into both primary and target', () => {
+            const integrationInstance = {
+                primary: {
+                    api: { _httpClient: { get: jest.fn() } },
+                },
+                target: {
+                    api: { _httpClient: { get: jest.fn() } },
+                },
+            };
+
+            injectDryRunHttpClient(integrationInstance, dryRunClient);
+
+            expect(integrationInstance.primary.api._httpClient).toBe(dryRunClient);
+            expect(integrationInstance.target.api._httpClient).toBe(dryRunClient);
+        });
+
+        test('should handle missing api modules gracefully', () => {
+            const integrationInstance = {
+                primary: {},
+                target: null,
+            };
+
+            expect(() => {
+                injectDryRunHttpClient(integrationInstance, dryRunClient);
+            }).not.toThrow();
+        });
+
+        test('should handle null integration instance', () => {
+            expect(() => {
+                injectDryRunHttpClient(null, dryRunClient);
+            }).not.toThrow();
+        });
+    });
+});