rdfjs-resource 2.0.7 → 3.0.0

package/README.md

@@ -17,7 +17,7 @@ npm i rdfjs-resource
 ### Wrap an RDF/JS `BlankNode` or `NamedNode` in a `Resource`
 
 ```
-const resource = new Resource({ dataset: theDataset, identifier: theNode });
+const resource = new Resource(dataset, identifier);
 ```
 
 ### Retrieve a value (object) of the `Resource`
@@ -32,34 +32,11 @@ const value = resource.value(rdf.type).toNumber().orDefault(0);
 
 See the `Resource.test.ts` for additional usage.
 
-### `MutableResource`
-
-`Resource` instances are immutable. To create a mutable resource, you have to supply an [RDF/JS DataFactory](https://rdf.js.org/data-model-spec/) as well as a graph identifier (`BlankNode | DefaultGraph | NamedNode`) to add/delete quads to/from in the supplied `DatasetCore`.
-
-```
-import { rdf } from "@tpluscode/rdf-ns-builders";
-
-const mutableResource = new MutableResource({
-  dataFactory: DataFactory,
-  dataset,
-  identifier: DataFactory.namedNode("http://example.com/subject"),
-  mutateGraph: DataFactory.defaultGraph(),
-});
-
-mutableResource.add(rdf.type, rdf.Resource);
-```
-
 ### `ResourceSet`
 
 For convenience, you can wrap a `DatasetCore` in a `ResourceSet`, then instantiate `Resource`s from that:
 
 ```
-const resourceSet = new ResourceSet({ dataset });
+const resourceSet = new ResourceSet(dataset);
 resourceSet.resource(identifier).value(rdf.type);
 ```
-
-### Named `Resource`
-
-`Resource` and `MutableResource` take a type parameter for the `identifier` specified in the resource's constructor. The parameter defaults to `BlankNode | NamedNode`.
-
-It's often useful to only deal in named resources (`Resource<NamedNode>`). The `ResourceSet` abstraction provides a `namedResource` factory method for convenience. `MutableResourceSet` provides a similar `namedMutableResource` factory method.

package/dist/DatasetValues.d.ts

@@ -1,18 +1,24 @@
-import type { DataFactory, NamedNode, Quad_Graph, Variable } from "@rdfjs/types";
+import type { DataFactory, Quad_Graph, Variable } from "@rdfjs/types";
+import type { PropertyPath } from "./PropertyPath.js";
 import type { Resource } from "./Resource.js";
+import type { Term } from "./Term.js";
+import { Value } from "./Value.js";
 import { Values } from "./Values.js";
-export declare abstract class DatasetValues<ValueT> extends Values<ValueT> {
-    protected readonly dataFactory: DataFactory;
-    protected readonly graph: Exclude<Quad_Graph, Variable> | null;
-    protected readonly unique: boolean;
-    constructor({ dataFactory, focusResource, graph, predicate, unique, }: {
+export declare class DatasetValues extends Values<Value> {
+    private readonly dataFactory;
+    private readonly graph;
+    private readonly unique;
+    constructor({ dataFactory, focusResource, graph, propertyPath, unique, }: {
         dataFactory: DataFactory;
         focusResource: Resource;
         graph: Exclude<Quad_Graph, Variable> | null;
-        predicate: NamedNode;
+        propertyPath: PropertyPath;
         unique: boolean;
     });
     get length(): number;
-    toArray(): readonly ValueT[];
+    private get dataset();
+    [Symbol.iterator](): Iterator<Value<Term>>;
+    toArray(): readonly Value<Term>[];
+    private terms;
 }
 //# sourceMappingURL=DatasetValues.d.ts.map

package/dist/DatasetValues.js

@@ -1,7 +1,9 @@
+import TermSet from "@rdfjs/term-set";
+import { Value } from "./Value.js";
 import { Values } from "./Values.js";
 export class DatasetValues extends Values {
-    constructor({ dataFactory, focusResource, graph, predicate, unique, }) {
-        super({ focusResource, predicate });
+    constructor({ dataFactory, focusResource, graph, propertyPath, unique, }) {
+        super({ focusResource, propertyPath });
         this.dataFactory = dataFactory;
         this.graph = graph;
         this.unique = unique;
@@ -13,8 +15,160 @@ export class DatasetValues extends Values {
         }
         return length;
     }
+    get dataset() {
+        return this.focusResource.dataset;
+    }
+    *[Symbol.iterator]() {
+        if (this.unique) {
+            const uniqueTerms = new TermSet();
+            for (const term of this.terms({
+                focusIdentifier: this.focusResource.identifier,
+                propertyPath: this.propertyPath,
+            })) {
+                if (uniqueTerms.has(term)) {
+                    continue;
+                }
+                yield new Value({
+                    dataFactory: this.dataFactory,
+                    focusResource: this.focusResource,
+                    propertyPath: this.propertyPath,
+                    term,
+                });
+                uniqueTerms.add(term);
+            }
+        }
+        else {
+            for (const term of this.terms({
+                focusIdentifier: this.focusResource.identifier,
+                propertyPath: this.propertyPath,
+            })) {
+                yield new Value({
+                    dataFactory: this.dataFactory,
+                    focusResource: this.focusResource,
+                    propertyPath: this.propertyPath,
+                    term,
+                });
+            }
+        }
+    }
     toArray() {
         return [...this];
     }
+    *terms({ inverse = false, focusIdentifier, propertyPath, }) {
+        switch (propertyPath.termType) {
+            case "AlternativePath": {
+                for (const member of propertyPath.members) {
+                    yield* this.terms({ inverse, focusIdentifier, propertyPath: member });
+                }
+                break;
+            }
+            case "InversePath": {
+                yield* this.terms({
+                    inverse: !inverse,
+                    focusIdentifier,
+                    propertyPath: propertyPath.path,
+                });
+                break;
+            }
+            case "NamedNode": {
+                const [subject, object] = inverse
+                    ? [null, focusIdentifier]
+                    : [focusIdentifier, null];
+                for (const quad of this.dataset.match(subject, propertyPath, object, this.graph)) {
+                    const term = inverse ? quad.subject : quad.object;
+                    switch (term.termType) {
+                        case "BlankNode":
+                        case "Literal":
+                        case "NamedNode":
+                            yield term;
+                            break;
+                        default:
+                            throw new Error(`unexpected termType ${term.termType}`);
+                    }
+                }
+                break;
+            }
+            case "OneOrMorePath": {
+                const visited = new TermSet();
+                const queue = [focusIdentifier];
+                while (queue.length > 0) {
+                    // biome-ignore lint/style/noNonNullAssertion: .length > 0
+                    const node = queue.shift();
+                    if (visited.has(node))
+                        continue;
+                    visited.add(node);
+                    for (const next of this.terms({
+                        inverse,
+                        focusIdentifier: node,
+                        propertyPath: propertyPath.path,
+                    })) {
+                        if (next.termType === "NamedNode" ||
+                            next.termType === "BlankNode") {
+                            queue.push(next);
+                        }
+                        yield next;
+                    }
+                }
+                break;
+            }
+            case "SequencePath": {
+                const members = inverse
+                    ? [...propertyPath.members].reverse()
+                    : propertyPath.members;
+                let reached = new TermSet([focusIdentifier]);
+                for (const member of members) {
+                    const nextReached = new TermSet();
+                    for (const node of reached) {
+                        if (node.termType === "NamedNode" ||
+                            node.termType === "BlankNode") {
+                            for (const next of this.terms({
+                                inverse,
+                                focusIdentifier: node,
+                                propertyPath: member,
+                            })) {
+                                nextReached.add(next);
+                            }
+                        }
+                    }
+                    reached = nextReached;
+                }
+                yield* reached;
+                break;
+            }
+            case "ZeroOrMorePath": {
+                yield focusIdentifier;
+                const visited = new TermSet();
+                const queue = [focusIdentifier];
+                while (queue.length > 0) {
+                    // biome-ignore lint/style/noNonNullAssertion: .length > 0
+                    const node = queue.shift();
+                    if (visited.has(node))
+                        continue;
+                    visited.add(node);
+                    for (const next of this.terms({
+                        inverse,
+                        focusIdentifier: node,
+                        propertyPath: propertyPath.path,
+                    })) {
+                        if (next.termType === "NamedNode" ||
+                            next.termType === "BlankNode") {
+                            queue.push(next);
+                        }
+                        yield next;
+                    }
+                }
+                break;
+            }
+            case "ZeroOrOnePath": {
+                yield focusIdentifier;
+                yield* this.terms({
+                    inverse,
+                    focusIdentifier,
+                    propertyPath: propertyPath.path,
+                });
+                break;
+            }
+        }
+    }
 }
 //# sourceMappingURL=DatasetValues.js.map

package/dist/MissingValueError.d.ts

@@ -1,10 +1,10 @@
-import type { NamedNode } from "@rdfjs/types";
+import { PropertyPath } from "./PropertyPath.js";
 import type { Resource } from "./Resource.js";
 import { ValueError } from "./ValueError.js";
 export declare class MissingValueError extends ValueError {
-    constructor({ focusResource, predicate, }: {
+    constructor({ focusResource, propertyPath, }: {
         focusResource: Resource;
-        predicate: NamedNode;
+        propertyPath: PropertyPath;
     });
 }
 //# sourceMappingURL=MissingValueError.d.ts.map

package/dist/MissingValueError.js

@@ -1,11 +1,12 @@
 import { Identifier } from "./Identifier.js";
+import { PropertyPath } from "./PropertyPath.js";
 import { ValueError } from "./ValueError.js";
 export class MissingValueError extends ValueError {
-    constructor({ focusResource, predicate, }) {
+    constructor({ focusResource, propertyPath, }) {
         super({
             focusResource,
-            message: `${Identifier.toString(focusResource.identifier)} missing ${predicate.value}`,
-            predicate,
+            message: `${Identifier.toString(focusResource.identifier)} missing ${PropertyPath.$toString(propertyPath)}`,
+            propertyPath,
         });
     }
 }

package/dist/MistypedPrimitiveValueError.d.ts

@@ -0,0 +1,13 @@
+import { MistypedValueError } from "./MistypedValueError.js";
+import type { Primitive } from "./Primitive.js";
+import { PropertyPath } from "./PropertyPath.js";
+import type { Resource } from "./Resource.js";
+export declare class MistypedPrimitiveValueError extends MistypedValueError<Primitive> {
+    constructor({ actualValue, expectedValueType, focusResource, propertyPath, }: {
+        actualValue: Primitive;
+        expectedValueType: string;
+        focusResource: Resource;
+        propertyPath: PropertyPath;
+    });
+}
+//# sourceMappingURL=MistypedPrimitiveValueError.d.ts.map

package/dist/MistypedPrimitiveValueError.js

@@ -0,0 +1,15 @@
+import { Identifier } from "./Identifier.js";
+import { MistypedValueError } from "./MistypedValueError.js";
+import { PropertyPath } from "./PropertyPath.js";
+export class MistypedPrimitiveValueError extends MistypedValueError {
+    constructor({ actualValue, expectedValueType, focusResource, propertyPath, }) {
+        super({
+            actualValue,
+            expectedValueType,
+            focusResource,
+            message: `expected ${Identifier.toString(focusResource.identifier)} ${PropertyPath.$toString(propertyPath)} to be a ${expectedValueType}, was ${typeof actualValue}`,
+            propertyPath,
+        });
+    }
+}
+//# sourceMappingURL=MistypedPrimitiveValueError.js.map

package/dist/MistypedTermValueError.d.ts

@@ -1,14 +1,13 @@
 import type { BlankNode, Literal, NamedNode, Quad, Variable } from "@rdfjs/types";
+import { MistypedValueError } from "./MistypedValueError.js";
+import { PropertyPath } from "./PropertyPath.js";
 import type { Resource } from "./Resource.js";
-import { ValueError } from "./ValueError.js";
-export declare class MistypedTermValueError extends ValueError {
-    readonly actualValue: BlankNode | Literal | NamedNode | Quad | Variable;
-    readonly expectedValueType: string;
-    constructor({ actualValue, expectedValueType, focusResource, predicate, }: {
+export declare class MistypedTermValueError extends MistypedValueError<BlankNode | Literal | NamedNode | Quad | Variable> {
+    constructor({ actualValue, expectedValueType, focusResource, propertyPath, }: {
         actualValue: BlankNode | Literal | NamedNode | Quad | Variable;
         expectedValueType: string;
         focusResource: Resource;
-        predicate: NamedNode;
+        propertyPath: PropertyPath;
     });
 }
 //# sourceMappingURL=MistypedTermValueError.d.ts.map

package/dist/MistypedTermValueError.js

@@ -1,14 +1,15 @@
 import { Identifier } from "./Identifier.js";
-import { ValueError } from "./ValueError.js";
-export class MistypedTermValueError extends ValueError {
-    constructor({ actualValue, expectedValueType, focusResource, predicate, }) {
+import { MistypedValueError } from "./MistypedValueError.js";
+import { PropertyPath } from "./PropertyPath.js";
+export class MistypedTermValueError extends MistypedValueError {
+    constructor({ actualValue, expectedValueType, focusResource, propertyPath, }) {
         super({
+            actualValue,
+            expectedValueType,
             focusResource,
-            message: `expected ${Identifier.toString(focusResource.identifier)} ${predicate.value} to be a ${expectedValueType}, was ${actualValue.termType}`,
-            predicate,
+            message: `expected ${Identifier.toString(focusResource.identifier)} ${PropertyPath.$toString(propertyPath)} to be a ${expectedValueType}, was ${actualValue.termType}`,
+            propertyPath,
         });
-        this.actualValue = actualValue;
-        this.expectedValueType = expectedValueType;
     }
 }
 //# sourceMappingURL=MistypedTermValueError.js.map

package/dist/MistypedValueError.d.ts

@@ -0,0 +1,15 @@
+import type { PropertyPath } from "./PropertyPath.js";
+import type { Resource } from "./Resource.js";
+import { ValueError } from "./ValueError.js";
+export declare abstract class MistypedValueError<T> extends ValueError {
+    readonly actualValue: T;
+    readonly expectedValueType: string;
+    constructor({ actualValue, expectedValueType, focusResource, message, propertyPath, }: {
+        actualValue: T;
+        expectedValueType: string;
+        message: string;
+        focusResource: Resource;
+        propertyPath: PropertyPath;
+    });
+}
+//# sourceMappingURL=MistypedValueError.d.ts.map

package/dist/MistypedValueError.js

@@ -0,0 +1,13 @@
+import { ValueError } from "./ValueError.js";
+export class MistypedValueError extends ValueError {
+    constructor({ actualValue, expectedValueType, focusResource, message, propertyPath, }) {
+        super({
+            focusResource,
+            message,
+            propertyPath,
+        });
+        this.actualValue = actualValue;
+        this.expectedValueType = expectedValueType;
+    }
+}
+//# sourceMappingURL=MistypedValueError.js.map

package/dist/PropertyPath.d.ts

@@ -0,0 +1,47 @@
+import type { NamedNode, Quad_Graph, Variable } from "@rdfjs/types";
+import { Either } from "purify-ts";
+import { Resource } from "./Resource.js";
+import { ResourceSet } from "./ResourceSet.js";
+interface AlternativePath {
+    readonly termType: "AlternativePath";
+    readonly members: readonly PropertyPath[];
+}
+interface InversePath {
+    readonly termType: "InversePath";
+    readonly path: PropertyPath;
+}
+interface OneOrMorePath {
+    readonly termType: "OneOrMorePath";
+    readonly path: PropertyPath;
+}
+type PredicatePath = NamedNode;
+interface SequencePath {
+    readonly termType: "SequencePath";
+    readonly members: readonly PropertyPath[];
+}
+interface ZeroOrMorePath {
+    readonly termType: "ZeroOrMorePath";
+    readonly path: PropertyPath;
+}
+interface ZeroOrOnePath {
+    readonly termType: "ZeroOrOnePath";
+    readonly path: PropertyPath;
+}
+/**
+ * A SHACL property path.
+ */
+export type PropertyPath = AlternativePath | InversePath | OneOrMorePath | PredicatePath | SequencePath | ZeroOrMorePath | ZeroOrOnePath;
+export declare namespace PropertyPath {
+    function $fromRdf(resource: Resource, options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
+    }): Either<Error, PropertyPath>;
+    type $Filter = object;
+    function $filter(_filter: $Filter, _value: PropertyPath): boolean;
+    function $toString(propertyPath: PropertyPath): string;
+    function $toRdf(propertyPath: PropertyPath, options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
+        resourceSet?: ResourceSet;
+    }): Resource;
+}
+export {};
+//# sourceMappingURL=PropertyPath.d.ts.map

package/dist/PropertyPath.js

@@ -0,0 +1,153 @@
+import dataFactory from "@rdfjs/data-model";
+import datasetFactory from "@rdfjs/dataset";
+import { Either, Left } from "purify-ts";
+import { Resource } from "./Resource.js";
+import { ResourceSet } from "./ResourceSet.js";
+import { sh } from "./vocabularies.js";
+export var PropertyPath;
+(function (PropertyPath) {
+    function $fromRdf(resource, options) {
+        // Predicate path
+        // sh:path ex:parent
+        if (resource.identifier.termType === "NamedNode") {
+            return Either.of(resource.identifier);
+        }
+        // The other property path types are BlankNodes
+        const getPropertyPathList = (list) => {
+            return list.chain((values) => {
+                const members = [];
+                for (const value of values) {
+                    const resource = value.toResource().toMaybe();
+                    if (resource.isNothing()) {
+                        return Left(new Error("non-identifier in property path list"));
+                    }
+                    const member = PropertyPath.$fromRdf(resource.unsafeCoerce());
+                    if (member.isLeft()) {
+                        return member;
+                    }
+                    members.push(member.unsafeCoerce());
+                }
+                return Either.of(members);
+            });
+        };
+        // Sequence path
+        // sh:path ( ex:parent ex:firstName )
+        {
+            const list = resource.toList();
+            if (list.isRight()) {
+                return getPropertyPathList(list).map((members) => ({
+                    termType: "SequencePath",
+                    members,
+                }));
+            }
+        }
+        for (const quad of resource.dataset.match(resource.identifier, null, null, options?.graph)) {
+            switch (quad.object.termType) {
+                case "BlankNode":
+                case "NamedNode":
+                    break;
+                default:
+                    return Left(new Error(`non-BlankNode/NamedNode property path object on path ${Resource.Identifier.toString(resource.identifier)}: ${quad.object.termType} ${quad.object.value}`));
+            }
+            const objectResource = new Resource(resource.dataset, quad.object);
+            // Alternative path
+            // sh:path: [ sh:alternativePath ( ex:father ex:mother  ) ]
+            if (quad.predicate.equals(sh.alternativePath)) {
+                return getPropertyPathList(objectResource.toList()).map((members) => ({
+                    termType: "AlternativePath",
+                    members,
+                }));
+            }
+            // Inverse path
+            // sh:path: [ sh:inversePath ex:parent ]
+            if (quad.predicate.equals(sh.inversePath)) {
+                return PropertyPath.$fromRdf(objectResource).map((path) => ({
+                    termType: "InversePath",
+                    path,
+                }));
+            }
+            // One or more path
+            if (quad.predicate.equals(sh.oneOrMorePath)) {
+                return PropertyPath.$fromRdf(objectResource).map((path) => ({
+                    termType: "OneOrMorePath",
+                    path,
+                }));
+            }
+            // Zero or more path
+            if (quad.predicate.equals(sh.zeroOrMorePath)) {
+                return PropertyPath.$fromRdf(objectResource).map((path) => ({
+                    termType: "ZeroOrMorePath",
+                    path,
+                }));
+            }
+            if (quad.predicate.equals(sh.zeroOrOnePath)) {
+                return PropertyPath.$fromRdf(objectResource).map((path) => ({
+                    termType: "ZeroOrOnePath",
+                    path,
+                }));
+            }
+        }
+        return Left(new Error(`unrecognized or ill-formed SHACL property path ${Resource.Identifier.toString(resource.identifier)}`));
+    }
+    PropertyPath.$fromRdf = $fromRdf;
+    function $filter(_filter, _value) {
+        return true;
+    }
+    PropertyPath.$filter = $filter;
+    function $toString(propertyPath) {
+        switch (propertyPath.termType) {
+            case "AlternativePath":
+            case "SequencePath":
+                return `${propertyPath.termType}([${propertyPath.members.map(PropertyPath.toString).join(", ")}])`;
+            case "InversePath":
+            case "OneOrMorePath":
+            case "ZeroOrMorePath":
+            case "ZeroOrOnePath":
+                return `${propertyPath.termType}(${PropertyPath.$toString(propertyPath.path)})`;
+            case "NamedNode":
+                return `PredicatePath(${propertyPath.value})`;
+        }
+    }
+    PropertyPath.$toString = $toString;
+    function $toRdf(propertyPath, options) {
+        const graph = options?.graph;
+        const resourceSet = options?.resourceSet ??
+            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+        if (propertyPath.termType === "NamedNode") {
+            return resourceSet.resource(propertyPath);
+        }
+        const resource = resourceSet.resource(dataFactory.blankNode());
+        switch (propertyPath.termType) {
+            case "AlternativePath":
+            case "SequencePath": {
+                const members = propertyPath.members.map((member) => PropertyPath.$toRdf(member, { graph, resourceSet }).identifier);
+                if (propertyPath.termType === "AlternativePath") {
+                    resource.addList(sh.alternativePath, members, { graph });
+                }
+                else {
+                    resource.addListItems(members, { graph });
+                }
+                return resource;
+            }
+        }
+        let predicate;
+        switch (propertyPath.termType) {
+            case "InversePath":
+                predicate = sh.inversePath;
+                break;
+            case "OneOrMorePath":
+                predicate = sh.oneOrMorePath;
+                break;
+            case "ZeroOrMorePath":
+                predicate = sh.zeroOrMorePath;
+                break;
+            case "ZeroOrOnePath":
+                predicate = sh.zeroOrOnePath;
+                break;
+        }
+        resource.add(predicate, PropertyPath.$toRdf(propertyPath.path, { graph, resourceSet }).identifier, graph);
+        return resource;
+    }
+    PropertyPath.$toRdf = $toRdf;
+})(PropertyPath || (PropertyPath = {}));
+//# sourceMappingURL=PropertyPath.js.map