@testsmith/perfornium 0.6.4 → 0.6.6

package/dist/core/step-executor.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StepExecutor = void 0;
 const hooks_manager_1 = require("./hooks-manager");
@@ -41,11 +8,16 @@ const rendezvous_1 = require("./rendezvous");
 const time_1 = require("../utils/time");
 const template_1 = require("../utils/template");
 const logger_1 = require("../utils/logger");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
+const check_evaluator_1 = require("./execution/check-evaluator");
+const data_extractor_1 = require("./execution/data-extractor");
+const json_payload_processor_1 = require("./execution/json-payload-processor");
 class StepExecutor {
     constructor(handlers, testName = 'Load Test') {
         this.templateProcessor = new template_1.TemplateProcessor();
+        // Extracted modules
+        this.checkEvaluator = new check_evaluator_1.CheckEvaluator();
+        this.dataExtractor = new data_extractor_1.DataExtractor();
+        this.jsonPayloadProcessor = new json_payload_processor_1.JSONPayloadProcessor();
         this.handlers = handlers;
         this.testName = testName;
         // Register this instance with ScriptExecutor for step execution in hooks
@@ -63,7 +35,6 @@ class StepExecutor {
         if (stepHooksManager) {
             try {
                 const beforeStepResult = await stepHooksManager.executeBeforeStep(context.variables, context.extracted_data, context.csv_data);
-                // Merge any variables returned by beforeStep hook
                 if (beforeStepResult?.variables) {
                     Object.assign(context.variables, beforeStepResult.variables);
                     logger_1.logger.debug(`Hook VU${context.vu_id}: beforeStep hook set variables: ${Object.keys(beforeStepResult.variables).join(', ')}`);
@@ -75,11 +46,9 @@ class StepExecutor {
         }
         let testResult;
         try {
-            // Execute the actual step
             testResult = await this.executeStepInternal(step, context, scenarioName, startTime);
         }
         catch (error) {
-            // Execute onStepError hook
             if (stepHooksManager) {
                 try {
                     await stepHooksManager.executeOnStepError(error, context.variables, context.extracted_data, context.csv_data);
@@ -88,31 +57,12 @@ class StepExecutor {
                     logger_1.logger.error(`VU ${context.vu_id} onStepError hook failed:`, hookError);
                 }
             }
-            // Create error result
-            const stepName = step.name || `${step.type}_${context.iteration}`;
-            const iteration = context.iteration || 1;
-            const threadName = `${iteration}. ${stepName} ${context.vu_id}-${iteration}`;
-            testResult = {
-                id: `${context.vu_id}-${Date.now()}`,
-                vu_id: context.vu_id,
-                iteration: context.iteration,
-                scenario: scenarioName,
-                action: step.name || step.type || 'rest',
-                step_name: stepName,
-                thread_name: threadName,
-                timestamp: startTime,
-                duration: Date.now() - startTime,
-                success: false,
-                error: error.message,
-                shouldRecord: true
-            };
+            testResult = this.createErrorResult(step, context, scenarioName, startTime, error);
         }
         finally {
-            // Execute teardownStep hook (only if testResult was created)
             if (stepHooksManager && testResult) {
                 try {
                     const teardownResult = await stepHooksManager.executeTeardownStep(context.variables, context.extracted_data, context.csv_data, testResult);
-                    // Merge any variables returned by teardownStep hook
                     if (teardownResult?.variables) {
                         Object.assign(context.variables, teardownResult.variables);
                     }
@@ -122,40 +72,20 @@ class StepExecutor {
                 }
             }
         }
-        // This should never happen, but TypeScript needs the guarantee
         if (!testResult) {
-            const stepName = step.name || `${step.type}_${context.iteration}`;
-            const iteration = context.iteration || 1;
-            const threadName = `${iteration}. ${stepName} ${context.vu_id}-${iteration}`;
-            testResult = {
-                id: `${context.vu_id}-${Date.now()}`,
-                vu_id: context.vu_id,
-                iteration: context.iteration,
-                scenario: scenarioName,
-                action: step.name || step.type || 'rest',
-                step_name: stepName,
-                thread_name: threadName,
-                timestamp: startTime,
-                duration: Date.now() - startTime,
-                success: false,
-                error: 'Unknown error occurred',
-                shouldRecord: true
-            };
+            testResult = this.createErrorResult(step, context, scenarioName, startTime, new Error('Unknown error occurred'));
         }
-        // Evaluate thresholds if they are defined for this step
+        // Evaluate thresholds
         if (step.thresholds && step.thresholds.length > 0) {
             try {
                 const evaluationResult = threshold_evaluator_1.ThresholdEvaluator.evaluate(step.thresholds, testResult, stepName);
                 if (!evaluationResult.passed) {
-                    // Add threshold failures to test result
                     testResult.threshold_failures = evaluationResult.failures;
-                    // Execute threshold actions (may throw errors for fail actions)
                     await threshold_evaluator_1.ThresholdEvaluator.executeThresholdActions(evaluationResult, stepName);
                 }
             }
             catch (error) {
                 logger_1.logger.error(`Threshold evaluation failed for step ${stepName}:`, error);
-                // If threshold action is to fail, we re-throw the error
                 if (error instanceof Error && error.message.includes('threshold violation')) {
                     throw error;
                 }
@@ -163,27 +93,30 @@ class StepExecutor {
         }
         return testResult;
     }
-    // Make this public so hooks can execute steps
+    createErrorResult(step, context, scenarioName, startTime, error) {
+        const stepName = step.name || `${step.type}_${context.iteration}`;
+        const iteration = context.iteration || 1;
+        const threadName = `${iteration}. ${stepName} ${context.vu_id}-${iteration}`;
+        return {
+            id: `${context.vu_id}-${Date.now()}`,
+            vu_id: context.vu_id,
+            iteration: context.iteration,
+            scenario: scenarioName,
+            action: step.name || step.type || 'rest',
+            step_name: stepName,
+            thread_name: threadName,
+            timestamp: startTime,
+            duration: Date.now() - startTime,
+            success: false,
+            error: error.message,
+            shouldRecord: true
+        };
+    }
     async executeStepInternal(step, context, scenarioName, startTime) {
         const processedStep = this.processTemplate(step, context);
         // Check condition if specified
         if (step.condition && !this.evaluateCondition(step.condition, context)) {
-            const stepName = step.name || `${step.type}_${context.iteration}`;
-            const iteration = context.iteration || 1;
-            const threadName = `${iteration}. ${stepName} ${context.vu_id}-${iteration}`;
-            return {
-                id: `${context.vu_id}-${Date.now()}`,
-                vu_id: context.vu_id,
-                iteration: context.iteration,
-                scenario: scenarioName,
-                action: step.name || step.type || 'rest',
-                step_name: stepName,
-                thread_name: threadName,
-                timestamp: startTime,
-                duration: 0,
-                success: true,
-                custom_metrics: { skipped: true }
-            };
+            return this.createSkippedResult(step, context, scenarioName, startTime);
         }
         let result;
         const stepType = step.type || 'rest';
@@ -213,15 +146,46 @@ class StepExecutor {
             default:
                 throw new Error(`Unsupported step type: ${step.type}`);
         }
-        // Use response_time from handler if available (e.g., web actions with action_time)
-        // Otherwise fall back to total elapsed time
+        const testResult = this.buildTestResult(step, context, scenarioName, startTime, result);
+        // Run checks if configured
+        if ('checks' in step && step.checks) {
+            const checkResults = await this.checkEvaluator.runChecks(step.checks, result, context);
+            if (!checkResults.passed) {
+                testResult.success = false;
+                testResult.error = checkResults.errors.join('; ');
+            }
+        }
+        // Extract data if configured
+        if ('extract' in step && step.extract) {
+            await this.dataExtractor.extractData(step.extract, result, context);
+        }
+        return testResult;
+    }
+    createSkippedResult(step, context, scenarioName, startTime) {
+        const stepName = step.name || `${step.type}_${context.iteration}`;
+        const iteration = context.iteration || 1;
+        const threadName = `${iteration}. ${stepName} ${context.vu_id}-${iteration}`;
+        return {
+            id: `${context.vu_id}-${Date.now()}`,
+            vu_id: context.vu_id,
+            iteration: context.iteration,
+            scenario: scenarioName,
+            action: step.name || step.type || 'rest',
+            step_name: stepName,
+            thread_name: threadName,
+            timestamp: startTime,
+            duration: 0,
+            success: true,
+            custom_metrics: { skipped: true }
+        };
+    }
+    buildTestResult(step, context, scenarioName, startTime, result) {
         const totalElapsed = Date.now() - startTime;
         const duration = result.response_time !== undefined ? result.response_time : totalElapsed;
         const stepName = step.name || `${step.type}_${context.iteration}`;
-        // Generate JMeter-style thread name: "iteration. step_name vu_id-iteration"
         const iteration = context.iteration || 1;
         const threadName = `${iteration}. ${stepName} ${context.vu_id}-${iteration}`;
-        const testResult = {
+        return {
             id: `${context.vu_id}-${Date.now()}`,
             vu_id: context.vu_id,
             iteration: context.iteration,
@@ -231,7 +195,7 @@ class StepExecutor {
             thread_name: threadName,
             timestamp: startTime,
             duration,
-            response_time: duration, // Add explicit response_time for reporting
+            response_time: duration,
             success: result.success,
             status: result.status,
             status_text: result.status_text,
@@ -246,11 +210,9 @@ class StepExecutor {
             response_body: result.response_body,
             custom_metrics: result.custom_metrics,
             shouldRecord: result.shouldRecord !== undefined ? result.shouldRecord : this.shouldRecordStep(step, true),
-            // JMeter-style timing breakdown
             sample_start: result.sample_start,
             connect_time: result.connect_time,
             latency: result.latency,
-            // JMeter-style size breakdown
             sent_bytes: result.sent_bytes,
             headers_size_sent: result.headers_size_sent,
             body_size_sent: result.body_size_sent,
@@ -258,29 +220,10 @@ class StepExecutor {
             body_size_received: result.body_size_received,
             data_type: result.data_type,
         };
-        // Run checks if configured
-        if ('checks' in step && step.checks) {
-            const checkResults = await this.runChecks(step.checks, result, context);
-            if (!checkResults.passed) {
-                testResult.success = false;
-                testResult.error = `Check failed: ${checkResults.errors.join(', ')}`;
-            }
-        }
-        // Extract data if configured
-        if ('extract' in step && step.extract) {
-            await this.extractData(step.extract, result, context);
-        }
-        return testResult;
     }
     shouldRecordStep(step, success) {
-        // Always record errors
         if (!success)
             return true;
-        // For web steps, only record meaningful performance measurements:
-        // - Verifications (verify_*) - time for elements/text to appear (measures app responsiveness)
-        // - Waits (wait_for_*) - time for conditions to be met
-        // - Performance measurements (measure_*, performance_audit)
-        // NOT recorded: goto, click, fill, press, select, hover, screenshot (navigation/interactions)
         if (step.type === 'web' && step.action) {
             const measurableCommands = [
                 'verify_exists', 'verify_visible', 'verify_text', 'verify_contains', 'verify_not_exists',
@@ -296,117 +239,9 @@ class StepExecutor {
         if (!handler) {
             throw new Error('REST handler not available');
         }
-        // Handle jsonFile loading with optional overrides
-        const processedStep = this.processJsonFile(step, context);
+        const processedStep = this.jsonPayloadProcessor.processJsonFile(step, context);
         return handler.execute(processedStep, context);
     }
-    /**
-     * Load JSON payload from file and apply overrides
-     * Supports dot notation for nested paths in overrides
-     */
-    processJsonFile(step, context) {
-        if (!step.jsonFile) {
-            return step;
-        }
-        // Resolve file path relative to CWD
-        const filePath = path.resolve(process.cwd(), step.jsonFile);
-        if (!fs.existsSync(filePath)) {
-            throw new Error(`JSON payload file not found: ${step.jsonFile}`);
-        }
-        // Load and parse JSON file
-        let payload;
-        try {
-            const fileContent = fs.readFileSync(filePath, 'utf-8');
-            payload = JSON.parse(fileContent);
-        }
-        catch (error) {
-            throw new Error(`Failed to parse JSON file ${step.jsonFile}: ${error.message}`);
-        }
-        // Apply overrides if specified
-        if (step.overrides) {
-            payload = this.applyOverrides(payload, step.overrides, context);
-        }
-        // Return new step with json property set (removing jsonFile and overrides)
-        const { jsonFile, overrides, ...restOfStep } = step;
-        return {
-            ...restOfStep,
-            json: payload
-        };
-    }
-    /**
-     * Apply overrides to a JSON object using dot notation for nested paths
-     * Override values are processed through the template processor
-     */
-    applyOverrides(obj, overrides, context) {
-        // Deep clone the object to avoid mutating the original
-        const result = JSON.parse(JSON.stringify(obj));
-        const contextData = {
-            __VU: context.vu_id,
-            __ITER: context.iteration,
-            vu_id: context.vu_id,
-            iteration: context.iteration,
-            variables: context.variables || {},
-            extracted_data: context.extracted_data || {},
-            ...context.variables,
-            ...context.extracted_data
-        };
-        for (const [path, value] of Object.entries(overrides)) {
-            // Process template expressions in override values
-            let processedValue = value;
-            if (typeof value === 'string') {
-                processedValue = this.templateProcessor.process(value, contextData);
-                // Try to parse as JSON if it looks like a number, boolean, or object
-                if (processedValue === 'true')
-                    processedValue = true;
-                else if (processedValue === 'false')
-                    processedValue = false;
-                else if (!isNaN(Number(processedValue)) && processedValue !== '') {
-                    processedValue = Number(processedValue);
-                }
-            }
-            this.setNestedValue(result, path, processedValue);
-        }
-        return result;
-    }
-    /**
-     * Set a value at a nested path using dot notation
-     * Example: setNestedValue(obj, 'user.profile.name', 'John')
-     */
-    setNestedValue(obj, path, value) {
-        const keys = path.split('.');
-        let current = obj;
-        for (let i = 0; i < keys.length - 1; i++) {
-            const key = keys[i];
-            // Handle array indices like 'items[0]'
-            const arrayMatch = key.match(/^(.+)\[(\d+)]$/);
-            if (arrayMatch) {
-                const [, prop, index] = arrayMatch;
-                if (!current[prop])
-                    current[prop] = [];
-                if (!current[prop][parseInt(index)])
-                    current[prop][parseInt(index)] = {};
-                current = current[prop][parseInt(index)];
-            }
-            else {
-                if (!current[key] || typeof current[key] !== 'object') {
-                    current[key] = {};
-                }
-                current = current[key];
-            }
-        }
-        const lastKey = keys[keys.length - 1];
-        // Handle array index in last key
-        const arrayMatch = lastKey.match(/^(.+)\[(\d+)]$/);
-        if (arrayMatch) {
-            const [, prop, index] = arrayMatch;
-            if (!current[prop])
-                current[prop] = [];
-            current[prop][parseInt(index)] = value;
-        }
-        else {
-            current[lastKey] = value;
-        }
-    }
     async executeSOAPStep(step, context) {
         const handler = this.handlers.get('soap');
         if (!handler) {
@@ -450,8 +285,7 @@ class StepExecutor {
     }
     async executeRendezvousStep(step, context) {
         const rendezvousManager = rendezvous_1.RendezvousManager.getInstance();
-        // Parse timeout - can be number (ms) or string ("30s", "1m")
-        let timeoutMs = 30000; // Default 30 seconds
+        let timeoutMs = 30000;
         if (step.timeout !== undefined) {
             if (typeof step.timeout === 'number') {
                 timeoutMs = step.timeout;
@@ -482,7 +316,7 @@ class StepExecutor {
                     rendezvous_reason: result.reason,
                     rendezvous_vu_count: result.vuCount
                 },
-                shouldRecord: true // Always record rendezvous timing
+                shouldRecord: true
             };
         }
         catch (error) {
@@ -497,18 +331,15 @@ class StepExecutor {
         }
     }
     async executeScriptStep(step, context) {
-        logger_1.logger.info(`📜 Executing script step: file=${step.file}, function=${step.function}`);
+        logger_1.logger.info(`Executing script step: file=${step.file}, function=${step.function}`);
         const { file, function: funcName, params, returns, timeout = 30000 } = step;
         const path = require('path');
         const fs = require('fs');
         try {
-            // Resolve file path relative to current working directory
             const filePath = path.resolve(process.cwd(), file);
-            // Load the module (supports both .ts and .js)
             let module;
             try {
                 if (filePath.endsWith('.ts')) {
-                    // Transpile TypeScript on the fly using esbuild
                     const esbuild = require('esbuild');
                     const source = fs.readFileSync(filePath, 'utf-8');
                     const result = esbuild.transformSync(source, {
@@ -516,11 +347,9 @@ class StepExecutor {
                         format: 'cjs',
                         target: 'node18'
                     });
-                    // Create a temporary module from the transpiled code
                     const Module = require('module');
                     const tempModule = new Module(filePath);
                     tempModule.filename = filePath;
-                    // Include both script dir and cwd node_modules for dependency resolution
                     const scriptPaths = Module._nodeModulePaths(path.dirname(filePath));
                     const cwdPaths = Module._nodeModulePaths(process.cwd());
                     tempModule.paths = [...new Set([...scriptPaths, ...cwdPaths])];
@@ -528,7 +357,6 @@ class StepExecutor {
                     module = tempModule.exports;
                 }
                 else {
-                    // For JS files, clear require cache and load directly
                     delete require.cache[require.resolve(filePath)];
                     module = require(filePath);
                 }
@@ -536,12 +364,10 @@ class StepExecutor {
             catch (loadError) {
                 throw new Error(`Failed to load script file '${file}': ${loadError.message}`);
             }
-            // Get the function from the module
             const fn = module[funcName] || module.default?.[funcName];
             if (typeof fn !== 'function') {
                 throw new Error(`Function '${funcName}' not found in '${file}'`);
             }
-            // Build parameters with context available
             const execParams = {
                 ...params,
                 __context: context,
@@ -550,14 +376,12 @@ class StepExecutor {
                 __vu_id: context.vu_id,
                 __iteration: context.iteration
             };
-            // Execute the function with timeout
             const timeoutPromise = new Promise((_, reject) => {
                 setTimeout(() => reject(new Error(`Script execution timeout (${timeout}ms)`)), timeout);
             });
             const resultPromise = Promise.resolve(fn(execParams));
             const result = await Promise.race([resultPromise, timeoutPromise]);
             logger_1.logger.debug(`Script ${funcName} returned: ${JSON.stringify(result)}`);
-            // Store return value if specified
             if (returns && result !== undefined) {
                 context.extracted_data[returns] = result;
             }
@@ -616,138 +440,20 @@ class StepExecutor {
         };
         logger_1.logger.debug(`StepExecutor processing template for VU${context.vu_id} Iter${context.iteration}`);
         logger_1.logger.debug(`Extracted data keys: ${Object.keys(context.extracted_data || {}).join(', ') || '(none)'}`);
-        logger_1.logger.debug(`Context data keys at top level: ${Object.keys(contextData).join(', ')}`);
         const stepStr = JSON.stringify(step);
-        logger_1.logger.debug(`Original step JSON: ${stepStr}`);
         const processed = this.templateProcessor.process(stepStr, contextData);
-        logger_1.logger.debug(`Raw processed result: ${processed}`);
-        logger_1.logger.debug(`Processed result type: ${typeof processed}`);
-        let processedStep;
         try {
             if (typeof processed === 'string') {
-                processedStep = JSON.parse(processed);
+                return JSON.parse(processed);
             }
             else {
-                processedStep = processed;
+                return processed;
             }
         }
         catch (error) {
             logger_1.logger.error(`JSON parsing failed in StepExecutor`);
-            logger_1.logger.error(`Processed content (first 500 chars): ${processed.substring(0, 500)}`);
-            logger_1.logger.error(`Error: ${error}`);
             throw new Error(`Failed to parse processed step JSON: ${error}`);
         }
-        logger_1.logger.debug(`Successfully parsed step: ${JSON.stringify(processedStep)}`);
-        return processedStep;
-    }
-    async runChecks(checks, result, context) {
-        const errors = [];
-        for (const check of checks) {
-            try {
-                let passed = false;
-                switch (check.type) {
-                    case 'status':
-                        passed = result.status === check.value;
-                        break;
-                    case 'response_time':
-                        const threshold = typeof check.value === 'string'
-                            ? (0, time_1.parseTime)(check.value.replace(/[<>]/g, ''))
-                            : check.value;
-                        passed = (result.duration || 0) < threshold;
-                        break;
-                    case 'json_path':
-                        const value = this.getJsonPath(result.data, check.value);
-                        passed = value !== undefined && value !== null;
-                        break;
-                    case 'text_contains':
-                        const text = typeof result.data === 'string' ? result.data : JSON.stringify(result.data);
-                        passed = text.includes(check.value);
-                        break;
-                    case 'custom':
-                        passed = await this.checkCustom(check.script, result, context);
-                        break;
-                }
-                if (!passed) {
-                    errors.push(check.description || `Check failed: ${check.type}`);
-                }
-            }
-            catch (error) {
-                errors.push(`Check error: ${error}`);
-            }
-        }
-        return { passed: errors.length === 0, errors };
-    }
-    async checkCustom(script, result, context) {
-        try {
-            const fn = new Function('result', 'context', `return ${script}`);
-            return !!fn(result, context);
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    async extractData(extractors, result, context) {
-        for (const extractor of extractors) {
-            try {
-                let value;
-                // Normalize type: accept both "jsonpath" and "json_path"
-                const extractType = (extractor.type || 'jsonpath').toLowerCase().replace('_', '');
-                // Normalize expression: accept both "path" and "expression"
-                const expression = extractor.expression || extractor.path;
-                switch (extractType) {
-                    case 'jsonpath':
-                        value = this.getJsonPath(result.data, expression);
-                        break;
-                    case 'regex':
-                        const match = String(result.data).match(new RegExp(expression));
-                        value = match ? (match[1] || match[0]) : null;
-                        break;
-                    case 'header':
-                        value = result.headers?.[expression.toLowerCase()];
-                        break;
-                    case 'custom':
-                        value = await this.extractCustom(extractor.script, result, context);
-                        break;
-                    default:
-                        // Default to jsonpath if type not recognized but path/expression provided
-                        if (expression) {
-                            value = this.getJsonPath(result.data, expression);
-                        }
-                }
-                if (value !== null && value !== undefined) {
-                    context.extracted_data[extractor.name] = value;
-                    logger_1.logger.debug(`Extracted ${extractor.name} = ${JSON.stringify(value)}`);
-                }
-                else if (extractor.default !== undefined) {
-                    context.extracted_data[extractor.name] = extractor.default;
-                }
-            }
-            catch (error) {
-                logger_1.logger.debug(`Extraction failed for ${extractor.name}: ${error}`);
-                if (extractor.default !== undefined) {
-                    context.extracted_data[extractor.name] = extractor.default;
-                }
-            }
-        }
-    }
-    async extractCustom(script, result, context) {
-        try {
-            const fn = new Function('result', 'context', `return ${script}`);
-            return fn(result, context);
-        }
-        catch (error) {
-            return null;
-        }
-    }
-    getJsonPath(obj, path) {
-        const keys = path.replace(/^\$\./, '').split('.');
-        return keys.reduce((current, key) => {
-            if (key.includes('[') && key.includes(']')) {
-                const [prop, index] = key.split(/[\[\]]/);
-                return current && current[prop] && current[prop][parseInt(index)];
-            }
-            return current && current[key];
-        }, typeof obj === 'string' ? JSON.parse(obj) : obj);
     }
 }
 exports.StepExecutor = StepExecutor;

package/dist/core/strategies/index.d.ts

@@ -0,0 +1,2 @@
+export { ThinkTimeStrategy } from './think-time-strategy';
+export { ScenarioSelector } from './scenario-selector';

package/dist/core/strategies/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScenarioSelector = exports.ThinkTimeStrategy = void 0;
+var think_time_strategy_1 = require("./think-time-strategy");
+Object.defineProperty(exports, "ThinkTimeStrategy", { enumerable: true, get: function () { return think_time_strategy_1.ThinkTimeStrategy; } });
+var scenario_selector_1 = require("./scenario-selector");
+Object.defineProperty(exports, "ScenarioSelector", { enumerable: true, get: function () { return scenario_selector_1.ScenarioSelector; } });

package/dist/core/strategies/scenario-selector.d.ts

@@ -0,0 +1,13 @@
+import { Scenario } from '../../config/types/hooks';
+export declare class ScenarioSelector {
+    /**
+     * Select scenarios based on weights using proportional distribution.
+     *
+     * Weights determine the probability of a scenario being selected:
+     * - scenario1 (weight: 50) + scenario2 (weight: 25) + scenario3 (weight: 25) = 100
+     * - 50% of VUs will run scenario1, 25% scenario2, 25% scenario3
+     *
+     * If weights don't sum to 100, they are normalized proportionally.
+     */
+    selectScenarios(scenarios: Scenario[]): Scenario[];
+}