feat: ✨ Created a mini nodeJS server with NewMan for testing without PostMan GUI.

This will mimic a run in a CD/CI environment or docker container.

node_modules/postman-collection/lib/collection/mutation-tracker.js

@@ -0,0 +1,243 @@
+var _ = require('../util').lodash,
+    PropertyBase = require('./property-base').PropertyBase,
+
+    /**
+     * Primitive mutation types.
+     *
+     * @private
+     * @constant
+     * @type {Object}
+     */
+    PRIMITIVE_MUTATIONS = {
+        SET: 'set',
+        UNSET: 'unset'
+    },
+
+    /**
+     * Detects if the mutation is a primitive mutation type. A primitive mutation is the simplified mutation structure.
+     *
+     * @private
+     * @param {MutationTracker.mutation} mutation -
+     * @returns {Boolean}
+     */
+    isPrimitiveMutation = function (mutation) {
+        return mutation && mutation.length <= 2;
+    },
+
+    /**
+     * Applies a single mutation on a target.
+     *
+     * @private
+     * @param {*} target -
+     * @param {MutationTracker.mutation} mutation -
+     */
+    applyMutation = function applyMutation (target, mutation) {
+        // only `set` and `unset` instructions are supported
+        // for non primitive mutations, the instruction would have to be extracted from mutation
+        /* istanbul ignore if */
+        if (!isPrimitiveMutation(mutation)) {
+            return;
+        }
+
+        // extract instruction from the mutation
+        var operation = mutation.length > 1 ? PRIMITIVE_MUTATIONS.SET : PRIMITIVE_MUTATIONS.UNSET;
+
+        // now hand over applying mutation to the target
+        target.applyMutation(operation, ...mutation);
+    },
+
+    MutationTracker;
+
+/**
+ * A JSON representation of a mutation on an object. Here objects mean instances of postman-collection classes.
+ * This captures the instruction and the parameters of the instruction so that it can be replayed on a different object.
+ * Mutations can be any change on an object. For example setting a key or unsetting a key.
+ *
+ * For example, the mutation to set `name` on an object to 'Bruce Wayne' would look like ['name', 'Bruce Wayne']. Where
+ * the first item is the key path and second item is the value. To add a property `punchLine` to the object it would be
+ * the same as updating the property i.e. ['punchLine', 'I\'m Batman']. To remove a property `age` the mutation would
+ * look like ['age'].
+ *
+ * This format of representing changes is derived from
+ * {@link http://json-delta.readthedocs.io/en/latest/philosophy.html}.
+ *
+ * The `set` and `unset` are primitive instructions and can be derived from the mutation without explicitly stating the
+ * instruction. For more complex mutation the instruction would have to be explicitly stated.
+ *
+ * @typedef {Array} MutationTracker.mutation
+ */
+
+/**
+ * A JSON representation of the MutationTracker.
+ *
+ * @typedef MutationTracker.definition
+ *
+ * @property {Array} stream contains the stream mutations tracked
+ * @property {Object} compacted contains a compacted version of the mutations
+ * @property {Boolean} [autoCompact=false] when set to true, all new mutations would be compacted immediately
+ */
+_.inherit((
+
+    /**
+     * A MutationTracker allows to record mutations on any of object and store them. This stored mutations can be
+     * transported for reporting or to replay on similar objects.
+     *
+     * @constructor
+     * @extends {PropertyBase}
+     *
+     * @param {MutationTracker.definition} definition serialized mutation tracker
+     */
+    MutationTracker = function MutationTracker (definition) {
+        // this constructor is intended to inherit and as such the super constructor is required to be executed
+        MutationTracker.super_.call(this, definition);
+
+        definition = definition || {};
+
+        // initialize options
+        this.autoCompact = Boolean(definition.autoCompact);
+
+        // restore mutations
+        this.stream = Array.isArray(definition.stream) ? definition.stream : [];
+        this.compacted = _.isPlainObject(definition.compacted) ? definition.compacted : {};
+    }), PropertyBase);
+
+_.assign(MutationTracker.prototype, /** @lends MutationTracker.prototype */ {
+
+    /**
+     * Records a new mutation.
+     *
+     * @private
+     * @param {MutationTracker.mutation} mutation -
+     */
+    addMutation (mutation) {
+        // bail out for empty or unsupported mutations
+        if (!(mutation && isPrimitiveMutation(mutation))) {
+            return;
+        }
+
+        // if autoCompact is set, we need to compact while adding
+        if (this.autoCompact) {
+            this.addAndCompact(mutation);
+
+            return;
+        }
+
+        // otherwise just push to the stream of mutations
+        this.stream.push(mutation);
+    },
+
+    /**
+     * Records a mutation compacting existing mutations for the same key path.
+     *
+     * @private
+     * @param {MutationTracker.mutation} mutation -
+     */
+    addAndCompact (mutation) {
+        // for `set` and `unset` mutations the key to compact with is the `keyPath`
+        var key = mutation[0];
+
+        // convert `keyPath` to a string
+        key = Array.isArray(key) ? key.join('.') : key;
+
+        this.compacted[key] = mutation;
+    },
+
+    /**
+     * Track a mutation.
+     *
+     * @param {String} instruction the type of mutation
+     * @param {...*} payload mutation parameters
+     */
+    track (instruction, ...payload) {
+        // invalid call
+        if (!(instruction && payload)) {
+            return;
+        }
+
+        // unknown instruction
+        if (!(instruction === PRIMITIVE_MUTATIONS.SET || instruction === PRIMITIVE_MUTATIONS.UNSET)) {
+            return;
+        }
+
+        // for primitive mutations the arguments form the mutation object
+        // if there is more complex mutation, we have to use a processor to create a mutation for the instruction
+        this.addMutation(payload);
+    },
+
+    /**
+     * Compacts the recorded mutations removing duplicate mutations that apply on the same key path.
+     */
+    compact () {
+        // for each of the mutation, add to compacted list
+        this.stream.forEach(this.addAndCompact.bind(this));
+
+        // reset the `stream`, all the mutations are now recorded in the `compacted` storage
+        this.stream = [];
+    },
+
+    /**
+     * Returns the number of mutations tracked so far.
+     *
+     * @returns {Number}
+     */
+    count () {
+        // the total count of mutations is the sum of
+        // mutations in the stream
+        var mutationCount = this.stream.length;
+
+        // and the compacted mutations
+        mutationCount += Object.keys(this.compacted).length;
+
+        return mutationCount;
+    },
+
+    /**
+     * Applies all the recorded mutations on a target object.
+     *
+     * @param {*} target Target to apply mutations. Must implement `applyMutation`.
+     */
+    applyOn (target) {
+        if (!(target && target.applyMutation)) {
+            return;
+        }
+
+        var applyIndividualMutation = function applyIndividualMutation (mutation) {
+            applyMutation(target, mutation);
+        };
+
+        // mutations move from `stream` to `compacted`, so we apply the compacted mutations first
+        // to ensure FIFO of mutations
+
+        // apply the compacted mutations first
+        _.forEach(this.compacted, applyIndividualMutation);
+
+        // apply the mutations in the stream
+        _.forEach(this.stream, applyIndividualMutation);
+    }
+});
+
+_.assign(MutationTracker, /** @lends MutationTracker */ {
+    /**
+     * Defines the name of this property for internal use.
+     *
+     * @private
+     * @readOnly
+     * @type {String}
+     */
+    _postman_propertyName: 'MutationTracker',
+
+    /**
+     * Check whether an object is an instance of {@link MutationTracker}.
+     *
+     * @param {*} obj -
+     * @returns {Boolean}
+     */
+    isMutationTracker: function (obj) {
+        return Boolean(obj) && ((obj instanceof MutationTracker) ||
+            _.inSuperChain(obj.constructor, '_postman_propertyName', MutationTracker._postman_propertyName));
+    }
+});
+
+module.exports = {
+    MutationTracker
+};