@shaclmate/compiler 4.0.34 → 4.0.36

package/dist/generators/ts/BigDecimalType.js

@@ -4,20 +4,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 export class BigDecimalType extends AbstractLiteralType {
     name = code `${this.reusables.imports.BigDecimal}`;
-    conversionFunction = {
-        code: code `${this.reusables.snippets.convertToBigDecimal}`,
-        sourceTypes: [
-            {
-                name: code `${this.reusables.imports.BigDecimal}`,
-                typeof: "object",
-            },
-        ],
-    };
+    conversionFunction = Maybe.empty();
     filterFunction = code `${this.reusables.snippets.filterBigDecimal}`;
     filterType = code `${this.reusables.snippets.NumericFilter}<${this.reusables.imports.BigDecimal}>`;
     hashFunction = code `${this.reusables.snippets.hashBigDecimal}`;
@@ -28,7 +21,7 @@ export class BigDecimalType extends AbstractLiteralType {
         return new AbstractLiteralType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
     }
     fromJsonExpression({ variables, }) {
-        return code `new ${this.reusables.imports.BigDecimal}(${variables.value})`;
+        return code `${this.reusables.imports.Either}.encase<Error, ${this.name}>(() => new ${this.name}(${variables.value}))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.toFixed()`;
@@ -48,9 +41,9 @@ export class BigDecimalType extends AbstractLiteralType {
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.bigDecimalLiteral}(${variables.value})]`;
     }
-    fromRdfExpressionChain({ variables, }) {
+    fromRdfResourceValuesExpressionChain({ variables, }) {
         return {
-            ...super.fromRdfExpressionChain({ variables }),
+            ...super.fromRdfResourceValuesExpressionChain({ variables }),
             valueTo: code `chain(values => values.chainMap(value => value.toLiteral().chain(${this.reusables.snippets.decodeBigDecimalLiteral})))`,
         };
     }

package/dist/generators/ts/BigIntType.js

@@ -19,7 +19,7 @@ export class BigIntType extends AbstractNumericType {
         if (this.primitiveIn.length > 0) {
             expression = code `${expression} as ${this.name}`;
         }
-        return expression;
+        return code `${this.reusables.imports.Either}.encase<Error, ${this.name}>(() => ${expression})`;
     }
     jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {

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

@@ -1,8 +1,9 @@
 import type { BlankNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
-    readonly conversionFunction: AbstractIdentifierType.ConversionFunction;
+    readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly parseFunction: Code;
@@ -16,7 +17,7 @@ export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
     jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode>["jsonSchema"]>[0]): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<BlankNode>["toJsonExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractIdentifierType<BlankNode>["fromRdfExpressionChain"]>[0]): {
+    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractIdentifierType<BlankNode>["fromRdfResourceValuesExpressionChain"]>[0]): {
         valueTo: Code;
         hasValues?: Code;
         languageIn?: Code;

package/dist/generators/ts/BlankNodeType.js

@@ -4,11 +4,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BlankNodeType extends AbstractIdentifierType {
-    conversionFunction = {
+    conversionFunction = Maybe.of({
         code: code `${this.reusables.snippets.convertToBlankNode}`,
         sourceTypes: [
             {
@@ -20,7 +21,7 @@ export class BlankNodeType extends AbstractIdentifierType {
                 typeof: "undefined",
             },
         ],
-    };
+    });
     filterFunction = code `${this.reusables.snippets.filterBlankNode}`;
     filterType = code `${this.reusables.snippets.BlankNodeFilter}`;
     parseFunction = code `${this.reusables.snippets.parseBlankNode};`;
@@ -37,7 +38,7 @@ export class BlankNodeType extends AbstractIdentifierType {
         });
     }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2))`;
+        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)))`;
     }
     jsonType(parameters) {
         const discriminantProperty = parameters?.includeDiscriminantProperty
@@ -57,9 +58,9 @@ export class BlankNodeType extends AbstractIdentifierType {
             : "";
         return code `{ "@id": \`_:\${${variables.value}.value}\`${discriminantProperty} }`;
     }
-    fromRdfExpressionChain({ variables, }) {
+    fromRdfResourceValuesExpressionChain({ variables, }) {
         return {
-            ...super.fromRdfExpressionChain({ variables }),
+            ...super.fromRdfResourceValuesExpressionChain({ variables }),
             valueTo: code `chain(values => values.chainMap(value => value.toBlankNode()))`,
         };
     }

package/dist/generators/ts/BooleanType.d.ts

@@ -10,11 +10,10 @@ export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     readonly schemaType: Code;
     readonly typeofs: "boolean"[];
     readonly valueSparqlWherePatternsFunction: Code;
-    get conversionFunction(): AbstractPrimitiveType.ConversionFunction;
     get name(): string;
     jsonSchema(_parameters: Parameters<AbstractPrimitiveType<number>["jsonSchema"]>[0]): Code;
     literalExpression(literal: boolean | Literal): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfResourceValuesExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<boolean>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<boolean>["fromRdfExpressionChain"]>;
+    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<boolean>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<boolean>["fromRdfResourceValuesExpressionChain"]>;
 }
 //# sourceMappingURL=BooleanType.d.ts.map

package/dist/generators/ts/BooleanType.js

@@ -17,17 +17,6 @@ export class BooleanType extends AbstractPrimitiveType {
     schemaType = code `${this.reusables.snippets.BooleanSchema}`;
     typeofs = ["boolean"];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.booleanSparqlWherePatterns}`;
-    get conversionFunction() {
-        return {
-            code: code `${this.reusables.snippets.convertToBoolean}<${this.name}>`,
-            sourceTypes: [
-                {
-                    name: this.name,
-                    typeof: "boolean",
-                },
-            ],
-        };
-    }
     get name() {
         if (this.primitiveIn.length > 0) {
             return `${this.primitiveIn.map((value) => value.toString()).join(" | ")}`;
@@ -46,18 +35,15 @@ export class BooleanType extends AbstractPrimitiveType {
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.boolean(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
-    fromRdfExpressionChain({ variables, }) {
+    fromRdfResourceValuesExpressionChain({ variables, }) {
         return {
-            ...super.fromRdfExpressionChain({ variables }),
+            ...super.fromRdfResourceValuesExpressionChain({ variables }),
             languageIn: undefined,
             preferredLanguages: undefined,
             valueTo: code `chain(values => values.chainMap(value => value.toBoolean(${this.primitiveIn.length === 1 ? `[${this.primitiveIn[0]}] as const` : ""})))`,
         };
     }
 }
-__decorate([
-    Memoize()
-], BooleanType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], BooleanType.prototype, "name", null);

package/dist/generators/ts/DateTimeType.d.ts

@@ -2,7 +2,6 @@ import type { Literal } from "@rdfjs/types";
 import { AbstractDateType } from "./AbstractDateType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateTimeType extends AbstractDateType {
-    readonly conversionFunction: AbstractDateType.ConversionFunction;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
     readonly kind = "DateTimeType";

package/dist/generators/ts/DateTimeType.js

@@ -2,15 +2,6 @@ import { LiteralDecoder } from "@rdfx/literal";
 import { AbstractDateType } from "./AbstractDateType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class DateTimeType extends AbstractDateType {
-    conversionFunction = {
-        code: code `${this.reusables.snippets.convertToDateTime}`,
-        sourceTypes: [
-            {
-                name: "Date",
-                typeof: "object",
-            },
-        ],
-    };
     graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDateTime}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashDateTime}`;
     kind = "DateTimeType";

package/dist/generators/ts/DateType.d.ts

@@ -3,7 +3,6 @@ import { AbstractDateType } from "./AbstractDateType.js";
 import { DateTimeType } from "./DateTimeType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateType extends AbstractDateType {
-    readonly conversionFunction: AbstractDateType.ConversionFunction;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
     readonly kind = "DateType";

package/dist/generators/ts/DateType.js

@@ -3,15 +3,6 @@ import { AbstractDateType } from "./AbstractDateType.js";
 import { DateTimeType } from "./DateTimeType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class DateType extends AbstractDateType {
-    conversionFunction = {
-        code: code `${this.reusables.snippets.convertToDate}`,
-        sourceTypes: [
-            {
-                name: "Date",
-                typeof: "object",
-            },
-        ],
-    };
     graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDate}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashDate}`;
     kind = "DateType";

package/dist/generators/ts/DefaultValueType.d.ts

@@ -11,10 +11,11 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly kind = "DefaultValueType";
     readonly typeofs: "object"[];
+    readonly validationFunction: Maybe<Code>;
     constructor({ defaultValue, ...superParameters }: {
         defaultValue: Literal | NamedNode;
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
-    get conversionFunction(): AbstractContainerType.ConversionFunction;
+    get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
     get equalsFunction(): Code;
     get filterFunction(): Code;
     get filterType(): Code;

package/dist/generators/ts/DefaultValueType.js

@@ -15,21 +15,22 @@ export class DefaultValueType extends AbstractContainerType {
     graphqlArgs = Maybe.empty();
     kind = "DefaultValueType";
     typeofs = ["object"];
+    validationFunction = this.itemType.validationFunction;
     constructor({ defaultValue, ...superParameters }) {
         super(superParameters);
         this.defaultValue = defaultValue;
     }
     get conversionFunction() {
-        const itemConversionFunction = this.itemType.conversionFunction;
-        return {
-            code: code `${this.reusables.snippets.convertWithDefaultValue}(${itemConversionFunction.code})`,
+        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertWithDefaultValue}(${itemConversionFunction.code}, ${this.defaultValueExpression})`,
             sourceTypes: itemConversionFunction.sourceTypes
                 .filter((sourceType) => sourceType.typeof !== "undefined")
                 .concat({
                 name: "undefined",
                 typeof: "undefined",
             }),
-        };
+        });
     }
     get equalsFunction() {
         return this.itemType.equalsFunction;

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

@@ -1,9 +1,10 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { type IdentifierNodeKind } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IdentifierType extends AbstractIdentifierType<BlankNode | NamedNode> {
-    readonly conversionFunction: AbstractIdentifierType.ConversionFunction;
+    readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly parseFunction: Code;
@@ -17,6 +18,6 @@ export declare class IdentifierType extends AbstractIdentifierType<BlankNode | N
     jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractIdentifierType<BlankNode | NamedNode>["fromRdfExpressionChain"]>;
+    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractIdentifierType<BlankNode | NamedNode>["fromRdfResourceValuesExpressionChain"]>;
 }
 //# sourceMappingURL=IdentifierType.d.ts.map

package/dist/generators/ts/IdentifierType.js

@@ -5,11 +5,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { NodeKind } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class IdentifierType extends AbstractIdentifierType {
-    conversionFunction = {
+    conversionFunction = Maybe.of({
         code: code `${this.reusables.snippets.convertToIdentifier}`,
         sourceTypes: [
             {
@@ -29,7 +30,7 @@ export class IdentifierType extends AbstractIdentifierType {
                 typeof: "undefined",
             },
         ],
-    };
+    });
     filterFunction = code `${this.reusables.snippets.filterIdentifier}`;
     filterType = code `${this.reusables.snippets.IdentifierFilter}`;
     parseFunction = code `${this.reusables.snippets.parseIdentifier};`;
@@ -46,7 +47,7 @@ export class IdentifierType extends AbstractIdentifierType {
         });
     }
     fromJsonExpression({ variables, }) {
-        return code `(${variables.value}["@id"].startsWith("_:") ? ${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)) : ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
+        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>((${variables.value}["@id"].startsWith("_:") ? ${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)) : ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"])))`;
     }
     jsonType(parameters) {
         const discriminantProperty = parameters?.includeDiscriminantProperty
@@ -68,9 +69,9 @@ export class IdentifierType extends AbstractIdentifierType {
         const valueToNamedNode = code `{ "@id": ${variables.value}.value${discriminantProperty} }`;
         return code `(${variables.value}.termType === "BlankNode" ? ${valueToBlankNode} : ${valueToNamedNode})`;
     }
-    fromRdfExpressionChain({ variables, }) {
+    fromRdfResourceValuesExpressionChain({ variables, }) {
         return {
-            ...super.fromRdfExpressionChain({ variables }),
+            ...super.fromRdfResourceValuesExpressionChain({ variables }),
             valueTo: code `chain(values => values.chainMap(value => value.toIdentifier()))`,
         };
     }

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

@@ -1,4 +1,5 @@
 import type { NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IriType extends AbstractIdentifierType<NamedNode> {
@@ -8,22 +9,13 @@ export declare class IriType extends AbstractIdentifierType<NamedNode> {
     readonly nodeKinds: ReadonlySet<"IRI">;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
-    get conversionFunction(): {
-        code: Code;
-        sourceTypes: ({
-            name: Code;
-            typeof: "string";
-        } | {
-            name: Code;
-            typeof: "object";
-        })[];
-    };
+    get conversionFunction(): Maybe<AbstractIdentifierType.ConversionFunction>;
     get name(): Code;
     get parseFunction(): Code;
     fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<NamedNode>["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractIdentifierType<NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<NamedNode>["toJsonExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractIdentifierType<NamedNode>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractIdentifierType<NamedNode>["fromRdfExpressionChain"]>;
+    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractIdentifierType<NamedNode>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractIdentifierType<NamedNode>["fromRdfResourceValuesExpressionChain"]>;
 }
 //# sourceMappingURL=IriType.d.ts.map

package/dist/generators/ts/IriType.js

@@ -4,6 +4,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { arrayOf, code, joinCode, literalOf, } from "./ts-poet-wrapper.js";
@@ -18,7 +19,7 @@ export class IriType extends AbstractIdentifierType {
         const IriT = this.in_.length > 0
             ? code `${joinCode(this.in_.map((iri) => code `${literalOf(iri.value)}`), { on: "| " })}`
             : code `string`;
-        return {
+        return Maybe.of({
             code: code `${this.reusables.snippets.convertToIri}<${IriT}>`,
             sourceTypes: [
                 {
@@ -30,7 +31,7 @@ export class IriType extends AbstractIdentifierType {
                     typeof: "object",
                 },
             ],
-        };
+        });
     }
     get name() {
         if (this.in_.length > 0) {
@@ -47,7 +48,7 @@ export class IriType extends AbstractIdentifierType {
         return code `${this.reusables.snippets.parseIri}`;
     }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"])`;
+        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         let idSchema;
@@ -81,9 +82,9 @@ export class IriType extends AbstractIdentifierType {
             : "";
         return code `{ "@id": ${variables.value}.value${discriminantProperty} }`;
     }
-    fromRdfExpressionChain({ variables, }) {
+    fromRdfResourceValuesExpressionChain({ variables, }) {
         return {
-            ...super.fromRdfExpressionChain({ variables }),
+            ...super.fromRdfResourceValuesExpressionChain({ variables }),
             valueTo: code `chain(values => values.chainMap(value => value.toIri(${this.in_.length > 0
                 ? code `[${joinCode(this.in_.map((in_) => this.rdfjsTermExpression(in_)), { on: ", " })}]`
                 : ""})))`,

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

@@ -19,7 +19,7 @@ declare const Super: (abstract new ({ partialType, resolveType, ...superParamete
 export declare class LazyObjectOptionType extends Super {
     readonly graphqlArgs: Super["graphqlArgs"];
     readonly kind = "LazyObjectOptionType";
-    get conversionFunction(): AbstractLazyObjectType.ConversionFunction;
+    get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
     protected get runtimeClass(): {
         name: Code;
         partialPropertyName: string;

package/dist/generators/ts/LazyObjectOptionType.js

@@ -13,7 +13,7 @@ export class LazyObjectOptionType extends Super {
     graphqlArgs = Maybe.empty();
     kind = "LazyObjectOptionType";
     get conversionFunction() {
-        return {
+        return Maybe.of({
             code: code `${this.reusables.snippets.convertToLazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
             sourceTypes: [
                 {
@@ -33,7 +33,7 @@ export class LazyObjectOptionType extends Super {
                     typeof: "undefined",
                 },
             ],
-        };
+        });
     }
     get runtimeClass() {
         return {
@@ -43,7 +43,7 @@ export class LazyObjectOptionType extends Super {
         };
     }
     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;

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 conversionFunction(): AbstractLazyObjectType.ConversionFunction;
+    get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
     protected get runtimeClass(): {
         name: Code;
         partialPropertyName: string;

package/dist/generators/ts/LazyObjectSetType.js

@@ -19,7 +19,7 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
     });
     kind = "LazyObjectSetType";
     get conversionFunction() {
-        return {
+        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: [
                 {
@@ -35,7 +35,7 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
                     typeof: "undefined",
                 },
             ],
-        };
+        });
     }
     get runtimeClass() {
         return {
@@ -45,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;

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 conversionFunction(): AbstractLazyObjectType.ConversionFunction;
+    get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
     protected get runtimeClass(): {
         name: Code;
         partialPropertyName: string;

package/dist/generators/ts/LazyObjectType.js

@@ -12,7 +12,7 @@ export class LazyObjectType extends AbstractLazyObjectType {
     graphqlArgs = Maybe.empty();
     kind = "LazyObjectType";
     get conversionFunction() {
-        return {
+        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: [
                 {
@@ -24,7 +24,7 @@ export class LazyObjectType extends AbstractLazyObjectType {
                     typeof: "object",
                 },
             ],
-        };
+        });
     }
     get runtimeClass() {
         return {
@@ -34,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;

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

@@ -1,9 +1,10 @@
 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: AbstractLiteralType.ConversionFunction;
+    readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly kind = "LiteralType";

package/dist/generators/ts/LiteralType.js

@@ -1,9 +1,10 @@
 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 = {
+    conversionFunction = Maybe.of({
         code: code `${this.reusables.snippets.convertToLiteral}`,
         sourceTypes: [
             ...["bigint", "boolean", "number", "string"].map((typeof_) => ({
@@ -19,7 +20,7 @@ export class LiteralType extends AbstractLiteralType {
                 typeof: "object",
             },
         ],
-    };
+    });
     filterFunction = code `${this.reusables.snippets.filterLiteral}`;
     filterType = code `${this.reusables.snippets.LiteralFilter}`;
     kind = "LiteralType";
@@ -29,7 +30,7 @@ export class LiteralType extends AbstractLiteralType {
         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");

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

@@ -12,6 +12,7 @@ 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 fromRdfType: Maybe<NamedNode>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
@@ -21,6 +22,7 @@ export declare class NamedObjectType extends AbstractType {
     readonly recursive: boolean;
     readonly synthetic: boolean;
     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;
@@ -41,7 +43,6 @@ export declare class NamedObjectType extends AbstractType {
     get _discriminantProperty(): NamedObjectType.DiscriminantProperty;
     get ancestorObjectTypes(): readonly NamedObjectType[];
     get childObjectTypes(): readonly NamedObjectType[];
-    get conversionFunction(): AbstractType.ConversionFunction;
     get declaration(): Maybe<Code>;
     get descendantFromRdfTypeVariables(): readonly Code[];
     get descendantFromRdfTypes(): readonly NamedNode[];