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

package/index.js

@@ -12,7 +12,7 @@ const { AdminFriggCommands, createAdminFriggCommands } = require('./src/applicat
 const { ScriptRunner, createScriptRunner } = require('./src/application/script-runner');
 
 // Infrastructure
-const { adminAuthMiddleware } = require('./src/infrastructure/admin-auth-middleware');
+const { validateAdminApiKey } = require('./src/infrastructure/admin-auth-middleware');
 const { router, app, handler: routerHandler } = require('./src/infrastructure/admin-script-router');
 const { handler: executorHandler } = require('./src/infrastructure/script-executor-handler');
 
@@ -45,7 +45,7 @@ module.exports = {
     createScriptRunner,
 
     // Infrastructure layer
-    adminAuthMiddleware,
+    validateAdminApiKey,
     router,
     app,
     routerHandler,

package/package.json

@@ -1,23 +1,21 @@
 {
     "name": "@friggframework/admin-scripts",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.517.f04156f.0",
+    "version": "2.0.0--canary.517.300ded3.0",
     "description": "Admin Script Runner for Frigg - Execute maintenance and operational scripts in hosted environments",
     "dependencies": {
         "@aws-sdk/client-scheduler": "^3.588.0",
-        "@friggframework/core": "2.0.0--canary.517.f04156f.0",
+        "@friggframework/core": "2.0.0--canary.517.300ded3.0",
         "bcryptjs": "^2.4.3",
         "express": "^4.18.2",
         "lodash": "4.17.21",
-        "mongoose": "6.11.6",
         "serverless-http": "^3.2.0",
         "uuid": "^9.0.1"
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.517.f04156f.0",
-        "@friggframework/prettier-config": "2.0.0--canary.517.f04156f.0",
-        "@friggframework/test": "2.0.0--canary.517.f04156f.0",
-        "chai": "^4.3.6",
+        "@friggframework/eslint-config": "2.0.0--canary.517.300ded3.0",
+        "@friggframework/prettier-config": "2.0.0--canary.517.300ded3.0",
+        "@friggframework/test": "2.0.0--canary.517.300ded3.0",
         "eslint": "^8.22.0",
         "jest": "^29.7.0",
         "prettier": "^2.7.1",
@@ -49,5 +47,5 @@
         "maintenance",
         "operations"
     ],
-    "gitHead": "f04156ff92c4e4bec35317ae6eb9cc00987cf395"
+    "gitHead": "300ded3ac35558075a081104b4b362b85cf0756f"
 }

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

@@ -5,7 +5,7 @@ jest.mock('@friggframework/core/integrations/repositories/integration-repository
 jest.mock('@friggframework/core/user/repositories/user-repository-factory');
 jest.mock('@friggframework/core/modules/repositories/module-repository-factory');
 jest.mock('@friggframework/core/credential/repositories/credential-repository-factory');
-jest.mock('@friggframework/core/admin-scripts/repositories/script-execution-repository-factory');
+jest.mock('@friggframework/core/admin-scripts/repositories/admin-process-repository-factory');
 jest.mock('@friggframework/core/queues');
 
 describe('AdminFriggCommands', () => {
@@ -13,7 +13,7 @@ describe('AdminFriggCommands', () => {
     let mockUserRepo;
     let mockModuleRepo;
     let mockCredentialRepo;
-    let mockScriptExecutionRepo;
+    let mockAdminProcessRepo;
     let mockQueuerUtil;
 
     beforeEach(() => {
@@ -46,8 +46,8 @@ describe('AdminFriggCommands', () => {
             updateCredential: jest.fn(),
         };
 
-        mockScriptExecutionRepo = {
-            appendExecutionLog: jest.fn().mockResolvedValue(undefined),
+        mockAdminProcessRepo = {
+            appendProcessLog: jest.fn().mockResolvedValue(undefined),
         };
 
         mockQueuerUtil = {
@@ -60,14 +60,14 @@ describe('AdminFriggCommands', () => {
         const { createUserRepository } = require('@friggframework/core/user/repositories/user-repository-factory');
         const { createModuleRepository } = require('@friggframework/core/modules/repositories/module-repository-factory');
         const { createCredentialRepository } = require('@friggframework/core/credential/repositories/credential-repository-factory');
-        const { createScriptExecutionRepository } = require('@friggframework/core/admin-scripts/repositories/script-execution-repository-factory');
+        const { createAdminProcessRepository } = require('@friggframework/core/admin-scripts/repositories/admin-process-repository-factory');
         const { QueuerUtil } = require('@friggframework/core/queues');
 
         createIntegrationRepository.mockReturnValue(mockIntegrationRepo);
         createUserRepository.mockReturnValue(mockUserRepo);
         createModuleRepository.mockReturnValue(mockModuleRepo);
         createCredentialRepository.mockReturnValue(mockCredentialRepo);
-        createScriptExecutionRepository.mockReturnValue(mockScriptExecutionRepo);
+        createAdminProcessRepository.mockReturnValue(mockAdminProcessRepo);
 
         // Mock QueuerUtil methods
         QueuerUtil.send = mockQueuerUtil.send;
@@ -158,16 +158,16 @@ describe('AdminFriggCommands', () => {
             expect(repo).toBe(mockCredentialRepo);
         });
 
-        it('creates scriptExecutionRepository on first access', () => {
+        it('creates adminProcessRepository on first access', () => {
             const commands = new AdminFriggCommands();
-            const { createScriptExecutionRepository } = require('@friggframework/core/admin-scripts/repositories/script-execution-repository-factory');
+            const { createAdminProcessRepository } = require('@friggframework/core/admin-scripts/repositories/admin-process-repository-factory');
 
-            expect(createScriptExecutionRepository).not.toHaveBeenCalled();
+            expect(createAdminProcessRepository).not.toHaveBeenCalled();
 
-            const repo = commands.scriptExecutionRepository;
+            const repo = commands.adminProcessRepository;
 
-            expect(createScriptExecutionRepository).toHaveBeenCalledTimes(1);
-            expect(repo).toBe(mockScriptExecutionRepo);
+            expect(createAdminProcessRepository).toHaveBeenCalledTimes(1);
+            expect(repo).toBe(mockAdminProcessRepo);
         });
     });
 
@@ -551,15 +551,15 @@ describe('AdminFriggCommands', () => {
         it('log() persists if executionId set', async () => {
             const commands = new AdminFriggCommands({ executionId: 'exec_123' });
             // Force repository creation
-            commands.scriptExecutionRepository;
+            commands.adminProcessRepository;
 
             commands.log('warn', 'Warning message', { detail: 'xyz' });
 
             // Give async operation a chance to execute
             await new Promise(resolve => setImmediate(resolve));
 
-            expect(mockScriptExecutionRepo.appendExecutionLog).toHaveBeenCalled();
-            const callArgs = mockScriptExecutionRepo.appendExecutionLog.mock.calls[0];
+            expect(mockAdminProcessRepo.appendProcessLog).toHaveBeenCalled();
+            const callArgs = mockAdminProcessRepo.appendProcessLog.mock.calls[0];
             expect(callArgs[0]).toBe('exec_123');
             expect(callArgs[1].level).toBe('warn');
             expect(callArgs[1].message).toBe('Warning message');
@@ -572,14 +572,14 @@ describe('AdminFriggCommands', () => {
 
             await new Promise(resolve => setImmediate(resolve));
 
-            expect(mockScriptExecutionRepo.appendExecutionLog).not.toHaveBeenCalled();
+            expect(mockAdminProcessRepo.appendProcessLog).not.toHaveBeenCalled();
         });
 
         it('log() handles persistence failure gracefully', async () => {
             const commands = new AdminFriggCommands({ executionId: 'exec_123' });
             // Force repository creation
-            commands.scriptExecutionRepository;
-            mockScriptExecutionRepo.appendExecutionLog.mockRejectedValue(new Error('DB Error'));
+            commands.adminProcessRepository;
+            mockAdminProcessRepo.appendProcessLog.mockRejectedValue(new Error('DB Error'));
 
             // Should not throw
             expect(() => commands.log('error', 'Test error')).not.toThrow();

package/src/application/__tests__/script-runner.test.js

@@ -36,9 +36,9 @@ describe('ScriptRunner', () => {
         scriptFactory = new ScriptFactory([TestScript]);
 
         mockCommands = {
-            createScriptExecution: jest.fn(),
-            updateScriptExecutionStatus: jest.fn(),
-            completeScriptExecution: jest.fn(),
+            createAdminProcess: jest.fn(),
+            updateAdminProcessState: jest.fn(),
+            completeAdminProcess: jest.fn(),
         };
 
         mockFrigg = {
@@ -49,11 +49,11 @@ describe('ScriptRunner', () => {
         createAdminScriptCommands.mockReturnValue(mockCommands);
         createAdminFriggCommands.mockReturnValue(mockFrigg);
 
-        mockCommands.createScriptExecution.mockResolvedValue({
+        mockCommands.createAdminProcess.mockResolvedValue({
             id: 'exec-123',
         });
-        mockCommands.updateScriptExecutionStatus.mockResolvedValue({});
-        mockCommands.completeScriptExecution.mockResolvedValue({ success: true });
+        mockCommands.updateAdminProcessState.mockResolvedValue({});
+        mockCommands.completeAdminProcess.mockResolvedValue({ success: true });
     });
 
     afterEach(() => {
@@ -76,7 +76,7 @@ describe('ScriptRunner', () => {
             expect(result.executionId).toBe('exec-123');
             expect(result.metrics.durationMs).toBeGreaterThanOrEqual(0);
 
-            expect(mockCommands.createScriptExecution).toHaveBeenCalledWith({
+            expect(mockCommands.createAdminProcess).toHaveBeenCalledWith({
                 scriptName: 'test-script',
                 scriptVersion: '1.0.0',
                 trigger: 'MANUAL',
@@ -85,15 +85,15 @@ describe('ScriptRunner', () => {
                 audit: { apiKeyName: 'test-key' },
             });
 
-            expect(mockCommands.updateScriptExecutionStatus).toHaveBeenCalledWith(
+            expect(mockCommands.updateAdminProcessState).toHaveBeenCalledWith(
                 'exec-123',
                 'RUNNING'
             );
 
-            expect(mockCommands.completeScriptExecution).toHaveBeenCalledWith(
+            expect(mockCommands.completeAdminProcess).toHaveBeenCalledWith(
                 'exec-123',
                 expect.objectContaining({
-                    status: 'COMPLETED',
+                    state: '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.completeScriptExecution).toHaveBeenCalledWith(
+            expect(mockCommands.completeAdminProcess).toHaveBeenCalledWith(
                 'exec-123',
                 expect.objectContaining({
-                    status: 'FAILED',
+                    state: 'FAILED',
                     error: expect.objectContaining({
                         message: 'Script failed',
                     }),
@@ -178,14 +178,144 @@ describe('ScriptRunner', () => {
             });
 
             expect(result.executionId).toBe('existing-exec-456');
-            expect(mockCommands.createScriptExecution).not.toHaveBeenCalled();
-            expect(mockCommands.updateScriptExecutionStatus).toHaveBeenCalledWith(
+            expect(mockCommands.createAdminProcess).not.toHaveBeenCalled();
+            expect(mockCommands.updateAdminProcessState).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._scriptExecutionRepository = null;
+        this._adminProcessRepository = null;
     }
 
     // ==================== LAZY-LOADED REPOSITORIES ====================
@@ -62,12 +62,12 @@ class AdminFriggCommands {
         return this._credentialRepository;
     }
 
-    get scriptExecutionRepository() {
-        if (!this._scriptExecutionRepository) {
-            const { createScriptExecutionRepository } = require('@friggframework/core/admin-scripts/repositories/script-execution-repository-factory');
-            this._scriptExecutionRepository = createScriptExecutionRepository();
+    get adminProcessRepository() {
+        if (!this._adminProcessRepository) {
+            const { createAdminProcessRepository } = require('@friggframework/core/admin-scripts/repositories/admin-process-repository-factory');
+            this._adminProcessRepository = createAdminProcessRepository();
         }
-        return this._scriptExecutionRepository;
+        return this._adminProcessRepository;
     }
 
     // ==================== INTEGRATION QUERIES ====================
@@ -209,7 +209,7 @@ class AdminFriggCommands {
 
         // Persist to execution record if we have an executionId
         if (this.executionId) {
-            this.scriptExecutionRepository.appendExecutionLog(this.executionId, entry)
+            this.adminProcessRepository.appendProcessLog(this.executionId, entry)
                 .catch(err => console.error('Failed to persist log:', err));
         }
 

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

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