@shaclmate/compiler 4.0.7 → 4.0.9

package/dist/generators/ts/BigDecimalType.d.ts

@@ -1,5 +1,5 @@
-import { type Code } from "ts-poet";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigDecimalType extends AbstractLiteralType {
     readonly filterFunction: Code;
     readonly filterType: Code;
@@ -7,7 +7,7 @@ export declare class BigDecimalType extends AbstractLiteralType {
     readonly kind = "BigDecimalType";
     readonly name: Code;
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     get conversions(): readonly AbstractLiteralType.Conversion[];
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
@@ -16,6 +16,6 @@ export declare class BigDecimalType extends AbstractLiteralType {
     jsonZodSchema(): Code;
     toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractLiteralType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractLiteralType["fromRdfExpressionChain"]>;
-    toRdfExpression({ variables, }: Parameters<AbstractLiteralType["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractLiteralType["toRdfResourceValuesExpression"]>[0]): Code;
 }
 //# sourceMappingURL=BigDecimalType.d.ts.map

package/dist/generators/ts/BigDecimalType.js

@@ -4,11 +4,11 @@ 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 { code } from "ts-poet";
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { imports } from "./imports.js";
 import { snippets } from "./snippets.js";
+import { code } from "./ts-poet-wrapper.js";
 export class BigDecimalType extends AbstractLiteralType {
     filterFunction = code `${snippets.filterBigDecimal}`;
     filterType = code `${snippets.NumericFilter}<${imports.BigDecimal}>`;
@@ -16,7 +16,7 @@ export class BigDecimalType extends AbstractLiteralType {
     kind = "BigDecimalType";
     name = code `${imports.BigDecimal}`;
     schemaType = code `${snippets.NumericSchema}<${imports.BigDecimal}>`;
-    sparqlWherePatternsFunction = code `${snippets.bigDecimalSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.bigDecimalSparqlWherePatterns}`;
     get conversions() {
         return [
             // {
@@ -75,7 +75,7 @@ export class BigDecimalType extends AbstractLiteralType {
             valueTo: code `chain(values => values.chainMap(value => value.toLiteral().chain(${snippets.decodeBigDecimalLiteral})))`,
         };
     }
-    toRdfExpression({ variables, }) {
+    toRdfResourceValuesExpression({ variables, }) {
         return code `[${snippets.bigDecimalLiteral}(${variables.value})]`;
     }
 }

package/dist/generators/ts/BlankNodeType.d.ts

@@ -10,7 +10,7 @@ export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
     readonly name: Code;
     readonly nodeKinds: ReadonlySet<"BlankNode">;
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     constructor(superParameters: Pick<ConstructorParameters<typeof AbstractIdentifierType<BlankNode>>[0], "comment" | "label">);
     fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;

package/dist/generators/ts/BlankNodeType.js

@@ -18,7 +18,7 @@ export class BlankNodeType extends AbstractIdentifierType {
     name = code `${imports.BlankNode}`;
     nodeKinds = nodeKinds;
     schemaType = code `${snippets.BlankNodeSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.blankNodeSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.blankNodeSparqlWherePatterns}`;
     constructor(superParameters) {
         super({
             ...superParameters,

package/dist/generators/ts/BooleanType.d.ts

@@ -7,7 +7,7 @@ export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "BooleanType";
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     readonly typeofs: NonEmptyList<"boolean">;
     get name(): string;
     protected get schemaObject(): {
@@ -16,7 +16,7 @@ export declare class BooleanType extends AbstractPrimitiveType<boolean> {
         kind: Code;
     };
     jsonZodSchema(_parameters: Parameters<AbstractPrimitiveType<number>["jsonZodSchema"]>[0]): Code;
-    toRdfExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfResourceValuesExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<boolean>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<boolean>["fromRdfExpressionChain"]>;
 }
 //# sourceMappingURL=BooleanType.d.ts.map

package/dist/generators/ts/BooleanType.js

@@ -17,7 +17,7 @@ export class BooleanType extends AbstractPrimitiveType {
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${imports.GraphQLBoolean}`);
     kind = "BooleanType";
     schemaType = code `${snippets.BooleanSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.booleanSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.booleanSparqlWherePatterns}`;
     typeofs = NonEmptyList(["boolean"]);
     get name() {
         if (this.primitiveIn.length > 0) {
@@ -37,7 +37,7 @@ export class BooleanType extends AbstractPrimitiveType {
         }
         return code `${imports.z}.boolean()`;
     }
-    toRdfExpression({ variables, }) {
+    toRdfResourceValuesExpression({ variables, }) {
         return code `[${snippets.literalFactory}.boolean(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
     }
     fromRdfExpressionChain({ variables, }) {

package/dist/generators/ts/DefaultValueType.d.ts

@@ -22,8 +22,8 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     get mutable(): boolean;
     get name(): Code | string;
     get schemaType(): Code;
-    get sparqlConstructTriplesFunction(): Code;
-    get sparqlWherePatternsFunction(): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
     protected get schemaObject(): {
         defaultValue: Code;
         item: Code;
@@ -32,14 +32,14 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     private get defaultValuePrimitiveExpression();
     private get defaultValueTermExpression();
     fromJsonExpression(parameters: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
-    fromRdfExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromRdfExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
     hashStatements(parameters: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
     jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     jsonZodSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonZodSchema"]>[0]): Code;
     toJsonExpression(parameters: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toRdfExpression(parameters: Parameters<AbstractType["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression(parameters: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace DefaultValueType {
     type ItemType = Exclude<AbstractContainerType.ItemType, BlankNodeType>;

package/dist/generators/ts/DefaultValueType.js

@@ -56,11 +56,11 @@ export class DefaultValueType extends AbstractContainerType {
     get schemaType() {
         return code `${snippets.DefaultValueSchema}`;
     }
-    get sparqlConstructTriplesFunction() {
-        return this.itemType.sparqlConstructTriplesFunction;
+    get valueSparqlConstructTriplesFunction() {
+        return this.itemType.valueSparqlConstructTriplesFunction;
     }
-    get sparqlWherePatternsFunction() {
-        return code `${snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlWherePatternsFunction})`;
+    get valueSparqlWherePatternsFunction() {
+        return code `${snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
     get schemaObject() {
         return {
@@ -102,10 +102,11 @@ export class DefaultValueType extends AbstractContainerType {
             case "TermType":
                 invariant(this.defaultValue.termType === "Literal");
                 return Maybe.of(this.defaultValueTermExpression);
+            case "AnonymousUnionType":
             case "ListType":
             case "ObjectType":
-            case "ObjectUnionType":
-            case "UnionType":
+            case "NamedObjectUnionType":
+            case "NamedUnionType":
                 return Maybe.empty();
             default:
                 this.itemType;
@@ -118,8 +119,8 @@ export class DefaultValueType extends AbstractContainerType {
     fromJsonExpression(parameters) {
         return this.itemType.fromJsonExpression(parameters);
     }
-    fromRdfExpression({ variables, }) {
-        return this.itemType.fromRdfExpression({
+    fromRdfResourceValuesExpression({ variables, }) {
+        return this.itemType.fromRdfResourceValuesExpression({
             variables: {
                 ...variables,
                 resourceValues: code `${variables.resourceValues}.map(values => values.length > 0 ? values : new ${imports.Resource}.Value(${{ dataFactory: imports.dataFactory, focusResource: variables.resource, propertyPath: variables.propertyPath, term: this.defaultValueTermExpression }}).toValues())`,
@@ -144,11 +145,11 @@ export class DefaultValueType extends AbstractContainerType {
     toJsonExpression(parameters) {
         return this.itemType.toJsonExpression(parameters);
     }
-    toRdfExpression(parameters) {
+    toRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
         return this.defaultValuePrimitiveExpression
-            .map((defaultValuePrimitiveExpression) => code `${this.itemType.equalsFunction}(${variables.value}, ${defaultValuePrimitiveExpression}).isLeft() ? ${this.itemType.toRdfExpression(parameters)} : []`)
-            .orDefault(code `${this.itemType.toRdfExpression(parameters)}.filter(value => !value.equals(${this.defaultValueTermExpression}))`);
+            .map((defaultValuePrimitiveExpression) => code `${this.itemType.equalsFunction}(${variables.value}, ${defaultValuePrimitiveExpression}).isLeft() ? ${this.itemType.toRdfResourceValuesExpression(parameters)} : []`)
+            .orDefault(code `${this.itemType.toRdfResourceValuesExpression(parameters)}.filter(value => !value.equals(${this.defaultValueTermExpression}))`);
     }
 }
 __decorate([
@@ -156,10 +157,10 @@ __decorate([
 ], DefaultValueType.prototype, "schemaType", null);
 __decorate([
     Memoize()
-], DefaultValueType.prototype, "sparqlConstructTriplesFunction", null);
+], DefaultValueType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], DefaultValueType.prototype, "sparqlWherePatternsFunction", null);
+], DefaultValueType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
 ], DefaultValueType.prototype, "defaultValuePrimitiveExpression", null);

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

@@ -11,7 +11,7 @@ export declare class IdentifierType extends AbstractIdentifierType<BlankNode | N
     readonly name: Code;
     readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     constructor(parameters: Pick<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "comment" | "label">);
     fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;

package/dist/generators/ts/IdentifierType.js

@@ -19,7 +19,7 @@ export class IdentifierType extends AbstractIdentifierType {
     name = code `(${imports.BlankNode} | ${imports.NamedNode})`;
     nodeKinds = nodeKinds;
     schemaType = code `${snippets.IdentifierSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.identifierSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.identifierSparqlWherePatterns}`;
     constructor(parameters) {
         super({
             ...parameters,

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

@@ -8,7 +8,7 @@ export declare class IriType extends AbstractIdentifierType<NamedNode> {
     readonly kind = "IriType";
     readonly nodeKinds: ReadonlySet<"IRI">;
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     get fromStringFunction(): Code;
     get name(): Code;
     protected get schemaObject(): {

package/dist/generators/ts/IriType.js

@@ -17,7 +17,7 @@ export class IriType extends AbstractIdentifierType {
     kind = "IriType";
     nodeKinds = nodeKinds;
     schemaType = code `${snippets.IriSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.iriSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.iriSparqlWherePatterns}`;
     get fromStringFunction() {
         const expressions = [
             code `${imports.Either}.encase(() => ${imports.Resource}.Identifier.fromString({ ${imports.dataFactory}, identifier }))`,

package/dist/generators/ts/LazyObjectOptionType.d.ts

@@ -24,7 +24,7 @@ export declare class LazyObjectOptionType extends Super {
     constructor({ partialType, resolveType, ...superParameters }: Omit<ConstructorParameters<typeof AbstractLazyObjectType<OptionType<AbstractLazyObjectType.ObjectTypeConstraint>, OptionType<AbstractLazyObjectType.ObjectTypeConstraint>>>[0], "runtimeClass">);
     get conversions(): readonly AbstractLazyObjectType.Conversion[];
     fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
-    fromRdfExpression(parameters: Parameters<Super["fromRdfExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression(parameters: Parameters<Super["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
 }
 export {};

package/dist/generators/ts/LazyObjectOptionType.js

@@ -36,18 +36,18 @@ export class LazyObjectOptionType extends Super {
                 sourceTypeof: "object",
             }, {
                 conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${imports.Maybe}.of(${this.partialType.itemType.newExpression({ parameters: value })}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
-                // Don't check instanceof value since the ObjectUnionType may be an interface
+                // Don't check instanceof value since the NamedObjectUnionType may be an interface
                 // Rely on the fact that this will be the last type check on an object
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: this.resolveType.itemType.name,
                 sourceTypeof: "object",
             });
         }
-        else if (this.resolveType.itemType.kind === "ObjectUnionType" &&
-            this.partialType.itemType.kind === "ObjectUnionType" &&
-            this.resolveType.itemType.memberTypes.length ===
-                this.partialType.itemType.memberTypes.length) {
-            const maybeMap = code `.map(object => { ${this.resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType: this.resolveType.itemType, partialObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} })`;
+        else if (this.resolveType.itemType.kind === "NamedObjectUnionType" &&
+            this.partialType.itemType.kind === "NamedObjectUnionType" &&
+            this.resolveType.itemType.members.length ===
+                this.partialType.itemType.members.length) {
+            const maybeMap = code `.map(object => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType.itemType, partialNamedObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} })`;
             conversions.push({
                 conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}${maybeMap}, resolver: async () => ${imports.Right}((${value} as ${imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
                 sourceTypeCheckExpression: (value) => code `${imports.Maybe}.isMaybe(${value})`,
@@ -55,7 +55,7 @@ export class LazyObjectOptionType extends Super {
                 sourceTypeof: "object",
             }, {
                 conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${imports.Maybe}.of(${value})${maybeMap}, resolver: async () => ${imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
-                // Don't check instanceof value since the ObjectUnionType may be an interface
+                // Don't check instanceof value since the NamedObjectUnionType may be an interface
                 // Rely on the fact that this will be the last type check on an object
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: this.resolveType.itemType.name,
@@ -73,9 +73,9 @@ export class LazyObjectOptionType extends Super {
     fromJsonExpression(parameters) {
         return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${imports.Left}(new Error(\`unable to resolve identifier \${${imports.Resource}.Identifier.toString(identifier)} deserialized from JSON\`))) })`;
     }
-    fromRdfExpression(parameters) {
+    fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.partialType.fromRdfExpression(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) })))`;
+        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) })))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce().extractNullable())`;

package/dist/generators/ts/LazyObjectSetType.d.ts

@@ -7,7 +7,7 @@ export declare class LazyObjectSetType extends AbstractLazyObjectType<SetType<Ab
     constructor({ partialType, resolveType, ...superParameters }: Omit<ConstructorParameters<typeof AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>>>[0], "runtimeClass">);
     get conversions(): readonly AbstractLazyObjectType.Conversion[];
     fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
-    fromRdfExpression(parameters: Parameters<Super["fromRdfExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression(parameters: Parameters<Super["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
 }
 type Super = AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>>;

package/dist/generators/ts/LazyObjectSetType.js

@@ -42,12 +42,12 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
                 sourceTypeof: "object",
             });
         }
-        else if (this.resolveType.itemType.kind === "ObjectUnionType" &&
-            this.partialType.itemType.kind === "ObjectUnionType" &&
-            this.resolveType.itemType.memberTypes.length ===
-                this.partialType.itemType.memberTypes.length) {
+        else if (this.resolveType.itemType.kind === "NamedObjectUnionType" &&
+            this.partialType.itemType.kind === "NamedObjectUnionType" &&
+            this.resolveType.itemType.members.length ===
+                this.partialType.itemType.members.length) {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => { ${this.resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType: this.resolveType.itemType, partialObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} }), resolver: async () => ${imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType.itemType, partialNamedObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} }), resolver: async () => ${imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: code `readonly ${this.resolveType.itemType.name}[]`,
                 sourceTypeof: "object",
@@ -64,9 +64,9 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
     fromJsonExpression(parameters) {
         return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: () => Promise.resolve(${imports.Left}(new Error("unable to resolve identifiers deserialized from JSON"))) })`;
     }
-    fromRdfExpression(parameters) {
+    fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.partialType.fromRdfExpression(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 }) })))`;
+        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 }) })))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `(${variables.value}.resolve({ limit: ${variables.args}.limit, offset: ${variables.args}.offset })).then(either => either.unsafeCoerce())`;

package/dist/generators/ts/LazyObjectType.d.ts

@@ -6,7 +6,7 @@ export declare class LazyObjectType extends AbstractLazyObjectType<AbstractLazyO
     constructor({ partialType, resolveType, ...superParameters }: Omit<ConstructorParameters<typeof AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint>>[0], "runtimeClass">);
     get conversions(): readonly AbstractLazyObjectType.Conversion[];
     fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
-    fromRdfExpression(parameters: Parameters<Super["fromRdfExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression(parameters: Parameters<Super["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
 }
 type Super = AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint>;

package/dist/generators/ts/LazyObjectType.js

@@ -30,13 +30,12 @@ export class LazyObjectType extends AbstractLazyObjectType {
                 sourceTypeof: "object",
             });
         }
-        else if (this.resolveType.kind === "ObjectUnionType" &&
-            this.partialType.kind === "ObjectUnionType" &&
-            this.resolveType.memberTypes.length ===
-                this.partialType.memberTypes.length) {
+        else if (this.resolveType.kind === "NamedObjectUnionType" &&
+            this.partialType.kind === "NamedObjectUnionType" &&
+            this.resolveType.members.length === this.partialType.members.length) {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ((object: ${this.resolveType.name}) => { ${this.resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType: this.resolveType, partialObjectUnionType: this.partialType, variables: { resolvedObjectUnion: code `object` } })} })(${value}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
-                // Don't check instanceof value since the ObjectUnionType may be an interface
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ((object: ${this.resolveType.name}) => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType, partialNamedObjectUnionType: this.partialType, variables: { resolvedObjectUnion: code `object` } })} })(${value}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
+                // Don't check instanceof value since the NamedObjectUnionType may be an interface
                 // Rely on the fact that this will be the last type check on an object
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: this.resolveType.name,
@@ -48,9 +47,9 @@ export class LazyObjectType extends AbstractLazyObjectType {
     fromJsonExpression(parameters) {
         return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${imports.Left}(new Error(\`unable to resolve identifier \${${imports.Resource}.Identifier.toString(identifier)} deserialized from JSON\`))) })`;
     }
-    fromRdfExpression(parameters) {
+    fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.partialType.fromRdfExpression(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) })))`;
+        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) })))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce())`;

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

@@ -2,6 +2,7 @@ import type { NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
 import type { IdentifierMintingStrategy } from "../../enums/IdentifierMintingStrategy.js";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import type { AnonymousUnionType } from "./AnonymousUnionType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
@@ -13,13 +14,13 @@ import type { IdentifierType } from "./IdentifierType.js";
 import type { IntType } from "./IntType.js";
 import type { IriType } from "./IriType.js";
 import type { LiteralType } from "./LiteralType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { NamedUnionType } from "./NamedUnionType.js";
 import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
-import type { UnionType } from "./UnionType.js";
 export declare class ListType<ItemTypeT extends ListType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     private readonly identifierMintingStrategy;
     private readonly identifierNodeKind;
@@ -30,14 +31,14 @@ export declare class ListType<ItemTypeT extends ListType.ItemType> extends Abstr
         identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
-    get sparqlConstructTriplesFunction(): Code;
-    get sparqlWherePatternsFunction(): Code;
-    fromRdfExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfExpression"]>[0]): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
+    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     jsonType(): AbstractCollectionType.JsonType;
-    toRdfExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace ListType {
-    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LiteralType | ObjectType | ObjectUnionType | StringType | TermType | UnionType;
+    type ItemType = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LiteralType | NamedObjectUnionType | NamedUnionType | ObjectType | StringType | TermType;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map

package/dist/generators/ts/ListType.js

@@ -22,19 +22,19 @@ export class ListType extends AbstractCollectionType {
         this.identifierMintingStrategy = identifierMintingStrategy.orDefault(identifierNodeKind === "BlankNode" ? "blankNode" : "sha256");
         this.toRdfTypes = toRdfTypes;
     }
-    get sparqlConstructTriplesFunction() {
-        return code `${snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlConstructTriplesFunction})`;
+    get valueSparqlConstructTriplesFunction() {
+        return code `${snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
-    get sparqlWherePatternsFunction() {
-        return code `${snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlWherePatternsFunction})`;
+    get valueSparqlWherePatternsFunction() {
+        return code `${snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
-    fromRdfExpression({ variables, }) {
+    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.fromRdfExpression({
+          valueList => ${this.itemType.fromRdfResourceValuesExpression({
                 variables: {
                     ...variables,
                     resourceValues: code `${imports.Right}(${imports.Resource}.Values.fromArray({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, values: valueList.toArray() }))`,
@@ -45,9 +45,9 @@ export class ListType extends AbstractCollectionType {
         ], { on: "." });
     }
     jsonType() {
-        return new AbstractCollectionType.JsonType(code `readonly (${this.itemType.jsonType().name})[]`);
+        return new AbstractCollectionType.JsonType(code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`);
     }
-    toRdfExpression({ variables, }) {
+    toRdfResourceValuesExpression({ variables, }) {
         let listIdentifier;
         let resourceTypeName;
         let subListIdentifier;
@@ -91,7 +91,7 @@ export class ListType extends AbstractCollectionType {
     
     ${joinCode(this.toRdfTypes.map((rdfType) => code `currentSubListResource.add(${rdfjsTermExpression(rdf.type)}, ${imports.dataFactory}.namedNode("${rdfType.value}"), ${variables.graph})`))}
     
-    currentSubListResource.add(${rdfjsTermExpression(rdf.first)}, ${this.itemType.toRdfExpression({ variables: { graph: variables.graph, propertyPath: rdfjsTermExpression(rdf.first), resource: code `currentSubListResource`, resourceSet: variables.resourceSet, value: code `item` } })}, ${variables.graph});
+    currentSubListResource.add(${rdfjsTermExpression(rdf.first)}, ${this.itemType.toRdfResourceValuesExpression({ variables: { graph: variables.graph, propertyPath: rdfjsTermExpression(rdf.first), resource: code `currentSubListResource`, resourceSet: variables.resourceSet, value: code `item` } })}, ${variables.graph});
 
     if (itemIndex + 1 === list.length) {
       currentSubListResource.add(${rdfjsTermExpression(rdf.rest)}, ${rdfjsTermExpression(rdf.nil)}, ${variables.graph});
@@ -111,16 +111,17 @@ export class ListType extends AbstractCollectionType {
 }
 __decorate([
     Memoize()
-], ListType.prototype, "sparqlConstructTriplesFunction", null);
+], ListType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], ListType.prototype, "sparqlWherePatternsFunction", null);
+], ListType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
 ], ListType.prototype, "jsonType", null);
 (function (ListType) {
     function isItemType(type) {
         switch (type.kind) {
+            case "AnonymousUnionType":
             case "BigDecimalType":
             case "BigIntType":
             case "BlankNodeType":
@@ -132,11 +133,11 @@ __decorate([
             case "IriType":
             case "IntType":
             case "LiteralType":
+            case "NamedObjectUnionType":
+            case "NamedUnionType":
             case "ObjectType":
-            case "ObjectUnionType":
             case "StringType":
             case "TermType":
-            case "UnionType":
                 return true;
             case "DefaultValueType":
             case "LazyObjectOptionType":

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

@@ -6,7 +6,7 @@ export declare class LiteralType extends AbstractLiteralType {
     readonly kind = "LiteralType";
     readonly name: Code;
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     get graphqlType(): AbstractLiteralType.GraphqlType;
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;

package/dist/generators/ts/LiteralType.js

@@ -9,12 +9,12 @@ export class LiteralType extends AbstractLiteralType {
     kind = "LiteralType";
     name = code `${imports.Literal}`;
     schemaType = code `${snippets.LiteralSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.literalSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.literalSparqlWherePatterns}`;
     get graphqlType() {
         throw new Error("not implemented");
     }
     fromJsonExpression({ variables, }) {
-        return code `${imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${imports.dataFactory}.namedNode(${variables.value}["@type"]) : undefined))`;
+        return code `${imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined))`;
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");

package/dist/generators/ts/NamedObjectUnionType.d.ts

@@ -0,0 +1,35 @@
+import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
+import { AbstractType } from "./AbstractType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+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 NamedObjectUnionType extends AbstractNamedUnionType<ObjectType> {
+    #private;
+    readonly graphqlArgs: AbstractType["graphqlArgs"];
+    readonly kind = "NamedObjectUnionType";
+    constructor({ identifierType, ...superParameters }: {
+        identifierType: BlankNodeType | IdentifierType | IriType;
+    } & Omit<ConstructorParameters<typeof AbstractNamedUnionType<ObjectType>>[0], "identifierType">);
+    get graphqlType(): AbstractType.GraphqlType;
+    get identifierTypeAlias(): Code;
+    get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
+    get schema(): Code;
+    get schemaType(): Code;
+    protected get staticModuleDeclarations(): Record<string, Code>;
+    private get focusSparqlConstructTriplesFunctionDeclaration();
+    private get focusSparqlWherePatternsFunctionDeclaration();
+    private get fromRdfResourceFunctionDeclaration();
+    private get graphqlTypeVariableStatement();
+    private get identifierTypeDeclarations();
+    private get isTypeFunctionDeclaration();
+    private get schemaVariableStatement();
+    private get toRdfResourceFunctionDeclaration();
+    graphqlResolveExpression({ variables, }: {
+        variables: {
+            value: Code;
+        };
+    }): Code;
+}
+//# sourceMappingURL=NamedObjectUnionType.d.ts.map