@shaclmate/compiler 4.0.13 → 4.0.15

package/dist/Compiler.d.ts

@@ -1,10 +1,13 @@
 import type { Either } from "purify-ts";
+import type { TsFeature } from "./enums/TsFeature.js";
 import type { Generator } from "./generators/Generator.js";
 import type { ShapesGraph } from "./input/ShapesGraph.js";
 export declare class Compiler {
     private readonly generator;
-    constructor({ generator }: {
+    private readonly tsFeaturesDefault?;
+    constructor({ generator, }: {
         generator: Generator;
+        tsFeaturesDefault?: ReadonlySet<TsFeature>;
     });
     compile(shapesGraph: ShapesGraph): Either<Error, string>;
 }

package/dist/Compiler.js

@@ -1,12 +1,14 @@
 import { ShapesGraphToAstTransformer } from "./ShapesGraphToAstTransformer.js";
 export class Compiler {
     generator;
-    constructor({ generator }) {
+    tsFeaturesDefault;
+    constructor({ generator, }) {
         this.generator = generator;
     }
     compile(shapesGraph) {
         return new ShapesGraphToAstTransformer({
             shapesGraph,
+            tsFeaturesDefault: this.tsFeaturesDefault,
         })
             .transform()
             .map((ast) => this.generator.generate(ast));

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -1,12 +1,19 @@
 import TermMap from "@rdfjs/term-map";
-import type * as rdfjs from "@rdfjs/types";
+import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { Either } from "purify-ts";
 import type * as ast from "./ast/index.js";
 import type { TsFeature } from "./enums/TsFeature.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<rdfjs.BlankNode | rdfjs.NamedNode, ast.Type>;
+    protected readonly cachedAstTypesByShapeIdentifier: TermMap<BlankNode | NamedNode, ast.Type>;
     protected readonly shapesGraph: input.ShapesGraph;
+    protected readonly relatedNodeShapesByIdentifier: TermMap<BlankNode | NamedNode, RelatedNodeShapes>;
     protected tsFeaturesDefault: ReadonlySet<TsFeature>;
     constructor({ shapesGraph, tsFeaturesDefault, }: {
         shapesGraph: input.ShapesGraph;
@@ -14,4 +21,5 @@ export declare class ShapesGraphToAstTransformer {
     });
     transform(): Either<Error, ast.Ast>;
 }
+export {};
 //# sourceMappingURL=ShapesGraphToAstTransformer.d.ts.map

package/dist/ShapesGraphToAstTransformer.js

@@ -1,15 +1,86 @@
 import TermMap from "@rdfjs/term-map";
 import { dash } from "@tpluscode/rdf-ns-builders";
 import { Either } from "purify-ts";
+import { Resource } from "rdfjs-resource";
 import { invariant } from "ts-invariant";
 import { ShapeStack } from "./_ShapesGraphToAstTransformer/ShapeStack.js";
 import { transformShapeToAstType } from "./_ShapesGraphToAstTransformer/transformShapeToAstType.js";
+import { logger } from "./logger.js";
+function relatedNodeShapes(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, Resource.Identifier.toString(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();
     shapesGraph;
+    relatedNodeShapesByIdentifier = new TermMap();
     tsFeaturesDefault;
     constructor({ shapesGraph, tsFeaturesDefault, }) {
+        this.relatedNodeShapesByIdentifier = relatedNodeShapes(shapesGraph);
         this.shapesGraph = shapesGraph;
         this.tsFeaturesDefault =
             tsFeaturesDefault ??
@@ -21,10 +92,10 @@ export class ShapesGraphToAstTransformer {
         const syntheticAstObjectTypesByName = {};
         const astNamedUnionTypes = [];
         for (const nodeShape of this.shapesGraph.nodeShapes) {
-            if (nodeShape.identifier.termType !== "NamedNode") {
+            if (nodeShape.$identifier.termType !== "NamedNode") {
                 continue;
             }
-            if (nodeShape.identifier.value.startsWith(dash[""].value)) {
+            if (nodeShape.$identifier.value.startsWith(dash[""].value)) {
                 continue;
             }
             const nodeShapeAstTypeEither = transformShapeToAstType.call(this, nodeShape, new ShapeStack());
@@ -39,7 +110,7 @@ export class ShapesGraphToAstTransformer {
                     }
                     break;
                 case "ObjectType": {
-                    invariant(nodeShapeAstType.name.isJust());
+                    invariant(nodeShapeAstType.name.isJust(), `node shape missing name: ${nodeShapeAstType.shapeIdentifier}`);
                     astObjectTypes.push(nodeShapeAstType);
                     for (const property of nodeShapeAstType.properties) {
                         switch (property.type.kind) {

package/dist/_ShapesGraphToAstTransformer/ShapeStack.js

@@ -7,16 +7,17 @@ export class ShapeStack {
         this.constraints = {
             get hasValues() {
                 for (const shape of stack.toReversed()) {
-                    if (shape.constraints.hasValues.length > 0) {
-                        return shape.constraints.hasValues;
+                    if (shape.hasValues.length > 0) {
+                        return shape.hasValues;
                     }
                 }
                 return [];
             },
             get in_() {
                 for (const shape of stack.toReversed()) {
-                    if (shape.constraints.in_.length > 0) {
-                        return shape.constraints.in_;
+                    const shapeIn = shape.in_.orDefault([]);
+                    if (shapeIn.length > 0) {
+                        return shapeIn;
                     }
                 }
                 return [];
@@ -26,7 +27,7 @@ export class ShapeStack {
     constraints;
     get defaultValue() {
         for (const shape of this.stack.toReversed()) {
-            if (shape.kind !== "PropertyShape") {
+            if (shape.$type !== "PropertyShape") {
                 continue;
             }
             if (shape.defaultValue.isJust()) {

package/dist/_ShapesGraphToAstTransformer/nodeShapeIdentifierMintingStrategy.d.ts

@@ -1,5 +1,6 @@
 import { Either, Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
+import { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
 import type * as input from "../input/index.js";
-export declare function nodeShapeIdentifierMintingStrategy(nodeShape: input.NodeShape): Either<Error, Maybe<IdentifierMintingStrategy>>;
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+export declare function nodeShapeIdentifierMintingStrategy(this: ShapesGraphToAstTransformer, nodeShape: input.NodeShape): Either<Error, Maybe<IdentifierMintingStrategy>>;
 //# sourceMappingURL=nodeShapeIdentifierMintingStrategy.d.ts.map

package/dist/_ShapesGraphToAstTransformer/nodeShapeIdentifierMintingStrategy.js

@@ -1,4 +1,5 @@
 import { Either, Left, Maybe } from "purify-ts";
+import { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
 import { shapeNodeKinds } from "./shapeNodeKinds.js";
 const defaultNodeShapeNodeKinds = new Set([
     "BlankNode",
@@ -6,23 +7,26 @@ const defaultNodeShapeNodeKinds = new Set([
 ]);
 export function nodeShapeIdentifierMintingStrategy(nodeShape) {
     if (nodeShape.identifierMintingStrategy.isJust()) {
-        if (nodeShape.identifierIn.length > 0) {
+        if (nodeShape.in_.filter((_) => _.length > 0).isJust()) {
             return Left(new Error(`${nodeShape} cannot have an identifier minting strategy and sh:in`));
         }
-        return Either.of(nodeShape.identifierMintingStrategy);
+        return Either.of(nodeShape.identifierMintingStrategy.map(IdentifierMintingStrategy.fromIri));
     }
-    return nodeShape.ancestorNodeShapes.chain((ancestorNodeShapes) => {
-        for (const ancestorNodeShape of ancestorNodeShapes) {
-            if (ancestorNodeShape.identifierMintingStrategy.isJust()) {
-                return Either.of(ancestorNodeShape.identifierMintingStrategy);
-            }
+    // Recurse into parents
+    for (const parentNodeShape of this.relatedNodeShapesByIdentifier.get(nodeShape.$identifier).parents) {
+        const parentNodeShapeIdentifierMintingStrategy = nodeShapeIdentifierMintingStrategy.call(this, parentNodeShape);
+        if (parentNodeShapeIdentifierMintingStrategy.isRight() &&
+            parentNodeShapeIdentifierMintingStrategy.extract().isJust()) {
+            return parentNodeShapeIdentifierMintingStrategy;
         }
-        return shapeNodeKinds(nodeShape, { defaultNodeShapeNodeKinds }).map((nodeKinds) => {
-            if (nodeKinds.has("BlankNode")) {
-                return Maybe.of("blankNode");
-            }
-            return Maybe.empty();
-        });
+    }
+    return shapeNodeKinds
+        .call(this, nodeShape, { defaultNodeShapeNodeKinds })
+        .map((nodeKinds) => {
+        if (nodeKinds.has("BlankNode")) {
+            return Maybe.of("blankNode");
+        }
+        return Maybe.empty();
     });
 }
 //# sourceMappingURL=nodeShapeIdentifierMintingStrategy.js.map

package/dist/_ShapesGraphToAstTransformer/nodeShapeTsFeatures.js

@@ -1,5 +1,6 @@
 import { Either } from "purify-ts";
 import { TS_FEATURES } from "../enums/TsFeature.js";
+import { shapeOntology } from "./shapeOntology.js";
 export function nodeShapeTsFeatures(nodeShape) {
     const tsFeaturesDefault = this.tsFeaturesDefault;
     function iriToTsFeatures(iri) {
@@ -26,7 +27,7 @@ export function nodeShapeTsFeatures(nodeShape) {
                 return ["sparql"];
         }
     }
-    return nodeShape.isDefinedBy.chain((ontologyMaybe) => {
+    return shapeOntology.call(this, nodeShape).chain((ontologyMaybe) => {
         let tsFeatureExcludes = nodeShape.tsFeatureExcludes.flatMap(iriToTsFeatures);
         let tsFeatureIncludes = nodeShape.tsFeatureIncludes.flatMap(iriToTsFeatures);
         if (tsFeatureExcludes.length === 0 && tsFeatureIncludes.length === 0) {

package/dist/_ShapesGraphToAstTransformer/shapeAstTypeName.js

@@ -1,10 +1,10 @@
 import { Curie } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 export function shapeAstTypeName(shape) {
-    if (shape.kind !== "NodeShape") {
+    if (shape.$type !== "NodeShape") {
         return Maybe.empty();
     }
-    if (shape.identifier.termType !== "NamedNode") {
+    if (shape.$identifier.termType !== "NamedNode") {
         return Maybe.empty();
     }
     // Explicit shaclmate:name
@@ -16,11 +16,11 @@ export function shapeAstTypeName(shape) {
         return shape.label;
     }
     // CURIE shape identifier
-    if (shape.identifier instanceof Curie) {
-        if (shape.identifier.hasUniqueReference) {
-            return Maybe.of(shape.identifier.reference);
+    if (shape.$identifier instanceof Curie) {
+        if (shape.$identifier.hasUniqueReference) {
+            return Maybe.of(shape.$identifier.reference);
         }
-        return Maybe.of(`${shape.identifier.prefix}_${shape.identifier.reference}`);
+        return Maybe.of(`${shape.$identifier.prefix}_${shape.$identifier.reference}`);
     }
     return Maybe.empty();
 }

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.d.ts

@@ -1,7 +1,8 @@
 import { NodeKind } from "@shaclmate/shacl-ast";
 import { Either } from "purify-ts";
 import type * as input from "../input/index.js";
-export declare function shapeNodeKinds(shape: input.Shape, options?: {
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+export declare function shapeNodeKinds(this: ShapesGraphToAstTransformer, shape: input.Shape, options?: {
     defaultNodeShapeNodeKinds: ReadonlySet<NodeKind>;
     defaultPropertyShapeNodeKinds?: ReadonlySet<NodeKind>;
 }): Either<Error, ReadonlySet<NodeKind>>;

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.js

@@ -7,34 +7,39 @@ const defaultPropertyShapeNodeKinds = new Set([
     "Literal",
 ]);
 function nodeShapeNodeKinds(nodeShape) {
-    const thisNodeKinds = nodeShape.constraints.nodeKinds;
-    return nodeShape.parentNodeShapes.chain((parentNodeShapes) => {
-        const parentNodeKinds = new Set();
-        for (const parentNodeShape of parentNodeShapes) {
-            for (const parentNodeKind of parentNodeShape.constraints.nodeKinds) {
+    const thisNodeKinds = nodeShape.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);
             }
+        });
+    }
+    if (parentNodeKinds.size > 0) {
+        if (thisNodeKinds.size === 0) {
+            return Either.of(parentNodeKinds);
         }
-        if (parentNodeKinds.size > 0) {
-            if (thisNodeKinds.size === 0) {
-                return Either.of(parentNodeKinds);
-            }
-            // 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`));
-                }
+        // 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`));
             }
         }
-        return Either.of(thisNodeKinds);
-    });
+    }
+    return Either.of(thisNodeKinds);
 }
 function propertyShapeNodeKinds(propertyShape) {
-    return Either.of(propertyShape.constraints.nodeKinds);
+    return Either.of(propertyShape.nodeKind.map(NodeKind.fromIri).orDefault(new Set()));
 }
 export function shapeNodeKinds(shape, options) {
-    return (shape.kind === "NodeShape"
-        ? nodeShapeNodeKinds(shape)
+    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();
@@ -42,14 +47,14 @@ export function shapeNodeKinds(shape, options) {
         for (const [constraint, { excludeNodeKinds, includeNodeKinds }] of [
             [
                 "sh:class",
-                shape.constraints.classes.length > 0
+                shape.classes.length > 0
                     ? { excludeNodeKinds: ["Literal"] }
                     : {},
             ],
             [
                 "sh:datatype",
                 {
-                    includeNodeKinds: shape.constraints.datatype
+                    includeNodeKinds: shape.datatype
                         .map(() => ["Literal"])
                         .orDefault([]),
                 },
@@ -57,7 +62,7 @@ export function shapeNodeKinds(shape, options) {
             [
                 "sh:defaultValue",
                 {
-                    includeNodeKinds: shape.kind === "PropertyShape"
+                    includeNodeKinds: shape.$type === "PropertyShape"
                         ? shape.defaultValue
                             .map((value) => NodeKind.fromTermType(value.termType))
                             .toList()
@@ -67,25 +72,27 @@ export function shapeNodeKinds(shape, options) {
             [
                 "sh:hasValue",
                 {
-                    includeNodeKinds: shape.constraints.hasValues.map((value) => NodeKind.fromTermType(value.termType)),
+                    includeNodeKinds: shape.hasValues.map((value) => NodeKind.fromTermType(value.termType)),
                 },
             ],
             [
                 "sh:in",
                 {
-                    includeNodeKinds: shape.constraints.in_.map((in_) => NodeKind.fromTermType(in_.termType)),
+                    includeNodeKinds: shape.in_
+                        .orDefault([])
+                        .map((in_) => NodeKind.fromTermType(in_.termType)),
                 },
             ],
             [
                 "sh:languageIn",
-                shape.constraints.languageIn.length > 0
+                shape.languageIn.orDefault([]).length > 0
                     ? { includeNodeKinds: ["Literal"] }
                     : {},
             ],
             [
                 "sh:maxExclusive",
                 {
-                    includeNodeKinds: shape.constraints.maxExclusive
+                    includeNodeKinds: shape.maxExclusive
                         .map(() => ["Literal"])
                         .orDefault([]),
                 },
@@ -93,7 +100,7 @@ export function shapeNodeKinds(shape, options) {
             [
                 "sh:maxInclusive",
                 {
-                    includeNodeKinds: shape.constraints.maxInclusive
+                    includeNodeKinds: shape.maxInclusive
                         .map(() => ["Literal"])
                         .orDefault([]),
                 },
@@ -101,7 +108,7 @@ export function shapeNodeKinds(shape, options) {
             [
                 "sh:minExclusive",
                 {
-                    includeNodeKinds: shape.constraints.minExclusive
+                    includeNodeKinds: shape.minExclusive
                         .map(() => ["Literal"])
                         .orDefault([]),
                 },
@@ -109,7 +116,7 @@ export function shapeNodeKinds(shape, options) {
             [
                 "sh:minInclusive",
                 {
-                    includeNodeKinds: shape.constraints.minInclusive
+                    includeNodeKinds: shape.minInclusive
                         .map(() => ["Literal"])
                         .orDefault([]),
                 },
@@ -162,7 +169,7 @@ export function shapeNodeKinds(shape, options) {
         if (constraintNodeKinds.size > 0) {
             return Either.of(constraintNodeKinds);
         }
-        if (shape.kind === "NodeShape") {
+        if (shape.$type === "NodeShape") {
             return Either.of(options?.defaultNodeShapeNodeKinds ?? defaultNodeShapeNodeKinds);
         }
         if (shape.path.termType === "InversePath") {

package/dist/_ShapesGraphToAstTransformer/shapeOntology.d.ts

@@ -0,0 +1,5 @@
+import { Either, Maybe } from "purify-ts";
+import type * as input from "../input/index.js";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+export declare function shapeOntology(this: ShapesGraphToAstTransformer, shape: input.Shape): Either<Error, Maybe<input.Ontology>>;
+//# sourceMappingURL=shapeOntology.d.ts.map

package/dist/_ShapesGraphToAstTransformer/shapeOntology.js

@@ -0,0 +1,25 @@
+import { Either, Maybe } from "purify-ts";
+export function shapeOntology(shape) {
+    if (shape.isDefinedBy.isJust()) {
+        // If there's an rdfs:isDefinedBy statement on the shape then don't fall back to anything else
+        return this.shapesGraph
+            .ontology(shape.isDefinedBy.unsafeCoerce())
+            .map(Maybe.of);
+    }
+    // No rdfs:isDefinedBy statement on the shape
+    const ontologies = this.shapesGraph.ontologies;
+    if (ontologies.length === 1) {
+        // If there's a single ontology in the shapes graph, consider the shape a part of the ontology
+        return Either.of(Maybe.of(ontologies[0]));
+    }
+    if (shape.$identifier.termType === "NamedNode") {
+        const prefixOntologies = ontologies.filter((ontology) => ontology.$identifier.termType === "NamedNode" &&
+            shape.$identifier.value.startsWith(ontology.$identifier.value));
+        if (prefixOntologies.length === 1) {
+            // If there's a single ontology whose IRI is a prefix of this shape's IRI, consider the shape a part of the ontology
+            return Either.of(Maybe.of(prefixOntologies[0]));
+        }
+    }
+    return Either.of(Maybe.empty());
+}
+//# sourceMappingURL=shapeOntology.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -4,6 +4,7 @@ import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import * as ast from "../ast/index.js";
 import { Eithers } from "../Eithers.js";
+import { Visibility } from "../enums/Visibility.js";
 import { ShapeStack } from "./ShapeStack.js";
 import { transformShapeToAstType } from "./transformShapeToAstType.js";
 function synthesizePartialAstObjectType({ identifierType, tsFeatures, }) {
@@ -48,13 +49,13 @@ function propertyName(objectType, propertyShape) {
     }
     // Pick up the common pattern of a property shape identifier being the node shape's identifier -localName,
     // like ex:NodeShape-property
-    if (propertyShape.identifier.termType === "NamedNode" &&
+    if (propertyShape.$identifier.termType === "NamedNode" &&
         objectType.shapeIdentifier.termType === "NamedNode") {
         const propertyShapeIdentifierPrefix = `${objectType.shapeIdentifier.value}-`;
-        if (propertyShape.identifier.value.startsWith(propertyShapeIdentifierPrefix) &&
-            propertyShape.identifier.value.length >
+        if (propertyShape.$identifier.value.startsWith(propertyShapeIdentifierPrefix) &&
+            propertyShape.$identifier.value.length >
                 propertyShapeIdentifierPrefix.length) {
-            return propertyShape.identifier.value.substring(propertyShapeIdentifierPrefix.length);
+            return propertyShape.$identifier.value.substring(propertyShapeIdentifierPrefix.length);
         }
     }
     // sh:path CURIE reference
@@ -62,12 +63,12 @@ function propertyName(objectType, propertyShape) {
         return propertyShape.path.reference;
     }
     // Shape identifier CURIE reference
-    if (propertyShape.identifier instanceof Curie) {
-        return propertyShape.identifier.reference;
+    if (propertyShape.$identifier instanceof Curie) {
+        return propertyShape.$identifier.reference;
     }
     // Shape identifier IRI
-    if (propertyShape.identifier.termType === "NamedNode") {
-        return propertyShape.identifier.value;
+    if (propertyShape.$identifier.termType === "NamedNode") {
+        return propertyShape.$identifier.value;
     }
     // sh:path IRI
     if (propertyShape.path.termType === "NamedNode") {
@@ -84,13 +85,13 @@ function transformPropertyShapeToAstType(propertyShape, shapeStack) {
     return transformShapeToAstType
         .call(this, propertyShape, shapeStack)
         .chain((propertyShapeAstType) => {
-        let maxCount = propertyShape.constraints.maxCount.orDefault(Number.MAX_SAFE_INTEGER);
-        let minCount = propertyShape.constraints.minCount.orDefault(0);
+        let maxCount = propertyShape.maxCount.orDefault(Number.MAX_SAFE_INTEGER);
+        let minCount = propertyShape.minCount.orDefault(0);
         if (minCount < 0) {
             minCount = 0;
         }
-        if (propertyShape.constraints.hasValues.length > minCount) {
-            minCount = propertyShape.constraints.hasValues.length;
+        if (propertyShape.hasValues.length > minCount) {
+            minCount = propertyShape.hasValues.length;
         }
         if (maxCount < minCount) {
             maxCount = minCount;
@@ -127,7 +128,11 @@ function transformPropertyShapeToAstType(propertyShape, shapeStack) {
 }
 export function transformPropertyShapeToAstObjectTypeProperty({ objectType, propertyShape, }) {
     const shapeStack = new ShapeStack(); // Start a new ShapeStack per property shape
-    return Eithers.chain2(propertyShape.resolve, transformPropertyShapeToAstType.call(this, propertyShape, shapeStack)).chain(([propertyShapeResolve, astType]) => {
+    return Eithers.chain2(propertyShape.resolve.isJust()
+        ? this.shapesGraph
+            .nodeShape(propertyShape.resolve.extract())
+            .map(Maybe.of)
+        : Either.of(Maybe.empty()), transformPropertyShapeToAstType.call(this, propertyShape, shapeStack)).chain(([propertyShapeResolve, astType]) => {
         let astResolveItemType;
         if (propertyShapeResolve.isJust()) {
             const astResolveTypeEither = transformShapeToAstType
@@ -196,7 +201,7 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                 comment: Maybe.empty(),
                 label: Maybe.empty(),
                 name: Maybe.empty(),
-                shapeIdentifier: propertyShape.identifier,
+                shapeIdentifier: propertyShape.$identifier,
             };
             switch (astType.kind) {
                 case "BlankNodeType":
@@ -253,9 +258,11 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
             objectType,
             order: propertyShape.order.orDefault(0),
             path: propertyShape.path,
-            shapeIdentifier: propertyShape.identifier,
+            shapeIdentifier: propertyShape.$identifier,
             type: astType,
-            visibility: propertyShape.visibility,
+            visibility: propertyShape.visibility
+                .map(Visibility.fromIri)
+                .orDefault("public"),
         }));
     });
 }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.js

@@ -11,9 +11,13 @@ import { transformShapeToAstType } from "./transformShapeToAstType.js";
 export function transformShapeToAstCompoundType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
-        return Eithers.chain4(shape.constraints.and, shape.constraints.nodes, shape.kind === "NodeShape"
+        return Eithers.chain4(Either.sequence(shape.and
+            .orDefault([])
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier))), Either.sequence(shape.nodes.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))), shape.$type === "NodeShape"
             ? nodeShapeTsFeatures.call(this, shape)
-            : Either.of(new Set()), shape.constraints.xone).chain(([andConstraintShapes, nodeConstraintShapes, tsFeatures, xoneConstraintShapes,]) => {
+            : Either.of(new Set()), Either.sequence(shape.xone
+            .orDefault([])
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([andConstraintShapes, nodeConstraintShapes, tsFeatures, xoneConstraintShapes,]) => {
             let compoundTypeKind;
             // Distinguish constraints that take arbitrary shapes from those that only take node shapes
             // With the latter we'll do special transformations.
@@ -41,7 +45,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                 comment: shape.comment,
                 label: shape.label,
                 name: shapeAstTypeName(shape),
-                shapeIdentifier: shape.identifier,
+                shapeIdentifier: shape.$identifier,
                 tsFeatures,
             });
             if (memberShapes.length === 1) {
@@ -50,7 +54,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                     .map(Maybe.of);
             }
             // Put a placeholder in the cache to deal with cyclic references
-            this.cachedAstTypesByShapeIdentifier.set(shape.identifier, compoundType);
+            this.cachedAstTypesByShapeIdentifier.set(shape.$identifier, compoundType);
             return Either.sequence(memberShapes.map((memberShape) => transformShapeToAstType.call(this, memberShape, shapeStack)))
                 .chain((memberShapeTypes) => {
                 for (let memberI = 0; memberI < memberShapes.length; memberI++) {
@@ -65,7 +69,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                     }
                     let memberDiscriminantValue;
                     if (compoundTypeKind === "UnionType") {
-                        if (memberShape.kind === "NodeShape") {
+                        if (memberShape.$type === "NodeShape") {
                             memberDiscriminantValue =
                                 memberShape.discriminantValue.extract();
                         }
@@ -84,7 +88,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                 return Either.of(Maybe.of(compoundType));
             })
                 .ifLeft(() => {
-                this.cachedAstTypesByShapeIdentifier.delete(shape.identifier);
+                this.cachedAstTypesByShapeIdentifier.delete(shape.$identifier);
             });
         });
     }