@shaclmate/compiler 4.0.33 → 4.0.35

package/dist/generators/ts/LazyObjectSetType.d.ts

@@ -1,10 +1,11 @@
+import { Maybe } from "purify-ts";
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import type { SetType } from "./SetType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LazyObjectSetType extends AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>> {
     readonly graphqlArgs: Super["graphqlArgs"];
     readonly kind = "LazyObjectSetType";
-    get conversions(): readonly AbstractLazyObjectType.Conversion[];
+    get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
     protected get runtimeClass(): {
         name: Code;
         partialPropertyName: string;

package/dist/generators/ts/LazyObjectSetType.js

@@ -18,34 +18,24 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
         },
     });
     kind = "LazyObjectSetType";
-    get conversions() {
-        const conversions = super.conversions.concat();
-        if (this.partialType.itemType.kind === "NamedObjectType") {
-            conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(${this.partialType.itemType.name}.create), resolver: async () => ${this.reusables.imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: code `readonly ${this.resolveType.itemType.name}[]`,
-                sourceTypeof: "object",
-            });
-        }
-        else if (this.resolveType.itemType.kind === "NamedObjectUnionType" &&
-            this.partialType.itemType.kind === "NamedObjectUnionType" &&
-            this.resolveType.itemType.members.length ===
-                this.partialType.itemType.members.length) {
-            conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType.itemType, partialNamedObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} }), resolver: async () => ${this.reusables.imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: code `readonly ${this.resolveType.itemType.name}[]`,
-                sourceTypeof: "object",
-            });
-        }
-        conversions.push({
-            conversionExpression: () => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: [], resolver: async () => { throw new Error("should never be called"); } })`,
-            sourceTypeCheckExpression: (value) => code `${value} === undefined`,
-            sourceTypeName: code `undefined`,
-            sourceTypeof: "undefined",
+    get conversionFunction() {
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToLazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            sourceTypes: [
+                {
+                    name: this.name,
+                    typeof: "object",
+                },
+                {
+                    name: this.resolveType.name,
+                    typeof: "object",
+                },
+                {
+                    name: "undefined",
+                    typeof: "undefined",
+                },
+            ],
         });
-        return conversions;
     }
     get runtimeClass() {
         return {
@@ -55,7 +45,7 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
         };
     }
     fromJsonExpression(parameters) {
-        return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: () => Promise.resolve(${this.reusables.imports.Left}(new Error("unable to resolve identifiers deserialized from JSON"))) })`;
+        return code `${this.partialType.fromJsonExpression(parameters)}.map(partial => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: partial, resolver: () => Promise.resolve(${this.reusables.imports.Left}(new Error("unable to resolve identifiers deserialized from JSON"))) }))`;
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
@@ -67,5 +57,5 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
 }
 __decorate([
     Memoize()
-], LazyObjectSetType.prototype, "conversions", null);
+], LazyObjectSetType.prototype, "conversionFunction", null);
 //# sourceMappingURL=LazyObjectSetType.js.map

package/dist/generators/ts/LazyObjectType.d.ts

@@ -1,9 +1,10 @@
+import { Maybe } from "purify-ts";
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LazyObjectType extends AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint> {
     readonly graphqlArgs: Super["graphqlArgs"];
     readonly kind = "LazyObjectType";
-    get conversions(): readonly AbstractLazyObjectType.Conversion[];
+    get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
     protected get runtimeClass(): {
         name: Code;
         partialPropertyName: string;

package/dist/generators/ts/LazyObjectType.js

@@ -11,31 +11,20 @@ import { code } from "./ts-poet-wrapper.js";
 export class LazyObjectType extends AbstractLazyObjectType {
     graphqlArgs = Maybe.empty();
     kind = "LazyObjectType";
-    get conversions() {
-        const conversions = super.conversions.concat();
-        if (this.partialType.kind === "NamedObjectType") {
-            conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.name}.create(${value}), resolver: async () => ${this.reusables.imports.Right}(${value} as ${this.resolveType.name}) })`,
-                // Don't check instanceof value since the NamedObjectType may be an interface
-                // Rely on the fact that this will be the last type check on an object
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: this.resolveType.name,
-                sourceTypeof: "object",
-            });
-        }
-        else if (this.resolveType.kind === "NamedObjectUnionType" &&
-            this.partialType.kind === "NamedObjectUnionType" &&
-            this.resolveType.members.length === this.partialType.members.length) {
-            conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ((object: ${this.resolveType.name}) => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType, partialNamedObjectUnionType: this.partialType, variables: { resolvedObjectUnion: code `object` } })} })(${value}), resolver: async () => ${this.reusables.imports.Right}(${value} as ${this.resolveType.name}) })`,
-                // Don't check instanceof value since the NamedObjectUnionType may be an interface
-                // Rely on the fact that this will be the last type check on an object
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: this.resolveType.name,
-                sourceTypeof: "object",
-            });
-        }
-        return conversions;
+    get conversionFunction() {
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToLazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.name}, ${this.resolveType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,
+            sourceTypes: [
+                {
+                    name: this.name,
+                    typeof: "object",
+                },
+                {
+                    name: this.resolveType.name,
+                    typeof: "object",
+                },
+            ],
+        });
     }
     get runtimeClass() {
         return {
@@ -45,7 +34,7 @@ export class LazyObjectType extends AbstractLazyObjectType {
         };
     }
     fromJsonExpression(parameters) {
-        return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${this.reusables.imports.Left}(new Error(\`unable to resolve identifier \${identifier} deserialized from JSON\`))) })`;
+        return code `${this.partialType.fromJsonExpression(parameters)}.map(partial => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: partial, resolver: (identifier) => Promise.resolve(${this.reusables.imports.Left}(new Error(\`unable to resolve identifier \${identifier} deserialized from JSON\`))) }))`;
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
@@ -55,6 +44,9 @@ export class LazyObjectType extends AbstractLazyObjectType {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce())`;
     }
 }
+__decorate([
+    Memoize()
+], LazyObjectType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], LazyObjectType.prototype, "runtimeClass", null);

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

@@ -1,18 +1,21 @@
+import type { Literal } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LiteralType extends AbstractLiteralType {
+    readonly name: Code;
+    readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly kind = "LiteralType";
-    readonly name: Code;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     get graphqlType(): AbstractLiteralType.GraphqlType;
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
-    hashStatements({ depth, variables, }: Parameters<AbstractLiteralType["hashStatements"]>[0]): readonly Code[];
-    jsonType(parameters?: Parameters<AbstractLiteralType["jsonType"]>[0]): AbstractLiteralType.JsonType;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonSchema"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractLiteralType["jsonType"]>[0]): AbstractLiteralType.JsonType;
+    literalExpression(literal: Literal): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/generators/ts/LiteralType.js

@@ -1,28 +1,45 @@
 import { xsd } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class LiteralType extends AbstractLiteralType {
+    name = code `${this.reusables.imports.Literal}`;
+    conversionFunction = Maybe.of({
+        code: code `${this.reusables.snippets.convertToLiteral}`,
+        sourceTypes: [
+            ...["bigint", "boolean", "number", "string"].map((typeof_) => ({
+                name: typeof_,
+                typeof: typeof_,
+            })),
+            {
+                name: "Date",
+                typeof: "object",
+            },
+            {
+                name: code `${this.reusables.imports.Literal}`,
+                typeof: "object",
+            },
+        ],
+    });
     filterFunction = code `${this.reusables.snippets.filterLiteral}`;
     filterType = code `${this.reusables.snippets.LiteralFilter}`;
     kind = "LiteralType";
-    name = code `${this.reusables.imports.Literal}`;
     schemaType = code `${this.reusables.snippets.LiteralSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.literalSparqlWherePatterns}`;
     get graphqlType() {
         throw new Error("not implemented");
     }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined))`;
+        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined)))`;
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
     }
-    hashStatements({ depth, variables, }) {
-        return [
-            ...super.hashStatements({ depth, variables }),
-            code `${variables.hasher}.update(${variables.value}.datatype.value);`,
-            code `${variables.hasher}.update(${variables.value}.language);`,
-        ];
+    jsonSchema({ includeDiscriminantProperty, }) {
+        const discriminantProperty = includeDiscriminantProperty
+            ? code `, termType: ${this.reusables.imports.z}.literal("Literal")`
+            : "";
+        return code `${this.reusables.imports.z}.object({ "@language": ${this.reusables.imports.z}.string().optional()${discriminantProperty}, "@type": ${this.reusables.imports.z}.string().optional(), "@value": ${this.reusables.imports.z}.string() })`;
     }
     jsonType(parameters) {
         const discriminantProperty = parameters?.includeDiscriminantProperty
@@ -30,11 +47,8 @@ export class LiteralType extends AbstractLiteralType {
             : "";
         return new AbstractLiteralType.JsonType(code `{ readonly "@language"?: string${discriminantProperty}, readonly "@type"?: string, readonly "@value": string }`);
     }
-    jsonSchema({ includeDiscriminantProperty, }) {
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${this.reusables.imports.z}.literal("Literal")`
-            : "";
-        return code `${this.reusables.imports.z}.object({ "@language": ${this.reusables.imports.z}.string().optional()${discriminantProperty}, "@type": ${this.reusables.imports.z}.string().optional(), "@value": ${this.reusables.imports.z}.string() })`;
+    literalExpression(literal) {
+        return this.rdfjsTermExpression(literal);
     }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         return code `{ "@language": ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined${includeDiscriminantProperty ? `, "termType": "Literal" as const` : ""}, "@type": ${variables.value}.datatype.value !== "${xsd.string.value}" ? ${variables.value}.datatype.value : undefined, "@value": ${variables.value}.value }`;

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

@@ -1,5 +1,5 @@
 import type { NamedNode } from "@rdfjs/types";
-import { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
 import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
 import type { Property as _Property } from "./_NamedObjectType/Property.js";
@@ -8,13 +8,12 @@ import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
-import type { TsFeature } from "./TsFeature.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class NamedObjectType extends AbstractType {
     protected readonly toRdfTypes: readonly NamedNode[];
+    readonly conversionFunction: Maybe<AbstractType.ConversionFunction>;
     readonly extern: boolean;
-    readonly features: ReadonlySet<TsFeature>;
     readonly fromRdfType: Maybe<NamedNode>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
@@ -22,11 +21,11 @@ export declare class NamedObjectType extends AbstractType {
     readonly name: string;
     readonly recursive: boolean;
     readonly synthetic: boolean;
-    readonly typeofs: NonEmptyList<"object">;
-    constructor({ extern, features, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }: {
+    readonly typeofs: "object"[];
+    readonly validationFunction: Maybe<Code>;
+    constructor({ extern, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }: {
         comment: Maybe<string>;
         extern: boolean;
-        features: ReadonlySet<TsFeature>;
         fromRdfType: Maybe<NamedNode>;
         identifierType: BlankNodeType | IdentifierType | IriType;
         label: Maybe<string>;
@@ -44,7 +43,6 @@ export declare class NamedObjectType extends AbstractType {
     get _discriminantProperty(): NamedObjectType.DiscriminantProperty;
     get ancestorObjectTypes(): readonly NamedObjectType[];
     get childObjectTypes(): readonly NamedObjectType[];
-    get conversions(): readonly AbstractType.Conversion[];
     get declaration(): Maybe<Code>;
     get descendantFromRdfTypeVariables(): readonly Code[];
     get descendantFromRdfTypes(): readonly NamedNode[];
@@ -56,6 +54,7 @@ export declare class NamedObjectType extends AbstractType {
     get filterType(): Code;
     get fromRdfTypeVariable(): Maybe<Code>;
     get graphqlType(): AbstractType.GraphqlType;
+    get hashFunction(): Code;
     get identifierTypeAlias(): Code;
     get mutable(): boolean;
     get objectSetMethodNames(): NamedObjectType.ObjectSetMethodNames;
@@ -75,13 +74,12 @@ export declare class NamedObjectType extends AbstractType {
             value: Code;
         };
     }): Code;
-    hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     jsonType(): AbstractType.JsonType;
     jsonUiSchemaElement({ variables, }: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
     private readonly lazyAncestorObjectTypes;
     private readonly lazyChildObjectTypes;
     private readonly lazyDescendantObjectTypes;

package/dist/generators/ts/NamedObjectType.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { NodeKind } from "@shaclmate/shacl-ast";
 import { camelCase } from "change-case";
-import { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
 import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
@@ -40,12 +40,11 @@ import { NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration } from "
 import { NamedObjectType_valueSparqlWherePatternsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js";
 import { ShaclProperty as _ShaclProperty } from "./_NamedObjectType/ShaclProperty.js";
 import { AbstractType } from "./AbstractType.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, def, joinCode } from "./ts-poet-wrapper.js";
 export class NamedObjectType extends AbstractType {
     toRdfTypes;
+    conversionFunction = Maybe.empty();
     extern;
-    features;
     fromRdfType;
     graphqlArgs = Maybe.empty();
     identifierType;
@@ -53,11 +52,11 @@ export class NamedObjectType extends AbstractType {
     name;
     recursive;
     synthetic;
-    typeofs = NonEmptyList(["object"]);
-    constructor({ extern, features, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }) {
+    typeofs = ["object"];
+    validationFunction = Maybe.empty();
+    constructor({ extern, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.extern = extern;
-        this.features = features;
         this.fromRdfType = fromRdfType;
         this.identifierType = identifierType;
         // Lazily initialize some members in getters to avoid recursive construction
@@ -81,22 +80,12 @@ export class NamedObjectType extends AbstractType {
     get childObjectTypes() {
         return this.lazyChildObjectTypes();
     }
-    get conversions() {
-        return [
-            {
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: this.name,
-                sourceTypeof: "object",
-            },
-        ];
-    }
     get declaration() {
         const declarations = [];
         if (!this.extern) {
             const staticModuleDeclarations = [];
             declarations.push(NamedObjectType_interfaceDeclaration.call(this));
-            staticModuleDeclarations.push(...NamedObjectType_createFunctionDeclaration.call(this).toList(), ...NamedObjectType_equalsFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_hashFunctionDeclarations.call(this));
+            staticModuleDeclarations.push(...NamedObjectType_createFunctionDeclaration.call(this).toList(), ...NamedObjectType_equalsFunctionDeclaration.call(this).toList(), ...NamedObjectType_hashFunctionDeclarations.call(this));
             const jsonModuleDeclarations = [
                 ...NamedObjectType_jsonParseFunctionDeclaration.call(this).toList(),
                 ...NamedObjectType_jsonSchemaFunctionDeclaration.call(this).toList(),
@@ -106,17 +95,17 @@ export class NamedObjectType extends AbstractType {
                 ? [
                     code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`,
                 ]
-                : []), NamedObjectType_filterFunctionDeclaration.call(this), NamedObjectType_filterTypeDeclaration.call(this), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), NamedObjectType_isTypeFunctionDeclaration.call(this), NamedObjectType_schemaVariableStatement.call(this), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.bind({
-                features: this.features,
+                : []), NamedObjectType_filterFunctionDeclaration.call(this), NamedObjectType_filterTypeDeclaration.call(this), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), NamedObjectType_isTypeFunctionDeclaration.call(this), NamedObjectType_schemaVariableStatement.call(this), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call({
+                configuration: this.configuration,
                 filterType: this.filterType,
                 name: this.name,
                 reusables: this.reusables,
-            })().toList(), ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.bind({
-                features: this.features,
+            }).toList(), ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
+                configuration: this.configuration,
                 filterType: this.filterType,
                 name: this.name,
                 reusables: this.reusables,
-            })().toList(), ...NamedObjectType_toJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_toRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_toStringFunctionDeclarations.call(this), ...NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.bind(this)().toList());
+            }).toList(), ...NamedObjectType_toJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_toRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_toStringFunctionDeclarations.call(this), ...NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.call(this).toList());
             if (staticModuleDeclarations.length > 0) {
                 declarations.push(code `\
 export namespace ${def(this.name)} {
@@ -161,6 +150,9 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     get graphqlType() {
         return new AbstractType.GraphqlType(code `${this.name}.GraphQL`, this.reusables);
     }
+    get hashFunction() {
+        return code `${this.name}.hash`;
+    }
     get identifierTypeAlias() {
         return code `${this.name}.Identifier`;
     }
@@ -168,7 +160,10 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return this.properties.some((property) => property.mutable);
     }
     get objectSetMethodNames() {
-        return NamedObjectType_objectSetMethodNames.call(this);
+        return NamedObjectType_objectSetMethodNames.call({
+            configuration: this.configuration,
+            name: this.name,
+        });
     }
     get parentObjectTypes() {
         return this.lazyParentObjectTypes();
@@ -218,9 +213,6 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
-    hashStatements({ variables, }) {
-        return [code `${this.name}.hash(${variables.value}, ${variables.hasher});`];
-    }
     jsonSchema({ context, }) {
         let expression = code `${this.name}.Json.schema()`;
         if (context === "property" &&
@@ -238,12 +230,12 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     toJsonExpression({ variables, }) {
         return code `${this.name}.toJson(${variables.value})`;
     }
-    toStringExpression({ variables, }) {
-        return code `${this.name}.${syntheticNamePrefix}toString(${variables.value})`;
-    }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.name}.toRdfResource(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
     }
+    toStringExpression({ variables, }) {
+        return code `${this.name}.${this.configuration.syntheticNamePrefix}toString(${variables.value})`;
+    }
     lazyAncestorObjectTypes;
     lazyChildObjectTypes;
     lazyDescendantObjectTypes;
@@ -260,9 +252,6 @@ __decorate([
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "childObjectTypes", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "conversions", null);
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "descendantFromRdfTypeVariables", null);
@@ -293,6 +282,9 @@ __decorate([
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "identifierTypeAlias", null);

package/dist/generators/ts/NamedObjectUnionType.d.ts

@@ -9,8 +9,10 @@ export declare class NamedObjectUnionType extends AbstractNamedUnionType<NamedOb
     #private;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly kind = "NamedObjectUnionType";
-    constructor({ identifierType, ...superParameters }: {
+    readonly synthetic: boolean;
+    constructor({ identifierType, synthetic, ...superParameters }: {
         identifierType: BlankNodeType | IdentifierType | IriType;
+        synthetic: boolean;
     } & Omit<ConstructorParameters<typeof AbstractNamedUnionType<NamedObjectType>>[0], "identifierType">);
     get graphqlType(): AbstractType.GraphqlType;
     get identifierTypeAlias(): Code;

package/dist/generators/ts/NamedObjectUnionType.js

@@ -14,15 +14,16 @@ import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from ".
 import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
 import { AbstractType } from "./AbstractType.js";
 import { singleEntryRecord } from "./singleEntryRecord.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class NamedObjectUnionType extends AbstractNamedUnionType {
     #identifierType;
     graphqlArgs = Maybe.empty();
     kind = "NamedObjectUnionType";
-    constructor({ identifierType, ...superParameters }) {
+    synthetic;
+    constructor({ identifierType, synthetic, ...superParameters }) {
         super({ ...superParameters, identifierType: Maybe.of(identifierType) });
         this.#identifierType = identifierType;
+        this.synthetic = synthetic;
     }
     get graphqlType() {
         return new AbstractType.GraphqlType(code `${this._name}.GraphQL`, this.reusables);
@@ -31,7 +32,10 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         return code `${this.name}.Identifier`;
     }
     get objectSetMethodNames() {
-        return NamedObjectType_objectSetMethodNames.call(this);
+        return NamedObjectType_objectSetMethodNames.call({
+            configuration: this.configuration,
+            name: this.name,
+        });
     }
     get schema() {
         return code `${this.name}.schema`;
@@ -50,7 +54,7 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
             ...this.isTypeFunctionDeclaration,
             ...this.schemaVariableStatement,
             ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call({
-                features: this.features,
+                configuration: this.configuration,
                 filterType: this.filterType,
                 name: this.name,
                 reusables: this.reusables,
@@ -58,7 +62,7 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
                 .map((code_) => singleEntryRecord(`sparqlConstructQuery`, code_))
                 .orDefault({}),
             ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
-                features: this.features,
+                configuration: this.configuration,
                 filterType: this.filterType,
                 name: this.name,
                 reusables: this.reusables,
@@ -69,7 +73,7 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         };
     }
     get focusSparqlConstructTriplesFunctionDeclaration() {
-        if (!this.features.has("sparql")) {
+        if (!this.configuration.features.has("sparql")) {
             return {};
         }
         return singleEntryRecord(`focusSparqlConstructTriples`, code `\
@@ -78,7 +82,7 @@ export function focusSparqlConstructTriples({ filter, focusIdentifier, variableP
 }`);
     }
     get focusSparqlWherePatternsFunctionDeclaration() {
-        if (!this.features.has("sparql")) {
+        if (!this.configuration.features.has("sparql")) {
             return {};
         }
         return singleEntryRecord(`focusSparqlWherePatterns`, code `\
@@ -88,7 +92,7 @@ ${joinCode([
             code `\
 if (focusIdentifier.termType === "Variable") {
   patterns = patterns.concat(${this.#identifierType.valueSparqlWherePatternsFunction}({
-      filter: filter?.${syntheticNamePrefix}identifier,
+      filter: filter?.${this.configuration.syntheticNamePrefix}identifier,
       ignoreRdfType: false,
       preferredLanguages,
       propertyPatterns: [],
@@ -106,7 +110,7 @@ if (focusIdentifier.termType === "Variable") {
 }`);
     }
     get fromRdfResourceFunctionDeclaration() {
-        if (!this.features.has("rdf")) {
+        if (!this.configuration.features.has("rdf")) {
             return {};
         }
         return singleEntryRecord(`fromRdfResource`, code `\
@@ -119,14 +123,17 @@ export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}
         }, null)};`);
     }
     get graphqlTypeVariableStatement() {
-        if (!this.features.has("graphql")) {
+        if (!this.configuration.features.has("graphql")) {
+            return {};
+        }
+        if (this.synthetic) {
             return {};
         }
         return singleEntryRecord(`GraphQL`, code `\
 export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
             description: this.comment.map(JSON.stringify).extract(),
             name: this.name,
-            resolveType: code `(value: ${this.name}) => value.${syntheticNamePrefix}type`,
+            resolveType: code `(value: ${this.name}) => value.${this.configuration.syntheticNamePrefix}type`,
             types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableName), { on: ", " })}]`,
         }});`);
     }
@@ -139,11 +146,11 @@ export namespace Identifier {
 }`);
     }
     get isTypeFunctionDeclaration() {
-        if (this._name === `${syntheticNamePrefix}Object`) {
+        if (this._name === `${this.configuration.syntheticNamePrefix}Object`) {
             return {};
         }
         return singleEntryRecord(`is${this._name}`, code `\
-    export function is${this._name}(object: ${syntheticNamePrefix}Object): object is ${this.name} {
+    export function is${this._name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${this.name} {
       return ${joinCode(this.members.map((member) => code `${member.type.name}.is${member.type.name}(object)`), { on: " || " })};
     }`);
     }
@@ -185,7 +192,7 @@ ${{
         }} as const;`);
     }
     get toRdfResourceFunctionDeclaration() {
-        if (!this.features.has("rdf")) {
+        if (!this.configuration.features.has("rdf")) {
             return {};
         }
         return singleEntryRecord(`toRdfResource`, code `\