@shaclmate/cli 4.0.50 → 4.0.51

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/commands/generate.d.ts

@@ -0,0 +1,8 @@
+import type { Generator } from "@shaclmate/compiler";
+import { type Either } from "purify-ts";
+export declare function generate({ generator, inputPaths, outputFilePath, }: {
+    generator: Generator;
+    inputPaths: readonly string[];
+    outputFilePath: string;
+}): Promise<Either<Error, void>>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/commands/generate.js

@@ -0,0 +1,37 @@
+import * as fs from "node:fs";
+import Serializer from "@rdfjs/serializer-turtle";
+import { Compiler, ShapesGraph } from "@shaclmate/compiler";
+import { EitherAsync } from "purify-ts";
+import SHACLValidator from "rdf-validate-shacl";
+import { logger } from "../logger.js";
+import { parseInputs } from "../parseInputs.js";
+import { shaclShaclDataset } from "../shaclShaclDataset.js";
+export async function generate({ generator, inputPaths, outputFilePath, }) {
+    return EitherAsync(async ({ liftEither }) => {
+        if (inputPaths.length === 0) {
+            throw new Error("must specify at least one input shapes graph file path");
+        }
+        const { dataset, prefixMap } = await liftEither(await parseInputs(inputPaths));
+        {
+            const validationReport = await new SHACLValidator(shaclShaclDataset, {}).validate(dataset);
+            if (!validationReport.conforms) {
+                process.stderr.write("input is not valid SHACL:\n");
+                process.stderr.write(new Serializer({
+                    prefixes: prefixMap,
+                }).transform(validationReport.dataset));
+                return;
+            }
+        }
+        const output = await liftEither(ShapesGraph.builder()
+            .parseDataset(dataset, { prefixMap })
+            .map((_) => _.build())
+            .chain((shapesGraph) => new Compiler({ generator, logger }).compile(shapesGraph)));
+        if (outputFilePath.length === 0) {
+            process.stdout.write(output);
+        }
+        else {
+            await fs.promises.writeFile(outputFilePath, output);
+        }
+    });
+}
+//# sourceMappingURL=generate.js.map

package/dist/commands/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./generate.js";
+export * from "./merge.js";
+export * from "./validate.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.js

@@ -0,0 +1,4 @@
+export * from "./generate.js";
+export * from "./merge.js";
+export * from "./validate.js";
+//# sourceMappingURL=index.js.map

package/dist/commands/merge.d.ts

@@ -0,0 +1,6 @@
+import { type Either } from "purify-ts";
+export declare function merge({ inputPaths, outputFilePath, }: {
+    inputPaths: readonly string[];
+    outputFilePath: string;
+}): Promise<Either<Error, void>>;
+//# sourceMappingURL=merge.d.ts.map

package/dist/commands/merge.js

@@ -0,0 +1,17 @@
+import fs from "node:fs";
+import Serializer from "@rdfjs/serializer-turtle";
+import { EitherAsync } from "purify-ts";
+import { parseInputs } from "../parseInputs.js";
+export async function merge({ inputPaths, outputFilePath, }) {
+    return EitherAsync(async ({ liftEither }) => {
+        const { dataset, prefixMap } = await liftEither(await parseInputs(inputPaths));
+        const output = new Serializer({ prefixes: prefixMap }).transform(dataset);
+        if (outputFilePath.length === 0) {
+            process.stdout.write(output);
+        }
+        else {
+            await fs.promises.writeFile(outputFilePath, output);
+        }
+    });
+}
+//# sourceMappingURL=merge.js.map

package/dist/commands/validate.d.ts

@@ -0,0 +1,6 @@
+import { type Either } from "purify-ts";
+export declare function validate({ dataGraphPaths, shapesGraphPaths, }: {
+    dataGraphPaths: readonly string[];
+    shapesGraphPaths: readonly string[];
+}): Promise<Either<Error, void>>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/commands/validate.js

@@ -0,0 +1,94 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import Serializer from "@rdfjs/serializer-turtle";
+import { EitherAsync } from "purify-ts";
+import SHACLValidator from "rdf-validate-shacl";
+import * as tmp from "tmp-promise";
+import which from "which";
+import { logger } from "../logger.js";
+import { parseInputs } from "../parseInputs.js";
+function execFileStreaming(cmd, args) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, { stdio: "inherit" });
+        child.on("close", (code) => {
+            resolve(code);
+        });
+    });
+}
+export async function validate({ dataGraphPaths, shapesGraphPaths, }) {
+    return EitherAsync(async ({ liftEither }) => {
+        const { dataset: dataGraphDataset, prefixMap: dataGraphPrefixMap } = await liftEither(await parseInputs(dataGraphPaths));
+        if (dataGraphDataset.size === 0) {
+            throw new Error("data graph is empty!");
+        }
+        logger.info("data graph size: %d", dataGraphDataset.size);
+        const { dataset: shapesGraphDataset } = await liftEither(await parseInputs(shapesGraphPaths));
+        if (shapesGraphDataset.size === 0) {
+            throw new Error("shapes graph is empty!");
+        }
+        logger.info("shapes graph size: %d", shapesGraphDataset.size);
+        const serializer = new Serializer({
+            prefixes: dataGraphPrefixMap,
+        });
+        logger.info("validating with rdf-shacl-validate");
+        const validationReport = await new SHACLValidator(shapesGraphDataset, {}).validate(dataGraphDataset);
+        if (validationReport.conforms) {
+            logger.info("validated with rdf-shacl-validate: conforms");
+        }
+        else {
+            logger.info("validated with rdf-shacl-validate: does not conform");
+            process.stderr.write(serializer.transform(validationReport.dataset));
+            return;
+        }
+        const jenaShaclFilePath = await which("shacl", { nothrow: true });
+        const pyshaclFilePath = await which("pyshacl", { nothrow: true });
+        if (jenaShaclFilePath === null && pyshaclFilePath === null) {
+            logger.debug("neither Jena nor pyshacl found on PATH");
+            return;
+        }
+        await tmp.withDir(async ({ path: tmpDirectoryPath }) => {
+            const dataGraphFilePath = path.join(tmpDirectoryPath, "data.ttl");
+            logger.debug("writing data graph to %s", dataGraphFilePath);
+            await fs.writeFile(dataGraphFilePath, serializer.transform(dataGraphDataset));
+            logger.debug("wrote data graph to %s", dataGraphFilePath);
+            const shapesGraphFilePath = path.join(tmpDirectoryPath, "shapes.ttl");
+            logger.debug("writing shapes graph to %s", shapesGraphFilePath);
+            await fs.writeFile(shapesGraphFilePath, serializer.transform(shapesGraphDataset));
+            logger.debug("wrote shapes graph to %s", shapesGraphFilePath);
+            if (jenaShaclFilePath !== null) {
+                const args = [
+                    "validate",
+                    "--data",
+                    dataGraphFilePath,
+                    "--shapes",
+                    shapesGraphFilePath,
+                ];
+                logger.info("validating with Jena (args=%s)", args);
+                const code = await execFileStreaming(jenaShaclFilePath, args);
+                logger.info("validated with Jena: %s", code === 0 ? "conforms" : "does not conform");
+                if (code !== 0) {
+                    return;
+                }
+            }
+            else {
+                logger.info("Jena not found on PATH, skipping");
+            }
+            if (pyshaclFilePath !== null) {
+                const args = ["-s", shapesGraphFilePath, dataGraphFilePath];
+                logger.info("validating with pyshacl (args=%s)", args);
+                const code = await execFileStreaming(pyshaclFilePath, args);
+                logger.info("validated with pyshacl: %s", code === 0 ? "conforms" : "does not conform");
+                if (code !== 0) {
+                    return;
+                }
+            }
+            else {
+                logger.info("pyshacl not found on PATH, skipping");
+            }
+        }, {
+            unsafeCleanup: true,
+        });
+    });
+}
+//# sourceMappingURL=validate.js.map

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * as commands from "./commands/index.js";
+export * from "./logger.js";
+export * from "./parseInputs.js";
+export * from "./shaclShaclDataset.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,5 @@
+export * as commands from "./commands/index.js";
+export * from "./logger.js";
+export * from "./parseInputs.js";
+export * from "./shaclShaclDataset.js";
+//# sourceMappingURL=index.js.map

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const logger: import("pino").Logger<never>;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.js

@@ -0,0 +1,15 @@
+import { pino } from "pino";
+export const logger = pino({
+    level: process.env["NODE_ENV"] === "development" ||
+        process.env["NODE_ENV"] === "test"
+        ? "debug"
+        : "info",
+    transport: {
+        target: "pino-pretty",
+        options: {
+            destination: 2,
+            colorize: true,
+        },
+    },
+});
+//# sourceMappingURL=logger.js.map

package/dist/parseInputs.d.ts

@@ -0,0 +1,8 @@
+import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import type { DatasetCore } from "@rdfjs/types";
+import { Either } from "purify-ts";
+export declare function parseInputs(inputPaths: readonly string[]): Promise<Either<Error, {
+    dataset: DatasetCore;
+    prefixMap: PrefixMap;
+}>>;
+//# sourceMappingURL=parseInputs.d.ts.map

package/dist/parseInputs.js

@@ -0,0 +1,49 @@
+import datasetFactory from "@rdfjs/dataset";
+import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import dataFactory from "@rdfx/data-factory";
+import { RdfDirectory, RdfFileSystemEntry } from "@rdfx/fs";
+import { Either, EitherAsync, Left } from "purify-ts";
+import { logger } from "./logger.js";
+export async function parseInputs(inputPaths) {
+    return EitherAsync(async ({ liftEither }) => {
+        const dataset = datasetFactory.dataset();
+        const prefixMapInit = [];
+        for (const inputPath of inputPaths) {
+            const parseInputFileSystemEntry = async (inputFileSystemEntry) => {
+                if (inputFileSystemEntry instanceof RdfDirectory) {
+                    for await (const file of inputFileSystemEntry.files({
+                        recursive: true,
+                    })) {
+                        await parseInputFileSystemEntry(file);
+                    }
+                    return;
+                }
+                const inputFile = inputFileSystemEntry;
+                await liftEither(await new Promise((resolve) => {
+                    const inputQuadStream = inputFile.parse();
+                    inputQuadStream.on("data", (quad) => dataset.add(quad));
+                    inputQuadStream.on("end", () => resolve(Either.of(null)));
+                    inputQuadStream.on("error", (error) => resolve(Left(error)));
+                    inputQuadStream.on("prefix", (prefix, prefixNode) => {
+                        const existingPrefixMapEntry = prefixMapInit.find((prefixMapEntry) => prefixMapEntry[0] === prefix ||
+                            prefixMapEntry[1].equals(prefixNode));
+                        if (existingPrefixMapEntry) {
+                            if (existingPrefixMapEntry[0] !== prefix ||
+                                !existingPrefixMapEntry[1].equals(prefixNode)) {
+                                logger.warn("conflicting prefix %s: %s", prefix, prefixNode.value);
+                            }
+                            return;
+                        }
+                        prefixMapInit.push([prefix, prefixNode]);
+                    });
+                }));
+            };
+            await parseInputFileSystemEntry(await liftEither(await RdfFileSystemEntry.fromPath(inputPath)));
+        }
+        return {
+            dataset,
+            prefixMap: new PrefixMap(prefixMapInit, { factory: dataFactory }),
+        };
+    });
+}
+//# sourceMappingURL=parseInputs.js.map

package/dist/shaclShaclDataset.d.ts

@@ -0,0 +1,3 @@
+import type { DatasetCore } from "@rdfjs/types";
+export declare const shaclShaclDataset: DatasetCore;
+//# sourceMappingURL=shaclShaclDataset.d.ts.map

package/dist/shaclShaclDataset.js

@@ -0,0 +1,414 @@
+import { Parser, Store } from "n3";
+export const shaclShaclDataset = new Store(new Parser({ format: "text/turtle" }).parse(`
+# baseURI: http://www.w3.org/ns/shacl-shacl#
+
+# A SHACL shapes graph to validate SHACL shapes graphs
+# Draft last edited 2017-04-04
+
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix sh:   <http://www.w3.org/ns/shacl#> .
+@prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .
+
+@prefix shsh: <http://www.w3.org/ns/shacl-shacl#> .
+
+shsh:
+ rdfs:label "SHACL for SHACL"@en ;
+ rdfs:comment "This shapes graph can be used to validate SHACL shapes graphs against a subset of the syntax rules."@en ;
+ sh:declare [
+  sh:prefix "shsh" ;
+  sh:namespace "http://www.w3.org/ns/shacl-shacl#" ;
+ ] .
+
+ 
+shsh:ListShape
+ a sh:NodeShape ;
+ rdfs:label "List shape"@en ;
+ rdfs:comment "A shape describing well-formed RDF lists. Currently does not check for non-recursion. This could be expressed using SHACL-SPARQL."@en ;
+ rdfs:seeAlso <https://www.w3.org/TR/shacl/#syntax-rule-SHACL-list> ;
+ sh:property [
+  sh:path [ sh:zeroOrMorePath rdf:rest ] ;
+  rdfs:comment "Each list member (including this node) must be have the shape shsh:ListNodeShape."@en ;
+  sh:hasValue rdf:nil ;
+  sh:node shsh:ListNodeShape ;
+ ] .
+
+shsh:ListNodeShape
+ a sh:NodeShape ;
+ rdfs:label "List node shape"@en ;
+ rdfs:comment "Defines constraints on what it means for a node to be a node within a well-formed RDF list. Note that this does not check whether the rdf:rest items are also well-formed lists as this would lead to unsupported recursion."@en ;
+ sh:or ( [
+    sh:hasValue rdf:nil ;
+          sh:property [
+     sh:path rdf:first ;
+     sh:maxCount 0 ;
+    ] ;
+    sh:property [
+     sh:path rdf:rest ;
+     sh:maxCount 0 ;
+    ] ;
+   ]
+   [
+    sh:not [ sh:hasValue rdf:nil ] ;
+    sh:property [
+     sh:path rdf:first ;
+     sh:maxCount 1 ;
+     sh:minCount 1 ;
+    ] ;
+    sh:property [
+     sh:path rdf:rest ;
+     sh:maxCount 1 ;
+     sh:minCount 1 ;
+    ] ;
+   ] ) .
+
+shsh:ShapeShape
+ a sh:NodeShape ;
+ rdfs:label "Shape shape"@en ;
+ rdfs:comment "A shape that can be used to validate syntax rules for other shapes."@en ;
+ 
+ # See https://www.w3.org/TR/shacl/#shapes for what counts as a shape
+ sh:targetClass sh:NodeShape ;
+ sh:targetClass sh:PropertyShape ;
+ sh:targetSubjectsOf sh:targetClass, sh:targetNode, sh:targetObjectsOf, sh:targetSubjectsOf ;
+ sh:targetSubjectsOf sh:and, sh:class, sh:closed, sh:datatype, sh:disjoint, sh:equals, sh:flags, sh:hasValue,
+  sh:ignoredProperties, sh:in, sh:languageIn, sh:lessThan, sh:lessThanOrEquals, sh:maxCount, sh:maxExclusive,
+  sh:maxInclusive, sh:maxLength, sh:minCount, sh:minExclusive, sh:minInclusive, sh:minLength, sh:node, sh:nodeKind,
+  sh:not, sh:or, sh:pattern, sh:property, sh:qualifiedMaxCount, sh:qualifiedMinCount, sh:qualifiedValueShape,
+  sh:qualifiedValueShape, sh:qualifiedValueShapesDisjoint, sh:qualifiedValueShapesDisjoint, sh:sparql, sh:uniqueLang, sh:xone ;
+
+ sh:targetObjectsOf sh:node ;        # node-node
+ sh:targetObjectsOf sh:not ;         # not-node
+ sh:targetObjectsOf sh:property ;    # property-node
+ sh:targetObjectsOf sh:qualifiedValueShape ; # qualifiedValueShape-node
+
+ # Shapes are either node shapes or property shapes
+ sh:xone ( shsh:NodeShapeShape shsh:PropertyShapeShape ) ;
+
+ sh:property [
+  sh:path sh:targetNode ;
+  sh:nodeKind sh:IRIOrLiteral ;   # targetNode-nodeKind
+ ] ; 
+ sh:property [
+  sh:path sh:targetClass ;
+  sh:nodeKind sh:IRI ;            # targetClass-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:targetSubjectsOf ;
+  sh:nodeKind sh:IRI ;            # targetSubjectsOf-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:targetObjectsOf ;
+  sh:nodeKind sh:IRI ;            # targetObjectsOf-nodeKind
+ ] ;
+ sh:or ( [ sh:not [ 
+    sh:class rdfs:Class ; 
+    sh:or ( [ sh:class sh:NodeShape ] [ sh:class sh:PropertyShape ] )
+   ] ]
+   [ sh:nodeKind sh:IRI ]
+    ) ;                           # implicit-targetClass-nodeKind
+ 
+ sh:property [
+  sh:path sh:severity ;
+  sh:maxCount 1 ;                 # severity-maxCount
+  sh:nodeKind sh:IRI ;            # severity-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:message ;
+  sh:or ( [ sh:datatype xsd:string ] [ sh:datatype rdf:langString ] ) ;   # message-datatype
+ ] ;
+ sh:property [
+  sh:path sh:deactivated ;
+  sh:maxCount 1 ;                 # deactivated-maxCount
+  sh:in ( true false ) ;          # deactivated-datatype
+ ] ;
+
+ sh:property [
+  sh:path sh:and ;
+  sh:node shsh:ListShape ;        # and-node
+ ] ;
+ sh:property [
+  sh:path sh:class ;
+  sh:nodeKind sh:IRI ;            # class-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:closed ;
+  sh:datatype xsd:boolean ;       # closed-datatype
+  sh:maxCount 1 ;                 # multiple-parameters
+ ] ;
+ sh:property [
+  sh:path sh:ignoredProperties ;
+  sh:node shsh:ListShape ;        # ignoredProperties-node
+  sh:maxCount 1 ;                 # multiple-parameters
+ ] ;
+ sh:property [
+  sh:path ( sh:ignoredProperties [ sh:zeroOrMorePath rdf:rest ] rdf:first ) ;
+  sh:nodeKind sh:IRI ;            # ignoredProperties-members-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:datatype ;
+  sh:nodeKind sh:IRI ;            # datatype-nodeKind
+  sh:maxCount 1 ;                 # datatype-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:disjoint ;
+  sh:nodeKind sh:IRI ;            # disjoint-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:equals ;
+  sh:nodeKind sh:IRI ;            # equals-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:in ;
+  sh:maxCount 1 ;                 # in-maxCount  
+  sh:node shsh:ListShape ;        # in-node
+ ] ;
+ sh:property [
+  sh:path sh:languageIn ;
+  sh:maxCount 1 ;                 # languageIn-maxCount
+  sh:node shsh:ListShape ;        # languageIn-node
+ ] ;
+ sh:property [
+  sh:path ( sh:languageIn [ sh:zeroOrMorePath rdf:rest ] rdf:first ) ;
+  sh:datatype xsd:string ;        # languageIn-members-datatype
+ ] ;
+ sh:property [
+  sh:path sh:lessThan ;
+  sh:nodeKind sh:IRI ;            # lessThan-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:lessThanOrEquals ;
+  sh:nodeKind sh:IRI ;            # lessThanOrEquals-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:maxCount ;
+  sh:datatype xsd:integer ;       # maxCount-datatype
+  sh:maxCount 1 ;                 # maxCount-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:maxExclusive ;
+  sh:maxCount 1 ;                 # maxExclusive-maxCount
+  sh:nodeKind sh:Literal ;        # maxExclusive-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:maxInclusive ;
+  sh:maxCount 1 ;                 # maxInclusive-maxCount
+  sh:nodeKind sh:Literal ;        # maxInclusive-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:maxLength ;
+  sh:datatype xsd:integer ;       # maxLength-datatype
+  sh:maxCount 1 ;                 # maxLength-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:minCount ;
+  sh:datatype xsd:integer ;       # minCount-datatype
+  sh:maxCount 1 ;                 # minCount-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:minExclusive ;
+  sh:maxCount 1 ;                 # minExclusive-maxCount
+  sh:nodeKind sh:Literal ;        # minExclusive-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:minInclusive ;
+  sh:maxCount 1 ;                 # minInclusive-maxCount
+  sh:nodeKind sh:Literal ;        # minInclusive-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:minLength ;
+  sh:datatype xsd:integer ;       # minLength-datatype
+  sh:maxCount 1 ;                 # minLength-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:nodeKind ;
+  sh:in ( sh:BlankNode sh:IRI sh:Literal sh:BlankNodeOrIRI sh:BlankNodeOrLiteral sh:IRIOrLiteral ) ; # nodeKind-in
+  sh:maxCount 1 ;                 # nodeKind-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:or ;
+  sh:node shsh:ListShape ;        # or-node
+ ] ;
+ sh:property [
+  sh:path sh:pattern ;
+  sh:datatype xsd:string ;        # pattern-datatype
+  sh:maxCount 1 ;                 # multiple-parameters
+  # Not implemented: syntax rule pattern-regex
+ ] ;
+ sh:property [
+  sh:path sh:flags ;
+  sh:datatype xsd:string ;        # flags-datatype
+  sh:maxCount 1 ;                 # multiple-parameters
+ ] ;
+ sh:property [
+  sh:path sh:qualifiedMaxCount ;
+  sh:datatype xsd:integer ;       # qualifiedMaxCount-datatype
+  sh:maxCount 1 ;                 # multiple-parameters
+ ] ;
+ sh:property [
+  sh:path sh:qualifiedMinCount ;
+  sh:datatype xsd:integer ;       # qualifiedMinCount-datatype
+  sh:maxCount 1 ;                 # multiple-parameters
+ ] ;
+ sh:property [
+  sh:path sh:qualifiedValueShape ;
+  sh:maxCount 1 ;                 # multiple-parameters
+ ] ;
+ sh:property [
+  sh:path sh:qualifiedValueShapesDisjoint ;
+  sh:datatype xsd:boolean ;       # qualifiedValueShapesDisjoint-datatype
+  sh:maxCount 1 ;                 # multiple-parameters
+ ] ;
+ sh:property [
+  sh:path sh:uniqueLang ;
+  sh:datatype xsd:boolean ;       # uniqueLang-datatype
+  sh:maxCount 1 ;                 # uniqueLang-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:xone ;
+  sh:node shsh:ListShape ;        # xone-node
+ ] .
+ 
+shsh:NodeShapeShape
+ a sh:NodeShape ;
+ sh:targetObjectsOf sh:node ;        # node-node
+ sh:property [
+  sh:path sh:path ;
+  sh:maxCount 0 ;                 # NodeShape-path-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:lessThan ;
+  sh:maxCount 0 ;                 # lessThan-scope
+ ] ;
+ sh:property [
+  sh:path sh:lessThanOrEquals ;
+  sh:maxCount 0 ;                 # lessThanOrEquals-scope
+ ] ;
+ sh:property [
+  sh:path sh:maxCount ;
+  sh:maxCount 0 ;                 # maxCount-scope
+ ] ;
+ sh:property [
+  sh:path sh:minCount ;
+  sh:maxCount 0 ;                 # minCount-scope
+ ] ;
+ sh:property [
+  sh:path sh:qualifiedValueShape ;
+  sh:maxCount 0 ;                 # qualifiedValueShape-scope
+ ] ;
+ sh:property [
+  sh:path sh:uniqueLang ;
+  sh:maxCount 0 ;                 # uniqueLang-scope
+ ] .
+
+shsh:PropertyShapeShape
+ a sh:NodeShape ;
+ sh:targetObjectsOf sh:property ;    # property-node
+ sh:property [
+  sh:path sh:path ;
+  sh:maxCount 1 ;                 # path-maxCount
+  sh:minCount 1 ;                 # PropertyShape-path-minCount
+  sh:node shsh:PathShape ;        # path-node
+ ] .
+
+# Values of sh:and, sh:or and sh:xone must be lists of shapes
+shsh:ShapesListShape
+ a sh:NodeShape ;
+ sh:targetObjectsOf sh:and ;         # and-members-node
+ sh:targetObjectsOf sh:or ;          # or-members-node
+ sh:targetObjectsOf sh:xone ;        # xone-members-node
+ sh:property [
+  sh:path ( [ sh:zeroOrMorePath rdf:rest ] rdf:first ) ;
+  sh:node shsh:ShapeShape ;
+ ] .
+
+
+# A path of blank node path syntax, used to simulate recursion
+_:PathPath
+ sh:alternativePath (
+  ( [ sh:zeroOrMorePath rdf:rest ] rdf:first )
+  ( sh:alternativePath [ sh:zeroOrMorePath rdf:rest ] rdf:first )
+  sh:inversePath
+  sh:zeroOrMorePath
+  sh:oneOrMorePath
+  sh:zeroOrOnePath 
+ ) .
+
+shsh:PathShape
+ a sh:NodeShape ;
+ rdfs:label "Path shape"@en ;
+ rdfs:comment "A shape that can be used to validate the syntax rules of well-formed SHACL paths."@en ;
+ rdfs:seeAlso <https://www.w3.org/TR/shacl/#property-paths> ;
+ sh:property [
+  sh:path [ sh:zeroOrMorePath _:PathPath ] ;
+  sh:node shsh:PathNodeShape ;
+ ] .
+
+shsh:PathNodeShape
+ sh:xone (                           # path-metarule
+   [ sh:nodeKind sh:IRI ]          # 2.3.1.1: Predicate path
+   [ sh:nodeKind sh:BlankNode ;    # 2.3.1.2: Sequence path
+     sh:node shsh:PathListWithAtLeast2Members ;
+   ]
+   [ sh:nodeKind sh:BlankNode ;    # 2.3.1.3: Alternative path
+     sh:closed true ;
+     sh:property [
+       sh:path sh:alternativePath ;
+       sh:node shsh:PathListWithAtLeast2Members ;
+       sh:minCount 1 ;
+       sh:maxCount 1 ;
+     ]
+   ]
+   [ sh:nodeKind sh:BlankNode ;    # 2.3.1.4: Inverse path
+     sh:closed true ;
+     sh:property [
+       sh:path sh:inversePath ;
+       sh:minCount 1 ;
+       sh:maxCount 1 ;
+     ] 
+   ]
+   [ sh:nodeKind sh:BlankNode ;    # 2.3.1.5: Zero-or-more path
+     sh:closed true ;
+     sh:property [
+       sh:path sh:zeroOrMorePath ;
+       sh:minCount 1 ;
+       sh:maxCount 1 ;
+     ] 
+   ]
+   [ sh:nodeKind sh:BlankNode ;    # 2.3.1.6: One-or-more path
+     sh:closed true ;
+     sh:property [
+       sh:path sh:oneOrMorePath ;
+       sh:minCount 1 ;
+       sh:maxCount 1 ;
+     ] 
+   ]
+   [ sh:nodeKind sh:BlankNode ;    # 2.3.1.7: Zero-or-one path
+     sh:closed true ;
+     sh:property [
+       sh:path sh:zeroOrOnePath ;
+       sh:minCount 1 ;
+       sh:maxCount 1 ;
+     ] 
+   ]
+  ) .
+
+shsh:PathListWithAtLeast2Members
+ a sh:NodeShape ;
+ sh:node shsh:ListShape ;
+ sh:property [
+  sh:path [ sh:oneOrMorePath rdf:rest ] ;
+  sh:minCount 2 ;    # 1 other list node plus rdf:nil
+ ] .
+
+shsh:ShapesGraphShape
+ a sh:NodeShape ;
+ sh:targetObjectsOf sh:shapesGraph ;
+ sh:nodeKind sh:IRI .                # shapesGraph-nodeKind
+
+shsh:EntailmentShape
+ a sh:NodeShape ;
+ sh:targetObjectsOf sh:entailment ;
+ sh:nodeKind sh:IRI .                # entailment-nodeKind
+`));
+//# sourceMappingURL=shaclShaclDataset.js.map

package/package.json

@@ -3,7 +3,7 @@
     "shaclmate": "dist/cli.js"
   },
   "dependencies": {
-    "@shaclmate/compiler": "4.0.50",
+    "@shaclmate/compiler": "4.0.51",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/serializer-turtle": "~1.1.5",
@@ -26,24 +26,24 @@
   },
   "files": [
     "README.md",
-    "dist/cli.ts.d.ts",
-    "dist/cli.ts.js",
-    "dist/commands/generate.ts.d.ts",
-    "dist/commands/generate.ts.js",
-    "dist/commands/index.ts.d.ts",
-    "dist/commands/index.ts.js",
-    "dist/commands/merge.ts.d.ts",
-    "dist/commands/merge.ts.js",
-    "dist/commands/validate.ts.d.ts",
-    "dist/commands/validate.ts.js",
-    "dist/index.ts.d.ts",
-    "dist/index.ts.js",
-    "dist/logger.ts.d.ts",
-    "dist/logger.ts.js",
-    "dist/parseInputs.ts.d.ts",
-    "dist/parseInputs.ts.js",
-    "dist/shaclShaclDataset.ts.d.ts",
-    "dist/shaclShaclDataset.ts.js"
+    "dist/cli.d.ts",
+    "dist/cli.js",
+    "dist/commands/generate.d.ts",
+    "dist/commands/generate.js",
+    "dist/commands/index.d.ts",
+    "dist/commands/index.js",
+    "dist/commands/merge.d.ts",
+    "dist/commands/merge.js",
+    "dist/commands/validate.d.ts",
+    "dist/commands/validate.js",
+    "dist/index.d.ts",
+    "dist/index.js",
+    "dist/logger.d.ts",
+    "dist/logger.js",
+    "dist/parseInputs.d.ts",
+    "dist/parseInputs.js",
+    "dist/shaclShaclDataset.d.ts",
+    "dist/shaclShaclDataset.js"
   ],
   "homepage": "https://github.com/minorg/shaclmate",
   "keywords": [
@@ -69,5 +69,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.50"
+  "version": "4.0.51"
 }