RDF/JS Wrapper

An RDF/JS object mapping library.

Purpose

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).

How To?

Publish the package

1. Run npm version major | minor | patch locally (see npm-version)
2. Draft a new release
3. The Continuous Deployment action will be triggered and automatically publish to npm

Background

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
2. Each class needs a Term, a Dataset, and a DataFactory to be instantiated
3. Each class property will have an associated RDF Property (a string, generally a URL, that is defined by an ontology/vocabulary)
4. Each class property will have an associated arity (singular, singular nullable or set)
5. 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...)
   2. a corresponding TermMapping to set values, that is translating Javascript primitive values to RDF Terms
   3. a corresponding ObjectMapping to wrap child objects as a TermWrapper
   4. a corresponding ValueMapping and TermMapping for sets of primitive values (both can be an ObjectMapping)
6. Each class mutates the underlying Dataset that is passed to it at instantiation time

Wrapping RDF

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.

Wrapping Terms

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:

import { TermWrapper, ValueMapping, TermMapping } from "https://unpkg.com/@rdfjs/wrapper"

class Person extends TermWrapper {
    get name() {
        return this.singularNullable("https://example.org/name", ValueMapping.literalToString)
    }

    set name(value) {
        this.overwriteNullable("https://example.org/name", value, TermMapping.literalToString)
    }
}

Assuming the following RDF has been loaded in a dataset dataset_x:

PREFIX ex: <https://example.org/>

ex:person1 ex:name "Alice" .

Class usage:

const person1 = new Person("https://example.org/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"

Wrapping Datasets

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:

class People extends DatasetWrapper {
    [Symbol.iterator]() {
        return this.subjectsOf("https://example.org/name", Person)
    }
}

Assuming the following RDF has been loaded in a dataset dataset_y:

PREFIX ex: <https://example.org/>

ex:person1 ex:name "Alice" .
ex:person2 ex:name "Bob" .

Dataset Wrapper usage:

const people = new People(dataset_y, DataFactory)

for (const person of people) {
    console.log(person.name)
}
// outputs
// Alice
// Bob

Wrapping objects

For example you can write a Person class with one name and one mum property:

import { TermWrapper, ValueMapping, TermMapping, ObjectMapping } from "https://unpkg.com/@rdfjs/wrapper"

class Person extends TermWrapper {
    get name() {
        return this.singularNullable("https://example.org/name", ValueMapping.literalToString)
    }

    set name(value) {
        this.singularNullable("https://example.org/name", value, TermMapping.literalToString)
    }

    get mum() {
        return this.singularNullable("https://example.org/mum", ObjectMapping.as(Person))
    }

    set mum(value) {
        this.overwriteNullable("https://example.org/mum", value, ObjectMapping.as(Person))
    }
}

Assuming the following RDF has been loaded in a dataset dataset_z:

PREFIX ex: <https://example.org/>

ex:person1 ex:name "Alice" .

ex:person2
    ex:name "Bob" ;
    ex:mum ex:person2 ;
.

Class usage:

const person2 = new Person("https://example.org/person2", dataset_z, DataFactory)

// Get property
console.log(person2.name)
// outputs "Bob"

// Get property from child class
console.log(person2.mum.name)
// outputs "Alice"

// Set class properties
const person3 = new Person("https://example.org/person3", dataset_z, DataFactory)
person3.name = "Joanne"
person1.mum = person3
console.log(person1.mum.name)
// outputs "Joanne"
console.log(person2.mum.mum.name)
// outputs "Joanne"

See also

• RDF
• Knowledge Graph

License

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