@shaclmate/compiler 3.0.4 → 4.0.0

package/dist/_ShapesGraphToAstTransformer/transformNodeShapeToAstType.js

@@ -1,139 +1,203 @@
+import dataFactory from "@rdfjs/data-model";
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
-import * as input from "../input/index.js";
+import * as ast from "../ast/index.js";
+import { Eithers } from "../Eithers.js";
 import { tsFeaturesDefault } from "../input/tsFeatures.js";
-import { logger } from "../logger.js";
-import { flattenAstObjectCompositeTypeMemberTypes } from "./flattenAstObjectCompositeTypeMemberTypes.js";
-import { pickLiteral } from "./pickLiteral.js";
+import { nodeShapeIdentifierMintingStrategy } from "./nodeShapeIdentifierMintingStrategy.js";
+import { nodeShapeTsFeatures } from "./nodeShapeTsFeatures.js";
+import { shapeNodeKinds } from "./shapeNodeKinds.js";
+const defaultNodeShapeNodeKinds = new Set([
+    "BlankNode",
+    "IRI",
+]);
+function isObjectTypePropertyRequired(property) {
+    switch (property.type.kind) {
+        case "DefaultValueType":
+            return false;
+        case "LazyObjectOptionType":
+            return false;
+        case "LazyObjectSetType":
+            return property.type.partialType.minCount > 0;
+        case "OptionType":
+            return false;
+        case "SetType":
+            return property.type.minCount > 0;
+        case "UnionType":
+            return property.type.memberTypes.every((memberType) => isObjectTypePropertyRequired({ type: memberType }));
+        case "BlankNodeType":
+        case "IdentifierType":
+        case "IriType":
+        case "LazyObjectType":
+        case "ListType":
+        case "LiteralType":
+        case "ObjectType":
+        case "ObjectUnionType":
+        case "PlaceholderType":
+        case "TermType":
+            return true;
+        case "IntersectionType":
+        case "ObjectIntersectionType":
+            throw new Error("unsupported");
+        default:
+            property.type;
+            throw new Error("should never reach this point");
+    }
+}
+const listPropertiesObjectType = new ast.ObjectType({
+    abstract: false,
+    export_: false,
+    extern: false,
+    comment: Maybe.empty(),
+    label: Maybe.empty(),
+    identifierMintingStrategy: Maybe.empty(),
+    identifierType: new ast.IdentifierType({
+        comment: Maybe.empty(),
+        label: Maybe.empty(),
+    }),
+    fromRdfType: Maybe.empty(),
+    name: Maybe.empty(),
+    toRdfTypes: [],
+    tsFeatures: new Set([]),
+    tsObjectDeclarationType: "class",
+    shapeIdentifier: dataFactory.blankNode(),
+    synthetic: true,
+    tsImports: [],
+});
 /**
  * Is an ast.ObjectType actually the shape of an RDF list?
  * If so, return the type of its rdf:first.
  */
 function transformNodeShapeToAstListType(nodeShape) {
     invariant(nodeShape.isList);
-    // Put a placeholder in the cache to deal with cyclic references
-    const listType = {
-        comment: pickLiteral(nodeShape.comments).map((literal) => literal.value),
-        identifierNodeKind: nodeShape.nodeKinds.has("BlankNode")
-            ? "BlankNode"
-            : "NamedNode",
-        itemType: {
-            kind: "PlaceholderType",
-        },
-        kind: "ListType",
-        label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
-        mutable: nodeShape.mutable,
-        name: this.shapeAstName(nodeShape),
-        identifierMintingStrategy: nodeShape.identifierMintingStrategy,
-        toRdfTypes: nodeShape.toRdfTypes,
-    };
-    this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, listType);
-    const properties = [];
-    for (const propertyShape of nodeShape.constraints.properties) {
-        const propertyEither = this.transformPropertyShapeToAstObjectTypeProperty(propertyShape);
-        if (propertyEither.isLeft()) {
-            logger.warn("error transforming %s %s: %s", nodeShape, propertyShape, propertyEither.extract().message);
-            continue;
-            // return property;
-        }
-        properties.push(propertyEither.unsafeCoerce());
-    }
-    if (properties.length !== 2) {
-        return Left(new Error(`${nodeShape} does not have exactly two properties`));
-    }
-    // rdf:first can have any type
-    // The type of the rdf:first property is the list item type.
-    const firstProperty = properties.find((property) => property.path.iri.equals(rdf.first));
-    if (!firstProperty) {
-        return Left(new Error(`${nodeShape} does not have an rdf:first property`));
-    }
-    const restProperty = properties.find((property) => property.path.iri.equals(rdf.rest));
-    if (!restProperty) {
-        return Left(new Error(`${nodeShape} does not have an rdf:rest property`));
-    }
-    if (restProperty.type.kind !== "UnionType") {
-        return Left(new Error(`${nodeShape} rdf:rest property is not sh:xone`));
-    }
-    if (restProperty.type.memberTypes.length !== 2) {
-        return Left(new Error(`${nodeShape} rdf:rest property sh:xone does not have exactly two member types`));
-    }
-    // rdf:rest should be sh:xone ( [ sh:class nodeShape ] [ sh:hasValue rdf:nil ] )
-    if (!restProperty.type.memberTypes.find((type) => type.kind === "ListType" &&
-        type.name.identifier.equals(nodeShape.identifier))) {
-        return Left(new Error(`${nodeShape} rdf:rest property sh:xone is not recursive into the node shape`));
-    }
-    if (!restProperty.type.memberTypes.find((type) => type.kind === "IdentifierType")) {
-        return Left(new Error(`${nodeShape} rdf:rest property sh:xone does not include sh:hasValue rdf:nil`));
-    }
-    listType.itemType = firstProperty.type;
-    return Either.of(listType);
+    return Eithers.chain3(nodeShapeIdentifierMintingStrategy(nodeShape), shapeNodeKinds(nodeShape, { defaultNodeShapeNodeKinds }), nodeShape.constraints.xone).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({
+            comment: nodeShape.comment,
+            identifierNodeKind: nodeKinds.has("BlankNode") ? "BlankNode" : "IRI",
+            itemType: ast.PlaceholderType.instance,
+            label: nodeShape.label,
+            mutable: nodeShape.mutable.orDefault(false),
+            identifierMintingStrategy,
+            shapeIdentifier: this.shapeIdentifier(nodeShape),
+            toRdfTypes: nodeShape.toRdfTypes,
+        });
+        this.nodeShapeAstTypesByIdentifier.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)) {
+                    emptyListShape = shape;
+                }
+                else if (shape.kind === "NodeShape" &&
+                    shape.constraints.properties.orDefault([]).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) => {
+                let firstPropertyShape;
+                let restPropertyShape;
+                for (const propertyShape of nonEmptyListShapeProperties) {
+                    if (propertyShape.path.termType !== "NamedNode") {
+                        continue;
+                    }
+                    if (propertyShape.path.equals(rdf.first)) {
+                        firstPropertyShape = propertyShape;
+                    }
+                    else if (propertyShape.path.equals(rdf.rest)) {
+                        restPropertyShape = propertyShape;
+                    }
+                }
+                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) {
+                    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) {
+                    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 this.transformPropertyShapeToAstObjectTypeProperty({
+                    // Just need a dummy ast.ObjectType here to get the properties transformed.
+                    objectType: listPropertiesObjectType,
+                    propertyShape: firstPropertyShape,
+                }).chain((firstProperty) => {
+                    if (!ast.ListType.isItemType(firstProperty.type)) {
+                        return Left(new Error(`${nodeShape}: ${firstProperty.type.kind} is not a valid list item type`));
+                    }
+                    listType.itemType = firstProperty.type;
+                    return this.transformPropertyShapeToAstObjectTypeProperty({
+                        // Just need a dummy ast.ObjectType here to get the properties transformed.
+                        objectType: listPropertiesObjectType,
+                        propertyShape: restPropertyShape,
+                    }).chain((restProperty) => {
+                        if (restProperty.type.kind !== "ListType" ||
+                            !restProperty.type.shapeIdentifier.equals(nodeShape.identifier)) {
+                            return Left(new Error(`${nodeShape} rdf:rest property is not recursive into the node shape`));
+                        }
+                        return Either.of(listType);
+                    });
+                });
+            });
+        })().ifLeft(() => {
+            this.nodeShapeAstTypesByIdentifier.delete(nodeShape.identifier);
+        });
+    });
 }
-export function transformNodeShapeToAstObjectCompositeType({ export_, nodeShape, }) {
-    let compositeTypeShapes;
-    let compositeTypeKind;
-    if (nodeShape.constraints.and.length > 0) {
-        compositeTypeShapes = nodeShape.constraints.and;
-        compositeTypeKind = "ObjectIntersectionType";
-    }
-    else if (nodeShape.constraints.xone.length > 0) {
-        compositeTypeShapes = nodeShape.constraints.xone;
-        compositeTypeKind = "ObjectUnionType";
-    }
-    else {
-        throw new Error("should never be reached");
-    }
-    const compositeTypeNodeShapes = [];
-    for (const compositeTypeShape of compositeTypeShapes) {
-        if (!(compositeTypeShape instanceof input.NodeShape)) {
-            return Left(new Error(`${nodeShape} has non-NodeShape in its logical constraint`));
+export function transformNodeShapeToAstObjectCompoundType({ export_, nodeShape, }) {
+    return Eithers.chain3(nodeShape.constraints.and, nodeShapeTsFeatures(nodeShape), nodeShape.constraints.xone).chain(([andShapes, tsFeatures, xoneShapes]) => {
+        let compoundTypeShapes;
+        let compoundTypeKind;
+        if (andShapes.length > 0) {
+            compoundTypeShapes = andShapes;
+            compoundTypeKind = "ObjectIntersectionType";
         }
-        compositeTypeNodeShapes.push(compositeTypeShape);
-    }
-    if (compositeTypeNodeShapes.length === 0) {
-        return Left(new Error(`${nodeShape} has no NodeShapes in its logical constraint`));
-    }
-    // Put a placeholder in the cache to deal with cyclic references
-    const compositeType = {
-        comment: pickLiteral(nodeShape.comments).map((literal) => literal.value),
-        export: export_,
-        kind: compositeTypeKind,
-        label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
-        memberTypes: [],
-        name: this.shapeAstName(nodeShape),
-        tsFeatures: new Set(),
-    };
-    this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, compositeType);
-    const memberTypes = [];
-    for (const memberNodeShape of compositeTypeNodeShapes) {
-        const memberTypeEither = this.transformNodeShapeToAstType(memberNodeShape);
-        if (memberTypeEither.isLeft()) {
-            return memberTypeEither;
+        else if (xoneShapes.length > 0) {
+            compoundTypeShapes = xoneShapes;
+            compoundTypeKind = "ObjectUnionType";
         }
-        const memberType = memberTypeEither.unsafeCoerce();
-        switch (memberType.kind) {
-            case "ObjectType":
-            case "ObjectIntersectionType":
-            case "ObjectUnionType":
-                memberTypes.push(memberType);
-                break;
-            default:
-                return Left(new Error(`${nodeShape} has one or more non-ObjectType node shapes in its logical constraint`));
+        else {
+            throw new Error("should never be reached");
         }
-    }
-    return flattenAstObjectCompositeTypeMemberTypes({
-        objectCompositeTypeKind: compositeTypeKind,
-        memberTypes,
-        shape: nodeShape,
-    }).map(({ memberTypes, tsFeatures }) => {
-        // Add to the placeholder composite type and return it.
-        for (const memberType of memberTypes) {
-            compositeType.memberTypes.push(memberType);
+        const compoundTypeNodeShapes = [];
+        for (const compoundTypeShape of compoundTypeShapes) {
+            if (compoundTypeShape.kind !== "NodeShape") {
+                return Left(new Error(`${nodeShape} has non-NodeShape in its logical constraint`));
+            }
+            compoundTypeNodeShapes.push(compoundTypeShape);
         }
-        for (const tsFeature of tsFeatures) {
-            compositeType.tsFeatures.add(tsFeature);
+        if (compoundTypeNodeShapes.length === 0) {
+            return Left(new Error(`${nodeShape} has no NodeShapes in its logical constraint`));
         }
-        return compositeType;
+        // Put a placeholder in the cache to deal with cyclic references
+        const compoundType = new (compoundTypeKind === "ObjectIntersectionType"
+            ? ast.ObjectIntersectionType
+            : ast.ObjectUnionType)({
+            comment: nodeShape.comment,
+            export_,
+            label: nodeShape.label,
+            name: nodeShape.shaclmateName,
+            shapeIdentifier: this.shapeIdentifier(nodeShape),
+            tsFeatures,
+        });
+        this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, compoundType);
+        return Either.sequence(compoundTypeNodeShapes.map((memberNodeShape) => this.transformNodeShapeToAstType(memberNodeShape).chain((memberType) => compoundType.addMemberType(memberType))))
+            .map(() => compoundType)
+            .ifLeft(() => {
+            this.nodeShapeAstTypesByIdentifier.delete(nodeShape.identifier);
+        });
     });
 }
 export function transformNodeShapeToAstType(nodeShape) {
@@ -146,123 +210,130 @@ export function transformNodeShapeToAstType(nodeShape) {
     if (nodeShape.isList) {
         return transformNodeShapeToAstListType.bind(this)(nodeShape);
     }
-    const export_ = nodeShape.export.orDefault(true);
-    if (nodeShape.constraints.and.length > 0 ||
-        nodeShape.constraints.xone.length > 0) {
-        return transformNodeShapeToAstObjectCompositeType.bind(this)({
-            export_,
-            nodeShape,
-        });
-    }
-    const fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
-    const toRdfTypes = nodeShape.toRdfTypes.concat();
-    if (toRdfTypes.length === 0) {
-        toRdfTypes.push(...nodeShape.rdfType.toList());
-    }
-    // Ensure toRdfTypes has fromRdfType
-    fromRdfType.ifJust((fromRdfType) => {
-        if (!toRdfTypes.some((toRdfType) => toRdfType.equals(fromRdfType))) {
-            toRdfTypes.push(fromRdfType);
+    return Eithers.chain11(nodeShape.ancestorNodeShapes, nodeShape.childNodeShapes, nodeShape.descendantNodeShapes, nodeShape.parentNodeShapes, nodeShape.constraints.and, nodeShapeIdentifierMintingStrategy(nodeShape), shapeNodeKinds(nodeShape, { defaultNodeShapeNodeKinds }), nodeShape.constraints.properties, nodeShapeTsFeatures(nodeShape), nodeShape.tsObjectDeclarationType.isJust()
+        ? Either.of(nodeShape.tsObjectDeclarationType)
+        : nodeShape.isDefinedBy.map((ontology) => ontology.chain((ontology) => ontology.tsObjectDeclarationType)), nodeShape.constraints.xone).chain(([ancestorNodeShapes, childNodeShapes, descendantNodeShapes, parentNodeShapes, andShapes, identifierMintingStrategy, nodeKinds, propertyShapes, tsFeatures, tsObjectDeclarationType, xoneShapes,]) => {
+        const abstract = nodeShape.abstract.orDefault(false);
+        const export_ = nodeShape.export.orDefault(true);
+        if (andShapes.length > 0 || xoneShapes.length > 0) {
+            return transformNodeShapeToAstObjectCompoundType.bind(this)({
+                export_,
+                nodeShape,
+            });
         }
-    });
-    const identifierIn = nodeShape.constraints.in_.filter((term) => term.termType === "NamedNode");
-    // Put a placeholder in the cache to deal with cyclic references
-    // If this node shape's properties (directly or indirectly) refer to the node shape itself,
-    // we'll return this placeholder.
-    const objectType = {
-        abstract: nodeShape.abstract.orDefault(false),
-        ancestorObjectTypes: [],
-        childObjectTypes: [],
-        comment: pickLiteral(nodeShape.comments).map((literal) => literal.value),
-        descendantObjectTypes: [],
-        export: export_,
-        extern: nodeShape.extern.orDefault(false),
-        fromRdfType,
-        label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
-        kind: "ObjectType",
-        identifierIn,
-        identifierMintingStrategy: identifierIn.length === 0
-            ? nodeShape.identifierMintingStrategy
-            : Maybe.empty(),
-        identifierNodeKinds: identifierIn.length === 0 ? nodeShape.nodeKinds : new Set(["NamedNode"]),
-        name: this.shapeAstName(nodeShape),
-        properties: [], // This is mutable, we'll populate it below.
-        parentObjectTypes: [], // This is mutable, we'll populate it below
-        synthetic: false,
-        toRdfTypes,
-        tsFeatures: nodeShape.tsFeatures.orDefault(new Set(tsFeaturesDefault)),
-        tsImports: nodeShape.tsImports,
-        tsObjectDeclarationType: nodeShape.tsObjectDeclarationType.orDefault("class"),
-    };
-    this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, objectType);
-    // Populate ancestor and descendant object types
-    const relatedObjectTypes = (relatedNodeShapes) => {
-        return relatedNodeShapes.flatMap((relatedNodeShape) => this.transformNodeShapeToAstType(relatedNodeShape)
-            .toMaybe()
-            .filter((astType) => astType.kind === "ObjectType")
-            .toList());
-    };
-    objectType.ancestorObjectTypes.push(...relatedObjectTypes(nodeShape.ancestorNodeShapes));
-    objectType.childObjectTypes.push(...relatedObjectTypes(nodeShape.childNodeShapes));
-    objectType.descendantObjectTypes.push(...relatedObjectTypes(nodeShape.descendantNodeShapes));
-    objectType.parentObjectTypes.push(...relatedObjectTypes(nodeShape.parentNodeShapes));
-    // Populate properties
-    // Check whether a type refers to this ObjectType
-    const isPropertyRecursive = (astType) => {
-        switch (astType.kind) {
-            case "IdentifierType":
-            case "LiteralType":
-            case "PlaceholderType":
-            case "TermType":
-                return false;
-            case "ObjectType":
-                if (astType.name === objectType.name) {
-                    return true;
-                }
-                for (const property of astType.properties) {
-                    if (isPropertyRecursive(property.type)) {
-                        return true;
-                    }
-                }
-                return false;
-            case "IntersectionType":
-            case "ObjectIntersectionType":
-            case "ObjectUnionType":
-            case "UnionType":
-                for (const memberType of astType.memberTypes) {
-                    if (isPropertyRecursive(memberType)) {
-                        return true;
-                    }
+        let fromRdfType;
+        let toRdfTypes;
+        if (!abstract) {
+            fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
+            if (nodeShape.isClass &&
+                nodeShape.identifier.termType === "NamedNode") {
+                fromRdfType = fromRdfType.alt(Maybe.of(nodeShape.identifier));
+            }
+            toRdfTypes = nodeShape.toRdfTypes.concat();
+            if (toRdfTypes.length === 0) {
+                toRdfTypes.push(...nodeShape.rdfType.toList());
+            }
+            // Ensure toRdfTypes has fromRdfType
+            fromRdfType.ifJust((fromRdfType) => {
+                if (!toRdfTypes.some((toRdfType) => toRdfType.equals(fromRdfType))) {
+                    toRdfTypes.push(fromRdfType);
                 }
-                return false;
-            case "ListType":
-            case "OptionType":
-            case "SetType":
-                return isPropertyRecursive(astType.itemType);
+            });
         }
-    };
-    for (const propertyShape of nodeShape.constraints.properties) {
-        const propertyEither = this.transformPropertyShapeToAstObjectTypeProperty(propertyShape);
-        if (propertyEither.isLeft()) {
-            logger.warn("error transforming %s %s: %s", nodeShape, propertyShape, propertyEither.extract().message);
-            continue;
-            // return property;
+        else {
+            fromRdfType = Maybe.empty();
+            toRdfTypes = [];
         }
-        const property = propertyEither.unsafeCoerce();
-        objectType.properties.push({
-            ...property,
-            recursive: isPropertyRecursive(property.type),
-        });
-    }
-    objectType.properties.sort((left, right) => {
-        if (left.order < right.order) {
-            return -1;
+        if (nodeKinds.has("Literal")) {
+            return Left(new Error(`${nodeShape} should not have a nodeKind "Literal"`));
+        }
+        let identifierType;
+        if (nodeKinds.size === 2) {
+            invariant(nodeShape.identifierIn.length === 0);
+            identifierType = new ast.IdentifierType({
+                comment: Maybe.empty(),
+                label: Maybe.empty(),
+            });
         }
-        if (left.order > right.order) {
-            return 1;
+        else {
+            switch ([...nodeKinds][0]) {
+                case "BlankNode":
+                    invariant(nodeShape.identifierIn.length === 0);
+                    identifierType = new ast.BlankNodeType({
+                        comment: Maybe.empty(),
+                        label: Maybe.empty(),
+                    });
+                    break;
+                case "IRI":
+                    identifierType = new ast.IriType({
+                        comment: Maybe.empty(),
+                        hasValues: [],
+                        in_: nodeShape.identifierIn,
+                        label: Maybe.empty(),
+                    });
+                    break;
+                case "Literal":
+                    throw new Error("should never happen");
+            }
         }
-        return 0;
+        // Put a placeholder in the cache to deal with cyclic references
+        // Remove the placeholder if the transformation fails.
+        // If this node shape's properties (directly or indirectly) refer to the node shape itself,
+        // we'll return this placeholder.
+        const objectType = new ast.ObjectType({
+            abstract,
+            comment: nodeShape.comment,
+            export_: export_,
+            extern: nodeShape.extern.orDefault(false),
+            fromRdfType,
+            label: nodeShape.label,
+            identifierType,
+            identifierMintingStrategy,
+            name: nodeShape.shaclmateName,
+            shapeIdentifier: this.shapeIdentifier(nodeShape),
+            synthetic: false,
+            toRdfTypes,
+            tsFeatures: tsFeatures.orDefault(new Set(tsFeaturesDefault)),
+            tsImports: nodeShape.tsImports,
+            tsObjectDeclarationType: tsObjectDeclarationType.orDefault("class"),
+        });
+        this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, objectType);
+        return (() => {
+            // Populate ancestor and descendant object types
+            const relatedObjectTypes = (relatedNodeShapes) => {
+                return relatedNodeShapes.flatMap((relatedNodeShape) => this.transformNodeShapeToAstType(relatedNodeShape)
+                    .toMaybe()
+                    .filter((astType) => astType.kind === "ObjectType")
+                    .toList());
+            };
+            objectType.addAncestorObjectTypes(...relatedObjectTypes(ancestorNodeShapes));
+            objectType.addChildObjectTypes(...relatedObjectTypes(childNodeShapes));
+            objectType.addDescendantObjectTypes(...relatedObjectTypes(descendantNodeShapes));
+            objectType.addParentObjectTypes(...relatedObjectTypes(parentNodeShapes));
+            // Populate properties
+            for (const propertyShape of propertyShapes) {
+                const propertyEither = this.transformPropertyShapeToAstObjectTypeProperty({
+                    objectType,
+                    propertyShape,
+                });
+                if (propertyEither.isLeft()) {
+                    return propertyEither;
+                }
+                propertyEither.ifRight((property) => {
+                    objectType.addProperties(property);
+                });
+            }
+            if (!objectType.abstract &&
+                !objectType.extern &&
+                objectType.fromRdfType.isNothing() &&
+                !objectType.properties.some(isObjectTypePropertyRequired)) {
+                return Left(new Error(`${nodeShape} has no required properties and no implicitly required rdf:type`));
+            }
+            objectType.sortProperties();
+            return Either.of(objectType);
+        })().ifLeft(() => {
+            this.nodeShapeAstTypesByIdentifier.delete(nodeShape.identifier);
+        });
     });
-    return Either.of(objectType);
 }
 //# sourceMappingURL=transformNodeShapeToAstType.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.d.ts

@@ -1,6 +1,9 @@
 import { Either } from "purify-ts";
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-import type * as ast from "../ast/index.js";
+import * as ast from "../ast/index.js";
 import type * as input from "../input/index.js";
-export declare function transformPropertyShapeToAstObjectTypeProperty(this: ShapesGraphToAstTransformer, propertyShape: input.PropertyShape): Either<Error, ast.ObjectType.Property>;
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+export declare function transformPropertyShapeToAstObjectTypeProperty(this: ShapesGraphToAstTransformer, { objectType, propertyShape, }: {
+    objectType: ast.ObjectType;
+    propertyShape: input.PropertyShape;
+}): Either<Error, ast.ObjectType.Property>;
 //# sourceMappingURL=transformPropertyShapeToAstObjectTypeProperty.d.ts.map