@shaclmate/compiler 4.0.18 → 4.0.20

package/dist/Compiler.d.ts

@@ -1,12 +1,15 @@
 import type { Either } from "purify-ts";
+import type { Logger } from "ts-log";
 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;
+    private readonly logger;
     private readonly tsFeaturesDefault?;
-    constructor({ generator, }: {
+    constructor({ generator, logger, }: {
         generator: Generator;
+        logger: Logger;
         tsFeaturesDefault?: ReadonlySet<TsFeature>;
     });
     compile(shapesGraph: ShapesGraph): Either<Error, string>;

package/dist/Compiler.js

@@ -1,12 +1,15 @@
 import { ShapesGraphToAstTransformer } from "./ShapesGraphToAstTransformer.js";
 export class Compiler {
     generator;
+    logger;
     tsFeaturesDefault;
-    constructor({ generator, }) {
+    constructor({ generator, logger, }) {
         this.generator = generator;
+        this.logger = logger;
     }
     compile(shapesGraph) {
         return new ShapesGraphToAstTransformer({
+            logger: this.logger,
             shapesGraph,
             tsFeaturesDefault: this.tsFeaturesDefault,
         })

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -1,6 +1,7 @@
 import TermMap from "@rdfjs/term-map";
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { Either } from "purify-ts";
+import type { Logger } from "ts-log";
 import type * as ast from "./ast/index.js";
 import type { TsFeature } from "./enums/TsFeature.js";
 import type * as input from "./input/index.js";
@@ -12,10 +13,12 @@ interface RelatedNodeShapes {
 }
 export declare class ShapesGraphToAstTransformer {
     protected readonly cachedAstTypesByShapeIdentifier: TermMap<BlankNode | NamedNode, ast.Type>;
+    protected readonly logger: Logger;
     protected readonly shapesGraph: input.ShapesGraph;
     protected readonly relatedNodeShapesByIdentifier: TermMap<BlankNode | NamedNode, RelatedNodeShapes>;
     protected tsFeaturesDefault: ReadonlySet<TsFeature>;
-    constructor({ shapesGraph, tsFeaturesDefault, }: {
+    constructor({ logger, shapesGraph, tsFeaturesDefault, }: {
+        logger: Logger;
         shapesGraph: input.ShapesGraph;
         tsFeaturesDefault?: ReadonlySet<TsFeature>;
     });

package/dist/ShapesGraphToAstTransformer.js

@@ -1,12 +1,10 @@
 import TermMap from "@rdfjs/term-map";
-import { Resource } from "@rdfx/resource";
 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";
-import { logger } from "./logger.js";
-function relatedNodeShapes(shapesGraph) {
+function relatedNodeShapes({ logger, shapesGraph, }) {
     const immediateRelatedNodeShapes = new TermMap();
     for (const childNodeShape of shapesGraph.nodeShapes) {
         let childRelatedNodeShapes = immediateRelatedNodeShapes.get(childNodeShape.$identifier);
@@ -21,7 +19,7 @@ function relatedNodeShapes(shapesGraph) {
             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);
+                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);
@@ -76,11 +74,16 @@ function relatedNodeShapes(shapesGraph) {
 export class ShapesGraphToAstTransformer {
     // Members are protected so they're accessible to functions in other files
     cachedAstTypesByShapeIdentifier = new TermMap();
+    logger;
     shapesGraph;
     relatedNodeShapesByIdentifier = new TermMap();
     tsFeaturesDefault;
-    constructor({ shapesGraph, tsFeaturesDefault, }) {
-        this.relatedNodeShapesByIdentifier = relatedNodeShapes(shapesGraph);
+    constructor({ logger, shapesGraph, tsFeaturesDefault, }) {
+        this.logger = logger;
+        this.relatedNodeShapesByIdentifier = relatedNodeShapes({
+            logger: this.logger,
+            shapesGraph,
+        });
         this.shapesGraph = shapesGraph;
         this.tsFeaturesDefault =
             tsFeaturesDefault ??

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -1,4 +1,4 @@
-import dataFactory from "@rdfjs/data-model";
+import dataFactory from "@rdfx/data-factory";
 import { Curie } from "@shaclmate/shacl-ast";
 import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -1,4 +1,4 @@
-import dataFactory from "@rdfjs/data-model";
+import dataFactory from "@rdfx/data-factory";
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Either, Left, Maybe } from "purify-ts";
 import * as ast from "../ast/index.js";

package/dist/ast/AbstractCollectionType.d.ts

@@ -12,6 +12,16 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
         mutable: boolean;
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
     equals(other: AbstractCollectionType<ItemTypeT>): boolean;
+    toJSON(): {
+        mutable: boolean | undefined;
+        itemType: any;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+    };
 }
 export declare namespace AbstractCollectionType {
     type ItemType = AbstractContainerType.ItemType;

package/dist/ast/AbstractCollectionType.js

@@ -20,6 +20,12 @@ export class AbstractCollectionType extends AbstractContainerType {
         }
         return true;
     }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            mutable: this.mutable ? true : undefined,
+        };
+    }
 }
 (function (AbstractCollectionType) {
     AbstractCollectionType.isItemType = AbstractContainerType.isItemType;

package/dist/ast/AbstractCompoundType.d.ts

@@ -31,7 +31,6 @@ export declare abstract class AbstractCompoundType<MemberT extends AbstractCompo
     get tsFeatures(): ReadonlySet<TsFeature>;
     addMember(member: MemberT): void;
     equals(other: AbstractCompoundType<MemberT, MemberTypeT>): boolean;
-    toString(): string;
 }
 export declare namespace AbstractCompoundType {
     interface Member<TypeT extends MemberType> {

package/dist/ast/AbstractCompoundType.js

@@ -80,9 +80,6 @@ export class AbstractCompoundType extends AbstractType {
         // Don't recurse
         return this.shapeIdentifier.equals(other.shapeIdentifier);
     }
-    toString() {
-        return `${this.kind}(memberTypes=[${this.members.map((memberType) => memberType.toString()).join(", ")}])`;
-    }
 }
 __decorate([
     Memoize()

package/dist/ast/AbstractContainerType.d.ts

@@ -27,7 +27,15 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     get nodeKinds(): ReadonlySet<NodeKind>;
     get recursive(): boolean;
     equals(other: AbstractContainerType<ItemTypeT>): boolean;
-    toString(): string;
+    toJSON(): {
+        itemType: any;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+    };
 }
 export declare namespace AbstractContainerType {
     type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | ObjectType | TermType | UnionType;

package/dist/ast/AbstractContainerType.js

@@ -29,8 +29,11 @@ export class AbstractContainerType extends AbstractType {
         }
         return true;
     }
-    toString() {
-        return `${this.kind}(itemType=${this.itemType})`;
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            itemType: this.itemType.toJSON(),
+        };
     }
 }
 (function (AbstractContainerType) {

package/dist/ast/AbstractLazyObjectType.d.ts

@@ -18,7 +18,100 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     get nodeKinds(): ReadonlySet<NodeKind>;
     get recursive(): boolean;
     equals(other: AbstractLazyObjectType<PartialTypeT, ResolveTypeT>): boolean;
-    toString(): string;
+    toJSON(): {
+        partialType: {
+            fromRdfType: import("@rdfjs/types").NamedNode<string> | undefined;
+            identifierMintingStrategy: "blankNode" | "sha256" | "uuidv4" | undefined;
+            identifierType: {
+                hasValues: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
+                in: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
+                nodeKinds: NodeKind[];
+                comment: string | undefined;
+                kind: string;
+                label: string | undefined;
+                name: string | undefined;
+                recursive: boolean | undefined;
+                shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+            };
+            parentObjectTypes: (string | import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>)[] | undefined;
+            synthetic: boolean | undefined;
+            toRdfTypes: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+        } | {
+            members: {
+                discriminantValue: string | number | undefined;
+                type: any;
+            }[] | undefined;
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+        } | {
+            itemType: any;
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+        };
+        resolveType: {
+            fromRdfType: import("@rdfjs/types").NamedNode<string> | undefined;
+            identifierMintingStrategy: "blankNode" | "sha256" | "uuidv4" | undefined;
+            identifierType: {
+                hasValues: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
+                in: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
+                nodeKinds: NodeKind[];
+                comment: string | undefined;
+                kind: string;
+                label: string | undefined;
+                name: string | undefined;
+                recursive: boolean | undefined;
+                shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+            };
+            parentObjectTypes: (string | import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>)[] | undefined;
+            synthetic: boolean | undefined;
+            toRdfTypes: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+        } | {
+            members: {
+                discriminantValue: string | number | undefined;
+                type: any;
+            }[] | undefined;
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+        } | {
+            itemType: any;
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+        };
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+    };
 }
 export declare namespace AbstractLazyObjectType {
     type ObjectTypeConstraint = ObjectType | ObjectUnionType;

package/dist/ast/AbstractLazyObjectType.js

@@ -29,8 +29,12 @@ export class AbstractLazyObjectType extends AbstractType {
         }
         return true;
     }
-    toString() {
-        return `${this.kind}(partialType=${this.partialType}, resolveType=${this.resolveType})`;
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            partialType: this.partialType.toJSON(),
+            resolveType: this.resolveType.toJSON(),
+        };
     }
 }
 //# sourceMappingURL=AbstractLazyObjectType.js.map

package/dist/ast/AbstractTermType.d.ts

@@ -18,6 +18,16 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
         in_: readonly ConstantTermT[];
     } & ConstructorParameters<typeof AbstractType>[0]);
     equals(other: AbstractTermType<ConstantTermT, _RuntimeTermT>): boolean;
-    toString(): string;
+    toJSON(): {
+        hasValues: readonly ConstantTermT[] | undefined;
+        in: readonly ConstantTermT[] | undefined;
+        nodeKinds: import("@shaclmate/shacl-ast").NodeKind[];
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: BlankNode | NamedNode<string>;
+    };
 }
 //# sourceMappingURL=AbstractTermType.d.ts.map

package/dist/ast/AbstractTermType.js

@@ -35,8 +35,13 @@ export class AbstractTermType extends AbstractType {
         }
         return true;
     }
-    toString() {
-        return `${this.kind}(nodeKinds=${[...this.nodeKinds].join(" | ")})`;
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            hasValues: this.hasValues.length > 0 ? this.hasValues : undefined,
+            in: this.in_.length > 0 ? this.in_ : undefined,
+            nodeKinds: [...this.nodeKinds],
+        };
     }
 }
 //# sourceMappingURL=AbstractTermType.js.map

package/dist/ast/AbstractType.d.ts

@@ -9,6 +9,10 @@ export declare abstract class AbstractType {
      * Documentation comment from rdfs:comment.
      */
     readonly comment: Maybe<string>;
+    /**
+     * Type discriminant
+     */
+    abstract readonly kind: string;
     /**
      * Human-readable label from rdfs:label.
      */
@@ -38,6 +42,14 @@ export declare abstract class AbstractType {
         shapeIdentifier: BlankNode | NamedNode;
     });
     equals(other: AbstractType): boolean;
-    abstract toString(): string;
+    toJSON(): {
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: BlankNode | NamedNode<string>;
+    };
+    toString(): string;
 }
 //# sourceMappingURL=AbstractType.d.ts.map

package/dist/ast/AbstractType.js

@@ -35,5 +35,18 @@ export class AbstractType {
         }
         return true;
     }
+    toJSON() {
+        return {
+            comment: this.comment.extract(),
+            kind: this.kind,
+            label: this.label.extract(),
+            name: this.name.extract(),
+            recursive: this.recursive ? true : undefined,
+            shapeIdentifier: this.shapeIdentifier,
+        };
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
 }
 //# sourceMappingURL=AbstractType.js.map

package/dist/ast/BlankNodeType.d.ts

@@ -6,6 +6,6 @@ import { AbstractTermType } from "./AbstractTermType.js";
 export declare class BlankNodeType extends AbstractTermType<NamedNode, BlankNode> {
     readonly kind = "BlankNodeType";
     readonly nodeKinds: ReadonlySet<"BlankNode">;
-    constructor(superParameters: Pick<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "comment" | "label" | "name" | "shapeIdentifier">);
+    constructor(superParameters: Omit<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "hasValues" | "in_">);
 }
 //# sourceMappingURL=BlankNodeType.d.ts.map

package/dist/ast/DefaultValueType.d.ts

@@ -17,6 +17,16 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
         defaultValue: Literal | NamedNode;
     });
     equals(other: DefaultValueType<ItemTypeT>): boolean;
+    toJSON(): {
+        defaultValue: Literal | NamedNode<string>;
+        itemType: any;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | NamedNode<string>;
+    };
 }
 export declare namespace DefaultValueType {
     type ItemType = Exclude<AbstractContainerType.ItemType, BlankNodeType>;

package/dist/ast/DefaultValueType.js

@@ -30,6 +30,12 @@ export class DefaultValueType extends AbstractContainerType {
         }
         return true;
     }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            defaultValue: this.defaultValue,
+        };
+    }
 }
 (function (DefaultValueType) {
     function isItemType(type) {

package/dist/ast/IdentifierType.d.ts

@@ -7,6 +7,6 @@ import { AbstractTermType } from "./AbstractTermType.js";
 export declare class IdentifierType extends AbstractTermType<NamedNode, BlankNode | NamedNode> {
     readonly kind = "IdentifierType";
     readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
-    constructor(superParameters: Pick<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "comment" | "label" | "name" | "shapeIdentifier">);
+    constructor(superParameters: Omit<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "hasValues" | "in_">);
 }
 //# sourceMappingURL=IdentifierType.d.ts.map

package/dist/ast/LiteralType.d.ts

@@ -19,6 +19,22 @@ export declare class LiteralType extends AbstractTermType<Literal, Literal> {
         minInclusive: Maybe<Literal>;
     } & Omit<ConstructorParameters<typeof AbstractTermType<Literal, Literal>>[0], "nodeKinds">);
     equals(other: AbstractTermType<Literal, Literal>): boolean;
-    toString(): string;
+    toJSON(): {
+        datatype: NamedNode<string> | undefined;
+        languageIn: readonly string[] | undefined;
+        maxExclusive: Literal | undefined;
+        maxInclusive: Literal | undefined;
+        minExclusive: Literal | undefined;
+        minInclusive: Literal | undefined;
+        hasValues: readonly Literal[] | undefined;
+        in: readonly Literal[] | undefined;
+        nodeKinds: import("@shaclmate/shacl-ast").NodeKind[];
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | NamedNode<string>;
+    };
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/ast/LiteralType.js

@@ -43,8 +43,16 @@ export class LiteralType extends AbstractTermType {
         }
         return true;
     }
-    toString() {
-        return `${this.kind}()`;
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            datatype: this.datatype.extract(),
+            languageIn: this.languageIn.length > 0 ? this.languageIn : undefined,
+            maxExclusive: this.maxExclusive.extract(),
+            maxInclusive: this.maxInclusive.extract(),
+            minExclusive: this.minExclusive.extract(),
+            minInclusive: this.minInclusive.extract(),
+        };
     }
 }
 const nodeKinds = new Set(["Literal"]);

package/dist/ast/ObjectCompoundType.js

@@ -1,5 +1,4 @@
 import TermSet from "@rdfjs/term-set";
-import { Resource } from "@rdfx/resource";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { BlankNodeType } from "./BlankNodeType.js";
@@ -79,7 +78,7 @@ export var ObjectCompoundType;
         }
         if (fromRdfTypes.size > 0 &&
             fromRdfTypes.size !== expectUniqueFromRdfTypesCount) {
-            throw new Error(`one or more ${objectCompoundType} members ([${memberObjectTypes_.map((memberType) => memberType.toString()).join(", ")}]) lack distinguishing fromRdfType's ({${[...fromRdfTypes].map((fromRdfType) => Resource.Identifier.toString(fromRdfType)).join(", ")}})`);
+            throw new Error(`one or more ${objectCompoundType} members ([${memberObjectTypes_.map((memberType) => memberType.toString()).join(", ")}]) lack distinguishing fromRdfType's ({${[...fromRdfTypes].join(", ")}})`);
         }
         return memberObjectTypes_;
     }

package/dist/ast/ObjectType.d.ts

@@ -98,7 +98,30 @@ export declare class ObjectType extends AbstractType {
     addProperties(...properties: readonly ObjectType.Property[]): void;
     equals(other: ObjectType): boolean;
     sortProperties(): void;
-    toString(): string;
+    toJSON(): {
+        fromRdfType: NamedNode<string> | undefined;
+        identifierMintingStrategy: "blankNode" | "sha256" | "uuidv4" | undefined;
+        identifierType: {
+            hasValues: readonly NamedNode<string>[] | undefined;
+            in: readonly NamedNode<string>[] | undefined;
+            nodeKinds: NodeKind[];
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: BlankNode | NamedNode<string>;
+        };
+        parentObjectTypes: (string | BlankNode | NamedNode<string>)[] | undefined;
+        synthetic: boolean | undefined;
+        toRdfTypes: readonly NamedNode<string>[] | undefined;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: BlankNode | NamedNode<string>;
+    };
 }
 export declare namespace ObjectType {
     class Property {
@@ -165,6 +188,26 @@ export declare namespace ObjectType {
          * Does the property directly or indirectly reference the ObjectType itself?
          */
         get recursive(): boolean;
+        toJSON(): {
+            comment: string | undefined;
+            description: string | undefined;
+            label: string | undefined;
+            mutable: boolean | undefined;
+            name: string;
+            order: number;
+            path: string;
+            recursive: boolean | undefined;
+            shapeIdentifier: BlankNode | NamedNode<string>;
+            type: {
+                comment: string | undefined;
+                kind: string;
+                label: string | undefined;
+                name: string | undefined;
+                recursive: boolean | undefined;
+                shapeIdentifier: BlankNode | NamedNode<string>;
+            };
+            visibility: Visibility;
+        };
         toString(): string;
     }
 }

package/dist/ast/ObjectType.js

@@ -4,7 +4,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { PropertyPath, Resource } from "@rdfx/resource";
+import { PropertyPath } from "@rdfx/resource";
+import { NTriplesIdentifier } from "@rdfx/string";
 import genericToposort from "toposort";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
@@ -166,8 +167,19 @@ export class ObjectType extends AbstractType {
             return 0;
         });
     }
-    toString() {
-        return `${this.kind}(shapeIdentifier=${Resource.Identifier.toString(this.shapeIdentifier)})`;
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            fromRdfType: this.fromRdfType.extract(),
+            identifierMintingStrategy: this.identifierMintingStrategy.extract(),
+            identifierType: this.identifierType.toJSON(),
+            parentObjectTypes: this.parentObjectTypes.length > 0
+                ? this.parentObjectTypes.map((parentObjectType) => parentObjectType.name.extract() ??
+                    parentObjectType.shapeIdentifier)
+                : undefined,
+            synthetic: this.synthetic ? true : undefined,
+            toRdfTypes: this.toRdfTypes.length > 0 ? this.toRdfTypes : undefined,
+        };
     }
 }
 const nodeKinds = new Set(["BlankNode", "IRI"]);
@@ -350,8 +362,23 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
             }
             return helper([{ objectType: rootObjectType, property: rootProperty }]);
         }
+        toJSON() {
+            return {
+                comment: this.comment.extract(),
+                description: this.description.extract(),
+                label: this.label.extract(),
+                mutable: this.mutable ? true : undefined,
+                name: this.name,
+                order: this.order,
+                path: PropertyPath.toString(this.path),
+                recursive: this.recursive ? true : undefined,
+                shapeIdentifier: this.shapeIdentifier,
+                type: this.type.toJSON(),
+                visibility: this.visibility,
+            };
+        }
         toString() {
-            return `${this.name}(path=${PropertyPath.toString(this.path)})`;
+            return JSON.stringify(this.toJSON());
         }
     }
     __decorate([
@@ -365,18 +392,14 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
         const objectTypeGraphNodes = [];
         const objectTypeGraphEdges = [];
         for (const objectType of objectTypes) {
-            const objectTypeShapeIdentifier = Resource.Identifier.toString(objectType.shapeIdentifier);
+            const objectTypeShapeIdentifier = NTriplesIdentifier.stringify(objectType.shapeIdentifier);
             invariant(!objectTypesByShapeIdentifier[objectTypeShapeIdentifier]);
             objectTypesByShapeIdentifier[objectTypeShapeIdentifier] = objectType;
             objectTypeGraphNodes.push(objectTypeShapeIdentifier);
             for (const parentAstObjectType of objectType.parentObjectTypes) {
-                // console.log(
-                //   objectTypeShapeIdentifier,
-                //   Resource.Identifier.toString(parentAstObjectType.shapeIdentifier),
-                // );
                 objectTypeGraphEdges.push([
                     objectTypeShapeIdentifier,
-                    Resource.Identifier.toString(parentAstObjectType.shapeIdentifier),
+                    NTriplesIdentifier.stringify(parentAstObjectType.shapeIdentifier),
                 ]);
             }
         }