@friggframework/admin-scripts 2.0.0--canary.517.300ded3.0 → 2.0.0--canary.522.cbd3d5a.0

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

@@ -0,0 +1,257 @@
+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/__tests__/script-runner.test.js

@@ -36,9 +36,9 @@ describe('ScriptRunner', () => {
         scriptFactory = new ScriptFactory([TestScript]);
 
         mockCommands = {
-            createAdminProcess: jest.fn(),
-            updateAdminProcessState: jest.fn(),
-            completeAdminProcess: jest.fn(),
+            createScriptExecution: jest.fn(),
+            updateScriptExecutionStatus: jest.fn(),
+            completeScriptExecution: jest.fn(),
         };
 
         mockFrigg = {
@@ -49,11 +49,11 @@ describe('ScriptRunner', () => {
         createAdminScriptCommands.mockReturnValue(mockCommands);
         createAdminFriggCommands.mockReturnValue(mockFrigg);
 
-        mockCommands.createAdminProcess.mockResolvedValue({
+        mockCommands.createScriptExecution.mockResolvedValue({
             id: 'exec-123',
         });
-        mockCommands.updateAdminProcessState.mockResolvedValue({});
-        mockCommands.completeAdminProcess.mockResolvedValue({ success: true });
+        mockCommands.updateScriptExecutionStatus.mockResolvedValue({});
+        mockCommands.completeScriptExecution.mockResolvedValue({ success: true });
     });
 
     afterEach(() => {
@@ -76,7 +76,7 @@ describe('ScriptRunner', () => {
             expect(result.executionId).toBe('exec-123');
             expect(result.metrics.durationMs).toBeGreaterThanOrEqual(0);
 
-            expect(mockCommands.createAdminProcess).toHaveBeenCalledWith({
+            expect(mockCommands.createScriptExecution).toHaveBeenCalledWith({
                 scriptName: 'test-script',
                 scriptVersion: '1.0.0',
                 trigger: 'MANUAL',
@@ -85,15 +85,15 @@ describe('ScriptRunner', () => {
                 audit: { apiKeyName: 'test-key' },
             });
 
-            expect(mockCommands.updateAdminProcessState).toHaveBeenCalledWith(
+            expect(mockCommands.updateScriptExecutionStatus).toHaveBeenCalledWith(
                 'exec-123',
                 'RUNNING'
             );
 
-            expect(mockCommands.completeAdminProcess).toHaveBeenCalledWith(
+            expect(mockCommands.completeScriptExecution).toHaveBeenCalledWith(
                 'exec-123',
                 expect.objectContaining({
-                    state: 'COMPLETED',
+                    status: 'COMPLETED',
                     output: { success: true, params: { foo: 'bar' } },
                     metrics: expect.objectContaining({
                         durationMs: expect.any(Number),
@@ -128,10 +128,10 @@ describe('ScriptRunner', () => {
             expect(result.scriptName).toBe('failing-script');
             expect(result.error.message).toBe('Script failed');
 
-            expect(mockCommands.completeAdminProcess).toHaveBeenCalledWith(
+            expect(mockCommands.completeScriptExecution).toHaveBeenCalledWith(
                 'exec-123',
                 expect.objectContaining({
-                    state: 'FAILED',
+                    status: 'FAILED',
                     error: expect.objectContaining({
                         message: 'Script failed',
                     }),
@@ -178,144 +178,14 @@ describe('ScriptRunner', () => {
             });
 
             expect(result.executionId).toBe('existing-exec-456');
-            expect(mockCommands.createAdminProcess).not.toHaveBeenCalled();
-            expect(mockCommands.updateAdminProcessState).toHaveBeenCalledWith(
+            expect(mockCommands.createScriptExecution).not.toHaveBeenCalled();
+            expect(mockCommands.updateScriptExecutionStatus).toHaveBeenCalledWith(
                 'existing-exec-456',
                 'RUNNING'
             );
         });
     });
 
-    describe('dry-run mode', () => {
-        it('should return preview without executing script', async () => {
-            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
-
-            const result = await runner.execute('test-script', { foo: 'bar' }, {
-                trigger: 'MANUAL',
-                dryRun: true,
-            });
-
-            expect(result.dryRun).toBe(true);
-            expect(result.status).toBe('DRY_RUN_VALID');
-            expect(result.scriptName).toBe('test-script');
-            expect(result.preview.script.name).toBe('test-script');
-            expect(result.preview.script.version).toBe('1.0.0');
-            expect(result.preview.input).toEqual({ foo: 'bar' });
-            expect(result.message).toContain('validation passed');
-
-            // Should NOT create execution record or call commands
-            expect(mockCommands.createAdminProcess).not.toHaveBeenCalled();
-            expect(mockCommands.updateAdminProcessState).not.toHaveBeenCalled();
-            expect(mockCommands.completeAdminProcess).not.toHaveBeenCalled();
-        });
-
-        it('should validate required parameters in dry-run', async () => {
-            class SchemaScript extends AdminScriptBase {
-                static Definition = {
-                    name: 'schema-script',
-                    version: '1.0.0',
-                    description: 'Script with schema',
-                    inputSchema: {
-                        type: 'object',
-                        required: ['requiredParam'],
-                        properties: {
-                            requiredParam: { type: 'string' },
-                            optionalParam: { type: 'number' },
-                        },
-                    },
-                };
-
-                async execute() {
-                    return {};
-                }
-            }
-
-            scriptFactory.register(SchemaScript);
-            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
-
-            // Missing required parameter
-            const result = await runner.execute('schema-script', {}, {
-                dryRun: true,
-            });
-
-            expect(result.status).toBe('DRY_RUN_INVALID');
-            expect(result.preview.validation.valid).toBe(false);
-            expect(result.preview.validation.errors).toContain('Missing required parameter: requiredParam');
-        });
-
-        it('should validate parameter types in dry-run', async () => {
-            class TypedScript extends AdminScriptBase {
-                static Definition = {
-                    name: 'typed-script',
-                    version: '1.0.0',
-                    description: 'Script with typed params',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            count: { type: 'integer' },
-                            name: { type: 'string' },
-                            enabled: { type: 'boolean' },
-                        },
-                    },
-                };
-
-                async execute() {
-                    return {};
-                }
-            }
-
-            scriptFactory.register(TypedScript);
-            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
-
-            const result = await runner.execute('typed-script', {
-                count: 'not-a-number',
-                name: 123,
-                enabled: 'true',
-            }, {
-                dryRun: true,
-            });
-
-            expect(result.status).toBe('DRY_RUN_INVALID');
-            expect(result.preview.validation.errors).toHaveLength(3);
-        });
-
-        it('should pass validation with correct parameters', async () => {
-            class ValidScript extends AdminScriptBase {
-                static Definition = {
-                    name: 'valid-script',
-                    version: '1.0.0',
-                    description: 'Script for validation',
-                    inputSchema: {
-                        type: 'object',
-                        required: ['name'],
-                        properties: {
-                            name: { type: 'string' },
-                            count: { type: 'integer' },
-                        },
-                    },
-                };
-
-                async execute() {
-                    return {};
-                }
-            }
-
-            scriptFactory.register(ValidScript);
-            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
-
-            const result = await runner.execute('valid-script', {
-                name: 'test',
-                count: 42,
-            }, {
-                dryRun: true,
-            });
-
-            expect(result.status).toBe('DRY_RUN_VALID');
-            expect(result.preview.validation.valid).toBe(true);
-            expect(result.preview.validation.errors).toHaveLength(0);
-        });
-    });
-
     describe('createScriptRunner()', () => {
         it('should create runner with default factory', () => {
             const runner = createScriptRunner();

package/src/application/admin-frigg-commands.js

@@ -25,7 +25,7 @@ class AdminFriggCommands {
         this._userRepository = null;
         this._moduleRepository = null;
         this._credentialRepository = null;
-        this._adminProcessRepository = null;
+        this._scriptExecutionRepository = null;
     }
 
     // ==================== LAZY-LOADED REPOSITORIES ====================
@@ -62,12 +62,12 @@ class AdminFriggCommands {
         return this._credentialRepository;
     }
 
-    get adminProcessRepository() {
-        if (!this._adminProcessRepository) {
-            const { createAdminProcessRepository } = require('@friggframework/core/admin-scripts/repositories/admin-process-repository-factory');
-            this._adminProcessRepository = createAdminProcessRepository();
+    get scriptExecutionRepository() {
+        if (!this._scriptExecutionRepository) {
+            const { createScriptExecutionRepository } = require('@friggframework/core/admin-scripts/repositories/script-execution-repository-factory');
+            this._scriptExecutionRepository = createScriptExecutionRepository();
         }
-        return this._adminProcessRepository;
+        return this._scriptExecutionRepository;
     }
 
     // ==================== INTEGRATION QUERIES ====================
@@ -209,7 +209,7 @@ class AdminFriggCommands {
 
         // Persist to execution record if we have an executionId
         if (this.executionId) {
-            this.adminProcessRepository.appendProcessLog(this.executionId, entry)
+            this.scriptExecutionRepository.appendExecutionLog(this.executionId, entry)
                 .catch(err => console.error('Failed to persist log:', err));
         }
 

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

@@ -1,4 +1,5 @@
-const { createAdminProcessRepository } = require('@friggframework/core/admin-scripts/repositories/admin-process-repository-factory');
+const { createScriptExecutionRepository } = require('@friggframework/core/admin-scripts/repositories/script-execution-repository-factory');
+const { createAdminApiKeyRepository } = require('@friggframework/core/admin-scripts/repositories/admin-api-key-repository-factory');
 
 /**
  * Admin Script Base Class
@@ -86,7 +87,8 @@ class AdminScriptBase {
         this.integrationFactory = params.integrationFactory || null;
 
         // OPTIONAL: Injected repositories (for testing or custom implementations)
-        this.adminProcessRepository = params.adminProcessRepository || null;
+        this.scriptExecutionRepository = params.scriptExecutionRepository || null;
+        this.adminApiKeyRepository = params.adminApiKeyRepository || null;
     }
 
     /**