@shaclmate/compiler 4.0.40 → 4.0.42

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

@@ -2,10 +2,12 @@ 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 jsTypes: readonly [{
+        readonly typeof: "number";
+    }];
     readonly kind = "Float";
-    readonly typeofs: "number"[];
+    get fromRdfResourceValuesFunction(): Code;
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
-    literalExpression(literal: Literal | number): Code;
-    protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<number>["fromRdfResourceValueExpression"]>[0]): Code;
+    literalValueExpression(literal: Literal | number): Code;
 }
 //# sourceMappingURL=FloatType.d.ts.map

package/dist/generators/ts/FloatType.js

@@ -9,18 +9,21 @@ import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class FloatType extends AbstractNumericType {
+    jsTypes = [{ typeof: "number" }];
     kind = "Float";
-    typeofs = ["number"];
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.floatFromRdfResourceValues}<${this.expression}>`;
+    }
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLFloat}`, this.reusables);
     }
-    literalExpression(literal) {
+    literalValueExpression(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` : ""})`;
-    }
 }
+__decorate([
+    Memoize()
+], FloatType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], FloatType.prototype, "graphqlType", null);

package/dist/generators/ts/GraphqlSchema.js

@@ -32,7 +32,7 @@ export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query
     (await ${this.reusables.imports.EitherAsync}<Error, ${namedObjectType.expression}>(async ({ liftEither }) => 
       liftEither(await objectSet.${namedObjectType.objectSetMethodNames.object}(await liftEither(${namedObjectType.identifierTypeAlias}.parse(args.identifier))))
     )).unsafeCoerce()`,
-                type: namedObjectType.graphqlType.name,
+                type: namedObjectType.graphqlType.expression,
             };
             fields[namedObjectType.objectSetMethodNames.objectIdentifiers] = {
                 args: {
@@ -73,7 +73,7 @@ export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query
     }
     return await liftEither(await objectSet.${namedObjectType.objectSetMethodNames.objects}({ filter, limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined }));
   })).unsafeCoerce()`,
-                type: code `new ${this.reusables.imports.GraphQLNonNull}(new ${this.reusables.imports.GraphQLList}(${namedObjectType.graphqlType.name}))`,
+                type: code `new ${this.reusables.imports.GraphQLNonNull}(new ${this.reusables.imports.GraphQLList}(${namedObjectType.graphqlType.expression}))`,
             };
             fields[namedObjectType.objectSetMethodNames.objectCount] = {
                 resolve: code `\

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

@@ -4,10 +4,11 @@ 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> {
+    protected readonly inlineExpression: Code;
     readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
-    readonly expression: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
+    readonly fromRdfResourceValuesFunction: Code;
     readonly kind = "Identifier";
     readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
     readonly parseFunction: Code;
@@ -18,6 +19,5 @@ export declare class IdentifierType extends AbstractIdentifierType<BlankNode | N
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
     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

@@ -10,30 +10,33 @@ import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class IdentifierType extends AbstractIdentifierType {
+    inlineExpression = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
     conversionFunction = Maybe.of({
         code: code `${this.reusables.snippets.convertToIdentifier}`,
         sourceTypes: [
             {
                 expression: code `${this.reusables.imports.BlankNode}`,
-                typeof: "object",
+                jsType: this.jsTypes[0],
             },
             {
                 expression: code `${this.reusables.imports.NamedNode}`,
-                typeof: "object",
+                jsType: this.jsTypes[0],
             },
             {
+                // To NamedNode
                 expression: code `string`,
-                typeof: "string",
+                jsType: { typeof: "string" },
             },
             {
+                // To BlankNode
                 expression: code `undefined`,
-                typeof: "undefined",
+                jsType: { typeof: "undefined" },
             },
         ],
     });
-    expression = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
     filterFunction = code `${this.reusables.snippets.filterIdentifier}`;
     filterType = code `${this.reusables.snippets.IdentifierFilter}`;
+    fromRdfResourceValuesFunction = code `${this.reusables.snippets.identifierFromRdfResourceValues}`;
     kind = "Identifier";
     nodeKinds = nodeKinds;
     parseFunction = code `${this.reusables.snippets.parseIdentifier};`;
@@ -69,12 +72,6 @@ export class IdentifierType extends AbstractIdentifierType {
         const valueToNamedNode = code `{ "@id": ${variables.value}.value${discriminantProperty} }`;
         return code `(${variables.value}.termType === "BlankNode" ? ${valueToBlankNode} : ${valueToNamedNode})`;
     }
-    fromRdfResourceValuesExpressionChain({ variables, }) {
-        return {
-            ...super.fromRdfResourceValuesExpressionChain({ variables }),
-            valueTo: code `chain(values => values.chainMap(value => value.toIdentifier()))`,
-        };
-    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/IntType.d.ts

@@ -2,10 +2,12 @@ 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 jsTypes: readonly [{
+        readonly typeof: "number";
+    }];
     readonly kind = "Int";
-    readonly typeofs: "number"[];
+    get fromRdfResourceValuesFunction(): Code;
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
-    literalExpression(literal: Literal | number): Code;
-    protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<number>["fromRdfResourceValueExpression"]>[0]): Code;
+    literalValueExpression(literal: Literal | number): Code;
 }
 //# sourceMappingURL=IntType.d.ts.map

package/dist/generators/ts/IntType.js

@@ -9,18 +9,21 @@ import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class IntType extends AbstractNumericType {
+    jsTypes = [{ typeof: "number" }];
     kind = "Int";
-    typeofs = ["number"];
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.intFromRdfResourceValues}<${this.expression}>`;
+    }
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLInt}`, this.reusables);
     }
-    literalExpression(literal) {
+    literalValueExpression(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` : ""})`;
-    }
 }
+__decorate([
+    Memoize()
+], IntType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], IntType.prototype, "graphqlType", null);

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

@@ -10,14 +10,14 @@ export declare class IriType extends AbstractIdentifierType<NamedNode> {
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     get conversionFunction(): Maybe<AbstractIdentifierType.ConversionFunction>;
-    get expression(): Code;
+    get fromRdfResourceValuesFunction(): Code;
     get parseFunction(): Code;
+    protected get inlineExpression(): Code;
     protected get schemaInitializers(): readonly Code[];
     private get valueTypeExpression();
     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

@@ -5,6 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
@@ -16,25 +17,23 @@ export class IriType extends AbstractIdentifierType {
     schemaType = code `${this.reusables.snippets.IriSchema}<${this.valueTypeExpression}>`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.iriSparqlWherePatterns}`;
     get conversionFunction() {
+        invariant(this.jsTypes.length === 1);
         return Maybe.of({
             code: code `${this.reusables.snippets.convertToIri}<${this.valueTypeExpression}>`,
             sourceTypes: [
                 {
                     expression: this.valueTypeExpression,
-                    typeof: "string",
+                    jsType: { typeof: "string" },
                 },
                 {
                     expression: this.expression,
-                    typeof: "object",
+                    jsType: this.jsTypes[0],
                 },
             ],
         });
     }
-    get expression() {
-        if (this.in_.length > 0) {
-            return code `${this.reusables.imports.NamedNode}<${this.valueTypeExpression}>`;
-        }
-        return code `${this.reusables.imports.NamedNode}`;
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.iriFromRdfResourceValues}<${this.valueTypeExpression}>`;
     }
     get parseFunction() {
         if (this.in_.length > 0) {
@@ -42,6 +41,12 @@ export class IriType extends AbstractIdentifierType {
         }
         return code `${this.reusables.snippets.parseIri}`;
     }
+    get inlineExpression() {
+        if (this.in_.length > 0) {
+            return code `${this.reusables.imports.NamedNode}<${this.valueTypeExpression}>`;
+        }
+        return code `${this.reusables.imports.NamedNode}`;
+    }
     get schemaInitializers() {
         let initializers = super.schemaInitializers;
         if (this.in_.length > 0) {
@@ -84,24 +89,19 @@ export class IriType extends AbstractIdentifierType {
             : "";
         return code `{ "@id": ${variables.value}.value${discriminantProperty} }`;
     }
-    fromRdfResourceValuesExpressionChain({ variables, }) {
-        return {
-            ...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: ", " })}]`
-                : ""})))`,
-        };
-    }
 }
 __decorate([
     Memoize()
 ], IriType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
-], IriType.prototype, "expression", null);
+], IriType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "parseFunction", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "inlineExpression", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "valueTypeExpression", null);

package/dist/generators/ts/{LazyObjectOptionType.d.ts → LazyOptionType.d.ts}

@@ -1,34 +1,36 @@
 import { Maybe } from "purify-ts";
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
+import { AbstractLazyType } from "./AbstractLazyType.js";
 import type { OptionType } from "./OptionType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-type Super = AbstractLazyObjectType<OptionType<AbstractLazyObjectType.ObjectTypeConstraint>, OptionType<AbstractLazyObjectType.ObjectTypeConstraint>>;
+type Super = AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>;
 declare const Super: (abstract new ({ partialType, resolveType, ...superParameters }: {
-    partialType: OptionType<AbstractLazyObjectType.ObjectTypeConstraint>;
-    resolveType: OptionType<AbstractLazyObjectType.ObjectTypeConstraint>;
+    partialType: OptionType<AbstractLazyType.ItemTypeConstraint>;
+    resolveType: OptionType<AbstractLazyType.ItemTypeConstraint>;
 } & {
-    alias: Maybe<string>;
+    name: Maybe<string>;
     comment: Maybe<string>;
     configuration: import("./TsGenerator.js").TsGenerator.Configuration;
     label: Maybe<string>;
     logger: import("ts-log").Logger;
     reusables: import("./Reusables.js").Reusables;
-}) => AbstractLazyObjectType<OptionType<AbstractLazyObjectType.ObjectTypeConstraint>, OptionType<AbstractLazyObjectType.ObjectTypeConstraint>>) & {
+    shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode;
+}) => AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>) & {
     readonly GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
     readonly JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+    JsType: typeof import("./AbstractType.js").AbstractType.JsType;
 };
-export declare class LazyObjectOptionType extends Super {
+export declare class LazyOptionType extends Super {
     readonly graphqlArgs: Super["graphqlArgs"];
-    readonly kind = "LazyObjectOption";
-    get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
+    readonly kind = "LazyOption";
+    get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
     protected get runtimeClass(): {
         name: Code;
         partialPropertyName: string;
         rawName: Code;
     };
     fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
-    fromRdfResourceValuesExpression(parameters: Parameters<Super["fromRdfResourceValuesExpression"]>[0]): Code;
+    get fromRdfResourceValuesFunction(): Code;
     graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
 }
 export {};
-//# sourceMappingURL=LazyObjectOptionType.d.ts.map
+//# sourceMappingURL=LazyOptionType.d.ts.map

package/dist/generators/ts/LazyOptionType.js

@@ -0,0 +1,75 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractLazyType } from "./AbstractLazyType.js";
+import { code } from "./ts-poet-wrapper.js";
+const Super = (AbstractLazyType);
+export class LazyOptionType extends Super {
+    graphqlArgs = Maybe.empty();
+    kind = "LazyOption";
+    get conversionFunction() {
+        invariant(this.jsTypes.length === 1);
+        invariant(this.resolveType.jsTypes.length === 1);
+        invariant(this.resolveType.itemType.jsTypes.length === 1);
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToLazyOption}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            sourceTypes: [
+                {
+                    expression: this.expression,
+                    jsType: this.jsTypes[0],
+                },
+                {
+                    expression: this.resolveType.expression,
+                    jsType: this.resolveType.jsTypes[0],
+                },
+                {
+                    expression: this.resolveType.itemType.expression,
+                    jsType: this.resolveType.itemType.jsTypes[0],
+                },
+                {
+                    expression: code `undefined`,
+                    jsType: { typeof: "undefined" },
+                },
+            ],
+        });
+    }
+    get runtimeClass() {
+        return {
+            name: code `${this.reusables.snippets.LazyOption}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
+            partialPropertyName: "partial",
+            rawName: code `${this.reusables.snippets.LazyOption}`,
+        };
+    }
+    fromJsonExpression(parameters) {
+        return code `${this.partialType.fromJsonExpression(parameters)}.map(partial => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: partial, resolver: (partial) => Promise.resolve(${this.reusables.imports.Left}(new Error(\`unable to resolve \${partial} deserialized from JSON\`))) }))`;
+    }
+    get fromRdfResourceValuesFunction() {
+        return code `\
+(
+    (
+      (values, { objectSet, schema, ...otherOptions }) =>
+        ${this.partialType.fromRdfResourceValuesFunction}(values, { ...otherOptions, objectSet, schema: schema.partialType })
+          .map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (partial, options) => objectSet.${this.resolveType.itemType.objectSetMethodNames.object}(partial.${this.configuration.syntheticNamePrefix}identifier(), options) })))
+    ) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>
+)`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return code `${variables.value}.resolve().then(either => either.unsafeCoerce().extractNullable())`;
+    }
+}
+__decorate([
+    Memoize()
+], LazyOptionType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], LazyOptionType.prototype, "runtimeClass", null);
+__decorate([
+    Memoize()
+], LazyOptionType.prototype, "fromRdfResourceValuesFunction", null);
+//# sourceMappingURL=LazyOptionType.js.map

package/dist/generators/ts/LazySetType.d.ts

@@ -0,0 +1,20 @@
+import { Maybe } from "purify-ts";
+import { AbstractLazyType } from "./AbstractLazyType.js";
+import type { SetType } from "./SetType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class LazySetType extends AbstractLazyType<SetType<AbstractLazyType.ItemTypeConstraint>, SetType<AbstractLazyType.ItemTypeConstraint>> {
+    readonly graphqlArgs: Super["graphqlArgs"];
+    readonly kind = "LazySet";
+    get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
+    protected get runtimeClass(): {
+        name: Code;
+        partialPropertyName: string;
+        rawName: Code;
+    };
+    fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
+    get fromRdfResourceValuesFunction(): Code;
+    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
+}
+type Super = AbstractLazyType<SetType<AbstractLazyType.ItemTypeConstraint>, SetType<AbstractLazyType.ItemTypeConstraint>>;
+export {};
+//# sourceMappingURL=LazySetType.d.ts.map

package/dist/generators/ts/LazySetType.js

@@ -0,0 +1,76 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractLazyType } from "./AbstractLazyType.js";
+import { code } from "./ts-poet-wrapper.js";
+export class LazySetType extends AbstractLazyType {
+    graphqlArgs = Maybe.of({
+        limit: {
+            type: code `${this.reusables.imports.GraphQLInt}`,
+        },
+        offset: {
+            type: code `${this.reusables.imports.GraphQLInt}`,
+        },
+    });
+    kind = "LazySet";
+    get conversionFunction() {
+        invariant(this.jsTypes.length === 1);
+        invariant(this.resolveType.jsTypes.length === 1);
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToLazySet}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            sourceTypes: [
+                {
+                    expression: this.expression,
+                    jsType: this.jsTypes[0],
+                },
+                {
+                    expression: this.resolveType.expression,
+                    jsType: this.resolveType.jsTypes[0],
+                },
+                {
+                    expression: code `undefined`,
+                    jsType: { typeof: "undefined" },
+                },
+            ],
+        });
+    }
+    get runtimeClass() {
+        return {
+            name: code `${this.reusables.snippets.LazySet}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
+            partialPropertyName: "partials",
+            rawName: code `${this.reusables.snippets.LazySet}`,
+        };
+    }
+    fromJsonExpression(parameters) {
+        return code `${this.partialType.fromJsonExpression(parameters)}.map(partials => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: partials, resolver: () => Promise.resolve(${this.reusables.imports.Left}(new Error("unable to resolve partials deserialized from JSON"))) }))`;
+    }
+    get fromRdfResourceValuesFunction() {
+        return code `\
+(
+    (
+      (values, { objectSet, schema, ...otherOptions }) =>
+        ${this.partialType.fromRdfResourceValuesFunction}(values, { ...otherOptions, objectSet, schema: schema.partialType })
+          .map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (partials, options) => objectSet.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers: partials.map(partial => partial.${this.configuration.syntheticNamePrefix}identifier()), ...options }) })))
+    ) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>
+)`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return code `(${variables.value}.resolve({ limit: ${variables.args}.limit, offset: ${variables.args}.offset })).then(either => either.unsafeCoerce())`;
+    }
+}
+__decorate([
+    Memoize()
+], LazySetType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], LazySetType.prototype, "runtimeClass", null);
+__decorate([
+    Memoize()
+], LazySetType.prototype, "fromRdfResourceValuesFunction", null);
+//# sourceMappingURL=LazySetType.js.map

package/dist/generators/ts/LazyType.d.ts

@@ -0,0 +1,19 @@
+import { Maybe } from "purify-ts";
+import { AbstractLazyType } from "./AbstractLazyType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class LazyType extends AbstractLazyType<AbstractLazyType.ItemTypeConstraint, AbstractLazyType.ItemTypeConstraint> {
+    readonly graphqlArgs: Super["graphqlArgs"];
+    readonly kind = "Lazy";
+    get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
+    protected get runtimeClass(): {
+        name: Code;
+        partialPropertyName: string;
+        rawName: Code;
+    };
+    fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
+    get fromRdfResourceValuesFunction(): Code;
+    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
+}
+type Super = AbstractLazyType<AbstractLazyType.ItemTypeConstraint, AbstractLazyType.ItemTypeConstraint>;
+export {};
+//# sourceMappingURL=LazyType.d.ts.map

package/dist/generators/ts/LazyType.js

@@ -0,0 +1,65 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractLazyType } from "./AbstractLazyType.js";
+import { code } from "./ts-poet-wrapper.js";
+export class LazyType extends AbstractLazyType {
+    graphqlArgs = Maybe.empty();
+    kind = "Lazy";
+    get conversionFunction() {
+        invariant(this.jsTypes.length === 1);
+        invariant(this.resolveType.jsTypes.length === 1);
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToLazy}<${this.partialType.expression}, ${this.resolveType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,
+            sourceTypes: [
+                {
+                    expression: this.expression,
+                    jsType: this.jsTypes[0],
+                },
+                {
+                    expression: this.resolveType.expression,
+                    jsType: this.resolveType.jsTypes[0],
+                },
+            ],
+        });
+    }
+    get runtimeClass() {
+        return {
+            name: code `${this.reusables.snippets.Lazy}<${this.partialType.expression}, ${this.resolveType.expression}>`,
+            partialPropertyName: "partial",
+            rawName: code `${this.reusables.snippets.Lazy}`,
+        };
+    }
+    fromJsonExpression(parameters) {
+        return code `${this.partialType.fromJsonExpression(parameters)}.map(partial => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: partial, resolver: (partial) => Promise.resolve(${this.reusables.imports.Left}(new Error(\`unable to resolve \${partial} deserialized from JSON\`))) }))`;
+    }
+    get fromRdfResourceValuesFunction() {
+        return code `\
+(
+    (
+      (values, { objectSet, schema, ...otherOptions }) =>
+        ${this.partialType.fromRdfResourceValuesFunction}(values, { ...otherOptions, objectSet, schema: schema.partialType })
+          .map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (partial, options) => objectSet.${this.resolveType.objectSetMethodNames.object}(partial.${this.configuration.syntheticNamePrefix}identifier(), options) })))
+    ) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>
+)`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return code `${variables.value}.resolve().then(either => either.unsafeCoerce())`;
+    }
+}
+__decorate([
+    Memoize()
+], LazyType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], LazyType.prototype, "runtimeClass", null);
+__decorate([
+    Memoize()
+], LazyType.prototype, "fromRdfResourceValuesFunction", null);
+//# sourceMappingURL=LazyType.js.map

package/dist/generators/ts/ListType.d.ts

@@ -1,4 +1,5 @@
 import type { NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";
@@ -21,20 +22,28 @@ import type { UnionType } from "./UnionType.js";
 export declare class ListType<ItemTypeT extends ListType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     private readonly identifierNodeKind;
     private readonly toRdfTypes;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Array";
+        readonly typeof: "object";
+    }];
     readonly kind = "List";
     constructor({ identifierNodeKind, toRdfTypes, ...superParameters }: {
         identifierNodeKind: ListType<ItemTypeT>["identifierNodeKind"];
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
+    get conversionFunction(): Maybe<AbstractCollectionType.ConversionFunction>;
+    get fromRdfResourceValuesFunction(): Code;
+    get toRdfResourceValueTypes(): AbstractCollectionType<ItemTypeT>["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
-    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
+    fromJsonExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
+    jsonSchema(parameters: Parameters<AbstractCollectionType<ItemTypeT>["jsonSchema"]>[0]): Code;
     jsonType(): AbstractCollectionType.JsonType;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toStringExpression"]>[0]): Code;
 }
 export declare namespace ListType {
-    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LiteralType | ObjectUnionType | ObjectType | StringType | TermType | UnionType<Type>;
+    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | ListType<ListType.ItemType> | LiteralType | ObjectUnionType | ObjectType | StringType | TermType | UnionType<Type>;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map