@shaclmate/compiler 4.0.19 → 4.0.21

package/dist/generators/ts/AbstractUnionType.js

@@ -13,24 +13,10 @@ import { removeUndefined } from "./removeUndefined.js";
 import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
-const emptyTermTypesSet = new Set();
-function termTypes(type) {
-    switch (type.kind) {
-        case "BlankNodeType":
-        case "IriType":
-        case "IdentifierType":
-        case "LiteralType":
-        case "TermType":
-            return type.termTypes;
-        default:
-            return emptyTermTypesSet;
-    }
-}
 export class AbstractUnionType extends AbstractType {
     discriminant;
     identifierType;
     abstract = false;
-    lazyMembers;
     recursive;
     constructor({ identifierType, members, recursive, ...superParameters }) {
         super(superParameters);
@@ -222,6 +208,15 @@ export class AbstractUnionType extends AbstractType {
             }}`), { on: ";" })} }`,
         }}`;
     }
+    get toRdfResourceValueTypes() {
+        const set = new Set();
+        for (const member of this.members) {
+            for (const value of member.type.toRdfResourceValueTypes) {
+                set.add(value);
+            }
+        }
+        return set;
+    }
     get typeofs() {
         return NonEmptyList.fromArray(this.concreteMembers.flatMap((member) => member.type.typeofs)).unsafeCoerce();
     }
@@ -318,55 +313,55 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
     }))
 ) satisfies ${snippets.FromRdfResourceValuesFunction}<${this.name}>)`;
     }
-    get inlineJsonType() {
+    get inlineJsonSchema() {
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
             case "extrinsic":
-                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
+                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
             case "hybrid":
-                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ jsonType, primaryDiscriminantValue }, memberI) => {
+                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ primaryDiscriminantValue, type }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
                         case "extrinsic":
-                            return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`;
+                            return code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
                         case "intrinsic":
-                            return code `${jsonType}`;
+                            return type.jsonSchema({
+                                includeDiscriminantProperty: true,
+                                context: "type",
+                            });
                         default:
                             throw new Error();
                     }
-                }), { on: "|" })})`);
+                }), { on: "," })}]).readonly()`;
             case "intrinsic":
+                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({
+                    includeDiscriminantProperty: true,
+                    context: "type",
+                })), { on: "," })}]).readonly()`;
             case "typeof":
-                return new AbstractType.JsonType(joinCode(this.concreteMembers.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
+                return code `${imports.z}.union([${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
             default:
                 throw discriminant;
         }
     }
-    get inlineJsonSchema() {
+    get inlineJsonType() {
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
             case "extrinsic":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
+                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
             case "hybrid":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ primaryDiscriminantValue, type }, memberI) => {
+                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ jsonType, primaryDiscriminantValue }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
                         case "extrinsic":
-                            return code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
+                            return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`;
                         case "intrinsic":
-                            return type.jsonSchema({
-                                includeDiscriminantProperty: true,
-                                context: "type",
-                            });
+                            return code `${jsonType}`;
                         default:
                             throw new Error();
                     }
-                }), { on: "," })}]).readonly()`;
+                }), { on: "|" })})`);
             case "intrinsic":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({
-                    includeDiscriminantProperty: true,
-                    context: "type",
-                })), { on: "," })}]).readonly()`;
             case "typeof":
-                return code `${imports.z}.union([${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
+                return new AbstractType.JsonType(joinCode(this.concreteMembers.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
             default:
                 throw discriminant;
         }
@@ -400,28 +395,6 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
                 throw new Error("should never reach this point");
         }
     }
-    get inlineValueSparqlConstructTriplesFunction() {
-        return code `\
-((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
-  let triples: ${imports.sparqljs}.Triple[] = [];
-
-  ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `\
-triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }));`))}
-  
-  return triples;
-}) satisfies ${snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
-    }
-    get inlineValueSparqlWherePatternsFunction() {
-        return code `\
-((({ filter, schema, ...otherParameters }) => {
-  const unionPatterns: ${imports.sparqljs}.GroupPattern[] = [];
-
-  ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `\
-unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }).concat(), type: "group" });`))}
-  
-  return [{ patterns: unionPatterns, type: "union" }];
-}) satisfies ${snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
-    }
     get inlineToJsonFunction() {
         return code `\
 ((value: ${this.name}): ${this.jsonType().name} => {
@@ -432,7 +405,19 @@ ${joinCode(this.concreteMembers.map(({ typeCheck, typeToJsonExpression, unwrap,
     }
     get inlineToRdfResourceValuesFunction() {
         return code `\
-(((value, _options) => {
+(((value, _options): (${joinCode([...this.toRdfResourceValueTypes].map((toRdfResourceValueType) => {
+            switch (toRdfResourceValueType) {
+                case "BlankNode":
+                    return code `${imports.BlankNode}`;
+                case "Literal":
+                    return code `${imports.Literal}`;
+                case "NamedNode":
+                    return code `${imports.NamedNode}`;
+                default:
+                    toRdfResourceValueType;
+                    throw new Error();
+            }
+        }), { on: " | " })})[] => {
 ${joinCode(this.concreteMembers.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(code `value`)}) { return ${type.toRdfResourceValuesExpression({
             variables: {
                 graph: code `_options.graph`,
@@ -444,7 +429,29 @@ ${joinCode(this.concreteMembers.map(({ type, unwrap, typeCheck }) => code `if ($
         })}; }`))}
 
   throw new Error("unable to serialize to RDF");
-}) as ${snippets.ToRdfResourceValuesFunction}<${this.name}>)`;
+}) satisfies ${snippets.ToRdfResourceValuesFunction}<${this.name}>)`;
+    }
+    get inlineValueSparqlConstructTriplesFunction() {
+        return code `\
+((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
+  let triples: ${imports.sparqljs}.Triple[] = [];
+
+  ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `\
+triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }));`))}
+  
+  return triples;
+}) satisfies ${snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
+    }
+    get inlineValueSparqlWherePatternsFunction() {
+        return code `\
+((({ filter, schema, ...otherParameters }) => {
+  const unionPatterns: ${imports.sparqljs}.GroupPattern[] = [];
+
+  ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `\
+unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }).concat(), type: "group" });`))}
+  
+  return [{ patterns: unionPatterns, type: "union" }];
+}) satisfies ${snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
     }
     get schemaObject() {
         return {
@@ -469,6 +476,7 @@ ${joinCode(this.concreteMembers.map(({ type, unwrap, typeCheck }) => code `if ($
         })
             .concat())} }`);
     }
+    lazyMembers;
 }
 __decorate([
     Memoize()
@@ -485,6 +493,9 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractUnionType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "toRdfResourceValueTypes", null);
 __decorate([
     Memoize()
 ], AbstractUnionType.prototype, "typeofs", null);
@@ -512,6 +523,19 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractUnionType.prototype, "inlineValueSparqlWherePatternsFunction", null);
+function termTypes(type) {
+    switch (type.kind) {
+        case "BlankNodeType":
+        case "IriType":
+        case "IdentifierType":
+        case "LiteralType":
+        case "TermType":
+            return type.termTypes;
+        default:
+            return emptyTermTypesSet;
+    }
+}
+const emptyTermTypesSet = new Set();
 export var Discriminant;
 (function (Discriminant) {
     function infer(members) {

package/dist/generators/ts/BlankNodeType.d.ts

@@ -5,13 +5,13 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly fromStringFunction: Code;
+    readonly parseFunction: Code;
     readonly kind = "BlankNodeType";
     readonly name: Code;
     readonly nodeKinds: ReadonlySet<"BlankNode">;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
-    constructor(superParameters: Pick<ConstructorParameters<typeof AbstractIdentifierType<BlankNode>>[0], "comment" | "label">);
+    constructor(superParameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode>>[0], "hasValues" | "in_">);
     fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;

package/dist/generators/ts/BlankNodeType.js

@@ -13,7 +13,7 @@ import { code } from "./ts-poet-wrapper.js";
 export class BlankNodeType extends AbstractIdentifierType {
     filterFunction = code `${snippets.filterBlankNode}`;
     filterType = code `${snippets.BlankNodeFilter}`;
-    fromStringFunction = code `export const fromString = ${snippets.blankNodeFromString};`;
+    parseFunction = code `${snippets.parseBlankNode};`;
     kind = "BlankNodeType";
     name = code `${imports.BlankNode}`;
     nodeKinds = nodeKinds;

package/dist/generators/ts/BooleanType.js

@@ -38,7 +38,7 @@ export class BooleanType extends AbstractPrimitiveType {
         return code `${imports.z}.boolean()`;
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.literalFactory}.boolean(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
+        return code `[${snippets.literalFactory}.boolean(${variables.value}, ${rdfjsTermExpression(this.datatype, { logger: this.logger })})]`;
     }
     fromRdfExpressionChain({ variables, }) {
         return {

package/dist/generators/ts/DefaultValueType.js

@@ -114,7 +114,7 @@ export class DefaultValueType extends AbstractContainerType {
         }
     }
     get defaultValueTermExpression() {
-        return rdfjsTermExpression(this.defaultValue);
+        return rdfjsTermExpression(this.defaultValue, { logger: this.logger });
     }
     fromJsonExpression(parameters) {
         return this.itemType.fromJsonExpression(parameters);

package/dist/generators/ts/IdentifierType.d.ts

@@ -6,13 +6,13 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class IdentifierType extends AbstractIdentifierType<BlankNode | NamedNode> {
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly fromStringFunction: Code;
+    readonly parseFunction: Code;
     readonly kind = "IdentifierType";
     readonly name: Code;
     readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
-    constructor(parameters: Pick<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "comment" | "label">);
+    constructor(parameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "hasValues" | "in_">);
     fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;

package/dist/generators/ts/IdentifierType.js

@@ -14,7 +14,7 @@ import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class IdentifierType extends AbstractIdentifierType {
     filterFunction = code `${snippets.filterIdentifier}`;
     filterType = code `${snippets.IdentifierFilter}`;
-    fromStringFunction = code `export const fromString = ${snippets.identifierFromString};`;
+    parseFunction = code `${snippets.parseIdentifier};`;
     kind = "IdentifierType";
     name = code `(${imports.BlankNode} | ${imports.NamedNode})`;
     nodeKinds = nodeKinds;

package/dist/generators/ts/IriType.d.ts

@@ -9,7 +9,7 @@ export declare class IriType extends AbstractIdentifierType<NamedNode> {
     readonly nodeKinds: ReadonlySet<"IRI">;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
-    get fromStringFunction(): Code;
+    get parseFunction(): Code;
     get name(): Code;
     protected get schemaObject(): {
         in: Code[] | undefined;

package/dist/generators/ts/IriType.js

@@ -18,18 +18,11 @@ export class IriType extends AbstractIdentifierType {
     nodeKinds = nodeKinds;
     schemaType = code `${snippets.IriSchema}`;
     valueSparqlWherePatternsFunction = code `${snippets.iriSparqlWherePatterns}`;
-    get fromStringFunction() {
-        const expressions = [
-            code `${imports.Either}.encase(() => ${imports.Resource}.Identifier.fromString({ ${imports.dataFactory}, identifier }))`,
-            code `chain((identifier) => (identifier.termType === "NamedNode") ? ${imports.Right}(identifier) : ${imports.Left}(new Error("expected identifier to be NamedNode")))`,
-        ];
+    get parseFunction() {
         if (this.in_.length > 0) {
-            expressions.push(code `chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${imports.Right}(identifier as ${imports.NamedNode}<"${iri.value}">);`))} default: return ${imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`);
+            return code `(identifier: string) => ${snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${imports.Right}(identifier as ${this.name});`))} default: return ${imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
         }
-        return code `\
-export function fromString(identifier: string): ${imports.Either}<Error, ${this.name}> {
-  return ${joinCode(expressions, { on: "." })} as ${imports.Either}<Error, ${this.name}>;
-}`;
+        return code `${snippets.parseIri}`;
     }
     get name() {
         if (this.in_.length > 0) {
@@ -45,7 +38,9 @@ export function fromString(identifier: string): ${imports.Either}<Error, ${this.
         return {
             ...super.schemaObject,
             in: this.in_.length > 0
-                ? this.in_.map(rdfjsTermExpression).concat()
+                ? this.in_
+                    .map((in_) => rdfjsTermExpression(in_, { logger: this.logger }))
+                    .concat()
                 : undefined,
         };
     }
@@ -88,14 +83,14 @@ export function fromString(identifier: string): ${imports.Either}<Error, ${this.
         return {
             ...super.fromRdfExpressionChain({ variables }),
             valueTo: code `chain(values => values.chainMap(value => value.toIri(${this.in_.length > 0
-                ? code `[${joinCode(this.in_.map((in_) => rdfjsTermExpression(in_)), { on: ", " })}]`
+                ? code `[${joinCode(this.in_.map((in_) => rdfjsTermExpression(in_, { logger: this.logger })), { on: ", " })}]`
                 : ""})))`,
         };
     }
 }
 __decorate([
     Memoize()
-], IriType.prototype, "fromStringFunction", null);
+], IriType.prototype, "parseFunction", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "name", null);

package/dist/generators/ts/LazyObjectOptionType.d.ts

@@ -14,6 +14,7 @@ declare const Super: (abstract new ({ partialType, resolveType, runtimeClass, ..
 } & {
     comment: Maybe<string>;
     label: Maybe<string>;
+    logger: import("ts-log").Logger;
 }) => AbstractLazyObjectType<OptionType<AbstractLazyObjectType.ObjectTypeConstraint>, OptionType<AbstractLazyObjectType.ObjectTypeConstraint>>) & {
     readonly GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
     readonly JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;

package/dist/generators/ts/LazyObjectOptionType.js

@@ -71,7 +71,7 @@ export class LazyObjectOptionType extends Super {
         return conversions;
     }
     fromJsonExpression(parameters) {
-        return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${imports.Left}(new Error(\`unable to resolve identifier \${${imports.Resource}.Identifier.toString(identifier)} deserialized from JSON\`))) })`;
+        return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${imports.Left}(new Error(\`unable to resolve identifier \${identifier} deserialized from JSON\`))) })`;
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;

package/dist/generators/ts/LazyObjectType.js

@@ -45,7 +45,7 @@ export class LazyObjectType extends AbstractLazyObjectType {
         return conversions;
     }
     fromJsonExpression(parameters) {
-        return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${imports.Left}(new Error(\`unable to resolve identifier \${${imports.Resource}.Identifier.toString(identifier)} deserialized from JSON\`))) })`;
+        return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${imports.Left}(new Error(\`unable to resolve identifier \${identifier} deserialized from JSON\`))) })`;
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;

package/dist/generators/ts/ListType.js

@@ -85,16 +85,16 @@ export class ListType extends AbstractCollectionType {
       currentSubListResource = listResource;
     } else {
       const newSubListResource = ${variables.resourceSet}.resource(${subListIdentifier});
-      currentSubListResource!.add(${rdfjsTermExpression(rdf.rest)}, newSubListResource.identifier, ${variables.graph});
+      currentSubListResource!.add(${rdfjsTermExpression(rdf.rest, { logger: this.logger })}, newSubListResource.identifier, ${variables.graph});
       currentSubListResource = newSubListResource;
     }
     
-    ${joinCode(this.toRdfTypes.map((rdfType) => code `currentSubListResource.add(${rdfjsTermExpression(rdf.type)}, ${imports.dataFactory}.namedNode("${rdfType.value}"), ${variables.graph})`))}
+    ${joinCode(this.toRdfTypes.map((rdfType) => code `currentSubListResource.add(${rdfjsTermExpression(rdf.type, { logger: this.logger })}, ${imports.dataFactory}.namedNode("${rdfType.value}"), ${variables.graph})`))}
     
-    currentSubListResource.add(${rdfjsTermExpression(rdf.first)}, ${this.itemType.toRdfResourceValuesExpression({ variables: { graph: variables.graph, propertyPath: rdfjsTermExpression(rdf.first), resource: code `currentSubListResource`, resourceSet: variables.resourceSet, value: code `item` } })}, ${variables.graph});
+    currentSubListResource.add(${rdfjsTermExpression(rdf.first, { logger: this.logger })}, ${this.itemType.toRdfResourceValuesExpression({ variables: { graph: variables.graph, propertyPath: rdfjsTermExpression(rdf.first, { logger: this.logger }), resource: code `currentSubListResource`, resourceSet: variables.resourceSet, value: code `item` } })}, ${variables.graph});
 
     if (itemIndex + 1 === list.length) {
-      currentSubListResource.add(${rdfjsTermExpression(rdf.rest)}, ${rdfjsTermExpression(rdf.nil)}, ${variables.graph});
+      currentSubListResource.add(${rdfjsTermExpression(rdf.rest, { logger: this.logger })}, ${rdfjsTermExpression(rdf.nil, { logger: this.logger })}, ${variables.graph});
     }
     
     return { currentSubListResource, listResource };
@@ -106,7 +106,7 @@ export class ListType extends AbstractCollectionType {
     currentSubListResource: ${resourceTypeName} | null;
     listResource: ${resourceTypeName};
   },
-).listResource.identifier : ${rdfjsTermExpression(rdf.nil)}]`;
+).listResource.identifier : ${rdfjsTermExpression(rdf.nil, { logger: this.logger })}]`;
     }
 }
 __decorate([

package/dist/generators/ts/NamedObjectType.d.ts

@@ -77,6 +77,7 @@ export declare class NamedObjectType extends AbstractType {
     get properties(): readonly NamedObjectType.Property[];
     get schema(): Code;
     get schemaType(): Code;
+    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get toRdfjsResourceType(): Code;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;

package/dist/generators/ts/NamedObjectType.js

@@ -4,6 +4,7 @@ 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 { NodeKind } from "@shaclmate/shacl-ast";
 import { camelCase } from "change-case";
 import { Maybe, NonEmptyList } from "purify-ts";
 import { Memoize } from "typescript-memoize";
@@ -228,6 +229,9 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     get schemaType() {
         return code `typeof ${this.schema}`;
     }
+    get toRdfResourceValueTypes() {
+        return new Set([...this.identifierType.nodeKinds].map(NodeKind.toTermType));
+    }
     get toRdfjsResourceType() {
         if (this.parentObjectTypes.length > 0) {
             return this.parentObjectTypes[0].toRdfjsResourceType;
@@ -396,6 +400,9 @@ __decorate([
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "toRdfResourceValueTypes", null);
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "toRdfjsResourceType", null);

package/dist/generators/ts/NamedObjectUnionType.js

@@ -125,7 +125,10 @@ export const ${syntheticNamePrefix}GraphQL = new ${imports.GraphQLUnionType}(${{
     get identifierTypeDeclarations() {
         return singleEntryRecord(`${syntheticNamePrefix}Identifier`, code `\
 export type ${syntheticNamePrefix}Identifier = ${this.#identifierType.name};
-export namespace ${syntheticNamePrefix}Identifier { ${joinCode([this.#identifierType.fromStringFunction, this.#identifierType.toStringFunction])} }`);
+export namespace ${syntheticNamePrefix}Identifier {
+  export const parse = ${this.#identifierType.parseFunction};
+  export const stringify = ${this.#identifierType.stringifyFunction};
+}`);
     }
     get isTypeFunctionDeclaration() {
         if (this._name === `${syntheticNamePrefix}Object`) {

package/dist/generators/ts/SetType.js

@@ -40,7 +40,7 @@ export class SetType extends AbstractCollectionType {
             chain.push(code `map(values => values.toArray()${this._mutable ? ".concat()" : ""})`);
         }
         else {
-            chain.push(code `chain(values => ${imports.NonEmptyList}.fromArray(values.toArray()).toEither(new Error(\`\${${imports.Resource}.Identifier.toString(${variables.resource}.identifier)} is an empty set\`)))`);
+            chain.push(code `chain(values => ${imports.NonEmptyList}.fromArray(values.toArray()).toEither(new Error(\`\${${variables.resource}.identifier} is an empty set\`)))`);
         }
         chain.push(code `map(valuesArray => ${imports.Resource}.Values.fromValue({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: valuesArray }))`);
         return joinCode(chain, { on: "." });

package/dist/generators/ts/StringType.js

@@ -48,7 +48,7 @@ export class StringType extends AbstractPrimitiveType {
         }
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.literalFactory}.string(${variables.value}${!this.datatype.equals(xsd.string) ? `, ${rdfjsTermExpression(this.datatype)}` : ""})]`;
+        return code `[${snippets.literalFactory}.string(${variables.value}${!this.datatype.equals(xsd.string) ? `, ${rdfjsTermExpression(this.datatype, { logger: this.logger })}` : ""})]`;
     }
     fromRdfExpressionChain({ variables, }) {
         return {

package/dist/generators/ts/TermType.js

@@ -49,7 +49,9 @@ export class TermType extends AbstractTermType {
     get schemaObject() {
         return {
             ...super.schemaObject,
-            in: this.in_.length > 0 ? this.in_.map(rdfjsTermExpression) : undefined,
+            in: this.in_.length > 0
+                ? this.in_.map((in_) => rdfjsTermExpression(in_, { logger: this.logger }))
+                : undefined,
         };
     }
     fromJsonExpression({ variables, }) {

package/dist/generators/ts/TsGenerator.d.ts

@@ -1,7 +1,12 @@
+import type { Logger } from "ts-log";
 import * as ast from "../../ast/index.js";
 import type { Generator } from "../Generator.js";
 export declare class TsGenerator implements Generator {
+    private readonly logger;
     private readonly typeFactory;
+    constructor({ logger }: {
+        logger: Logger;
+    });
     generate(ast_: ast.Ast): string;
 }
 //# sourceMappingURL=TsGenerator.d.ts.map

package/dist/generators/ts/TsGenerator.js

@@ -6,7 +6,12 @@ import { synthesizeUberObjectUnionType } from "./synthesizeUberObjectUnionType.j
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class TsGenerator {
-    typeFactory = new TypeFactory();
+    logger;
+    typeFactory;
+    constructor({ logger }) {
+        this.logger = logger;
+        this.typeFactory = new TypeFactory({ logger });
+    }
     generate(ast_) {
         let declarations = [];
         for (const astNamedUnionType of ast_.namedUnionTypes) {
@@ -29,6 +34,7 @@ export class TsGenerator {
         const namedObjectUnionTypesNameSorted = namedObjectUnionTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
         if (namedObjectTypesToposorted.length > 0) {
             const uberObjectUnionType = synthesizeUberObjectUnionType({
+                logger: this.logger,
                 namedObjectTypes: namedObjectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
             });
             declarations = declarations.concat(uberObjectUnionType.declaration.toList());

package/dist/generators/ts/TypeFactory.d.ts

@@ -1,4 +1,5 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
+import type { Logger } from "ts-log";
 import * as ast from "../../ast/index.js";
 import { AnonymousUnionType } from "./AnonymousUnionType.js";
 import { NamedObjectType } from "./NamedObjectType.js";
@@ -9,6 +10,10 @@ export declare class TypeFactory {
     private cachedNamedObjectUnionTypesByShapeIdentifier;
     private cachedObjectTypePropertiesByShapeIdentifier;
     private cachedObjectTypesByShapeIdentifier;
+    private readonly logger;
+    constructor({ logger }: {
+        logger: Logger;
+    });
     createNamedObjectUnionType(astType: ast.ObjectUnionType): NamedObjectUnionType;
     createNamedObjectType(astType: ast.ObjectType): NamedObjectType;
     createType(astType: ast.Type, parameters?: {