@shaclmate/compiler 4.0.34 → 4.0.36

package/dist/generators/ts/AbstractCollectionType.d.ts

@@ -15,7 +15,7 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
         minCount: bigint;
         mutable: boolean;
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
-    get conversionFunction(): AbstractType.ConversionFunction;
+    get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
     get equalsFunction(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
@@ -24,6 +24,7 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
     get mutable(): boolean;
     get name(): Code;
     get schemaType(): Code;
+    get validationFunction(): Maybe<Code>;
     protected get schemaObject(): {
         minCount: number | undefined;
         item: Code;

package/dist/generators/ts/AbstractCollectionType.js

@@ -8,8 +8,7 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
-import { codeEquals } from "./codeEquals.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for ListType and SetType.
  */
@@ -29,7 +28,7 @@ export class AbstractCollectionType extends AbstractContainerType {
         }
     }
     get conversionFunction() {
-        const itemConversionFunction = this.itemType.conversionFunction;
+        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
         const sourceTypes = [
             {
                 name: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.name}`), { on: " | " })})[]`,
@@ -42,10 +41,10 @@ export class AbstractCollectionType extends AbstractContainerType {
                 typeof: "undefined",
             });
         }
-        return {
-            code: code `${this._mutable ? this.reusables.snippets.convertToMutableArray : this.reusables.snippets.convertToReadonlyArray}(${itemConversionFunction.code})`,
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToArray}(${itemConversionFunction.code}, ${literalOf(!this._mutable)})`,
             sourceTypes,
-        };
+        });
     }
     get equalsFunction() {
         return code `((left, right) => ${this.reusables.snippets.arrayEquals}(left, right, ${this.itemType.equalsFunction}))`;
@@ -71,6 +70,9 @@ export class AbstractCollectionType extends AbstractContainerType {
     get schemaType() {
         return code `${this.reusables.snippets.CollectionSchema}<${this.itemType.schemaType}>`;
     }
+    get validationFunction() {
+        return Maybe.of(code `${this.reusables.snippets.validateArray}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)}, ${literalOf(!this._mutable)})`);
+    }
     get schemaObject() {
         return {
             ...super.schemaObject,
@@ -82,13 +84,9 @@ export class AbstractCollectionType extends AbstractContainerType {
         if (this.minCount === 0n) {
             expression = code `(${expression} ?? [])`;
         }
-        const valueVariable = code `item`;
-        const itemFromJsonExpression = this.itemType.fromJsonExpression({
-            variables: { value: valueVariable },
-        });
-        return codeEquals(itemFromJsonExpression, valueVariable)
-            ? expression
-            : code `${expression}.map(item => (${itemFromJsonExpression}))`;
+        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.name}>(${expression}.map(item => (${this.itemType.fromJsonExpression({
+            variables: { value: code `item` },
+        })})))`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
@@ -137,6 +135,9 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "validationFunction", null);
 (function (AbstractCollectionType) {
     AbstractCollectionType.GraphqlType = AbstractContainerType.GraphqlType;
     AbstractCollectionType.isItemType = AbstractContainerType.isItemType;

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -38,6 +38,8 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     get recursive(): boolean;
     get schema(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
+    protected get itemConversionFunctionDefault(): AbstractType.ConversionFunction;
+    protected get itemValidationFunctionDefault(): Code;
     protected get schemaObject(): {
         item: Code;
         kind: Code;

package/dist/generators/ts/AbstractContainerType.js

@@ -33,6 +33,20 @@ export class AbstractContainerType extends AbstractType {
     get toRdfResourceValueTypes() {
         return this.itemType.toRdfResourceValueTypes;
     }
+    get itemConversionFunctionDefault() {
+        return {
+            code: code `${this.reusables.snippets.identityConversionFunction}`,
+            sourceTypes: [
+                {
+                    name: this.itemType.name,
+                    typeof: this.itemType.typeofs[0],
+                },
+            ],
+        };
+    }
+    get itemValidationFunctionDefault() {
+        return code `${this.reusables.snippets.identityValidationFunction}`;
+    }
     get schemaObject() {
         return {
             ...super.schemaObject,
@@ -43,6 +57,12 @@ export class AbstractContainerType extends AbstractType {
 __decorate([
     Memoize()
 ], AbstractContainerType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], AbstractContainerType.prototype, "itemConversionFunctionDefault", null);
+__decorate([
+    Memoize()
+], AbstractContainerType.prototype, "itemValidationFunctionDefault", null);
 (function (AbstractContainerType) {
     AbstractContainerType.GraphqlType = AbstractType.GraphqlType;
     function isItemType(type) {

package/dist/generators/ts/AbstractDateType.d.ts

@@ -13,7 +13,7 @@ export declare abstract class AbstractDateType extends AbstractPrimitiveType<Dat
     fromJsonExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromJsonExpression"]>[0]): Code;
     jsonType(): AbstractPrimitiveType.JsonType;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["toRdfResourceValuesExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<Date>["fromRdfExpressionChain"]>;
+    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<Date>["fromRdfResourceValuesExpressionChain"]>;
     protected abstract fromRdfResourceValueExpression(variables: {
         variables: {
             value: Code;

package/dist/generators/ts/AbstractDateType.js

@@ -17,7 +17,7 @@ export class AbstractDateType extends AbstractPrimitiveType {
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.dateSparqlWherePatterns}`;
     typeofs = ["object"];
     fromJsonExpression({ variables, }) {
-        return code `new Date(${variables.value})`;
+        return code `${this.reusables.imports.Either}.of<Error, Date>(new Date(${variables.value}))`;
     }
     jsonType() {
         return new AbstractPrimitiveType.JsonType(code `string`);
@@ -25,9 +25,9 @@ export class AbstractDateType extends AbstractPrimitiveType {
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.date(${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 => ${this.fromRdfResourceValueExpression({

package/dist/generators/ts/AbstractLazyObjectType.d.ts

@@ -17,6 +17,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     readonly discriminantProperty: AbstractType["discriminantProperty"];
     readonly mutable = false;
     readonly typeofs: "object"[];
+    readonly validationFunction: Maybe<Code>;
     constructor({ partialType, resolveType, ...superParameters }: {
         partialType: PartialTypeT;
         resolveType: ResolveTypeT;

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -17,6 +17,7 @@ export class AbstractLazyObjectType extends AbstractType {
     discriminantProperty = Maybe.empty();
     mutable = false;
     typeofs = ["object"];
+    validationFunction = Maybe.empty();
     constructor({ partialType, resolveType, ...superParameters }) {
         super(superParameters);
         this.partialType = partialType;

package/dist/generators/ts/AbstractLiteralType.d.ts

@@ -19,7 +19,7 @@ export declare abstract class AbstractLiteralType extends AbstractTermType<Liter
      * For example, a string would be converted to "thestring".
      */
     abstract literalExpression(literal: Literal): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType<Literal, Literal>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractTermType<Literal, Literal>["fromRdfExpressionChain"]>;
+    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractTermType<Literal, Literal>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractTermType<Literal, Literal>["fromRdfResourceValuesExpressionChain"]>;
 }
 export declare namespace AbstractLiteralType {
     type ConversionFunction = AbstractTermType.ConversionFunction;

package/dist/generators/ts/AbstractLiteralType.js

@@ -16,9 +16,9 @@ export class AbstractLiteralType extends AbstractTermType {
             languageIn: this.languageIn.length > 0 ? this.languageIn.map(literalOf) : undefined,
         };
     }
-    fromRdfExpressionChain({ variables, }) {
+    fromRdfResourceValuesExpressionChain({ variables, }) {
         return {
-            ...super.fromRdfExpressionChain({ variables }),
+            ...super.fromRdfResourceValuesExpressionChain({ variables }),
             languageIn: this.languageIn.length > 0
                 ? code `chain(values => ${this.reusables.snippets.fromRdfLanguageIn}(values, ${JSON.stringify(this.languageIn)}))`
                 : undefined,

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -16,9 +16,10 @@ export class AbstractNamedUnionType extends AbstractUnionType {
         this._name = name;
     }
     get declaration() {
-        const declarations = [
-            code `export type ${def(this._name)} = ${this.inlineName};`,
-        ];
+        const declarations = [];
+        if (this.configuration.features.has("Object.type")) {
+            declarations.push(code `export type ${def(this._name)} = ${this.inlineName};`);
+        }
         const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations);
         if (staticModuleDeclarations.length > 0) {
             declarations.push(code `\
@@ -68,22 +69,26 @@ ${joinCode(staticModuleDeclarations
     }
     get staticModuleDeclarations() {
         const staticModuleDeclarations = {};
-        if (this.configuration.features.has("equals")) {
+        if (this.configuration.features.has("Object.equals")) {
             staticModuleDeclarations[`equals`] =
                 code `export const equals = ${this.inlineEqualsFunction};`;
         }
-        staticModuleDeclarations[`Filter`] =
-            code `export type Filter = ${this.inlineFilterType};`;
-        staticModuleDeclarations[`filter`] =
-            code `export const filter = ${this.inlineFilterFunction};`;
-        if (this.configuration.features.has("hash")) {
+        if (this.configuration.features.has("Object.filter")) {
+            staticModuleDeclarations[`Filter`] =
+                code `export type Filter = ${this.inlineFilterType};`;
+            staticModuleDeclarations[`filter`] =
+                code `export const filter = ${this.inlineFilterFunction};`;
+        }
+        if (this.configuration.features.has("Object.hash")) {
             staticModuleDeclarations[`hash`] =
                 code `export const hash = ${this.inlineHashFunction};`;
         }
-        if (this.configuration.features.has("json")) {
-            staticModuleDeclarations[`Json`] = code `\
-${this.jsonTypeAliasDeclaration}
-
+        if (this.configuration.features.has("Object.JSON.type")) {
+            staticModuleDeclarations[`Json.type`] =
+                code `${this.jsonTypeAliasDeclaration}`;
+        }
+        if (this.configuration.features.has("Object.JSON.schema")) {
+            staticModuleDeclarations[`Json.namespace`] = code `\
 export namespace Json {
   ${this.jsonSchemaFunctionDeclaration}
 
@@ -93,26 +98,34 @@ export namespace Json {
     return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
   }
 }`;
+        }
+        if (this.configuration.features.has("Object.fromJson")) {
             staticModuleDeclarations[`fromJson`] =
                 code `export const fromJson = ${this.inlineFromJsonFunction};`;
-            staticModuleDeclarations[`toJson`] =
-                code `export const toJson = ${this.inlineToJsonFunction};`;
         }
-        if (this.configuration.features.has("rdf")) {
+        if (this.configuration.features.has("Object.fromRdf")) {
             staticModuleDeclarations[`fromRdfResourceValues`] =
                 code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}> = ${this.inlineFromRdfResourceValuesFunction};`;
+        }
+        if (this.configuration.features.has("Object.toJson")) {
+            staticModuleDeclarations[`toJson`] =
+                code `export const toJson = ${this.inlineToJsonFunction};`;
+        }
+        if (this.configuration.features.has("Object.toRdf")) {
             staticModuleDeclarations[`toRdfResourceValues`] =
                 code `export const toRdfResourceValues = ${this.inlineToRdfResourceValuesFunction};`;
         }
-        if (this.configuration.features.has("sparql")) {
+        if (this.configuration.features.has("Object.SPARQL")) {
             staticModuleDeclarations[`valueSparqlConstructTriples`] =
                 code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlConstructTriplesFunction};`;
             staticModuleDeclarations[`valueSparqlWherePatterns`] =
                 code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlWherePatternsFunction};`;
         }
-        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-        staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
-            code `export const ${syntheticNamePrefix}toString = ${this.inlineToStringFunction};`;
+        if (this.configuration.features.has("Object.toString")) {
+            const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+            staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
+                code `export const ${syntheticNamePrefix}toString = ${this.inlineToStringFunction};`;
+        }
         return staticModuleDeclarations;
     }
     fromJsonExpression({ variables, }) {

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -6,13 +6,6 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractNumericType<ValueT extends bigint | number> extends AbstractPrimitiveType<ValueT> {
     readonly hashFunction: Code;
     abstract readonly kind: "BigIntType" | "FloatType" | "IntType";
-    get conversionFunction(): {
-        code: Code;
-        sourceTypes: {
-            name: string | Code;
-            typeof: import("./Typeof.js").Typeof;
-        }[];
-    };
     get filterFunction(): Code;
     get filterType(): Code;
     get name(): Code | string;
@@ -20,7 +13,7 @@ export declare abstract class AbstractNumericType<ValueT extends bigint | number
     get valueSparqlWherePatternsFunction(): Code;
     jsonSchema(_parameters: Parameters<AbstractPrimitiveType<ValueT>["jsonSchema"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<ValueT>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<ValueT>["fromRdfExpressionChain"]>;
+    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<ValueT>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<ValueT>["fromRdfResourceValuesExpressionChain"]>;
     protected abstract fromRdfResourceValueExpression(variables: {
         variables: {
             value: Code;

package/dist/generators/ts/AbstractNumericType.js

@@ -12,17 +12,6 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
  */
 export class AbstractNumericType extends AbstractPrimitiveType {
     hashFunction = code `${this.reusables.snippets.hashNumeric}`;
-    get conversionFunction() {
-        return {
-            code: code `${this.reusables.snippets.convertToNumeric}<${this.name}>`,
-            sourceTypes: [
-                {
-                    name: this.name,
-                    typeof: this.typeofs[0],
-                },
-            ],
-        };
-    }
     get filterFunction() {
         return code `${this.reusables.snippets.filterNumeric}<${this.typeofs[0]}>`;
     }
@@ -54,9 +43,9 @@ export class AbstractNumericType extends AbstractPrimitiveType {
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.${this.typeofs[0]}(${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 => ${this.fromRdfResourceValueExpression({
@@ -65,9 +54,6 @@ export class AbstractNumericType extends AbstractPrimitiveType {
         };
     }
 }
-__decorate([
-    Memoize()
-], AbstractNumericType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], AbstractNumericType.prototype, "filterFunction", null);

package/dist/generators/ts/AbstractPrimitiveType.d.ts

@@ -4,6 +4,7 @@ import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractPrimitiveType<ValueT extends bigint | boolean | Date | string | number> extends AbstractLiteralType {
     protected readonly datatype: NamedNode;
+    readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly equalsFunction: Code;
     abstract readonly kind: "BigIntType" | "BooleanType" | "DateTimeType" | "DateType" | "FloatType" | "IntType" | "NumberType" | "StringType";
     readonly primitiveIn: readonly ValueT[];

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -10,6 +10,7 @@ import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class AbstractPrimitiveType extends AbstractLiteralType {
     datatype;
+    conversionFunction = Maybe.empty();
     equalsFunction = code `${this.reusables.snippets.strictEquals}`;
     primitiveIn;
     constructor({ datatype, primitiveIn, ...superParameters }) {
@@ -29,7 +30,7 @@ export class AbstractPrimitiveType extends AbstractLiteralType {
         };
     }
     fromJsonExpression({ variables, }) {
-        return variables.value;
+        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${variables.value})`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;

package/dist/generators/ts/AbstractTermType.d.ts

@@ -24,6 +24,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     abstract readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly recursive = false;
     readonly typeofs: readonly Typeof[];
+    readonly validationFunction: Maybe<Code>;
     constructor({ hasValues, in_, ...superParameters }: {
         hasValues: readonly ConstantTermT[];
         in_: readonly ConstantTermT[];
@@ -51,7 +52,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
      *
      * Considering the sub-expressions as a record instead of an array allows them to be selectively overridden by subclasses.
      */
-    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfResourceValuesExpression"]>[0]): {
+    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<Type["fromRdfResourceValuesExpression"]>[0]): {
         hasValues?: Code;
         languageIn?: Code;
         preferredLanguages?: Code;

package/dist/generators/ts/AbstractTermType.js

@@ -28,6 +28,7 @@ export class AbstractTermType extends AbstractType {
     mutable = false;
     recursive = false;
     typeofs = ["object"];
+    validationFunction = Maybe.empty();
     constructor({ hasValues, in_, ...superParameters }) {
         super(superParameters);
         this.hasValues = hasValues;
@@ -71,7 +72,7 @@ export class AbstractTermType extends AbstractType {
         //     (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")),
         //   "IdentifierType and LiteralType should override",
         // );
-        const chain = this.fromRdfExpressionChain(parameters);
+        const chain = this.fromRdfResourceValuesExpressionChain(parameters);
         const { variables } = parameters;
         return joinCode([
             variables.resourceValues,
@@ -99,7 +100,7 @@ export class AbstractTermType extends AbstractType {
      *
      * Considering the sub-expressions as a record instead of an array allows them to be selectively overridden by subclasses.
      */
-    fromRdfExpressionChain({ variables, }) {
+    fromRdfResourceValuesExpressionChain({ variables, }) {
         let valueToExpression;
         if (this.in_.length > 0) {
             valueToExpression = code `value.toTerm([${joinCode(this.in_.map((in_) => this.rdfjsTermExpression(in_)), { on: ", " })}])`;

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

@@ -17,15 +17,15 @@ export declare abstract class AbstractType {
      */
     readonly comment: Maybe<string>;
     /**
-     * Function that converts one or more source types to this type and returns Either<Error, ThisType>.
-     *
-     * The function takes two parameters:
-     *  - an instance of this.schemaType
-     *  - a value with one of the source types
+     * Function that takes a value of one or more source types to this type and returns Either<Error, ThisType>.
      *
      * The source types should include this type.
+     *
+     * The function should not perform validation (e.g., checking array lengths). That will be done by validationFunction in conjunction with this function.
+     *
+     * If unspecified, uses an identity function (i.e., function identity(value: ThisType): Either<Error, ThisType>).
      */
-    abstract readonly conversionFunction: AbstractType.ConversionFunction;
+    abstract readonly conversionFunction: Maybe<AbstractType.ConversionFunction>;
     /**
      * The declaration of named types.
      */
@@ -98,6 +98,18 @@ export declare abstract class AbstractType {
      * JavaScript typeof(s) the type.
      */
     abstract readonly typeofs: readonly Typeof[];
+    /**
+     * Function that takes
+     * - a schema of this.schemaType
+     * - a value of this.type
+     *
+     * and validates the value against the schema, returning
+     * - Left(Error) if validation fails or
+     * - Right(the value) if validatios succeeds
+     *
+     * If unspecified, uses an identity function (i.e., function identity(schema: unknown, value: ThisType): Either<Error, ThisType>).
+     */
+    abstract readonly validationFunction: Maybe<Code>;
     /**
      * A ValueSparqlConstructTriplesFunction (reference or declaration) that returns an array of sparqljs.Triple's for a property value of this type.
      *
@@ -135,8 +147,7 @@ export declare abstract class AbstractType {
         kind: Code;
     };
     /**
-     * An expression that converts this type's JSON type to a value of this type. It doesn't return a Either because the JSON has
-     * already been validated and converted to the expected JSON type with Zod.
+     * An expression that converts this type's JSON type to an Either<Error, ThisType>.
      */
     abstract fromJsonExpression(parameters: {
         variables: {

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -10,6 +10,7 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     private readonly discriminant;
     private readonly identifierType;
     readonly recursive: boolean;
+    readonly validationFunction: Maybe<Code>;
     constructor({ identifierType, members, recursive, ...superParameters }: {
         identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
         members: readonly (Pick<AbstractUnionType.Member<MemberTypeT>, "type"> & {
@@ -17,7 +18,7 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
         })[];
         recursive: boolean;
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get conversionFunction(): AbstractType.ConversionFunction;
+    get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get members(): readonly AbstractUnionType.Member<MemberTypeT>[];
     get mutable(): boolean;
@@ -30,11 +31,11 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     protected get inlineFilterType(): Code;
     protected get inlineFromJsonFunction(): Code;
     protected get inlineFromRdfResourceValuesFunction(): Code;
+    protected get inlineHashFunction(): Code;
     protected get inlineJsonSchema(): Code;
     protected get inlineJsonType(): AbstractType.JsonType;
     protected get inlineName(): Code;
     protected get inlineToJsonFunction(): Code;
-    protected get inlineHashFunction(): Code;
     protected get inlineToRdfResourceValuesFunction(): Code;
     protected get inlineToStringFunction(): Code;
     protected get inlineValueSparqlConstructTriplesFunction(): Code;

package/dist/generators/ts/AbstractUnionType.js

@@ -14,6 +14,7 @@ export class AbstractUnionType extends AbstractType {
     discriminant;
     identifierType;
     recursive;
+    validationFunction = Maybe.empty();
     constructor({ identifierType, members, recursive, ...superParameters }) {
         super(superParameters);
         this.identifierType = identifierType;
@@ -130,8 +131,8 @@ export class AbstractUnionType extends AbstractType {
         });
     }
     get conversionFunction() {
-        return {
-            code: code `${this.reusables.snippets.convertToUnion}`,
+        return Maybe.of({
+            code: code `${this.reusables.snippets.identityConversionFunction}`,
             sourceTypes: this.discriminant.kind === "typeof"
                 ? this.members.map(({ primaryDiscriminantValue, type }) => ({
                     name: type.name,
@@ -143,7 +144,7 @@ export class AbstractUnionType extends AbstractType {
                         typeof: "object",
                     },
                 ],
-        };
+        });
     }
     get discriminantProperty() {
         switch (this.discriminant.kind) {
@@ -250,12 +251,12 @@ if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeC
     }
     get inlineFromJsonFunction() {
         return code `\
-((value: ${this.jsonType().name}): ${this.name} => {
-${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${wrap(type.fromJsonExpression({
+((value: ${this.jsonType().name}): ${this.reusables.imports.Either}<Error, ${this.name}> => {
+${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${type.fromJsonExpression({
             variables: {
                 value: code `(${unwrap(code `value`)} as ${jsonType})`,
             },
-        }))}; }`))}
+        })}.map(value => (${wrap(code `value`)})); }`))}
 
   throw new Error("unable to deserialize JSON");
 })`;
@@ -299,6 +300,13 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
         }, null)}.chain(values => values.head());
     }))
 ) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}>)`;
+    }
+    get inlineHashFunction() {
+        return code `\
+(<HasherT extends ${this.reusables.snippets.Hasher}>(hasher: HasherT, value: ${this.name}): HasherT => {
+${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.hashFunction}(hasher, ${unwrap(code `value`)}); }`))}
+  return hasher;
+})`;
     }
     get inlineJsonSchema() {
         const discriminant = this.discriminant; // To get type narrowing to work
@@ -388,13 +396,6 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
 ${joinCode(this.members.map(({ typeCheck, typeToJsonExpression, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(typeToJsonExpression(unwrap(code `value`)))}; }`))}
 
   throw new Error("unable to serialize to JSON");
-})`;
-    }
-    get inlineHashFunction() {
-        return code `\
-(<HasherT extends ${this.reusables.snippets.Hasher}>(hasher: HasherT, value: ${this.name}): HasherT => {
-${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.hashFunction}(hasher, ${unwrap(code `value`)}); }`))}
-  return hasher;
 })`;
     }
     get inlineToRdfResourceValuesFunction() {

package/dist/generators/ts/BigDecimalType.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 BigDecimalType extends AbstractLiteralType {
     readonly name: Code;
-    readonly conversionFunction: AbstractLiteralType.ConversionFunction;
+    readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly hashFunction: Code;
@@ -18,6 +19,6 @@ export declare class BigDecimalType extends AbstractLiteralType {
     literalExpression(literal: Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractLiteralType["toRdfResourceValuesExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractLiteralType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractLiteralType["fromRdfExpressionChain"]>;
+    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractLiteralType["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractLiteralType["fromRdfResourceValuesExpressionChain"]>;
 }
 //# sourceMappingURL=BigDecimalType.d.ts.map