RxDB

https://rxdb.info/
Admin
RxDB is a local-first NoSQL database for JavaScript that enables offline-first applications with...
Tokens:721,852
Snippets:6,029
Trust Score:9.7
Update:1 week ago
Show doc for...
Tokens:
Raw
### Setup RxDB with LocalStorage RxStorage

Source: https://rxdb.info/electron-database.html

Install dependencies with `npm install rxdb rxjs`, then create a database using `getRxStorageLocalstorage()`. The example shows creating a database, adding collections, inserting a document, running a query, and observing a query.

```javascript
import { createRxDatabase } from 'rxdb';
import { getRxStorageLocalstorage } from 'rxdb/plugins/storage-localstorage';
 
// create database
const db = await createRxDatabase({
    name: 'exampledb',
    storage: getRxStorageLocalstorage()
});
 
// create collections
const collections = await myRxDatabase.addCollections({
    humans: {
        /* ... */
    }
});
 
// insert document
await collections.humans.insert({id: 'foo', name: 'bar'});
 
// run a query
const result = await collections.humans.find({
    selector: {
        name: 'bar'
    }
}).exec();
 
// observe a query
await collections.humans.find({
    selector: {
        name: 'bar'
    }
}).$.subscribe(result => {/* ... */});
```

--------------------------------

### Create and start RxServer with Express adapter

Source: https://rxdb.info/rx-server.html

Install rxdb-server and import createRxServer. Use the RxServerAdapterExpress adapter (requires express installed). After adding endpoints, call myServer.start() to start the HTTP server.

```javascript
import { createRxServer } from 'rxdb-server/plugins/server';
 
/**
 * We use the express adapter which is the one that comes with RxDB core
 * Make sure you have express installed in the correct version!
 * @see https://github.com/pubkey/rxdb-server/blob/master/package.json
 */
import { RxServerAdapterExpress } from 'rxdb-server/plugins/adapter-express';
 
const myServer = await createRxServer({
    database: myRxDatabase,
    adapter: RxServerAdapterExpress,
    port: 443
});
 
// add endpoints here (see below)
 
// after adding the endpoints, start the server
await myServer.start();
```

--------------------------------

### replicateRxCollection() example with configuration

Source: https://rxdb.info/replication.html

Example of starting replication for a single RxCollection using replicateRxCollection(). Includes options for replicationIdentifier, live, retryTime, waitForLeadership, autoStart, deletedField, and a push handler with batchSize.

```javascript
import { replicateRxCollection } from 'rxdb/plugins/replication';
import {
    lastOfArray
} from 'rxdb';
const replicationState = await replicateRxCollection({
    collection: myRxCollection,
    /**
     * An id for the replication to identify it
     * and so that RxDB is able to resume the replication on app reload.
     * If you replicate with a remote server, it is recommended to put the
     * server url into the replicationIdentifier.
     */
    replicationIdentifier: 'my-rest-replication-to-https://example.com/api/sync',
    /**
     * By default it will do an ongoing realtime replication.
     * By settings live: false the replication will run once until the local state
     * is in sync with the remote state, then it will cancel itself.
     * (optional), default is true.
     */
    live: true,
    /**
     * Time in milliseconds after when a failed backend request
     * has to be retried.
     * This time will be skipped if a offline->online switch is detected
     * via navigator.onLine
     * (optional), default is 5 seconds.
     */
    retryTime: 5 * 1000,
    /**
     * When multiInstance is true, like when you use RxDB in multiple browser tabs,
     * the replication should always run in only one of the open browser tabs.
     * If waitForLeadership is true, it will wait until
     * the current instance is leader.
     * If waitForLeadership is false, it will start
     * replicating, even if it is not leader.
     * [default=true]
     */
    waitForLeadership: true,
    /**
     * If this is set to false,
     * the replication will not start automatically
     * but will wait for replicationState.start() being called.
     * (optional), default is true
     */
    autoStart: true,
 
    /**
     * Custom deleted field, the boolean property of the document data that
     * marks a document as being deleted.
     * If your backend uses a different field name
     * than '_deleted', set the field name here.
     * RxDB will still store the documents internally
     * with '_deleted', setting this field
     * only maps the data on the data layer.
     * 
     * If a custom deleted field contains a non-boolean value, the deleted state
     * of the documents depends on if the value is
     * truthy or not. So instead of providing a boolean
     * deleted value, you could also work with using a
     * 'deletedAt' timestamp instead.
     * 
     * [default='_deleted']
     */
    deletedField: 'deleted',
 
    /**
     * Optional,
     * only needed when you want to replicate local changes to the remote instance.
     */
    push: {
        /**
         * Push handler
         */
        async handler(docs) {
            /**
             * Push the local documents to a remote REST server.
             */
            const rawResponse = await fetch('https://example.com/api/sync/push', {
                method: 'POST',
                headers: {
                    'Accept': 'application/json',
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ docs })
            });
            /**
             * Contains an array with all conflicts that appeared during this push.
             * If there were no conflicts, return an empty array.
             */
            const response = await rawResponse.json();
            return response;
        },
        /**
         * Batch size, optional
         * Defines how many documents will be given to the push handler at once.
         */
        batchSize: 5,

```

--------------------------------

### Client-side replication setup with replicateServer

Source: https://rxdb.info/replication-mongodb.html?code=MG1&console=errors

Creates a client-side RxDatabase with the same schema as the server and starts replication using the replicateServer function. The URL should be the endpoint printed by the server, e.g., http://localhost:8080/humans/0. The example uses live replication with batch sizes of 50 for both pull and push.

```typescript
//> client.ts
 
import { createRxDatabase } from 'rxdb';
import { getRxStorageDexie } from 'rxdb/plugins/storage-dexie';
import { replicateServer } from 'rxdb-server/plugins/replication-server';
 
const db = await createRxDatabase({
  name: 'mydb-client',
  storage: getRxStorageDexie()
});
 
await db.addCollections({
  humans: {
    schema: {
      version: 0,  
      primaryKey: 'passportId',
      type: 'object',
      properties: {
        passportId: { type: 'string', maxLength: 100 },
        firstName: { type: 'string' },
        lastName: { type: 'string' }
      },
      required: ['passportId', 'firstName', 'lastName']
    }
  }
});
 
// Start replication to the RxServer endpoint printed by the server:
// e.g. http://localhost:8080/humans/0
const replicationState = replicateServer({
  replicationIdentifier: 'humans-rxserver',
  collection: db.humans,
  url: 'http://localhost:8080/humans/0',
  live: true,
  pull: { batchSize: 50 },
  push: { batchSize: 50 }
});
 

```

--------------------------------

### RxDB Quick Example: Setup and Insert with LocalStorage

Source: https://rxdb.info/articles/reactjs-storage.html

Sets up an RxDB database using LocalStorage storage, defines a hero schema, adds a collection, inserts a document, and queries all heroes. Uses getRxStorageLocalstorage() from 'rxdb/plugins/storage-localstorage'.

```javascript
import { createRxDatabase } from 'rxdb';
import { getRxStorageLocalstorage } from 'rxdb/plugins/storage-localstorage';
 
(async function setUpRxDB() {
  const db = await createRxDatabase({
    name: 'heroDB',
    storage: getRxStorageLocalstorage(),
    multiInstance: false
  });
 
  const heroSchema = {
    title: 'hero schema',
    version: 0,
    type: 'object',
    primaryKey: 'id',
    properties: {
      id: { type: 'string', maxLength: 100 },
      name: { type: 'string' },
      power: { type: 'string' }
    },
    required: ['id', 'name']
  };
 
  await db.addCollections({ heroes: { schema: heroSchema } });
 
  // Insert a doc
  await db.heroes.insert({ id: '1', name: 'AlphaHero', power: 'Lightning' });
 
  // Query docs once
  const allHeroes = await db.heroes.find().exec();
  console.log('Heroes: ', allHeroes);
})();
```

--------------------------------

### Example Setup of a local database

Source: https://rxdb.info/articles/zero-latency-local-first.html

Creates a local RxDB instance using localstorage-based storage, adds a 'tasks' collection with a schema, and sets up a reactive query that logs all tasks on changes. The database instance is returned for further use.

```javascript
import { createRxDatabase } from 'rxdb/plugins/core';
import { getRxStorageLocalstorage } from 'rxdb/plugins/storage-localstorage';
 
async function initZeroLocalDB() {
  // Create a local RxDB instance using localstorage-based storage
  const db = await createRxDatabase({
    name: 'myZeroLocalDB',
    storage: getRxStorageLocalstorage(),
    // optional: password for encryption if needed
  });
 
  // Define one or more collections
  await db.addCollections({
    tasks: {
      schema: {
        title: 'task schema',
        version: 0,
        type: 'object',
        primaryKey: 'id',
        properties: {
          id:       { type: 'string', maxLength: 100 },
          title:    { type: 'string' },
          done:     { type: 'boolean' }
        }
      }
    }
  });
 
  // Reactive query - automatically updates on local or remote changes
  db.tasks
    .find()
    .$ // returns an RxJS Observable
    .subscribe(allTasks => {
      console.log('All tasks updated:', allTasks);
    });
 
  return db;
}
```

--------------------------------

### WebSocket server setup with startRxStorageRemoteWebsocketServer

Source: https://rxdb.info/rx-storage-remote.html

Shows how to start a WebSocket server based on either a RxDatabase or a pure RxStorage. The server listens on the specified port and enables remote access without replicating the full database state.

```javascript
// server.js
import { getRxStorageMemory } from 'rxdb/plugins/storage-memory';
import {
    startRxStorageRemoteWebsocketServer
} from 'rxdb/plugins/storage-remote-websocket';
 
// either you can create the server based on a RxDatabase
const serverBasedOnDatabase = await startRxStorageRemoteWebsocketServer({
    port: 8080,
    database: myRxDatabase
});
 
// or you can create the server based on a pure RxStorage
const serverBasedOn = await startRxStorageRemoteWebsocketServer({
    port: 8080,
    storage: getRxStorageMemory()
});
```

--------------------------------

### Code example: wait for leadership and start data pulling

Source: https://rxdb.info/leader-election.html

Creates a database with multiInstance enabled, adds a temperature collection, and uses waitForLeadership() to start a periodic fetch and insert when the tab becomes leader.

```javascript
import { getRxStorageLocalstorage } from 'rxdb/plugins/storage-localstorage';
 
const db = await createRxDatabase({
  name: 'weatherDB',
  storage: getRxStorageLocalstorage(),
  password: 'myPassword',
  multiInstance: true
});
 
await db.addCollections({
  temperature: {
    schema: mySchema
  }
});
 
db.waitForLeadership()
  .then(() => {
    console.log('Long lives the king!'); // <- runs when db becomes leader
    setInterval(async () => {
      const temp = await fetch('https://example.com/api/temp/');
      db.temperature.insert({
          degrees: temp,
          time: new Date().getTime()
      });
    }, 1000 * 10);
  });
```

--------------------------------

### Manual Migration Setup

Source: https://rxdb.info/migration-schema.html?code=COL25&console=errors

Example of adding a collection with autoMigrate set to false and defining migration strategies, then checking if migration is needed and starting it manually.

```APIDOC
## Manual Migration Setup

### Description
This example shows how to configure a collection to not auto-migrate, define migration strategies, check if migration is needed, and start the migration manually.

### Method
N/A (SDK usage)

### Endpoint
N/A

### Parameters
- **autoMigrate** (boolean) - Required - Set to false to prevent automatic migration on collection creation.
- **migrationStrategies** (object) - Required - Map of version numbers to async functions that migrate documents.

### Request Example
```javascript
const messageCol = await myDatabase.addCollections({
  messages: {
    schema: messageSchemaV1,
    autoMigrate: false, // <- migration will not run at creation
    migrationStrategies: {
      1: async function(oldDoc){
        ...
        anything that takes very long
        ...
        return oldDoc;
      }
    }
  }
});
```

### Response
No direct response; the collection is created with migration disabled.

```

--------------------------------

### Main process: exposeIpcMainRxStorage setup

Source: https://rxdb.info/electron.html

Sets up the RxStorage in the main process using `exposeIpcMainRxStorage` with a memory storage. Requires `nodeIntegration` to be enabled in Electron.

```javascript
//  main.js
const { exposeIpcMainRxStorage } = require('rxdb/plugins/electron');
const { getRxStorageMemory } = require('rxdb/plugins/storage-memory');
app.on('ready', async function () {
    exposeIpcMainRxStorage({
        key: 'main-storage',
        storage: getRxStorageMemory(),
        ipcMain: electron.ipcMain
    });
});
```

--------------------------------

### Stop and Start Appwrite with Docker Compose

Source: https://rxdb.info/replication-appwrite.html

Manually stop and start the Appwrite instance with Docker Compose after installation.

```bash
# stop
docker-compose down
 
# start
docker-compose up
```

--------------------------------

### Get a collection from the database

Source: https://rxdb.info/rx-collection.html?code=COL1&console=errors

Call the collection name directly on the database to get an existing collection. The example shows that the returned collection is the same instance as the one created via addCollections.

```javascript
// newly created collection
const collections = await db.addCollections({
  heroes: {
    schema: mySchema
  }
});
const collection2 = db.heroes;
console.log(collections.heroes === collection2); //> true
```

--------------------------------

### setHeaders example

Source: https://rxdb.info/replication-graphql.html?code=GQL3&console=errors

Change the replication headers after setup using the RxGraphQLReplicationState returned by syncGraphQL().

```typescript
replicationState.setHeaders({
    Authorization: `...`
});
```

--------------------------------

### Set up RxDB with FoundationDB storage

Source: https://rxdb.info/nodejs-database.html

Imports createRxDatabase and getRxStorageFoundationDB, then creates a database with FoundationDB storage. Requires a FoundationDB cluster file and apiVersion. After creation, adds a collection and runs a query.

```javascript
import { createRxDatabase } from 'rxdb';
import { getRxStorageFoundationDB } from 'rxdb/plugins/storage-foundationdb';
 
const db = await createRxDatabase({
    name: 'exampledb',
    storage: getRxStorageFoundationDB({
        apiVersion: 620,
        clusterFile: '/path/to/fdb.cluster'
    })
});
 
// add a collection
await db.addCollections({
    users: {
        schema: mySchema
    }
});
 
// run a query
const result = await db.users.find({
    selector: {
        name: 'foobar'
    }
}).exec();

```

--------------------------------

### Count query with exec and subscribe

Source: https://rxdb.info/rx-query.html

Use count() to get the number of matching documents without fetching full document data. The example shows getting the count once with exec() and observing it with $.

```javascript
const query = myCollection.count({
  selector: {
    age: {
      $gt: 18
    }
  }
  // 'limit' and 'skip' MUST NOT be set for count queries.
});
 
// get the count result once
const matchingAmount = await query.exec(); // > number
 
// observe the result
query.$.subscribe(amount => {
  console.log('Currently has ' + amount + ' documents');
});
```

--------------------------------

### Setup Compression with keyCompression: true

Source: https://rxdb.info/articles/zero-latency-local-first.html

Enable key compression to reduce storage usage and speed up replication. Add 'keyCompression: true' to the collection schema.

```javascript
await db.addCollections({
  logs: {
    schema: {
      title: 'log schema',
      version: 0,
      keyCompression: true,
      type: 'object',
      primaryKey: 'id',
      properties: {
        id:         { type: 'string', maxLength: 100 },
        message:    { type: 'string' },
        timestamp:  { type: 'number' }
      }
    }
  }
});
```

--------------------------------

### Observe a field with get$()

Source: https://rxdb.info/rx-document.html?code=DOC16&console=errors

get$() returns an observable that emits the current value of the given path each time the document changes. The example shows subscribing to 'name' and then patching the document to see the update.

```javascript
// get the live-updating value of 'name'
let isName;
myDocument.get$('name')
  .subscribe(newName => {
    isName = newName;
  });
 
await myDocument.incrementalPatch({name: 'foobar2'});
console.dir(isName); // isName is now 'foobar2'
 
// OR
 
myDocument.name$
  .subscribe(newName => {
    isName = newName;
  });
 
```

--------------------------------

### Start CouchDB Replication

Source: https://rxdb.info/articles/tanstack-db/tanstack-db-couchdb-sync.html

Sets up live replication with CouchDB. The plugin does not create missing databases, so a PUT request creates the 'todos' database first. Uses basic authentication via getFetchWithCouchDBAuthorization.

```javascript
import {
    replicateCouchDB,
    getFetchWithCouchDBAuthorization
} from 'rxdb/plugins/replication-couchdb';
 
// The plugin does not create missing databases,
// create it once on the server:
await fetch('http://localhost:5984/todos', { method: 'PUT' });
 
const replicationState = replicateCouchDB({
    replicationIdentifier: 'todos-to-my-couchdb',
    collection: db.todos,
    url: 'http://localhost:5984/todos/',
    live: true,
    fetch: getFetchWithCouchDBAuthorization('myUsername', 'myPassword'),
    pull: {},
    push: {}
});
```

--------------------------------

### Create and configure an RxDB database

Source: https://rxdb.info/articles/jquery-database.html

Minimal example to create an RxDB instance with localstorage storage, optional password, multiInstance, and eventReduce options. Adds a 'hero' collection with a schema. Call this on page initialization and store the returned db object.

```javascript
import { createRxDatabase } from 'rxdb';
import { getRxStorageLocalstorage } from 'rxdb/plugins/storage-localstorage';
 
async function initDatabase() {
  const db = await createRxDatabase({
    name: 'heroesdb',
    storage: getRxStorageLocalstorage(),
    password: 'myPassword',         // optional encryption password
    multiInstance: true,            // multi-tab support
    eventReduce: true               // optimizes event handling
  });
 
  await db.addCollections({
    hero: {
      schema: {
        title: 'hero schema',
        version: 0,
        primaryKey: 'id',
        type: 'object',
        properties: {
          id: { type: 'string', maxLength: 100 },
          name: { type: 'string' },
          points: { type: 'number' }
        }
      }
    }
  });
 
  return db;
}
```

--------------------------------

### DenoKV and non-DenoKV database multiInstance settings

Source: https://rxdb.info/rx-storage-denokv.html

Shows two database creation examples: one with DenoKV storage using multiInstance: true (default) to share events across DenoDeploy instances, and one with filesystem storage using multiInstance: false to avoid mixing events across instances.

```javascript
// DenoKV based database
const db = await createRxDatabase({
  name: 'denokvdatabase',
  storage: getRxStorageDenoKV(),
  /**
   * Use multiInstance: true so that the Deno Broadcast Channel
   * emits event across DenoDeploy instances
   * (true is also the default, so you can skip this setting)
   */
  multiInstance: true
});

// Non-DenoKV based database
const db = await createRxDatabase({
  name: 'denokvdatabase',
  storage: getRxStorageFilesystemNode(),
  /**
   * Use multiInstance: false so that it does not share events
   * across instances because the stored data is anyway not shared
   * between them.
   */
  multiInstance: false
});
```

--------------------------------

### startReplication helper function

Source: https://rxdb.info/replication.html?code=RC_PUSH_NO_AR&console=errors

Example helper function that starts replication for any collection, preserving the document type generic.

```APIDOC
## startReplication helper function

### Description
Example helper function that starts replication for any collection, preserving the document type generic.

### Code Example
```typescript
import type {
    RxCollection,
    ReplicationPullHandler,
    ReplicationPushHandler
} from 'rxdb';
import {
    replicateRxCollection,
    RxReplicationState
} from 'rxdb/plugins/replication';
 
type MyCheckpoint = { id: string; updatedAt: number; };
 
export function startReplication<RxDocType>(
    collection: RxCollection<RxDocType>,
    pullHandler: ReplicationPullHandler<RxDocType, MyCheckpoint>,
    pushHandler: ReplicationPushHandler<RxDocType>
): RxReplicationState<RxDocType, MyCheckpoint> {
    return replicateRxCollection<RxDocType, MyCheckpoint>({
        collection,
        replicationIdentifier: 'my-sync-' + collection.name,
        live: true,
        pull: { handler: pullHandler },
        push: { handler: pushHandler }
    });
}
 
// replicationState is typed as RxReplicationState<HeroDocType, MyCheckpoint>
const replicationState = startReplication(
    myDatabase.heroes,
    myPullHandler,
    myPushHandler
);
```

```

--------------------------------

### Get current deleted state

Source: https://rxdb.info/rx-document.html?code=DOC16&console=errors

Getter that returns the current value of deleted$. The example shows false before removal and true after.

```javascript
console.log(myDocument.deleted);
// false

await myDocument.remove();

console.log(myDocument.deleted);
// true
```

--------------------------------

### Before: IndexedDB storage setup

Source: https://rxdb.info/articles/alternatives/absurd-sql-alternative.html

Shows the original RxDB setup using IndexedDB storage. The storage is passed as a parameter to createRxDatabase, making it easy to swap.

```javascript
// Before: IndexedDB
import { getRxStorageIndexedDB } from 'rxdb/plugins/storage-indexeddb';
 
const db = await createRxDatabase({
  name: 'budget',
  storage: getRxStorageIndexedDB()
});
```

--------------------------------

### Create and start RxServer with Fastify adapter

Source: https://rxdb.info/rx-server.html

Premium adapter for Fastify. Requires the rxdb-premium package. Provides better performance and is more modern than express.

```javascript
import { createRxServer } from 'rxdb-server/plugins/server';
import { RxServerAdapterFastify } from 'rxdb-premium/plugins/server-adapter-fastify';
 
const myServer = await createRxServer({
    database: myRxDatabase,
    adapter: RxServerAdapterFastify,
    port: 443
});
await myServer.start();
```

--------------------------------

### Node.js WebRTC and WebSocket polyfill with createSimplePeerWrtc

Source: https://rxdb.info/replication-webrtc.html

Use this setup to polyfill WebRTC and WebSocket in Node.js. Install node-datachannel via npm install node-datachannel --save and use the createSimplePeerWrtc wrapper to avoid read-only property issues with simple-peer.

```javascript
import nodeDatachannelPolyfill from 'node-datachannel/polyfill';
import { WebSocket } from 'ws';
import { createSimplePeerWrtc } from 'rxdb/plugins/replication-webrtc';
const replicationPool = await replicateWebRTC(
    {
        /* ... */
        connectionHandlerCreator: getConnectionHandlerSimplePeer({
            signalingServerUrl: 'wss://example.com:8080',
            wrtc: createSimplePeerWrtc(nodeDatachannelPolyfill),
            webSocketConstructor: WebSocket
        }),
        pull: {},
        push: {}
        /* ... */
    }
);
```

--------------------------------

### Start P2P Replication with replicateWebRTC

Source: https://rxdb.info/replication-webrtc.html

Starts WebRTC replication on the todos collection. Requires a topic and a connection handler creator. The example uses getConnectionHandlerSimplePeer with a signaling server URL and Node.js-specific dependencies (wrtc and WebSocket). Returns a replicationPool instead of a single RxReplicationState.

```javascript
const replicationPool = await replicateWebRTC(
    {
        // Start the replication for a single collection
        collection: db.todos,
 
        // The topic is like a 'room-name'. All clients with the same topic
        // will replicate with each other. In most cases you want to use
        // a different topic string per user. Also you should prefix the topic with
        // a unique identifier for your app, to ensure
        // you do not let your users connect
        // with other apps that also use the RxDB P2P Replication.
        topic: 'my-users-pool',
        /**
         * You need a collection handler to be able to create WebRTC connections.
         * Here we use the simple peer handler which
         * uses the 'simple-peer' npm library.
         * To learn how to create a custom connection handler, read the source code,
         * it is pretty simple.
         */
        connectionHandlerCreator: getConnectionHandlerSimplePeer({
            // Set the signaling server url.
            // You can use the server provided by RxDB for tryouts,
            // but in production you should use your own server instead.
            signalingServerUrl: 'wss://signaling.rxdb.info/',
 
            // only in Node.js, we need the wrtc library
            // because Node.js does not have WebRTC.
            // Wrap with createSimplePeerWrtc().
            wrtc: createSimplePeerWrtc(
                require('node-datachannel/polyfill')
            ),
 
            // only in Node.js, we need the WebSocket library
            // because Node.js does not contain the WebSocket API.
            webSocketConstructor: require('ws').WebSocket
        }),
        pull: {},
        push: {}
    }
);
```

--------------------------------

### Remote storage client and remote setup

Source: https://rxdb.info/rx-storage-remote.html

Shows how to set up the client side with getRxStorageRemote and the remote side with exposeRxStorageRemote. The messageChannelCreator must return an object with messages$, send(), and close().

```javascript
// on the client
import { getRxStorageRemote } from 'rxdb/plugins/storage-remote';
const storage = getRxStorageRemote({
    identifier: 'my-id',
    mode: 'storage',
    messageChannelCreator: () => Promise.resolve({
        messages$: new Subject(),
        send(msg) {
            // send to remote storage
        }
    })
});
const myDb = await createRxDatabase({
    storage
});
 
```

```javascript
// on the remote
import { getRxStorageLocalstorage } from 'rxdb/plugins/storage-localstorage';
import { exposeRxStorageRemote } from 'rxdb/plugins/storage-remote';
exposeRxStorageRemote({
    storage: getRxStorageLocalstorage(),
    messages$: new Subject(),
    send(msg){
        // send to other side
    }
});
```
Tokens:
Raw