@shaclmate/compiler 3.0.4 → 4.0.1

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -1,202 +1,200 @@
-import N3 from "n3";
+import dataFactory from "@rdfjs/data-model";
 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 { ShapeStack } from "./ShapeStack.js";
-import { pickLiteral } from "./pickLiteral.js";
-function identifierNodeKinds(type) {
-    switch (type.kind) {
-        case "ObjectType":
-            return type.identifierNodeKinds;
-        case "ObjectUnionType":
-            return new Set(type.memberTypes.flatMap((memberType) => [
-                ...memberType.identifierNodeKinds,
-            ]));
-    }
-}
-function synthesizeStubAstObjectType({ identifierNodeKinds, tsFeatures, }) {
+import { transformShapeToAstAbstractTypeProperties } from "./transformShapeToAstAbstractTypeProperties.js";
+function synthesizePartialAstObjectType({ identifierType, tsFeatures, }) {
     let syntheticName;
-    switch (identifierNodeKinds.size) {
-        case 1:
-            invariant(identifierNodeKinds.has("NamedNode"));
-            syntheticName = "NamedDefaultStub";
+    switch (identifierType.kind) {
+        case "BlankNodeType":
+            throw new Error("should never happen");
+        case "IdentifierType":
+            syntheticName = "DefaultPartial";
             break;
-        case 2:
-            syntheticName = "DefaultStub";
+        case "IriType":
+            syntheticName = "NamedDefaultPartial";
             break;
-        default:
-            throw new Error("should never happen");
     }
-    return {
+    return new ast.ObjectType({
         abstract: false,
-        ancestorObjectTypes: [],
-        childObjectTypes: [],
         comment: Maybe.empty(),
-        descendantObjectTypes: [],
-        export: true,
+        export_: true,
         extern: false,
         fromRdfType: Maybe.empty(),
-        identifierIn: [],
-        identifierNodeKinds,
+        identifierType,
         identifierMintingStrategy: Maybe.empty(),
-        kind: "ObjectType",
         label: Maybe.empty(),
-        name: {
-            identifier: N3.DataFactory.blankNode(),
-            label: Maybe.empty(),
-            propertyPath: Maybe.empty(),
-            shName: Maybe.empty(),
-            shaclmateName: Maybe.empty(),
-            syntheticName: Maybe.of(syntheticName),
-        },
-        parentObjectTypes: [],
-        properties: [],
+        name: Maybe.of(syntheticName),
+        shapeIdentifier: dataFactory.namedNode(`urn:shaclmate:synthetic:${syntheticName}`),
         synthetic: true,
         toRdfTypes: [],
         tsFeatures,
         tsImports: [],
         tsObjectDeclarationType: "class",
-    };
-}
-function transformPropertyShapeToAstType(propertyShape) {
-    const itemTypeEither = this.transformShapeToAstType(propertyShape, new ShapeStack());
-    if (itemTypeEither.isLeft()) {
-        return itemTypeEither;
-    }
-    const itemType = itemTypeEither.unsafeCoerce();
-    if (propertyShape.defaultValue.isJust()) {
-        return Either.of(itemType);
-    }
-    if (propertyShape.constraints.maxCount.isNothing() &&
-        propertyShape.constraints.minCount.isNothing()) {
-        return Either.of({
-            itemType,
-            kind: "SetType",
-            mutable: propertyShape.mutable,
-            minCount: 0,
-        });
-    }
-    let maxCount = propertyShape.constraints.maxCount.orDefault(Number.MAX_SAFE_INTEGER);
-    let minCount = propertyShape.constraints.minCount.orDefault(0);
-    if (minCount < 0) {
-        minCount = 0;
-    }
-    if (propertyShape.constraints.hasValues.length > minCount) {
-        minCount = propertyShape.constraints.hasValues.length;
-    }
-    if (maxCount < minCount) {
-        maxCount = minCount;
-    }
-    if (minCount === 0 && maxCount === 1) {
-        return Either.of({
-            itemType,
-            kind: "OptionType",
-        });
-    }
-    if (minCount === 1 && maxCount === 1) {
-        return Either.of(itemType);
-    }
-    invariant(propertyShape.constraints.minCount.isJust() ||
-        propertyShape.constraints.maxCount.isJust());
-    return Either.of({
-        itemType,
-        kind: "SetType",
-        minCount,
-        mutable: propertyShape.mutable,
     });
 }
-export function transformPropertyShapeToAstObjectTypeProperty(propertyShape) {
-    {
-        const property = this.astObjectTypePropertiesByIdentifier.get(propertyShape.identifier);
-        if (property) {
-            return Either.of(property);
+function transformPropertyShapeToAstType(propertyShape) {
+    // if (
+    //   propertyShape.path.kind === "PredicatePath" &&
+    //   propertyShape.path.iri.value.endsWith("termProperty")
+    // ) {
+    // }
+    return this.transformShapeToAstType(propertyShape, new ShapeStack()).chain((propertyShapeAstType) => {
+        let maxCount = propertyShape.constraints.maxCount.orDefault(Number.MAX_SAFE_INTEGER);
+        let minCount = propertyShape.constraints.minCount.orDefault(0);
+        if (minCount < 0) {
+            minCount = 0;
         }
-    }
-    const typeEither = transformPropertyShapeToAstType.bind(this)(propertyShape);
-    if (typeEither.isLeft()) {
-        return typeEither;
-    }
-    const type = typeEither.unsafeCoerce();
-    let stubType = Maybe.empty();
-    let propertyShapeStubItemType;
-    if (propertyShape.stub.isJust()) {
-        const propertyShapeStubTypeEither = this.transformNodeShapeToAstType(propertyShape.stub.unsafeCoerce()).chain((propertyShapeStubType) => {
-            switch (propertyShapeStubType.kind) {
-                case "ListType":
-                case "ObjectIntersectionType":
-                    return Left(new Error(`${propertyShape} stub cannot refer to a ${propertyShapeStubType.kind}`));
-                case "ObjectType":
-                case "ObjectUnionType":
-                    return Either.of(propertyShapeStubType);
+        if (propertyShape.constraints.hasValues.length > minCount) {
+            minCount = propertyShape.constraints.hasValues.length;
+        }
+        if (maxCount < minCount) {
+            maxCount = minCount;
+        }
+        if (propertyShapeAstType.kind === "DefaultValueType") {
+            if (minCount > 0) {
+                return Left(new Error(`${propertyShape}: has sh:minCount > 0 and sh:defaultValue`));
             }
-        });
-        if (propertyShapeStubTypeEither.isLeft()) {
-            return propertyShapeStubTypeEither;
+            if (maxCount > 1) {
+                return Left(new Error(`${propertyShape}: sets with sh:defaultValue are currently unsupported`));
+            }
+            return Either.of(propertyShapeAstType);
         }
-        propertyShapeStubItemType = propertyShapeStubTypeEither.unsafeCoerce();
-    }
-    if (propertyShapeStubItemType || propertyShape.lazy.orDefault(false)) {
-        switch (type.kind) {
-            case "ObjectType":
-            case "ObjectUnionType":
-                stubType = Maybe.of(propertyShapeStubItemType ??
-                    synthesizeStubAstObjectType({
-                        identifierNodeKinds: identifierNodeKinds(type),
-                        tsFeatures: type.tsFeatures,
-                    }));
-                break;
-            case "OptionType":
-            case "SetType": {
-                switch (type.itemType.kind) {
+        if (minCount === 1 && maxCount === 1) {
+            return Either.of(propertyShapeAstType);
+        }
+        if (minCount === 0 && maxCount === 1) {
+            if (!ast.OptionType.isItemType(propertyShapeAstType)) {
+                return Left(new Error(`${propertyShape}: ${propertyShapeAstType} is not an OptionType item type`));
+            }
+            return Either.of(new ast.OptionType({
+                itemType: propertyShapeAstType,
+            }));
+        }
+        if (!ast.SetType.isItemType(propertyShapeAstType)) {
+            return Left(new Error(`${propertyShape}: ${propertyShapeAstType} is not a SetType item type`));
+        }
+        return Either.of(new ast.SetType({
+            itemType: propertyShapeAstType,
+            minCount,
+            mutable: propertyShape.mutable.orDefault(false),
+        }));
+    });
+}
+export function transformPropertyShapeToAstObjectTypeProperty({ objectType, propertyShape, }) {
+    return Eithers.chain3(transformShapeToAstAbstractTypeProperties(propertyShape), propertyShape.resolve, transformPropertyShapeToAstType.bind(this)(propertyShape)).chain(([astAbstractTypeProperties, propertyShapeResolve, astType]) => {
+        let astResolveItemType;
+        if (propertyShapeResolve.isJust()) {
+            const astResolveTypeEither = this.transformNodeShapeToAstType(propertyShapeResolve.unsafeCoerce()).chain((astResolveType) => {
+                switch (astResolveType.kind) {
+                    case "ListType":
+                    case "ObjectIntersectionType":
+                        return Left(new Error(`${propertyShape} resolve cannot refer to a ${astResolveType.kind}`));
                     case "ObjectType":
                     case "ObjectUnionType":
-                        break;
-                    default:
-                        return Left(new Error(`${propertyShape} marked lazy but has ${type.kind} of ${type.itemType.kind}`));
+                        return Either.of(astResolveType);
                 }
-                const stubItemType = propertyShapeStubItemType ??
-                    synthesizeStubAstObjectType({
-                        identifierNodeKinds: identifierNodeKinds(type.itemType),
-                        tsFeatures: type.itemType.tsFeatures,
+            });
+            if (astResolveTypeEither.isLeft()) {
+                return astResolveTypeEither;
+            }
+            astResolveItemType = astResolveTypeEither.unsafeCoerce();
+        }
+        if (astResolveItemType) {
+            let astItemType;
+            switch (astType.kind) {
+                case "DefaultValueType":
+                case "OptionType":
+                case "SetType":
+                    astItemType = astType.itemType;
+                    break;
+                case "LazyObjectOptionType":
+                case "LazyObjectSetType":
+                // biome-ignore lint/suspicious/noFallthroughSwitchClause: break is unreachable
+                case "LazyObjectType":
+                    invariant(false, `lazy types should not appear here: ${astType.kind}`);
+                default:
+                    astItemType = astType;
+                    break;
+            }
+            let astPartialItemType;
+            switch (astItemType.kind) {
+                case "BlankNodeType":
+                case "IdentifierType":
+                case "IriType":
+                    astPartialItemType = synthesizePartialAstObjectType({
+                        identifierType: astItemType,
+                        tsFeatures: astResolveItemType.tsFeatures,
+                    });
+                    break;
+                case "ObjectType":
+                case "ObjectUnionType":
+                    astPartialItemType = astItemType;
+                    break;
+                default:
+                    return Left(new Error(`${propertyShape} has a resolve with an incompatible partial type ${astItemType.kind}`));
+            }
+            switch (astType.kind) {
+                case "BlankNodeType":
+                case "IdentifierType":
+                case "IriType":
+                case "ObjectType":
+                case "ObjectUnionType":
+                    astType = new ast.LazyObjectType({
+                        ...astAbstractTypeProperties,
+                        partialType: astPartialItemType,
+                        resolveType: astResolveItemType,
+                    });
+                    break;
+                case "OptionType":
+                    astType = new ast.LazyObjectOptionType({
+                        ...astAbstractTypeProperties,
+                        partialType: new ast.OptionType({
+                            itemType: astPartialItemType,
+                        }),
+                        resolveType: new ast.OptionType({
+                            itemType: astResolveItemType,
+                        }),
                     });
-                switch (type.kind) {
-                    case "OptionType":
-                        stubType = Maybe.of({
-                            kind: "OptionType",
-                            itemType: stubItemType,
-                        });
-                        break;
-                    case "SetType":
-                        stubType = Maybe.of({
-                            kind: "SetType",
-                            itemType: stubItemType,
+                    break;
+                case "SetType":
+                    astType = new ast.LazyObjectSetType({
+                        ...astAbstractTypeProperties,
+                        partialType: new ast.SetType({
+                            itemType: astPartialItemType,
                             minCount: 0,
-                            mutable: Maybe.empty(),
-                        });
-                        break;
-                }
-                break;
+                            mutable: false,
+                        }),
+                        resolveType: new ast.SetType({
+                            itemType: astResolveItemType,
+                            minCount: 0,
+                            mutable: false,
+                        }),
+                    });
+                    break;
+                default:
+                    invariant(false, `unexpected lazy AST type ${astType.kind}`);
             }
-            default:
-                return Left(new Error(`${propertyShape} marked lazy but has ${type.kind}`));
         }
-    }
-    const path = propertyShape.path;
-    if (path.kind !== "PredicatePath") {
-        return Left(new Error(`${propertyShape} has non-predicate path, unsupported`));
-    }
-    const property = {
-        comment: pickLiteral(propertyShape.comments).map((literal) => literal.value),
-        description: pickLiteral(propertyShape.descriptions).map((literal) => literal.value),
-        label: pickLiteral(propertyShape.labels).map((literal) => literal.value),
-        mutable: propertyShape.mutable,
-        name: this.shapeAstName(propertyShape),
-        order: propertyShape.order.orDefault(0),
-        path,
-        stubType,
-        type: type,
-        visibility: propertyShape.visibility,
-    };
-    this.astObjectTypePropertiesByIdentifier.set(propertyShape.identifier, property);
-    return Either.of(property);
+        return Either.of(new ast.ObjectType.Property({
+            comment: propertyShape.comment,
+            description: propertyShape.description,
+            label: propertyShape.label,
+            mutable: propertyShape.mutable.orDefault(false),
+            name: propertyShape.shaclmateName.alt(propertyShape.name),
+            objectType,
+            order: propertyShape.order.orDefault(0),
+            path: (propertyShape.path.termType === "NamedNode"
+                ? this.curieFactory.create(propertyShape.path).extract()
+                : undefined) ?? propertyShape.path,
+            shapeIdentifier: (propertyShape.identifier.termType === "NamedNode"
+                ? this.curieFactory.create(propertyShape.identifier).extract()
+                : undefined) ?? propertyShape.identifier,
+            type: astType,
+            visibility: propertyShape.visibility,
+        }));
+    });
 }
 //# sourceMappingURL=transformPropertyShapeToAstObjectTypeProperty.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstAbstractTypeProperties.d.ts

@@ -0,0 +1,12 @@
+import { Either, Maybe } from "purify-ts";
+import type * as input from "../input/index.js";
+type AstAbstractTypeProperties = {
+    readonly comment: Maybe<string>;
+    readonly label: Maybe<string>;
+};
+declare namespace AstAbstractTypeProperties {
+    const empty: AstAbstractTypeProperties;
+}
+export declare function transformShapeToAstAbstractTypeProperties(shape: input.Shape): Either<Error, AstAbstractTypeProperties>;
+export {};
+//# sourceMappingURL=transformShapeToAstAbstractTypeProperties.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstAbstractTypeProperties.js

@@ -0,0 +1,31 @@
+import { Either, Maybe } from "purify-ts";
+var AstAbstractTypeProperties;
+(function (AstAbstractTypeProperties) {
+    AstAbstractTypeProperties.empty = {
+        comment: Maybe.empty(),
+        label: Maybe.empty(),
+    };
+})(AstAbstractTypeProperties || (AstAbstractTypeProperties = {}));
+export function transformShapeToAstAbstractTypeProperties(shape) {
+    if (shape.kind === "PropertyShape") {
+        // comment, label, et al. belong to the ObjectType.Property, not to the type
+        return Either.of(AstAbstractTypeProperties.empty);
+    }
+    return shape.constraints.properties.chain((properties) => {
+        if (properties.length > 0) {
+            // comment, label, et al. belong to the ObjectType, not to the type
+            return Either.of(AstAbstractTypeProperties.empty);
+        }
+        return shape.constraints.xone.map((xone) => {
+            if (xone.length > 0) {
+                // comment, label, et al. belong to the ObjectType, not to the type
+                return AstAbstractTypeProperties.empty;
+            }
+            return {
+                comment: shape.comment,
+                label: shape.label,
+            };
+        });
+    });
+}
+//# sourceMappingURL=transformShapeToAstAbstractTypeProperties.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.d.ts

@@ -0,0 +1,10 @@
+import { Either, Maybe } from "purify-ts";
+import * as ast from "../ast/index.js";
+import type * as input from "../input/index.js";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import type { ShapeStack } from "./ShapeStack.js";
+/**
+ * Try to convert a shape to a compound type (intersection or union) using some heuristics.
+ */
+export declare function transformShapeToAstCompoundType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<Exclude<ast.Type, ast.PlaceholderType>>>;
+//# sourceMappingURL=transformShapeToAstCompoundType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.js

@@ -0,0 +1,141 @@
+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 { transformShapeToAstAbstractTypeProperties } from "./transformShapeToAstAbstractTypeProperties.js";
+/**
+ * Try to convert a shape to a compound type (intersection or union) using some heuristics.
+ */
+export function transformShapeToAstCompoundType(shape, shapeStack) {
+    shapeStack.push(shape);
+    try {
+        return Eithers.chain3(shape.constraints.and, shape.constraints.nodes, shape.constraints.xone).chain(([andConstraintShapes, nodeConstraintShapes, xoneConstraintShapes]) => {
+            let compoundTypeKind;
+            // Distinguish constraints that take arbitrary shapes from those that only take node shapes
+            // With the latter we'll do special transformations.
+            let memberShapes;
+            let memberNodeShapes;
+            if (andConstraintShapes.length > 0) {
+                memberShapes = andConstraintShapes;
+                compoundTypeKind = "IntersectionType";
+            }
+            else if (nodeConstraintShapes.length > 0) {
+                memberNodeShapes = nodeConstraintShapes;
+                compoundTypeKind = "IntersectionType";
+            }
+            else if (xoneConstraintShapes.length > 0) {
+                memberShapes = xoneConstraintShapes;
+                compoundTypeKind = "UnionType";
+            }
+            else {
+                return Either.of(Maybe.empty());
+            }
+            const memberDiscriminantValues = [];
+            const memberTypes = [];
+            if (memberNodeShapes) {
+                invariant(memberNodeShapes.length > 0);
+                invariant(!memberShapes);
+                for (const memberNodeShape of memberNodeShapes) {
+                    const memberTypeEither = this.transformNodeShapeToAstType(memberNodeShape);
+                    if (memberTypeEither.isLeft()) {
+                        return memberTypeEither;
+                    }
+                    memberTypes.push(memberTypeEither.unsafeCoerce());
+                    if (compoundTypeKind === "UnionType") {
+                        const memberDiscriminantValue = memberNodeShape.discriminantValue.extract();
+                        if (memberDiscriminantValue) {
+                            memberDiscriminantValues.push(memberDiscriminantValue);
+                        }
+                        else if (memberDiscriminantValues.length > 0) {
+                            return Left(new Error(`${shape} does not have a discriminant value while the other members of the compound type do`));
+                        }
+                    }
+                }
+            }
+            else if (memberShapes) {
+                invariant(memberShapes.length > 0);
+                for (const memberShape of memberShapes) {
+                    const memberTypeEither = this.transformShapeToAstType(memberShape, shapeStack);
+                    if (memberTypeEither.isLeft()) {
+                        return memberTypeEither;
+                    }
+                    memberTypes.push(memberTypeEither.unsafeCoerce());
+                    if (compoundTypeKind === "UnionType") {
+                        let memberDiscriminantValue;
+                        if (memberShape.kind === "NodeShape") {
+                            memberDiscriminantValue =
+                                memberShape.discriminantValue.extract();
+                        }
+                        if (memberDiscriminantValue) {
+                            if (memberDiscriminantValues.includes(memberDiscriminantValue)) {
+                                return Left(new Error(`${shape} member ${memberShape} has a duplicate discriminant value: ${memberDiscriminantValue}`));
+                            }
+                            memberDiscriminantValues.push(memberDiscriminantValue);
+                        }
+                        else if (memberDiscriminantValues.length > 0) {
+                            return Left(new Error(`${shape} member ${memberShape} does not have a discriminant value while the other members of the compound type do`));
+                        }
+                    }
+                }
+            }
+            else {
+                invariant(false);
+            }
+            if (memberTypes.length === 1) {
+                return Either.of(Maybe.of(memberTypes[0]));
+            }
+            return transformShapeToAstAbstractTypeProperties(shape).chain((astAbstractTypeProperties) => {
+                // If every member type is an ObjectType, ObjectIntersectionType, or ObjectUnionType (the latter of which can be flattened to ObjectTypes),
+                // produce a different AST type (ObjectIntersectionType or ObjectUnionType).
+                if (memberTypes.every((memberType) => {
+                    switch (memberType.kind) {
+                        case "ObjectType":
+                        case "ObjectIntersectionType":
+                        case "ObjectUnionType":
+                            return true;
+                        default:
+                            return false;
+                    }
+                })) {
+                    const compoundType = new (compoundTypeKind === "IntersectionType"
+                        ? ast.ObjectIntersectionType
+                        : ast.ObjectUnionType)({
+                        ...astAbstractTypeProperties,
+                        export_: true,
+                        name: shape.shaclmateName,
+                        shapeIdentifier: this.shapeIdentifier(shape),
+                        tsFeatures: Maybe.empty(),
+                    });
+                    for (const memberType of memberTypes) {
+                        const addMemberTypeResult = compoundType.addMemberType(memberType);
+                        if (addMemberTypeResult.isLeft()) {
+                            return addMemberTypeResult;
+                        }
+                    }
+                }
+                // Compound type doesn't solely consist of ObjectTypes
+                switch (compoundTypeKind) {
+                    case "IntersectionType":
+                        return Either.of(Maybe.of(new ast.IntersectionType({
+                            ...astAbstractTypeProperties,
+                            memberTypes,
+                        })));
+                    case "UnionType":
+                        if (memberDiscriminantValues.length > 0 &&
+                            memberDiscriminantValues.length !== memberTypes.length) {
+                            return Left(new Error(`${shape} has members without discriminant values`));
+                        }
+                        return Either.of(Maybe.of(new ast.UnionType({
+                            ...astAbstractTypeProperties,
+                            memberDiscriminantValues,
+                            memberTypes,
+                        })));
+                }
+            });
+        });
+    }
+    finally {
+        shapeStack.pop(shape);
+    }
+}
+//# sourceMappingURL=transformShapeToAstCompoundType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstTermType.d.ts

@@ -1,12 +1,12 @@
 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";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
 import type { ShapeStack } from "./ShapeStack.js";
+type AstTermType = ast.BlankNodeType | ast.DefaultValueType<ast.IdentifierType | ast.LiteralType | ast.IriType | ast.TermType> | ast.IdentifierType | ast.IriType | ast.LiteralType | ast.TermType;
 /**
  * Try to convert a shape to an AST TermType using some heuristics.
  */
-export declare function transformShapeToAstTermType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Omit<ast.TermType, "kind"> & {
-    readonly kind: "TermType";
-}>;
+export declare function transformShapeToAstTermType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, AstTermType>;
+export {};
 //# sourceMappingURL=transformShapeToAstTermType.d.ts.map