Safe Proxy

safeProxy.js

Object.prototype.toSafeProxy = function() {
	const getter = (target, name, receiver) => {
		const value = target[name]
		
		if (value == null) {
			return nullProxy(value)
		} else if (typeof value === 'object') {
			return value.toSafeProxy()
		} else if (typeof value === 'function') {
			return value
		} else {
			return primitiveProxy(value)
		}
	}

	const nullProxy = (value) => {
		return new Proxy({
				value: () => value,
				fallbackTo: fallback => fallback,
				flatMap: () => value
			}, { get: getter })
	}
	
	const primitiveProxy = (value) => {
		return new Proxy({
				value: () => value,
				fallbackTo: () => value,
				flatMap: map => map(value)
			}, { get: getter })
	}
	
	return new Proxy(Object.assign({}, this, { 
		fallbackTo: () => this,
		flatMap: map => map(this)
	}), {
		get: getter
	})
}

This is an attempt to recreate Swift's optional chaining and nil coalescing feature.
I don't like the fact that I have to access value() to fetch primitive values but it's a work in progress!

The current usage is the following:
someObject.toSafeProxy().aKey.anotherKey.somethingThatMayNotExist.fallbackTo('some fallback value')

Added flatMap to the safe proxies