@shaclmate/compiler 4.0.50 → 4.0.52

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstStructTypeField.js

@@ -0,0 +1,285 @@
+import dataFactory from "@rdfx/data-factory";
+import { Curie } from "@shaclmate/shacl-ast";
+import { sh } from "@tpluscode/rdf-ns-builders";
+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 { transformShapeToAstType } from "./transformShapeToAstType.js";
+function fieldName(propertyShape, structType) {
+    // Explicit shaclmate:name or sh:name
+    const name = propertyShape.shaclmateName.alt(propertyShape.name).extract();
+    if (name) {
+        return name;
+    }
+    // Explicit rdfs:label
+    const label = propertyShape.label.extract();
+    if (label) {
+        return label;
+    }
+    // Pick up the common pattern of a property shape identifier being the node shape's identifier -localName,
+    // like ex:NodeShape-property
+    const propertyShapeIdentifier = propertyShape.$identifier();
+    if (propertyShapeIdentifier.termType === "NamedNode" &&
+        structType.shapeIdentifier.termType === "NamedNode") {
+        const propertyShapeIdentifierPrefix = `${structType.shapeIdentifier.value}-`;
+        if (propertyShapeIdentifier.value.startsWith(propertyShapeIdentifierPrefix) &&
+            propertyShapeIdentifier.value.length >
+                propertyShapeIdentifierPrefix.length) {
+            return propertyShapeIdentifier.value.substring(propertyShapeIdentifierPrefix.length);
+        }
+    }
+    // sh:path CURIE reference
+    if (propertyShape.path instanceof Curie) {
+        return propertyShape.path.reference;
+    }
+    // Shape identifier CURIE reference
+    if (propertyShapeIdentifier instanceof Curie) {
+        return propertyShapeIdentifier.reference;
+    }
+    // Shape identifier IRI
+    if (propertyShapeIdentifier.termType === "NamedNode") {
+        return propertyShapeIdentifier.value;
+    }
+    // sh:path IRI
+    if (propertyShape.path.termType === "NamedNode") {
+        return propertyShape.path.value;
+    }
+    throw new Error(`${propertyShape}: unable to infer name`);
+}
+function synthesizePartialAstStructType({ identifierType, }) {
+    let syntheticName;
+    switch (identifierType.kind) {
+        case "BlankNode":
+            throw new Error("should never happen");
+        case "Identifier":
+            syntheticName = "DefaultPartial";
+            break;
+        case "Iri":
+            syntheticName = "NamedDefaultPartial";
+            break;
+    }
+    let partialAstStructType = this.syntheticAstStructTypesByName.get(syntheticName);
+    if (partialAstStructType) {
+        return partialAstStructType;
+    }
+    partialAstStructType = new ast.StructType({
+        comment: Maybe.empty(),
+        extern: false,
+        fromRdfType: Maybe.empty(),
+        identifierType,
+        label: Maybe.empty(),
+        name: Maybe.of(syntheticName),
+        shapeIdentifier: dataFactory.namedNode(`urn:shaclmate:synthetic:${syntheticName}`),
+        synthetic: true,
+        toRdfTypes: [],
+        tsImports: [],
+    });
+    this.syntheticAstStructTypesByName.set(syntheticName, partialAstStructType);
+    return partialAstStructType;
+}
+function transformPropertyShapeToAstType(propertyShape, shapeStack) {
+    // if (
+    //   propertyShape.path.kind === "PredicatePath" &&
+    //   propertyShape.path.iri.value.endsWith("termProperty")
+    // ) {
+    // }
+    return transformShapeToAstType
+        .call(this, propertyShape, shapeStack)
+        .chain((propertyShapeAstType) => {
+        let maxCount = propertyShape.maxCount.orDefault(BigInt(Number.MAX_SAFE_INTEGER));
+        let minCount = propertyShape.minCount.orDefault(0n);
+        if (minCount < 0n) {
+            minCount = 0n;
+        }
+        if (propertyShape.hasValues.length > minCount) {
+            minCount = BigInt(propertyShape.hasValues.length);
+        }
+        if (maxCount < minCount) {
+            maxCount = minCount;
+        }
+        if (propertyShapeAstType.kind === "DefaultValue") {
+            if (minCount > 0n) {
+                return Left(new Error(`${propertyShape}: has sh:minCount > 0 and sh:defaultValue`));
+            }
+            if (maxCount > 1) {
+                return Left(new Error(`${propertyShape}: sets with sh:defaultValue are currently unsupported`));
+            }
+            return Either.of(propertyShapeAstType);
+        }
+        if (minCount === 1n && maxCount === 1n) {
+            return Either.of(propertyShapeAstType);
+        }
+        if (minCount === 0n && maxCount === 1n) {
+            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),
+        }));
+    });
+}
+/**
+ * Try to transform a property shape to an ast.StructType.Field.
+ *
+ * Returns:
+ *  - Right<Just<ast.StructType.Field>> if the transformation succeeds
+ *  - Right<Nothing> if the property shape should be ignored
+ *  - Left<Error> if the transformation fails
+ */
+export function transformPropertyShapeToAstStructTypeField({ propertyShape, structType, }) {
+    if (propertyShape.ignore) {
+        return Either.of(Maybe.empty());
+    }
+    switch (propertyShape.severity.orDefault(sh.Violation).value) {
+        case "http://www.w3.org/ns/shacl#Info":
+        case "http://www.w3.org/ns/shacl#Warning":
+            return Either.of(Maybe.empty());
+    }
+    const shapeStack = new ShapeStack(); // Start a new ShapeStack per property shape
+    return Eithers.chain2(propertyShape.resolve.isJust()
+        ? this.shapesGraph
+            .nodeShape(propertyShape.resolve.extract())
+            .map(Maybe.of)
+        : Either.of(Maybe.empty()), transformPropertyShapeToAstType.call(this, propertyShape, shapeStack)).chain(([propertyShapeResolve, astType]) => {
+        let astResolveItemType;
+        if (propertyShapeResolve.isJust()) {
+            const astResolveTypeEither = transformShapeToAstType
+                .call(this, propertyShapeResolve.unsafeCoerce(), shapeStack)
+                .chain((astResolveType) => {
+                switch (astResolveType.kind) {
+                    case "Struct":
+                        return Either.of(astResolveType);
+                    case "Union":
+                        if (
+                        // This check relies on .members being populated, which may not happen in cycles
+                        astResolveType.members.length > 0 &&
+                            !astResolveType.isStructUnionType()) {
+                            return Left(new Error(`${propertyShape} resolve cannot refer to a ${astResolveType.kind} with non-StructType members`));
+                        }
+                        return Either.of(astResolveType);
+                    default:
+                        return Left(new Error(`${propertyShape} resolve cannot refer to a ${astResolveType.kind}`));
+                }
+            });
+            if (astResolveTypeEither.isLeft()) {
+                return astResolveTypeEither;
+            }
+            astResolveItemType = astResolveTypeEither.unsafeCoerce();
+        }
+        if (astResolveItemType) {
+            let astItemType;
+            switch (astType.kind) {
+                case "DefaultValue":
+                case "Option":
+                case "Set":
+                    astItemType = astType.itemType;
+                    break;
+                case "LazyOption":
+                case "LazySet":
+                // biome-ignore lint/suspicious/noFallthroughSwitchClause: break is unreachable
+                case "Lazy":
+                    invariant(false, `lazy types should not appear here: ${astType.kind}`);
+                default:
+                    astItemType = astType;
+                    break;
+            }
+            let astPartialItemType;
+            switch (astItemType.kind) {
+                case "BlankNode":
+                case "Identifier":
+                case "Iri":
+                    astPartialItemType = synthesizePartialAstStructType.call(this, {
+                        identifierType: astItemType,
+                    });
+                    break;
+                case "Struct":
+                    astPartialItemType = astItemType;
+                    break;
+                case "Union":
+                    if (!astItemType.isStructUnionType()) {
+                        return Left(new Error(`${propertyShape} partial type cannot be a ${astItemType.kind} with non-StructType members`));
+                    }
+                    astPartialItemType = astItemType;
+                    break;
+                default:
+                    return Left(new Error(`${propertyShape} has a resolve with an incompatible partial type ${astItemType.kind}`));
+            }
+            const astAbstractTypeProperties = {
+                comment: Maybe.empty(),
+                label: Maybe.empty(),
+                name: Maybe.empty(),
+                shapeIdentifier: propertyShape.$identifier(),
+            };
+            switch (astType.kind) {
+                case "BlankNode":
+                case "Identifier":
+                case "Iri":
+                case "Struct":
+                case "Union":
+                    astType = new ast.LazyType({
+                        ...astAbstractTypeProperties,
+                        partialType: astPartialItemType,
+                        resolveType: astResolveItemType,
+                    });
+                    break;
+                case "Option":
+                    astType = new ast.LazyOptionType({
+                        ...astAbstractTypeProperties,
+                        partialType: new ast.OptionType({
+                            itemType: astPartialItemType,
+                        }),
+                        resolveType: new ast.OptionType({
+                            itemType: astResolveItemType,
+                        }),
+                    });
+                    break;
+                case "Set":
+                    astType = new ast.LazySetType({
+                        ...astAbstractTypeProperties,
+                        partialType: new ast.SetType({
+                            itemType: astPartialItemType,
+                            minCount: 0n,
+                            mutable: false,
+                        }),
+                        resolveType: new ast.SetType({
+                            itemType: astResolveItemType,
+                            minCount: 0n,
+                            mutable: false,
+                        }),
+                    });
+                    break;
+                default:
+                    invariant(false, `unexpected lazy AST type ${astType.kind}`);
+            }
+        }
+        if (propertyShape.path.termType === "InversePath" &&
+            astType.nodeKinds.has("Literal")) {
+            return Left(new Error(`${propertyShape}: property shapes with inverse paths can only have blank node or IRI node kinds`));
+        }
+        return Either.of(Maybe.of(new ast.StructType.Field({
+            comment: propertyShape.comment,
+            description: propertyShape.description,
+            display: propertyShape.display,
+            label: propertyShape.label,
+            mutable: propertyShape.mutable.orDefault(false),
+            name: fieldName.call(this, propertyShape, structType),
+            order: propertyShape.order.orDefault(0),
+            path: propertyShape.path,
+            shapeIdentifier: propertyShape.$identifier(),
+            structType,
+            type: astType,
+        })));
+    });
+}
+//# sourceMappingURL=transformPropertyShapeToAstStructTypeField.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<ast.Type>>;
+//# sourceMappingURL=transformShapeToAstCompoundType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.js

@@ -0,0 +1,92 @@
+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 { shapeAstTypeName } from "./shapeAstTypeName.js";
+import { transformShapeToAstType } from "./transformShapeToAstType.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.chain2(Either.sequence(shape.and
+            .orDefault([])
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier))), Either.sequence(shape.xone
+            .orDefault([])
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([andConstraintShapes, 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;
+            if (andConstraintShapes.length > 0) {
+                memberShapes = andConstraintShapes;
+                compoundTypeKind = "Intersection";
+            }
+            else if (xoneConstraintShapes.length > 0) {
+                memberShapes = xoneConstraintShapes;
+                compoundTypeKind = "Union";
+            }
+            else {
+                return Either.of(Maybe.empty());
+            }
+            invariant(memberShapes.length > 0);
+            const memberDiscriminantValues = new Set();
+            const compoundType = new (compoundTypeKind === "Intersection"
+                ? ast.IntersectionType
+                : ast.UnionType)({
+                comment: shape.comment,
+                label: shape.label,
+                name: shapeAstTypeName(shape),
+                shapeIdentifier: shape.$identifier(),
+                synthetic: false,
+            });
+            if (memberShapes.length === 1) {
+                return transformShapeToAstType
+                    .call(this, memberShapes[0], shapeStack)
+                    .map(Maybe.of);
+            }
+            // Put a placeholder in the cache to deal with cyclic references
+            this.cachedAstTypesByShapeIdentifier.set(shape.$identifier(), compoundType);
+            return Either.sequence(memberShapes.map((memberShape) => transformShapeToAstType.call(this, memberShape, shapeStack)))
+                .chain((memberShapeTypes) => {
+                for (let memberI = 0; memberI < memberShapes.length; memberI++) {
+                    const memberShape = memberShapes[memberI];
+                    const memberType = memberShapeTypes[memberI];
+                    if (!ast.IntersectionType.isMemberType(memberType)) {
+                        return Left(new Error(`${shape} has an invalid member type kind "${memberType.kind}"`));
+                    }
+                    if (memberI > 0 &&
+                        compoundType.members.some((existingMember) => ast.Type.equals(memberType, existingMember.type))) {
+                        return Left(new Error(`${shape} has duplicate ${compoundTypeKind} member type: ${memberType}`));
+                    }
+                    let memberDiscriminantValue;
+                    if (compoundTypeKind === "Union") {
+                        if (memberShape.$type === "NodeShape") {
+                            memberDiscriminantValue =
+                                memberShape.discriminantValue.extract();
+                        }
+                        if (memberDiscriminantValue) {
+                            if (memberDiscriminantValues.has(memberDiscriminantValue)) {
+                                return Left(new Error(`${shape} member ${memberShape} has a duplicate discriminant value: ${memberDiscriminantValue}`));
+                            }
+                            memberDiscriminantValues.add(memberDiscriminantValue);
+                        }
+                    }
+                    compoundType.addMember({
+                        discriminantValue: Maybe.fromNullable(memberDiscriminantValue),
+                        type: memberType,
+                    });
+                }
+                return Either.of(Maybe.of(compoundType));
+            })
+                .ifLeft(() => {
+                this.cachedAstTypesByShapeIdentifier.delete(shape.$identifier());
+            });
+        });
+    }
+    finally {
+        shapeStack.pop(shape);
+    }
+}
+//# sourceMappingURL=transformShapeToAstCompoundType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.d.ts

@@ -0,0 +1,11 @@
+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";
+/**
+ * Is an ast.StructType actually the shape of an RDF list?
+ * If so, return the type of its rdf:first.
+ */
+export declare function transformShapeToAstListType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.ListType>>;
+//# sourceMappingURL=transformShapeToAstListType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -0,0 +1,149 @@
+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";
+import { Eithers } from "../Eithers.js";
+import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
+import { shapeNodeKinds } from "./shapeNodeKinds.js";
+import { transformPropertyShapeToAstStructTypeField } from "./transformPropertyShapeToAstStructTypeField.js";
+const listPropertiesStructType = new ast.StructType({
+    extern: false,
+    comment: Maybe.empty(),
+    label: Maybe.empty(),
+    identifierType: new ast.IdentifierType({
+        comment: Maybe.empty(),
+        label: Maybe.empty(),
+        name: Maybe.empty(),
+        shapeIdentifier: dataFactory.blankNode(),
+    }),
+    fromRdfType: Maybe.empty(),
+    name: Maybe.empty(),
+    toRdfTypes: [],
+    shapeIdentifier: dataFactory.blankNode(),
+    synthetic: true,
+    tsImports: [],
+});
+const astListTypePlaceholderItemType = new ast.BlankNodeType({
+    comment: Maybe.empty(),
+    label: Maybe.empty(),
+    name: Maybe.empty(),
+    shapeIdentifier: dataFactory.blankNode(),
+});
+const empty = Either.of(Maybe.empty());
+/**
+ * Is an ast.StructType actually the shape of an RDF list?
+ * If so, return the type of its rdf:first.
+ */
+export function transformShapeToAstListType(shape, shapeStack) {
+    shapeStack.push(shape);
+    try {
+        if (shape.$type !== "NodeShape") {
+            return empty;
+        }
+        const nodeShape = shape;
+        return Eithers.chain2(shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.xone
+            .orDefault([])
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([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: astListTypePlaceholderItemType,
+                label: nodeShape.label,
+                mutable: nodeShape.mutable.orDefault(false),
+                // name: shapeAstTypeName(nodeShape),
+                // List types don't need names currently
+                name: Maybe.empty(),
+                shapeIdentifier: nodeShape.$identifier(),
+                toRdfTypes: nodeShape.toRdfTypes,
+            });
+            this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier(), listType);
+            return (() => {
+                let emptyListShape;
+                let nonEmptyListShape;
+                for (const shape of xone) {
+                    if (shape.hasValues.length === 1 &&
+                        shape.hasValues[0].equals(rdf.nil)) {
+                        emptyListShape = shape;
+                    }
+                    else if (shape.$type === "NodeShape" &&
+                        shape.properties.length >= 2) {
+                        nonEmptyListShape = shape;
+                    }
+                }
+                if (!emptyListShape || !nonEmptyListShape) {
+                    return empty;
+                }
+                return Either.sequence(nonEmptyListShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))).chain((nonEmptyListShapePropertyShapes) => {
+                    let firstPropertyShape;
+                    let restPropertyShape;
+                    for (const propertyShape of nonEmptyListShapePropertyShapes) {
+                        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 empty;
+                    }
+                    if (firstPropertyShape.maxCount.extract() !== 1n ||
+                        firstPropertyShape.minCount.extract() !== 1n) {
+                        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 empty;
+                    }
+                    if (restPropertyShape.maxCount.extract() !== 1n ||
+                        restPropertyShape.minCount.extract() !== 1n) {
+                        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 transformPropertyShapeToAstStructTypeField
+                        .call(this, {
+                        // Just need a dummy ast.StructType here to get the properties transformed.
+                        propertyShape: firstPropertyShape,
+                        structType: listPropertiesStructType,
+                    })
+                        .chain((firstFieldMaybe) => {
+                        const firstField = firstFieldMaybe.extract();
+                        if (!firstField) {
+                            return Left(new Error(`${nodeShape}: rdf:first field is ignored`));
+                        }
+                        if (!ast.ListType.isItemType(firstField.type)) {
+                            return Left(new Error(`${nodeShape}: ${firstField.type.kind} is not a valid list item type`));
+                        }
+                        listType.itemType = firstField.type;
+                        return transformPropertyShapeToAstStructTypeField
+                            .call(this, {
+                            // Just need a dummy ast.StructType here to get the properties transformed.
+                            propertyShape: restPropertyShape,
+                            structType: listPropertiesStructType,
+                        })
+                            .chain((restFieldMaybe) => {
+                            const restField = restFieldMaybe.extract();
+                            if (!restField) {
+                                return Left(new Error(`${nodeShape}: rdf:rest field is ignored`));
+                            }
+                            if (restField.type.kind !== "List" ||
+                                !restField.type.shapeIdentifier.equals(nodeShape.$identifier())) {
+                                return Left(new Error(`${nodeShape} rdf:rest property is not recursive into the node shape`));
+                            }
+                            return Either.of(Maybe.of(listType));
+                        });
+                    });
+                });
+            })().ifLeft(() => {
+                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.$identifier());
+            });
+        });
+    }
+    finally {
+        shapeStack.pop(shape);
+    }
+}
+//# sourceMappingURL=transformShapeToAstListType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstStructType.d.ts

@@ -0,0 +1,7 @@
+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";
+export declare function transformShapeToAstStructType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.Type>>;
+//# sourceMappingURL=transformShapeToAstStructType.d.ts.map