@shaclmate/compiler 4.0.19 → 4.0.21

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

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

@@ -13,20 +13,6 @@ import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 import { tsComment } from "../tsComment.js";
 import { AbstractProperty } from "./AbstractProperty.js";
-function propertyPathToCode(propertyPath) {
-    switch (propertyPath.termType) {
-        case "AlternativePath":
-        case "SequencePath":
-            return code `{ members: [${joinCode(propertyPath.members.map(propertyPathToCode), { on: "," })}] as const, termType: ${literalOf(propertyPath.termType)} as const }`;
-        case "InversePath":
-        case "OneOrMorePath":
-        case "ZeroOrMorePath":
-        case "ZeroOrOnePath":
-            return code `{ path: ${propertyPathToCode(propertyPath.path)}, termType: ${literalOf(propertyPath.termType)} as const }`;
-        case "NamedNode":
-            return rdfjsTermExpression(propertyPath);
-    }
-}
 export class ShaclProperty extends AbstractProperty {
     comment;
     description;
@@ -121,7 +107,7 @@ export class ShaclProperty extends AbstractProperty {
             // comment: this.comment.map(JSON.stringify).extract(),
             // description: this.description.map(JSON.stringify).extract(),
             path: this.namedObjectType.features.has("rdf")
-                ? propertyPathToCode(this.path)
+                ? this.propertyPathToCode(this.path)
                 : undefined,
             // label: this.label.map(JSON.stringify).extract(),
             // mutable: this.mutable ? true : undefined,
@@ -235,13 +221,27 @@ export class ShaclProperty extends AbstractProperty {
             default:
                 return [];
         }
-        const propertyPath = propertyPathToCode(this.path);
+        const propertyPath = this.propertyPathToCode(this.path);
         return [
             code `${variables.resource}.add(${propertyPath}, ${this.type.toRdfResourceValuesExpression({
                 variables: { ...variables, propertyPath },
             })}, ${variables.graph});`,
         ];
     }
+    propertyPathToCode(propertyPath) {
+        switch (propertyPath.termType) {
+            case "AlternativePath":
+            case "SequencePath":
+                return code `{ members: [${joinCode(propertyPath.members.map((member) => this.propertyPathToCode(member)), { on: "," })}] as const, termType: ${literalOf(propertyPath.termType)} as const }`;
+            case "InversePath":
+            case "OneOrMorePath":
+            case "ZeroOrMorePath":
+            case "ZeroOrOnePath":
+                return code `{ path: ${this.propertyPathToCode(propertyPath.path)}, termType: ${literalOf(propertyPath.termType)} as const }`;
+            case "NamedNode":
+                return rdfjsTermExpression(propertyPath, { logger: this.logger });
+        }
+    }
 }
 __decorate([
     Memoize()

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

@@ -1,5 +1,5 @@
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code, joinCode } from "../ts-poet-wrapper.js";
+import { code } from "../ts-poet-wrapper.js";
 export function identifierTypeDeclarations() {
     const ancestorObjectTypeWithSameIdentifierType = this.ancestorObjectTypes.find((ancestorObjectType) => ancestorObjectType.identifierType.name === this.identifierType.name);
     if (ancestorObjectTypeWithSameIdentifierType) {
@@ -13,7 +13,11 @@ export function identifierTypeDeclarations() {
     // Bespoke identifier type and associated functions
     return [
         code `export type ${syntheticNamePrefix}Identifier = ${this.identifierType.name};`,
-        code `export namespace ${syntheticNamePrefix}Identifier { ${joinCode([this.identifierType.fromStringFunction, this.identifierType.toStringFunction])} }`,
+        code `\
+export namespace ${syntheticNamePrefix}Identifier {
+  export const parse = ${this.identifierType.parseFunction};
+  export const stringify = ${this.identifierType.stringifyFunction};
+}`,
     ];
 }
 //# sourceMappingURL=identifierTypeDeclarations.js.map

package/dist/generators/ts/_snippets/parseIri.d.ts

@@ -0,0 +1,2 @@
+export declare const snippets_parseIri: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=parseIri.d.ts.map

package/dist/generators/ts/_snippets/parseIri.js

@@ -0,0 +1,12 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_parseIdentifier } from "./snippets_parseIdentifier.js";
+export const snippets_parseIri = conditionalOutput(`${syntheticNamePrefix}parseIri`, code `\
+export function ${syntheticNamePrefix}parseIri(identifier: string): ${imports.Either}<Error, ${imports.NamedNode}> {
+  return \
+    ${snippets_parseIdentifier}(identifier)\
+      .chain((identifier) => (identifier.termType === "NamedNode") ? ${imports.Right}(identifier) : ${imports.Left}(new Error("expected identifier to be NamedNode"))) \
+    as ${imports.Either}<Error, ${imports.NamedNode}>;
+}`);
+//# sourceMappingURL=parseIri.js.map

package/dist/generators/ts/_snippets/snippets_ToRdfResourceValuesFunction.js

@@ -2,9 +2,10 @@ import { imports } from "../imports.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_PropertyPath } from "./snippets_PropertyPath.js";
+const ReturnT = code `${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}`;
 export const snippets_ToRdfResourceValuesFunction = conditionalOutput(`${syntheticNamePrefix}ToRdfResourceValuesFunction`, code `\
-export type ${syntheticNamePrefix}ToRdfResourceValuesFunction<T> =
-  (value: T,
+export type ${syntheticNamePrefix}ToRdfResourceValuesFunction<ValueT, ReturnT extends ${ReturnT} = ${ReturnT}> =
+  (value: ValueT,
    options: {
      graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
      ignoreRdfType?: boolean;
@@ -12,5 +13,5 @@ export type ${syntheticNamePrefix}ToRdfResourceValuesFunction<T> =
      resource: ${imports.Resource};
      resourceSet: ${imports.ResourceSet};
    }
-  ) => (bigint | boolean | number | string | ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode})[];`);
+  ) => ReturnT[];`);
 //# sourceMappingURL=snippets_ToRdfResourceValuesFunction.js.map

package/dist/generators/ts/_snippets/snippets_listSparqlWherePatterns.js

@@ -1,4 +1,5 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
+import { dummyLogger } from "ts-log";
 import { imports } from "../imports.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
@@ -7,6 +8,7 @@ import { snippets_CollectionFilter } from "./snippets_CollectionFilter.js";
 import { snippets_CollectionSchema } from "./snippets_CollectionSchema.js";
 import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
 import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
+const logger = dummyLogger;
 export const snippets_listSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}listSparqlWherePatterns`, code `\
 function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets_ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets_ValueSparqlWherePatternsFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
   return (parameters) => {
@@ -28,7 +30,7 @@ function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>
           triples: [
             {
               subject: listVariable,
-              predicate: ${rdfjsTermExpression(rdf.first)},
+              predicate: ${rdfjsTermExpression(rdf.first, { logger })},
               object: item0Variable,
             },
           ],
@@ -53,7 +55,7 @@ function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>
         triples: [
           {
             subject: listVariable,
-            predicate: ${rdfjsTermExpression(rdf.rest)},
+            predicate: ${rdfjsTermExpression(rdf.rest, { logger })},
             object: rest0Variable,
           },
         ],
@@ -70,7 +72,7 @@ function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>
       triples: [
         {
           subject: listVariable,
-          predicate: { type: "path", pathType: "*", items: [${rdfjsTermExpression(rdf.rest)}] },
+          predicate: { type: "path", pathType: "*", items: [${rdfjsTermExpression(rdf.rest, { logger })}] },
           object: restNVariable,
         },
       ],
@@ -84,7 +86,7 @@ function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>
           triples: [
             {
               subject: restNVariable,
-              predicate: ${rdfjsTermExpression(rdf.first)},
+              predicate: ${rdfjsTermExpression(rdf.first, { logger })},
               object: itemNVariable,
             },
           ],
@@ -107,7 +109,7 @@ function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>
       triples: [
         {
           subject: restNVariable,
-          predicate: ${rdfjsTermExpression(rdf.rest)},
+          predicate: ${rdfjsTermExpression(rdf.rest, { logger })},
           object: variable("RestNBasic"),
         },
       ],

package/dist/generators/ts/_snippets/snippets_parseBlankNode.d.ts

@@ -0,0 +1,2 @@
+export declare const snippets_parseBlankNode: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_parseBlankNode.d.ts.map

package/dist/generators/ts/_snippets/snippets_parseBlankNode.js

@@ -0,0 +1,12 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_parseIdentifier } from "./snippets_parseIdentifier.js";
+export const snippets_parseBlankNode = conditionalOutput(`${syntheticNamePrefix}parseBlankNode`, code `\
+export function ${syntheticNamePrefix}parseBlankNode(identifier: string): ${imports.Either}<Error, ${imports.BlankNode}> {
+  return \
+    ${snippets_parseIdentifier}(identifier)\
+      .chain((identifier) => (identifier.termType === "BlankNode") ? ${imports.Right}(identifier) : ${imports.Left}(new Error("expected identifier to be BlankNode"))) \
+    as ${imports.Either}<Error, ${imports.BlankNode}>;
+}`);
+//# sourceMappingURL=snippets_parseBlankNode.js.map

package/dist/generators/ts/_snippets/snippets_parseIdentifier.d.ts

@@ -0,0 +1,2 @@
+export declare const snippets_parseIdentifier: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_parseIdentifier.d.ts.map

package/dist/generators/ts/_snippets/snippets_parseIdentifier.js

@@ -0,0 +1,6 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_parseIdentifier = conditionalOutput(`${syntheticNamePrefix}parseIdentifier`, code `\
+const ${syntheticNamePrefix}parseIdentifier = ${imports.NTriplesIdentifier}.parser(${imports.dataFactory});`);
+//# sourceMappingURL=snippets_parseIdentifier.js.map