@shaclmate/compiler 4.0.19 → 4.0.20

package/dist/ast/ObjectType.d.ts

@@ -99,58 +99,28 @@ export declare class ObjectType extends AbstractType {
     equals(other: ObjectType): boolean;
     sortProperties(): void;
     toJSON(): {
-        fromRdfType: string | undefined;
+        fromRdfType: NamedNode<string> | undefined;
         identifierMintingStrategy: "blankNode" | "sha256" | "uuidv4" | undefined;
         identifierType: {
-            hasValues: ({
-                termType: "BlankNode";
-                value: string;
-                datatype?: undefined;
-                language?: undefined;
-            } | {
-                datatype: string;
-                language: string;
-                termType: "Literal";
-                value: string;
-            } | {
-                termType: "NamedNode";
-                value: string;
-                datatype?: undefined;
-                language?: undefined;
-            })[] | undefined;
-            in: ({
-                termType: "BlankNode";
-                value: string;
-                datatype?: undefined;
-                language?: undefined;
-            } | {
-                datatype: string;
-                language: string;
-                termType: "Literal";
-                value: string;
-            } | {
-                termType: "NamedNode";
-                value: string;
-                datatype?: undefined;
-                language?: undefined;
-            })[] | undefined;
+            hasValues: readonly NamedNode<string>[] | undefined;
+            in: readonly NamedNode<string>[] | undefined;
             nodeKinds: NodeKind[];
             comment: string | undefined;
             kind: string;
             label: string | undefined;
             name: string | undefined;
             recursive: boolean | undefined;
-            shapeIdentifier: string;
+            shapeIdentifier: BlankNode | NamedNode<string>;
         };
-        parentObjectTypes: string[] | undefined;
+        parentObjectTypes: (string | BlankNode | NamedNode<string>)[] | undefined;
         synthetic: boolean | undefined;
-        toRdfTypes: string[] | undefined;
+        toRdfTypes: readonly NamedNode<string>[] | undefined;
         comment: string | undefined;
         kind: string;
         label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
-        shapeIdentifier: string;
+        shapeIdentifier: BlankNode | NamedNode<string>;
     };
 }
 export declare namespace ObjectType {
@@ -227,14 +197,14 @@ export declare namespace ObjectType {
             order: number;
             path: string;
             recursive: boolean | undefined;
-            shapeIdentifier: string;
+            shapeIdentifier: BlankNode | NamedNode<string>;
             type: {
                 comment: string | undefined;
                 kind: string;
                 label: string | undefined;
                 name: string | undefined;
                 recursive: boolean | undefined;
-                shapeIdentifier: string;
+                shapeIdentifier: BlankNode | NamedNode<string>;
             };
             visibility: Visibility;
         };

package/dist/ast/ObjectType.js

@@ -4,7 +4,8 @@ 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 { PropertyPath, Resource } from "@rdfx/resource";
+import { PropertyPath } from "@rdfx/resource";
+import { NTriplesIdentifier } from "@rdfx/string";
 import genericToposort from "toposort";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
@@ -169,16 +170,15 @@ export class ObjectType extends AbstractType {
     toJSON() {
         return {
             ...super.toJSON(),
-            fromRdfType: this.fromRdfType.map(Resource.Identifier.toString).extract(),
+            fromRdfType: this.fromRdfType.extract(),
             identifierMintingStrategy: this.identifierMintingStrategy.extract(),
             identifierType: this.identifierType.toJSON(),
             parentObjectTypes: this.parentObjectTypes.length > 0
-                ? this.parentObjectTypes.map((parentObjectType) => parentObjectType.name.orDefault(Resource.Identifier.toString(parentObjectType.shapeIdentifier)))
+                ? this.parentObjectTypes.map((parentObjectType) => parentObjectType.name.extract() ??
+                    parentObjectType.shapeIdentifier)
                 : undefined,
             synthetic: this.synthetic ? true : undefined,
-            toRdfTypes: this.toRdfTypes.length > 0
-                ? this.toRdfTypes.map(Resource.Identifier.toString)
-                : undefined,
+            toRdfTypes: this.toRdfTypes.length > 0 ? this.toRdfTypes : undefined,
         };
     }
 }
@@ -372,7 +372,7 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
                 order: this.order,
                 path: PropertyPath.toString(this.path),
                 recursive: this.recursive ? true : undefined,
-                shapeIdentifier: Resource.Identifier.toString(this.shapeIdentifier),
+                shapeIdentifier: this.shapeIdentifier,
                 type: this.type.toJSON(),
                 visibility: this.visibility,
             };
@@ -392,18 +392,14 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
         const objectTypeGraphNodes = [];
         const objectTypeGraphEdges = [];
         for (const objectType of objectTypes) {
-            const objectTypeShapeIdentifier = Resource.Identifier.toString(objectType.shapeIdentifier);
+            const objectTypeShapeIdentifier = NTriplesIdentifier.stringify(objectType.shapeIdentifier);
             invariant(!objectTypesByShapeIdentifier[objectTypeShapeIdentifier]);
             objectTypesByShapeIdentifier[objectTypeShapeIdentifier] = objectType;
             objectTypeGraphNodes.push(objectTypeShapeIdentifier);
             for (const parentAstObjectType of objectType.parentObjectTypes) {
-                // console.log(
-                //   objectTypeShapeIdentifier,
-                //   Resource.Identifier.toString(parentAstObjectType.shapeIdentifier),
-                // );
                 objectTypeGraphEdges.push([
                     objectTypeShapeIdentifier,
-                    Resource.Identifier.toString(parentAstObjectType.shapeIdentifier),
+                    NTriplesIdentifier.stringify(parentAstObjectType.shapeIdentifier),
                 ]);
             }
         }

package/dist/ast/SetType.d.ts

@@ -21,7 +21,7 @@ export declare class SetType<ItemTypeT extends SetType.ItemType = SetType.ItemTy
         label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
-        shapeIdentifier: string;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
     };
 }
 export declare namespace SetType {

package/dist/ast/UnionType.d.ts

@@ -17,7 +17,7 @@ export declare class UnionType<MemberTypeT extends UnionType.MemberType = UnionT
         label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
-        shapeIdentifier: string;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
     };
 }
 export declare namespace UnionType {

package/dist/generators/transformAstToLabeledPropertyGraph.js

@@ -1,4 +1,3 @@
-import { Resource } from "@rdfx/resource";
 import { Maybe } from "purify-ts";
 export function transformAstToLabeledPropertyGraph(ast) {
     const nodes = [];
@@ -34,7 +33,7 @@ export function transformAstToLabeledPropertyGraph(ast) {
                 case "UnionType":
                     if (itemType.name.isJust()) {
                         relationships.push({
-                            id: Resource.Identifier.toString(namedObjectTypeProperty.shapeIdentifier),
+                            id: namedObjectTypeProperty.shapeIdentifier.toString(),
                             label: Maybe.of(namedObjectTypeProperty.name),
                             properties: {},
                             sourceNodeId: id,
@@ -68,9 +67,9 @@ export function transformAstToLabeledPropertyGraph(ast) {
     };
 }
 function typeId(type) {
-    return type.name.orDefault(Resource.Identifier.toString(type.shapeIdentifier));
+    return type.name.orDefault(type.shapeIdentifier.toString());
 }
 function typeName(type) {
-    return type.name.orDefault(Resource.Identifier.toString(type.shapeIdentifier));
+    return type.name.orDefault(type.shapeIdentifier.toString());
 }
 //# sourceMappingURL=transformAstToLabeledPropertyGraph.js.map

package/dist/generators/ts/AbstractDateType.js

@@ -49,7 +49,7 @@ export class AbstractDateType extends AbstractPrimitiveType {
         return new AbstractPrimitiveType.JsonType(code `string`);
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.literalFactory}.date(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
+        return code `[${snippets.literalFactory}.date(${variables.value}, ${rdfjsTermExpression(this.datatype, { logger: this.logger })})]`;
     }
     fromRdfExpressionChain({ variables, }) {
         return {

package/dist/generators/ts/AbstractIdentifierType.d.ts

@@ -3,11 +3,11 @@ import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import { AbstractTermType } from "./AbstractTermType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractIdentifierType<IdentifierT extends BlankNode | NamedNode> extends AbstractTermType<NamedNode, IdentifierT> {
-    abstract readonly fromStringFunction: Code;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     abstract readonly kind: "BlankNodeType" | "IdentifierType" | "IriType";
     abstract readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
-    readonly toStringFunction: Code;
+    abstract readonly parseFunction: Code;
+    readonly stringifyFunction: Code;
     get conversions(): readonly AbstractTermType.Conversion[];
     graphqlResolveExpression({ variables: { value }, }: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
 }

package/dist/generators/ts/AbstractIdentifierType.js

@@ -10,10 +10,7 @@ import { imports } from "./imports.js";
 import { code } from "./ts-poet-wrapper.js";
 export class AbstractIdentifierType extends AbstractTermType {
     graphqlType = new AbstractTermType.GraphqlType(code `${imports.GraphQLString}`);
-    toStringFunction = // Re-export rdfjsResource.Resource.Identifier.toString
-     code `\
-// biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
-export const toString = ${imports.Resource}.Identifier.toString`;
+    stringifyFunction = code `${imports.NTriplesTerm}.stringify`;
     get conversions() {
         const conversions = super.conversions.concat();
         if (this.nodeKinds.has("IRI")) {
@@ -29,7 +26,7 @@ export const toString = ${imports.Resource}.Identifier.toString`;
         return conversions;
     }
     graphqlResolveExpression({ variables: { value }, }) {
-        return code `${imports.Resource}.Identifier.toString(${value})`;
+        return code `${imports.NTriplesTerm}.stringify(${value})`;
     }
 }
 __decorate([

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -92,7 +92,7 @@ ${this.jsonTypeAliasDeclaration}
 export namespace ${syntheticNamePrefix}Json {
   ${this.jsonSchemaFunctionDeclaration}
 
-  export function ${syntheticNamePrefix}parse(json: unknown): ${imports.Either}<Error, ${syntheticNamePrefix}Json> {
+  export function parse(json: unknown): ${imports.Either}<Error, ${syntheticNamePrefix}Json> {
     const jsonSafeParseResult = schema().safeParse(json);
     if (!jsonSafeParseResult.success) { return ${imports.Left}(jsonSafeParseResult.error); }
     return ${imports.Right}(jsonSafeParseResult.data);

package/dist/generators/ts/AbstractNumericType.js

@@ -51,7 +51,7 @@ export class AbstractNumericType extends AbstractPrimitiveType {
         }
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.literalFactory}.${this.typeofs[0]}(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
+        return code `[${snippets.literalFactory}.${this.typeofs[0]}(${variables.value}, ${rdfjsTermExpression(this.datatype, { logger: this.logger })})]`;
     }
     fromRdfExpressionChain({ variables, }) {
         return {

package/dist/generators/ts/AbstractTermType.js

@@ -136,7 +136,7 @@ export class AbstractTermType extends AbstractType {
     fromRdfExpressionChain({ variables, }) {
         let valueToExpression;
         if (this.in_.length > 0) {
-            valueToExpression = code `value.toTerm([${joinCode(this.in_.map((in_) => rdfjsTermExpression(in_)), { on: ", " })}])`;
+            valueToExpression = code `value.toTerm([${joinCode(this.in_.map((in_) => rdfjsTermExpression(in_, { logger: this.logger })), { on: ", " })}])`;
         }
         else if (this.nodeKinds.size < 3) {
             const eitherTypeParameters = code `<Error, ${this.name}>`;
@@ -152,7 +152,7 @@ export class AbstractTermType extends AbstractType {
         return {
             hasValues: this.hasValues.length > 0
                 ? code `\
-chain(values => ${imports.Either}.sequence([${joinCode(this.hasValues.map(rdfjsTermExpression), { on: ", " })}].map(hasValue => values.find(value => value.term.equals(hasValue)))).map(() => values))`
+chain(values => ${imports.Either}.sequence([${joinCode(this.hasValues.map((hasValue) => rdfjsTermExpression(hasValue, { logger: this.logger })), { on: ", " })}].map(hasValue => values.find(value => value.term.equals(hasValue)))).map(() => values))`
                 : undefined,
             valueTo: code `chain(values => values.chainMap(value => ${valueToExpression}))`,
         };

package/dist/generators/ts/AbstractType.d.ts

@@ -1,10 +1,12 @@
 import type { Maybe, NonEmptyList } from "purify-ts";
+import type { Logger } from "ts-log";
 import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class all types.
  */
 export declare abstract class AbstractType {
+    protected readonly logger: Logger;
     /**
      * Is the type abstract?
      */
@@ -104,9 +106,10 @@ export declare abstract class AbstractType {
      * - variablePrefix: string prefix to use for new variables
      */
     abstract readonly valueSparqlWherePatternsFunction: Code;
-    constructor({ comment, label, }: {
+    constructor({ comment, label, logger, }: {
         comment: Maybe<string>;
         label: Maybe<string>;
+        logger: Logger;
     });
     /**
      * Helper to compose the result of schema along the type hierarchy.
@@ -177,6 +180,19 @@ export declare abstract class AbstractType {
             value: Code;
         };
     }): readonly Code[];
+    /**
+     * Zod schema for the JSON type of this type.
+     *
+     * This method is called in two contexts:
+     * "property": from a ShaclProperty, while generating the z.object properties of an NamedObjectType
+     * "type": from another Type e.g., an OptionType or UnionType
+     *
+     * z.lazy() should only be returned for "property".
+     */
+    abstract jsonSchema(parameters: {
+        includeDiscriminantProperty?: boolean;
+        context: "property" | "type";
+    }): Code;
     /**
      * JSON-compatible version of the type.
      */
@@ -191,19 +207,6 @@ export declare abstract class AbstractType {
             scopePrefix: Code;
         };
     }): Maybe<Code>;
-    /**
-     * Zod schema for the JSON type of this type.
-     *
-     * This method is called in two contexts:
-     * "property": from a ShaclProperty, while generating the z.object properties of an NamedObjectType
-     * "type": from another Type e.g., an OptionType or UnionType
-     *
-     * z.lazy() should only be returned for "property".
-     */
-    abstract jsonSchema(parameters: {
-        includeDiscriminantProperty?: boolean;
-        context: "property" | "type";
-    }): Code;
     /**
      * An expression that converts a value of this type to a JSON-LD compatible value. It can assume the presence
      * of the correct JSON-LD context.

package/dist/generators/ts/AbstractType.js

@@ -12,6 +12,7 @@ import { code, literalOf } from "./ts-poet-wrapper.js";
  * Abstract base class all types.
  */
 export class AbstractType {
+    logger;
     /**
      * Comment from rdfs:comment.
      */
@@ -20,9 +21,10 @@ export class AbstractType {
      * Label from rdfs:label.
      */
     label;
-    constructor({ comment, label, }) {
+    constructor({ comment, label, logger, }) {
         this.comment = comment;
         this.label = label;
+        this.logger = logger;
     }
     /**
      * Helper to compose the result of schema along the type hierarchy.

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/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