Support Two-way Data Binding

[Yeuoly]

What about planning to support two-way Data Binding in future?

1. we can use Observable in the frontend to enable monitoring and changing data, if there is any modification, the modern frontend framework like React/Vue can update pages immediately
2. In the backend, while we can offer an Observable[T any] struct with Update() method like this

type Observable[T any] struct {
	data *T
}

func NewObservable[T any](data *T) *Observable[T] {
	return &Observable[T]{
		data: data,
	}
}

func (o *Observable[T]) Update() {
	// use websocket to update the data on the frontend
}

func Foo() {
	data := "hello"
	observable := NewObservable(&data)

	// update
	data = "world"
	observable.Update()
}

If changes are made to the frontend data, the corresponding backend data will be updated instantly. Additionally, invoking the Update() method ensures that the frontend data is also synchronized. However, it's important to note that implementing these features involves a substantial amount of work."

I hope this helps! Let me know if you have any further requests or if there's anything else I can assist you with.

[leaanthony]

I did introduce the concept of a "store" in v1 but had to drop it. It wasn't as easy as you might think. Things to consider:

• Initial state sync
• Updates from frontend to backend
• Using a pointer to data instead of a copy leads to unsafe concurrent use

[Yeuoly]

How about designing an abstract store? It would be independent of the frontend and backend, serving as an abstract entity that provides APIs to both the frontend and backend. For instance, on the frontend, you could implement the interface using Observable, while on the backend, it could be Observable[T any]. The data in this store doesn't reside in the frontend but rather in the backend, and the synchronization between the frontend and backend is maintained within the Wails environment. Users are not allowed to modify data arbitrarily; instead, they need to access the corresponding API in a secure environment when they want to read or modify data.

Like this

func (o *Observable[T]) Read(fn func(data T)) {
	o.lock.RLock()
	defer o.lock.RUnlock()
	fn(*o.data)
}

func (o *Observable[T]) Update(fn func(data *T)) {
	o.lock.Lock()
	defer o.lock.Unlock()
	fn(o.data)
	// sync to the frontend
}

func Foo() {
	observable := NewObservable[string]("hello")

	observable.Update(func(data *string) {
		*data = "world"
	})
}

[leaanthony]

You would still have data race conditions. Having data T would be better but creating a new T it owned and updates could only happen via methods is what we need.

[Yeuoly]

Yes, it is highly possible that there could be issues of race conditions in a simple implementation. That's why I want to accomplish this task through a middleware. Whether it's on the frontend or backend, reading or modifying data needs to be done under the protection of the middleware. The data synchronization between the frontend and backend middleware is maintained by Wails, which helps to solve many problems.