underlying object is changed

[reimerp]

If you create an object, e.g.

const o = {
  name: 'John Smith',
  password: 'hunter1'
};

and write this to an white-out stream, than the output is correct, but the underlying object is changed as well:

 wo.write(o);
 console.log(o.password);     // XXXXXXX instead of hunter1

This is if you use a censor mode for 'password'. If you try 'remove' than the property of the underlying object is removed. This should not be the desired behavior with streams.

[arb]

Yeah, that's expected. If we clone the incoming object, that's expensive. I agree thought mutation the original object isn't ideal. Do you have any suggestions short of cloning?

[jugaltheshah]

Sorry to comment on this old issue, but I also ran into issues with this due to white-out mutating the object. What about using ES6 proxies like this:

var handler = {
    get: function(obj, prop) {
      switch(prop) {
        case 'secret':
        case 'password':
            return 'XXXXXX'
        default:
            return obj[prop];
      }
    }
};

var target = {
  secret: 'password',
  notsecret: 'hello world'
};

var p = new Proxy(target, handler);

console.log(p.secret); // points to the proxy, outputs 'XXXXXX'
console.log(target.secret); // points to the original object, outputs 'password'

The idea is, white-out would create a proxy for each object it processes. It would still do a recursive traversal to find keys that need to be whited out, but instead of mutating those keys, it would create a getter for that key in the proxy, which would return the censored version when accessed. When done traversing, white-out hands off a reference to this proxy. Net result: the codebase still sees the object as it was before mutating, and whatever comes after would see the censored values. Memory usage is slightly larger than changing the original object, but less so than a deep clone.

Edited for wording / clarity.

[arb]

That's a slick idea! Personally, I would just use another transform stream that clones the incoming object and then passes it on. A stream, in general, should do one thing and in this case, it censors values. Would adding another transform stream into the pipeline be an acceptable solution? I'm positive there is something on npm that is a clone stream or even a proxy stream.

[jugaltheshah]

Thanks! I think using multiple streams makes sense. Furthermore, the possibility of nested objects inside the target makes this proxy idea a bit more complex than I'd thought anyhow.

Actually, the traverse library itself provides a map fn (https://www.npmjs.com/package/traverse#mapfn), the express purpose of which is to assign the result of traversal to a new object rather than modifying the original. How about using that instead of forEach? Would you still want a new stream in that case?

[arb]

Yeah using map instead of forEach might be worth investigating. However per #15, I'm likely going to replace traverse with something that's still currently being maintained so at this point, I'm not really looking to make any changes to white-out with how it uses traverse. If you want to open a PR with a nice warning about mutation that would be good for now and maybe I'll tackle mutation in the next major release.

[jugaltheshah]

Yeah using map instead of forEach might be worth investigating. However per #15, I'm likely going to replace traverse with something that's still currently being maintained so at this point, I'm not really looking to make any changes to white-out with how it uses traverse. If you want to open a PR with a nice warning about mutation that would be good for now and maybe I'll tackle mutation in the next major release.

Done: #16.