@shaclmate/compiler 4.0.40 → 4.0.42

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -4,22 +4,15 @@ import { Either } from "purify-ts";
 import type { Logger } from "ts-log";
 import type * as ast from "./ast/index.js";
 import type * as input from "./input/index.js";
-interface RelatedNodeShapes {
-    readonly ancestors: input.NodeShape[];
-    readonly children: input.NodeShape[];
-    readonly parents: input.NodeShape[];
-    readonly descendants: input.NodeShape[];
-}
 export declare class ShapesGraphToAstTransformer {
     protected readonly cachedAstTypesByShapeIdentifier: TermMap<BlankNode | NamedNode, ast.Type>;
+    protected readonly syntheticAstStructTypesByName: Map<string, ast.StructType>;
     protected readonly logger: Logger;
     protected readonly shapesGraph: input.ShapesGraph;
-    protected readonly relatedNodeShapesByIdentifier: TermMap<BlankNode | NamedNode, RelatedNodeShapes>;
     constructor({ logger, shapesGraph, }: {
         logger: Logger;
         shapesGraph: input.ShapesGraph;
     });
     transform(): Either<Error, ast.Ast>;
 }
-export {};
 //# sourceMappingURL=ShapesGraphToAstTransformer.d.ts.map

package/dist/ShapesGraphToAstTransformer.js

@@ -1,161 +1,46 @@
 import TermMap from "@rdfjs/term-map";
-import { dash } from "@tpluscode/rdf-ns-builders";
 import { Either } from "purify-ts";
-import { invariant } from "ts-invariant";
 import { ShapeStack } from "./_ShapesGraphToAstTransformer/ShapeStack.js";
 import { transformShapeToAstType } from "./_ShapesGraphToAstTransformer/transformShapeToAstType.js";
-function relatedNodeShapes({ logger, shapesGraph, }) {
-    const immediateRelatedNodeShapes = new TermMap();
-    for (const childNodeShape of shapesGraph.nodeShapes) {
-        let childRelatedNodeShapes = immediateRelatedNodeShapes.get(childNodeShape.$identifier());
-        if (!childRelatedNodeShapes) {
-            childRelatedNodeShapes = {
-                children: new TermMap(),
-                parents: new TermMap(),
-            };
-            immediateRelatedNodeShapes.set(childNodeShape.$identifier(), childRelatedNodeShapes);
-        }
-        for (const parentClassIdentifier of childNodeShape.subClassOf) {
-            shapesGraph
-                .nodeShape(parentClassIdentifier)
-                .ifLeft((error) => {
-                logger.error("%s is rdfs:subClassOf %s which is either missing or not a node shape: %s", childNodeShape, parentClassIdentifier, error.message);
-            })
-                .ifRight((parentNodeShape) => {
-                childRelatedNodeShapes.parents.set(parentNodeShape.$identifier(), parentNodeShape);
-                let parentRelatedNodeShapes = immediateRelatedNodeShapes.get(parentNodeShape.$identifier());
-                if (!parentRelatedNodeShapes) {
-                    parentRelatedNodeShapes = {
-                        children: new TermMap(),
-                        parents: new TermMap(),
-                    };
-                    immediateRelatedNodeShapes.set(parentNodeShape.$identifier(), parentRelatedNodeShapes);
-                }
-                parentRelatedNodeShapes.children.set(childNodeShape.$identifier(), childNodeShape);
-            });
-        }
-    }
-    const result = new TermMap();
-    for (const nodeShape of shapesGraph.nodeShapes) {
-        const { children: childNodeShapes, parents: parentNodeShapes } = immediateRelatedNodeShapes.get(nodeShape.$identifier());
-        const ancestorNodeShapes = new TermMap();
-        function recurseAncestorNodeShapes(nodeShape) {
-            for (const parentNodeShape of immediateRelatedNodeShapes
-                .get(nodeShape.$identifier())
-                .parents.values()) {
-                if (!ancestorNodeShapes.has(parentNodeShape.$identifier())) {
-                    ancestorNodeShapes.set(parentNodeShape.$identifier(), parentNodeShape);
-                    recurseAncestorNodeShapes(parentNodeShape);
-                }
-            }
-        }
-        recurseAncestorNodeShapes(nodeShape);
-        const descendantNodeShapes = new TermMap();
-        function recurseDescendantNodeShapes(nodeShape) {
-            for (const childNodeShape of immediateRelatedNodeShapes
-                .get(nodeShape.$identifier())
-                .children.values()) {
-                if (!descendantNodeShapes.has(childNodeShape.$identifier())) {
-                    descendantNodeShapes.set(childNodeShape.$identifier(), childNodeShape);
-                    recurseDescendantNodeShapes(childNodeShape);
-                }
-            }
-        }
-        recurseDescendantNodeShapes(nodeShape);
-        result.set(nodeShape.$identifier(), {
-            ancestors: [...ancestorNodeShapes.values()],
-            children: [...childNodeShapes.values()],
-            descendants: [...descendantNodeShapes.values()],
-            parents: [...parentNodeShapes.values()],
-        });
-    }
-    return result;
-}
 export class ShapesGraphToAstTransformer {
     // Members are protected so they're accessible to functions in other files
     cachedAstTypesByShapeIdentifier = new TermMap();
+    syntheticAstStructTypesByName = new Map();
     logger;
     shapesGraph;
-    relatedNodeShapesByIdentifier = new TermMap();
     constructor({ logger, shapesGraph, }) {
         this.logger = logger;
-        this.relatedNodeShapesByIdentifier = relatedNodeShapes({
-            logger: this.logger,
-            shapesGraph,
-        });
         this.shapesGraph = shapesGraph;
     }
     transform() {
-        const astNamedIntersectionTypes = [];
-        const astObjectTypes = [];
-        const syntheticAstObjectTypesByName = {};
-        const astNamedUnionTypes = [];
+        const astNamedTypes = [];
         for (const nodeShape of this.shapesGraph.nodeShapes) {
             if (nodeShape.$identifier().termType !== "NamedNode") {
                 continue;
             }
-            if (nodeShape.$identifier().value.startsWith(dash[""].value)) {
-                continue;
-            }
             const nodeShapeAstTypeEither = transformShapeToAstType.call(this, nodeShape, new ShapeStack());
             if (nodeShapeAstTypeEither.isLeft()) {
                 return nodeShapeAstTypeEither;
             }
             const nodeShapeAstType = nodeShapeAstTypeEither.unsafeCoerce();
-            switch (nodeShapeAstType.kind) {
-                case "Intersection":
-                    if (nodeShapeAstType.name.isJust()) {
-                        astNamedIntersectionTypes.push(nodeShapeAstType);
-                    }
-                    break;
-                case "Object": {
-                    invariant(nodeShapeAstType.name.isJust(), `node shape missing name: ${nodeShapeAstType.shapeIdentifier}`);
-                    astObjectTypes.push(nodeShapeAstType);
-                    for (const property of nodeShapeAstType.properties) {
-                        switch (property.type.kind) {
-                            case "LazyObjectOption":
-                            case "LazyObjectSet":
-                            case "LazyObject": {
-                                const partialItemType = property.type.partialType.kind === "Object" ||
-                                    property.type.partialType.kind === "Union"
-                                    ? property.type.partialType
-                                    : property.type.partialType.itemType;
-                                if (partialItemType.kind === "Object" &&
-                                    partialItemType.synthetic) {
-                                    const partialItemTypeName = partialItemType.name.unsafeCoerce();
-                                    if (!syntheticAstObjectTypesByName[partialItemTypeName]) {
-                                        syntheticAstObjectTypesByName[partialItemTypeName] =
-                                            partialItemType;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    break;
-                }
-                case "Union":
-                    if (nodeShapeAstType.name.isJust()) {
-                        astNamedUnionTypes.push(nodeShapeAstType);
-                    }
-                    break;
-                default:
-                    break;
-            }
+            nodeShapeAstType.name.ifJust(() => {
+                astNamedTypes.push(nodeShapeAstType);
+            });
         }
         return Either.of({
             lazyTypesCount: [...this.cachedAstTypesByShapeIdentifier.values()].reduce((acc, astType) => {
                 switch (astType.kind) {
-                    case "LazyObject":
-                    case "LazyObjectOption":
-                    case "LazyObjectSet":
+                    case "Lazy":
+                    case "LazyOption":
+                    case "LazySet":
                         return acc + 1;
                     default:
                         return acc;
                 }
             }, 0),
-            namedIntersectionTypes: astNamedIntersectionTypes,
-            namedObjectTypes: astObjectTypes.concat(Object.values(syntheticAstObjectTypesByName)),
-            namedUnionTypes: astNamedUnionTypes,
+            namedTypes: astNamedTypes.concat([
+                ...this.syntheticAstStructTypesByName.values(),
+            ]),
         });
     }
 }

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.js

@@ -6,177 +6,145 @@ const defaultPropertyShapeNodeKinds = new Set([
     "IRI",
     "Literal",
 ]);
-function nodeShapeNodeKinds(nodeShape) {
-    const thisNodeKinds = nodeShape.nodeKind
+export function shapeNodeKinds(shape, options) {
+    const explicitNodeKinds = shape.nodeKind
         .map(NodeKind.fromIri)
         .orDefault(new Set());
-    // Recurse into parents
-    const parentNodeKinds = new Set();
-    for (const parentNodeShape of this.relatedNodeShapesByIdentifier.get(nodeShape.$identifier()).parents) {
-        nodeShapeNodeKinds
-            .call(this, parentNodeShape)
-            .ifRight((parentNodeKinds_) => {
-            for (const parentNodeKind of parentNodeKinds_) {
-                parentNodeKinds.add(parentNodeKind);
+    // Consider constraints that dictate certain node kinds, like sh:datatype dictates a Literal nodeKind.
+    const constraintExcludeNodeKinds = new Set();
+    const constraintIncludeNodeKinds = new Set();
+    for (const [constraint, { excludeNodeKinds, includeNodeKinds }] of [
+        [
+            "sh:class",
+            shape.classes.length > 0
+                ? { excludeNodeKinds: ["Literal"] }
+                : {},
+        ],
+        [
+            "sh:datatype",
+            {
+                includeNodeKinds: shape.datatype
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+        [
+            "sh:defaultValue",
+            {
+                includeNodeKinds: shape.$type === "PropertyShape"
+                    ? shape.defaultValue
+                        .map((value) => NodeKind.fromTermType(value.termType))
+                        .toList()
+                    : [],
+            },
+        ],
+        [
+            "sh:hasValue",
+            {
+                includeNodeKinds: shape.hasValues.map((value) => NodeKind.fromTermType(value.termType)),
+            },
+        ],
+        [
+            "sh:in",
+            {
+                includeNodeKinds: shape.in_
+                    .orDefault([])
+                    .map((in_) => NodeKind.fromTermType(in_.termType)),
+            },
+        ],
+        [
+            "sh:languageIn",
+            shape.languageIn.orDefault([]).length > 0
+                ? { includeNodeKinds: ["Literal"] }
+                : {},
+        ],
+        [
+            "sh:maxExclusive",
+            {
+                includeNodeKinds: shape.maxExclusive
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+        [
+            "sh:maxInclusive",
+            {
+                includeNodeKinds: shape.maxInclusive
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+        [
+            "sh:minExclusive",
+            {
+                includeNodeKinds: shape.minExclusive
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+        [
+            "sh:minInclusive",
+            {
+                includeNodeKinds: shape.minInclusive
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+    ]) {
+        for (const excludeNodeKind of excludeNodeKinds ?? []) {
+            if (explicitNodeKinds.size > 0 &&
+                explicitNodeKinds.has(excludeNodeKind)) {
+                return Left(new Error(`${shape} has ${constraint} that conflicts with sh:nodeKind`));
             }
-        });
-    }
-    if (parentNodeKinds.size > 0) {
-        if (thisNodeKinds.size === 0) {
-            return Either.of(parentNodeKinds);
+            constraintExcludeNodeKinds.add(excludeNodeKind);
         }
-        // Check that thisNodeKinds doesn't conflict with parent node kinds
-        for (const thisNodeKind of thisNodeKinds) {
-            if (!parentNodeKinds.has(thisNodeKind)) {
-                return Left(new Error(`${nodeShape} has a nodeKind ${thisNodeKind} that is not in its parent's node kinds`));
+        for (const includeNodeKind of includeNodeKinds ?? []) {
+            if (explicitNodeKinds.size > 0 &&
+                !explicitNodeKinds.has(includeNodeKind)) {
+                return Left(new Error(`${shape} has ${constraint} that conflicts with sh:nodeKind`));
             }
+            constraintIncludeNodeKinds.add(includeNodeKind);
         }
     }
-    return Either.of(thisNodeKinds);
-}
-function propertyShapeNodeKinds(propertyShape) {
-    return Either.of(propertyShape.nodeKind.map(NodeKind.fromIri).orDefault(new Set()));
-}
-export function shapeNodeKinds(shape, options) {
-    return (shape.$type === "NodeShape"
-        ? nodeShapeNodeKinds.call(this, shape)
-        : propertyShapeNodeKinds(shape)).chain((explicitNodeKinds) => {
-        // Consider constraints that dictate certain node kinds, like sh:datatype dictates a Literal nodeKind.
-        const constraintExcludeNodeKinds = new Set();
-        const constraintIncludeNodeKinds = new Set();
-        for (const [constraint, { excludeNodeKinds, includeNodeKinds }] of [
-            [
-                "sh:class",
-                shape.classes.length > 0
-                    ? { excludeNodeKinds: ["Literal"] }
-                    : {},
-            ],
-            [
-                "sh:datatype",
-                {
-                    includeNodeKinds: shape.datatype
-                        .map(() => ["Literal"])
-                        .orDefault([]),
-                },
-            ],
-            [
-                "sh:defaultValue",
-                {
-                    includeNodeKinds: shape.$type === "PropertyShape"
-                        ? shape.defaultValue
-                            .map((value) => NodeKind.fromTermType(value.termType))
-                            .toList()
-                        : [],
-                },
-            ],
-            [
-                "sh:hasValue",
-                {
-                    includeNodeKinds: shape.hasValues.map((value) => NodeKind.fromTermType(value.termType)),
-                },
-            ],
-            [
-                "sh:in",
-                {
-                    includeNodeKinds: shape.in_
-                        .orDefault([])
-                        .map((in_) => NodeKind.fromTermType(in_.termType)),
-                },
-            ],
-            [
-                "sh:languageIn",
-                shape.languageIn.orDefault([]).length > 0
-                    ? { includeNodeKinds: ["Literal"] }
-                    : {},
-            ],
-            [
-                "sh:maxExclusive",
-                {
-                    includeNodeKinds: shape.maxExclusive
-                        .map(() => ["Literal"])
-                        .orDefault([]),
-                },
-            ],
-            [
-                "sh:maxInclusive",
-                {
-                    includeNodeKinds: shape.maxInclusive
-                        .map(() => ["Literal"])
-                        .orDefault([]),
-                },
-            ],
-            [
-                "sh:minExclusive",
-                {
-                    includeNodeKinds: shape.minExclusive
-                        .map(() => ["Literal"])
-                        .orDefault([]),
-                },
-            ],
-            [
-                "sh:minInclusive",
-                {
-                    includeNodeKinds: shape.minInclusive
-                        .map(() => ["Literal"])
-                        .orDefault([]),
-                },
-            ],
-        ]) {
-            for (const excludeNodeKind of excludeNodeKinds ?? []) {
-                if (explicitNodeKinds.size > 0 &&
-                    explicitNodeKinds.has(excludeNodeKind)) {
-                    return Left(new Error(`${shape} has ${constraint} that conflicts with sh:nodeKind`));
-                }
-                constraintExcludeNodeKinds.add(excludeNodeKind);
-            }
-            for (const includeNodeKind of includeNodeKinds ?? []) {
-                if (explicitNodeKinds.size > 0 &&
-                    !explicitNodeKinds.has(includeNodeKind)) {
-                    return Left(new Error(`${shape} has ${constraint} that conflicts with sh:nodeKind`));
-                }
-                constraintIncludeNodeKinds.add(includeNodeKind);
-            }
-        }
-        if (explicitNodeKinds.size > 0) {
-            return Either.of(explicitNodeKinds);
-        }
-        // There were no explicit sh:nodeKind, try to infer the shape's node kind from the node kinds excluded and included by constraints
-        const constraintNodeKinds = new Set();
-        if (constraintIncludeNodeKinds.size > 0) {
-            // If constraints dictated/included certain node kinds be included. Add those to the set.
-            for (const constraintIncludeNodeKind of constraintIncludeNodeKinds) {
-                constraintNodeKinds.add(constraintIncludeNodeKind);
-            }
-            // Check whether other constraints' excluded node kinds conflict.
-            if (constraintExcludeNodeKinds.size > 0) {
-                for (const constraintExcludeNodeKind of constraintExcludeNodeKinds) {
-                    if (constraintIncludeNodeKinds.has(constraintExcludeNodeKind)) {
-                        return Left(new Error(`${shape} has constraints with conflicting exclude/include node kinds`));
-                    }
-                }
-            }
+    if (explicitNodeKinds.size > 0) {
+        return Either.of(explicitNodeKinds);
+    }
+    // There were no explicit sh:nodeKind, try to infer the shape's node kind from the node kinds excluded and included by constraints
+    const constraintNodeKinds = new Set();
+    if (constraintIncludeNodeKinds.size > 0) {
+        // If constraints dictated/included certain node kinds be included. Add those to the set.
+        for (const constraintIncludeNodeKind of constraintIncludeNodeKinds) {
+            constraintNodeKinds.add(constraintIncludeNodeKind);
         }
-        else if (constraintExcludeNodeKinds.size > 0) {
-            // No constraint dictated that certain node kinds be included, but some constraint dictated that certain node kinds be excluded.
-            // Start with all node kinds and exclude.
-            constraintNodeKinds.add("BlankNode");
-            constraintNodeKinds.add("IRI");
-            constraintNodeKinds.add("Literal");
+        // Check whether other constraints' excluded node kinds conflict.
+        if (constraintExcludeNodeKinds.size > 0) {
             for (const constraintExcludeNodeKind of constraintExcludeNodeKinds) {
-                constraintNodeKinds.delete(constraintExcludeNodeKind);
+                if (constraintIncludeNodeKinds.has(constraintExcludeNodeKind)) {
+                    return Left(new Error(`${shape} has constraints with conflicting exclude/include node kinds`));
+                }
             }
         }
-        if (constraintNodeKinds.size > 0) {
-            return Either.of(constraintNodeKinds);
-        }
-        if (shape.$type === "NodeShape") {
-            return Either.of(options?.defaultNodeShapeNodeKinds ?? defaultNodeShapeNodeKinds);
-        }
-        if (shape.path.termType === "InversePath") {
-            // Inverse paths can only have blank nodes and IRIs as values, because the value is the subject of a triple.
-            return Either.of(new Set(["BlankNode", "IRI"]));
+    }
+    else if (constraintExcludeNodeKinds.size > 0) {
+        // No constraint dictated that certain node kinds be included, but some constraint dictated that certain node kinds be excluded.
+        // Start with all node kinds and exclude.
+        constraintNodeKinds.add("BlankNode");
+        constraintNodeKinds.add("IRI");
+        constraintNodeKinds.add("Literal");
+        for (const constraintExcludeNodeKind of constraintExcludeNodeKinds) {
+            constraintNodeKinds.delete(constraintExcludeNodeKind);
         }
-        return Either.of(defaultPropertyShapeNodeKinds);
-    });
+    }
+    if (constraintNodeKinds.size > 0) {
+        return Either.of(constraintNodeKinds);
+    }
+    if (shape.$type === "NodeShape") {
+        return Either.of(options?.defaultNodeShapeNodeKinds ?? defaultNodeShapeNodeKinds);
+    }
+    if (shape.path.termType === "InversePath") {
+        // Inverse paths can only have blank nodes and IRIs as values, because the value is the subject of a triple.
+        return Either.of(new Set(["BlankNode", "IRI"]));
+    }
+    return Either.of(defaultPropertyShapeNodeKinds);
 }
 //# sourceMappingURL=shapeNodeKinds.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstStructTypeField.d.ts

@@ -0,0 +1,17 @@
+import { Either, Maybe } from "purify-ts";
+import * as ast from "../ast/index.js";
+import type * as input from "../input/index.js";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+/**
+ * Try to transform a property shape to an ast.StructType.Field.
+ *
+ * Returns:
+ *  - Right<Just<ast.StructType.Field>> if the transformation succeeds
+ *  - Right<Nothing> if the property shape should be ignored
+ *  - Left<Error> if the transformation fails
+ */
+export declare function transformPropertyShapeToAstStructTypeField(this: ShapesGraphToAstTransformer, { propertyShape, structType, }: {
+    propertyShape: input.PropertyShape;
+    structType: ast.StructType;
+}): Either<Error, Maybe<ast.StructType.Field>>;
+//# sourceMappingURL=transformPropertyShapeToAstStructTypeField.d.ts.map