@shaclmate/shacl-ast 3.0.4 → 4.0.0

package/dist/ShapesGraph.js

@@ -1,2 +1,312 @@
-export {};
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import TermMap from "@rdfjs/term-map";
+import TermSet from "@rdfjs/term-set";
+import { owl, sh } from "@tpluscode/rdf-ns-builders";
+import { Either, Left } from "purify-ts";
+import { Resource, ResourceSet } from "rdfjs-resource";
+import { Memoize } from "typescript-memoize";
+import * as generated from "./generated.js";
+import { NodeShape } from "./NodeShape.js";
+import { Ontology } from "./Ontology.js";
+import { PropertyGroup } from "./PropertyGroup.js";
+import { PropertyShape } from "./PropertyShape.js";
+export class ShapesGraph {
+    nodeShapesByIdentifier;
+    ontologiesByIdentifier;
+    propertyGroupsByIdentifier;
+    propertyShapesByIdentifier;
+    constructor(parameters) {
+        this.nodeShapesByIdentifier = parameters.nodeShapesByIdentifier;
+        this.ontologiesByIdentifier = parameters.ontologiesByIdentifier;
+        this.propertyGroupsByIdentifier = parameters.propertyGroupsByIdentifier;
+        this.propertyShapesByIdentifier = parameters.propertyShapesByIdentifier;
+    }
+    get nodeShapes() {
+        return [...this.nodeShapesByIdentifier.values()];
+    }
+    nodeShapeByIdentifier(identifier) {
+        const nodeShape = this.nodeShapesByIdentifier.get(identifier);
+        return nodeShape
+            ? Either.of(nodeShape)
+            : Left(new Error(`no such node shape ${Resource.Identifier.toString(identifier)}`));
+    }
+    get ontologies() {
+        return [...this.ontologiesByIdentifier.values()];
+    }
+    ontologyByIdentifier(identifier) {
+        const ontology = this.ontologiesByIdentifier.get(identifier);
+        return ontology
+            ? Either.of(ontology)
+            : Left(new Error(`no such ontology ${Resource.Identifier.toString(identifier)}`));
+    }
+    propertyGroupByIdentifier(identifier) {
+        const propertyGroup = this.propertyGroupsByIdentifier.get(identifier);
+        return propertyGroup
+            ? Either.of(propertyGroup)
+            : Left(new Error(`no such property group ${Resource.Identifier.toString(identifier)}`));
+    }
+    get propertyGroups() {
+        return [...this.propertyGroupsByIdentifier.values()];
+    }
+    propertyShapeByIdentifier(identifier) {
+        const propertyShape = this.propertyShapesByIdentifier.get(identifier);
+        return propertyShape
+            ? Either.of(propertyShape)
+            : Left(new Error(`no such property shape ${Resource.Identifier.toString(identifier)}`));
+    }
+    get propertyShapes() {
+        return [...this.propertyShapesByIdentifier.values()];
+    }
+    shapeByIdentifier(identifier) {
+        return this.nodeShapeByIdentifier(identifier).alt(this.propertyShapeByIdentifier(identifier));
+    }
+}
+__decorate([
+    Memoize()
+], ShapesGraph.prototype, "nodeShapes", null);
+__decorate([
+    Memoize()
+], ShapesGraph.prototype, "ontologies", null);
+__decorate([
+    Memoize()
+], ShapesGraph.prototype, "propertyGroups", null);
+__decorate([
+    Memoize()
+], ShapesGraph.prototype, "propertyShapes", null);
+(function (ShapesGraph) {
+    class Factory {
+        preferredLanguages;
+        constructor(parameters) {
+            this.preferredLanguages = parameters?.preferredLanguages ?? ["en", ""];
+        }
+        createShapesGraph({ dataset, ignoreUndefinedShapes, }) {
+            function datasetHasMatch(subject, predicate, object, graph) {
+                for (const _ of dataset.match(subject, predicate, object, graph)) {
+                    return true;
+                }
+                return false;
+            }
+            const resourceSet = new ResourceSet(dataset);
+            const nodeShapesByIdentifier = new TermMap();
+            const ontologiesByIdentifier = new TermMap();
+            const propertyGroupsByIdentifier = new TermMap();
+            const propertyShapesByIdentifier = new TermMap();
+            // Have to instantiate ShapesGraph here so the shapes have references to it
+            // Pass in the mutable TermMap's and then mutate them
+            const shapesGraph = new ShapesGraph({
+                nodeShapesByIdentifier,
+                ontologiesByIdentifier,
+                propertyGroupsByIdentifier,
+                propertyShapesByIdentifier,
+            });
+            return Either.encase(() => {
+                function readGraph() {
+                    const graphs = new TermSet();
+                    for (const quad of dataset) {
+                        graphs.add(quad.graph);
+                    }
+                    if (graphs.size !== 1) {
+                        return undefined;
+                    }
+                    const graph = [...graphs.values()][0];
+                    switch (graph.termType) {
+                        case "BlankNode":
+                        case "DefaultGraph":
+                        case "NamedNode":
+                            return graph;
+                        default:
+                            throw new RangeError(`expected NamedNode or default graph, actual ${graph.termType}`);
+                    }
+                }
+                const graph = readGraph();
+                // Read ontologies
+                for (const ontologyResource of resourceSet.instancesOf(owl.Ontology, {
+                    graph,
+                })) {
+                    if (ontologiesByIdentifier.has(ontologyResource.identifier)) {
+                        continue;
+                    }
+                    this.createOntology({
+                        resource: ontologyResource,
+                        shapesGraph,
+                    }).ifRight((ontology) => ontologiesByIdentifier.set(ontologyResource.identifier, ontology));
+                }
+                // Read property groups
+                for (const propertyGroupResource of resourceSet.instancesOf(sh.PropertyGroup, { graph })) {
+                    if (propertyGroupResource.identifier.termType !== "NamedNode") {
+                        continue;
+                    }
+                    if (propertyGroupsByIdentifier.has(propertyGroupResource.identifier)) {
+                        continue;
+                    }
+                    this.createPropertyGroup({
+                        resource: propertyGroupResource,
+                        shapesGraph,
+                    }).ifRight((propertyGroup) => propertyGroupsByIdentifier.set(propertyGroupResource.identifier, propertyGroup));
+                }
+                // Read shapes
+                // Collect the shape identifiers in sets
+                const shapeNodeSet = new TermSet();
+                // Utility function for adding to the shapeNodeSet
+                function addShapeNode(shapeNode) {
+                    switch (shapeNode.termType) {
+                        case "BlankNode":
+                        case "NamedNode":
+                            shapeNodeSet.add(shapeNode);
+                            return true;
+                        default:
+                            throw new RangeError(`unexpected shape node identifier term type: ${shapeNode.termType}`);
+                    }
+                }
+                // Test each shape condition
+                // https://www.w3.org/TR/shacl/#shapes
+                // Subject is a SHACL instance of sh:NodeShape or sh:PropertyShape
+                for (const rdfType of [sh.NodeShape, sh.PropertyShape]) {
+                    for (const resource of resourceSet.instancesOf(rdfType, {
+                        graph,
+                    })) {
+                        addShapeNode(resource.identifier);
+                    }
+                }
+                // Subject of a triple with sh:targetClass, sh:targetNode, sh:targetObjectsOf, or sh:targetSubjectsOf predicate
+                for (const predicate of [
+                    sh.targetClass,
+                    sh.targetNode,
+                    sh.targetObjectsOf,
+                    sh.targetSubjectsOf,
+                ]) {
+                    for (const quad of dataset.match(null, predicate, null, graph)) {
+                        addShapeNode(quad.subject);
+                    }
+                }
+                // Subject of a triple that has a parameter as predicate
+                // https://www.w3.org/TR/shacl/#constraints
+                // https://www.w3.org/TR/shacl/#core-components
+                for (const predicate of [
+                    sh.class,
+                    sh.datatype,
+                    sh.nodeKind,
+                    sh.minCount,
+                    sh.maxCount,
+                    sh.minExclusive,
+                    sh.minInclusive,
+                    sh.maxExclusive,
+                    sh.maxInclusive,
+                    sh.minLength,
+                    sh.maxLength,
+                    sh.pattern,
+                    sh.languageIn,
+                    sh.uniqueLang,
+                    sh.equals,
+                    sh.disjoint,
+                    sh.lessThan,
+                    sh.lessThanOrEquals,
+                    sh.not,
+                    sh.and,
+                    sh.or,
+                    sh.xone,
+                    sh.node,
+                    sh.property,
+                    sh.qualifiedValueShape,
+                    sh.qualifiedMinCount,
+                    sh.qualifiedMaxCount,
+                    sh.closed,
+                    sh.ignoredProperties,
+                    sh.hasValue,
+                    sh.in,
+                ]) {
+                    for (const quad of dataset.match(null, predicate, null, graph)) {
+                        addShapeNode(quad.subject);
+                    }
+                }
+                // Object of a shape-expecting, non-list-taking parameter such as sh:node
+                for (const predicate of [sh.node, sh.not, sh.property]) {
+                    for (const quad of dataset.match(null, predicate, null, graph)) {
+                        addShapeNode(quad.object);
+                        if (!ignoreUndefinedShapes && !datasetHasMatch(quad.object)) {
+                            throw new Error(`undefined shape: ${Resource.Identifier.toString(quad.object)}`);
+                        }
+                    }
+                }
+                // Member of a SHACL list that is a value of a shape-expecting and list-taking parameter such as sh:or
+                for (const predicate of [sh.and, sh.or, sh.xone]) {
+                    for (const quad of dataset.match(null, predicate, null, graph)) {
+                        switch (quad.object.termType) {
+                            case "BlankNode":
+                            case "NamedNode":
+                                break;
+                            default:
+                                throw new RangeError(`expected list term to be a blank or named node, not ${quad.object.termType}`);
+                        }
+                        for (const value of resourceSet
+                            .resource(quad.object)
+                            .toList()
+                            .unsafeCoerce()) {
+                            const identifier = value.toIdentifier().unsafeCoerce();
+                            addShapeNode(identifier);
+                            if (!ignoreUndefinedShapes && !datasetHasMatch(identifier)) {
+                                throw new Error(`undefined shape: ${Resource.Identifier.toString(identifier)}`);
+                            }
+                        }
+                    }
+                }
+                // Separate shapes into node and property shapes.
+                for (const shapeNode of shapeNodeSet) {
+                    if (dataset.match(shapeNode, sh.path, null, graph).size > 0) {
+                        // A property shape is a shape in the shapes graph that is the subject of a triple that has sh:path as its predicate. A shape has at most one value for sh:path. Each value of sh:path in a shape must be a well-formed SHACL property path. It is recommended, but not required, for a property shape to be declared as a SHACL instance of sh:PropertyShape. SHACL instances of sh:PropertyShape have one value for the property sh:path.
+                        propertyShapesByIdentifier.set(shapeNode, this.createPropertyShape({
+                            resource: resourceSet.resource(shapeNode),
+                            shapesGraph,
+                        }).unsafeCoerce());
+                    }
+                    else {
+                        // A node shape is a shape in the shapes graph that is not the subject of a triple with sh:path as its predicate. It is recommended, but not required, for a node shape to be declared as a SHACL instance of sh:NodeShape. SHACL instances of sh:NodeShape cannot have a value for the property sh:path.
+                        nodeShapesByIdentifier.set(shapeNode, this.createNodeShape({
+                            resource: resourceSet.resource(shapeNode),
+                            shapesGraph,
+                        }).unsafeCoerce());
+                    }
+                }
+                return shapesGraph;
+            });
+        }
+    }
+    ShapesGraph.Factory = Factory;
+    class DefaultFactory extends Factory {
+        createNodeShape({ resource, shapesGraph, }) {
+            return generated.ShaclCoreNodeShape.$fromRdf(resource, {
+                ignoreRdfType: true,
+                preferredLanguages: this.preferredLanguages,
+            }).map((generatedShape) => new NodeShape(generatedShape, shapesGraph));
+        }
+        createOntology({ resource, }) {
+            return generated.OwlOntology.$fromRdf(resource, {
+                ignoreRdfType: true,
+                preferredLanguages: this.preferredLanguages,
+            }).map((generatedOntology) => new Ontology(generatedOntology));
+        }
+        createPropertyGroup({ resource, }) {
+            return generated.ShaclCorePropertyGroup.$fromRdf(resource, {
+                ignoreRdfType: true,
+                preferredLanguages: this.preferredLanguages,
+            }).map((propertyGroup) => new PropertyGroup(propertyGroup));
+        }
+        createPropertyShape({ resource, shapesGraph, }) {
+            return generated.ShaclCorePropertyShape.$fromRdf(resource, {
+                ignoreRdfType: true,
+                preferredLanguages: this.preferredLanguages,
+            }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));
+        }
+    }
+    const defaultFactory = new DefaultFactory();
+    function create(parameters) {
+        return defaultFactory.createShapesGraph(parameters);
+    }
+    ShapesGraph.create = create;
+})(ShapesGraph || (ShapesGraph = {}));
 //# sourceMappingURL=ShapesGraph.js.map