RDF/JS object mapping library
npm install rdfjs-wrapper
An RDF/JS object mapping library.
The purpose of the RDF/JS Wrapper library is to enable idiomatic JavaScript object-oriented programming over RDF with type system support (TypeScript compatible).
In other words, RDF data is abstracted away and developers can define standard mapping classes to program over it.
Additionally, standard mapping classes can be defined and reused in any number of context where they are relevant (see for example @solid/object).
RDF/JS Wrapper uses the interfaces described in the RDF/JS specifications.
Practically, to map RDF to objects, you need to:
1. Write a class or use an existing class that extends TermWrapper
1. Each class needs a Term, a Dataset, and a DataFactory to be instantiated
1. Each class property will have an associated RDF Property (a string, generally a URL, that is defined by an ontology/vocabulary)
1. Each class property depending on its type can have:
1. a corresponding ValueMapping to get values, that is translating RDF Terms to JavaScript primitive values (string, number, boolean...)
1. a corresponding TermMapping to set values, that is translating Javascript primitive values to RDF Terms
1. a corresponding ValueMapping and TermMapping for sets of primitive values
1. a corresponding TermWrapper for properties returning a class
1. two corresponding TermWrappers (generally the same) for sets of classes
1. Each class mutates the underlying Dataset that is passed to it at instantiation time
In order to wrap RDF, one needs an underlying data structure. Therefore, both TermWrapper and DatasetWrapper take an RDF/JS Dataset and Datafactory as constructor parameters.
Term wrapping lets you manipulate data in a graph via class properties.
A term wrapper instantiates a class from a term.
For example you can write a Person class with one name property:
``javascript
import { TermWrapper } from "https://unpkg.com/rdfjs-wrapper"
class Person extends TermWrapper {
get name() {
return this.singularNullable("http://example.com/name", ValueMappings.literalToString)
}
set name(value) {
this.overwriteNullable("http://example.com/name", value, TermMappings.literalToString)
}
`
Assuming the following RDF has been loaded in a dataset dataset_x:
`turtle
PREFIX ex:
ex:person1 ex:name "Alice" .
`
Class usage:
`javascript
const person1 = new Person(DataFactory.namedNode("http://example.com/person1"), dataset_x, DataFactory)
// Get property
console.log(person1.name)
// outputs "Alice"
// Set property
person1.name = [...person1].reverse().join("")
console.log(person1.name)
// outputs "ecilA"
`
Dataset wrapping lets you find data in a graph that is meant to be wrapped.
For example, you can write a People dataset wrapper to find each Person in a graph:
`javascript`
class People extends DatasetWrapper {
[Symbol.iterator]() {
return this.subjectsOf("http://example.com/name", Person)
}
}
Assuming the following RDF has been loaded in a dataset dataset_y:
`turtle
PREFIX ex:
ex:person1 ex:name "Alice" .
ex:person2 ex:name "Bob" .
`
Dataset Wrapper usage:
`javascript
const people = new People(dataset_y, DataFactory)
for (const person of people) {
console.log(person.name)
}
// outputs
// Alice
// Bob
`
This work is dual-licensed under MIT and Apache 2.0.
You can choose between one of them if you use this work.
SPDX-License-Identifier: MIT OR Apache-2.0`