@shaclmate/compiler 4.0.93 → 4.0.95

package/dist/generators/ts/IriType.js

@@ -8,14 +8,47 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import { InlineCallable } from "./InlineCallable.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { arrayOf, code, joinCode, literalOf, } from "./ts-poet-wrapper.js";
 export class IriType extends AbstractIdentifierType {
-    filterFunction = code `${this.reusables.snippets.filterIri}`;
+    filterFunction = new ReferenceCallable(this.reusables.snippets.filterIri);
     filterType = code `${this.reusables.snippets.IriFilter}`;
     kind = "Iri";
     nodeKinds = nodeKinds;
     schemaType = code `${this.reusables.snippets.IriSchema}<${this.valueTypeExpression}>`;
-    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.iriSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.iriSparqlWherePatterns);
+    get fromJsonValueFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.iriFromJsonString}<${this.valueTypeExpression}>`);
+    }
+    get fromJsonObjectFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.iriFromJsonObject}<${this.valueTypeExpression}>`);
+    }
+    get toJsonValueFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.iriToJsonString}<${this.valueTypeExpression}>`);
+    }
+    get toJsonObjectFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.iriToJsonObject}<${this.valueTypeExpression}>`);
+    }
+    get jsonValueType() {
+        if (this.in_.length === 0) {
+            return super.jsonValueType;
+        }
+        return this.jsonTypeFactory.createJsonStringType({
+            in_: this.in_.map((in_) => in_.value),
+            inReference: this.name.isJust() && this.configuration.features.has("Object.schema")
+                ? code `${this.name.extract()}.schema.in.map(_ => _.value)`
+                : undefined,
+        });
+    }
+    get jsonObjectType() {
+        if (this.in_.length === 0) {
+            return super.jsonObjectType;
+        }
+        return this.jsonTypeFactory.createJsonObjectType({
+            "@id": { type: this.jsonValueType },
+        });
+    }
     get conversionFunction() {
         invariant(this.jsTypes.length === 1);
         return Maybe.of({
@@ -37,13 +70,13 @@ export class IriType extends AbstractIdentifierType {
         });
     }
     get fromRdfResourceValuesFunction() {
-        return code `${this.reusables.snippets.iriFromRdfResourceValues}<${this.valueTypeExpression}>`;
+        return new ReferenceCallable(code `${this.reusables.snippets.iriFromRdfResourceValues}<${this.valueTypeExpression}>`);
     }
     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.expression});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
+            return new InlineCallable(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.expression});`))} 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}`;
+        return new ReferenceCallable(this.reusables.snippets.parseIri);
     }
     get inlineExpression() {
         if (this.in_.length > 0) {
@@ -87,42 +120,25 @@ export class IriType extends AbstractIdentifierType {
             .map((name) => code `${name}["value"]`)
             .orDefaultLazy(() => this.inlineValueTypeExpression);
     }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
-    }
-    jsonSchema({ includeDiscriminantProperty, }) {
-        let idSchema;
-        if (this.in_.length > 0) {
-            const name = this.name.extract();
-            if (name && this.configuration.features.has("Object.schema")) {
-                // Reuse the type from schema to cut down code
-                idSchema = code `${this.reusables.imports.z}.enum(${name}.schema.in.map(_ => _.value))`;
-            }
-            else {
-                idSchema = code `${this.reusables.imports.z}.enum(${arrayOf(...this.in_.map((iri) => iri.value))})`;
-            }
-        }
-        else {
-            idSchema = code `${this.reusables.imports.z}.string().min(1)`;
-        }
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${this.reusables.imports.z}.literal("NamedNode")`
-            : "";
-        return code `${this.reusables.imports.z}.object({ "@id": ${idSchema}${discriminantProperty} })`;
-    }
-    jsonType(parameters) {
-        const discriminantProperty = parameters?.includeDiscriminantProperty
-            ? `, readonly termType: "NamedNode"`
-            : "";
-        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": ${this.valueTypeExpression}${discriminantProperty} }`);
-    }
-    toJsonExpression({ includeDiscriminantProperty, variables, }) {
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${variables.value}.termType`
-            : "";
-        return code `{ "@id": ${variables.value}.value${discriminantProperty} }`;
-    }
 }
+__decorate([
+    Memoize()
+], IriType.prototype, "fromJsonValueFunction", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "fromJsonObjectFunction", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "toJsonValueFunction", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "toJsonObjectFunction", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "jsonValueType", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "jsonObjectType", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "conversionFunction", null);
@@ -141,8 +157,5 @@ __decorate([
 __decorate([
     Memoize()
 ], IriType.prototype, "valueTypeExpression", null);
-__decorate([
-    Memoize()
-], IriType.prototype, "jsonType", null);
 const nodeKinds = new Set(["IRI"]);
 //# sourceMappingURL=IriType.js.map

package/dist/generators/ts/LangStringType.d.ts

@@ -1,31 +1,36 @@
 import type { Literal } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LangStringType extends AbstractLiteralType {
     private readonly languageIn;
     protected readonly inlineExpression: Code;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
-    readonly filterFunction: Code;
+    readonly filterFunction: ReferenceCallable;
     readonly filterType: Code;
-    readonly fromRdfResourceValuesFunction: Code;
+    readonly fromJsonObjectFunction: ReferenceCallable;
+    readonly fromJsonValueFunction: ReferenceCallable;
+    readonly fromRdfResourceValuesFunction: ReferenceCallable;
     readonly jsTypes: readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
     }];
+    readonly jsonObjectType: AbstractLiteralType["jsonObjectType"];
+    readonly jsonValueType: AbstractLiteralType["jsonValueType"];
     readonly kind = "LangString";
     readonly schemaType: Code;
-    readonly valueSparqlWherePatternsFunction: Code;
+    readonly toJsonObjectFunction: ReferenceCallable;
+    readonly toJsonValueFunction: ReferenceCallable;
+    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
     constructor({ languageIn, ...superParameters }: {
         languageIn: readonly string[];
     } & ConstructorParameters<typeof AbstractLiteralType>[0]);
+    get discriminatedType(): Maybe<AbstractLiteralType.DiscriminatedType>;
     get graphqlType(): AbstractLiteralType.GraphqlType;
     protected get schemaInitializers(): readonly Code[];
-    fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
-    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonSchema"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractLiteralType["jsonType"]>[0]): AbstractLiteralType.JsonType;
+    toLoggableExpression({ variables, }: Parameters<AbstractLiteralType["toLoggableExpression"]>[0]): Code;
     valueExpression(literal: Literal): Code;
-    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=LangStringType.d.ts.map

package/dist/generators/ts/LangStringType.js

@@ -1,5 +1,13 @@
+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 { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class LangStringType extends AbstractLiteralType {
     languageIn;
@@ -13,19 +21,40 @@ export class LangStringType extends AbstractLiteralType {
             },
         ],
     });
-    filterFunction = code `${this.reusables.snippets.filterLiteral}`;
+    filterFunction = new ReferenceCallable(this.reusables.snippets.filterLiteral);
     filterType = code `${this.reusables.snippets.LiteralFilter}`;
-    fromRdfResourceValuesFunction = code `${this.reusables.snippets.langStringFromRdfResourceValues}`;
+    fromJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.langStringFromJsonObject);
+    fromJsonValueFunction = this.fromJsonObjectFunction;
+    fromRdfResourceValuesFunction = new ReferenceCallable(this.reusables.snippets.langStringFromRdfResourceValues);
     jsTypes = [
         { instanceof: "Object", typeof: "object" },
     ];
+    jsonObjectType = this.jsonTypeFactory.createJsonObjectType({
+        "@language": {
+            type: this.jsonTypeFactory.createJsonStringType({ minLength: 1n }),
+        },
+        "@value": { type: this.jsonTypeFactory.createJsonStringType() },
+    }, { snippet: this.reusables.snippets.LangStringJsonObject });
+    jsonValueType = this.jsonObjectType;
     kind = "LangString";
     schemaType = code `${this.reusables.snippets.LangStringSchema}`;
-    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.langStringSparqlWherePatterns}`;
+    toJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.langStringToJsonObject);
+    toJsonValueFunction = this.toJsonObjectFunction;
+    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.langStringSparqlWherePatterns);
     constructor({ languageIn, ...superParameters }) {
         super(superParameters);
         this.languageIn = languageIn;
     }
+    get discriminatedType() {
+        return Maybe.of({
+            discriminantProperty: {
+                jsonName: "termType",
+                name: "termType",
+                values: [...this.termTypes],
+            },
+            expression: this.expression,
+        });
+    }
     get graphqlType() {
         throw new Error("not implemented");
     }
@@ -36,29 +65,17 @@ export class LangStringType extends AbstractLiteralType {
         }
         return initializers;
     }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"]))`;
-    }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
     }
-    jsonSchema({ includeDiscriminantProperty, }) {
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${this.reusables.imports.z}.literal("Literal")`
-            : "";
-        return code `${this.reusables.imports.z}.object({ "@language": ${this.reusables.imports.z}.string()${discriminantProperty}, "@value": ${this.reusables.imports.z}.string() })`;
-    }
-    jsonType(parameters) {
-        const discriminantProperty = parameters?.includeDiscriminantProperty
-            ? `, readonly termType: "Literal"`
-            : "";
-        return new AbstractLiteralType.JsonType(code `{ readonly "@language": string${discriminantProperty}, readonly "@value": string }`);
+    toLoggableExpression({ variables, }) {
+        return code `\`\${JSON.stringify(${variables.value}.value)}@\${${variables.value}.language}\``;
     }
     valueExpression(literal) {
         return this.rdfjsTermExpression(literal);
     }
-    toJsonExpression({ includeDiscriminantProperty, variables, }) {
-        return code `{ "@language": ${variables.value}.language${includeDiscriminantProperty ? `, "termType": "Literal" as const` : ""}, "@value": ${variables.value}.value }`;
-    }
 }
+__decorate([
+    Memoize()
+], LangStringType.prototype, "discriminatedType", null);
 //# sourceMappingURL=LangStringType.js.map

package/dist/generators/ts/LazyOptionType.d.ts

@@ -2,26 +2,10 @@ import { Maybe } from "purify-ts";
 import { AbstractLazyType } from "./AbstractLazyType.js";
 import type { OptionType } from "./OptionType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-type Super = AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>;
-declare const Super: (abstract new ({ partialType, resolveType, ...superParameters }: {
-    partialType: OptionType<AbstractLazyType.ItemTypeConstraint>;
-    resolveType: OptionType<AbstractLazyType.ItemTypeConstraint>;
-} & {
-    name: Maybe<string>;
-    comment: Maybe<string>;
-    configuration: import("./TsGenerator.js").TsGenerator.Configuration;
-    label: Maybe<string>;
-    logger: import("@rdfx/logger").Logger;
-    reusables: import("./Reusables.js").Reusables;
-    shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode;
-}) => AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>) & {
-    readonly GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    readonly JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
-    ConversionFunction: typeof import("./AbstractType.js").AbstractType.ConversionFunction;
-    readonly JsType: typeof import("./_AbstractType/AbstractType_JsType.js").AbstractType_JsType;
-};
-export declare class LazyOptionType extends Super {
-    readonly graphqlArgs: Super["graphqlArgs"];
+export declare class LazyOptionType extends AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>> {
+    protected readonly partialItemType: AbstractLazyType.ItemTypeConstraint;
+    protected readonly resolveItemType: AbstractLazyType.ItemTypeConstraint;
+    readonly graphqlArgs: AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>["graphqlArgs"];
     readonly kind = "LazyOption";
     get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
     protected get runtimeClass(): {
@@ -29,9 +13,11 @@ export declare class LazyOptionType extends Super {
         partialPropertyName: string;
         rawName: Code;
     };
-    fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
-    get fromRdfResourceValuesFunction(): Code;
-    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
+    protected objectSetResolverFunctionExpressions({ variables, }: {
+        variables: {
+            objectSet: Code;
+        };
+    }): Code;
+    graphqlResolveExpression({ variables, }: Parameters<AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>["graphqlResolveExpression"]>[0]): Code;
 }
-export {};
 //# sourceMappingURL=LazyOptionType.d.ts.map

package/dist/generators/ts/LazyOptionType.js

@@ -9,8 +9,9 @@ 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 {
+export class LazyOptionType extends AbstractLazyType {
+    partialItemType = this.partialType.itemType;
+    resolveItemType = this.resolveType.itemType;
     graphqlArgs = Maybe.empty();
     kind = "LazyOption";
     get conversionFunction() {
@@ -23,7 +24,6 @@ ${this.reusables.snippets.convertToLazyOption}<
   ${this.partialType.itemType.expression},
   ${this.resolveType.itemType.expression},
 >(
-  ${this.partialType.itemType.typeGuardFunction.unsafeCoerce()},
   ${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })}
 )`,
             sourceTypes: [
@@ -31,18 +31,10 @@ ${this.reusables.snippets.convertToLazyOption}<
                     expression: this.expression,
                     jsType: this.jsTypes[0],
                 },
-                {
-                    expression: this.partialType.expression,
-                    jsType: this.partialType.jsTypes[0],
-                },
                 {
                     expression: this.resolveType.expression,
                     jsType: this.resolveType.jsTypes[0],
                 },
-                {
-                    expression: this.partialType.itemType.expression,
-                    jsType: this.resolveType.itemType.jsTypes[0],
-                },
                 {
                     expression: this.resolveType.itemType.expression,
                     jsType: this.resolveType.itemType.jsTypes[0],
@@ -61,18 +53,8 @@ ${this.reusables.snippets.convertToLazyOption}<
             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}>
-)`;
+    objectSetResolverFunctionExpressions({ variables, }) {
+        return code `(partial, options) => ${variables.objectSet}.${this.resolveItemType.objectSetMethodNames.object}(partial.${this.partialItemType.identifierProperty.unsafeCoerce().name}(), options)`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce().extractNullable())`;
@@ -84,7 +66,4 @@ __decorate([
 __decorate([
     Memoize()
 ], LazyOptionType.prototype, "runtimeClass", null);
-__decorate([
-    Memoize()
-], LazyOptionType.prototype, "fromRdfResourceValuesFunction", null);
 //# sourceMappingURL=LazyOptionType.js.map

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

@@ -3,16 +3,21 @@ 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>> {
+    protected readonly partialItemType: AbstractLazyType.ItemTypeConstraint;
+    protected readonly resolveItemType: AbstractLazyType.ItemTypeConstraint;
     readonly graphqlArgs: Super["graphqlArgs"];
     readonly kind = "LazySet";
     get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
+    protected objectSetResolverFunctionExpressions({ variables, }: {
+        variables: {
+            objectSet: Code;
+        };
+    }): Code;
     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>>;

package/dist/generators/ts/LazySetType.js

@@ -10,6 +10,8 @@ import { Memoize } from "typescript-memoize";
 import { AbstractLazyType } from "./AbstractLazyType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class LazySetType extends AbstractLazyType {
+    partialItemType = this.partialType.itemType;
+    resolveItemType = this.resolveType.itemType;
     graphqlArgs = Maybe.of({
         limit: {
             type: code `${this.reusables.imports.GraphQLInt}`,
@@ -28,7 +30,6 @@ ${this.reusables.snippets.convertToLazySet}<
   ${this.partialType.itemType.expression},
   ${this.resolveType.itemType.expression}
 >(
-  ${this.partialType.itemType.typeGuardFunction.unsafeCoerce()},
   ${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })}
 )`,
             sourceTypes: [
@@ -36,18 +37,10 @@ ${this.reusables.snippets.convertToLazySet}<
                     expression: this.expression,
                     jsType: this.jsTypes[0],
                 },
-                {
-                    expression: this.partialType.expression,
-                    jsType: this.partialType.jsTypes[0],
-                },
                 {
                     expression: this.resolveType.expression,
                     jsType: this.resolveType.jsTypes[0],
                 },
-                {
-                    expression: this.partialType.itemType.expression,
-                    jsType: this.partialType.itemType.jsTypes[0],
-                },
                 {
                     expression: this.resolveType.itemType.expression,
                     jsType: this.resolveType.itemType.jsTypes[0],
@@ -59,6 +52,9 @@ ${this.reusables.snippets.convertToLazySet}<
             ],
         });
     }
+    objectSetResolverFunctionExpressions({ variables, }) {
+        return code `(partials, options) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers: partials.map(partial => partial.${this.partialItemType.identifierProperty.unsafeCoerce().name}()), ...options })`;
+    }
     get runtimeClass() {
         return {
             name: code `${this.reusables.snippets.LazySet}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
@@ -66,19 +62,6 @@ ${this.reusables.snippets.convertToLazySet}<
             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())`;
     }
@@ -89,7 +72,4 @@ __decorate([
 __decorate([
     Memoize()
 ], LazySetType.prototype, "runtimeClass", null);
-__decorate([
-    Memoize()
-], LazySetType.prototype, "fromRdfResourceValuesFunction", null);
 //# sourceMappingURL=LazySetType.js.map

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

@@ -2,6 +2,8 @@ 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> {
+    protected readonly partialItemType: AbstractLazyType.ItemTypeConstraint;
+    protected readonly resolveItemType: AbstractLazyType.ItemTypeConstraint;
     readonly graphqlArgs: Super["graphqlArgs"];
     readonly kind = "Lazy";
     get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
@@ -10,9 +12,12 @@ export declare class LazyType extends AbstractLazyType<AbstractLazyType.ItemType
         partialPropertyName: string;
         rawName: Code;
     };
-    fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
-    get fromRdfResourceValuesFunction(): Code;
     graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
+    protected objectSetResolverFunctionExpressions({ variables, }: {
+        variables: {
+            objectSet: Code;
+        };
+    }): Code;
 }
 type Super = AbstractLazyType<AbstractLazyType.ItemTypeConstraint, AbstractLazyType.ItemTypeConstraint>;
 export {};

package/dist/generators/ts/LazyType.js

@@ -10,6 +10,8 @@ import { Memoize } from "typescript-memoize";
 import { AbstractLazyType } from "./AbstractLazyType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class LazyType extends AbstractLazyType {
+    partialItemType = this.partialType;
+    resolveItemType = this.resolveType;
     graphqlArgs = Maybe.empty();
     kind = "Lazy";
     get conversionFunction() {
@@ -21,7 +23,6 @@ ${this.reusables.snippets.convertToLazy}<
   ${this.partialType.expression},
   ${this.resolveType.expression}
 >(
-  ${this.partialType.typeGuardFunction.unsafeCoerce()},
   ${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })}
 )`,
             sourceTypes: [
@@ -29,10 +30,6 @@ ${this.reusables.snippets.convertToLazy}<
                     expression: this.expression,
                     jsType: this.jsTypes[0],
                 },
-                {
-                    expression: this.partialType.expression,
-                    jsType: this.partialType.jsTypes[0],
-                },
                 {
                     expression: this.resolveType.expression,
                     jsType: this.resolveType.jsTypes[0],
@@ -47,22 +44,12 @@ ${this.reusables.snippets.convertToLazy}<
             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())`;
     }
+    objectSetResolverFunctionExpressions({ variables, }) {
+        return code `(partial, options) => ${variables.objectSet}.${this.resolveItemType.objectSetMethodNames.object}(partial.${this.partialItemType.identifierProperty.unsafeCoerce().name}(), options)`;
+    }
 }
 __decorate([
     Memoize()
@@ -70,7 +57,4 @@ __decorate([
 __decorate([
     Memoize()
 ], LazyType.prototype, "runtimeClass", null);
-__decorate([
-    Memoize()
-], LazyType.prototype, "fromRdfResourceValuesFunction", null);
 //# sourceMappingURL=LazyType.js.map

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

@@ -5,6 +5,7 @@ import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { BooleanType } from "./BooleanType.js";
+import type { Callable } from "./Callable.js";
 import type { DateTimeType } from "./DateTimeType.js";
 import type { DateType } from "./DateType.js";
 import type { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
@@ -15,6 +16,7 @@ import type { IriType } from "./IriType.js";
 import type { LangStringType } from "./LangStringType.js";
 import type { LiteralType } from "./LiteralType.js";
 import type { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
+import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
@@ -32,19 +34,22 @@ export declare class ListType<ItemTypeT extends ListType.ItemType> extends Abstr
         identifierNodeKind: ListType<ItemTypeT>["identifierNodeKind"];
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
+    get jsonValueType(): AbstractCollectionType<ItemTypeT>["jsonValueType"];
     get conversionFunction(): Maybe<AbstractCollectionType.ConversionFunction>;
-    get fromRdfResourceValuesFunction(): Code;
+    get jsonObjectType(): AbstractCollectionType<ItemTypeT>["jsonObjectType"];
+    get fromJsonValueFunction(): AbstractCollectionType<ItemTypeT>["fromJsonValueFunction"];
+    get fromJsonObjectFunction(): AbstractCollectionType<ItemTypeT>["fromJsonObjectFunction"];
+    get fromRdfResourceValuesFunction(): Callable;
+    get toJsonValueFunction(): AbstractCollectionType<ItemTypeT>["toJsonValueFunction"];
+    get toJsonObjectFunction(): AbstractCollectionType<ItemTypeT>["toJsonObjectFunction"];
     get toRdfResourceValueTypes(): AbstractCollectionType<ItemTypeT>["toRdfResourceValueTypes"];
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
-    fromJsonExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
-    jsonSchema(parameters: Parameters<AbstractCollectionType<ItemTypeT>["jsonSchema"]>[0]): Code;
-    jsonType(): AbstractCollectionType.JsonType;
+    get valueSparqlConstructTriplesFunction(): Callable;
+    get valueSparqlWherePatternsFunction(): Callable;
     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 | DiscriminatedUnionType | FloatType | IdentifierType | IntType | IriType | LangStringType | ListType<ListType.ItemType> | LiteralType | ObjectDiscriminatedUnionType | ObjectType | StringType | TermType;
+    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DiscriminatedUnionType | FloatType | IdentifierType | IntType | IriType | LangStringType | ListType<ListType.ItemType> | LiteralType | ObjectDiscriminatedUnionType | ObjectIntersectionType | ObjectType | StringType | TermType;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map