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

package/package.json

@@ -1,23 +1,21 @@
 {
     "name": "@friggframework/admin-scripts",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.517.a37d697.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.a37d697.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.a37d697.0",
-        "@friggframework/prettier-config": "2.0.0--canary.517.a37d697.0",
-        "@friggframework/test": "2.0.0--canary.517.a37d697.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": "a37d697613667fff814938b1f30ee2d834c4ffcd"
+    "gitHead": "300ded3ac35558075a081104b4b362b85cf0756f"
 }

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

@@ -93,7 +93,7 @@ describe('ScriptRunner', () => {
             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),
@@ -131,7 +131,7 @@ describe('ScriptRunner', () => {
             expect(mockCommands.completeAdminProcess).toHaveBeenCalledWith(
                 'exec-123',
                 expect.objectContaining({
-                    status: 'FAILED',
+                    state: 'FAILED',
                     error: expect.objectContaining({
                         message: 'Script failed',
                     }),
@@ -186,6 +186,136 @@ describe('ScriptRunner', () => {
         });
     });
 
+    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/script-runner.js

@@ -1,8 +1,6 @@
 const { getScriptFactory } = require('./script-factory');
 const { createAdminFriggCommands } = require('./admin-frigg-commands');
 const { createAdminScriptCommands } = require('@friggframework/core/application/commands/admin-script-commands');
-const { wrapAdminFriggCommandsForDryRun } = require('./dry-run-repository-wrapper');
-const { createDryRunHttpClient, injectDryRunHttpClient } = require('./dry-run-http-interceptor');
 
 /**
  * Script Runner
@@ -30,7 +28,7 @@ class ScriptRunner {
      * @param {string} options.mode - 'sync' | 'async'
      * @param {Object} options.audit - Audit info { apiKeyName, apiKeyLast4, ipAddress }
      * @param {string} options.executionId - Reuse existing execution ID
-     * @param {boolean} options.dryRun - Execute in dry-run mode (no writes, log operations)
+     * @param {boolean} options.dryRun - Dry-run mode: validate and preview without executing
      */
     async execute(scriptName, params = {}, options = {}) {
         const { trigger = 'MANUAL', audit = {}, executionId: existingExecutionId, dryRun = false } = options;
@@ -46,6 +44,11 @@ class ScriptRunner {
             );
         }
 
+        // Dry-run mode: validate and return preview without executing
+        if (dryRun) {
+            return this.createDryRunPreview(scriptName, definition, params);
+        }
+
         let executionId = existingExecutionId;
 
         // Create execution record if not provided
@@ -64,25 +67,13 @@ class ScriptRunner {
         const startTime = new Date();
 
         try {
-            // Update status to RUNNING (skip in dry-run)
-            if (!dryRun) {
-                await this.commands.updateAdminProcessState(executionId, 'RUNNING');
-            }
+            await this.commands.updateAdminProcessState(executionId, 'RUNNING');
 
             // Create frigg commands for the script
-            let frigg;
-            let operationLog = [];
-
-            if (dryRun) {
-                // Dry-run mode: wrap commands to intercept writes
-                frigg = this.createDryRunFriggCommands(operationLog);
-            } else {
-                // Normal mode: create real commands
-                frigg = createAdminFriggCommands({
-                    executionId,
-                    integrationFactory: this.integrationFactory,
-                });
-            }
+            const frigg = createAdminFriggCommands({
+                executionId,
+                integrationFactory: this.integrationFactory,
+            });
 
             // Create script instance
             const script = this.scriptFactory.createInstance(scriptName, {
@@ -97,34 +88,15 @@ class ScriptRunner {
             const endTime = new Date();
             const durationMs = endTime - startTime;
 
-            // Complete execution (skip in dry-run)
-            if (!dryRun) {
-                await this.commands.completeAdminProcess(executionId, {
-                    status: 'COMPLETED',
-                    output,
-                    metrics: {
-                        startTime: startTime.toISOString(),
-                        endTime: endTime.toISOString(),
-                        durationMs,
-                    },
-                });
-            }
-
-            // Return dry-run preview if in dry-run mode
-            if (dryRun) {
-                return {
-                    executionId,
-                    dryRun: true,
-                    status: 'DRY_RUN_COMPLETED',
-                    scriptName,
-                    preview: {
-                        operations: operationLog,
-                        summary: this.summarizeOperations(operationLog),
-                        scriptOutput: output,
-                    },
-                    metrics: { durationMs },
-                };
-            }
+            await this.commands.completeAdminProcess(executionId, {
+                state: 'COMPLETED',
+                output,
+                metrics: {
+                    startTime: startTime.toISOString(),
+                    endTime: endTime.toISOString(),
+                    durationMs,
+                },
+            });
 
             return {
                 executionId,
@@ -134,31 +106,26 @@ class ScriptRunner {
                 metrics: { durationMs },
             };
         } catch (error) {
-            // Calculate metrics even on failure
             const endTime = new Date();
             const durationMs = endTime - startTime;
 
-            // Record failure (skip in dry-run)
-            if (!dryRun) {
-                await this.commands.completeAdminProcess(executionId, {
-                    status: 'FAILED',
-                    error: {
-                        name: error.name,
-                        message: error.message,
-                        stack: error.stack,
-                    },
-                    metrics: {
-                        startTime: startTime.toISOString(),
-                        endTime: endTime.toISOString(),
-                        durationMs,
-                    },
-                });
-            }
+            await this.commands.completeAdminProcess(executionId, {
+                state: 'FAILED',
+                error: {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack,
+                },
+                metrics: {
+                    startTime: startTime.toISOString(),
+                    endTime: endTime.toISOString(),
+                    durationMs,
+                },
+            });
 
             return {
                 executionId,
-                dryRun,
-                status: dryRun ? 'DRY_RUN_FAILED' : 'FAILED',
+                status: 'FAILED',
                 scriptName,
                 error: {
                     name: error.name,
@@ -170,80 +137,107 @@ class ScriptRunner {
     }
 
     /**
-     * Create dry-run version of AdminFriggCommands
-     * Intercepts all write operations and logs them
+     * Create dry-run preview without executing the script
+     * Validates inputs and shows what would be executed
      *
-     * @param {Array} operationLog - Array to collect logged operations
-     * @returns {Object} Wrapped AdminFriggCommands
+     * @param {string} scriptName - Script name
+     * @param {Object} definition - Script definition
+     * @param {Object} params - Input parameters
+     * @returns {Object} Dry-run preview
      */
-    createDryRunFriggCommands(operationLog) {
-        // Create real commands (for read operations)
-        const realCommands = createAdminFriggCommands({
-            executionId: null, // Don't persist logs in dry-run
-            integrationFactory: this.integrationFactory,
-        });
-
-        // Wrap commands to intercept writes
-        const wrappedCommands = wrapAdminFriggCommandsForDryRun(realCommands, operationLog);
+    createDryRunPreview(scriptName, definition, params) {
+        const validation = this.validateParams(definition, params);
+
+        return {
+            dryRun: true,
+            status: validation.valid ? 'DRY_RUN_VALID' : 'DRY_RUN_INVALID',
+            scriptName,
+            preview: {
+                script: {
+                    name: definition.name,
+                    version: definition.version,
+                    description: definition.description,
+                    requiresIntegrationFactory: definition.config?.requiresIntegrationFactory || false,
+                },
+                input: params,
+                inputSchema: definition.inputSchema || null,
+                validation,
+            },
+            message: validation.valid
+                ? 'Dry-run validation passed. Script is ready to execute with provided parameters.'
+                : `Dry-run validation failed: ${validation.errors.join(', ')}`,
+        };
+    }
 
-        // Create dry-run HTTP client
-        const dryRunHttpClient = createDryRunHttpClient(operationLog);
+    /**
+     * Validate parameters against script's input schema
+     *
+     * @param {Object} definition - Script definition
+     * @param {Object} params - Input parameters
+     * @returns {Object} Validation result { valid, errors }
+     */
+    validateParams(definition, params) {
+        const errors = [];
+        const schema = definition.inputSchema;
 
-        // Override instantiate to inject dry-run HTTP client
-        const originalInstantiate = wrappedCommands.instantiate.bind(wrappedCommands);
-        wrappedCommands.instantiate = async (integrationId) => {
-            const instance = await originalInstantiate(integrationId);
+        if (!schema) {
+            return { valid: true, errors: [] };
+        }
 
-            // Inject dry-run HTTP client into the integration instance
-            injectDryRunHttpClient(instance, dryRunHttpClient);
+        // Check required fields
+        if (schema.required && Array.isArray(schema.required)) {
+            for (const field of schema.required) {
+                if (params[field] === undefined || params[field] === null) {
+                    errors.push(`Missing required parameter: ${field}`);
+                }
+            }
+        }
 
-            return instance;
-        };
+        // Basic type validation for properties
+        if (schema.properties) {
+            for (const [key, prop] of Object.entries(schema.properties)) {
+                const value = params[key];
+                if (value !== undefined && value !== null) {
+                    const typeError = this.validateType(key, value, prop);
+                    if (typeError) {
+                        errors.push(typeError);
+                    }
+                }
+            }
+        }
 
-        return wrappedCommands;
+        return { valid: errors.length === 0, errors };
     }
 
     /**
-     * Summarize operations from dry-run log
-     *
-     * @param {Array} log - Operation log
-     * @returns {Object} Summary statistics
+     * Validate a single parameter type
      */
-    summarizeOperations(log) {
-        const summary = {
-            totalOperations: log.length,
-            databaseWrites: 0,
-            httpRequests: 0,
-            byOperation: {},
-            byModel: {},
-            byService: {},
-        };
+    validateType(key, value, schema) {
+        const expectedType = schema.type;
+        if (!expectedType) return null;
 
-        for (const op of log) {
-            // Count by operation type
-            const operation = op.operation || op.method || 'UNKNOWN';
-            summary.byOperation[operation] = (summary.byOperation[operation] || 0) + 1;
-
-            // Database operations
-            if (op.model) {
-                summary.databaseWrites++;
-                summary.byModel[op.model] = summary.byModel[op.model] || [];
-                summary.byModel[op.model].push({
-                    operation: op.operation,
-                    method: op.method,
-                    timestamp: op.timestamp,
-                });
-            }
+        const actualType = Array.isArray(value) ? 'array' : typeof value;
 
-            // HTTP requests
-            if (op.operation === 'HTTP_REQUEST') {
-                summary.httpRequests++;
-                const service = op.service || 'unknown';
-                summary.byService[service] = (summary.byService[service] || 0) + 1;
-            }
+        if (expectedType === 'integer' && (typeof value !== 'number' || !Number.isInteger(value))) {
+            return `Parameter "${key}" must be an integer`;
+        }
+        if (expectedType === 'number' && typeof value !== 'number') {
+            return `Parameter "${key}" must be a number`;
+        }
+        if (expectedType === 'string' && typeof value !== 'string') {
+            return `Parameter "${key}" must be a string`;
+        }
+        if (expectedType === 'boolean' && typeof value !== 'boolean') {
+            return `Parameter "${key}" must be a boolean`;
+        }
+        if (expectedType === 'array' && !Array.isArray(value)) {
+            return `Parameter "${key}" must be an array`;
+        }
+        if (expectedType === 'object' && (typeof value !== 'object' || Array.isArray(value))) {
+            return `Parameter "${key}" must be an object`;
         }
 
-        return summary;
+        return null;
     }
 }