proxy.js

const { log, clear } = console
clear()

class Foo {
  constructor() {
    this.state = {}
    this.util = {
      nested: {
        mergeRight,
        identity,
      }
    }
  }
  update(x) {
    this.state = this.util.nested.mergeRight(
      this.state, 
      this.util.nested.identity(x),
    )
  }
  log() {
    log(this.state)
  }
  updateLog(x) {
    this.update(x)
    this.log()
  }
}

// Spec :: { [String]: (Function -> (...args) -> Any) }
// makeProxy :: [String] -> Spec -> Instance|Object -> Proxy
const makeProxy = curry((path, spec, data) =>
    new Proxy(data, {
        get: (target, propKey, reciever) =>
            is(String)(head(path))
                ? equals(head(path), propKey)
                    ? makeProxy(tail(path), spec, target[propKey])
                    : target[propKey]
                : includes(propKey, keys(spec))
                    ? spec[propKey](Reflect.get(target, propKey, reciever))
                    : target[propKey]
    })
)

class Baz {
  constructor(foo, rabbit) {
    this.foo = makeProxy(
      ['util', 'nested'],
      {
        mergeRight: (method) => (...args) => {
          const result = method(...args)
          log(`mergeRight interception`)
          return result
        },
        identity: (method) => (...args) => {
          const result = method(...args)
          log(`identity interception`)
          return result
        },
      },
      foo
    )
  }
  updateLog(x) {
    this.foo.updateLog(x)
  }
}

const foo = new Foo()
const bar = new Baz(foo)

bar.updateLog({ one: 'one' })
bar.updateLog({ two: 'two' })
bar.updateLog({ one: 'foo' })