@muze-nl/oldm-core 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Muze.nl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,116 @@
+# @muze-nl/oldm-core
+
+Core Object Linked Data Mapper package.
+
+This package contains the object/graph mapping layer only. It has explicit ESM exports, no bundled parser/writer, no N3 dependency, and no global side effects.
+
+```javascript
+import oldm, { one, many, first, Collection } from '@muze-nl/oldm-core'
+import { n3Parser, n3Writer } from '@muze-nl/oldm-n3'
+
+const context = oldm({
+  parser: n3Parser,
+  writer: n3Writer
+})
+```
+
+
+## Prefix preference
+
+OLDM shortens predicate and type IRIs with the prefixes configured on the context. Prefix declarations found in Turtle input are parser conveniences; they do not decide the JavaScript property names exposed by OLDM.
+
+When multiple prefixes point at the same namespace, client-provided prefixes are preferred over OLDM defaults, and defaults are preferred over prefixes found in a parsed source document. For example, both `pim:` and `space:` are common aliases for `http://www.w3.org/ns/pim/space#`. Since OLDM prefers `space` for that namespace, profile data using either `pim:storage` or `space:storage` is exposed as `space$storage` in JavaScript.
+
+```javascript
+const context = oldm({
+  parser: n3Parser,
+  prefixes: {
+    space: 'http://www.w3.org/ns/pim/space#'
+  }
+})
+
+const profile = context.parse(turtle, profileUrl, 'text/turtle')
+const me = profile.subjects[`${profileUrl}#me`]
+
+console.log(me.space$storage.id)
+```
+
+
+## Multiple graphs in one context
+
+`Context` keeps a registry of parsed graphs and exposes a combined view over all graphs loaded into the same context.
+
+```javascript
+const profile = context.parse(profileTurtle, profileUrl, 'text/turtle')
+const settings = context.parse(settingsTurtle, settingsUrl, 'text/turtle')
+
+profile.get(`${profileUrl}#me`)       // graph-specific view
+context.get(`${profileUrl}#me`)       // combined context view
+context.graphs                        // parsed graphs in load order
+context.graph(profileUrl)             // graph by source URL
+context.data                          // combined subjects
+context.subjects                      // combined subject map
+context.sources(context.get(`${profileUrl}#me`))
+// graphs containing that subject
+context.sources(context.get(`${profileUrl}#me`), 'vcard$fn')
+// graphs containing that property
+context.sources(context.get(`${profileUrl}#me`), 'vcard$fn', 'Auke')
+// graphs containing that specific value
+profile.context.data                  // same combined view, starting from a graph
+profile.context.subjects              // same combined subject map, starting from a graph
+```
+
+The combined context view merges named subjects by IRI. Graph-specific views remain unchanged, so code can still separate data by original resource. Blank nodes remain graph-scoped.
+
+If a loader or middleware gives you a `Graph`, use `graph.context` to access the combined view for all graphs loaded into the same context:
+
+```javascript
+const graph = context.parse(profileTurtle, profileUrl, 'text/turtle')
+
+graph.data             // subjects from this one resource
+graph.context.data     // combined subjects from the whole context
+graph.context.get(id)  // merged subject from the whole context
+```
+
+For source-aware writes, use the graph-specific helpers when you know the resource you want to edit:
+
+```javascript
+profile.set(`${profileUrl}#me`, 'vcard$fn', 'Auke')
+profile.add(`${profileUrl}#me`, 'schema$knowsAbout', 'Linked Data')
+profile.delete(`${profileUrl}#me`, 'schema$knowsAbout', 'Old value')
+```
+
+Context-level helpers can choose a graph explicitly:
+
+```javascript
+context.set(`${profileUrl}#me`, 'vcard$fn', 'Auke', { graph: profile })
+context.add(`${profileUrl}#me`, 'schema$knowsAbout', 'Solid', { graph: profileUrl })
+```
+
+When no graph is passed, `context.set/add/delete()` uses a conservative default: the subject's exact graph URL, the subject document URL without a fragment, the only graph that currently contains the subject, the configured `defaultGraph`, or the only graph in the context. Direct property assignment on a named subject from `context.get(...)` uses the same resolver, so simple edits can stay object-like:
+
+```javascript
+const me = context.get(`${profileUrl}#me`)
+me.vcard$fn = 'Auke'
+delete me.vcard$nickname
+```
+
+If there is no obvious source graph, OLDM throws and asks you to choose one explicitly with `context.set/add/delete(..., { graph })` or `graph.set/add/delete(...)`.
+
+## Public exports
+
+- default `oldm(options)` context factory
+- `Context`
+- `Graph`
+- `NamedNode`
+- `BlankNode`
+- `Collection`
+- `one(values, whichOne)`
+- `many(values)`
+- `first(...values)`
+- `prefixes`
+- `rdfType`
+
+## License
+
+MIT.

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@muze-nl/oldm-core",
+  "version": "0.6.0",
+  "description": "Core Object - Linked Data Mapper, without parser or writer dependencies",
+  "type": "module",
+  "main": "src/oldm.mjs",
+  "exports": {
+    ".": "./src/oldm.mjs"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "test": "tap --disable-coverage test/*.mjs",
+    "coverage": "tap --allow-incomplete-coverage --show-full-coverage test/*.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/muze-nl/oldm.git",
+    "directory": "packages/oldm-core"
+  },
+  "author": "auke@muze.nl",
+  "license": "MIT",
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/src/oldm.mjs

@@ -0,0 +1,961 @@
+export default function oldm(options)
+{
+	return new Context(options)
+}
+
+export const rdfType = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type'
+
+export const prefixes = {
+	acl:    'http://www.w3.org/ns/auth/acl#',
+	acp:    'http://www.w3.org/ns/solid/acp#',
+	dcterms:'http://purl.org/dc/terms/',
+	foaf:   'http://xmlns.com/foaf/0.1/',
+	ldn:    'https://www.w3.org/ns/ldn#',
+	ldp:    'http://www.w3.org/ns/ldp#',
+	notify: 'http://www.w3.org/ns/solid/notifications#',
+	oidc:   'http://www.w3.org/ns/solid/oidc#',
+	owl:    'http://www.w3.org/2002/07/owl#',
+	pim:    'http://www.w3.org/ns/pim/space#',
+	rdf:    'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+	rdfs:   'http://www.w3.org/2000/01/rdf-schema#',
+	schema: 'http://schema.org/',
+	solid:  'http://www.w3.org/ns/solid/terms#',
+	stat:   'http://www.w3.org/ns/posix/stat#',
+	turtle: 'http://www.w3.org/ns/iana/media-types/text/turtle#',
+	vcard:  'http://www.w3.org/2006/vcard/ns#',
+	xsd:    'http://www.w3.org/2001/XMLSchema#'
+}
+
+export function one(values, whichOne='last')
+{
+	let result = values
+	if (Array.isArray(values)) {
+		if (whichOne=='last') {
+			result = values[values.length-1]
+		} else if (whichOne=='first') {
+			result = values[0]
+		} else if (typeof whichOne=='function') {
+			result = whichOne(values)			
+		} else {
+			throw new Error('Unknown value for whichOne parameter')
+		}
+	}
+	return result
+}
+
+export function many(values)
+{
+	if (Array.isArray(values)) {
+		return values
+	}
+	if (values == null) {
+		return []
+	}
+	return [values]
+}
+
+export function first(...values)
+{
+	for (const value of values) {
+		if (value!==null && value!==undefined) {
+			return value
+		}
+	}
+	return null
+}
+
+function values(value)
+{
+	if (Array.isArray(value) && !(value instanceof Collection)) {
+		return value
+	}
+	if (value === undefined) {
+		return []
+	}
+	return [value]
+}
+
+function mergeValue(existing, value)
+{
+	const result = values(existing)
+	for (const item of values(value)) {
+		if (!result.some(existingItem => sameValue(existingItem, item))) {
+			result.push(item)
+		}
+	}
+	if (result.length == 0) {
+		return undefined
+	}
+	if (result.length == 1) {
+		return result[0]
+	}
+	return result
+}
+
+function sameValue(left, right)
+{
+	if (left === right) {
+		return true
+	}
+	if (left instanceof NamedNode && right instanceof NamedNode) {
+		return left.id == right.id
+	}
+	if (left instanceof NamedNode && typeof right == 'string') {
+		return left.id == right
+	}
+	if (typeof left == 'string' && right instanceof NamedNode) {
+		return left == right.id
+	}
+	if (left instanceof Collection && right instanceof Collection) {
+		return left.length == right.length
+			&& left.every((item, index) => sameValue(item, right[index]))
+	}
+	if (isLiteral(left) && isLiteral(right)) {
+		return String(left) == String(right)
+			&& left?.type == right?.type
+			&& left?.language == right?.language
+	}
+	return false
+}
+
+
+function sameSourceValue(left, right)
+{
+	if (left === right) {
+		return true
+	}
+	if (left instanceof NamedNode && right instanceof NamedNode) {
+		return left.id == right.id
+	}
+	if (left instanceof NamedNode && typeof right == 'string') {
+		return left.id == right
+	}
+	if (typeof left == 'string' && right instanceof NamedNode) {
+		return left == right.id
+	}
+	if (left instanceof Collection && right instanceof Collection) {
+		return left.length == right.length
+			&& left.every((item, index) => sameSourceValue(item, right[index]))
+	}
+	if (isLiteral(left) && isLiteral(right)) {
+		const leftType = left?.type
+		const rightType = right?.type
+		const leftLanguage = left?.language
+		const rightLanguage = right?.language
+		return String(left) == String(right)
+			&& (!leftType || !rightType || leftType == rightType)
+			&& (!leftLanguage || !rightLanguage || leftLanguage == rightLanguage)
+	}
+	return false
+}
+
+function resolveValue(value, subjects, context)
+{
+	if (value instanceof Collection) {
+		const collection = new Collection(context)
+		for (const item of value) {
+			collection.push(resolveValue(item, subjects, context))
+		}
+		return collection
+	}
+	if (Array.isArray(value)) {
+		return value.map(item => resolveValue(item, subjects, context))
+	}
+	if (value instanceof NamedNode && subjects[value.id]) {
+		return subjects[value.id]
+	}
+	return value
+}
+
+function isLiteral(value)
+{
+	return (
+		value instanceof String
+		|| value instanceof Number
+		|| typeof value == 'boolean'
+		|| typeof value == 'string'
+		|| typeof value == 'number'
+	)
+}
+
+export class Context {
+	#buildingSubjects = false
+
+	constructor(options)
+	{
+		const clientPrefixes = options?.prefixes ?? {}
+		this.prefixes = {...prefixes, ...clientPrefixes}
+		this.prefixOrder = [
+			...Object.keys(clientPrefixes),
+			...Object.keys(prefixes).filter(prefix => !(prefix in clientPrefixes))
+		]
+		if (!this.prefixes['xsd']) {
+			this.prefixes['xsd'] = 'http://www.w3.org/2001/XMLSchema#'
+			this.prefixOrder.push('xsd')
+		}
+		this.parser = options?.parser
+		this.writer = options?.writer
+		this.graphs = []
+		this.graphsByUrl = Object.create(null)
+		this.defaultGraph = options?.defaultGraph ?? null
+		this.separator = options?.separator ?? '$'
+
+		Object.defineProperty(this, 'subjects', {
+			get() {
+				return this.getSubjects()
+			}
+		})
+
+		Object.defineProperty(this, 'data', {
+			get() {
+				return Object.values(this.subjects)
+			}
+		})
+	}
+
+	parse(input, url, type)
+	{
+		const {quads, prefixes} = this.parser(input, url, type)
+		if (prefixes) {
+			for (let prefix in prefixes) {
+				let prefixURL = prefixes[prefix]
+				if (prefixURL.match(/^http(s?):\/\/$/i)) {
+					prefixURL += url.substring(prefixURL.length)
+				} else try {
+					prefixURL = new URL(prefixes[prefix], url).href
+				} catch(err) {
+					console.error('Could not parse prefix', prefixes[prefix], err.message)
+				}
+
+				if (!this.prefixes[prefix]) {
+					this.prefixes[prefix] = prefixURL
+					this.prefixOrder.push(prefix)
+				}
+			}
+		}
+		return this.addGraph(new Graph(quads, url, type, prefixes, this))
+	}
+
+	addGraph(graph)
+	{
+		if (!graph?.url) {
+			throw new Error('Cannot add graph without a url')
+		}
+
+		const existing = this.graphsByUrl[graph.url]
+		if (existing) {
+			const index = this.graphs.indexOf(existing)
+			if (index >= 0) {
+				this.graphs[index] = graph
+			}
+		} else {
+			this.graphs.push(graph)
+		}
+		this.graphsByUrl[graph.url] = graph
+		return graph
+	}
+
+	graph(url)
+	{
+		return this.graphsByUrl[this.fullURI(url)]
+	}
+
+	set(subject, predicate, value, options={})
+	{
+		return this.resolveGraph(subject, options).set(subject, predicate, value)
+	}
+
+	add(subject, predicate, value, options={})
+	{
+		return this.resolveGraph(subject, options).add(subject, predicate, value)
+	}
+
+	delete(subject, predicate=null, value=undefined, options={})
+	{
+		const graph = this.resolveGraph(subject, options)
+		if (arguments.length < 3) {
+			return graph.delete(subject, predicate)
+		}
+		return graph.delete(subject, predicate, value)
+	}
+
+	resolveGraph(subject, options={})
+	{
+		if (options.graph) {
+			return this.getGraphOption(options.graph)
+		}
+
+		if (subject instanceof BlankNode && subject.graph instanceof Graph) {
+			return subject.graph
+		}
+
+		const id = this.subjectID(subject)
+		if (id) {
+			const exactGraph = this.graphsByUrl[id]
+			if (exactGraph) {
+				return exactGraph
+			}
+
+			const documentGraph = this.graphsByUrl[this.documentURL(id)]
+			if (documentGraph) {
+				return documentGraph
+			}
+
+			const subjectSources = this.graphs.filter(graph => graph.subjects[id])
+			if (subjectSources.length == 1) {
+				return subjectSources[0]
+			}
+			if (subjectSources.length > 1) {
+				throw new Error(`Cannot choose a source graph for ${id}. Use context.set/add/delete(..., { graph }) or graph.set/add/delete(...) to choose one explicitly.`)
+			}
+		}
+
+		if (this.defaultGraph) {
+			return this.getGraphOption(this.defaultGraph)
+		}
+
+		if (this.graphs.length == 1) {
+			return this.graphs[0]
+		}
+
+		throw new Error('Cannot choose a source graph. Use context.set/add/delete(..., { graph }) or graph.set/add/delete(...) to choose one explicitly.')
+	}
+
+	getGraphOption(graph)
+	{
+		if (graph instanceof Graph) {
+			if (!this.graphs.includes(graph)) {
+				throw new Error('The selected graph is not part of this context')
+			}
+			return graph
+		}
+
+		const resolved = this.graph(graph)
+		if (!resolved) {
+			throw new Error(`Unknown graph: ${graph}`)
+		}
+		return resolved
+	}
+
+	documentURL(id)
+	{
+		try {
+			const url = new URL(id)
+			url.hash = ''
+			return url.href
+		} catch(err) {
+			return id
+		}
+	}
+
+	sources(subject, predicate=null, value=undefined)
+	{
+		if (!subject) {
+			return [...this.graphs]
+		}
+
+		if (subject instanceof BlankNode && !(subject instanceof NamedNode)) {
+			return this.sourcesForBlankNode(subject, predicate, value, arguments.length >= 3)
+		}
+
+		const id = this.subjectID(subject)
+		if (!id) {
+			return []
+		}
+
+		return this.graphs.filter(graph => {
+			const graphSubject = graph.subjects[id]
+			return graphSubject
+				&& this.subjectHasSource(graphSubject, predicate, value, arguments.length >= 3)
+		})
+	}
+
+	sourcesForBlankNode(subject, predicate, value, hasValue)
+	{
+		const graph = subject.graph
+		if (!(graph instanceof Graph)) {
+			return []
+		}
+		if (this.subjectHasSource(subject, predicate, value, hasValue)) {
+			return [graph]
+		}
+		return []
+	}
+
+	subjectHasSource(subject, predicate, value, hasValue)
+	{
+		if (!predicate) {
+			return true
+		}
+
+		const property = this.propertyName(predicate)
+		if (!(property in subject)) {
+			return false
+		}
+		if (!hasValue) {
+			return true
+		}
+
+		return values(subject[property]).some(item => sameSourceValue(item, value))
+	}
+
+	subjectID(subject)
+	{
+		if (subject?.id) {
+			return this.fullURI(subject.id)
+		}
+		if (typeof subject == 'string') {
+			return this.fullURI(subject)
+		}
+		return null
+	}
+
+	propertyName(predicate)
+	{
+		if (predicate?.id) {
+			predicate = predicate.id
+		}
+		if (predicate == 'a' || predicate == rdfType || this.fullURI(predicate) == rdfType) {
+			return 'a'
+		}
+		return this.shortURI(this.fullURI(predicate))
+	}
+
+	get(shortID)
+	{
+		return this.subjects[this.fullURI(shortID)]
+	}
+
+	getSubjects()
+	{
+		const subjects = Object.create(null)
+
+		this.#buildingSubjects = true
+		try {
+			for (const graph of this.graphs) {
+				for (const id of Object.keys(graph.subjects)) {
+					if (!subjects[id]) {
+						subjects[id] = this.contextSubject(new NamedNode(id, this))
+					}
+				}
+			}
+
+			for (const graph of this.graphs) {
+				for (const [id, subject] of Object.entries(graph.subjects)) {
+					this.mergeSubject(subjects[id], subject, subjects)
+				}
+			}
+		} finally {
+			this.#buildingSubjects = false
+		}
+
+		return subjects
+	}
+
+	mergeSubject(target, source, subjects)
+	{
+		for (const [predicate, value] of Object.entries(source)) {
+			if (predicate == 'id') {
+				continue
+			}
+			target[predicate] = mergeValue(
+				target[predicate],
+				resolveValue(value, subjects, this)
+			)
+		}
+	}
+
+	contextSubject(subject)
+	{
+		const context = this
+		return new Proxy(subject, {
+			set(target, property, value, receiver) {
+				if (context.#buildingSubjects || typeof property == 'symbol' || property == 'id' || property == 'graph') {
+					return Reflect.set(target, property, value, receiver)
+				}
+
+				context.set(target.id, property, value)
+				context.updateContextProperty(target, property)
+				return true
+			},
+
+			deleteProperty(target, property) {
+				if (context.#buildingSubjects || typeof property == 'symbol' || property == 'id' || property == 'graph') {
+					return Reflect.deleteProperty(target, property)
+				}
+
+				context.delete(target.id, property)
+				context.updateContextProperty(target, property)
+				return true
+			}
+		})
+	}
+
+	updateContextProperty(target, property)
+	{
+		const updated = this.get(target.id)
+		if (updated && property in updated) {
+			target[property] = updated[property]
+		} else {
+			delete target[property]
+		}
+	}
+
+	fullURI(shortURI, separator=null)
+	{
+		if (!separator) {
+			separator = this.separator
+		}
+		const [prefix, path] = shortURI.split(separator)
+		if (path && this.prefixes[prefix]) {
+			return this.prefixes[prefix]+path 
+		}
+		return shortURI
+	}
+
+	shortURI(fullURI, separator=null)
+	{
+		if (!separator) {
+			separator = this.separator
+		}
+		for (const prefix of this.prefixOrder) {
+			if (fullURI.startsWith(this.prefixes[prefix])) {
+				return prefix + separator + fullURI.substring(this.prefixes[prefix].length)
+			}
+		}
+		return fullURI
+	}
+
+	setType(literal, shortType)
+	{
+		if (!shortType) {
+			return literal
+		}
+		if (typeof literal == 'string') {
+			literal = new String(literal)
+		} else if (typeof literal == 'number') {
+			literal = new Number(literal)
+		}
+		if (typeof literal !== 'object') {
+			throw new Error('cannot set type on ',literal,shortType)
+		}
+		literal.type = shortType
+		return literal
+	}
+
+	getType(literal)
+	{
+		if (literal && typeof literal == 'object') {
+			return literal.type
+		}
+		return null
+	}
+}
+
+export class Graph
+{
+	#blankNodes = Object.create(null)
+
+	constructor(quads, url, mimetype, prefixes, context)
+	{
+		this.mimetype = mimetype
+		this.url      = url
+		this.prefixes = prefixes
+		this.context  = context
+		this.subjects = Object.create(null)
+		for (let quad of quads) {
+			let subject
+			if (quad.subject.termType=='BlankNode') {
+				let shortPred = this.shortURI(quad.predicate.id,':')
+				let shortObj
+				switch(shortPred) {
+					case 'rdf:first':
+						subject = this.addCollection(quad.subject.id)
+						shortObj = quad.object.id ? this.shortURI(quad.object.id, ':') : null
+						if (shortObj!='rdf:nil') {
+							const value = this.getValue(quad.object)
+							if (value) {
+								subject.push(value)
+							}
+						}
+					continue
+					case 'rdf:rest':
+						this.#blankNodes[quad.object.id] = this.#blankNodes[quad.subject.id]
+					continue
+					default:
+						subject = this.addBlankNode(quad.subject.id)
+					break
+				}
+			} else {
+				subject = this.addNamedNode(quad.subject.id)
+			}
+			subject.addPredicate(quad.predicate.id, quad.object)
+		}
+		if (this.subjects[url]) {
+			this.primary = this.subjects[url]
+		} else {
+			this.primary = null
+		}
+		Object.defineProperty(this, 'data', {
+			get() {
+				return Object.values(this.subjects)
+			}
+		})
+	}
+
+	addNamedNode(uri)
+	{
+		// make sure any relative uri subject ids are fully qualified
+		let absURI = new URL(uri, this.url).href
+		if (!this.subjects[absURI]) {
+			this.subjects[absURI] = new NamedNode(absURI, this)
+		}
+		return this.subjects[absURI]
+	}
+
+	addBlankNode(id)
+	{
+		if (!this.#blankNodes[id]) {
+			this.#blankNodes[id] = new BlankNode(this)
+		}
+		return this.#blankNodes[id]
+	}
+
+	addCollection(id)
+	{
+		if (!this.#blankNodes[id]) {
+			this.#blankNodes[id] = new Collection(this)
+		}
+		return this.#blankNodes[id]
+	}
+
+	write()
+	{
+		return this.context.writer(this)
+	}
+
+	get(shortID)
+	{
+		return this.subjects[this.fullURI(shortID)]
+	}
+
+	set(subject, predicate, value)
+	{
+		const node = this.ensureSubject(subject)
+		const property = this.context.propertyName(predicate)
+
+		if (property == 'a') {
+			node.a = this.normalizeTypeValues(value)
+		} else {
+			node[property] = this.normalizeValues(value)
+		}
+		return node
+	}
+
+	add(subject, predicate, value)
+	{
+		const node = this.ensureSubject(subject)
+		const property = this.context.propertyName(predicate)
+		const newValue = property == 'a'
+			? this.normalizeTypeValues(value)
+			: this.normalizeValues(value)
+
+		node[property] = mergeValue(node[property], newValue)
+		return node
+	}
+
+	delete(subject, predicate=null, value=undefined)
+	{
+		const node = this.findSubject(subject)
+		if (!node) {
+			return false
+		}
+
+		if (!predicate) {
+			if (node.id) {
+				delete this.subjects[node.id]
+				if (this.primary === node) {
+					this.primary = null
+				}
+			}
+			return true
+		}
+
+		const property = this.context.propertyName(predicate)
+		if (!(property in node)) {
+			return false
+		}
+
+		if (arguments.length < 3) {
+			delete node[property]
+			return true
+		}
+
+		const deleteValues = property == 'a'
+			? values(this.normalizeTypeValues(value))
+			: values(this.normalizeValues(value))
+		const remaining = values(node[property])
+			.filter(item => !deleteValues.some(deleteValue => sameValue(item, deleteValue)))
+
+		if (remaining.length == values(node[property]).length) {
+			return false
+		}
+		if (remaining.length == 0) {
+			delete node[property]
+		} else if (remaining.length == 1) {
+			node[property] = remaining[0]
+		} else {
+			node[property] = remaining
+		}
+		return true
+	}
+
+	ensureSubject(subject)
+	{
+		if (subject instanceof BlankNode && !(subject instanceof NamedNode)) {
+			if (subject.graph !== this) {
+				throw new Error('Cannot write a blank node into a different graph')
+			}
+			return subject
+		}
+
+		if (subject instanceof NamedNode) {
+			return this.addNamedNode(subject.id)
+		}
+
+		return this.addNamedNode(this.fullURI(subject))
+	}
+
+	findSubject(subject)
+	{
+		if (subject instanceof BlankNode && !(subject instanceof NamedNode)) {
+			return subject.graph === this ? subject : null
+		}
+		const id = subject?.id ? subject.id : this.fullURI(subject)
+		return this.subjects[id]
+	}
+
+	normalizeValues(value)
+	{
+		if (Array.isArray(value) && !(value instanceof Collection)) {
+			return value.map(item => this.normalizeValue(item))
+		}
+		return this.normalizeValue(value)
+	}
+
+	normalizeValue(value)
+	{
+		if (value instanceof Collection) {
+			const collection = new Collection(this)
+			for (const item of value) {
+				collection.push(this.normalizeValue(item))
+			}
+			return collection
+		}
+		if (value instanceof NamedNode) {
+			return this.addNamedNode(value.id)
+		}
+		if (value instanceof BlankNode) {
+			if (value.graph !== this) {
+				throw new Error('Cannot write a blank node into a different graph')
+			}
+			return value
+		}
+		if (this.looksLikeURI(value)) {
+			return this.addNamedNode(this.fullURI(value))
+		}
+		return value
+	}
+
+	normalizeTypeValues(value)
+	{
+		if (Array.isArray(value) && !(value instanceof Collection)) {
+			return value.map(item => this.normalizeTypeValue(item))
+		}
+		return this.normalizeTypeValue(value)
+	}
+
+	normalizeTypeValue(value)
+	{
+		if (value instanceof NamedNode) {
+			return this.shortURI(value.id)
+		}
+		return this.shortURI(this.fullURI(value))
+	}
+
+	looksLikeURI(value)
+	{
+		if (typeof value != 'string') {
+			return false
+		}
+		if (/^[a-z][a-z0-9+.-]*:/i.test(value)) {
+			return true
+		}
+		const [prefix, path] = value.split(this.context.separator)
+		return Boolean(path && this.context.prefixes[prefix])
+	}
+
+	fullURI(shortURI, separator=null)
+	{
+		if (!separator) {
+			separator = this.context.separator
+		}
+		const [prefix, path] = shortURI.split(separator)
+		if (path) {
+			if (this.context.prefixes[prefix]) {
+				return this.context.prefixes[prefix]+path
+			}
+			if (this.prefixes[prefix]) {
+				return this.prefixes[prefix]+path
+			}
+		}
+		return shortURI
+	}
+
+	shortURI(fullURI, separator=null)
+	{
+		if (!separator) {
+			separator = this.context.separator
+		}
+		for (const prefix of this.context.prefixOrder) {
+			if (fullURI.startsWith(this.context.prefixes[prefix])) {
+				return prefix + separator + fullURI.substring(this.context.prefixes[prefix].length)
+			}
+		}
+		if (this.url && fullURI.startsWith(this.url)) {
+			return fullURI.substring(this.url.length)
+		}
+		return fullURI
+	}
+
+	/**
+	 * This sets the type of a literal, usually one of the xsd types
+	 */
+	setType(literal, type)
+	{
+		const shortType = this.shortURI(type)
+		return this.context.setType(literal, shortType)
+	}
+
+	/**
+	 * This returns the type of a literal, or null
+	 */
+	getType(literal)
+	{
+		return this.context.getType(literal)
+	}
+
+	setLanguage(literal, language)
+	{
+		if (typeof literal == 'string') {
+			literal = new String(literal)
+		} else if (typeof literal == 'number') {
+			literal = new Number(literal)
+		}
+		if (typeof literal !== 'object') {
+			throw new Error('cannot set language on ',literal)
+		}
+		literal.language = language
+		return literal
+	}
+
+	getValue(object)
+	{
+		let result
+		if (object.termType=='Literal') {
+			result = object.value
+			let datatype = object.datatype?.id
+			if (datatype) {
+				result = this.setType(result, datatype)
+			}
+			let language = object.language
+			if (language) {
+				result = this.setLanguage(result, language)
+			}
+		} else if (object.termType=='BlankNode') {
+			result = this.addBlankNode(object.id)
+		} else {
+			result = this.addNamedNode(object.id)
+		}
+		return result
+	}
+
+
+}
+
+export class BlankNode
+{
+
+	constructor(graph)
+	{
+		Object.defineProperty(this, 'graph', {
+			value: graph,
+			writable: false,
+			enumerable: false
+		})
+	}
+
+	addPredicate(predicate, object)
+	{
+		if (predicate.id) {
+			predicate = predicate.id
+		}
+		if (predicate==rdfType) {
+			let type = this.graph.shortURI(object.id)
+			this.addType(type)
+		} else {
+			const value = this.graph.getValue(object)
+			predicate = this.graph.shortURI(predicate)
+			if (!this[predicate]) {
+				this[predicate] = value
+			} else if (Array.isArray(this[predicate])) {
+				this[predicate].push(value)
+			} else {
+				this[predicate] = [ this[predicate], value]
+			}
+		}
+	}
+
+	/**
+	 * Adds a rdfType value, stored in this.a
+	 * Subjects can have more than one type (or class), unlike literals
+	 * The type value can be any URI, xsdTypes are unexpected here
+	 */
+	addType(type)
+	{
+		if (!this.a) {
+			this.a = type
+		} else {
+			if (!Array.isArray(this.a)) {
+				this.a = [ this.a ]
+			}
+			this.a.push(type)
+		}
+	}
+}
+
+export class NamedNode extends BlankNode
+{
+	constructor(id, graph)
+	{
+		super(graph)
+		Object.defineProperty(this, 'id', {
+			value: id,
+			writable: false,
+			enumerable: true
+		})
+	}
+}
+
+export class Collection extends Array
+{
+	constructor(graph)
+	{
+		super()
+		Object.defineProperty(this, 'graph', {
+			value: graph,
+			writable: false,
+			enumerable: false
+		})
+	}
+}