Access properties directly from the entity

When modifying or accessing entity properties, consistently you have to step into the data property:

my_entity.data.my_property
my_entity.data.my_other_property

Compare this to the other gcloud datastore APIs:

Python:

my_entity['my_property']

Ruby:

my_entity[:my_property]

It would be nice if properties could be accessed on the entity directly.

Seems our entities are comprised of key and data properties, so that the user can access their key value by going entity.key instead of entity.__key__ I believe. I'd suspect we'd have to change that if we wanted all the properties to be on the first level of the entity object like you described. Unless we wanted to potentially clobber entity.key but I believe key is not a reserved value as far as datastore is concerned, only __key__ is reserved.

@ryanseys

I think the issue comes specifically because Javascript doesn't allow you to differentiate between a method (entity.key()), a property (entity.key), and an attribute (entity['key']) -- as far as JS is concerned, it's all the same thing.

One option would be to add a getter method for the key (entity.getKey()) as a shortcut for the __key__ attribute.

This doesn't address the issue where things could be blasted out (ie, getKey as a property in Datastore would be blasted out by the getKey method), so if we do something like this we'd need to also expose the "raw data" on the entity object as well.

In short though, I think the common case will be "very few people will have a property called getKey" -- we should optimize for that and allow people "go the long way" (ie, entity.data.getKey) if they are uncommon enough to name a property as that. (Note that apparently property names are allowed to have spaces -- and even start with spaces -- so there will be edge cases that we should make possible but not easy.)

@ryanseys What do you think?

This sounds like a job well-suited for Proxies! Unfortunately Node doesn't universally support those. I think we might be able to get around this by attaching a special getter and setter to the getKey property of the entity object that detects when it's reassigned, and properly diverts the reassignment to the underlying property... I'll see what I can think up.