@shaclmate/compiler 3.0.4 → 4.0.0

package/dist/ast/ObjectType.d.ts

@@ -1,41 +1,21 @@
-import type { NamedNode } from "@rdfjs/types";
-import type { NodeKind, PredicatePath } from "@shaclmate/shacl-ast";
+import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
+import { PropertyPath } from "rdfjs-resource";
 import type { IdentifierMintingStrategy, PropertyVisibility, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
-import type { Name } from "./Name.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
-import type { OptionType } from "./OptionType.js";
-import type { SetType } from "./SetType.js";
-import type { Type } from "./Type.js";
-export interface ObjectType {
+import { AbstractType } from "./AbstractType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { Curie } from "./Curie.js";
+import type { IdentifierType } from "./IdentifierType.js";
+import type { IriType } from "./IriType.js";
+import { Type } from "./Type.js";
+export declare class ObjectType extends AbstractType {
+    #private;
     /**
      * Classes generated from this type are abstract / cannot be instantiated themselves.
      *
      * Defaults to false.
      */
     readonly abstract: boolean;
-    /**
-     * Ancestor (parents, their parents, ad nauseum) ObjectTypes of this ObjectType.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    readonly ancestorObjectTypes: ObjectType[];
-    /**
-     * Immediate child ObjectTypes of this ObjectType.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    readonly childObjectTypes: ObjectType[];
-    /**
-     * Documentation comment from rdfs:comment.
-     */
-    readonly comment: Maybe<string>;
-    /**
-     * Descendant (children, their children, ad nauseum) ObjectTypes of this ObjectType.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    readonly descendantObjectTypes: ObjectType[];
     /**
      * Should generated code derived from this ObjectType be visible outside its module?
      *
@@ -55,46 +35,26 @@ export interface ObjectType {
      * class targets).
      */
     readonly fromRdfType: Maybe<NamedNode>;
-    /**
-     * Instances of this ObjectType must have explicit identifiers and the identifiers must be in this list of IRIs.
-     *
-     * Mutually exclusive with minting strategies
-     */
-    readonly identifierIn: readonly NamedNode[];
-    /**
-     * The RDF node kinds this ObjectType may be identified by.
-     *
-     * Used to associate instances with an RDF identifier.
-     */
-    readonly identifierNodeKinds: Set<Exclude<NodeKind, "Literal">>;
     /**
      * Strategy for minting new object identifiers.
      */
     readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
     /**
-     * Type discriminator.
-     */
-    readonly kind: "ObjectType";
-    /**
-     * Human-readable label from rdfs:label.
+     * Identifier type.
      */
-    readonly label: Maybe<string>;
+    readonly identifierType: BlankNodeType | IdentifierType | IriType;
     /**
-     * Name of this type, usually derived from sh:name or shaclmate:name.
+     * Type discriminant.
      */
-    readonly name: Name;
+    readonly kind = "ObjectType";
     /**
-     * Immediate parent ObjectTypes of this Object types.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
+     * Name of this type, from shaclmate:name.
      */
-    readonly parentObjectTypes: ObjectType[];
+    readonly name: Maybe<string>;
     /**
-     * Properties of this ObjectType.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
+     * Identifier of the shape this ObjectType was derived from.
      */
-    readonly properties: ObjectType.Property[];
+    readonly shapeIdentifier: BlankNode | NamedNode;
     /**
      * Was this type synthesized or did it come from SHACL?
      */
@@ -109,7 +69,7 @@ export interface ObjectType {
     /**
      * TypeScript features to generate.
      */
-    readonly tsFeatures: Set<TsFeature>;
+    readonly tsFeatures: ReadonlySet<TsFeature>;
     /**
      * TypeScript imports to add to generated code.
      *
@@ -123,9 +83,37 @@ export interface ObjectType {
      * Whether to generate a TypeScript class or interface for this type.
      */
     readonly tsObjectDeclarationType: TsObjectDeclarationType;
+    constructor({ abstract, export_, extern, fromRdfType, identifierMintingStrategy, identifierType, name, shapeIdentifier, synthetic, toRdfTypes, tsFeatures, tsImports, tsObjectDeclarationType, ...superParameters }: {
+        abstract: boolean;
+        export_: boolean;
+        extern: boolean;
+        fromRdfType: Maybe<NamedNode>;
+        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
+        identifierType: BlankNodeType | IdentifierType | IriType;
+        name: Maybe<string>;
+        shapeIdentifier: BlankNode | Curie | NamedNode;
+        synthetic: boolean;
+        toRdfTypes: readonly NamedNode[];
+        tsFeatures: ReadonlySet<TsFeature>;
+        tsImports: readonly string[];
+        tsObjectDeclarationType: TsObjectDeclarationType;
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    addAncestorObjectTypes(...ancestorObjectTypes: readonly ObjectType[]): void;
+    addChildObjectTypes(...childObjectTypes: readonly ObjectType[]): void;
+    addDescendantObjectTypes(...descendantObjectTypes: readonly ObjectType[]): void;
+    addParentObjectTypes(...parentObjectTypes: readonly ObjectType[]): void;
+    addProperties(...properties: readonly ObjectType.Property[]): void;
+    get ancestorObjectTypes(): readonly ObjectType[];
+    get childObjectTypes(): readonly ObjectType[];
+    get descendantObjectTypes(): readonly ObjectType[];
+    get parentObjectTypes(): readonly ObjectType[];
+    get properties(): readonly ObjectType.Property[];
+    equals(other: ObjectType): boolean;
+    sortProperties(): void;
+    toString(): string;
 }
 export declare namespace ObjectType {
-    interface Property {
+    class Property {
         /**
          * Documentation comment from rdfs:comment.
          */
@@ -142,11 +130,15 @@ export declare namespace ObjectType {
          * The property should be mutable in generated code i.e., it should be re-assignable. The property value may or may
          * not be mutable.
          */
-        readonly mutable: Maybe<boolean>;
+        readonly mutable: boolean;
+        /**
+         * Object type this property belongs to.
+         */
+        readonly objectType: ObjectType;
         /**
-         * Name of this property.
+         * Name of this property, derived from sh:name or shaclmate:name.
          */
-        readonly name: Name;
+        readonly name: Maybe<string>;
         /**
          * Relative order of this property, derived from sh:order.
          */
@@ -154,17 +146,11 @@ export declare namespace ObjectType {
         /**
          * SHACL property path (https://www.w3.org/TR/shacl/#property-paths)
          */
-        readonly path: PredicatePath;
+        readonly path: Curie | PropertyPath;
         /**
-         * Does the property directly or indirectly reference the ObjectType itself?
+         * Identifier of the property shape.
          */
-        readonly recursive?: boolean;
-        /**
-         * The property will be resolved lazily, with this type serving as a stub before resolution of the actual type (type).
-         *
-         * This type will mirror type: if type is an OptionType<ObjectType>, this will also be an OptionType<ObjectType>.
-         */
-        readonly stubType: Maybe<ObjectType | ObjectUnionType | OptionType<ObjectType | ObjectUnionType> | SetType<ObjectType | ObjectUnionType>>;
+        readonly shapeIdentifier: BlankNode | NamedNode;
         /**
          * Type of this property.
          */
@@ -173,7 +159,28 @@ export declare namespace ObjectType {
          * Visibility: private, protected, public.
          */
         readonly visibility: PropertyVisibility;
+        constructor({ comment, description, label, mutable, name, objectType, order, path, shapeIdentifier, type, visibility, }: {
+            comment: Maybe<string>;
+            description: Maybe<string>;
+            label: Maybe<string>;
+            mutable: boolean;
+            name: Maybe<string>;
+            objectType: ObjectType;
+            order: number;
+            path: Curie | PropertyPath;
+            shapeIdentifier: BlankNode | NamedNode;
+            type: Type;
+            visibility: PropertyVisibility;
+        });
+        equals(other: Property): boolean;
+        /**
+         * Does the property directly or indirectly reference the ObjectType itself?
+         */
+        get recursive(): boolean;
+        toString(): string;
     }
+}
+export declare namespace ObjectType {
     function toposort(objectTypes: readonly ObjectType[]): readonly ObjectType[];
 }
 //# sourceMappingURL=ObjectType.d.ts.map

package/dist/ast/ObjectType.js

@@ -1,25 +1,418 @@
-import { Resource } from "rdfjs-resource";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 "rdfjs-resource";
 import genericToposort from "toposort";
-export var ObjectType;
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractType } from "./AbstractType.js";
+import { arrayEquals } from "./equals.js";
+import { Type } from "./Type.js";
+export class ObjectType extends AbstractType {
+    /**
+     * Classes generated from this type are abstract / cannot be instantiated themselves.
+     *
+     * Defaults to false.
+     */
+    abstract;
+    /**
+     * Ancestor (parents, their parents, ad nauseum) ObjectTypes of this ObjectType.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    #ancestorObjectTypes = [];
+    /**
+     * Immediate child ObjectTypes of this ObjectType.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    #childObjectTypes = [];
+    /**
+     * Descendant (children, their children, ad nauseum) ObjectTypes of this ObjectType.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    #descendantObjectTypes = [];
+    /**
+     * Should generated code derived from this ObjectType be visible outside its module?
+     *
+     * Defaults to true.
+     */
+    export;
+    /**
+     * If true, the code for this ObjectType is defined externally and should not be generated.
+     *
+     * Defaults to false.
+     */
+    extern;
+    /**
+     * The expected rdf:type of instances of this ObjectType.
+     *
+     * This is usually the identifier of an sh:NodeShape that is also an rdfs:Class (i.e., a node shape with implicit
+     * class targets).
+     */
+    fromRdfType;
+    /**
+     * Strategy for minting new object identifiers.
+     */
+    identifierMintingStrategy;
+    /**
+     * Identifier type.
+     */
+    identifierType;
+    /**
+     * Type discriminant.
+     */
+    kind = "ObjectType";
+    /**
+     * Name of this type, from shaclmate:name.
+     */
+    name;
+    /**
+     * Immediate parent ObjectTypes of this Object types.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    #parentObjectTypes = [];
+    /**
+     * Properties of this ObjectType.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    #properties = [];
+    /**
+     * Identifier of the shape this ObjectType was derived from.
+     */
+    shapeIdentifier;
+    /**
+     * Was this type synthesized or did it come from SHACL?
+     */
+    synthetic;
+    /**
+     * rdf:type's that will be added to this object when it's serialized toRdf.
+     *
+     * This is usually the identifier of an sh:NodeShape that is also an rdfs:Class (i.e., a node shape with implicit
+     * class targets).
+     */
+    toRdfTypes;
+    /**
+     * TypeScript features to generate.
+     */
+    tsFeatures;
+    /**
+     * TypeScript imports to add to generated code.
+     *
+     * This is often used in conjunction with extern=true to import the extern'd ObjectType code in order for generated
+     * code to reference it.
+     *
+     * import { MyType } from "./MyType.js"
+     */
+    tsImports;
+    /**
+     * Whether to generate a TypeScript class or interface for this type.
+     */
+    tsObjectDeclarationType;
+    constructor({ abstract, export_, extern, fromRdfType, identifierMintingStrategy, identifierType, name, shapeIdentifier, synthetic, toRdfTypes, tsFeatures, tsImports, tsObjectDeclarationType, ...superParameters }) {
+        super(superParameters);
+        this.abstract = abstract;
+        this.export = export_;
+        this.extern = extern;
+        this.fromRdfType = fromRdfType;
+        this.identifierMintingStrategy = identifierMintingStrategy;
+        this.identifierType = identifierType;
+        this.name = name;
+        this.shapeIdentifier = shapeIdentifier;
+        this.synthetic = synthetic;
+        this.toRdfTypes = toRdfTypes;
+        this.tsFeatures = tsFeatures;
+        this.tsImports = tsImports;
+        this.tsObjectDeclarationType = tsObjectDeclarationType;
+    }
+    addAncestorObjectTypes(...ancestorObjectTypes) {
+        this.#ancestorObjectTypes.push(...ancestorObjectTypes);
+    }
+    addChildObjectTypes(...childObjectTypes) {
+        this.#childObjectTypes.push(...childObjectTypes);
+    }
+    addDescendantObjectTypes(...descendantObjectTypes) {
+        this.#descendantObjectTypes.push(...descendantObjectTypes);
+    }
+    addParentObjectTypes(...parentObjectTypes) {
+        this.#parentObjectTypes.push(...parentObjectTypes);
+    }
+    addProperties(...properties) {
+        this.#properties.push(...properties);
+        for (const property of properties) {
+            invariant(Object.is(property.objectType, this));
+        }
+    }
+    get ancestorObjectTypes() {
+        return this.#ancestorObjectTypes;
+    }
+    get childObjectTypes() {
+        return this.#childObjectTypes;
+    }
+    get descendantObjectTypes() {
+        return this.#descendantObjectTypes;
+    }
+    get parentObjectTypes() {
+        return this.#parentObjectTypes;
+    }
+    get properties() {
+        return this.#properties;
+    }
+    equals(other) {
+        // Don't recurse
+        return this.shapeIdentifier.equals(other.shapeIdentifier);
+    }
+    sortProperties() {
+        this.#properties.sort((left, right) => {
+            if (left.order < right.order) {
+                return -1;
+            }
+            if (left.order > right.order) {
+                return 1;
+            }
+            return 0;
+        });
+    }
+    toString() {
+        return `${this.kind}(shapeIdentifier=${Resource.Identifier.toString(this.shapeIdentifier)})`;
+    }
+}
+(function (ObjectType) {
+    class Property {
+        /**
+         * Documentation comment from rdfs:comment.
+         */
+        comment;
+        /**
+         * Description from sh:description.
+         */
+        description;
+        /**
+         * Human-readable label from rdfs:label.
+         */
+        label;
+        /**
+         * The property should be mutable in generated code i.e., it should be re-assignable. The property value may or may
+         * not be mutable.
+         */
+        mutable;
+        /**
+         * Object type this property belongs to.
+         */
+        objectType;
+        /**
+         * Name of this property, derived from sh:name or shaclmate:name.
+         */
+        name;
+        /**
+         * Relative order of this property, derived from sh:order.
+         */
+        order;
+        /**
+         * SHACL property path (https://www.w3.org/TR/shacl/#property-paths)
+         */
+        path;
+        /**
+         * Identifier of the property shape.
+         */
+        shapeIdentifier;
+        /**
+         * Type of this property.
+         */
+        type;
+        /**
+         * Visibility: private, protected, public.
+         */
+        visibility;
+        constructor({ comment, description, label, mutable, name, objectType, order, path, shapeIdentifier, type, visibility, }) {
+            this.comment = comment;
+            this.description = description;
+            this.label = label;
+            this.mutable = mutable;
+            this.name = name;
+            this.objectType = objectType;
+            this.order = order;
+            this.path = path;
+            this.shapeIdentifier = shapeIdentifier;
+            this.type = type;
+            this.visibility = visibility;
+        }
+        equals(other) {
+            return this.shapeIdentifier.equals(other.shapeIdentifier);
+        }
+        /**
+         * Does the property directly or indirectly reference the ObjectType itself?
+         */
+        get recursive() {
+            const DEBUG = false;
+            const rootObjectType = this.objectType;
+            const rootProperty = this;
+            function helper(stack) {
+                const currentStackFrame = stack.at(-1);
+                const { objectType, property, propertyType } = currentStackFrame;
+                if (DEBUG) {
+                    process.stderr.write(`${[
+                        stack.length.toString(),
+                        rootObjectType,
+                        rootProperty,
+                        objectType,
+                        property,
+                        propertyType
+                            ? `[${propertyType.map(Type.toString).join(", ")}]`
+                            : "undefined",
+                    ].join(",")}\n`);
+                }
+                for (const lowerStackFrame of stack.slice(0, -1)) {
+                    if (!Type.equals(currentStackFrame.objectType, lowerStackFrame.objectType)) {
+                        continue;
+                    }
+                    if (!currentStackFrame.property.equals(lowerStackFrame.property)) {
+                        continue;
+                    }
+                    if (!arrayEquals(Type.equals)(currentStackFrame.propertyType ?? [], lowerStackFrame.propertyType ?? [])) {
+                        continue;
+                    }
+                    // We've seen this combination before and don't want to recurse further, to avoid infinite recursion
+                    if (DEBUG) {
+                        process.stderr.write("recursion detected, halting");
+                    }
+                    return true;
+                }
+                if (!propertyType) {
+                    return helper(stack.concat({
+                        objectType,
+                        property,
+                        propertyType: [property.type],
+                    }));
+                }
+                invariant(propertyType.length > 0);
+                const currentPropertyType = propertyType.at(-1);
+                switch (currentPropertyType.kind) {
+                    case "BlankNodeType":
+                    case "IdentifierType":
+                    case "IriType":
+                    case "LiteralType":
+                    case "PlaceholderType":
+                    case "TermType":
+                        return false;
+                    case "LazyObjectOptionType":
+                    case "LazyObjectSetType":
+                    case "LazyObjectType": {
+                        if (helper(stack.concat({
+                            objectType,
+                            property,
+                            propertyType: propertyType.concat(currentPropertyType.partialType),
+                        }))) {
+                            return true;
+                        }
+                        if (helper(stack.concat({
+                            objectType,
+                            property,
+                            propertyType: propertyType.concat(currentPropertyType.resolveType),
+                        }))) {
+                            return true;
+                        }
+                        return false;
+                    }
+                    case "ObjectType": {
+                        if (DEBUG) {
+                            process.stderr.write(`recurse into ${currentPropertyType}`);
+                        }
+                        for (const property of currentPropertyType.properties) {
+                            if (helper(stack.concat({
+                                objectType: currentPropertyType,
+                                property,
+                            }))) {
+                                return true;
+                            }
+                        }
+                        return false;
+                    }
+                    case "IntersectionType":
+                    case "UnionType": {
+                        if (DEBUG) {
+                            process.stderr.write(`recurse into ${currentPropertyType}`);
+                        }
+                        for (const memberType of currentPropertyType.memberTypes) {
+                            if (helper(stack.concat({
+                                objectType,
+                                property,
+                                propertyType: propertyType.concat(memberType),
+                            }))) {
+                                return true;
+                            }
+                        }
+                        return false;
+                    }
+                    case "ObjectIntersectionType":
+                    case "ObjectUnionType": {
+                        if (DEBUG) {
+                            process.stderr.write(`recurse into ${currentPropertyType}`);
+                        }
+                        for (const memberType of currentPropertyType.memberObjectTypes) {
+                            for (const property of memberType.properties) {
+                                if (helper(stack.concat({
+                                    objectType: memberType,
+                                    property,
+                                }))) {
+                                    return true;
+                                }
+                            }
+                        }
+                        return false;
+                    }
+                    case "DefaultValueType":
+                    case "ListType":
+                    case "OptionType":
+                    case "SetType":
+                        return helper(stack.concat({
+                            objectType,
+                            property,
+                            propertyType: propertyType.concat(currentPropertyType.itemType),
+                        }));
+                }
+            }
+            return helper([{ objectType: rootObjectType, property: rootProperty }]);
+        }
+        toString() {
+            return `${this.name.orDefault(Resource.Identifier.toString(this.shapeIdentifier))}(path=${PropertyPath.$toString(this.path)})`;
+        }
+    }
+    __decorate([
+        Memoize()
+    ], Property.prototype, "recursive", null);
+    ObjectType.Property = Property;
+})(ObjectType || (ObjectType = {}));
 (function (ObjectType) {
     function toposort(objectTypes) {
-        const objectTypesByIdentifier = {};
+        const objectTypesByShapeIdentifier = {};
         const objectTypeGraphNodes = [];
         const objectTypeGraphEdges = [];
         for (const objectType of objectTypes) {
-            const objectTypeIdentifier = Resource.Identifier.toString(objectType.name.identifier);
-            objectTypesByIdentifier[objectTypeIdentifier] = objectType;
-            objectTypeGraphNodes.push(objectTypeIdentifier);
+            const objectTypeShapeIdentifier = Resource.Identifier.toString(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([
-                    objectTypeIdentifier,
-                    Resource.Identifier.toString(parentAstObjectType.name.identifier),
+                    objectTypeShapeIdentifier,
+                    Resource.Identifier.toString(parentAstObjectType.shapeIdentifier),
                 ]);
             }
         }
         return genericToposort
             .array(objectTypeGraphNodes, objectTypeGraphEdges)
-            .map((objectTypeIdentifier) => objectTypesByIdentifier[objectTypeIdentifier])
+            .map((objectTypeIdentifier) => objectTypesByShapeIdentifier[objectTypeIdentifier])
             .reverse();
     }
     ObjectType.toposort = toposort;

package/dist/ast/ObjectUnionType.d.ts

@@ -1,8 +1,8 @@
-import type { ObjectCompositeType } from "./ObjectCompositeType.js";
+import { AbstractObjectCompoundType } from "./AbstractObjectCompoundType.js";
 /**
  * A disjunction/union of object types, corresponding to an sh:xone on a node shape.
  */
-export interface ObjectUnionType extends ObjectCompositeType {
-    readonly kind: "ObjectUnionType";
+export declare class ObjectUnionType extends AbstractObjectCompoundType<ObjectUnionType> {
+    readonly kind = "ObjectUnionType";
 }
 //# sourceMappingURL=ObjectUnionType.d.ts.map

package/dist/ast/ObjectUnionType.js

@@ -1,2 +1,8 @@
-export {};
+import { AbstractObjectCompoundType } from "./AbstractObjectCompoundType.js";
+/**
+ * A disjunction/union of object types, corresponding to an sh:xone on a node shape.
+ */
+export class ObjectUnionType extends AbstractObjectCompoundType {
+    kind = "ObjectUnionType";
+}
 //# sourceMappingURL=ObjectUnionType.js.map