Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/CapacitorSet/rebridge
A transparent Javascript interface to Redis.
https://github.com/CapacitorSet/rebridge
es6 es6-proxies nodejs redis redis-database
Last synced: about 1 month ago
JSON representation
A transparent Javascript interface to Redis.
- Host: GitHub
- URL: https://github.com/CapacitorSet/rebridge
- Owner: CapacitorSet
- License: mit
- Created: 2016-07-10T21:03:10.000Z (about 8 years ago)
- Default Branch: master
- Last Pushed: 2018-02-08T03:18:27.000Z (over 6 years ago)
- Last Synced: 2024-05-09T18:27:50.198Z (2 months ago)
- Topics: es6, es6-proxies, nodejs, redis, redis-database
- Language: JavaScript
- Size: 50.8 KB
- Stars: 366
- Watchers: 12
- Forks: 13
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Lists
- awesome-es2015-proxy - rebridge - Redis bridge. (Proxy Resources / Modules)
README
Rebridge
========
[](https://www.npmjs.com/package/rebridge)
[](https://travis-ci.org/CapacitorSet/rebridge)
Rebridge is a transparent Javascript-Redis bridge. You can use it to create JavaScript objects that are *automatically* synchronized to a Redis database.
## Install
```
npm install rebridge
```
## Usage
### Synchronous, non-blocking usage
```js
const Rebridge = require("rebridge");
const redis = require("redis");
const client = redis.createClient();
const db = new Rebridge(client, {
mode: "deasync"
});
db.users = [];
db.users.push({
username: "johndoe",
email: "[email protected]"
});
db.users.push({
username: "foobar",
email: "[email protected]"
});
db.users.push({
username: "CapacitorSet",
email: "[email protected]"
});
console.log("Users:", db.users._value); // Prints the list of users
const [me] = db.users.filter(user => user.username === "CapacitorSet");
console.log("Me:", me); // Prints [{username: "CapacitorSet", email: "..."}]
client.quit();
```
### Asynchronous usage
```js
const Rebridge = require("rebridge");
const redis = require("redis");
const client = redis.createClient();
const db = new Rebridge(client);
db.users.set([])
.then(() => Promise.all([
db.users.push({
username: "johndoe",
email: "[email protected]"
}),
db.users.push({
username: "foobar",
email: "[email protected]"
}),
db.users.push({
username: "CapacitorSet",
email: "[email protected]"
})
]))
.then(() => db.users._promise)
.then(arr => console.log("Users:", arr)) // Prints the list of users
.then(() => db.users.filter(user => user.username === "CapacitorSet"))
.then(([me]) => console.log("Me:", me)) // Prints [{username: "CapacitorSet", email: "..."}]
.then(() => client.quit())
.catch(err => console.log("An error occurred:", err));
```
## Requirements
Rebridge uses ES6 Proxy objects, so it requires at least Node 6.
## Limitations
* By default, Rebridge objects can't contain functions, circular references, and in general everything for which `x === JSON.parse(JSON.stringify(x))` doesn't hold true. However, you can use a custom serialization function (see below).
* Obviously, you cannot write directly to `db` (i.e. you can't do `var db = Rebridge(); db = {"name": "foo"}`).
## Custom serialization
By default, Rebridge serializes to JSON, but you can pass a custom serialization function. For instance, if you wanted to serialize to YAML, you would do something like this:
```js
const yaml = require("js-yaml");
const db = new Rebridge(client, {
serialize: yaml.dump,
deserialize: yaml.load
});
```
## How it works
`Rebridge()` returns an ES6 Proxy object around `{}`. When you try to read one of its properties, the getter intercepts the call, retrieves and deserializes the result from the database, and returns that instead; the same happens when you write to it.
The Proxy will forward the native methods and properties transparently, so that the objects it returns should behave the same as native objects; if this is not the case, file an issue on GitHub.
First-level objects (eg. `db.foo`) correspond to keys in the Redis database; they are serialized using JSON. When requesting deeper objects (eg. `db.foo.bar.baz`), the first-level object (`db.foo`) is deserialized to a native object, which is then accessed in the standard way.