@friggframework/admin-scripts 2.0.0--canary.522.cbd3d5a.0 → 2.0.0--canary.517.35ee143.0

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
@@ -29,8 +27,10 @@ class ScriptRunner {
      * @param {string} options.trigger - 'MANUAL' | 'SCHEDULED' | 'QUEUE'
      * @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 {string} options.executionId - Reuse existing AdminProcess record ID (NOT the Lambda execution ID).
+     *   This is the database ID from the AdminProcess collection/table that tracks script executions.
+     *   Pass this when resuming a queued execution to continue using the same execution record.
+     * @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;
@@ -40,17 +40,22 @@ class ScriptRunner {
         const definition = scriptClass.Definition;
 
         // Validate integrationFactory requirement
-        if (definition.config?.requiresIntegrationFactory && !this.integrationFactory) {
+        if (definition.config?.requireIntegrationInstance && !this.integrationFactory) {
             throw new Error(
                 `Script "${scriptName}" requires integrationFactory but none was provided`
             );
         }
 
+        // 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
         if (!executionId) {
-            const execution = await this.commands.createScriptExecution({
+            const execution = await this.commands.createAdminProcess({
                 scriptName,
                 scriptVersion: definition.version,
                 trigger,
@@ -64,25 +69,13 @@ class ScriptRunner {
         const startTime = new Date();
 
         try {
-            // Update status to RUNNING (skip in dry-run)
-            if (!dryRun) {
-                await this.commands.updateScriptExecutionStatus(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 +90,15 @@ class ScriptRunner {
             const endTime = new Date();
             const durationMs = endTime - startTime;
 
-            // Complete execution (skip in dry-run)
-            if (!dryRun) {
-                await this.commands.completeScriptExecution(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 +108,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.completeScriptExecution(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 +139,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,
+                    requireIntegrationInstance: definition.config?.requireIntegrationInstance || 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;
     }
 }
 

package/src/application/use-cases/__tests__/delete-schedule-use-case.test.js

@@ -0,0 +1,168 @@
+const { DeleteScheduleUseCase } = require('../delete-schedule-use-case');
+
+describe('DeleteScheduleUseCase', () => {
+    let useCase;
+    let mockCommands;
+    let mockSchedulerAdapter;
+    let mockScriptFactory;
+
+    beforeEach(() => {
+        mockCommands = {
+            deleteSchedule: jest.fn(),
+        };
+
+        mockSchedulerAdapter = {
+            deleteSchedule: jest.fn(),
+        };
+
+        mockScriptFactory = {
+            has: jest.fn(),
+            get: jest.fn(),
+        };
+
+        useCase = new DeleteScheduleUseCase({
+            commands: mockCommands,
+            schedulerAdapter: mockSchedulerAdapter,
+            scriptFactory: mockScriptFactory,
+        });
+    });
+
+    describe('execute', () => {
+        it('should delete schedule and cleanup external scheduler', async () => {
+            const deletedSchedule = {
+                scriptName: 'test-script',
+                externalScheduleId: 'arn:aws:scheduler:us-east-1:123:schedule/test',
+            };
+
+            mockScriptFactory.has.mockReturnValue(true);
+            mockScriptFactory.get.mockReturnValue({ Definition: {} });
+            mockCommands.deleteSchedule.mockResolvedValue({
+                deletedCount: 1,
+                deleted: deletedSchedule,
+            });
+            mockSchedulerAdapter.deleteSchedule.mockResolvedValue();
+
+            const result = await useCase.execute('test-script');
+
+            expect(result.success).toBe(true);
+            expect(result.deletedCount).toBe(1);
+            expect(result.message).toBe('Schedule override removed');
+            expect(mockSchedulerAdapter.deleteSchedule).toHaveBeenCalledWith('test-script');
+        });
+
+        it('should not call scheduler when no external rule exists', async () => {
+            mockScriptFactory.has.mockReturnValue(true);
+            mockScriptFactory.get.mockReturnValue({ Definition: {} });
+            mockCommands.deleteSchedule.mockResolvedValue({
+                deletedCount: 1,
+                deleted: { scriptName: 'test-script' }, // No externalScheduleId
+            });
+
+            const result = await useCase.execute('test-script');
+
+            expect(result.success).toBe(true);
+            expect(mockSchedulerAdapter.deleteSchedule).not.toHaveBeenCalled();
+        });
+
+        it('should handle scheduler delete errors gracefully with warning', async () => {
+            mockScriptFactory.has.mockReturnValue(true);
+            mockScriptFactory.get.mockReturnValue({ Definition: {} });
+            mockCommands.deleteSchedule.mockResolvedValue({
+                deletedCount: 1,
+                deleted: {
+                    scriptName: 'test-script',
+                    externalScheduleId: 'arn:aws:scheduler:us-east-1:123:schedule/test',
+                },
+            });
+            mockSchedulerAdapter.deleteSchedule.mockRejectedValue(
+                new Error('Scheduler delete failed')
+            );
+
+            const result = await useCase.execute('test-script');
+
+            expect(result.success).toBe(true);
+            expect(result.schedulerWarning).toBe('Scheduler delete failed');
+        });
+
+        it('should return definition schedule as effective after deletion', async () => {
+            const definitionSchedule = {
+                enabled: true,
+                cronExpression: '0 6 * * *',
+                timezone: 'America/Los_Angeles',
+            };
+
+            mockScriptFactory.has.mockReturnValue(true);
+            mockScriptFactory.get.mockReturnValue({
+                Definition: { schedule: definitionSchedule },
+            });
+            mockCommands.deleteSchedule.mockResolvedValue({
+                deletedCount: 1,
+                deleted: { scriptName: 'test-script' },
+            });
+
+            const result = await useCase.execute('test-script');
+
+            expect(result.effectiveSchedule.source).toBe('definition');
+            expect(result.effectiveSchedule.enabled).toBe(true);
+            expect(result.effectiveSchedule.cronExpression).toBe('0 6 * * *');
+            expect(result.effectiveSchedule.timezone).toBe('America/Los_Angeles');
+        });
+
+        it('should default timezone to UTC when not in definition', async () => {
+            mockScriptFactory.has.mockReturnValue(true);
+            mockScriptFactory.get.mockReturnValue({
+                Definition: { schedule: { enabled: true, cronExpression: '0 6 * * *' } },
+            });
+            mockCommands.deleteSchedule.mockResolvedValue({
+                deletedCount: 1,
+                deleted: { scriptName: 'test-script' },
+            });
+
+            const result = await useCase.execute('test-script');
+
+            expect(result.effectiveSchedule.timezone).toBe('UTC');
+        });
+
+        it('should return none as effective when no definition schedule', async () => {
+            mockScriptFactory.has.mockReturnValue(true);
+            mockScriptFactory.get.mockReturnValue({ Definition: {} });
+            mockCommands.deleteSchedule.mockResolvedValue({
+                deletedCount: 1,
+                deleted: { scriptName: 'test-script' },
+            });
+
+            const result = await useCase.execute('test-script');
+
+            expect(result.effectiveSchedule.source).toBe('none');
+            expect(result.effectiveSchedule.enabled).toBe(false);
+        });
+
+        it('should return correct message when no schedule found', async () => {
+            mockScriptFactory.has.mockReturnValue(true);
+            mockScriptFactory.get.mockReturnValue({ Definition: {} });
+            mockCommands.deleteSchedule.mockResolvedValue({
+                deletedCount: 0,
+                deleted: null,
+            });
+
+            const result = await useCase.execute('test-script');
+
+            expect(result.success).toBe(true);
+            expect(result.deletedCount).toBe(0);
+            expect(result.message).toBe('No schedule override found');
+        });
+
+        it('should throw SCRIPT_NOT_FOUND error when script does not exist', async () => {
+            mockScriptFactory.has.mockReturnValue(false);
+
+            await expect(useCase.execute('non-existent'))
+                .rejects.toThrow('Script "non-existent" not found');
+
+            try {
+                await useCase.execute('non-existent');
+            } catch (error) {
+                expect(error.code).toBe('SCRIPT_NOT_FOUND');
+            }
+        });
+    });
+});

package/src/application/use-cases/__tests__/get-effective-schedule-use-case.test.js

@@ -0,0 +1,114 @@
+const { GetEffectiveScheduleUseCase } = require('../get-effective-schedule-use-case');
+
+describe('GetEffectiveScheduleUseCase', () => {
+    let useCase;
+    let mockCommands;
+    let mockScriptFactory;
+
+    beforeEach(() => {
+        mockCommands = {
+            getScheduleByScriptName: jest.fn(),
+        };
+
+        mockScriptFactory = {
+            has: jest.fn(),
+            get: jest.fn(),
+        };
+
+        useCase = new GetEffectiveScheduleUseCase({
+            commands: mockCommands,
+            scriptFactory: mockScriptFactory,
+        });
+    });
+
+    describe('execute', () => {
+        it('should return database schedule when override exists', async () => {
+            const dbSchedule = {
+                scriptName: 'test-script',
+                enabled: true,
+                cronExpression: '0 9 * * *',
+                timezone: 'UTC',
+            };
+
+            mockScriptFactory.has.mockReturnValue(true);
+            mockScriptFactory.get.mockReturnValue({ Definition: {} });
+            mockCommands.getScheduleByScriptName.mockResolvedValue(dbSchedule);
+
+            const result = await useCase.execute('test-script');
+
+            expect(result.source).toBe('database');
+            expect(result.schedule).toEqual(dbSchedule);
+        });
+
+        it('should return definition schedule when no database override', async () => {
+            const definitionSchedule = {
+                enabled: true,
+                cronExpression: '0 12 * * *',
+                timezone: 'America/New_York',
+            };
+
+            mockScriptFactory.has.mockReturnValue(true);
+            mockScriptFactory.get.mockReturnValue({
+                Definition: { schedule: definitionSchedule },
+            });
+            mockCommands.getScheduleByScriptName.mockResolvedValue(null);
+
+            const result = await useCase.execute('test-script');
+
+            expect(result.source).toBe('definition');
+            expect(result.schedule.enabled).toBe(true);
+            expect(result.schedule.cronExpression).toBe('0 12 * * *');
+            expect(result.schedule.timezone).toBe('America/New_York');
+        });
+
+        it('should default timezone to UTC when not specified in definition', async () => {
+            mockScriptFactory.has.mockReturnValue(true);
+            mockScriptFactory.get.mockReturnValue({
+                Definition: { schedule: { enabled: true, cronExpression: '0 12 * * *' } },
+            });
+            mockCommands.getScheduleByScriptName.mockResolvedValue(null);
+
+            const result = await useCase.execute('test-script');
+
+            expect(result.schedule.timezone).toBe('UTC');
+        });
+
+        it('should return none when no schedule configured', async () => {
+            mockScriptFactory.has.mockReturnValue(true);
+            mockScriptFactory.get.mockReturnValue({ Definition: {} });
+            mockCommands.getScheduleByScriptName.mockResolvedValue(null);
+
+            const result = await useCase.execute('test-script');
+
+            expect(result.source).toBe('none');
+            expect(result.schedule.enabled).toBe(false);
+            expect(result.schedule.scriptName).toBe('test-script');
+        });
+
+        it('should return none when definition schedule is disabled', async () => {
+            mockScriptFactory.has.mockReturnValue(true);
+            mockScriptFactory.get.mockReturnValue({
+                Definition: { schedule: { enabled: false } },
+            });
+            mockCommands.getScheduleByScriptName.mockResolvedValue(null);
+
+            const result = await useCase.execute('test-script');
+
+            expect(result.source).toBe('none');
+            expect(result.schedule.enabled).toBe(false);
+        });
+
+        it('should throw SCRIPT_NOT_FOUND error when script does not exist', async () => {
+            mockScriptFactory.has.mockReturnValue(false);
+
+            await expect(useCase.execute('non-existent'))
+                .rejects.toThrow('Script "non-existent" not found');
+
+            try {
+                await useCase.execute('non-existent');
+            } catch (error) {
+                expect(error.code).toBe('SCRIPT_NOT_FOUND');
+            }
+        });
+    });
+});