@shaclmate/compiler 2.0.20 → 2.0.23

package/dist/generators/ts/IdentifierType.js

@@ -4,14 +4,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import { StructureKind, VariableDeclarationKind, } from "ts-morph";
 import { Memoize } from "typescript-memoize";
 import { TermType } from "./TermType.js";
+import { Type } from "./Type.js";
 export class IdentifierType extends TermType {
     kind = "IdentifierType";
     get conversions() {
         return super.conversions.concat([
             {
-                conversionExpression: (value) => `${this.dataFactoryVariable}.namedNode(${value})`,
+                conversionExpression: (value) => `dataFactory.namedNode(${value})`,
                 sourceTypeCheckExpression: (value) => `typeof ${value} === "string"`,
                 sourceTypeName: this.in_.length > 0
                     ? this.in_.map((iri) => `"${iri.value}"`).join(" | ")
@@ -19,6 +21,55 @@ export class IdentifierType extends TermType {
             },
         ]);
     }
+    get fromStringFunctionDeclaration() {
+        if (this.nodeKinds.has("BlankNode") &&
+            this.nodeKinds.has("NamedNode") &&
+            this.in_.length === 0) {
+            // Wrap rdfjsResource.Resource.Identifier.fromString
+            return {
+                isExported: true,
+                kind: StructureKind.Function,
+                name: "fromString",
+                parameters: [
+                    {
+                        name: "identifier",
+                        type: "string",
+                    },
+                ],
+                returnType: "purify.Either<Error, rdfjsResource.Resource.Identifier>",
+                statements: [
+                    "return purify.Either.encase(() => rdfjsResource.Resource.Identifier.fromString({ dataFactory, identifier }));",
+                ],
+            };
+        }
+        const expressions = [
+            "purify.Either.encase(() => rdfjsResource.Resource.Identifier.fromString({ dataFactory, identifier }))",
+        ];
+        if (this.isNamedNodeKind) {
+            expressions.push(`chain((identifier) => (identifier.termType === "NamedNode") ? purify.Either.of(identifier) : purify.Left(new Error("expected identifier to be NamedNode")))`);
+            if (this.in_.length > 0) {
+                expressions.push(`chain((identifier) => { switch (identifier.value) { ${this.in_.map((iri) => `case "${iri.value}": return purify.Either.of(identifier as rdfjs.NamedNode<"${iri.value}">);`).join(" ")} default: return purify.Left(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`);
+            }
+        }
+        return {
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "fromString",
+            parameters: [
+                {
+                    name: "identifier",
+                    type: "string",
+                },
+            ],
+            returnType: `purify.Either<Error, ${this.name}>`,
+            statements: [
+                `return ${expressions.join(".")} as purify.Either<Error, ${this.name}>;`,
+            ],
+        };
+    }
+    get graphqlName() {
+        return new Type.GraphqlName("graphql.GraphQLString");
+    }
     get isNamedNodeKind() {
         return this.nodeKinds.size === 1 && this.nodeKinds.has("NamedNode");
     }
@@ -26,9 +77,9 @@ export class IdentifierType extends TermType {
         if (this.in_.length > 0 && this.isNamedNodeKind) {
             // Treat sh:in as a union of the IRIs
             // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            return `{ readonly "@id": ${this.in_.map((iri) => `"${iri.value}"`).join(" | ")} }`;
+            return new Type.JsonName(`{ readonly "@id": ${this.in_.map((iri) => `"${iri.value}"`).join(" | ")} }`);
         }
-        return `{ readonly "@id": string }`;
+        return new Type.JsonName(`{ readonly "@id": string }`);
     }
     get name() {
         if (this.in_.length > 0 && this.isNamedNodeKind) {
@@ -42,9 +93,24 @@ export class IdentifierType extends TermType {
             .map((nodeKind) => `rdfjs.${nodeKind}`)
             .join(" | ")})`;
     }
+    get toStringFunctionDeclaration() {
+        // Re-export rdfjsResource.Resource.Identifier.toString
+        return {
+            declarationKind: VariableDeclarationKind.Const,
+            isExported: true,
+            kind: StructureKind.VariableStatement,
+            declarations: [
+                {
+                    initializer: "rdfjsResource.Resource.Identifier.toString",
+                    leadingTrivia: "// biome-ignore lint/suspicious/noShadowRestrictedNames:",
+                    name: "toString",
+                },
+            ],
+        };
+    }
     fromJsonExpression({ variables, }) {
-        const valueToBlankNode = `${this.dataFactoryVariable}.blankNode(${variables.value}["@id"].substring(2))`;
-        const valueToNamedNode = `${this.dataFactoryVariable}.namedNode(${variables.value}["@id"])`;
+        const valueToBlankNode = `dataFactory.blankNode(${variables.value}["@id"].substring(2))`;
+        const valueToNamedNode = `dataFactory.namedNode(${variables.value}["@id"])`;
         if (this.nodeKinds.size === 2) {
             return `(${variables.value}["@id"].startsWith("_:") ? ${valueToBlankNode} : ${valueToNamedNode})`;
         }
@@ -55,6 +121,9 @@ export class IdentifierType extends TermType {
                 return valueToNamedNode;
         }
     }
+    graphqlResolveExpression({ variables: { value }, }) {
+        return `rdfjsResource.Resource.Identifier.toString(${value})`;
+    }
     jsonZodSchema({ variables, }) {
         let idSchema;
         if (this.in_.length > 0 && this.isNamedNodeKind) {
@@ -87,14 +156,33 @@ export class IdentifierType extends TermType {
         if (this.isNamedNodeKind) {
             let expression = `${variables.resourceValue}.toIri()`;
             if (this.in_.length > 0) {
-                expression = `${expression}.chain(iri => { switch (iri.value) { ${this.in_.map((iri) => `case "${iri.value}": return purify.Either.of<rdfjsResource.Resource.ValueError, ${this.name}>(iri as rdfjs.NamedNode<"${iri.value}">);`).join(" ")} default: return purify.Left(new rdfjsResource.Resource.MistypedValueError({ actualValue: iri, expectedValueType: ${JSON.stringify(this.name)}, focusResource: ${variables.resource}, predicate: ${variables.predicate} })); } } )`;
+                const eitherTypeParameters = `<Error, ${this.name}>`;
+                expression = `${expression}.chain(iri => { switch (iri.value) { ${this.in_.map((iri) => `case "${iri.value}": return purify.Either.of${eitherTypeParameters}(iri as rdfjs.NamedNode<"${iri.value}">);`).join(" ")} default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError({ actualValue: iri, expectedValueType: ${JSON.stringify(this.name)}, focusResource: ${variables.resource}, predicate: ${variables.predicate} })); } } )`;
             }
             return expression;
         }
         throw new Error(`not implemented: ${this.name}`);
     }
 }
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "fromStringFunctionDeclaration", null);
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "graphqlName", null);
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "isNamedNodeKind", null);
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "jsonName", null);
 __decorate([
     Memoize()
 ], IdentifierType.prototype, "name", null);
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "toStringFunctionDeclaration", null);
 //# sourceMappingURL=IdentifierType.js.map

package/dist/generators/ts/Import.d.ts

@@ -4,6 +4,8 @@ export type Import = ImportDeclarationStructure | string;
  * Singleton values for common imports.
  */
 export declare namespace Import {
+    const GRAPHQL: Import;
+    const GRAPHQL_SCALARS: Import;
     const PURIFY: Import;
     const RDF_LITERAL: Import;
     const RDFJS_RESOURCE: Import;

package/dist/generators/ts/Import.js

@@ -4,6 +4,16 @@ import { StructureKind } from "ts-morph";
  */
 export var Import;
 (function (Import) {
+    Import.GRAPHQL = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "graphql",
+        namespaceImport: "graphql",
+    };
+    Import.GRAPHQL_SCALARS = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "graphql-scalars",
+        namespaceImport: "graphqlScalars",
+    };
     Import.PURIFY = {
         kind: StructureKind.ImportDeclaration,
         moduleSpecifier: "purify-ts",

package/dist/generators/ts/IntType.d.ts

@@ -0,0 +1,6 @@
+import { NumberType } from "./NumberType.js";
+import { Type } from "./Type.js";
+export declare class IntType extends NumberType {
+    get graphqlName(): Type.GraphqlName;
+}
+//# sourceMappingURL=IntType.d.ts.map

package/dist/generators/ts/IntType.js

@@ -0,0 +1,18 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
+import { NumberType } from "./NumberType.js";
+import { Type } from "./Type.js";
+export class IntType extends NumberType {
+    get graphqlName() {
+        return new Type.GraphqlName("graphql.GraphQLInt");
+    }
+}
+__decorate([
+    Memoize()
+], IntType.prototype, "graphqlName", null);
+//# sourceMappingURL=IntType.js.map

package/dist/generators/ts/ListType.d.ts

@@ -1,38 +1,41 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy, TsFeature } from "../../enums/index.js";
+import type { IdentifierMintingStrategy } 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";
-    private readonly identifierNodeKind;
-    private readonly identifierMintingStrategy;
     private readonly _mutable;
+    private readonly identifierMintingStrategy;
+    private readonly identifierNodeKind;
     private readonly toRdfTypes;
-    constructor({ identifierNodeKind, itemType, identifierMintingStrategy, mutable, toRdfTypes, ...superParameters }: {
+    readonly itemType: Type;
+    readonly kind = "ListType";
+    readonly typeof = "object";
+    constructor({ identifierNodeKind, itemType, identifierMintingStrategy, mutable, toRdfTypes, }: {
         identifierNodeKind: ListType["identifierNodeKind"];
         itemType: Type;
         identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         mutable: boolean;
         toRdfTypes: readonly NamedNode[];
-    } & ConstructorParameters<typeof Type>[0]);
+    });
     get conversions(): readonly Type.Conversion[];
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get equalsFunction(): string;
-    get jsonName(): string;
+    get graphqlName(): Type.GraphqlName;
+    get jsonName(): Type.JsonName;
     get mutable(): boolean;
     get name(): string;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    graphqlResolveExpression({ variables, }: Parameters<Type["graphqlResolveExpression"]>[0]): string;
     hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonUiSchemaElement(parameters: Parameters<Type["jsonUiSchemaElement"]>[0]): ReturnType<Type["jsonUiSchemaElement"]>;
     jsonZodSchema(parameters: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    snippetDeclarations(features: Set<TsFeature>): readonly string[];
-    sparqlConstructTemplateTriples({ variables, context, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-    sparqlWherePatterns({ variables, context, }: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
+    snippetDeclarations(parameters: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
+    sparqlConstructTemplateTriples(parameters: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
-    useImports(features: Set<TsFeature>): readonly Import[];
+    useImports(parameters: Parameters<Type["useImports"]>[0]): readonly Import[];
 }
 //# sourceMappingURL=ListType.d.ts.map

package/dist/generators/ts/ListType.js

@@ -1,18 +1,28 @@
-import { rdf } from "@tpluscode/rdf-ns-builders";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { Maybe } from "purify-ts";
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Memoize } from "typescript-memoize";
 import { Import } from "./Import.js";
 import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 export class ListType extends Type {
-    itemType;
-    kind = "ListType";
-    identifierNodeKind;
-    identifierMintingStrategy;
     _mutable;
+    identifierMintingStrategy;
+    identifierNodeKind;
     toRdfTypes;
-    constructor({ identifierNodeKind, itemType, identifierMintingStrategy, mutable, toRdfTypes, ...superParameters }) {
-        super(superParameters);
+    itemType;
+    kind = "ListType";
+    typeof = "object";
+    constructor({ identifierNodeKind, itemType, identifierMintingStrategy, mutable, toRdfTypes, }) {
+        super();
         this.identifierNodeKind = identifierNodeKind;
         this.itemType = itemType;
         this.identifierMintingStrategy = identifierMintingStrategy.orDefault(identifierNodeKind === "BlankNode" ? "blankNode" : "sha256");
@@ -22,8 +32,11 @@ export class ListType extends Type {
     get conversions() {
         return [
             {
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => `Array.isArray(${value})`,
+                // Defensive copy
+                conversionExpression: (value) => `${value}${this.mutable ? ".concat()" : ""}`,
+                // Array.isArray doesn't narrow correctly
+                // sourceTypeCheckExpression: (value) => `Array.isArray(${value})`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
                 sourceTypeName: this.name,
             },
         ];
@@ -32,10 +45,13 @@ export class ListType extends Type {
         return Maybe.empty();
     }
     get equalsFunction() {
-        return `((left, right) => arrayEquals(left, right, ${this.itemType.equalsFunction}))`;
+        return `((left, right) => ${syntheticNamePrefix}arrayEquals(left, right, ${this.itemType.equalsFunction}))`;
+    }
+    get graphqlName() {
+        return new Type.GraphqlName(`new graphql.GraphQLList(${this.itemType.graphqlName})`);
     }
     get jsonName() {
-        return `readonly (${this.itemType.jsonName})[]`;
+        return new Type.JsonName(`readonly (${this.itemType.jsonName})[]`);
     }
     get mutable() {
         return this._mutable || this.itemType.mutable;
@@ -44,18 +60,21 @@ export class ListType extends Type {
         return `${this._mutable ? "" : "readonly "}${this.itemType.name}[]`;
     }
     fromJsonExpression({ variables, }) {
-        return `${variables.value}.map(_item => (${this.itemType.fromJsonExpression({ variables: { value: "_item" } })}))`;
+        return `${variables.value}.map(item => (${this.itemType.fromJsonExpression({ variables: { value: "item" } })}))`;
     }
     fromRdfExpression({ variables, }) {
         const chain = [variables.resourceValues];
         chain.push("head()");
         chain.push("chain(value => value.toList())");
-        chain.push(`map(values => values.flatMap(_value => ${this.itemType.fromRdfExpression({ variables: { ...variables, resourceValues: "_value.toValues()" } })}.toMaybe().toList()))`);
+        chain.push(`chain(values => purify.Either.sequence(values.map(value => ${this.itemType.fromRdfExpression({ variables: { ...variables, resourceValues: "value.toValues()" } })})))`);
         return chain.join(".");
     }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
     hashStatements({ depth, variables, }) {
         return [
-            `for (const _element${depth} of ${variables.value}) { ${this.itemType.hashStatements({ depth: depth + 1, variables: { ...variables, value: `_element${depth}` } }).join("\n")} }`,
+            `for (const item${depth} of ${variables.value}) { ${this.itemType.hashStatements({ depth: depth + 1, variables: { ...variables, value: `item${depth}` } }).join("\n")} }`,
         ];
     }
     jsonUiSchemaElement(parameters) {
@@ -64,33 +83,35 @@ export class ListType extends Type {
     jsonZodSchema(parameters) {
         return `${this.itemType.jsonZodSchema(parameters)}.array()`;
     }
-    snippetDeclarations(features) {
+    snippetDeclarations(parameters) {
         const snippetDeclarations = this.itemType
-            .snippetDeclarations(features)
+            .snippetDeclarations(parameters)
             .concat();
-        if (features.has("equals")) {
+        if (parameters.features.has("equals")) {
             snippetDeclarations.push(SnippetDeclarations.arrayEquals);
         }
         return snippetDeclarations;
     }
-    sparqlConstructTemplateTriples({ variables, context, }) {
-        switch (context) {
-            case "property":
-                return super.sparqlConstructTemplateTriples({ context, variables });
-            case "type": {
+    sparqlConstructTemplateTriples(parameters) {
+        switch (parameters.context) {
+            case "object":
+                return super.sparqlConstructTemplateTriples(parameters);
+            case "subject": {
+                const { variables } = parameters;
                 const triples = [];
                 const listVariable = variables.subject;
-                const variable = (suffix) => `${this.dataFactoryVariable}.variable!(\`\${${variables.variablePrefix}}${suffix}\`)`;
+                const variable = (suffix) => `dataFactory.variable!(\`\${${variables.variablePrefix}}${suffix}\`)`;
                 const variablePrefix = (suffix) => `\`\${${variables.variablePrefix}}${suffix}\``;
                 {
                     // ?list rdf:first ?item0
                     const item0Variable = variable("Item0");
                     triples.push(objectInitializer({
                         subject: listVariable,
-                        predicate: this.rdfjsTermExpression(rdf.first),
+                        predicate: rdfjsTermExpression(rdf.first),
                         object: item0Variable,
                     }), ...this.itemType.sparqlConstructTemplateTriples({
-                        context: "type",
+                        allowIgnoreRdfType: true,
+                        context: "subject",
                         variables: {
                             subject: item0Variable,
                             variablePrefix: variablePrefix("Item0"),
@@ -102,7 +123,7 @@ export class ListType extends Type {
                     const rest0Variable = variable("Rest0");
                     triples.push(objectInitializer({
                         subject: listVariable,
-                        predicate: this.rdfjsTermExpression(rdf.rest),
+                        predicate: rdfjsTermExpression(rdf.rest),
                         object: rest0Variable,
                     }));
                 }
@@ -113,10 +134,11 @@ export class ListType extends Type {
                     const itemNVariable = variable("ItemN");
                     triples.push(objectInitializer({
                         subject: restNVariable,
-                        predicate: this.rdfjsTermExpression(rdf.first),
+                        predicate: rdfjsTermExpression(rdf.first),
                         object: itemNVariable,
                     }), ...this.itemType.sparqlConstructTemplateTriples({
-                        context: "type",
+                        allowIgnoreRdfType: true,
+                        context: "subject",
                         variables: {
                             subject: itemNVariable,
                             variablePrefix: variablePrefix("ItemN"),
@@ -126,35 +148,37 @@ export class ListType extends Type {
                 // ?restN rdf:rest ?restNBasic to get the rdf:rest statement in the CONSTRUCT
                 triples.push(objectInitializer({
                     subject: restNVariable,
-                    predicate: this.rdfjsTermExpression(rdf.rest),
+                    predicate: rdfjsTermExpression(rdf.rest),
                     object: variable("RestNBasic"),
                 }));
                 return triples;
             }
         }
     }
-    sparqlWherePatterns({ variables, context, }) {
+    sparqlWherePatterns(parameters) {
         // 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 });
-            case "type": {
+        switch (parameters.context) {
+            case "object":
+                return super.sparqlWherePatterns(parameters);
+            case "subject": {
+                const { variables } = parameters;
                 const patterns = [];
                 const listVariable = variables.subject;
-                const variable = (suffix) => `${this.dataFactoryVariable}.variable!(\`\${${variables.variablePrefix}}${suffix}\`)`;
+                const variable = (suffix) => `dataFactory.variable!(\`\${${variables.variablePrefix}}${suffix}\`)`;
                 const variablePrefix = (suffix) => `\`\${${variables.variablePrefix}}${suffix}\``;
                 {
                     // ?list rdf:first ?item0
                     const item0Variable = variable("Item0");
                     patterns.push(`{ type: "bgp", triples: [${objectInitializer({
                         subject: listVariable,
-                        predicate: this.rdfjsTermExpression(rdf.first),
+                        predicate: rdfjsTermExpression(rdf.first),
                         object: item0Variable,
                     })}] }`, ...this.itemType.sparqlWherePatterns({
-                        context: "type",
+                        allowIgnoreRdfType: true,
+                        context: "subject",
                         variables: {
                             subject: item0Variable,
                             variablePrefix: variablePrefix("Item0"),
@@ -166,7 +190,7 @@ export class ListType extends Type {
                     const rest0Variable = variable("Rest0");
                     patterns.push(`{ type: "bgp", triples: [${objectInitializer({
                         subject: listVariable,
-                        predicate: this.rdfjsTermExpression(rdf.rest),
+                        predicate: rdfjsTermExpression(rdf.rest),
                         object: rest0Variable,
                     })}] }`);
                 }
@@ -175,7 +199,7 @@ export class ListType extends Type {
                 // ?list rdf:rest+ ?restN
                 optionalPatterns.push(`{ type: "bgp", triples: [${objectInitializer({
                     subject: listVariable,
-                    predicate: `{ type: "path", pathType: "*", items: [${this.rdfjsTermExpression(rdf.rest)}] }`,
+                    predicate: `{ type: "path", pathType: "*", items: [${rdfjsTermExpression(rdf.rest)}] }`,
                     object: restNVariable,
                 })}] }`);
                 {
@@ -183,10 +207,11 @@ export class ListType extends Type {
                     const itemNVariable = variable("ItemN");
                     optionalPatterns.push(`{ type: "bgp", triples: [${objectInitializer({
                         subject: restNVariable,
-                        predicate: this.rdfjsTermExpression(rdf.first),
+                        predicate: rdfjsTermExpression(rdf.first),
                         object: itemNVariable,
                     })}] }`, ...this.itemType.sparqlWherePatterns({
-                        context: "type",
+                        allowIgnoreRdfType: true,
+                        context: "subject",
                         variables: {
                             subject: itemNVariable,
                             variablePrefix: variablePrefix("ItemN"),
@@ -196,7 +221,7 @@ export class ListType extends Type {
                 // ?restN rdf:rest ?restNBasic to get the rdf:rest statement in the CONSTRUCT
                 optionalPatterns.push(`{ type: "bgp", triples: [${objectInitializer({
                     subject: restNVariable,
-                    predicate: this.rdfjsTermExpression(rdf.rest),
+                    predicate: rdfjsTermExpression(rdf.rest),
                     object: variable("RestNBasic"),
                 })}] }`);
                 patterns.push(`{ type: "optional", patterns: [${optionalPatterns.join(", ")}] }`);
@@ -208,12 +233,12 @@ export class ListType extends Type {
     toJsonExpression({ variables, }) {
         let expression = variables.value;
         const itemFromJsonExpression = this.itemType.fromJsonExpression({
-            variables: { value: "_item" },
+            variables: { value: "item" },
         });
-        if (itemFromJsonExpression !== "_item") {
-            expression = `${expression}.map(_item => (${itemFromJsonExpression}))`;
+        if (itemFromJsonExpression !== "item") {
+            expression = `${expression}.map(item => (${itemFromJsonExpression}))`;
         }
-        return `${variables.value}.map(_item => (${this.itemType.toJsonExpression({ variables: { value: "_item" } })}))`;
+        return `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: "item" } })}))`;
     }
     toRdfExpression({ variables, }) {
         let listIdentifier;
@@ -233,9 +258,9 @@ export class ListType extends Type {
                         throw new RangeError(this.identifierMintingStrategy);
                     case "sha256":
                         listIdentifier = `dataFactory.namedNode(\`urn:shaclmate:list:\${${variables.value}.reduce(
-        (_hasher, _item) => {
-          ${this.itemType.hashStatements({ depth: 0, variables: { hasher: "_hasher", value: "_item" } }).join("\n")}
-          return _hasher;
+        (hasher, item) => {
+          ${this.itemType.hashStatements({ depth: 0, variables: { hasher: "hasher", value: "item" } }).join("\n")}
+          return hasher;
         },
         sha256.create(),
       )}\`)`;
@@ -260,16 +285,16 @@ export class ListType extends Type {
       const newSubListResource = ${variables.resourceSet}.${resourceSetMethodName}(${subListIdentifier}, ${objectInitializer({
             mutateGraph: variables.mutateGraph,
         })});
-      currentSubListResource!.add(dataFactory.namedNode("${rdf.rest.value}"), newSubListResource.identifier);
+      currentSubListResource!.add(${rdfjsTermExpression(rdf.rest)}, newSubListResource.identifier);
       currentSubListResource = newSubListResource;
     }
     
-    ${this.toRdfTypes.map((rdfType) => `currentSubListResource.add(dataFactory.namedNode("${rdf.type.value}"), dataFactory.namedNode("${rdfType.value}"))`).join("\n")}
+    ${this.toRdfTypes.map((rdfType) => `currentSubListResource.add(${rdfjsTermExpression(rdf.type)}, dataFactory.namedNode("${rdfType.value}"))`).join("\n")}
         
-    currentSubListResource.add(dataFactory.namedNode("${rdf.first.value}"), ${this.itemType.toRdfExpression({ variables: { mutateGraph: variables.mutateGraph, predicate: `dataFactory.namedNode("${rdf.first.value}")`, resource: "currentSubListResource", resourceSet: variables.resourceSet, value: "item" } })});
+    currentSubListResource.add(${rdfjsTermExpression(rdf.first)}, ${this.itemType.toRdfExpression({ variables: { mutateGraph: variables.mutateGraph, predicate: rdfjsTermExpression(rdf.first), resource: "currentSubListResource", resourceSet: variables.resourceSet, value: "item" } })});
 
     if (itemIndex + 1 === list.length) {
-      currentSubListResource.add(dataFactory.namedNode("${rdf.rest.value}"), dataFactory.namedNode("${rdf.nil.value}"));
+      currentSubListResource.add(${rdfjsTermExpression(rdf.rest)}, ${rdfjsTermExpression(rdf.nil)});
     }
     
     return { currentSubListResource, listResource };
@@ -283,14 +308,30 @@ export class ListType extends Type {
     currentSubListResource: ${mutableResourceTypeName} | null;
     listResource: ${mutableResourceTypeName};
   },
-).listResource.identifier : dataFactory.namedNode("${rdf.nil.value}")`;
+).listResource.identifier : ${rdfjsTermExpression(rdf.nil)}`;
     }
-    useImports(features) {
-        const imports = this.itemType.useImports(features).concat();
-        if (features.has("hash") && this.identifierNodeKind === "NamedNode") {
+    useImports(parameters) {
+        const imports = this.itemType.useImports(parameters).concat();
+        if (parameters.features.has("hash") &&
+            this.identifierNodeKind === "NamedNode") {
             imports.push(Import.SHA256);
         }
         return imports;
     }
 }
+__decorate([
+    Memoize()
+], ListType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "graphqlName", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "jsonName", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "name", null);
 //# sourceMappingURL=ListType.js.map

package/dist/generators/ts/LiteralType.d.ts

@@ -1,16 +1,17 @@
 import type { Literal } from "@rdfjs/types";
 import { TermType } from "./TermType.js";
-export declare class LiteralType extends TermType<Literal> {
+import { Type } from "./Type.js";
+export declare class LiteralType extends TermType<Literal, Literal> {
     private readonly languageIn;
     constructor({ languageIn, ...superParameters }: {
         languageIn: readonly string[];
-    } & Omit<ConstructorParameters<typeof TermType<Literal>>[0], "nodeKinds">);
-    get jsonName(): string;
-    fromJsonExpression({ variables, }: Parameters<TermType<Literal>["fromJsonExpression"]>[0]): string;
-    hashStatements({ depth, variables, }: Parameters<TermType<Literal>["hashStatements"]>[0]): readonly string[];
-    jsonZodSchema({ variables, }: Parameters<TermType<Literal>["jsonZodSchema"]>[0]): ReturnType<TermType<Literal>["jsonZodSchema"]>;
-    propertyFromRdfResourceValueExpression({ variables, }: Parameters<TermType<Literal>["propertyFromRdfResourceValueExpression"]>[0]): string;
-    toJsonExpression({ variables, }: Parameters<TermType<Literal>["toJsonExpression"]>[0]): string;
-    protected propertyFilterRdfResourceValuesExpression({ variables, }: Parameters<TermType<Literal>["propertyFilterRdfResourceValuesExpression"]>[0]): string;
+    } & Omit<ConstructorParameters<typeof TermType<Literal, Literal>>[0], "nodeKinds">);
+    get jsonName(): Type.JsonName;
+    fromJsonExpression({ variables, }: Parameters<TermType<Literal, Literal>["fromJsonExpression"]>[0]): string;
+    hashStatements({ depth, variables, }: Parameters<TermType<Literal, Literal>["hashStatements"]>[0]): readonly string[];
+    jsonZodSchema({ variables, }: Parameters<TermType<Literal, Literal>["jsonZodSchema"]>[0]): ReturnType<TermType<Literal, Literal>["jsonZodSchema"]>;
+    propertyFromRdfResourceValueExpression({ variables, }: Parameters<TermType<Literal, Literal>["propertyFromRdfResourceValueExpression"]>[0]): string;
+    toJsonExpression({ variables, }: Parameters<TermType<Literal, Literal>["toJsonExpression"]>[0]): string;
+    protected propertyFilterRdfResourceValuesExpression({ variables, }: Parameters<TermType<Literal, Literal>["propertyFilterRdfResourceValuesExpression"]>[0]): string;
 }
 //# sourceMappingURL=LiteralType.d.ts.map