building an offline first application that doesn't require extensive custom updates

[chrisdrackett]

We have a current application that is running via a GraphQL API and using mobx state tree on the frontend. Due to some issues around working with graphql linked to mobx state tree and many issues around circular types in typescript we've been looking at replacing our current implantation with something else, potentially urql.

Our biggest concern is that with the number of various lists and interconnected models we have in our app using updateQuery for all our various mutations and updates would quickly get difficult to maintain and organize.

Basically we're looking for a way to have local storage with all known item types (ideally populated by mutation + query results) that we could then filter through to get lists on the fly. "show me all items with the type task that also have isDeleted as true" for example. Ideally in this case when we run a deleteTask mutation we don't also need to update this and other arrays in both the optimistic and updates section of the cache.

Anyways, we're still very new to urql so maybe we're missing something and/or there is another way to get where we're trying to go...

[JoviDeCroock]

The thing you are describing is quite automatic anyway, so if your deleteTask returns a Task:id that is present in cache will make it automatically update, so let's say Task:1 is in cache and deleteTask returns the following:

deleteTask {
  id: 1,
  __typename: 'Task',
  isDeleted: true
}

Then this task will be updated to have isDeleted: true this could be due to it being present in cache due to a former query, ... When we can't find said Task due to it being an addTask, .. (create task) we'll need you to show us how it connects to your rootTypes.

This could be for instance a task that is assigned to a user OR Query.task(id: x) returning said task.

[kitten]

So the question is also: how offline are we talking; offline-first doesn't always mean that we have all queries working offline.
If you're describing a 100% local parity state cache then you'll have to write a lot of updates yourself. If you're fine with some queries going back to the server to update, we have solutions like cache.invalidate (and soon @populate)

I believe you'll have to be a bit more precise with your question, because in the docs you can see a lot of examples for updates, and we can give you more examples / code snippets, or explain scenarios, but overall we can't answer a question based on a vague idea 😅

When it comes to arrays we basically just search through what is in the store/cache and build out a list. So for a list of all deleted items we find all items that we have that have isDeleted as true.

This specific thing is not in Graphcache. It's a cache not a database, so there are ways to make all of these things work, but we're not talking database-level of convenience

[chrisdrackett]

all the way offline! Our app is written so that full functionality is possible without an internet connection. However to support using the app on multiple devices, with other users, and for backup purposes when and while the app is connected to the internet we do queries and send mutations (sometimes queued up if the client has been offline) to the server to keep the client updated with changes made on other clients.

We have very little logic on our server itself, its essentially just dumb storage.

My guess based on these conversations is that we can't really treat Graphcache as a store/database as you say and need to look into ways to create that functionality ourselves.

[kitten]

We're not self-obsessed, so I got to say: Graphcache wasn't built for that. What you're looking for is a fully synced database-like service. Amplify can help you here or failing that you could build a GraphQL execute schema embedded in your application that's using an existing library that fully syncs all changes.

Doing this with a cache like Graphcache instead just isn't solid. We're providing Offline Support for Twitter-like apps, not apps that need access to 100% of the data all the time.

So tl;dr: Amplify or write a client-side executable schema with some client/server-sync database

[chrisdrackett]

Thanks! we'll keep looking around. RxDB looks like it might have some promise as well!

[smontlouis]

Hey @chrisdrackett we are in the same process right now. Did you finally use RxDB ? Are synchronizing it with your cloud database ?