A tiny library of formatters and combinators to simplify working with neo4j-driver
's returned structure.
npm install neopreen --save
const np = require('neopreen')
const preen = np.row({
person: np.node({
name: np.string
}),
food: np.node({
name: np.string,
litres: np.float
}),
relation: np.relation({
amount: np.string
})
})
const data = sess.run(
` CREATE (person:Person { name: "Tom" })
CREATE (food:Item { name: 'Sherbet lemonade'
, litres: 0.5 })
CREATE (person)
-[relation:LIKES { amount: "A LOT" }]
->(food)
RETURN person, relation, food `)
.then(preen)
The resulting contents of data
's promise will look like this:
{
person: {
name: 'Tom',
$id: 14001, // Whatever Neo4j assigns.
$labels: [ 'Person' ]
},
food: {
name: 'Sherbet lemonade',
litres: 0.5,
$id: 14002, // Whatever Neo4j assigns.
$labels: [ 'Item' ]
},
relation: {
amount: 'A LOT',
$from: 14001,
$id: 59009, // Whatever Neo4j assigns.
$to: 14002,
$type: 'LIKES'
}
}
As we would all hope, this API treats data as immutable. It won't update the structure you pass in; it will, instead, return a copy with the changes applied.
Take a Neo4j integer, and call x.toNumber()
on it, returning the int
value.
Cast the given value to a float
. This is done with the unary x => +x
.
Cast the given value to a string
using x => '' + x
.
Cast the given value to a bool
using x => !!x
.
Format an array, applying the given formatter
to each element within. For example:
// Returns [1.0, 2.0, 3.0]
np.array(np.float)([1, '2', 3.0])
Format an object according to the given schema. Missing keys will be denoted by null
:
const validator = np.object({
name: np.string,
cats: np.int,
hat: np.string
})
// { name: 'Jeff', cats: 12, hat: null }
validator({
name: 'Jeff',
cats: require('neo4j-driver').v1.int(12)
})
Format a Node
type from the neo4j-driver
library. The result is an object with the node's properties formatted according to the provided formatter, along with two extra properties:
$id
, the Neo4j ID of the node (converted toint
).$labels
, the labels applied to the node (as astring
array).
Format a Relationship
type from the neo4j-driver
library. The result is an object with the relationship's properties formatted according to the provided formatter, along with two extra properties:
$from
, the Neo4j ID of the source node (converted toint
).$to
, the Neo4j ID of the target node (converted toint
).$id
, the Neo4j ID of the relationship.$type
, the label for the relationship.
Format a Record
type from the neo4j-driver
library. This is useful for users consuming the output via neo4j-driver
's observable interface. Each record can be formatted according to the formatter as it arrives.
If you're expecting one result (that is, a single returned row containing a single value), this function returns that structure. It is advised that this result is formatted with one of the original formatters (unless it's a Node
or Relationship
, in which case you can nest the node
and relation
formatters).
For a result set of any number of rows with more than one field being returned per row. In the repository's main example, row
is used as only one row is being returned. If that is not the case, chances are that many
is what you want.
Format the results of a query that returns multiple fields, but only one row (such as the example at the top of this README).
Format the results of a query that returns multiple rows, but only one field.
PRs are always welcome! There's a code of conduct, naturally, so be mindful!