@shaclmate/compiler 4.0.33 → 4.0.35

package/dist/generators/ts/DefaultValueType.js

@@ -4,33 +4,33 @@ 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 { LiteralDecoder } from "@rdfx/literal";
-import { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
-import { code, literalOf } from "./ts-poet-wrapper.js";
+import { code } from "./ts-poet-wrapper.js";
 export class DefaultValueType extends AbstractContainerType {
     defaultValue;
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
     kind = "DefaultValueType";
-    typeofs = NonEmptyList(["object"]);
+    typeofs = ["object"];
+    validationFunction = this.itemType.validationFunction;
     constructor({ defaultValue, ...superParameters }) {
         super(superParameters);
         this.defaultValue = defaultValue;
     }
-    get conversions() {
-        let conversions = this.itemType.conversions;
-        this.defaultValuePrimitiveExpression.ifJust((defaultValue) => {
-            conversions = conversions.concat({
-                conversionExpression: () => code `${defaultValue}`,
-                sourceTypeCheckExpression: (value) => code `${value} === undefined`,
-                sourceTypeName: code `undefined`,
-                sourceTypeof: "undefined",
-            });
+    get conversionFunction() {
+        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",
+            }),
         });
-        return conversions;
     }
     get equalsFunction() {
         return this.itemType.equalsFunction;
@@ -44,6 +44,9 @@ export class DefaultValueType extends AbstractContainerType {
     get graphqlType() {
         return this.itemType.graphqlType;
     }
+    get hashFunction() {
+        return this.itemType.hashFunction;
+    }
     get mutable() {
         return this.itemType.mutable;
     }
@@ -51,7 +54,7 @@ export class DefaultValueType extends AbstractContainerType {
         return this.itemType.name;
     }
     get schemaType() {
-        return code `${this.reusables.snippets.DefaultValueSchema}`;
+        return code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.name}, ${this.itemType.schemaType}>`;
     }
     get valueSparqlConstructTriplesFunction() {
         return this.itemType.valueSparqlConstructTriplesFunction;
@@ -62,56 +65,25 @@ export class DefaultValueType extends AbstractContainerType {
     get schemaObject() {
         return {
             ...super.schemaObject,
-            defaultValue: this.defaultValueTermExpression,
+            defaultValue: this.defaultValueExpression,
         };
     }
-    get defaultValuePrimitiveExpression() {
+    get defaultValueExpression() {
         switch (this.itemType.kind) {
-            case "BigDecimalType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `new ${this.reusables.imports.BigDecimal}(${literalOf(this.defaultValue.value)})`);
-            case "BigIntType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `${LiteralDecoder.decodeBigIntLiteral(this.defaultValue).unsafeCoerce()}n`);
-            case "BooleanType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `${LiteralDecoder.decodeBooleanLiteral(this.defaultValue).unsafeCoerce()}`);
-            case "DateType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `new Date("${LiteralDecoder.decodeDateLiteral(this.defaultValue).unsafeCoerce().toISOString()}")`);
-            case "DateTimeType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `new Date("${LiteralDecoder.decodeDateTimeLiteral(this.defaultValue).unsafeCoerce().toISOString()}")`);
-            case "FloatType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `${LiteralDecoder.decodeFloatLiteral(this.defaultValue).unsafeCoerce()}`);
-            case "IntType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `${LiteralDecoder.decodeIntLiteral(this.defaultValue).unsafeCoerce()}`);
-            case "StringType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `${literalOf(this.defaultValue.value)}`);
             case "IdentifierType":
             case "IriType":
-                invariant(this.defaultValue.termType === "NamedNode");
-                return Maybe.of(this.defaultValueTermExpression);
             case "LiteralType":
             case "TermType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(this.defaultValueTermExpression);
+                return this.rdfjsTermExpression(this.defaultValue);
             case "AnonymousUnionType":
             case "ListType":
             case "NamedObjectType":
             case "NamedObjectUnionType":
             case "NamedUnionType":
-                return Maybe.empty();
-            default:
-                this.itemType;
-                throw new Error("should never reach this point");
+                throw new RangeError(`not implemented ${this.itemType.kind}`);
         }
-    }
-    get defaultValueTermExpression() {
-        return this.rdfjsTermExpression(this.defaultValue);
+        invariant(this.defaultValue.termType === "Literal");
+        return this.itemType.literalExpression(this.defaultValue);
     }
     fromJsonExpression(parameters) {
         return this.itemType.fromJsonExpression(parameters);
@@ -120,16 +92,13 @@ export class DefaultValueType extends AbstractContainerType {
         return this.itemType.fromRdfResourceValuesExpression({
             variables: {
                 ...variables,
-                resourceValues: code `${variables.resourceValues}.map(values => values.length > 0 ? values : new ${this.reusables.imports.Resource}.Value(${{ dataFactory: this.reusables.imports.dataFactory, focusResource: variables.resource, propertyPath: variables.propertyPath, term: this.defaultValueTermExpression }}).toValues())`,
+                resourceValues: code `${variables.resourceValues}.map(values => values.length > 0 ? values : new ${this.reusables.imports.Resource}.Value(${{ dataFactory: this.reusables.imports.dataFactory, focusResource: variables.resource, propertyPath: variables.propertyPath, term: this.rdfjsTermExpression(this.defaultValue) }}).toValues())`,
             },
         });
     }
     graphqlResolveExpression(parameters) {
         return this.itemType.graphqlResolveExpression(parameters);
     }
-    hashStatements(parameters) {
-        return this.itemType.hashStatements(parameters);
-    }
     jsonSchema(parameters) {
         return this.itemType.jsonSchema(parameters);
     }
@@ -144,14 +113,15 @@ export class DefaultValueType extends AbstractContainerType {
     }
     toRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        return this.defaultValuePrimitiveExpression
-            .map((defaultValuePrimitiveExpression) => code `${this.itemType.equalsFunction}(${variables.value}, ${defaultValuePrimitiveExpression}).isLeft() ? ${this.itemType.toRdfResourceValuesExpression(parameters)} : []`)
-            .orDefault(code `${this.itemType.toRdfResourceValuesExpression(parameters)}.filter(value => !value.equals(${this.defaultValueTermExpression}))`);
+        return code `${this.itemType.equalsFunction}(${variables.value}, ${this.defaultValueExpression}).isLeft() ? ${this.itemType.toRdfResourceValuesExpression(parameters)} : []`;
     }
     toStringExpression(parameters) {
         return this.itemType.toStringExpression(parameters);
     }
 }
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], DefaultValueType.prototype, "schemaType", null);
@@ -163,10 +133,7 @@ __decorate([
 ], DefaultValueType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
-], DefaultValueType.prototype, "defaultValuePrimitiveExpression", null);
-__decorate([
-    Memoize()
-], DefaultValueType.prototype, "defaultValueTermExpression", null);
+], DefaultValueType.prototype, "defaultValueExpression", null);
 (function (DefaultValueType) {
     function isItemType(type) {
         if (type.kind === "BlankNodeType") {

package/dist/generators/ts/FloatType.d.ts

@@ -1,11 +1,11 @@
-import { NonEmptyList } from "purify-ts";
+import type { Literal } from "@rdfjs/types";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class FloatType extends AbstractNumericType<number> {
     readonly kind = "FloatType";
-    readonly typeofs: NonEmptyList<"number">;
+    readonly typeofs: "number"[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
+    literalExpression(literal: Literal | number): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<number>["fromRdfResourceValueExpression"]>[0]): Code;
-    protected literalOf(value: number): string;
 }
 //# sourceMappingURL=FloatType.d.ts.map

package/dist/generators/ts/FloatType.js

@@ -4,22 +4,22 @@ 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 { NonEmptyList } from "purify-ts";
+import { LiteralDecoder } from "@rdfx/literal";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class FloatType extends AbstractNumericType {
     kind = "FloatType";
-    typeofs = NonEmptyList(["number"]);
+    typeofs = ["number"];
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLFloat}`, this.reusables);
     }
+    literalExpression(literal) {
+        return code `${typeof literal === "number" ? literal : LiteralDecoder.decodeFloatLiteral(literal).unsafeCoerce()}`;
+    }
     fromRdfResourceValueExpression({ variables, }) {
         return code `${variables.value}.toFloat(${this.primitiveIn.length > 0 ? `${JSON.stringify(this.primitiveIn)} as const` : ""})`;
     }
-    literalOf(value) {
-        return value.toString();
-    }
 }
 __decorate([
     Memoize()

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 { AbstractTermType } from "./AbstractTermType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IdentifierType extends AbstractIdentifierType<BlankNode | NamedNode> {
+    readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly parseFunction: Code;
@@ -13,10 +14,10 @@ export declare class IdentifierType extends AbstractIdentifierType<BlankNode | N
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     constructor(parameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "hasValues" | "in_">);
-    fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
-    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
-    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractTermType["fromRdfExpressionChain"]>;
+    fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
+    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 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,32 @@ 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 { AbstractTermType } from "./AbstractTermType.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class IdentifierType extends AbstractIdentifierType {
+    conversionFunction = Maybe.of({
+        code: code `${this.reusables.snippets.convertToIdentifier}`,
+        sourceTypes: [
+            {
+                name: code `${this.reusables.imports.BlankNode}`,
+                typeof: "object",
+            },
+            {
+                name: code `${this.reusables.imports.NamedNode}`,
+                typeof: "object",
+            },
+            {
+                name: "string",
+                typeof: "string",
+            },
+            {
+                name: "undefined",
+                typeof: "undefined",
+            },
+        ],
+    });
     filterFunction = code `${this.reusables.snippets.filterIdentifier}`;
     filterType = code `${this.reusables.snippets.IdentifierFilter}`;
     parseFunction = code `${this.reusables.snippets.parseIdentifier};`;
@@ -26,13 +47,13 @@ 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
             ? `, readonly termType: "BlankNode" | "NamedNode"`
             : "";
-        return new AbstractTermType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
@@ -48,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/IntType.d.ts

@@ -1,11 +1,11 @@
-import { NonEmptyList } from "purify-ts";
+import type { Literal } from "@rdfjs/types";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IntType extends AbstractNumericType<number> {
     readonly kind = "IntType";
-    readonly typeofs: NonEmptyList<"number">;
+    readonly typeofs: "number"[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
+    literalExpression(literal: Literal | number): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<number>["fromRdfResourceValueExpression"]>[0]): Code;
-    protected literalOf(value: number): string;
 }
 //# sourceMappingURL=IntType.d.ts.map

package/dist/generators/ts/IntType.js

@@ -4,22 +4,22 @@ 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 { NonEmptyList } from "purify-ts";
+import { LiteralDecoder } from "@rdfx/literal";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class IntType extends AbstractNumericType {
     kind = "IntType";
-    typeofs = NonEmptyList(["number"]);
+    typeofs = ["number"];
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLInt}`, this.reusables);
     }
+    literalExpression(literal) {
+        return code `${typeof literal === "number" ? literal : LiteralDecoder.decodeIntLiteral(literal).unsafeCoerce()}`;
+    }
     fromRdfResourceValueExpression({ variables, }) {
         return code `${variables.value}.toInt(${this.primitiveIn.length > 0 ? `${JSON.stringify(this.primitiveIn)} as const` : ""})`;
     }
-    literalOf(value) {
-        return value.toString();
-    }
 }
 __decorate([
     Memoize()

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

@@ -1,6 +1,6 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { AbstractTermType } from "./AbstractTermType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IriType extends AbstractIdentifierType<NamedNode> {
     readonly filterFunction: Code;
@@ -9,16 +9,13 @@ export declare class IriType extends AbstractIdentifierType<NamedNode> {
     readonly nodeKinds: ReadonlySet<"IRI">;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
-    get parseFunction(): Code;
+    get conversionFunction(): Maybe<AbstractIdentifierType.ConversionFunction>;
     get name(): Code;
-    protected get schemaObject(): {
-        in: Code[] | undefined;
-        kind: Code;
-    };
-    fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
-    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
-    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractTermType["fromRdfExpressionChain"]>;
+    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 fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractIdentifierType<NamedNode>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractIdentifierType<NamedNode>["fromRdfResourceValuesExpressionChain"]>;
 }
 //# sourceMappingURL=IriType.d.ts.map

package/dist/generators/ts/IriType.js

@@ -4,10 +4,10 @@ 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 { AbstractTermType } from "./AbstractTermType.js";
-import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
+import { arrayOf, code, joinCode, literalOf, } from "./ts-poet-wrapper.js";
 export class IriType extends AbstractIdentifierType {
     filterFunction = code `${this.reusables.snippets.filterIri}`;
     filterType = code `${this.reusables.snippets.IriFilter}`;
@@ -15,43 +15,40 @@ export class IriType extends AbstractIdentifierType {
     nodeKinds = nodeKinds;
     schemaType = code `${this.reusables.snippets.IriSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.iriSparqlWherePatterns}`;
-    get parseFunction() {
-        if (this.in_.length > 0) {
-            return code `(identifier: string) => ${this.reusables.snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${this.reusables.imports.Right}(identifier as ${this.name});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
-        }
-        return code `${this.reusables.snippets.parseIri}`;
+    get conversionFunction() {
+        const IriT = this.in_.length > 0
+            ? code `${joinCode(this.in_.map((iri) => code `${literalOf(iri.value)}`), { on: "| " })}`
+            : code `string`;
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToIri}<${IriT}>`,
+            sourceTypes: [
+                {
+                    name: IriT,
+                    typeof: "string",
+                },
+                {
+                    name: this.name,
+                    typeof: "object",
+                },
+            ],
+        });
     }
     get name() {
         if (this.in_.length > 0) {
             // Treat sh:in as a union of the IRIs
             // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            return code `${this.reusables.imports.NamedNode}<${this.in_
-                .map((iri) => `"${iri.value}"`)
-                .join(" | ")}>`;
+            return code `${this.reusables.imports.NamedNode}<${joinCode(this.in_.map((iri) => code `${literalOf(iri.value)}`), { on: "| " })}>`;
         }
         return code `${this.reusables.imports.NamedNode}`;
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            in: this.in_.length > 0
-                ? this.in_.map((in_) => this.rdfjsTermExpression(in_)).concat()
-                : undefined,
-        };
-    }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"])`;
-    }
-    jsonType(parameters) {
-        const discriminantProperty = parameters?.includeDiscriminantProperty
-            ? `, readonly termType: "NamedNode"`
-            : "";
+    get parseFunction() {
         if (this.in_.length > 0) {
-            // Treat sh:in as a union of the IRIs
-            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            return new AbstractTermType.JsonType(code `{ readonly "@id": ${this.in_.map((iri) => `"${iri.value}"`).join(" | ")}${discriminantProperty} }`);
+            return code `(identifier: string) => ${this.reusables.snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${this.reusables.imports.Right}(identifier as ${this.name});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
         }
-        return new AbstractTermType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+        return code `${this.reusables.snippets.parseIri}`;
+    }
+    fromJsonExpression({ variables, }) {
+        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         let idSchema;
@@ -68,15 +65,26 @@ export class IriType extends AbstractIdentifierType {
             : "";
         return code `${this.reusables.imports.z}.object({ "@id": ${idSchema}${discriminantProperty} })`;
     }
+    jsonType(parameters) {
+        const discriminantProperty = parameters?.includeDiscriminantProperty
+            ? `, readonly termType: "NamedNode"`
+            : "";
+        if (this.in_.length > 0) {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            return new AbstractIdentifierType.JsonType(code `{ readonly "@id": ${this.in_.map((iri) => `"${iri.value}"`).join(" | ")}${discriminantProperty} }`);
+        }
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+    }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         const discriminantProperty = includeDiscriminantProperty
             ? code `, termType: ${variables.value}.termType`
             : "";
         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: ", " })}]`
                 : ""})))`,
@@ -85,10 +93,13 @@ export class IriType extends AbstractIdentifierType {
 }
 __decorate([
     Memoize()
-], IriType.prototype, "parseFunction", null);
+], IriType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "name", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "parseFunction", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "jsonType", null);

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

@@ -8,6 +8,7 @@ declare const Super: (abstract new ({ partialType, resolveType, ...superParamete
     resolveType: OptionType<AbstractLazyObjectType.ObjectTypeConstraint>;
 } & {
     comment: Maybe<string>;
+    configuration: import("./TsGenerator.js").TsGenerator.Configuration;
     label: Maybe<string>;
     logger: import("ts-log").Logger;
     reusables: import("./Reusables.js").Reusables;
@@ -18,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 conversions(): readonly AbstractLazyObjectType.Conversion[];
+    get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
     protected get runtimeClass(): {
         name: Code;
         partialPropertyName: string;

package/dist/generators/ts/LazyObjectOptionType.js

@@ -12,49 +12,28 @@ const Super = (AbstractLazyObjectType);
 export class LazyObjectOptionType extends Super {
     graphqlArgs = Maybe.empty();
     kind = "LazyObjectOptionType";
-    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 ${this.reusables.imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
-                sourceTypeCheckExpression: (value) => code `${this.reusables.imports.Maybe}.isMaybe(${value})`,
-                sourceTypeName: code `${this.reusables.imports.Maybe}<${this.resolveType.itemType.name}>`,
-                sourceTypeof: "object",
-            }, {
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.reusables.imports.Maybe}.of(${this.partialType.itemType.name}.create(${value})), resolver: async () => ${this.reusables.imports.Right}(${value} as ${this.resolveType.itemType.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.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) {
-            const maybeMap = code `.map(object => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType.itemType, partialNamedObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} })`;
-            conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}${maybeMap}, resolver: async () => ${this.reusables.imports.Right}((${value} as ${this.reusables.imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
-                sourceTypeCheckExpression: (value) => code `${this.reusables.imports.Maybe}.isMaybe(${value})`,
-                sourceTypeName: code `${this.reusables.imports.Maybe}<${this.resolveType.itemType.name}>`,
-                sourceTypeof: "object",
-            }, {
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.reusables.imports.Maybe}.of(${value})${maybeMap}, resolver: async () => ${this.reusables.imports.Right}(${value} as ${this.resolveType.itemType.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.itemType.name,
-                sourceTypeof: "object",
-            });
-        }
-        conversions.push({
-            conversionExpression: () => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.reusables.imports.Maybe}.empty(), 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.convertToLazyObjectOption}<${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: this.resolveType.itemType.name,
+                    typeof: "object",
+                },
+                {
+                    name: "undefined",
+                    typeof: "undefined",
+                },
+            ],
         });
-        return conversions;
     }
     get runtimeClass() {
         return {
@@ -64,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;
@@ -76,7 +55,7 @@ export class LazyObjectOptionType extends Super {
 }
 __decorate([
     Memoize()
-], LazyObjectOptionType.prototype, "conversions", null);
+], LazyObjectOptionType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], LazyObjectOptionType.prototype, "runtimeClass", null);