@doop/deepstream

Deepstream.io adapter for Doop.

Features vs. Vanilla Deepstream:

• Entirely promise based - no weird callbacks that DS seems to prefer for some methods
• Minimal get() / set() implementations which try to avoid subscribing to Deepstream to fetch data when possible
• Names are dropped entirely to use paths which can be in dotted.notation, slash/notation or ['array', 'format']
• Distinction from record names and subkeys via At notation - e.g. this/is/a/record@this/is/a/subkey
• Array format paths are automatically escaped if any member contains a splitter character (dots or slashes)

Backend

See config.js for example config to merge.

The module will be detected and loaded automatically with the server as app.deepstream.

Frontend

The vm.$deepstream service should be loaded by default.

app.component({
	data() { return {
		doc: {},
	}},
	watch: {
		doc: {
			deep: true,
			handler() {
				this.$debug('SET', this.doc);
				this.$deepstream.set(this.doc);
			},
		},
	},
	created() {
		this.$debug.enable(true);
		this.record = this.$deepstream.get('debug/deepstream');
		this.record.subscribe(values => {
			this.$debug('GET', this.doc);
			this.doc = values;
		});
	},
});

API

client

The actual DeepstreamClient instance.

options

General options for the Deepstram wrapper.

Options are:

| Option | Type | Default | Description | |------------------|------------|----------|------------------------------------------| | pathAtNotation | boolean | true | Support At notation when splitting paths | | pathSplitSlash | boolean | true | Support path seperators with slashes | | pathSplitDot | boolean | false | Support path seperators with dots | | split | function | See code | Path spliter function |

pathCache

An object containing all loaded records.

isReady

Boolean indicating if the module has loaded, connected and authenticated.

connect(url, auth?)

Async function which establishes a connection with an optional auth object.

getRecord(path)

Fetch (+cache) a DeepstreamRecord instance for a given path.

splitPath(path)

Internal function used to seperate a regular path into component deepstream docName + docPath specs, used by some DS functions. This function supports dotted.notation, slash/notation and ['array', 'notation']. Array members are sanitised and is the recommended method to specifiy a path.

get(path, fallback?)

Async function to fetch a given, nested path. See splitPath() for valid path specifications. If the record doesn't exist the fallback is used instead of throwing.

has(path)

Async function which will return a boolean if the path exists.

set(path, value)

Async function to set a given, nested path. See splitPath() for valid path specifications.

merge(path, values)

Convenience async function to merge the given values object into an existing object + save. See splitPath() for valid path specifications.

subscribe(path, cb, options?)

Subscribe to a path, calling the callback as cb(newValue) for any change.

Options can be:

| Option | Type | Default | Description | |-------------|-----------|---------|-------------------------------------------------------------------------------------------------------------------| | immediate | boolean | true | Whether to fire the subscription immediately with the current value, if falsy only updates will fire the callback |

unsubscribe(path, cb)

Release a given callback from its subscription.

VUE: bindData(vuePath, dsPath, options?)

Bind a local Vue variable to a remote Deepstream path. Read or writes to the remote will sync with local (assuming the correct allow{Read,Write} options are enabled).

Options can be:

| Option | Type | Default | Description | |--------------|------------|---------|--------------------------------------------------------------------------| | immediate | boolean | true | Whether to fetch the state immediately after subscription | | allowRead | boolean | true | Keep the local state up to date with the remote | | allowWrite | boolean | true | Keep the remote state up to date with local | | readData | function | | Function to call as (newData) when any data is incomming from remote | | writeData | function | | Function to call as (newData) before changes are transmitted to remote |

Notes:

• Data object parameters in readData and writeData can mutate incomming / outgoing data respectively
• Setting {allowWrite: false} is essencially the same as $deepstream.subscribe(path, cb) but automatically updates local state without a callback

VUE: destroyVM()

Clean up all bindings and release any pending subscriptions. Called automatically when a Vue component is entering the beforeDestroy lifecycle stage.

rpc

Object for Remote-Procedure-Calls.

rpc.provide(name, cb)

Regisiter an RPC function.

rpc.call(name, data?)

Call a registered RPC function with an optional data object.