postman-runtime 7.51.1 → 7.52.0-beta.2

package/lib/runner/extensions/item.command.js

@@ -2,6 +2,7 @@ var _ = require('lodash'),
     uuid = require('uuid'),
     Response = require('postman-collection').Response,
     visualizer = require('../../visualizer'),
+    resolveSecrets = require('../resolve-secrets').resolveSecrets,
 
     /**
      * List of request properties which can be mutated via pre-request
@@ -121,7 +122,11 @@ module.exports = {
                 stopOnFailure = this.options.stopOnFailure,
                 delay = _.get(this.options, 'delay.item'),
 
-                ctxTemplate;
+                ctxTemplate,
+                self = this,
+                secretResolvers = this.state.secretResolvers,
+                secretResolutionPayload,
+                executeItemFlow;
 
             // validate minimum parameters required for the command to work
             if (!(item && coords)) {
@@ -134,159 +139,197 @@ module.exports = {
             // here we code to queue prerequest script, then make a request and then execute test script
             this.triggers.beforeItem(null, coords, item);
 
-            this.queueDelay(function () {
+            // Build payload for secret resolution
+            // Only scan environment, globals, and collectionVariables for secrets
+            secretResolutionPayload = {
+                item,
+                environment,
+                globals,
+                collectionVariables
+            };
+
+            /**
+             * Execute the main item flow (delay, prerequest, request, test)
+             */
+            executeItemFlow = function () {
+                self.queueDelay(function () {
                 // create the context object for scripts to run
-                ctxTemplate = {
-                    collectionVariables: collectionVariables,
-                    vaultSecrets: vaultSecrets,
-                    _variables: _variables,
-                    globals: globals,
-                    environment: environment,
-                    data: data,
-                    request: item.request
-                };
-
-                // @todo make it less nested by coding Instruction.thenQueue
-                this.queue('event', {
-                    name: 'prerequest',
-                    item: item,
-                    coords: coords,
-                    context: ctxTemplate,
-                    // No need to include vaultSecrets here as runtime takes care of tracking internally
-                    trackContext: ['globals', 'environment', 'collectionVariables'],
-                    stopOnScriptError: stopOnError,
-                    stopOnFailure: stopOnFailure
-                }).done(function (prereqExecutions, prereqExecutionError, shouldSkipExecution) {
-                    // if stop on error is marked and script executions had an error,
-                    // do not proceed with more commands, instead we bail out
-                    if ((stopOnError || stopOnFailure) && prereqExecutionError) {
-                        this.triggers.item(null, coords, item); // @todo - should this trigger receive error?
-
-                        return callback && callback.call(this, prereqExecutionError, {
-                            prerequest: prereqExecutions
-                        });
-                    }
-
-                    if (shouldSkipExecution) {
-                        this.triggers.item(prereqExecutionError, coords, item, null, { isSkipped: true });
-
-                        return callback && callback.call(this, prereqExecutionError, {
-                            prerequest: prereqExecutions
-                        });
-                    }
-
-                    // update allowed request mutation properties with the mutated context
-                    // @note from this point forward, make sure this mutated
-                    // request instance is used for upcoming commands.
-                    ALLOWED_REQUEST_MUTATIONS.forEach(function (property) {
-                        if (_.has(ctxTemplate, ['request', property])) {
-                            item.request[property] = ctxTemplate.request[property];
-                        }
-
-                        // update property's parent reference
-                        if (item.request[property] && typeof item.request[property].setParent === 'function') {
-                            item.request[property].setParent(item.request);
-                        }
-                    });
-
-                    this.queue('request', {
+                    ctxTemplate = {
+                        collectionVariables: collectionVariables,
+                        vaultSecrets: vaultSecrets,
+                        _variables: _variables,
+                        globals: globals,
+                        environment: environment,
+                        data: data,
+                        request: item.request
+                    };
+
+                    // @todo make it less nested by coding Instruction.thenQueue
+                    this.queue('event', {
+                        name: 'prerequest',
                         item: item,
-                        vaultSecrets: ctxTemplate.vaultSecrets,
-                        globals: ctxTemplate.globals,
-                        environment: ctxTemplate.environment,
-                        collectionVariables: ctxTemplate.collectionVariables,
-                        _variables: ctxTemplate._variables,
-                        data: ctxTemplate.data,
                         coords: coords,
-                        source: 'collection'
-                    }).done(function (result, requestError) {
-                        !result && (result = {});
-
-                        var request = result.request,
-                            response = result.response,
-                            cookies = result.cookies;
-
-                        if ((stopOnError || stopOnFailure) && requestError) {
+                        context: ctxTemplate,
+                        // No need to include vaultSecrets here as runtime takes care of tracking internally
+                        trackContext: ['globals', 'environment', 'collectionVariables'],
+                        stopOnScriptError: stopOnError,
+                        stopOnFailure: stopOnFailure
+                    }).done(function (prereqExecutions, prereqExecutionError, shouldSkipExecution) {
+                    // if stop on error is marked and script executions had an error,
+                    // do not proceed with more commands, instead we bail out
+                        if ((stopOnError || stopOnFailure) && prereqExecutionError) {
                             this.triggers.item(null, coords, item); // @todo - should this trigger receive error?
 
-                            return callback && callback.call(this, requestError, {
-                                request
+                            return callback && callback.call(this, prereqExecutionError, {
+                                prerequest: prereqExecutions
                             });
                         }
 
-                        // also the test object requires the updated request object (since auth helpers may modify it)
-                        request && (ctxTemplate.request = request);
+                        if (shouldSkipExecution) {
+                            this.triggers.item(prereqExecutionError, coords, item, null, { isSkipped: true });
 
-                        // @note convert response instance to plain object.
-                        // we want to avoid calling Response.toJSON() which triggers toJSON on Response.stream buffer.
-                        // Because that increases the size of stringified object by 3 times.
-                        // Also, that increases the total number of tokens (buffer.data) whereas Buffer.toString
-                        // generates a single string that is easier to stringify and sent over the UVM bridge.
-                        response && (ctxTemplate.response = getResponseJSON(response));
+                            return callback && callback.call(this, prereqExecutionError, {
+                                prerequest: prereqExecutions
+                            });
+                        }
 
-                        // set cookies for this transaction
-                        cookies && (ctxTemplate.cookies = cookies);
+                        // update allowed request mutation properties with the mutated context
+                        // @note from this point forward, make sure this mutated
+                        // request instance is used for upcoming commands.
+                        ALLOWED_REQUEST_MUTATIONS.forEach(function (property) {
+                            if (_.has(ctxTemplate, ['request', property])) {
+                                item.request[property] = ctxTemplate.request[property];
+                            }
 
-                        // the context template also has a test object to store assertions
-                        ctxTemplate.tests = {}; // @todo remove
+                            // update property's parent reference
+                            if (item.request[property] && typeof item.request[property].setParent === 'function') {
+                                item.request[property].setParent(item.request);
+                            }
+                        });
 
-                        this.queue('event', {
-                            name: 'test',
+                        this.queue('request', {
                             item: item,
+                            vaultSecrets: ctxTemplate.vaultSecrets,
+                            globals: ctxTemplate.globals,
+                            environment: ctxTemplate.environment,
+                            collectionVariables: ctxTemplate.collectionVariables,
+                            _variables: ctxTemplate._variables,
+                            data: ctxTemplate.data,
                             coords: coords,
-                            context: ctxTemplate,
-                            // No need to include vaultSecrets here as runtime takes care of tracking internally
-                            trackContext: ['tests', 'globals', 'environment', 'collectionVariables'],
-                            stopOnScriptError: stopOnError,
-                            abortOnFailure: abortOnFailure,
-                            stopOnFailure: stopOnFailure
-                        }).done(function (testExecutions, testExecutionError) {
-                            var visualizerData = extractVisualizerData(prereqExecutions, testExecutions),
-                                visualizerResult;
-
-                            if (visualizerData) {
-                                visualizer.processTemplate(visualizerData.template,
-                                    visualizerData.data,
-                                    visualizerData.options,
-                                    function (err, processedTemplate) {
-                                        visualizerResult = {
-                                            // bubble up the errors while processing template through visualizer result
-                                            error: err,
+                            source: 'collection'
+                        }).done(function (result, requestError) {
+                            !result && (result = {});
+
+                            var request = result.request,
+                                response = result.response,
+                                cookies = result.cookies;
 
-                                            // add processed template and data to visualizer result
-                                            processedTemplate: processedTemplate,
-                                            data: visualizerData.data
-                                        };
+                            if ((stopOnError || stopOnFailure) && requestError) {
+                                this.triggers.item(null, coords, item); // @todo - should this trigger receive error?
 
-                                        // trigger an event saying that item has been processed
-                                        this.triggers.item(null, coords, item, visualizerResult);
-                                    }.bind(this));
+                                return callback && callback.call(this, requestError, {
+                                    request
+                                });
                             }
-                            else {
+
+                            // also the test object requires the updated request object
+                            // (since auth helpers may modify it)
+                            request && (ctxTemplate.request = request);
+
+                            // @note convert response instance to plain object.
+                            // we want to avoid calling Response.toJSON() which triggers
+                            // toJSON on Response.stream buffer.
+                            // Because that increases the size of stringified object by 3 times.
+                            // Also, that increases the total number of tokens (buffer.data) whereas Buffer.toString
+                            // generates a single string that is easier to stringify and sent over the UVM bridge.
+                            response && (ctxTemplate.response = getResponseJSON(response));
+
+                            // set cookies for this transaction
+                            cookies && (ctxTemplate.cookies = cookies);
+
+                            // the context template also has a test object to store assertions
+                            ctxTemplate.tests = {}; // @todo remove
+
+                            this.queue('event', {
+                                name: 'test',
+                                item: item,
+                                coords: coords,
+                                context: ctxTemplate,
+                                // No need to include vaultSecrets here as runtime takes care of tracking internally
+                                trackContext: ['tests', 'globals', 'environment', 'collectionVariables'],
+                                stopOnScriptError: stopOnError,
+                                abortOnFailure: abortOnFailure,
+                                stopOnFailure: stopOnFailure
+                            }).done(function (testExecutions, testExecutionError) {
+                                var visualizerData = extractVisualizerData(prereqExecutions, testExecutions),
+                                    visualizerResult;
+
+                                if (visualizerData) {
+                                    visualizer.processTemplate(visualizerData.template,
+                                        visualizerData.data,
+                                        visualizerData.options,
+                                        function (err, processedTemplate) {
+                                            visualizerResult = {
+                                            // bubble up the errors while processing template through visualizer result
+                                                error: err,
+
+                                                // add processed template and data to visualizer result
+                                                processedTemplate: processedTemplate,
+                                                data: visualizerData.data
+                                            };
+
+                                            // trigger an event saying that item has been processed
+                                            this.triggers.item(null, coords, item, visualizerResult);
+                                        }.bind(this));
+                                }
+                                else {
                                 // trigger an event saying that item has been processed
                                 // @todo - should this trigger receive error?
-                                this.triggers.item(null, coords, item, null);
-                            }
-
-                            // reset mutated request with original request instance
-                            // @note request mutations are not persisted across iterations
-                            item.request = originalRequest;
-
-                            callback && callback.call(this, ((stopOnError || stopOnFailure) && testExecutionError) ?
-                                testExecutionError : null, {
-                                prerequest: prereqExecutions,
-                                request: request,
-                                response: response,
-                                test: testExecutions
+                                    this.triggers.item(null, coords, item, null);
+                                }
+
+                                // reset mutated request with original request instance
+                                // @note request mutations are not persisted across iterations
+                                item.request = originalRequest;
+
+                                callback && callback.call(this, ((stopOnError || stopOnFailure) && testExecutionError) ?
+                                    testExecutionError : null, {
+                                    prerequest: prereqExecutions,
+                                    request: request,
+                                    response: response,
+                                    test: testExecutions
+                                });
                             });
                         });
                     });
+                }.bind(self), {
+                    time: delay,
+                    source: 'item',
+                    cursor: coords
+                }, next);
+            };
+
+            // Resolve secrets before pre-request scripts so scripts can access resolved values via related pm APIs
+            if (secretResolvers) {
+                resolveSecrets(secretResolutionPayload, secretResolvers, function (err) {
+                    if (err) {
+                        // Secret resolution failed - this is fatal for the current item
+                        // (same pattern as pre-request script skip)
+                        self.triggers.item(err, coords, item, null, { isSecretResolutionFailed: true });
+
+                        callback && callback.call(self, err, {
+                            request: null
+                        });
+
+                        return next();
+                    }
+
+                    executeItemFlow();
                 });
-            }.bind(this), {
-                time: delay,
-                source: 'item',
-                cursor: coords
-            }, next);
+            }
+            else {
+                executeItemFlow();
+            }
         }
     }
 };

package/lib/runner/extensions/request.command.js

@@ -12,21 +12,23 @@ module.exports = {
 
     process: {
         request (payload, next) {
-            var abortOnError = _.has(payload, 'abortOnError') ? payload.abortOnError : this.options.abortOnError,
+            var self = this,
+                abortOnError = _.has(payload, 'abortOnError') ? payload.abortOnError : this.options.abortOnError,
 
-                // helper function to trigger `response` callback anc complete the command
+                // helper function to trigger `response` callback and complete the command
                 complete = function (err, nextPayload) {
                     // nextPayload will be empty for unhandled errors
                     // trigger `response` callback
                     // nextPayload.response will be empty for error flows
                     // the `item` argument is resolved and mutated here
-                    nextPayload && this.triggers.response(err, nextPayload.coords, nextPayload.response,
+                    nextPayload && self.triggers.response(err, nextPayload.coords, nextPayload.response,
                         nextPayload.request, nextPayload.item, nextPayload.cookies, nextPayload.history);
 
                     // the error is passed twice to allow control between aborting the error vs just
                     // bubbling it up
                     return next(err && abortOnError ? err : null, nextPayload, err);
-                }.bind(this),
+                },
+
                 context = createItemContext(payload);
 
             // resolve variables in item and auth
@@ -38,7 +40,7 @@ module.exports = {
             // we do not queue `httprequest` instruction here,
             // queueing will unblock the item command to prepare for the next `event` instruction
             // at this moment request is not fulfilled, and we want to block it
-            this.immediate('httprequest', payload)
+            self.immediate('httprequest', payload)
                 .done(function (nextPayload, err) {
                     // change signature to error first
                     complete(err, nextPayload);

package/lib/runner/index.js

@@ -97,6 +97,14 @@ _.assign(Runner.prototype, {
      * @param {String} [options.entrypoint.lookupStrategy=idOrName] strategy to lookup the entrypoint [idOrName, path]
      * @param {Array<String>} [options.entrypoint.path] path to lookup
      * @param {Object} [options.run] Run-specific options, such as options related to the host
+     * @param {Object} [options.secretResolvers] - Object mapping provider names to resolver configs.
+     * Keys must match secret.source.provider (e.g. postman, azure, 1password, aws, hashicorp).
+     * Each resolver config may have:
+     *   - {String} id - (Required) Unique identifier for the resolver (same as secret.source.provider)
+     *   - {String} name - (Required) Human-readable name for the resolver
+     *   - {Function} resolver - (Required) Function(secret, context) that returns resolved value or Promise
+     *   - {Number} [timeout=5000] - (Optional) Timeout in milliseconds (default: 5000)
+     *   - {Number} [retryCount=0] - (Optional) Number of retry attempts on failure (default: 0)
      *
      * @param {Function} callback -
      */
@@ -147,7 +155,8 @@ _.assign(Runner.prototype, {
                 collectionVariables: collection.variables,
                 localVariables: options.localVariables,
                 certificates: options.certificates,
-                proxies: options.proxies
+                proxies: options.proxies,
+                secretResolvers: options.secretResolvers
             }, runOptions)));
         });
     }