Proposal: add optional cache for tables

[serjek]

I am thinking about something like this:

class Db extends tink.sql.Database {
  @:table @:cache var DataPoints:DataPoints;
}

where @:cache will generate an internal class like this:

class Memcached<T> implements coconut.data.Model {
	@:constant var loadData:Void->Promise<Array<T>>;
	@:constant var dbInsertOne:T->Promise<Noise> = @byDefault _ -> Promise.lift(new Error("not implemented"));
	@:constant var dbInsertMany:Array<T>->Promise<Noise> = @byDefault _ -> Promise.lift(new Error("not implemented"));

	@:loaded var loadedData:Vector<T> = loadData().next(Vector.fromArray);
	@:computed var data:Vector<T> = loadedData.or(Vector.empty()) & cachedData;
	@:computed var isLoaded:Bool = loadedData != Loading;
	@:observable var cachedData:Vector<T> = Vector.empty();

	@:transition function insertOne(v:T) {
		dbInsertOne(v).handle(v -> switch v {
			case Success(_):
			case Failure(e): throw e;
		});
		return {cachedData: cachedData & v}
	}
	@:transition function insertMany(v:Array<T>) {
		dbInsertMany(v).handle(v -> switch v {
			case Success(_):
			case Failure(e): throw e;
		});
		return {cachedData: cachedData & Vector.fromArray(v)}
	}
}

and declared like this

var memcachedDataPoints:Memcached<DataPoints> = new Memcached({
  loadData: db.DataPoints.select().all,
  dbInsertOne: db.DataPoints.insertOne,
  dbInsertMany: db.DataPoints.insertMany
});

And then data still can be accessed (set/get) directly through table declaration, with data flow processed by memcached middleware.

Pro: easy to use application level cache with unified and clean api
Con: extra dependency (coconut)