@shaclmate/compiler 4.0.11 → 4.0.13

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.js

@@ -1,10 +1,6 @@
 import { NodeKind } from "@shaclmate/shacl-ast";
 import { Either, Left } from "purify-ts";
-const defaultNodeShapeNodeKinds = new Set([
-    "BlankNode",
-    "IRI",
-    "Literal",
-]);
+import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
 const defaultPropertyShapeNodeKinds = new Set([
     "BlankNode",
     "IRI",
@@ -169,7 +165,11 @@ export function shapeNodeKinds(shape, options) {
         if (shape.kind === "NodeShape") {
             return Either.of(options?.defaultNodeShapeNodeKinds ?? defaultNodeShapeNodeKinds);
         }
-        return Either.of(options?.defaultPropertyShapeNodeKinds ?? defaultPropertyShapeNodeKinds);
+        if (shape.path.termType === "InversePath") {
+            // Inverse paths can only have blank nodes and IRIs as values, because the value is the subject of a triple.
+            return Either.of(new Set(["BlankNode", "IRI"]));
+        }
+        return Either.of(defaultPropertyShapeNodeKinds);
     });
 }
 //# sourceMappingURL=shapeNodeKinds.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -240,6 +240,10 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                     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(new ast.ObjectType.Property({
             comment: propertyShape.comment,
             description: propertyShape.description,

package/dist/ast/AbstractCompoundType.d.ts

@@ -1,3 +1,4 @@
+import type { NodeKind } from "@shaclmate/shacl-ast";
 import type { TsFeature } from "../enums/TsFeature.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
@@ -25,6 +26,7 @@ export declare abstract class AbstractCompoundType<MemberT extends AbstractCompo
         tsFeatures: ReadonlySet<TsFeature>;
     } & ConstructorParameters<typeof AbstractType>[0]);
     get members(): readonly MemberT[];
+    get nodeKinds(): ReadonlySet<NodeKind>;
     get recursive(): boolean;
     get tsFeatures(): ReadonlySet<TsFeature>;
     addMember(member: MemberT): void;

package/dist/ast/AbstractCompoundType.js

@@ -30,6 +30,15 @@ export class AbstractCompoundType extends AbstractType {
     get members() {
         return this.#members;
     }
+    get nodeKinds() {
+        const nodeKinds = new Set();
+        for (const member of this.members) {
+            for (const nodeKind of member.type.nodeKinds) {
+                nodeKinds.add(nodeKind);
+            }
+        }
+        return nodeKinds;
+    }
     get recursive() {
         return this.members.some((member) => member.type.recursive);
     }
@@ -75,6 +84,9 @@ export class AbstractCompoundType extends AbstractType {
         return `${this.kind}(memberTypes=[${this.members.map((memberType) => memberType.toString()).join(", ")}])`;
     }
 }
+__decorate([
+    Memoize()
+], AbstractCompoundType.prototype, "nodeKinds", null);
 __decorate([
     Memoize()
 ], AbstractCompoundType.prototype, "tsFeatures", null);

package/dist/ast/AbstractContainerType.d.ts

@@ -1,3 +1,4 @@
+import type { NodeKind } from "@shaclmate/shacl-ast";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
@@ -23,6 +24,7 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     constructor({ itemType, ...superParameters }: {
         itemType: ItemTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
+    get nodeKinds(): ReadonlySet<NodeKind>;
     get recursive(): boolean;
     equals(other: AbstractContainerType<ItemTypeT>): boolean;
     toString(): string;

package/dist/ast/AbstractContainerType.js

@@ -14,6 +14,9 @@ export class AbstractContainerType extends AbstractType {
         super(superParameters);
         this.itemType = itemType;
     }
+    get nodeKinds() {
+        return this.itemType.nodeKinds;
+    }
     get recursive() {
         return this.itemType.recursive;
     }

package/dist/ast/AbstractLazyObjectType.d.ts

@@ -1,3 +1,4 @@
+import type { NodeKind } from "@shaclmate/shacl-ast";
 import { AbstractType } from "./AbstractType.js";
 import type { ObjectType } from "./ObjectType.js";
 import type { ObjectUnionType } from "./ObjectUnionType.js";
@@ -14,6 +15,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         partialType: PartialTypeT;
         resolveType: ResolveTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
+    get nodeKinds(): ReadonlySet<NodeKind>;
     get recursive(): boolean;
     equals(other: AbstractLazyObjectType<PartialTypeT, ResolveTypeT>): boolean;
     toString(): string;

package/dist/ast/AbstractLazyObjectType.js

@@ -11,6 +11,9 @@ export class AbstractLazyObjectType extends AbstractType {
         this.partialType = partialType;
         this.resolveType = resolveType;
     }
+    get nodeKinds() {
+        return this.partialType.nodeKinds;
+    }
     get recursive() {
         return this.partialType.recursive;
     }

package/dist/ast/AbstractTermType.d.ts

@@ -1,5 +1,4 @@
 import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
-import type { NodeKind } from "@shaclmate/shacl-ast";
 import { AbstractType } from "./AbstractType.js";
 /**
  * Abstract base class of term types (BlankNodeType, IdentifierType, LiteralType, IriType, TermType).
@@ -13,7 +12,6 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     readonly hasValues: readonly ConstantTermT[];
     readonly in_: readonly ConstantTermT[];
     abstract readonly kind: "BlankNodeType" | "IdentifierType" | "IriType" | "LiteralType" | "TermType";
-    abstract readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly recursive = false;
     constructor({ hasValues, in_, ...superParameters }: {
         hasValues: readonly ConstantTermT[];

package/dist/ast/AbstractType.d.ts

@@ -1,4 +1,5 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { NodeKind } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 /**
  * Abstract base class for Types.
@@ -16,6 +17,12 @@ export declare abstract class AbstractType {
      * Name of this type, from shaclmate:name or sh:name.
      */
     readonly name: Maybe<string>;
+    /**
+     * The range of node kinds of this type.
+     *
+     * For example, an object type has blank and IRI node kinds, while a string type has a Literal node kind.
+     */
+    abstract readonly nodeKinds: ReadonlySet<NodeKind>;
     /**
      * Does this type directly or indirectly reference itself?
      */

package/dist/ast/ObjectType.d.ts

@@ -1,4 +1,5 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { NodeKind } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
 import { PropertyPath } from "rdfjs-resource";
 import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
@@ -43,6 +44,7 @@ export declare class ObjectType extends AbstractType {
      * Type discriminant.
      */
     readonly kind = "ObjectType";
+    readonly nodeKinds: ReadonlySet<NodeKind>;
     /**
      * Was this type synthesized or did it come from SHACL?
      */

package/dist/ast/ObjectType.js

@@ -73,6 +73,7 @@ export class ObjectType extends AbstractType {
      * Type discriminant.
      */
     kind = "ObjectType";
+    nodeKinds = nodeKinds;
     /**
      * Was this type synthesized or did it come from SHACL?
      */
@@ -169,6 +170,7 @@ export class ObjectType extends AbstractType {
         return `${this.kind}(shapeIdentifier=${Resource.Identifier.toString(this.shapeIdentifier)})`;
     }
 }
+const nodeKinds = new Set(["BlankNode", "IRI"]);
 (function (ObjectType) {
     class Property {
         /**

package/dist/generators/ts/AbstractCollectionType.js

@@ -196,7 +196,10 @@ export class AbstractCollectionType extends AbstractContainerType {
             schema = code `${schema}.nonempty().min(${this.minCount})`;
         }
         else {
-            schema = code `${schema}.default(() => [])`;
+            schema = code `${schema}.optional()`;
+        }
+        if (!this._mutable) {
+            schema = code `${schema}.readonly()`;
         }
         return schema;
     }

package/dist/generators/ts/AbstractUnionType.js

@@ -296,9 +296,9 @@ ${joinCode(this.concreteMembers.map(({ jsonTypeCheck, type, unwrap, wrap }) => c
                 return code `${imports.z}.discriminatedUnion("${this.discriminant.name}", [${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({
                     includeDiscriminantProperty: true,
                     context: "type",
-                })), { on: "," })}])`;
+                })), { on: "," })}]).readonly()`;
             case "typeof":
-                return code `${imports.z}.union([${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}])`;
+                return code `${imports.z}.union([${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
             default:
                 throw this.discriminant;
         }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.js

@@ -6,25 +6,19 @@ export function NamedObjectType_jsonSchemaFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
-    const mergeZodObjectSchemas = [];
+    let properties = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        mergeZodObjectSchemas.push(parentObjectType.jsonSchema({ context: "type" }));
+        properties.push(code `...${parentObjectType.jsonSchema({ context: "type" })}.shape`);
     }
     if (this.properties.length > 0) {
-        mergeZodObjectSchemas.push(code `${imports.z}.object({ ${joinCode(this.properties
+        properties = properties.concat(this.properties
             .flatMap((property) => property.jsonZchema.toList())
-            .map(({ key, schema }) => code `"${key}": ${schema}`), { on: "," })} })`);
+            .map(({ key, schema }) => code `"${key}": ${schema}`));
     }
+    // ${this.properties.every((property) => !property.mutable) ? `.readonly()` : ""}
     return Maybe.of(code `\
 export function schema() {
-  return ${mergeZodObjectSchemas.length > 0
-        ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
-            if (merged === null) {
-                return zodObjectSchema;
-            }
-            return code `${merged}.merge(${zodObjectSchema})`;
-        }, null)
-        : `${imports.z}.object()`} satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
+  return ${imports.z}.object({${joinCode(properties, { on: "," })}}) satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
 }`);
 }
 //# sourceMappingURL=NamedObjectType_jsonSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/ShaclProperty.js

@@ -101,7 +101,7 @@ export class ShaclProperty extends AbstractProperty {
     }
     get jsonSignature() {
         const typeJsonType = this.type.jsonType();
-        return Maybe.of(code `readonly ${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
+        return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
     }
     get jsonZchema() {
         let schema = this.type.jsonSchema({

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.11",
+    "@shaclmate/shacl-ast": "4.0.13",
     "@rdfjs/data-model": "~2.1.1",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
@@ -78,5 +78,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.11"
+  "version": "4.0.13"
 }