@shaclmate/compiler 4.0.40 → 4.0.41

package/dist/generators/ts/LazyObjectType.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 { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import { code } from "./ts-poet-wrapper.js";
@@ -12,16 +13,18 @@ export class LazyObjectType extends AbstractLazyObjectType {
     graphqlArgs = Maybe.empty();
     kind = "LazyObject";
     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 })})`,
             sourceTypes: [
                 {
                     expression: this.expression,
-                    typeof: "object",
+                    jsType: this.jsTypes[0],
                 },
                 {
                     expression: this.resolveType.expression,
-                    typeof: "object",
+                    jsType: this.resolveType.jsTypes[0],
                 },
             ],
         });

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 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;
     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

package/dist/generators/ts/ListType.js

@@ -5,24 +5,48 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class ListType extends AbstractCollectionType {
     identifierNodeKind;
     toRdfTypes;
+    jsTypes = [
+        { instanceof: "Array", typeof: "object" },
+    ];
     kind = "List";
     constructor({ identifierNodeKind, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.identifierNodeKind = identifierNodeKind;
         this.toRdfTypes = toRdfTypes;
     }
+    get conversionFunction() {
+        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToList}(${itemConversionFunction.code}, ${literalOf(!this._mutable)})`,
+            sourceTypes: [
+                {
+                    expression: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.expression}`), { on: " | " })})[]`,
+                    jsType: { instanceof: "Array", typeof: "object" },
+                },
+            ],
+        });
+    }
+    get toRdfResourceValueTypes() {
+        return new Set(["BlankNode", "NamedNode"]); // List or rdf:nil
+    }
     get valueSparqlConstructTriplesFunction() {
         return code `${this.reusables.snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
+    fromJsonExpression({ variables, }) {
+        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.expression}>(${variables.value}.map(item => (${this.itemType.fromJsonExpression({
+            variables: { value: code `item` },
+        })})))`;
+    }
     fromRdfResourceValuesExpression({ variables, }) {
         return joinCode([
             variables.resourceValues,
@@ -39,22 +63,29 @@ export class ListType extends AbstractCollectionType {
             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) {
+            schema = code `${schema}.readonly()`;
+        }
+        return schema;
+    }
     jsonType() {
-        return new AbstractCollectionType.JsonType(code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`);
+        return new AbstractCollectionType.JsonType(code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().expression})[]`);
     }
     toRdfResourceValuesExpression({ variables, }) {
         let mintListIdentifierFunction;
         let mintSubListIdentifierFunction;
-        let resourceTypeName;
+        let resourceTypeExpression;
         switch (this.identifierNodeKind) {
             case "BlankNode": {
                 mintListIdentifierFunction =
                     mintSubListIdentifierFunction = code `(() => ${this.reusables.imports.dataFactory}.blankNode())`;
-                resourceTypeName = code `${this.reusables.imports.Resource}<${this.reusables.imports.BlankNode}>`;
+                resourceTypeExpression = code `${this.reusables.imports.Resource}<${this.reusables.imports.BlankNode}>`;
                 break;
             }
             case "IRI": {
-                resourceTypeName = code `${this.reusables.imports.Resource}<${this.reusables.imports.NamedNode}>`;
+                resourceTypeExpression = code `${this.reusables.imports.Resource}<${this.reusables.imports.NamedNode}>`;
                 throw new RangeError("list IRI minting is unsupported");
             }
         }
@@ -81,8 +112,8 @@ export class ListType extends AbstractCollectionType {
     currentSubListResource: null,
     listResource: ${variables.resourceSet}.resource(${mintListIdentifierFunction}()),
   } as {
-    currentSubListResource: ${resourceTypeName} | null;
-    listResource: ${resourceTypeName};
+    currentSubListResource: ${resourceTypeExpression} | null;
+    listResource: ${resourceTypeExpression};
   },
 ).listResource.identifier : ${this.rdfjsTermExpression(rdf.nil)}]`;
     }
@@ -90,6 +121,12 @@ export class ListType extends AbstractCollectionType {
         return code `\`[\${${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })}))}]\``;
     }
 }
+__decorate([
+    Memoize()
+], ListType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "toRdfResourceValueTypes", null);
 __decorate([
     Memoize()
 ], ListType.prototype, "valueSparqlConstructTriplesFunction", null);
@@ -112,6 +149,7 @@ __decorate([
             case "Identifier":
             case "Iri":
             case "Int":
+            case "List":
             case "Literal":
             case "ObjectUnion":
             case "Object":
@@ -123,7 +161,6 @@ __decorate([
             case "LazyObjectOption":
             case "LazyObjectSet":
             case "LazyObject":
-            case "List":
             case "Option":
             case "Set":
                 return false;

package/dist/generators/ts/LiteralType.d.ts

@@ -7,6 +7,10 @@ export declare class LiteralType extends AbstractLiteralType {
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
     readonly kind = "Literal";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;

package/dist/generators/ts/LiteralType.js

@@ -9,20 +9,23 @@ export class LiteralType extends AbstractLiteralType {
         sourceTypes: [
             ...["bigint", "boolean", "number", "string"].map((typeof_) => ({
                 expression: code `${typeof_}`,
-                typeof: typeof_,
+                jsType: { typeof: typeof_ },
             })),
             {
                 expression: code `Date`,
-                typeof: "object",
+                jsType: { instanceof: "Date", typeof: "object" },
             },
             {
                 expression: code `${this.reusables.imports.Literal}`,
-                typeof: "object",
+                jsType: { instanceof: "Object", typeof: "object" },
             },
         ],
     });
     filterFunction = code `${this.reusables.snippets.filterLiteral}`;
     filterType = code `${this.reusables.snippets.LiteralFilter}`;
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
     kind = "Literal";
     schemaType = code `${this.reusables.snippets.LiteralSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.literalSparqlWherePatterns}`;

package/dist/generators/ts/ObjectType.d.ts

@@ -13,41 +13,33 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class ObjectType extends AbstractType {
     protected readonly toRdfTypes: readonly NamedNode[];
     readonly conversionFunction: Maybe<AbstractType.ConversionFunction>;
+    readonly discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
     readonly extern: boolean;
     readonly fromRdfType: Maybe<NamedNode>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
     readonly kind = "Object";
     readonly recursive: boolean;
     readonly referencesObjectType = true;
     readonly synthetic: boolean;
-    readonly typeofs: "object"[];
     readonly validationFunction: Maybe<Code>;
-    constructor({ extern, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }: {
+    constructor({ discriminantProperty, extern, fromRdfType, identifierType, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }: {
+        discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
         comment: Maybe<string>;
         extern: boolean;
         fromRdfType: Maybe<NamedNode>;
         identifierType: BlankNodeType | IdentifierType | IriType;
         label: Maybe<string>;
-        lazyAncestorObjectTypes: () => readonly ObjectType[];
-        lazyChildObjectTypes: () => readonly ObjectType[];
-        lazyDiscriminantProperty: (namedObjectType: ObjectType) => ObjectType.DiscriminantProperty;
-        lazyDescendantObjectTypes: () => readonly ObjectType[];
-        lazyParentObjectTypes: () => readonly ObjectType[];
-        lazyProperties: (namedObjectType: ObjectType) => readonly ObjectType.Property[];
+        lazyProperties: (objectType: ObjectType) => readonly ObjectType.Property[];
         recursive: boolean;
         synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get _discriminantProperty(): ObjectType.DiscriminantProperty;
-    get ancestorObjectTypes(): readonly ObjectType[];
-    get childObjectTypes(): readonly ObjectType[];
     get declaration(): Maybe<Code>;
-    get descendantFromRdfTypeVariables(): readonly Code[];
-    get descendantFromRdfTypes(): readonly NamedNode[];
-    get descendantObjectTypes(): readonly ObjectType[];
-    get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
-    get discriminantValue(): string;
     get equalsFunction(): Code;
     get expression(): Code;
     get filterFunction(): Code;
@@ -58,7 +50,6 @@ export declare class ObjectType extends AbstractType {
     get identifierTypeAlias(): Code;
     get mutable(): boolean;
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
-    get parentObjectTypes(): readonly ObjectType[];
     get properties(): readonly ObjectType.Property[];
     get schema(): Code;
     get schemaType(): Code;
@@ -80,11 +71,6 @@ export declare class ObjectType extends AbstractType {
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-    private readonly lazyAncestorObjectTypes;
-    private readonly lazyChildObjectTypes;
-    private readonly lazyDescendantObjectTypes;
-    private readonly lazyDiscriminantProperty;
-    private readonly lazyParentObjectTypes;
     private readonly lazyProperties;
 }
 export declare namespace ObjectType {

package/dist/generators/ts/ObjectType.js

@@ -44,41 +44,31 @@ import { code, def, joinCode } from "./ts-poet-wrapper.js";
 export class ObjectType extends AbstractType {
     toRdfTypes;
     conversionFunction = Maybe.empty();
+    discriminantProperty;
     extern;
     fromRdfType;
     graphqlArgs = Maybe.empty();
     identifierType;
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
     kind = "Object";
     recursive;
     referencesObjectType = true;
     synthetic;
-    typeofs = ["object"];
     validationFunction = Maybe.empty();
-    constructor({ extern, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }) {
+    constructor({ discriminantProperty, extern, fromRdfType, identifierType, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }) {
         super(superParameters);
+        this.discriminantProperty = discriminantProperty;
         this.extern = extern;
         this.fromRdfType = fromRdfType;
         this.identifierType = identifierType;
         // Lazily initialize some members in getters to avoid recursive construction
-        this.lazyAncestorObjectTypes = lazyAncestorObjectTypes;
-        this.lazyChildObjectTypes = lazyChildObjectTypes;
-        this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
-        this.lazyDiscriminantProperty = lazyDiscriminantProperty;
-        this.lazyParentObjectTypes = lazyParentObjectTypes;
         this.lazyProperties = lazyProperties;
         this.recursive = recursive;
         this.synthetic = synthetic;
         this.toRdfTypes = toRdfTypes;
     }
-    get _discriminantProperty() {
-        return this.lazyDiscriminantProperty(this);
-    }
-    get ancestorObjectTypes() {
-        return this.lazyAncestorObjectTypes();
-    }
-    get childObjectTypes() {
-        return this.lazyChildObjectTypes();
-    }
     get declaration() {
         const alias = this.alias.extract();
         if (!alias) {
@@ -123,26 +113,6 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         }
         return Maybe.of(joinCode(declarations, { on: "\n\n" }));
     }
-    get descendantFromRdfTypeVariables() {
-        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfTypeVariable.toList());
-    }
-    get descendantFromRdfTypes() {
-        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfType.toList());
-    }
-    get descendantObjectTypes() {
-        return this.lazyDescendantObjectTypes();
-    }
-    get discriminantProperty() {
-        return Maybe.of({
-            jsonName: this._discriminantProperty.jsonName,
-            name: this._discriminantProperty.name,
-            ownValues: this._discriminantProperty.type.ownValues,
-            descendantValues: this._discriminantProperty.type.descendantValues,
-        });
-    }
-    get discriminantValue() {
-        return this.alias.unsafeCoerce();
-    }
     get equalsFunction() {
         return code `${this.alias.unsafeCoerce()}.equals`;
     }
@@ -176,9 +146,6 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
             configuration: this.configuration,
         });
     }
-    get parentObjectTypes() {
-        return this.lazyParentObjectTypes();
-    }
     get properties() {
         const properties = this.lazyProperties(this);
         const propertyNames = new Set();
@@ -199,9 +166,6 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return new Set([...this.identifierType.nodeKinds].map(NodeKind.toTermType));
     }
     get toRdfjsResourceType() {
-        if (this.parentObjectTypes.length > 0) {
-            return this.parentObjectTypes[0].toRdfjsResourceType;
-        }
         return code `${this.reusables.imports.Resource}${this.identifierType.kind === "Iri" ? code `<${this.reusables.imports.NamedNode}>` : ""}`;
     }
     get valueSparqlConstructTriplesFunction() {
@@ -251,37 +215,8 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     toStringExpression({ variables, }) {
         return code `${this.alias.unsafeCoerce()}.${this.configuration.syntheticNamePrefix}toString(${variables.value})`;
     }
-    lazyAncestorObjectTypes;
-    lazyChildObjectTypes;
-    lazyDescendantObjectTypes;
-    lazyDiscriminantProperty;
-    lazyParentObjectTypes;
     lazyProperties;
 }
-__decorate([
-    Memoize()
-], ObjectType.prototype, "_discriminantProperty", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "ancestorObjectTypes", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "childObjectTypes", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "descendantFromRdfTypeVariables", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "descendantFromRdfTypes", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "descendantObjectTypes", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "discriminantProperty", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "discriminantValue", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "equalsFunction", null);
@@ -312,9 +247,6 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "objectSetMethodNames", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "parentObjectTypes", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "properties", null);

package/dist/generators/ts/ObjectUnionType.js

@@ -130,7 +130,7 @@ export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
             description: this.comment.map(JSON.stringify).extract(),
             name: alias,
             resolveType: code `(value: ${alias}) => value.${this.configuration.syntheticNamePrefix}type`,
-            types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableName), { on: ", " })}]`,
+            types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableExpression), { on: ", " })}]`,
         }});`);
     }
     get identifierTypeDeclarations() {
@@ -163,7 +163,7 @@ export namespace Identifier {
         }
         const commonPropertiesByName = {};
         this.members.forEach((member, memberI) => {
-            for (const memberTypeProperty of member.type.properties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.properties))) {
+            for (const memberTypeProperty of member.type.properties) {
                 if (memberTypeProperty.kind !== "Shacl") {
                     continue;
                 }

package/dist/generators/ts/OptionType.d.ts

@@ -5,7 +5,10 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
     readonly kind = "Option";
-    readonly typeofs: "object"[];
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Maybe";
+        readonly typeof: "object";
+    }];
     get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
     get equalsFunction(): Code;
     get expression(): Code;
@@ -15,6 +18,7 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     get hashFunction(): Code;
     get mutable(): boolean;
     get schemaType(): Code;
+    get toRdfResourceValueTypes(): AbstractContainerType<ItemTypeT>["toRdfResourceValueTypes"];
     get validationFunction(): Maybe<Code>;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;

package/dist/generators/ts/OptionType.js

@@ -14,17 +14,19 @@ export class OptionType extends AbstractContainerType {
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
     kind = "Option";
-    typeofs = ["object"];
+    jsTypes = [
+        { instanceof: "Maybe", typeof: "object" },
+    ];
     get conversionFunction() {
         const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
         return Maybe.of({
             code: code `${this.reusables.snippets.convertToMaybe}(${itemConversionFunction.code})`,
             sourceTypes: itemConversionFunction.sourceTypes.concat({
                 expression: this.expression,
-                typeof: "object",
+                jsType: { instanceof: "Maybe", typeof: "object" },
             }, {
                 expression: code `undefined`,
-                typeof: "undefined",
+                jsType: { typeof: "undefined" },
             }),
         });
     }
@@ -42,7 +44,7 @@ export class OptionType extends AbstractContainerType {
     }
     get graphqlType() {
         invariant(!this.itemType.graphqlType.nullable);
-        return new AbstractContainerType.GraphqlType(this.itemType.graphqlType.name, this.reusables, {
+        return new AbstractContainerType.GraphqlType(this.itemType.graphqlType.expression, this.reusables, {
             nullable: true,
         });
     }
@@ -55,6 +57,9 @@ export class OptionType extends AbstractContainerType {
     get schemaType() {
         return code `${this.reusables.snippets.MaybeSchema}<${this.itemType.schemaType}>`;
     }
+    get toRdfResourceValueTypes() {
+        return this.itemType.toRdfResourceValueTypes;
+    }
     get validationFunction() {
         return Maybe.of(code `${this.reusables.snippets.validateMaybe}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)})`);
     }
@@ -84,7 +89,7 @@ export class OptionType extends AbstractContainerType {
     jsonType(parameters) {
         const itemTypeJsonType = this.itemType.jsonType(parameters);
         invariant(!itemTypeJsonType.optional);
-        return new AbstractContainerType.JsonType(itemTypeJsonType.name, {
+        return new AbstractContainerType.JsonType(itemTypeJsonType.expression, {
             optional: true,
         });
     }

package/dist/generators/ts/RdfjsDatasetObjectSetType.js

@@ -87,10 +87,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
                     // objectsSync has per-object type logic, not just forwarding
                 ];
                 const runtimeObjectType = (filterFunction, namedObjectType) => {
-                    const fromRdfTypes = namedObjectType.fromRdfTypeVariable
-                        .toList()
-                        .concat(namedObjectType.descendantFromRdfTypeVariables);
-                    return code `{ filter: ${filterFunction}, fromRdfResource: ${namedObjectType.expression}.fromRdfResource, fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
+                    return code `{ filter: ${filterFunction}, fromRdfResource: ${namedObjectType.expression}.fromRdfResource, fromRdfTypes: ${namedObjectType.fromRdfTypeVariable.map((fromRdfTypeVariable) => code `[${fromRdfTypeVariable}]`).orDefault(code `[]`)} }`;
                 };
                 switch (namedObjectType.kind) {
                     case "Object": {

package/dist/generators/ts/SetType.d.ts

@@ -1,17 +1,32 @@
+import { Maybe } from "purify-ts";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import type { AbstractContainerType } from "./AbstractContainerType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class SetType<ItemTypeT extends SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     readonly graphqlArgs: AbstractCollectionType<ItemTypeT>["graphqlArgs"];
     readonly kind = "Set";
+    readonly minCount: bigint;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Array";
+        readonly typeof: "object";
+    }];
+    constructor({ minCount, ...superParameters }: {
+        minCount: bigint;
+    } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
+    get conversionFunction(): Maybe<AbstractCollectionType.ConversionFunction>;
+    get toRdfResourceValueTypes(): AbstractCollectionType<ItemTypeT>["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
+    protected get schemaInitializers(): readonly Code[];
+    fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
+    jsonSchema(parameters: Parameters<AbstractContainerType<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 SetType {
     type ItemType = AbstractCollectionType.ItemType;
-    const isItemType: typeof import("./AbstractContainerType.js").AbstractContainerType.isItemType;
+    const isItemType: typeof AbstractContainerType.isItemType;
 }
 //# sourceMappingURL=SetType.d.ts.map