@shaclmate/compiler 4.0.95 → 4.0.97

package/dist/generators/ts/AbstractLazyType.d.ts

@@ -23,23 +23,23 @@ export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazy
         partialType: PartialTypeT;
         resolveType: ResolveTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get jsonValueType(): AbstractType["jsonValueType"];
     get equalsFunction(): Callable;
-    get jsonObjectType(): AbstractType["jsonObjectType"];
     get filterFunction(): Callable;
     get filterType(): Code;
-    get fromJsonValueFunction(): AbstractType["fromJsonValueFunction"];
     get fromJsonObjectFunction(): AbstractType["fromJsonObjectFunction"];
+    get fromJsonValueFunction(): AbstractType["fromJsonValueFunction"];
     get fromRdfResourceValuesFunction(): Callable;
     get graphqlType(): AbstractType.GraphqlType;
     get hashFunction(): Callable;
     get inlineExpression(): Code;
     get jsTypes(): readonly AbstractType.JsType[];
+    get jsonObjectType(): AbstractType["jsonObjectType"];
+    get jsonValueType(): AbstractType["jsonValueType"];
     get recursive(): boolean;
     get referencesNamedType(): boolean;
     get schemaType(): Code;
-    get toJsonValueFunction(): AbstractType["toJsonValueFunction"];
     get toJsonObjectFunction(): AbstractType["toJsonObjectFunction"];
+    get toJsonValueFunction(): AbstractType["toJsonValueFunction"];
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Callable;
     get valueSparqlWherePatternsFunction(): Callable;
@@ -47,9 +47,11 @@ export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazy
     toLoggableExpression({ variables, }: Parameters<AbstractType["toLoggableExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-    protected abstract objectSetResolverFunctionExpressions(parameters: {
+    protected abstract objectSetResolveExpression(parameters: {
         variables: {
             objectSet: Code;
+            partial: Code;
+            resolverOptions: Code;
         };
     }): Code;
     protected resolveToPartialFunction<ObjectTypeT extends AbstractLazyType.ItemTypeConstraint>({ partialType, resolveType, }: {
@@ -63,6 +65,11 @@ export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazy
             resolvedObjectDiscriminatedUnion: Code;
         };
     }): Code;
+    protected resolverFunctionExpression({ variables, }: {
+        variables: {
+            factoryFunctionOptions: Code;
+        };
+    }): Code;
 }
 export declare namespace AbstractLazyType {
     type ItemTypeConstraint = ObjectType | ObjectDiscriminatedUnionType;

package/dist/generators/ts/AbstractLazyType.js

@@ -21,17 +21,11 @@ export class AbstractLazyType extends AbstractType {
         this.partialType = partialType;
         this.resolveType = resolveType;
     }
-    get jsonValueType() {
-        return this.partialType.jsonValueType;
-    }
     get equalsFunction() {
         return new InlineCallable(code `(left, right) => ${this.partialType.equalsFunction.annotatedUsage}(left.${this.runtimeClass.partialPropertyName}, right.${this.runtimeClass.partialPropertyName})`, {
             type: code `${this.reusables.snippets.EqualsFunction}<${this.expression}>`,
         });
     }
-    get jsonObjectType() {
-        return this.partialType.jsonObjectType;
-    }
     get filterFunction() {
         return new InlineCallable(code `(filter, value) => ${this.partialType.filterFunction.annotatedUsage}(filter, value.${this.runtimeClass.partialPropertyName})`, {
             type: code `${this.reusables.snippets.FilterFunction}<${this.filterType}, ${this.expression}>`,
@@ -40,23 +34,23 @@ export class AbstractLazyType extends AbstractType {
     get filterType() {
         return this.partialType.filterType;
     }
-    get fromJsonValueFunction() {
-        return new InlineCallable(code `(jsonValue, { objectSet, schema, ...otherOptions }) => ${this.partialType.fromJsonValueFunction.annotatedUsage}(jsonValue, { objectSet, schema: schema.partialType, ...otherOptions })
-        .map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: objectSet ? ${this.objectSetResolverFunctionExpressions({ variables: { objectSet: code `objectSet` } })} : ${this.reusables.snippets.missingResolver} }))`, {
-            type: code `${this.reusables.snippets.FromJsonValueFunction}<${this.jsonValueType.expression}, ${this.expression}, ${this.schema}>`,
-        });
-    }
     get fromJsonObjectFunction() {
-        return new InlineCallable(code `(jsonObject, { objectSet, schema, ...otherOptions }) => ${this.partialType.fromJsonObjectFunction.annotatedUsage}(jsonObject, { objectSet, schema: schema.partialType, ...otherOptions })
-        .map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: objectSet ? ${this.objectSetResolverFunctionExpressions({ variables: { objectSet: code `objectSet` } })} : ${this.reusables.snippets.missingResolver} }))`, {
+        return new InlineCallable(code `(jsonObject, fromJsonObjectOptions) => ${this.partialType.fromJsonObjectFunction.annotatedUsage}(jsonObject, { ...fromJsonObjectOptions, schema: fromJsonObjectOptions.schema.partialType })
+        .map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: ${this.resolverFunctionExpression({ variables: { factoryFunctionOptions: code `fromJsonObjectOptions` } })} }))`, {
             type: code `${this.reusables.snippets.FromJsonObjectFunction}<${this.jsonObjectType.expression}, ${this.expression}, ${this.schema}>`,
         });
     }
+    get fromJsonValueFunction() {
+        return new InlineCallable(code `(jsonValue, fromJsonValueOptions) => ${this.partialType.fromJsonValueFunction.annotatedUsage}(jsonValue, { ...fromJsonValueOptions, schema: fromJsonValueOptions.schema.partialType })
+        .map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: ${this.resolverFunctionExpression({ variables: { factoryFunctionOptions: code `fromJsonValueOptions` } })} }))`, {
+            type: code `${this.reusables.snippets.FromJsonValueFunction}<${this.jsonValueType.expression}, ${this.expression}, ${this.schema}>`,
+        });
+    }
     get fromRdfResourceValuesFunction() {
         return new InlineCallable(code `\
-  (values, { objectSet, schema, ...otherOptions }) =>
-    ${this.partialType.fromRdfResourceValuesFunction.annotatedUsage}(values, { objectSet, schema: schema.partialType, ...otherOptions })
-      .map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: ${this.objectSetResolverFunctionExpressions({ variables: { objectSet: code `objectSet` } })} })))`, {
+  (values, fromRdfResourceValuesOptions) =>
+    ${this.partialType.fromRdfResourceValuesFunction.annotatedUsage}(values, { ...fromRdfResourceValuesOptions, schema: fromRdfResourceValuesOptions.schema.partialType })
+      .map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: ${this.resolverFunctionExpression({ variables: { factoryFunctionOptions: code `fromRdfResourceValuesOptions` } })} })))`, {
             type: code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>`,
         });
     }
@@ -78,6 +72,12 @@ export class AbstractLazyType extends AbstractType {
             },
         ];
     }
+    get jsonObjectType() {
+        return this.partialType.jsonObjectType;
+    }
+    get jsonValueType() {
+        return this.partialType.jsonValueType;
+    }
     get recursive() {
         return this.partialType.recursive;
     }
@@ -90,16 +90,16 @@ export class AbstractLazyType extends AbstractType {
             partialType: this.partialType.schemaType,
         }}`;
     }
-    get toJsonValueFunction() {
-        return new InlineCallable(code `(value) => ${this.partialType.toJsonValueFunction.unannotatedUsage}(value.${this.runtimeClass.partialPropertyName})`, {
-            type: code `${this.reusables.snippets.ToJsonValueFunction}<${this.expression}, ${this.jsonValueType.expression}>`,
-        });
-    }
     get toJsonObjectFunction() {
         return new InlineCallable(code `(value) => ${this.partialType.toJsonObjectFunction.unannotatedUsage}(value.${this.runtimeClass.partialPropertyName})`, {
             type: code `${this.reusables.snippets.ToJsonObjectFunction}<${this.expression}, ${this.jsonValueType.expression}>`,
         });
     }
+    get toJsonValueFunction() {
+        return new InlineCallable(code `(value) => ${this.partialType.toJsonValueFunction.unannotatedUsage}(value.${this.runtimeClass.partialPropertyName})`, {
+            type: code `${this.reusables.snippets.ToJsonValueFunction}<${this.expression}, ${this.jsonValueType.expression}>`,
+        });
+    }
     get toRdfResourceValueTypes() {
         return this.partialType.toRdfResourceValueTypes;
     }
@@ -160,6 +160,19 @@ export class AbstractLazyType extends AbstractType {
         caseBlocks.push(code `default: ${variables.resolvedObjectDiscriminatedUnion} satisfies never; throw new Error("unrecognized type");`);
         return code `switch (${variables.resolvedObjectDiscriminatedUnion}.${resolvedObjectDiscriminatedUnionType.discriminatedType.unsafeCoerce().discriminantProperty.name}) { ${joinCode(caseBlocks)} }`;
     }
+    resolverFunctionExpression({ variables, }) {
+        if (!this.configuration.features.has("ObjectSet")) {
+            return code `${this.reusables.snippets.missingResolver}`;
+        }
+        return code `\
+(partial, resolverOptions) => {
+  const objectSet = ${variables.factoryFunctionOptions}?.objectSet;
+  if (!objectSet) {
+    return ${this.reusables.snippets.missingResolver}();
+  }
+  return ${this.objectSetResolveExpression({ variables: { objectSet: code `objectSet`, partial: code `partial`, resolverOptions: code `resolverOptions` } })};
+}`;
+    }
 }
 __decorate([
     Memoize()

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

@@ -5,7 +5,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 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 graphqlArgs: Super["graphqlArgs"];
     readonly kind = "LazyOption";
     get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
     protected get runtimeClass(): {
@@ -13,11 +13,9 @@ export declare class LazyOptionType extends AbstractLazyType<OptionType<Abstract
         partialPropertyName: string;
         rawName: Code;
     };
-    protected objectSetResolverFunctionExpressions({ variables, }: {
-        variables: {
-            objectSet: Code;
-        };
-    }): Code;
-    graphqlResolveExpression({ variables, }: Parameters<AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>["graphqlResolveExpression"]>[0]): Code;
+    protected objectSetResolveExpression({ variables, }: Parameters<Super["objectSetResolveExpression"]>[0]): Code;
+    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
 }
+type Super = AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>;
+export {};
 //# sourceMappingURL=LazyOptionType.d.ts.map

package/dist/generators/ts/LazyOptionType.js

@@ -53,8 +53,8 @@ ${this.reusables.snippets.convertToLazyOption}<
             rawName: code `${this.reusables.snippets.LazyOption}`,
         };
     }
-    objectSetResolverFunctionExpressions({ variables, }) {
-        return code `(partial, options) => ${variables.objectSet}.${this.resolveItemType.objectSetMethodNames.object}(partial.${this.partialItemType.identifierProperty.unsafeCoerce().name}(), options)`;
+    objectSetResolveExpression({ variables, }) {
+        return code `${variables.objectSet}.${this.resolveItemType.objectSetMethodNames.object}(${variables.partial}.${this.partialItemType.identifierProperty.unsafeCoerce().name}(), ${variables.resolverOptions})`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce().extractNullable())`;

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

@@ -8,11 +8,7 @@ export declare class LazySetType extends AbstractLazyType<SetType<AbstractLazyTy
     readonly graphqlArgs: Super["graphqlArgs"];
     readonly kind = "LazySet";
     get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
-    protected objectSetResolverFunctionExpressions({ variables, }: {
-        variables: {
-            objectSet: Code;
-        };
-    }): Code;
+    protected objectSetResolveExpression({ variables, }: Parameters<Super["objectSetResolveExpression"]>[0]): Code;
     protected get runtimeClass(): {
         name: Code;
         partialPropertyName: string;

package/dist/generators/ts/LazySetType.js

@@ -52,8 +52,8 @@ ${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 })`;
+    objectSetResolveExpression({ variables, }) {
+        return code `${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers: ${variables.partial}.map(partial => partial.${this.partialItemType.identifierProperty.unsafeCoerce().name}()), ...${variables.resolverOptions} })`;
     }
     get runtimeClass() {
         return {

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

@@ -13,11 +13,7 @@ export declare class LazyType extends AbstractLazyType<AbstractLazyType.ItemType
         rawName: Code;
     };
     graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
-    protected objectSetResolverFunctionExpressions({ variables, }: {
-        variables: {
-            objectSet: Code;
-        };
-    }): Code;
+    protected objectSetResolveExpression({ variables, }: Parameters<Super["objectSetResolveExpression"]>[0]): Code;
 }
 type Super = AbstractLazyType<AbstractLazyType.ItemTypeConstraint, AbstractLazyType.ItemTypeConstraint>;
 export {};

package/dist/generators/ts/LazyType.js

@@ -47,8 +47,8 @@ ${this.reusables.snippets.convertToLazy}<
     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)`;
+    objectSetResolveExpression({ variables, }) {
+        return code `${variables.objectSet}.${this.resolveItemType.objectSetMethodNames.object}(${variables.partial}.${this.partialItemType.identifierProperty.unsafeCoerce().name}(), ${variables.resolverOptions})`;
     }
 }
 __decorate([

package/dist/generators/ts/ObjectDiscriminatedUnionType.d.ts

@@ -1,22 +1,22 @@
 import type { Maybe } from "purify-ts";
-import { ObjectDiscriminatedUnionType_schemaExpression } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaExpression.js";
 import { AbstractDiscriminatedUnionType } from "./AbstractDiscriminatedUnionType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { Callable } from "./Callable.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
+import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class ObjectDiscriminatedUnionType extends AbstractDiscriminatedUnionType<ObjectType> {
-    protected schemaExpression: typeof ObjectDiscriminatedUnionType_schemaExpression;
+export declare class ObjectDiscriminatedUnionType extends AbstractDiscriminatedUnionType<ObjectDiscriminatedUnionType.MemberType> {
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
     readonly kind = "ObjectDiscriminatedUnion";
     constructor({ identifierType, ...superParameters }: {
         identifierType: BlankNodeType | IdentifierType | IriType;
-    } & ConstructorParameters<typeof AbstractDiscriminatedUnionType<ObjectType>>[0]);
+    } & ConstructorParameters<typeof AbstractDiscriminatedUnionType<ObjectDiscriminatedUnionType.MemberType>>[0]);
     get focusSparqlConstructTriplesFunction(): Callable;
     get focusSparqlWherePatternsFunction(): Callable;
     get fromRdfResourceFunction(): Callable;
+    get fromRdfTypeVariables(): readonly Code[];
     get identifierTypeAlias(): Code;
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
     get sparqlConstructQueryFunction(): Callable;
@@ -26,4 +26,7 @@ export declare class ObjectDiscriminatedUnionType extends AbstractDiscriminatedU
     protected get inlineExpression(): Code;
     protected staticModuleDeclarations(name: string): Record<string, Code>;
 }
+export declare namespace ObjectDiscriminatedUnionType {
+    type MemberType = ObjectDiscriminatedUnionType | ObjectIntersectionType | ObjectType;
+}
 //# sourceMappingURL=ObjectDiscriminatedUnionType.d.ts.map

package/dist/generators/ts/ObjectDiscriminatedUnionType.js

@@ -10,7 +10,6 @@ import { ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunction } from
 import { ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunction } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunction.js";
 import { ObjectDiscriminatedUnionType_fromRdfResourceFunction } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_fromRdfResourceFunction.js";
 import { ObjectDiscriminatedUnionType_graphqlTypeExpression } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_graphqlTypeExpression.js";
-import { ObjectDiscriminatedUnionType_schemaExpression } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaExpression.js";
 import { ObjectDiscriminatedUnionType_toRdfResourceFunction } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_toRdfResourceFunction.js";
 import { ObjectDiscriminatedUnionType_typeGuardFunction } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_typeGuardFunction.js";
 import { ObjectType_identifierTypeDeclarations } from "./_ObjectType/ObjectType_identifierTypeDeclarations.js";
@@ -21,7 +20,6 @@ import { AbstractDiscriminatedUnionType } from "./AbstractDiscriminatedUnionType
 import { DeclaredCallable } from "./DeclaredCallable.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ObjectDiscriminatedUnionType extends AbstractDiscriminatedUnionType {
-    schemaExpression = ObjectDiscriminatedUnionType_schemaExpression;
     identifierType;
     kind = "ObjectDiscriminatedUnion";
     constructor({ identifierType, ...superParameters }) {
@@ -37,6 +35,21 @@ export class ObjectDiscriminatedUnionType extends AbstractDiscriminatedUnionType
     get fromRdfResourceFunction() {
         return ObjectDiscriminatedUnionType_fromRdfResourceFunction.call(this);
     }
+    get fromRdfTypeVariables() {
+        return this.members.flatMap((member) => {
+            switch (member.type.kind) {
+                case "Object":
+                    return member.type.fromRdfTypeVariable.toList();
+                case "ObjectDiscriminatedUnion":
+                    return member.type.fromRdfTypeVariables;
+                case "ObjectIntersection":
+                    return [];
+                default:
+                    member.type;
+                    throw new RangeError("should never reach this point");
+            }
+        });
+    }
     get identifierTypeAlias() {
         return this.name.map((name) => code `${name}.Identifier`).unsafeCoerce();
     }
@@ -121,6 +134,9 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectDiscriminatedUnionType.prototype, "fromRdfResourceFunction", null);
+__decorate([
+    Memoize()
+], ObjectDiscriminatedUnionType.prototype, "fromRdfTypeVariables", null);
 __decorate([
     Memoize()
 ], ObjectDiscriminatedUnionType.prototype, "identifierTypeAlias", null);

package/dist/generators/ts/ObjectIntersectionType.d.ts

@@ -10,7 +10,7 @@ import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
 import type { ObjectType } from "./ObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class ObjectIntersectionType extends AbstractIntersectionType<ObjectType> {
+export declare class ObjectIntersectionType extends AbstractIntersectionType<ObjectIntersectionType.MemberType> {
     protected fromJsonObjectFunctionExpression: typeof ObjectIntersectionType_fromJsonObjectFunctionExpression;
     protected fromJsonObjectFunctionType: typeof ObjectIntersectionType_fromJsonObjectFunctionType;
     protected fromRdfResourceValuesFunctionExpression: typeof ObjectIntersectionType_fromRdfResourceValuesFunctionExpression;
@@ -22,7 +22,7 @@ export declare class ObjectIntersectionType extends AbstractIntersectionType<Obj
     readonly kind = "ObjectIntersection";
     constructor({ identifierType, ...superParameters }: {
         identifierType: BlankNodeType | IdentifierType | IriType;
-    } & ConstructorParameters<typeof AbstractIntersectionType<ObjectType>>[0]);
+    } & ConstructorParameters<typeof AbstractIntersectionType<ObjectIntersectionType.MemberType>>[0]);
     get _fromRdfResourceFunction(): Callable;
     get _toRdfResourceFunction(): Callable;
     get createFunction(): Callable;
@@ -31,8 +31,8 @@ export declare class ObjectIntersectionType extends AbstractIntersectionType<Obj
     get focusSparqlWherePatternsFunction(): Callable;
     get fromRdfResourceFunction(): Callable;
     get identifierTypeAlias(): Code;
-    get jsonObjectType(): AbstractIntersectionType<ObjectType>["jsonObjectType"];
-    get jsonValueType(): AbstractIntersectionType<ObjectType>["jsonValueType"];
+    get jsonObjectType(): AbstractIntersectionType<ObjectIntersectionType.MemberType>["jsonObjectType"];
+    get jsonValueType(): AbstractIntersectionType<ObjectIntersectionType.MemberType>["jsonValueType"];
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
     get sparqlConstructQueryFunction(): Callable;
     get sparqlConstructQueryStringFunction(): Callable;
@@ -41,4 +41,7 @@ export declare class ObjectIntersectionType extends AbstractIntersectionType<Obj
     protected get createUnsafeFunction(): Callable;
     protected staticModuleDeclarations(name: string): Record<string, Code>;
 }
+export declare namespace ObjectIntersectionType {
+    type MemberType = ObjectIntersectionType | ObjectType;
+}
 //# sourceMappingURL=ObjectIntersectionType.d.ts.map

package/dist/generators/ts/RdfjsDatasetObjectSetType.js

@@ -4,10 +4,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
 export class RdfjsDatasetObjectSetType extends AbstractObjectSetType {
     get declaration() {
         const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
@@ -87,30 +86,42 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
 }`,
                     // objectsSync has per-object type logic, not just forwarding
                 ];
-                const runtimeObjectType = (filterFunction, namedObjectType) => {
-                    return code `{ filter: ${filterFunction.annotatedUsage}, fromRdfResource: ${namedObjectType.expression}.fromRdfResource, fromRdfTypes: ${namedObjectType.fromRdfTypeVariable.map((fromRdfTypeVariable) => code `[${fromRdfTypeVariable}]`).orDefault(code `[]`)} }`;
+                const runtimeObjectType = (namedObjectType, options) => {
+                    let fromRdfTypeVariables;
+                    switch (namedObjectType.kind) {
+                        case "Object":
+                            fromRdfTypeVariables =
+                                namedObjectType.fromRdfTypeVariable.toList();
+                            break;
+                        case "ObjectDiscriminatedUnion":
+                            fromRdfTypeVariables = namedObjectType.fromRdfTypeVariables;
+                            break;
+                        case "ObjectIntersection":
+                            fromRdfTypeVariables = [];
+                            break;
+                    }
+                    return code `{ filter: ${(options?.filterFunction ?? namedObjectType.filterFunction).annotatedUsage}, fromRdfResource: ${namedObjectType.expression}.fromRdfResource, fromRdfTypes: ${arrayOf(...fromRdfTypeVariables)} }`;
                 };
                 switch (namedObjectType.kind) {
                     case "Object": {
                         return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.expression}[]> {
-  return this.#objectsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
+  return this.#objectsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType)}, query);
 }`);
                     }
                     case "ObjectDiscriminatedUnion":
                         return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.expression}[]> {
   return this.#objectDiscriminatedUnionsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
-    ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
+    ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(member.type, {
+                            filterFunction: namedObjectType.filterFunction,
+                        })), { on: ", " })}
   ], query);
 }`);
                     case "ObjectIntersection":
                         return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.expression}[]> {
-  return this.#objectsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, {
-                            expression: namedObjectType.expression,
-                            fromRdfTypeVariable: Maybe.empty(),
-                        })}, query);
+  return this.#objectsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType)}, query);
 }`);
                     default:
                         namedObjectType;

package/dist/generators/ts/TypeFactory.js

@@ -86,23 +86,12 @@ export class TypeFactory {
                 return cachedType;
             }
         }
-        const objectDiscriminatedUnionIdentifierType = this.createIdentifierType(ast.StructCompoundType.identifierType(astType));
+        const objectDiscriminatedUnionIdentifierType = this.createIdentifierType(ast.StructCompoundType.identifierType(astType).unsafeCoerce());
         const objectDiscriminatedUnionTypeName = astType.name.map((name) => this.tsName(name));
         const objectDiscriminatedUnionType = new ObjectDiscriminatedUnionType({
             ...this.constructorParameters,
             comment: astType.comment,
-            identifierProperty: astType.isStructDiscriminatedUnionType() &&
-                astType.members.every((member) => {
-                    switch (member.type.kind) {
-                        case "DiscriminatedUnion":
-                            return member.type.members.every((member) => member.type.identifierField.isJust());
-                        case "Struct":
-                            return member.type.identifierField.isJust();
-                        default:
-                            member.type;
-                            throw new Error("should never reach this point");
-                    }
-                })
+            identifierProperty: ast.StructCompoundType.hasIdentifierField(astType)
                 ? Maybe.of(new ObjectType.IdentifierProperty({
                     ...this.constructorParameters,
                     name: `${this.configuration.syntheticNamePrefix}identifier`,
@@ -112,10 +101,16 @@ export class TypeFactory {
                 : Maybe.empty(),
             identifierType: objectDiscriminatedUnionIdentifierType,
             label: astType.label,
-            members: ast.StructCompoundType.memberStructTypes(astType).map((astStructType) => ({
-                discriminantValue: Maybe.empty(),
-                type: this.createObjectType(astStructType),
-            })),
+            members: astType.members.map((member) => {
+                const type = this.createType(member.type);
+                invariant(type.kind === "ObjectDiscriminatedUnion" ||
+                    type.kind === "ObjectIntersection" ||
+                    type.kind === "Object", type.kind);
+                return {
+                    discriminantValue: Maybe.empty(),
+                    type: type,
+                };
+            }),
             name: objectDiscriminatedUnionTypeName,
             recursive: astType.recursive,
             shapeIdentifier: astType.shapeIdentifier,
@@ -132,23 +127,12 @@ export class TypeFactory {
                 return cachedType;
             }
         }
-        const objectIntersectionIdentifierType = this.createIdentifierType(ast.StructCompoundType.identifierType(astType));
+        const objectIntersectionIdentifierType = this.createIdentifierType(ast.StructCompoundType.identifierType(astType).unsafeCoerce());
         const objectIntersectionTypeName = astType.name.map((name) => this.tsName(name));
         const objectIntersectionType = new ObjectIntersectionType({
             ...this.constructorParameters,
             comment: astType.comment,
-            identifierProperty: astType.isStructIntersectionType() &&
-                astType.members.every((member) => {
-                    switch (member.type.kind) {
-                        case "Intersection":
-                            return member.type.members.every((member) => member.type.identifierField.isJust());
-                        case "Struct":
-                            return member.type.identifierField.isJust();
-                        default:
-                            member.type;
-                            throw new Error("should never reach this point");
-                    }
-                })
+            identifierProperty: ast.StructCompoundType.hasIdentifierField(astType)
                 ? Maybe.of(new ObjectType.IdentifierProperty({
                     ...this.constructorParameters,
                     name: `${this.configuration.syntheticNamePrefix}identifier`,
@@ -158,9 +142,11 @@ export class TypeFactory {
                 : Maybe.empty(),
             identifierType: objectIntersectionIdentifierType,
             label: astType.label,
-            members: ast.StructCompoundType.memberStructTypes(astType).map((astStructType) => ({
-                type: this.createObjectType(astStructType),
-            })),
+            members: astType.members.map((member) => {
+                const type = this.createType(member.type);
+                invariant(type.kind === "ObjectIntersection" || type.kind === "Object", type.kind);
+                return { type };
+            }),
             name: objectIntersectionTypeName,
             recursive: astType.recursive,
             shapeIdentifier: astType.shapeIdentifier,