@shaclmate/compiler 2.0.15 → 2.0.17

package/{Compiler.js → dist/Compiler.js}

@@ -2,6 +2,8 @@ import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
 import { ShapesGraphToAstTransformer } from "./ShapesGraphToAstTransformer.js";
 import { ShapesGraph } from "./input/ShapesGraph.js";
 export class Compiler {
+    generator;
+    iriPrefixMap;
     constructor({ generator, iriPrefixMap, }) {
         this.generator = generator;
         this.iriPrefixMap = iriPrefixMap ?? new PrefixMap();

package/{ShapesGraphToAstTransformer.js → dist/ShapesGraphToAstTransformer.js}

@@ -3,18 +3,20 @@ import { dash } from "@tpluscode/rdf-ns-builders";
 import { Either, Maybe } from "purify-ts";
 import * as _ShapesGraphToAstTransformer from "./_ShapesGraphToAstTransformer/index.js";
 export class ShapesGraphToAstTransformer {
+    // Members are protected so they're accessible to the bound functions
+    astObjectTypePropertiesByIdentifier = new TermMap();
+    iriPrefixMap;
+    nodeShapeAstTypesByIdentifier = new TermMap();
+    shapeAstName = _ShapesGraphToAstTransformer.shapeAstName;
+    shapesGraph;
+    transformNodeShapeToAstType = _ShapesGraphToAstTransformer.transformNodeShapeToAstType;
+    transformPropertyShapeToAstCompositeType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstCompositeType;
+    transformPropertyShapeToAstIdentifierType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstIdentifierType;
+    transformPropertyShapeToAstLiteralType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstLiteralType;
+    transformPropertyShapeToAstObjectTypeProperty = _ShapesGraphToAstTransformer.transformPropertyShapeToAstObjectTypeProperty;
+    transformPropertyShapeToAstTermType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstTermType;
+    transformPropertyShapeToAstType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstType;
     constructor({ iriPrefixMap, shapesGraph, }) {
-        // Members are protected so they're accessible to the bound functions
-        this.astObjectTypePropertiesByIdentifier = new TermMap();
-        this.nodeShapeAstTypesByIdentifier = new TermMap();
-        this.shapeAstName = _ShapesGraphToAstTransformer.shapeAstName;
-        this.transformNodeShapeToAstType = _ShapesGraphToAstTransformer.transformNodeShapeToAstType;
-        this.transformPropertyShapeToAstCompositeType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstCompositeType;
-        this.transformPropertyShapeToAstIdentifierType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstIdentifierType;
-        this.transformPropertyShapeToAstLiteralType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstLiteralType;
-        this.transformPropertyShapeToAstObjectTypeProperty = _ShapesGraphToAstTransformer.transformPropertyShapeToAstObjectTypeProperty;
-        this.transformPropertyShapeToAstTermType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstTermType;
-        this.transformPropertyShapeToAstType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstType;
         this.iriPrefixMap = iriPrefixMap;
         this.shapesGraph = shapesGraph;
     }

package/{_ShapesGraphToAstTransformer → dist/_ShapesGraphToAstTransformer}/transformNodeShapeToAstType.js

@@ -1,5 +1,5 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
-import { Either, Left } from "purify-ts";
+import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { TsFeature } from "../enums/index.js";
 import * as input from "../input/index.js";
@@ -24,7 +24,7 @@ function transformNodeShapeToListType(nodeShape) {
         label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
         mutable: nodeShape.mutable,
         name: this.shapeAstName(nodeShape),
-        mintingStrategy: nodeShape.mintingStrategy,
+        identifierMintingStrategy: nodeShape.identifierMintingStrategy,
         toRdfTypes: nodeShape.toRdfTypes,
     };
     this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, listType);
@@ -125,6 +125,7 @@ export function transformNodeShapeToAstType(nodeShape) {
         }
         return Either.of(compositeType);
     }
+    const identifierIn = nodeShape.constraints.in_.filter((term) => term.termType === "NamedNode");
     // Put a placeholder in the cache to deal with cyclic references
     // If this node shape's properties (directly or indirectly) refer to the node shape itself,
     // we'll return this placeholder.
@@ -139,9 +140,12 @@ export function transformNodeShapeToAstType(nodeShape) {
         fromRdfType: nodeShape.fromRdfType,
         label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
         kind: "ObjectType",
-        mintingStrategy: nodeShape.mintingStrategy,
+        identifierIn,
+        identifierMintingStrategy: identifierIn.length === 0
+            ? nodeShape.identifierMintingStrategy
+            : Maybe.empty(),
+        identifierKinds: identifierIn.length === 0 ? nodeShape.nodeKinds : new Set(["NamedNode"]),
         name: this.shapeAstName(nodeShape),
-        nodeKinds: nodeShape.nodeKinds,
         properties: [], // This is mutable, we'll populate it below.
         parentObjectTypes: [], // This is mutable, we'll populate it below
         toRdfTypes: nodeShape.toRdfTypes,

package/{_ShapesGraphToAstTransformer → dist/_ShapesGraphToAstTransformer}/transformPropertyShapeToAstCompositeType.js

@@ -27,13 +27,13 @@ export function transformPropertyShapeToAstCompositeType(shape, inherited) {
                     nodeKinds.add(astType.identifierNodeKind);
                     break;
                 case "ObjectType":
-                    nodeKinds = astType.nodeKinds;
+                    nodeKinds = astType.identifierKinds;
                     break;
                 case "ObjectIntersectionType":
                 case "ObjectUnionType":
                     nodeKinds = new Set();
                     for (const memberType of astType.memberTypes) {
-                        for (const nodeKind of memberType.nodeKinds) {
+                        for (const nodeKind of memberType.identifierKinds) {
                             nodeKinds.add(nodeKind);
                         }
                     }

package/{_ShapesGraphToAstTransformer → dist/_ShapesGraphToAstTransformer}/transformPropertyShapeToAstType.js

@@ -30,6 +30,7 @@ export function transformPropertyShapeToAstType(shape, inherited) {
                 return {
                     itemType,
                     kind: "SetType",
+                    mutable: shape.mutable,
                     minCount: 0,
                 };
             }
@@ -52,6 +53,7 @@ export function transformPropertyShapeToAstType(shape, inherited) {
             itemType,
             kind: "SetType",
             minCount: minCount.orDefault(0),
+            mutable: shape.mutable,
         };
     });
 }

package/{ast → dist/ast}/ListType.d.ts

@@ -1,6 +1,6 @@
 import type { NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
-import type { MintingStrategy } from "../enums/MintingStrategy.js";
+import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
 import type { Name } from "./Name.js";
 import type { Type } from "./Type.js";
 /**
@@ -33,7 +33,7 @@ export interface ListType {
     /**
      * Strategy for minting new list and sub-list identifiers.
      */
-    readonly mintingStrategy: Maybe<MintingStrategy>;
+    readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
     /**
      * The list should be mutable in generated code.
      */

package/{ast → dist/ast}/ObjectType.d.ts

@@ -1,7 +1,7 @@
 import type { NamedNode } from "@rdfjs/types";
-import type { PredicatePath } from "@shaclmate/shacl-ast";
+import type { NodeKind, PredicatePath } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
-import type { MintingStrategy, PropertyVisibility, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
+import type { IdentifierMintingStrategy, PropertyVisibility, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
 import type { Name } from "./Name.js";
 import type { Type } from "./Type.js";
 export interface ObjectType {
@@ -52,6 +52,22 @@ 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 identifierKinds: Set<Exclude<NodeKind, "Literal">>;
+    /**
+     * Strategy for minting new object identifiers.
+     */
+    readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
     /**
      * Type discriminator.
      */
@@ -60,20 +76,10 @@ export interface ObjectType {
      * Human-readable label from rdfs:label.
      */
     readonly label: Maybe<string>;
-    /**
-     * Strategy for minting new object identifiers.
-     */
-    readonly mintingStrategy: Maybe<MintingStrategy>;
     /**
      * Name of this type, usually derived from sh:name or shaclmate:name.
      */
     readonly name: Name;
-    /**
-     * The RDF node kinds this ObjectType may be identified by.
-     *
-     * Used to associate instances with an RDF identifier.
-     */
-    readonly nodeKinds: Set<"BlankNode" | "NamedNode">;
     /**
      * Immediate parent ObjectTypes of this Object types.
      *

package/dist/ast/SetType.d.ts

@@ -0,0 +1,23 @@
+import type { Maybe } from "purify-ts";
+import type { Type } from "./Type.js";
+/**
+ * An unordered set of items of a specific type.
+ *
+ * This is a property with sh:maxCount != 1.
+ */
+export interface SetType {
+    /**
+     * Set item type.
+     */
+    readonly itemType: Type;
+    readonly kind: "SetType";
+    /**
+     * Minimum number of items in the set.
+     */
+    readonly minCount: number;
+    /**
+     * The set should be mutable in generated code.
+     */
+    readonly mutable: Maybe<boolean>;
+}
+//# sourceMappingURL=SetType.d.ts.map

package/dist/enums/IdentifierMintingStrategy.d.ts

@@ -0,0 +1,5 @@
+/**
+ * TypeScript enum corresponding to shaclmate:identifierMintingStrategy, for simpler manipulation.
+ */
+export type IdentifierMintingStrategy = "sha256" | "uuidv4";
+//# sourceMappingURL=IdentifierMintingStrategy.d.ts.map

package/dist/enums/IdentifierMintingStrategy.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IdentifierMintingStrategy.js.map

package/{enums → dist/enums}/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./MintingStrategy.js";
+export * from "./IdentifierMintingStrategy.js";
 export * from "./PropertyVisibility.js";
 export * from "./TsFeature.js";
 export * from "./TsObjectDeclarationType.js";

package/{enums → dist/enums}/index.js

@@ -1,4 +1,4 @@
-export * from "./MintingStrategy.js";
+export * from "./IdentifierMintingStrategy.js";
 export * from "./PropertyVisibility.js";
 export * from "./TsFeature.js";
 export * from "./TsObjectDeclarationType.js";

package/{generators → dist/generators}/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./Generator.js";
 export * as json from "./json/index.js";
 export * as ts from "./ts/index.js";
 //# sourceMappingURL=index.d.ts.map

package/{generators → dist/generators}/index.js

@@ -1,3 +1,4 @@
+export * from "./Generator.js";
 export * as json from "./json/index.js";
 export * as ts from "./ts/index.js";
 //# sourceMappingURL=index.js.map

package/{generators → dist/generators}/json/AstJsonGenerator.js

@@ -70,7 +70,11 @@ function typeToJson(type) {
                 parentObjectTypes: type.parentObjectTypes.length > 0
                     ? type.parentObjectTypes.map((type) => nameToJson(type.name))
                     : undefined,
-                nodeKinds: [...type.nodeKinds],
+                identifierIn: type.identifierIn.length > 0
+                    ? type.identifierIn.map(termToJson)
+                    : undefined,
+                identifierKinds: [...type.identifierKinds],
+                identifierMintingStrategy: type.identifierMintingStrategy.extract(),
                 toRdfTypes: type.toRdfTypes.length > 0
                     ? type.toRdfTypes.map(termToJson)
                     : undefined,

package/{generators → dist/generators}/ts/BooleanType.js

@@ -8,10 +8,7 @@ import { Memoize } from "typescript-memoize";
 import { PrimitiveType } from "./PrimitiveType.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class BooleanType extends PrimitiveType {
-    constructor() {
-        super(...arguments);
-        this.kind = "BooleanType";
-    }
+    kind = "BooleanType";
     get conversions() {
         const conversions = [
             {

package/{generators → dist/generators}/ts/DateTimeType.d.ts

@@ -1,10 +1,13 @@
+import type { NamedNode } from "@rdfjs/types";
 import type { TsFeature } from "../../enums/index.js";
 import { PrimitiveType } from "./PrimitiveType.js";
 import type { Type } from "./Type.js";
 export declare class DateTimeType extends PrimitiveType<Date> {
     readonly equalsFunction = "dateEquals";
-    readonly kind = "DateTimeType";
+    readonly kind: "DateTimeType" | "DateType";
     readonly mutable = true;
+    protected readonly xsdDatatype: NamedNode;
+    protected readonly zodDatatype: string;
     get conversions(): readonly Type.Conversion[];
     get jsonName(): string;
     get name(): string;

package/{generators → dist/generators}/ts/DateTimeType.js

@@ -1,13 +1,13 @@
+import { xsd } from "@tpluscode/rdf-ns-builders";
 import { PrimitiveType } from "./PrimitiveType.js";
 import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class DateTimeType extends PrimitiveType {
-    constructor() {
-        super(...arguments);
-        this.equalsFunction = "dateEquals";
-        this.kind = "DateTimeType";
-        this.mutable = true;
-    }
+    equalsFunction = "dateEquals";
+    kind = "DateTimeType";
+    mutable = true;
+    xsdDatatype = xsd.dateTime;
+    zodDatatype = "datetime";
     get conversions() {
         const conversions = [
             {
@@ -38,12 +38,12 @@ export class DateTimeType extends PrimitiveType {
         return [`${variables.hasher}.update(${variables.value}.toISOString());`];
     }
     jsonZodSchema({ variables, }) {
-        return `${variables.zod}.string().datetime()`;
+        return `${variables.zod}.string().${this.zodDatatype}()`;
     }
     propertyFromRdfResourceValueExpression({ variables, }) {
         let expression = `${variables.resourceValue}.toDate()`;
         if (this.primitiveIn.length > 0) {
-            expression = `${expression}.chain(value => { ${this.primitiveIn.map((value) => `if (value.getTime() === ${value.getTime()}) { return purify.Either.of(value); }`).join(" ")} return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); })`;
+            expression = `${expression}.chain(value => { ${this.primitiveIn.map((value) => `if (value.getTime() === ${value.getTime()}) { return purify.Either.of(value); }`).join(" ")} return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: `rdfLiteral.toRdf(value, ${objectInitializer({ dataFactory: this.dataFactoryVariable, datatype: this.rdfjsTermExpression(this.xsdDatatype) })})`, expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); })`;
         }
         return expression;
     }
@@ -58,9 +58,10 @@ export class DateTimeType extends PrimitiveType {
         return `${variables.value}.toISOString()`;
     }
     toRdfExpression({ variables, }) {
+        const valueToRdf = `rdfLiteral.toRdf(${variables.value}, ${objectInitializer({ dataFactory: this.dataFactoryVariable, datatype: this.rdfjsTermExpression(this.xsdDatatype) })})`;
         return this.primitiveDefaultValue
-            .map((defaultValue) => `${variables.value}.getTime() !== ${defaultValue.getTime()} ? ${variables.value} : undefined`)
-            .orDefault(variables.value);
+            .map((defaultValue) => `${variables.value}.getTime() !== ${defaultValue.getTime()} ? ${valueToRdf} : undefined`)
+            .orDefault(valueToRdf);
     }
 }
 //# sourceMappingURL=DateTimeType.js.map

package/dist/generators/ts/DateType.d.ts

@@ -0,0 +1,9 @@
+import { DateTimeType } from "./DateTimeType.js";
+import type { PrimitiveType } from "./PrimitiveType.js";
+export declare class DateType extends DateTimeType {
+    readonly kind = "DateType";
+    protected readonly xsdDatatype: import("@rdfjs/types").NamedNode<string> & import("@rdfjs/types").NamedNode<"http://www.w3.org/2001/XMLSchema#date">;
+    protected readonly zodDatatype = "date";
+    toJsonExpression({ variables, }: Parameters<PrimitiveType<Date>["toJsonExpression"]>[0]): string;
+}
+//# sourceMappingURL=DateType.d.ts.map

package/dist/generators/ts/DateType.js

@@ -0,0 +1,11 @@
+import { xsd } from "@tpluscode/rdf-ns-builders";
+import { DateTimeType } from "./DateTimeType.js";
+export class DateType extends DateTimeType {
+    kind = "DateType";
+    xsdDatatype = xsd.date;
+    zodDatatype = "date";
+    toJsonExpression({ variables, }) {
+        return `${variables.value}.toISOString().replace(/T.*$/, '')`;
+    }
+}
+//# sourceMappingURL=DateType.js.map

package/{generators → dist/generators}/ts/DeclaredType.js

@@ -1,5 +1,8 @@
 import { Type } from "./Type.js";
 export class DeclaredType extends Type {
+    export;
+    features;
+    name;
     constructor({ export_, features, name, ...superParameters }) {
         super(superParameters);
         this.export = export_;

package/{generators → dist/generators}/ts/IdentifierType.d.ts

@@ -1,7 +1,9 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { TermType } from "./TermType.js";
+import type { Type } from "./Type.js";
 export declare class IdentifierType extends TermType<BlankNode | NamedNode> {
     readonly kind = "IdentifierType";
+    get conversions(): readonly Type.Conversion[];
     get isNamedNodeKind(): boolean;
     get jsonName(): string;
     get name(): string;

package/{generators → dist/generators}/ts/IdentifierType.js

@@ -7,9 +7,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Memoize } from "typescript-memoize";
 import { TermType } from "./TermType.js";
 export class IdentifierType extends TermType {
-    constructor() {
-        super(...arguments);
-        this.kind = "IdentifierType";
+    kind = "IdentifierType";
+    get conversions() {
+        return super.conversions.concat([
+            {
+                conversionExpression: (value) => `${this.dataFactoryVariable}.namedNode(${value})`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "string"`,
+                sourceTypeName: this.in_.length > 0
+                    ? this.in_.map((iri) => `"${iri.value}"`).join(" | ")
+                    : "string",
+            },
+        ]);
     }
     get isNamedNodeKind() {
         return this.nodeKinds.size === 1 && this.nodeKinds.has("NamedNode");

package/{generators → dist/generators}/ts/ListType.d.ts

@@ -1,19 +1,19 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import type { MintingStrategy, TsFeature } from "../../enums/index.js";
+import type { IdentifierMintingStrategy, TsFeature } from "../../enums/index.js";
 import { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class ListType extends Type {
     readonly itemType: Type;
     readonly kind = "ListType";
-    readonly mutable: boolean;
     private readonly identifierNodeKind;
-    private readonly mintingStrategy;
+    private readonly identifierMintingStrategy;
+    private readonly _mutable;
     private readonly toRdfTypes;
-    constructor({ identifierNodeKind, itemType, mintingStrategy, mutable, toRdfTypes, ...superParameters }: {
+    constructor({ identifierNodeKind, itemType, identifierMintingStrategy, mutable, toRdfTypes, ...superParameters }: {
         identifierNodeKind: ListType["identifierNodeKind"];
         itemType: Type;
-        mintingStrategy: Maybe<MintingStrategy>;
+        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         mutable: boolean;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof Type>[0]);
@@ -21,6 +21,7 @@ export declare class ListType extends Type {
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get equalsFunction(): string;
     get jsonName(): string;
+    get mutable(): boolean;
     get name(): string;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;

package/{generators → dist/generators}/ts/ListType.js

@@ -5,13 +5,19 @@ import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class ListType extends Type {
-    constructor({ identifierNodeKind, itemType, mintingStrategy, mutable, toRdfTypes, ...superParameters }) {
+    itemType;
+    kind = "ListType";
+    identifierNodeKind;
+    identifierMintingStrategy;
+    _mutable;
+    toRdfTypes;
+    constructor({ identifierNodeKind, itemType, identifierMintingStrategy, mutable, toRdfTypes, ...superParameters }) {
         super(superParameters);
-        this.kind = "ListType";
         this.identifierNodeKind = identifierNodeKind;
         this.itemType = itemType;
-        this.mintingStrategy = mintingStrategy.orDefault("sha256");
-        this.mutable = mutable;
+        this.identifierMintingStrategy =
+            identifierMintingStrategy.orDefault("sha256");
+        this._mutable = mutable;
         this.toRdfTypes = toRdfTypes;
     }
     get conversions() {
@@ -32,8 +38,11 @@ export class ListType extends Type {
     get jsonName() {
         return `readonly (${this.itemType.jsonName})[]`;
     }
+    get mutable() {
+        return this._mutable || this.itemType.mutable;
+    }
     get name() {
-        return `${this.mutable ? "" : "readonly "}${this.itemType.name}[]`;
+        return `${this._mutable ? "" : "readonly "}${this.itemType.name}[]`;
     }
     fromJsonExpression({ variables, }) {
         return `${variables.value}.map(_item => (${this.itemType.fromJsonExpression({ variables: { value: "_item" } })}))`;
@@ -57,7 +66,9 @@ export class ListType extends Type {
         return `${this.itemType.jsonZodSchema(parameters)}.array()`;
     }
     snippetDeclarations(features) {
-        const snippetDeclarations = [];
+        const snippetDeclarations = this.itemType
+            .snippetDeclarations(features)
+            .concat();
         if (features.has("equals")) {
             snippetDeclarations.push(SnippetDeclarations.arrayEquals);
         }
@@ -124,6 +135,10 @@ export class ListType extends Type {
         }
     }
     sparqlWherePatterns({ variables, context, }) {
+        // Need to handle two cases:
+        // (1) (?s, ?p, ?list) where ?list binds to rdf:nil
+        // (2) (?s, ?p, ?list) (?list, rdf:first, "element") (?list, rdf:rest, rdf:nil) etc. where list binds to the head of a list
+        // Case (2) is case (1) with OPTIONAL graph patterns to handle actual list elements.
         switch (context) {
             case "property":
                 return super.sparqlWherePatterns({ context, variables });
@@ -186,7 +201,8 @@ export class ListType extends Type {
                     object: variable("RestNBasic"),
                 })}] }`);
                 patterns.push(`{ type: "optional", patterns: [${optionalPatterns.join(", ")}] }`);
-                return patterns;
+                // Having an optional around everything handles the rdf:nil case
+                return [`{ type: "optional", patterns: [${patterns.join(", ")}] }`];
             }
         }
     }
@@ -213,7 +229,7 @@ export class ListType extends Type {
                 break;
             }
             case "NamedNode": {
-                switch (this.mintingStrategy) {
+                switch (this.identifierMintingStrategy) {
                     case "sha256":
                         listIdentifier = `dataFactory.namedNode(\`urn:shaclmate:list:\${${variables.value}.reduce(
         (_hasher, _item) => {
@@ -236,12 +252,11 @@ export class ListType extends Type {
                 break;
             }
         }
-        return `${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+        return `${variables.value}.length > 0 ? ${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
     if (itemIndex === 0) {
       currentSubListResource = listResource;
     } else {
-      const newSubListResource = ${variables.resourceSet}.${resourceSetMethodName}(${objectInitializer({
-            identifier: subListIdentifier,
+      const newSubListResource = ${variables.resourceSet}.${resourceSetMethodName}(${subListIdentifier}, ${objectInitializer({
             mutateGraph: variables.mutateGraph,
         })});
       currentSubListResource!.add(dataFactory.namedNode("${rdf.rest.value}"), newSubListResource.identifier);
@@ -260,15 +275,14 @@ export class ListType extends Type {
   },
   {
     currentSubListResource: null,
-    listResource: resourceSet.${resourceSetMethodName}(${objectInitializer({
-            identifier: listIdentifier,
+    listResource: resourceSet.${resourceSetMethodName}(${listIdentifier}, ${objectInitializer({
             mutateGraph: variables.mutateGraph,
         })}),
   } as {
     currentSubListResource: ${mutableResourceTypeName} | null;
     listResource: ${mutableResourceTypeName};
   },
-).listResource.identifier`;
+).listResource.identifier : dataFactory.namedNode("${rdf.nil.value}")`;
     }
     useImports(features) {
         const imports = this.itemType.useImports(features).concat();

package/{generators → dist/generators}/ts/LiteralType.js

@@ -1,6 +1,7 @@
 import { xsd } from "@tpluscode/rdf-ns-builders";
 import { TermType } from "./TermType.js";
 export class LiteralType extends TermType {
+    languageIn;
     constructor({ languageIn, ...superParameters }) {
         super({
             ...superParameters,

package/{generators → dist/generators}/ts/NumberType.js

@@ -8,10 +8,7 @@ import { Memoize } from "typescript-memoize";
 import { PrimitiveType } from "./PrimitiveType.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class NumberType extends PrimitiveType {
-    constructor() {
-        super(...arguments);
-        this.kind = "NumberType";
-    }
+    kind = "NumberType";
     get conversions() {
         const conversions = [
             {

package/{generators → dist/generators}/ts/ObjectType.d.ts

@@ -1,7 +1,7 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { type ClassDeclarationStructure, type InterfaceDeclarationStructure, type ModuleDeclarationStructure } from "ts-morph";
-import type { MintingStrategy, TsFeature, TsObjectDeclarationType } from "../../enums/index.js";
+import type { IdentifierMintingStrategy, TsFeature, TsObjectDeclarationType } from "../../enums/index.js";
 import { DeclaredType } from "./DeclaredType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import { Import } from "./Import.js";
@@ -15,14 +15,14 @@ export declare class ObjectType extends DeclaredType {
     protected readonly extern: boolean;
     protected readonly fromRdfType: Maybe<NamedNode>;
     protected readonly label: Maybe<string>;
-    protected readonly mintingStrategy: Maybe<MintingStrategy>;
+    protected readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
     protected readonly toRdfTypes: readonly NamedNode[];
     private readonly imports;
     private readonly lazyAncestorObjectTypes;
     private readonly lazyDescendantObjectTypes;
     private readonly lazyParentObjectTypes;
     private readonly lazyProperties;
-    constructor({ abstract, comment, declarationType, extern, fromRdfType, label, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, imports, mintingStrategy, toRdfTypes, ...superParameters }: {
+    constructor({ abstract, comment, declarationType, extern, fromRdfType, label, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, imports, identifierMintingStrategy, toRdfTypes, ...superParameters }: {
         abstract: boolean;
         comment: Maybe<string>;
         declarationType: TsObjectDeclarationType;
@@ -34,7 +34,7 @@ export declare class ObjectType extends DeclaredType {
         lazyDescendantObjectTypes: () => readonly ObjectType[];
         lazyParentObjectTypes: () => readonly ObjectType[];
         lazyProperties: () => readonly ObjectType.Property[];
-        mintingStrategy: Maybe<MintingStrategy>;
+        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof DeclaredType>[0]);
     get _discriminatorProperty(): Type.DiscriminatorProperty;