RxDB

RxDB offers several architectural advantages for web applications:

• Offline Accessibility: Users can interact with the application without an active internet connection.
• Caching & Low Latency: Storing data locally reduces server requests and eliminates network round-trips for queries.
• Scalability: By distributing the query workload to the user's device, you reduce the burden on your central server.
• Multi-tab Support: RxDB natively supports synchronization across different browser tabs or instances of the same application.
• State Management: You can use the local database for state management, potentially replacing libraries like Redux or NgRx.
• Encryption: Sensitive local data can be stored securely using RxDB's encryption capabilities.

RxDB is a client-side JavaScript database built on top of the IndexedDB standard. When integrated with React, it provides several key advantages for data management:

• Improved Performance: Local data storage reduces the frequency of server requests, leading to faster retrieval and higher responsiveness.
• Offline Capabilities: Enables users to interact with the application and access data even without an internet connection.
• Real-Time Updates: Leverages reactive programming to observe data changes, allowing the UI to update automatically when data changes.
• Reduced Server Load: By performing data operations locally on the client, it helps create a more scalable architecture by offloading work from the server.

When building local-first applications, Supabase has several key limitations:

• No Client-Side Database: Queries like supabase.from('table').select('*') fail when the network is unavailable because there is no local fallback.
• No Sync Engine: Supabase Realtime is a streaming protocol. It does not track checkpoints or automatically fetch missed changes after a reconnection.
• No Observable Queries: The SDK lacks a reactive query system. To update a UI, you must manually combine Realtime subscriptions with manual re-fetches, which is inefficient and complex.
• Relational vs. Document Model: Supabase uses a relational PostgreSQL model, which may not map directly to the JSON document shapes often used in modern web UIs.

The replication-microsoft-onedrive plugin enables cross-device synchronization for single users by replicating an RxDB database to a folder in their Microsoft OneDrive. This approach requires no backend server and works offline-first. It uses the Microsoft Graph API for data storage and WebRTC for near real-time peer-to-peer signaling between devices.

import {
    replicateMicrosoftOneDrive
} from 'rxdb/plugins/replication-microsoft-onedrive';

const replicationState = await replicateMicrosoftOneDrive({
    replicationIdentifier: 'my-app-onedrive-sync',
    collection: myRxCollection,
    oneDrive: {
        authToken: 'USER_ACCESS_TOKEN',
        folderPath: 'my-app-data/user-1'
    },
    live: true,
    pull: {
        batchSize: 60,
        modifier: doc => doc
    },
    push: {
        batchSize: 60,
        modifier: doc => doc
    }
});

RxDB is a JSON-focused, NoSQL database designed for client-side usage (browsers, mobile apps, or Node.js) with an offline-first philosophy. Its core features include:

• Local JSON Storage: Stores records as JSON documents, matching front-end state management and eliminating complex transformations.
• Reactive Queries: Uses JSON-based query definitions that allow UIs to subscribe to results and automatically refresh when data changes.
• Offline-First Sync: Includes replication plugins to push/pull changes to/from remote servers, handling offline updates seamlessly.
• Optional JSON-Schema: Supports JSON-Schema for field definition, required fields, data types, indexing, and type validation.

RxDB can be extended with various third-party plugins to add advanced functionality such as React hooks, full-text search, specific backend replication, and utility enhancements.

Available plugins include:

• UI Integration: rxdb-hooks for integrating RxDB into React applications.
• Search: rxdb-flexsearch for full-text search using FlexSearch.
• Replication:
  • rxdb-orion for Laravel Orion.
  • rxdb-supabase for Supabase.
  • rxdb-solid for Solid pods.
• Utilities & Features:
  • rxdb-utils for models, timestamps, default values, and views.
  • rxdb-extra for timestamps, simple search, and strict schema (compatible with latest versions).
• Storage Adapters: loki-async-reference-adapter for using LokiJS RxStorage in React Native environments.

When choosing a client-side JavaScript database for real-time, local-first applications, you may consider several alternatives to RxDB. These alternatives include:

• Firebase
• Meteor
• Minimongo
• WatermelonDB
• AWS Amplify
• AWS Datastore
• RethinkDB
• Horizon
• Supabase
• CouchDB

Note that the RxDB documentation provides an opinionated view of these technologies. RxDB distinguishes itself by being backend-agnostic (allowing use with your own backend or no backend at all), being independently funded (not tied to a specific cloud provider), and having a long history of performance optimization and stability.