@shaclmate/compiler 4.0.13 → 4.0.14

package/dist/ShapesGraphToAstTransformer.js

@@ -21,10 +21,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());

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,18 +7,20 @@ 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) => {
+    return Either.sequence(nodeShape.ancestorClassIris.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))).chain((ancestorNodeShapes) => {
         for (const ancestorNodeShape of ancestorNodeShapes) {
             if (ancestorNodeShape.identifierMintingStrategy.isJust()) {
-                return Either.of(ancestorNodeShape.identifierMintingStrategy);
+                return Either.of(ancestorNodeShape.identifierMintingStrategy.map(IdentifierMintingStrategy.fromIri));
             }
         }
-        return shapeNodeKinds(nodeShape, { defaultNodeShapeNodeKinds }).map((nodeKinds) => {
+        return shapeNodeKinds
+            .call(this, nodeShape, { defaultNodeShapeNodeKinds })
+            .map((nodeKinds) => {
             if (nodeKinds.has("BlankNode")) {
                 return Maybe.of("blankNode");
             }

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,11 +7,15 @@ const defaultPropertyShapeNodeKinds = new Set([
     "Literal",
 ]);
 function nodeShapeNodeKinds(nodeShape) {
-    const thisNodeKinds = nodeShape.constraints.nodeKinds;
-    return nodeShape.parentNodeShapes.chain((parentNodeShapes) => {
+    const thisNodeKinds = nodeShape.nodeKind
+        .map(NodeKind.fromIri)
+        .orDefault(new Set());
+    return Either.sequence(nodeShape.parentClassIris.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))).chain((parentNodeShapes) => {
         const parentNodeKinds = new Set();
         for (const parentNodeShape of parentNodeShapes) {
-            for (const parentNodeKind of parentNodeShape.constraints.nodeKinds) {
+            for (const parentNodeKind of parentNodeShape.nodeKind
+                .map(NodeKind.fromIri)
+                .orDefault(new Set())) {
                 parentNodeKinds.add(parentNodeKind);
             }
         }
@@ -30,11 +34,11 @@ function nodeShapeNodeKinds(nodeShape) {
     });
 }
 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 +46,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 +61,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 +71,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 +99,7 @@ export function shapeNodeKinds(shape, options) {
             [
                 "sh:maxInclusive",
                 {
-                    includeNodeKinds: shape.constraints.maxInclusive
+                    includeNodeKinds: shape.maxInclusive
                         .map(() => ["Literal"])
                         .orDefault([]),
                 },
@@ -101,7 +107,7 @@ export function shapeNodeKinds(shape, options) {
             [
                 "sh:minExclusive",
                 {
-                    includeNodeKinds: shape.constraints.minExclusive
+                    includeNodeKinds: shape.minExclusive
                         .map(() => ["Literal"])
                         .orDefault([]),
                 },
@@ -109,7 +115,7 @@ export function shapeNodeKinds(shape, options) {
             [
                 "sh:minInclusive",
                 {
-                    includeNodeKinds: shape.constraints.minInclusive
+                    includeNodeKinds: shape.minInclusive
                         .map(() => ["Literal"])
                         .orDefault([]),
                 },
@@ -162,7 +168,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,9 @@ 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.flatMap((and) => and.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.flatMap((xone) => xone.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 +41,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 +50,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 +65,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 +84,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                 return Either.of(Maybe.of(compoundType));
             })
                 .ifLeft(() => {
-                this.cachedAstTypesByShapeIdentifier.delete(shape.identifier);
+                this.cachedAstTypesByShapeIdentifier.delete(shape.$identifier);
             });
         });
     }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -42,14 +42,14 @@ const astListTypePlaceholderItemType = new ast.BlankNodeType({
 export function transformShapeToAstListType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
-        if (shape.kind !== "NodeShape") {
+        if (shape.$type !== "NodeShape") {
             return Either.of(Maybe.empty());
         }
         const nodeShape = shape;
         if (!nodeShape.isList) {
             return Either.of(Maybe.empty());
         }
-        return Eithers.chain3(nodeShapeIdentifierMintingStrategy(nodeShape), shapeNodeKinds(nodeShape, { defaultNodeShapeNodeKinds }), nodeShape.constraints.xone).chain(([identifierMintingStrategy, nodeKinds, xone]) => {
+        return Eithers.chain3(nodeShapeIdentifierMintingStrategy.call(this, nodeShape), shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.xone.flatMap((xone) => xone.map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier))))).chain(([identifierMintingStrategy, nodeKinds, xone]) => {
             // Put a placeholder in the cache to deal with cyclic references
             // Remove the placeholder if the transformation fails.
             const listType = new ast.ListType({
@@ -60,27 +60,27 @@ export function transformShapeToAstListType(shape, shapeStack) {
                 mutable: nodeShape.mutable.orDefault(false),
                 name: shapeAstTypeName(nodeShape),
                 identifierMintingStrategy,
-                shapeIdentifier: nodeShape.identifier,
+                shapeIdentifier: nodeShape.$identifier,
                 toRdfTypes: nodeShape.toRdfTypes,
             });
-            this.cachedAstTypesByShapeIdentifier.set(nodeShape.identifier, listType);
+            this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier, listType);
             return (() => {
                 let emptyListShape;
                 let nonEmptyListShape;
                 for (const shape of xone) {
-                    if (shape.constraints.hasValues.length === 1 &&
-                        shape.constraints.hasValues[0].equals(rdf.nil)) {
+                    if (shape.hasValues.length === 1 &&
+                        shape.hasValues[0].equals(rdf.nil)) {
                         emptyListShape = shape;
                     }
-                    else if (shape.kind === "NodeShape" &&
-                        shape.constraints.properties.orDefault([]).length >= 2) {
+                    else if (shape.$type === "NodeShape" &&
+                        shape.properties.length >= 2) {
                         nonEmptyListShape = shape;
                     }
                 }
                 if (!emptyListShape || !nonEmptyListShape) {
                     return Left(new Error(`${nodeShape} does not have an sh:xone with exactly two shapes, one for the empty list and one for the non-empty list`));
                 }
-                return nonEmptyListShape.constraints.properties.chain((nonEmptyListShapeProperties) => {
+                return Either.sequence(nonEmptyListShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))).chain((nonEmptyListShapeProperties) => {
                     let firstPropertyShape;
                     let restPropertyShape;
                     for (const propertyShape of nonEmptyListShapeProperties) {
@@ -97,15 +97,15 @@ export function transformShapeToAstListType(shape, shapeStack) {
                     if (!firstPropertyShape) {
                         return Left(new Error(`${nodeShape} has a non-empty list shape without an sh:property shape whose sh:path is rdf:first`));
                     }
-                    if (firstPropertyShape.constraints.maxCount.extract() !== 1 ||
-                        firstPropertyShape.constraints.minCount.extract() !== 1) {
+                    if (firstPropertyShape.maxCount.extract() !== 1 ||
+                        firstPropertyShape.minCount.extract() !== 1) {
                         return Left(new Error(`${nodeShape} non-empty list shape rdf:first property shape does not have sh:maxCount=1 and/or sh:minCount=1`));
                     }
                     if (!restPropertyShape) {
                         return Left(new Error(`${nodeShape} has a non-empty list shape without an sh:property shape whose sh:path is rdf:rest`));
                     }
-                    if (restPropertyShape.constraints.maxCount.extract() !== 1 ||
-                        restPropertyShape.constraints.minCount.extract() !== 1) {
+                    if (restPropertyShape.maxCount.extract() !== 1 ||
+                        restPropertyShape.minCount.extract() !== 1) {
                         return Left(new Error(`${nodeShape} non-empty list shape rdf:rest property shape does not have sh:maxCount=1 and/or sh:minCount=1`));
                     }
                     return transformPropertyShapeToAstObjectTypeProperty
@@ -127,7 +127,7 @@ export function transformShapeToAstListType(shape, shapeStack) {
                         })
                             .chain((restProperty) => {
                             if (restProperty.type.kind !== "ListType" ||
-                                !restProperty.type.shapeIdentifier.equals(nodeShape.identifier)) {
+                                !restProperty.type.shapeIdentifier.equals(nodeShape.$identifier)) {
                                 return Left(new Error(`${nodeShape} rdf:rest property is not recursive into the node shape`));
                             }
                             return Either.of(Maybe.of(listType));
@@ -135,7 +135,7 @@ export function transformShapeToAstListType(shape, shapeStack) {
                     });
                 });
             })().ifLeft(() => {
-                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.identifier);
+                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.$identifier);
             });
         });
     }