This is a catch-all for the initial design and implementation of the Observable Entities feature.
Observable Entities is an API that provides ObservableCollections of entities, that have dual representations as proxy-backed implementations of an entity interface (optional) and an ObservableEntity structure that provides each field of the entity as a SettableValue.
The initial work is currently in org.observe.entity. There is a JDBC implementation that at one point was indeed serving entities correctly, though very few operations were tested. There's a completely untested beginning of a JSON-implementation (backed by a second, remote entity implementation) as well.
Checklists: (These do not necessarily need to be done in order. In particular, the JDBC implementation should be done immediately after the critical API elements are worked out.)
API
[ ] Transactionality: Batch operations until the caller releases the write transaction on the entity set.
[ ] Collections, Maps, Value Sets: Implement these structures for entity fields
[ ] Pre-filtered changes: The entity provider should not need to send changes for entities that the entity set doesn't care about (no active query or lookup by ID)
[ ] Access and modification control: providers should be able to advertise which entity operations are allowed (potentially including queries, i.e. the provider could choose to advertise that there is data that the client does not have access to).
[ ] Delete cascading. E.g. deleting an entity would wipe out all entities that "depend" on it
[ ] Migration: Tweak Entity Migration to work with Observable Entities
This might best be done as a utility that providers can utilize to do the migration, since the entity set framework itself is not flexible in its fields
Providers
[ ] Complete JDBC provider
[ ] Initial simple field-based CRUD functionality against H2
[ ] Collections and maps
[ ] Prepared statements
[ ] Other DB dialects (use Hibernate dialects?)
[ ] Migration
[ ] ObservableConfig
Would be nice to unify the ObservableConfig and Observable Entity APIs to enable code to transition from the simpler ObservableConfig backing to a more robust Observable Entity backing.
[ ] Complete JSON provider
[ ] Only send updates for entities that the client is interested in
[ ] Cassandra provider
[ ] Entity subset
Synchronizes a subset of entities between a server entity set and a client entity set for fast access and to decrease the global load on the server
Tests
[ ] General ObservableConfig-backed test
[ ] General simple field-base CRUD
[ ] Collections and Maps
[ ] Prepared statements
[ ] Tests for each provider, including multiple JDBC dialects
This is a catch-all for the initial design and implementation of the Observable Entities feature.
Observable Entities is an API that provides ObservableCollections of entities, that have dual representations as proxy-backed implementations of an entity interface (optional) and an ObservableEntity structure that provides each field of the entity as a SettableValue.
The initial work is currently in org.observe.entity. There is a JDBC implementation that at one point was indeed serving entities correctly, though very few operations were tested. There's a completely untested beginning of a JSON-implementation (backed by a second, remote entity implementation) as well.
Checklists: (These do not necessarily need to be done in order. In particular, the JDBC implementation should be done immediately after the critical API elements are worked out.)
API
Providers
Tests