@shaclmate/compiler 4.0.18 → 4.0.20

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

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?: {

package/dist/generators/ts/TypeFactory.js

@@ -7,7 +7,6 @@ import { Maybe } from "purify-ts";
 import reservedTsIdentifiers_ from "reserved-identifiers";
 import { invariant } from "ts-invariant";
 import * as ast from "../../ast/index.js";
-import { logger } from "../../logger.js";
 import { AnonymousUnionType } from "./AnonymousUnionType.js";
 import { BigDecimalType } from "./BigDecimalType.js";
 import { BigIntType } from "./BigIntType.js";
@@ -38,6 +37,10 @@ export class TypeFactory {
     cachedNamedObjectUnionTypesByShapeIdentifier = new TermMap();
     cachedObjectTypePropertiesByShapeIdentifier = new TermMap();
     cachedObjectTypesByShapeIdentifier = new TermMap();
+    logger;
+    constructor({ logger }) {
+        this.logger = logger;
+    }
     createNamedObjectUnionType(astType) {
         {
             const cachedNamedObjectUnionType = this.cachedNamedObjectUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
@@ -50,6 +53,7 @@ export class TypeFactory {
             features: astType.tsFeatures,
             identifierType: this.createIdentifierType(ast.ObjectCompoundType.identifierType(astType)),
             label: astType.label,
+            logger: this.logger,
             members: ast.ObjectCompoundType.memberObjectTypes(astType).map((namedObjectType) => ({
                 discriminantValue: Maybe.empty(),
                 type: this.createNamedObjectType(namedObjectType),
@@ -97,6 +101,7 @@ export class TypeFactory {
                     }
                 }
                 return new NamedObjectType.DiscriminantProperty({
+                    logger: this.logger,
                     name: `${syntheticNamePrefix}type`,
                     namedObjectType,
                     type: new NamedObjectType.DiscriminantProperty.Type({
@@ -110,6 +115,7 @@ export class TypeFactory {
             lazyIdentifierProperty: (namedObjectType) => new NamedObjectType.IdentifierProperty({
                 identifierMintingStrategy: astType.identifierMintingStrategy,
                 identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
+                logger: this.logger,
                 name: `${syntheticNamePrefix}identifier`,
                 namedObjectType,
                 type: identifierType,
@@ -139,6 +145,7 @@ export class TypeFactory {
                 // Some ObjectTypes have an identifierPrefix property, depending on their identifier minting strategy.
                 if (namedObjectTypeNeedsIdentifierPrefixProperty(astType)) {
                     properties.splice(0, 0, new NamedObjectType.IdentifierPrefixProperty({
+                        logger: this.logger,
                         name: `${syntheticNamePrefix}identifierPrefix`,
                         namedObjectType,
                         own: !astType.ancestorObjectTypes.some(namedObjectTypeNeedsIdentifierPrefixProperty),
@@ -148,6 +155,7 @@ export class TypeFactory {
                             hasValues: [],
                             in_: [],
                             label: astType.label,
+                            logger: this.logger,
                             languageIn: [],
                             primitiveIn: [],
                         }),
@@ -158,6 +166,7 @@ export class TypeFactory {
                 properties.splice(0, 0, namedObjectType.identifierProperty);
                 return properties;
             },
+            logger: this.logger,
             name,
             recursive: astType.recursive,
             staticModuleName,
@@ -211,6 +220,7 @@ export class TypeFactory {
             features: astType.tsFeatures,
             identifierType: Maybe.empty(),
             label: astType.label,
+            logger: this.logger,
             members: astType.members.map((member) => ({
                 discriminantValue: member.discriminantValue,
                 type: this.createType(member.type),
@@ -222,6 +232,7 @@ export class TypeFactory {
             comment: astType.comment,
             label: astType.label,
             identifierType: Maybe.empty(),
+            logger: this.logger,
             members: astType.members.map((member) => ({
                 discriminantValue: member.discriminantValue,
                 type: this.createType(member.type),
@@ -233,6 +244,7 @@ export class TypeFactory {
         return new BlankNodeType({
             comment: astType.comment,
             label: astType.label,
+            logger: this.logger,
         });
     }
     createDefaultValueType(astType) {
@@ -245,6 +257,7 @@ export class TypeFactory {
             defaultValue: astType.defaultValue,
             itemType,
             label: astType.label,
+            logger: this.logger,
         });
     }
     createIdentifierType(astType) {
@@ -255,6 +268,7 @@ export class TypeFactory {
                 return new IdentifierType({
                     comment: astType.comment,
                     label: astType.label,
+                    logger: this.logger,
                 });
             case "IriType":
                 return this.createIriType(astType);
@@ -266,12 +280,14 @@ export class TypeFactory {
             hasValues: astType.hasValues,
             in_: astType.in_,
             label: astType.label,
+            logger: this.logger,
         });
     }
     createLazyObjectOptionType(astType) {
         return new LazyObjectOptionType({
             comment: astType.comment,
             label: astType.label,
+            logger: this.logger,
             partialType: this.createOptionType(astType.partialType),
             resolveType: this.createOptionType(astType.resolveType),
         });
@@ -280,6 +296,7 @@ export class TypeFactory {
         return new LazyObjectSetType({
             comment: astType.comment,
             label: astType.label,
+            logger: this.logger,
             partialType: this.createSetType(astType.partialType),
             resolveType: this.createSetType(astType.resolveType),
         });
@@ -288,6 +305,7 @@ export class TypeFactory {
         return new LazyObjectType({
             comment: astType.comment,
             label: astType.label,
+            logger: this.logger,
             partialType: this.createType(astType.partialType),
             resolveType: this.createType(astType.resolveType),
         });
@@ -300,6 +318,7 @@ export class TypeFactory {
             identifierNodeKind: astType.identifierNodeKind,
             itemType,
             label: astType.label,
+            logger: this.logger,
             minCount: 0,
             mutable: astType.mutable,
             identifierMintingStrategy: astType.identifierMintingStrategy,
@@ -336,6 +355,7 @@ export class TypeFactory {
                             in_: astType.in_,
                             label: astType.label,
                             languageIn: [],
+                            logger: this.logger,
                         });
                     case "bigint":
                         return new BigIntType({
@@ -345,6 +365,7 @@ export class TypeFactory {
                             in_: astType.in_,
                             label: astType.label,
                             languageIn: [],
+                            logger: this.logger,
                             primitiveIn: astType.in_.map((value) => LiteralDecoder.decodeBigIntLiteral(value).unsafeCoerce()),
                         });
                     case "boolean":
@@ -355,6 +376,7 @@ export class TypeFactory {
                             label: astType.label,
                             languageIn: [],
                             in_: astType.in_,
+                            logger: this.logger,
                             primitiveIn: astType.in_.map((value) => LiteralDecoder.decodeBooleanLiteral(value).unsafeCoerce()),
                         });
                     case "date":
@@ -366,6 +388,7 @@ export class TypeFactory {
                             in_: astType.in_,
                             label: astType.label,
                             languageIn: [],
+                            logger: this.logger,
                             primitiveIn: astType.in_.map((value) => (datatypeDefinition.kind === "date"
                                 ? LiteralDecoder.decodeDateLiteral
                                 : LiteralDecoder.decodeDateTimeLiteral)(value).unsafeCoerce()),
@@ -379,6 +402,7 @@ export class TypeFactory {
                             in_: astType.in_,
                             label: astType.label,
                             languageIn: [],
+                            logger: this.logger,
                             primitiveIn: astType.in_.map((value) => (datatypeDefinition.kind === "float"
                                 ? LiteralDecoder.decodeFloatLiteral
                                 : LiteralDecoder.decodeIntLiteral)(value).unsafeCoerce()),
@@ -389,9 +413,10 @@ export class TypeFactory {
                                 comment: astType.comment,
                                 datatype,
                                 hasValues: astType.hasValues,
+                                in_: astType.in_,
                                 label: astType.label,
                                 languageIn: astType.languageIn,
-                                in_: astType.in_,
+                                logger: this.logger,
                                 primitiveIn: astType.in_.map((value) => value.value),
                             });
                         }
@@ -402,14 +427,14 @@ export class TypeFactory {
                 // Drop down
             }
             else {
-                logger.warn("unrecognized literal datatype: %s", datatype.value);
+                this.logger.warn("unrecognized literal datatype: %s", datatype.value);
             }
         }
         else if (datatypes.size > 0) {
-            logger.warn("literal type has multiple datatypes: %s", JSON.stringify([...datatypes].map((datatype) => datatype.value)));
+            this.logger.warn("literal type has multiple datatypes: %s", JSON.stringify([...datatypes].map((datatype) => datatype.value)));
         }
         else {
-            logger.debug("literal type has no datatypes");
+            this.logger.debug("literal type has no datatypes");
         }
         return new LiteralType({
             comment: astType.comment,
@@ -417,6 +442,7 @@ export class TypeFactory {
             in_: astType.in_,
             label: astType.label,
             languageIn: astType.languageIn,
+            logger: this.logger,
         });
     }
     createObjectTypeProperty({ astObjectTypeProperty, namedObjectType, }) {
@@ -430,6 +456,7 @@ export class TypeFactory {
             comment: astObjectTypeProperty.comment,
             description: astObjectTypeProperty.description,
             label: astObjectTypeProperty.label,
+            logger: this.logger,
             mutable: astObjectTypeProperty.mutable,
             namedObjectType,
             name: tsName(astObjectTypeProperty.name),
@@ -448,6 +475,7 @@ export class TypeFactory {
             comment: astType.comment,
             itemType,
             label: astType.label,
+            logger: this.logger,
         });
     }
     createSetType(astType) {
@@ -457,6 +485,7 @@ export class TypeFactory {
             comment: astType.comment,
             itemType,
             label: astType.label,
+            logger: this.logger,
             mutable: astType.mutable,
             minCount: astType.minCount,
         });
@@ -467,6 +496,7 @@ export class TypeFactory {
             hasValues: astType.hasValues,
             in_: astType.in_,
             label: astType.label,
+            logger: this.logger,
             nodeKinds: astType.nodeKinds,
         });
     }

package/dist/generators/ts/ZodGenerator.d.ts

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

package/dist/generators/ts/ZodGenerator.js

@@ -7,7 +7,10 @@ import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ZodGenerator {
-    typeFactory = new TypeFactory();
+    typeFactory;
+    constructor({ logger }) {
+        this.typeFactory = new TypeFactory({ logger });
+    }
     generate(ast_) {
         const declarations = [];
         for (const namedObjectType of ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => this.typeFactory.createNamedObjectType(astObjectType))) {

package/dist/generators/ts/_NamedObjectType/AbstractProperty.d.ts

@@ -1,9 +1,11 @@
 import type { Maybe } from "purify-ts";
+import type { Logger } from "ts-log";
 import type { Visibility } from "../../../enums/Visibility.js";
 import type { NamedObjectType } from "../NamedObjectType.js";
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterFunction" | "mutable" | "name" | "schema">> {
+    protected readonly logger: Logger;
     protected readonly namedObjectType: NamedObjectType;
     /**
      * Optional property to include in the parameters object of a class constructor.
@@ -75,7 +77,8 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
      * Property visibility: private, protected, public.
      */
     readonly visibility: Visibility;
-    constructor({ name, namedObjectType, type, visibility, }: {
+    constructor({ logger, name, namedObjectType, type, visibility, }: {
+        logger: Logger;
         name: string;
         namedObjectType: NamedObjectType;
         type: TypeT;

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

@@ -9,6 +9,7 @@ import { Memoize } from "typescript-memoize";
 import { removeUndefined } from "../removeUndefined.js";
 import { code, literalOf } from "../ts-poet-wrapper.js";
 export class AbstractProperty {
+    logger;
     namedObjectType;
     /**
      * TypeScript identifier-safe name of the property.
@@ -22,7 +23,8 @@ export class AbstractProperty {
      * Property visibility: private, protected, public.
      */
     visibility;
-    constructor({ name, namedObjectType, type, visibility, }) {
+    constructor({ logger, name, namedObjectType, type, visibility, }) {
+        this.logger = logger;
         this.name = name;
         this.namedObjectType = namedObjectType;
         this.type = type;

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

@@ -9,7 +9,6 @@ import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { logger } from "../../../logger.js";
 import { codeEquals } from "../codeEquals.js";
 import { imports } from "../imports.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
@@ -138,7 +137,7 @@ export class IdentifierProperty extends AbstractProperty {
             args: Maybe.empty(),
             description: Maybe.empty(),
             name: `_${this.name.substring(syntheticNamePrefix.length)}`,
-            resolve: code `(source) => ${this.typeAlias}.toString(source.${this.name})`,
+            resolve: code `(source) => ${this.typeAlias}.stringify(source.${this.name})`,
             type: this.type.graphqlType.name,
         });
     }
@@ -260,7 +259,7 @@ export class IdentifierProperty extends AbstractProperty {
                             mintIdentifier = code `${imports.dataFactory}.blankNode()`;
                             break;
                         case "sha256":
-                            logger.warn("minting %s identifiers with %s is unsupported", this.namedObjectType.declarationType, identifierMintingStrategy);
+                            this.logger.warn("minting %s identifiers with %s is unsupported", this.namedObjectType.declarationType, identifierMintingStrategy);
                             return;
                         case "uuidv4":
                             mintIdentifier = code `${imports.dataFactory}.namedNode(\`\${${variables.parameters}.${this.identifierPrefixPropertyName} ?? "urn:shaclmate:${this.namedObjectType.discriminantValue}:"}\${${imports.uuid}.v4()}\`)`;
@@ -284,8 +283,10 @@ export class IdentifierProperty extends AbstractProperty {
         return Maybe.of(code `${this.type.fromRdfResourceValuesExpression({
             variables: {
                 ...variables,
-                propertyPath: rdfjsTermExpression(rdf.subject),
-                resourceValues: code `${imports.Right}(new ${imports.Resource}.Value(${{ dataFactory: imports.dataFactory, focusResource: variables.resource, propertyPath: rdfjsTermExpression(rdf.subject), term: code `${variables.resource}.identifier` }}).toValues())`,
+                propertyPath: rdfjsTermExpression(rdf.subject, {
+                    logger: this.logger,
+                }),
+                resourceValues: code `${imports.Right}(new ${imports.Resource}.Value(${{ dataFactory: imports.dataFactory, focusResource: variables.resource, propertyPath: rdfjsTermExpression(rdf.subject, { logger: this.logger }), term: code `${variables.resource}.identifier` }}).toValues())`,
             },
         })}.chain(values => values.head())`);
     }

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

@@ -26,8 +26,8 @@ export function NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration()
         statements.push(code `\
 if (!parameters?.ignoreRdfType) {
   triples.push(
-    { subject: ${variables.focusIdentifier}, predicate: ${rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} },
-    { subject: ${rdfTypeVariable}, predicate: ${rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }
+    { subject: ${variables.focusIdentifier}, predicate: ${rdfjsTermExpression(rdf.type, { logger: this.logger })}, object: ${rdfTypeVariable} },
+    { subject: ${rdfTypeVariable}, predicate: ${rdfjsTermExpression(rdfs.subClassOf, { logger: this.logger })}, object: ${rdfClassVariable} }
   );
 }`);
     }

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

@@ -47,7 +47,7 @@ if (!parameters?.ignoreRdfType) {
       triples: [
         {
           subject: ${variables.focusIdentifier},
-          predicate: ${rdfjsTermExpression(rdf.type)},
+          predicate: ${rdfjsTermExpression(rdf.type, { logger: this.logger })},
           object: rdfTypeVariable
         }
       ],
@@ -60,7 +60,7 @@ if (!parameters?.ignoreRdfType) {
             {
               subject: rdfTypeVariable,
               predicate: {
-                items: [${rdfjsTermExpression(rdfs.subClassOf)}],
+                items: [${rdfjsTermExpression(rdfs.subClassOf, { logger: this.logger })}],
                 pathType: "+" as const,
                 type: "path" as const
               },

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

@@ -8,6 +8,6 @@ export function NamedObjectType_fromRdfTypeVariableStatement() {
         return Maybe.empty();
     }
     return this.fromRdfType.map((fromRdfType) => code `\
-export const ${syntheticNamePrefix}fromRdfType: ${imports.NamedNode}<string> = ${rdfjsTermExpression(fromRdfType)};`);
+export const ${syntheticNamePrefix}fromRdfType: ${imports.NamedNode}<string> = ${rdfjsTermExpression(fromRdfType, { logger: this.logger })};`);
 }
 //# sourceMappingURL=NamedObjectType_fromRdfTypeVariableStatement.js.map

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

@@ -32,7 +32,7 @@ export function NamedObjectType_propertiesFromRdfResourceFunctionDeclaration() {
     });
     this.fromRdfType.ifJust((fromRdfType) => {
         const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();
-        const predicate = rdfjsTermExpression(rdf.type);
+        const predicate = rdfjsTermExpression(rdf.type, { logger: this.logger });
         // Check the expected type and its known subtypes
         const cases = new Set();
         cases.add(fromRdfType.value);
@@ -54,7 +54,7 @@ export function NamedObjectType_propertiesFromRdfResourceFunctionDeclaration() {
         return ${imports.Right}(true as const);
       }
 
-      return ${imports.Left}(new Error(\`\${${imports.Resource}.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type (actual: \${actualRdfType.value}, expected: ${fromRdfType.value})\`));
+      return ${imports.Left}(new Error(\`\${${variables.resource}.identifier} has unexpected RDF type (actual: \${actualRdfType.value}, expected: ${fromRdfType.value})\`));
     }) : ${imports.Right}(true as const)`,
             variable: "_rdfTypeCheck",
         });

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

@@ -40,7 +40,7 @@ export function NamedObjectType_toRdfResourceFunctionOrMethodDeclaration() {
         statements.push(code `const ${variables.resource} = ${variables.resourceSet}.resource(${this.thisVariable}.${this.identifierProperty.name});`);
     }
     if (this.toRdfTypes.length > 0) {
-        statements.push(code `if (!options?.${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${rdfjsTermExpression(rdf.type)}, ${imports.dataFactory}.namedNode("${toRdfType.value}"), options?.${variables.graph});`), { on: " " })} }`);
+        statements.push(code `if (!options?.${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${rdfjsTermExpression(rdf.type, { logger: this.logger })}, ${imports.dataFactory}.namedNode("${toRdfType.value}"), options?.${variables.graph});`), { on: " " })} }`);
     }
     for (const property of this.properties) {
         statements.push(...property.toRdfRdfResourceValuesStatements({

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

@@ -44,5 +44,6 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
     sparqlWherePatternsExpression({ variables, }: Parameters<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>[0]): ReturnType<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>;
     toJsonObjectMemberExpression(parameters: Parameters<AbstractProperty<TypeT>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements({ variables, }: Parameters<AbstractProperty<TypeT>["toRdfRdfResourceValuesStatements"]>[0]): readonly Code[];
+    private propertyPathToCode;
 }
 //# sourceMappingURL=ShaclProperty.d.ts.map