@shaclmate/compiler 4.0.41 → 4.0.43

package/dist/generators/ts/DefaultValueType.js

@@ -13,8 +13,8 @@ export class DefaultValueType extends AbstractContainerType {
     defaultValue;
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
-    kind = "DefaultValue";
     jsTypes = this.itemType.jsTypes;
+    kind = "DefaultValue";
     validationFunction = this.itemType.validationFunction;
     constructor({ defaultValue, ...superParameters }) {
         super(superParameters);
@@ -44,6 +44,9 @@ export class DefaultValueType extends AbstractContainerType {
     get filterType() {
         return this.itemType.filterType;
     }
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.defaultValueFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
+    }
     get graphqlType() {
         return this.itemType.graphqlType;
     }
@@ -54,7 +57,7 @@ export class DefaultValueType extends AbstractContainerType {
         return this.itemType.mutable;
     }
     get schemaType() {
-        return code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.expression}, ${this.itemType.schemaType}>`;
+        return code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.schemaType}>`;
     }
     get toRdfResourceValueTypes() {
         return this.itemType.toRdfResourceValueTypes;
@@ -66,7 +69,7 @@ export class DefaultValueType extends AbstractContainerType {
         return code `${this.reusables.snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
     get schemaInitializers() {
-        return super.schemaInitializers.concat(code `defaultValue: ${this.defaultValueExpression}`);
+        return super.schemaInitializers.concat(code `defaultValue: ${this.rdfjsTermExpression(this.defaultValue)}`);
     }
     get defaultValueExpression() {
         switch (this.itemType.kind) {
@@ -82,19 +85,11 @@ export class DefaultValueType extends AbstractContainerType {
                 throw new RangeError(`not implemented ${this.itemType.kind}`);
         }
         invariant(this.defaultValue.termType === "Literal");
-        return this.itemType.literalExpression(this.defaultValue);
+        return this.itemType.literalValueExpression(this.defaultValue);
     }
     fromJsonExpression(parameters) {
         return this.itemType.fromJsonExpression(parameters);
     }
-    fromRdfResourceValuesExpression({ variables, }) {
-        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.rdfjsTermExpression(this.defaultValue) }}).toValues())`,
-            },
-        });
-    }
     graphqlResolveExpression(parameters) {
         return this.itemType.graphqlResolveExpression(parameters);
     }
@@ -121,6 +116,9 @@ export class DefaultValueType extends AbstractContainerType {
 __decorate([
     Memoize()
 ], DefaultValueType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], DefaultValueType.prototype, "schemaType", null);

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

@@ -6,8 +6,8 @@ export declare class FloatType extends AbstractNumericType<number> {
         readonly typeof: "number";
     }];
     readonly kind = "Float";
+    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

@@ -11,16 +11,19 @@ import { code } from "./ts-poet-wrapper.js";
 export class FloatType extends AbstractNumericType {
     jsTypes = [{ typeof: "number" }];
     kind = "Float";
+    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/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> {
-    readonly expression: Code;
+    protected readonly inlineExpression: Code;
     readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
     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,7 +10,7 @@ import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class IdentifierType extends AbstractIdentifierType {
-    expression = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
+    inlineExpression = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
     conversionFunction = Maybe.of({
         code: code `${this.reusables.snippets.convertToIdentifier}`,
         sourceTypes: [
@@ -36,6 +36,7 @@ export class IdentifierType extends AbstractIdentifierType {
     });
     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};`;
@@ -71,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

@@ -6,8 +6,8 @@ export declare class IntType extends AbstractNumericType<number> {
         readonly typeof: "number";
     }];
     readonly kind = "Int";
+    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

@@ -11,16 +11,19 @@ import { code } from "./ts-poet-wrapper.js";
 export class IntType extends AbstractNumericType {
     jsTypes = [{ typeof: "number" }];
     kind = "Int";
+    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

@@ -32,11 +32,8 @@ export class IriType extends AbstractIdentifierType {
             ],
         });
     }
-    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) {
@@ -44,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) {
@@ -86,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,35 +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/{LazyObjectOptionType.js → LazyOptionType.js}

@@ -7,18 +7,18 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
+import { AbstractLazyType } from "./AbstractLazyType.js";
 import { code } from "./ts-poet-wrapper.js";
-const Super = (AbstractLazyObjectType);
-export class LazyObjectOptionType extends Super {
+const Super = (AbstractLazyType);
+export class LazyOptionType extends Super {
     graphqlArgs = Maybe.empty();
-    kind = "LazyObjectOption";
+    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.convertToLazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            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,
@@ -41,17 +41,23 @@ export class LazyObjectOptionType extends Super {
     }
     get runtimeClass() {
         return {
-            name: code `${this.reusables.snippets.LazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
+            name: code `${this.reusables.snippets.LazyOption}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
             partialPropertyName: "partial",
-            rawName: code `${this.reusables.snippets.LazyObjectOption}`,
+            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: (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: (partial) => Promise.resolve(${this.reusables.imports.Left}(new Error(\`unable to resolve \${partial} deserialized from JSON\`))) }))`;
     }
-    fromRdfResourceValuesExpression(parameters) {
-        const { variables } = parameters;
-        return code `${this.partialType.fromRdfResourceValuesExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier, options) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.object}(identifier, options) })))`;
+    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())`;
@@ -59,8 +65,11 @@ export class LazyObjectOptionType extends Super {
 }
 __decorate([
     Memoize()
-], LazyObjectOptionType.prototype, "conversionFunction", null);
+], LazyOptionType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
-], LazyObjectOptionType.prototype, "runtimeClass", null);
-//# sourceMappingURL=LazyObjectOptionType.js.map
+], 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/{LazyObjectSetType.js → LazySetType.js}

@@ -7,9 +7,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
+import { AbstractLazyType } from "./AbstractLazyType.js";
 import { code } from "./ts-poet-wrapper.js";
-export class LazyObjectSetType extends AbstractLazyObjectType {
+export class LazySetType extends AbstractLazyType {
     graphqlArgs = Maybe.of({
         limit: {
             type: code `${this.reusables.imports.GraphQLInt}`,
@@ -18,12 +18,12 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
             type: code `${this.reusables.imports.GraphQLInt}`,
         },
     });
-    kind = "LazyObjectSet";
+    kind = "LazySet";
     get conversionFunction() {
         invariant(this.jsTypes.length === 1);
         invariant(this.resolveType.jsTypes.length === 1);
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            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,
@@ -42,17 +42,23 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
     }
     get runtimeClass() {
         return {
-            name: code `${this.reusables.snippets.LazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
+            name: code `${this.reusables.snippets.LazySet}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
             partialPropertyName: "partials",
-            rawName: code `${this.reusables.snippets.LazyObjectSet}`,
+            rawName: code `${this.reusables.snippets.LazySet}`,
         };
     }
     fromJsonExpression(parameters) {
-        return code `${this.partialType.fromJsonExpression(parameters)}.map(partial => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: partial, resolver: () => Promise.resolve(${this.reusables.imports.Left}(new Error("unable to resolve identifiers deserialized from JSON"))) }))`;
+        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"))) }))`;
     }
-    fromRdfResourceValuesExpression(parameters) {
-        const { variables } = parameters;
-        return code `${this.partialType.fromRdfResourceValuesExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifiers, options) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers, ...options }) })))`;
+    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())`;
@@ -60,8 +66,11 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
 }
 __decorate([
     Memoize()
-], LazyObjectSetType.prototype, "conversionFunction", null);
+], LazySetType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
-], LazyObjectSetType.prototype, "runtimeClass", null);
-//# sourceMappingURL=LazyObjectSetType.js.map
+], 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/{LazyObjectType.js → LazyType.js}

@@ -7,16 +7,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
+import { AbstractLazyType } from "./AbstractLazyType.js";
 import { code } from "./ts-poet-wrapper.js";
-export class LazyObjectType extends AbstractLazyObjectType {
+export class LazyType extends AbstractLazyType {
     graphqlArgs = Maybe.empty();
-    kind = "LazyObject";
+    kind = "Lazy";
     get conversionFunction() {
         invariant(this.jsTypes.length === 1);
         invariant(this.resolveType.jsTypes.length === 1);
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.expression}, ${this.resolveType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,
+            code: code `${this.reusables.snippets.convertToLazy}<${this.partialType.expression}, ${this.resolveType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,
             sourceTypes: [
                 {
                     expression: this.expression,
@@ -31,17 +31,23 @@ export class LazyObjectType extends AbstractLazyObjectType {
     }
     get runtimeClass() {
         return {
-            name: code `${this.reusables.snippets.LazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.expression}, ${this.resolveType.expression}>`,
+            name: code `${this.reusables.snippets.Lazy}<${this.partialType.expression}, ${this.resolveType.expression}>`,
             partialPropertyName: "partial",
-            rawName: code `${this.reusables.snippets.LazyObject}`,
+            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: (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: (partial) => Promise.resolve(${this.reusables.imports.Left}(new Error(\`unable to resolve \${partial} deserialized from JSON\`))) }))`;
     }
-    fromRdfResourceValuesExpression(parameters) {
-        const { variables } = parameters;
-        return code `${this.partialType.fromRdfResourceValuesExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier, options) => ${variables.objectSet}.${this.resolveType.objectSetMethodNames.object}(identifier, options) })))`;
+    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())`;
@@ -49,8 +55,11 @@ export class LazyObjectType extends AbstractLazyObjectType {
 }
 __decorate([
     Memoize()
-], LazyObjectType.prototype, "conversionFunction", null);
+], LazyType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
-], LazyObjectType.prototype, "runtimeClass", null);
-//# sourceMappingURL=LazyObjectType.js.map
+], LazyType.prototype, "runtimeClass", null);
+__decorate([
+    Memoize()
+], LazyType.prototype, "fromRdfResourceValuesFunction", null);
+//# sourceMappingURL=LazyType.js.map

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

@@ -32,11 +32,11 @@ export declare class ListType<ItemTypeT extends ListType.ItemType> extends Abstr
         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;
     fromJsonExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
-    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     jsonSchema(parameters: Parameters<AbstractCollectionType<ItemTypeT>["jsonSchema"]>[0]): Code;
     jsonType(): AbstractCollectionType.JsonType;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;

package/dist/generators/ts/ListType.js

@@ -33,6 +33,9 @@ export class ListType extends AbstractCollectionType {
             ],
         });
     }
+    get fromRdfResourceValuesFunction() {
+        return code `${this._mutable ? this.reusables.snippets.mutableListFromRdfResourceValues : this.reusables.snippets.listFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
+    }
     get toRdfResourceValueTypes() {
         return new Set(["BlankNode", "NamedNode"]); // List or rdf:nil
     }
@@ -47,22 +50,6 @@ export class ListType extends AbstractCollectionType {
             variables: { value: code `item` },
         })})))`;
     }
-    fromRdfResourceValuesExpression({ variables, }) {
-        return joinCode([
-            variables.resourceValues,
-            code `chain(values => values.chainMap(value => value.toList(${{ graph: variables.graph }})))`, // Resource.Values<Resource.Value> to Resource.Values<Resource.Values>
-            code `chain(valueLists =>
-        valueLists.chainMap(
-          valueList => ${this.itemType.fromRdfResourceValuesExpression({
-                variables: {
-                    ...variables,
-                    resourceValues: code `${this.reusables.imports.Right}(${this.reusables.imports.Resource}.Values.fromArray({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, values: valueList.toArray() }))`,
-                },
-            })}
-      ))`, // Resource.Values<Resource.Values> to Resource.Values<item type arrays>
-            code `map(valueLists => valueLists.map(valueList => valueList.toArray()${this.mutable ? ".concat()" : ""}))`, // Convert inner Resource.Values to arrays
-        ], { on: "." });
-    }
     jsonSchema(parameters) {
         let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
         if (!this._mutable) {
@@ -124,6 +111,9 @@ export class ListType extends AbstractCollectionType {
 __decorate([
     Memoize()
 ], ListType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], ListType.prototype, "toRdfResourceValueTypes", null);
@@ -158,9 +148,9 @@ __decorate([
             case "Union":
                 return true;
             case "DefaultValue":
-            case "LazyObjectOption":
-            case "LazyObjectSet":
-            case "LazyObject":
+            case "LazyOption":
+            case "LazySet":
+            case "Lazy":
             case "Option":
             case "Set":
                 return false;