oxigraph/js

Oxigraph for JavaScript

This package provides a JavaScript API on top of Oxigraph compiled with WebAssembly.

Oxigraph is a work in progress graph database written in Rust implementing the SPARQL standard.

It is a work in progress and currently offers a simple in-memory store with SPARQL 1.1 Query capabilities.

The store is also able to load RDF serialized in Turtle, TriG, N-Triples, N-Quads and RDF XML.

It is distributed using a a NPM package that should work with nodeJS.

npm install oxigraph

const oxigraph = require('oxigraph');

API

Oxigraph currently provides a simple JS API. It is centered around the MemoryStore class.

The NamedNode, BlankNode, Literal, DefaultGraph, Quad and DataFactory types are following the RDF/JS datamodel specification.

To import MemoryStore using Node:

const { MemoryStore } = require('oxigraph');

MemoryStore

MemoryStore(optional sequence<Quad>? quads) (constructor)

const store = new MemoryStore();

If provided, the MemoryStore will be initialized with a sequence of quads.

MemoryStore.dataFactory

Returns a DataFactory following RDF/JS datamodel specification.

Example:

const store = new MemoryStore();
const ex = store.dataFactory.namedNode("http://example.com");
const blank = store.dataFactory.blankNode();
const foo = store.dataFactory.literal("foo");
const quad = store.dataFactory.quad(blank, ex, foo);

MemoryStore.prototype.add(Quad quad)

Inserts a quad in the store.

Example:

store.add(quad);

MemoryStore.prototype.delete(Quad quad)

Removes a quad from the store.

Example:

store.delete(quad);

MemoryStore.prototype.has(Quad quad)

Returns a boolean stating if the store contains the quad.

Example:

store.has(quad);

MemoryStore.prototype.match(optional Term? subject, optional Term? predicate, optional Term? object, optional Term? graph)

Returns an array with all the quads matching a given quad pattern.

Example to get all quads in the default graph with ex for subject:

store.match(ex, null, null, store.dataFactory.defaultGraph());

Example to get all quads:

store.match();

MemoryStore.prototype.query(String query)

Executes a SPARQL 1.1 Query. For SELECT queries the return type is an array of Map which keys are the bound variables and values are the values the result is bound to. For CONSTRUCT and ÐESCRIBE queries the return type is an array of Quad. For ASK queries the return type is a boolean.

Example of SELECT query:

for (binding of store.query("SELECT DISTINCT ?s WHERE { ?s ?p ?o }")) {
    console.log(binding.get("s").value);
}

Example of CONSTRUCT query:

const filteredStore = new MemoryStore(store.query("CONSTRUCT { <http:/example.com/> ?p ?o } WHERE { <http:/example.com/> ?p ?o }"));

Example of ASK query:

if (store.query("ASK { ?s ?s ?s }")) {
    console.log("there is a triple with same subject, predicate and object");
}

MemoryStore.prototype.load(String data, String mimeType, NamedNode|String? baseIRI, NamedNode|BlankNode|DefaultGraph? toNamedGraph)

Loads serialized RDF triples or quad into the store. The method arguments are:

1. data: the serialized RDF triples or quads.
2. mimeType: the MIME type of the serialization. See below for the supported mime types.
3. baseIRI: the base IRI to use to resolve the relative IRIs in the serialization.
4. toNamedGraph: for triple serialization formats, the name of the named graph the triple should be loaded to.

The available formats are:

• Turtle: text/turtle
• TriG: application/trig
• N-Triples: application/n-triples
• N-Quads: application/n-quads
• RDF XML: application/rdf+xml

Example of loading a Turtle file into the named graph <http://example.com/graph> with the base IRI http://example.com:

store.load("<http://example.com> <http://example.com> <> .", "text/turtle", "http://example.com", store.dataFactory.namedNode("http://example.com/graph"));

Example

Insert the triple <http://example/> <http://schema.org/name> "example" and log the name of <http://example/> in SPARQL:

const { MemoryStore } = require('oxigraph');
const store = new MemoryStore();
const dataFactory = store.dataFactory;
const ex = dataFactory.namedNode("http://example/");
const schemaName = dataFactory.namedNode("http://schema.org/name");
store.add(dataFactory.triple(ex, schemaName, dataFactory.literal("example")));
for (binding of store.query("SELECT ?name WHERE { <http://example/> <http://schema.org/name> ?name }")) {
    console.log(binding.get("name").value);
}

How to contribute

The Oxigraph bindings are written in Rust using the Rust WASM toolkit.

The The Rust Wasm Book is a great tutorial to get started.

To build the JavaScript bindings, just run wasm-pack build, to run the tests of the JS bindings written in JS just do a usual npm test.