PouchDB Blog

Local first is amazing. I have been building a local first application for Invoicing since 2020 called Upcount https://www.upcount.app/. First I used PouchDB which is also awesome https://pouchdb.com/ but now switched to SQLite and Turso https://turso.tech/ which seems to fit my needs much better.

Pouch DB is a great local first DB with optional sync for JavaScript: https://pouchdb.com/

> use-basically-I-wanted-to-have-independent-JSON-instead-of-SQLite-so-in-the-future-maybe-have-a-web-function-to-sync solution sounds like you should use CouchDB, it a database/webserver, so you could make a simple html form on localhost[0], CouchDB is built with replication/sync (over HTTP) as one of it's main feature[1], and on the field, an offline-first webapp with PouchDB[2] and Service Workers[3] could have the exact same form [0] https://docs.couchdb.org/en/stable/best-practices/forms.html [1] https://pouchdb.com [2] https://github.com/pouchdb-community/worker-pouch

I haven't heard of CouchDB in quite some time, great to see it still improving. I used it years ago when I was experimenting with Ionic[0]. What appealed to me was that I could use CouchDB (cloud) and PouchDB[1] (device) to and have a replicated copy of the data locally. The application was used in areas where network connection was very limited. Using this strategy I was able to ensure the mobile devices data was as recent as the last time it had a network connection. [0] - https://ionicframework.com/ [1] - https://pouchdb.com/

Someone familiar please chime in. I did evaluate it + pouchdb[0] is fantastic, but the 'lack of' / slow development make it showstopper. [https://pouchdb.com/]

While I've not dug into ForerunnerDB, it sounds like it is playing in the same space as PouchDB[1]. PouchDB is a JS database that works in the browser or in Node with various back-ends for data storage, syncs with CouchDB (or compatible, such as PouchDB Server) on the back-end, and currently uses map-reduce queries, though there is work in-progress to implement a MongoDB-like query language[2]. (This will match the Mango query language soon to be seen in CouchDB [3].) Plus I've been really impressed with the development team—responsive to issues, consistent releases, high code-quality. It's a great project! [1] http://pouchdb.com/ [2] https://github.com/nolanlawson/pouchdb-find [3] https://github.com/cloudant/mango

Safari are finally adding IndexedDB, which means for the first time we have a unified storage interface across all the browsers. IndexedDB is kinda nasty to work with directly, but there are fairly good libraries on top of it. http://www.taffydb.com/ looks great for complex queries. One I work on http://pouchdb.com provides syncing (also works with WebSQL) WebSQL is also pretty nasty to work with, hand crafting SQL string in the browser for one just feelds weird, even yesterday I had a bug filed which related to the internal SQLLite implementation (the entire reason WebSQL is a no go is it has one implementation, Richard Hipp would now own web storage) I havent seen much support from webSQL, even between those of us who actually use it most are just waiting for it to die, indexeddb in safari is that final nail

For those interested in the replication side Cloudant and CouchDB, there is some start to documenting the protocol on http://www.replication.io. It's exciting to have more things can seamlessly replicate! Another great example is the PouchDB project (http://pouchdb.com).

I would recommend you to use PouchDB, its a similar approach, but in this case you use CouchDB as a database, it can be used offline and it syncs http://pouchdb.com/

I was looking really hard at using CouchDB 2.0 for an offline-first progressive web app. The biggest asset in my opinion of CouchDB is actually PouchDB [1] PouchDB is really great and nicely designed. However, the showstopper that I hit was that CouchDB still does not support permissions on a per-user basis (even though PouchDB encourages this explicitly [2]) What this means is that if you have a typical system with users and logins, who can only access their own data, and you require some sort of aggregated view where you can view all users data behind some sort of permissions (admin user, etc), you are forced to create a new db for each user in Couch, and then run replication for those users to a separate master. Think for example if you wanted to store images in CouchDB, and then have some sort of global feed (like instagram) So, systems with many users (tens of thousands -> millions) would be stuck replicating an equal number of couch databases constantly. Each replica in 2.0 was an erlang thread, and each database is a separate file. Apparently some of the performance issues were fixed in 2.1, but it still requires a physical file per db and continuous replication. Some promising solutions like envoy [3] from Cloudant, which were based on Mango [4] have been worked on, but don't seem to have much support in the core Couch community and feels to have been abandoned. Another problem is that you can't really throttle or manage pouchDB <-> couchDB replication very…

I don't know how node-webkit works exactly, but npm uses CouchDB to store the packages definition. If node-webkit works the same (ie you can publish the application on the npm registry), you can replicate the registry (or part of it) on other places, and redirect your local node-webkit installer on those replicas. These replicas don't need to be CouchDB instances, they just need to speak its protocol. Fortunately for you there's an excellent package that does that: PouchDB (http://pouchdb.com/), which you can use as a library (so you don't need to install another server) in your node.js application. Finally, when the user wants to install the application that is published on the npm registry, it would have to get some kind of signature from the registry, and then pick any mirror to download the content from. This is a very important step: there must be a way for the user to make sure what he downloads is legit. One can assume if it's on the npm registry then it is. This is not bittorrent, but it's much more integrated in the current environment which means less hacking to do.

Choose three. Preemptive actor model (Erlang, Elixir, Gleam) for backend. https://pouchdb.com for frontend.

CouchDB on the server and PouchDB on the client was an attempt at making such an environment: - https://couchdb.apache.org/ - https://pouchdb.com/ Also some more pondering on local-first application development from a "few" (~10) years back can be found here: https://unhosted.org/

Why not just use pouchdb? It's pretty battle-tested, syncs with couchdb if you want a path to a more robust backend? edit: https://pouchdb.com/

Another interesting option is PouchDB[0], which is a Javascript implementation of the CouchDB[1] synchronization API. It allows you to acheive eventual consistency between a client with intermittent connectivity, and a backend database. [0] https://pouchdb.com/ [1] https://couchdb.apache.org/

How does this compare to PouchDB[1]? [1]: https://pouchdb.com/

Not sure if you're thinking more of an official standard but PouchDB is open source and sounds similar to what you're talking about: https://pouchdb.com/

we considered PouchDB[1] (client) and CouchDB[2] (server) for an PWA back then (2017). nowadays i would probably favor WatermelonDB[3]. [1]: https://pouchdb.com/ [2]: https://couchdb.apache.org/ [3]: https://nozbe.github.io/WatermelonDB/

It sounds like a database that both exists in the cloud and locally on your device. Which sounds useful! But then, PouchDB already exists: https://pouchdb.com/

A bit offtrack - does anybody know how rxdb differs from PouchDB? https://pouchdb.com

Not SQL, but https://pouchdb.com/ looks like a better version of this. Also not SQL, IndexedDB [0] Seems like a well-supported [1] document database built into the browser would beat LocalStorage in almost every way. That's what I've found in my experience at least. Maybe SQL just isn't the right tool on either the frontend or the backend? [0] https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_A... [1] https://caniuse.com/indexeddb

indexedDB is too low level for that kind of thing by itself. It's just a fast Key-Value store with secondary indexes that's in your browser. You either need to find a solution that has a sync system built in (such as <https://dexie.org/> or <https://pouchdb.com/> ) or you'd roll your own atop whatever you were using.

Switch local storage for IndexedDB. Good library that wraps it is PouchDB: https://pouchdb.com/ It can sync browser db to remote database.

PouchDB can be used to solve some of those backing-up and synchronization issues. https://pouchdb.com/

It seems that you are describing pouchdb: https://pouchdb.com/

https://pouchdb.com/ is a JavaScript port of CouchDB, running in the browser and capable of replicating with normal CouchDB.

I'm not really familiar with mongo db but I have been working with couchdb for awhile now. I just posted a "Show HN" of a simple demo app I made that uses CouchDB installed on the client side. CouchDB will run a Mac, Windows, and Linux desktop PCs. The demo uses PouchDB.js to interact with CouchDB. PouchDB is really pretty sweet. Take a look at the demo and play around with it a bit. There are two web pages that are both self contained. One sets up a user and db, the other demonstrates crud routines. https://cherrypc.com/app/editor/setup.html https://cherrypc.com/app/editor/index.html Also check out the PouchDB docs: https://pouchdb.com/

That sounds interesting. Have you compared your service to pouchdb and gun? Is it possible to use icepeak in offline mode and automatically sync when getting online again? [1] https://pouchdb.com/ [2] https://gun.js.org/

That won't fit in cookie space... this is really for redundant controls for session/access tokens etc... anything large like that you're better off using caching and a service worker to handle repeated requests. Also, cookies are sent with every request to the server, and I don't think you'd want the user sending 10MB to your server for every request. Also, if you are storing larger strings in local/sessionStorage, websql or indexdb, you should use lz-string[1] to try to minimize storage impact. Aside: if you want something with a nicer interface for underlying storage you may want to look at pouchdb[2], which has a localized couch interface and supports remote synching to coudchdb, which is pretty nice. [1] https://github.com/pieroxy/lz-string [2] https://pouchdb.com/

I recommend http://callbackhell.com/ and https://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html