Add pm.require API

Author: coditva

lib/postman-sandbox.js

@@ -93,6 +93,7 @@ class PostmanSandbox extends UniversalVM {
             executionEventName = 'execution.result.' + id,
             executionTimeout = _.get(options, 'timeout', this.executionTimeout),
             cursor = _.clone(_.get(options, 'cursor', {})), // clone the cursor as it travels through IPC for mutation
+            requireFileCache = _.get(options, 'requireFileResolver'),
             debugMode = _.has(options, 'debug') ? options.debug : this.debug;
 
         let waiting;
@@ -126,6 +127,7 @@ class PostmanSandbox extends UniversalVM {
             cursor: cursor,
             debug: debugMode,
             timeout: executionTimeout,
+            requireFileCache: requireFileCache,
             legacy: _.get(options, 'legacy')
         });
     }

lib/sandbox/execute.js

@@ -9,6 +9,7 @@ const _ = require('lodash'),
     PostmanTimers = require('./timers'),
     PostmanAPI = require('./pmapi'),
     PostmanCookieStore = require('./cookie-store'),
+    createPostmanRequire = require('./pm-require'),
 
     EXECUTION_RESULT_EVENT_BASE = 'execution.result.',
     EXECUTION_REQUEST_EVENT_BASE = 'execution.request.',
@@ -228,6 +229,7 @@ module.exports = function (bridge, glob) {
                     },
                     dispatchAssertions,
                     new PostmanCookieStore(id, bridge, timers),
+                    createPostmanRequire(options.requireFileCache, scope),
                     {
                         disabledAPIs: initializationOptions.disabledAPIs
                     })

lib/sandbox/pm-require.js

@@ -0,0 +1,91 @@
+const MODULE_KEY = '__module_obj', // why not use `module`?
+    MODULE_WRAPPER = [
+        '(function (exports, module) {\n',
+        `\n})(${MODULE_KEY}.exports, ${MODULE_KEY});`
+    ];
+
+class PostmanRequireStore {
+    constructor (fileCache) {
+        this.fileCache = fileCache || {};
+    }
+
+    getResolvedPath (path) {
+        if (this.hasFile(path)) {
+            return path;
+        }
+    }
+
+    hasFile (path) {
+        return Boolean(this.fileCache[path]);
+    }
+
+    getFileData (path) {
+        return this.hasFile(path) && this.fileCache[path].data;
+    }
+}
+
+function createPostmanRequire (fileCache, scope) {
+    const store = new PostmanRequireStore(fileCache),
+        cache = {};
+
+    return function postmanRequire (name) {
+        const path = store.getResolvedPath(name);
+
+        // Any module should not be evaluated twice, so we use it from the
+        // cache. If there's a circular dependency, the partially evaluated
+        // module will be returned from the cache.
+        if (cache[path]) {
+            // Always use the resolved path as the ID of the module. This
+            // ensures that relative paths are handled correctly.
+            return cache[path].exports;
+        }
+
+        /* eslint-disable-next-line one-var */
+        const file = path && store.getFileData(path);
+
+        if (!file) {
+            // Error should contain the name exactly as the user specified,
+            // and not the resolved path.
+            throw new Error(`Cannot find module '${name}'`);
+        }
+
+        /* eslint-disable-next-line one-var */
+        const moduleObj = {
+            id: path,
+            exports: {}
+        };
+
+        // Add to cache before executing. This ensures that any dependency
+        // that tries to import it's parent/ancestor gets the cached
+        // version and not end up in infinite loop.
+        cache[moduleObj.id] = moduleObj;
+
+        /* eslint-disable-next-line one-var */
+        const wrappedModule = MODULE_WRAPPER[0] + file + MODULE_WRAPPER[1];
+
+        scope.import({
+            [MODULE_KEY]: moduleObj
+        });
+
+        // Note: We're executing the code in the same scope as the one
+        // which called the `pm.require` function. This is because we want
+        // to share the global scope across all the required modules. Any
+        // locals are available inside the required modules and any locals
+        // created inside the required modules are available to the parent.
+        //
+        // Why `async` = true?
+        //   - We want to allow execution of async code like setTimeout etc.
+        scope.exec(wrappedModule, true, (err) => {
+            // Bubble up the error to be caught as execution error
+            if (err) {
+                throw err;
+            }
+        });
+
+        scope.unset(MODULE_KEY);
+
+        return moduleObj.exports;
+    };
+}
+
+module.exports = createPostmanRequire;

lib/sandbox/pmapi.js

@@ -47,10 +47,11 @@ const _ = require('lodash'),
  * @param {Function} onSkipRequest - callback to execute when pm.execution.skipRequest() called
  * @param {Function} onAssertion - callback to execute when pm.expect() called
  * @param {Object} cookieStore - cookie store
+ * @param {Function} require - require
  * @param {Object} [options] - options
  * @param {Array.<String>} [options.disabledAPIs] - list of disabled APIs
  */
-function Postman (execution, onRequest, onSkipRequest, onAssertion, cookieStore, options = {}) {
+function Postman (execution, onRequest, onSkipRequest, onAssertion, cookieStore, require, options = {}) {
     // @todo - ensure runtime passes data in a scope format
     let iterationData = new VariableScope();
 
@@ -291,7 +292,9 @@ function Postman (execution, onRequest, onSkipRequest, onAssertion, cookieStore,
                  */
                 current: execution.legacy._eventItemName
             })
-        }
+        },
+
+        require: require
     }, options.disabledAPIs);
 
     // extend pm api with test runner abilities

package-lock.json

@@ -92,7 +92,7 @@
     "terser": "^5.24.0",
     "tsd-jsdoc": "^2.5.0",
     "tv4": "1.3.0",
-    "uniscope": "2.0.1",
+    "uniscope": "github:postmanlabs/uniscope#feat/options-reset-locals",
     "watchify": "^4.0.0",
     "xml2js": "0.4.23"
   },