@shaclmate/compiler 2.0.22 → 2.0.24

package/dist/generators/ts/ObjectUnionType.js

@@ -7,14 +7,93 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { camelCase, pascalCase } from "change-case";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
-import { StructureKind, } from "ts-morph";
+import { StructureKind, VariableDeclarationKind, } from "ts-morph";
 import { Memoize } from "typescript-memoize";
 import { DeclaredType } from "./DeclaredType.js";
+import { Type } from "./Type.js";
 import { hasherTypeConstraint } from "./_ObjectType/hashFunctionOrMethodDeclarations.js";
+import { objectSetMethodNames } from "./_ObjectType/objectSetMethodNames.js";
 import { sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/sparqlConstructQueryFunctionDeclaration.js";
 import { sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/sparqlConstructQueryStringFunctionDeclaration.js";
 import { objectInitializer } from "./objectInitializer.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { tsComment } from "./tsComment.js";
+class MemberType {
+    delegate;
+    universe;
+    constructor({ delegate, universe, }) {
+        this.delegate = delegate;
+        this.universe = universe;
+    }
+    get declarationType() {
+        return this.delegate.declarationType;
+    }
+    get discriminatorPropertyValues() {
+        // A member type's combined discriminator property values are its "own" values plus any descendant values that are
+        // not the "own" values of some other member type.
+        // So if you have type A, type B, and B inherits A, then
+        // A has
+        //   own discriminator property values: ["A"]
+        //   descendant discriminator property values: ["B"]
+        // and B has
+        //  own discriminator property values: ["B"]
+        //  descendant discriminator property values ["B"]
+        // In this case A shouldn't have "B" as a combined discriminator property value since it's "claimed" by B.
+        const memberOwnDiscriminatorPropertyValues = new Set();
+        for (const memberType of this.universe) {
+            for (const ownDiscriminatorPropertyValue of memberType.discriminatorProperty.unsafeCoerce()
+                .ownValues) {
+                memberOwnDiscriminatorPropertyValues.add(ownDiscriminatorPropertyValue);
+            }
+        }
+        return this.delegate._discriminatorProperty.ownValues.concat(this.delegate._discriminatorProperty.descendantValues.filter((value) => !memberOwnDiscriminatorPropertyValues.has(value)));
+    }
+    get features() {
+        return this.delegate.features;
+    }
+    get fromRdfType() {
+        return this.delegate.fromRdfType;
+    }
+    get fromRdfTypeVariable() {
+        return this.delegate.fromRdfTypeVariable;
+    }
+    get graphqlName() {
+        return this.delegate.graphqlName;
+    }
+    get identifierTypeAlias() {
+        return this.delegate.identifierTypeAlias;
+    }
+    get jsonName() {
+        return this.delegate.jsonName;
+    }
+    get mutable() {
+        return this.delegate.mutable;
+    }
+    get name() {
+        return this.delegate.name;
+    }
+    get staticModuleName() {
+        return this.delegate.staticModuleName;
+    }
+    get toRdfjsResourceType() {
+        return this.delegate.toRdfjsResourceType;
+    }
+    jsonZodSchema(parameters) {
+        return this.delegate.jsonZodSchema(parameters);
+    }
+    newExpression(parameters) {
+        return this.delegate.newExpression(parameters);
+    }
+    snippetDeclarations(parameters) {
+        return this.delegate.snippetDeclarations(parameters);
+    }
+    useImports() {
+        return this.delegate.useImports();
+    }
+}
+__decorate([
+    Memoize()
+], MemberType.prototype, "discriminatorPropertyValues", null);
 /**
  * A union of object types, generated as a type alias
  *
@@ -26,28 +105,34 @@ import { tsComment } from "./tsComment.js";
  * It also generates SPARQL graph patterns that UNION the member object types.
  */
 export class ObjectUnionType extends DeclaredType {
-    kind = "ObjectUnionType";
     _discriminatorProperty;
     comment;
     label;
+    identifierType;
+    kind = "ObjectUnionType";
     memberTypes;
-    constructor({ comment, label, memberTypes, ...superParameters }) {
+    typeof = "object";
+    constructor({ comment, identifierType, label, memberTypes, ...superParameters }) {
         super(superParameters);
         this.comment = comment;
+        this.identifierType = identifierType;
         this.label = label;
         invariant(memberTypes.length > 0);
-        this.memberTypes = memberTypes;
+        const discriminatorPropertyDescendantValues = [];
         const discriminatorPropertyName = memberTypes[0].discriminatorProperty.unsafeCoerce().name;
-        const discriminatorPropertyValues = [];
-        for (const memberType of this.memberTypes) {
+        const discriminatorPropertyOwnValues = [];
+        for (const memberType of memberTypes) {
             invariant(memberType.declarationType === memberTypes[0].declarationType);
             invariant(memberType._discriminatorProperty.name === discriminatorPropertyName);
-            discriminatorPropertyValues.push(...memberType._discriminatorProperty.values);
+            discriminatorPropertyDescendantValues.push(...memberType._discriminatorProperty.descendantValues);
+            discriminatorPropertyOwnValues.push(...memberType._discriminatorProperty.ownValues);
         }
         this._discriminatorProperty = {
+            descendantValues: discriminatorPropertyDescendantValues,
             name: discriminatorPropertyName,
-            values: discriminatorPropertyValues,
+            ownValues: discriminatorPropertyOwnValues,
         };
+        this.memberTypes = memberTypes.map((memberType) => new MemberType({ delegate: memberType, universe: memberTypes }));
     }
     get conversions() {
         return [
@@ -59,26 +144,29 @@ export class ObjectUnionType extends DeclaredType {
         ];
     }
     get declarationImports() {
-        return this.memberTypes.flatMap((memberType) => memberType.useImports(this.features));
+        return this.memberTypes.flatMap((memberType) => memberType.useImports());
     }
     get declarations() {
         const declarations = [this.typeAliasDeclaration];
-        const moduleStatements = [
+        const staticModuleStatements = [
             ...this.equalsFunctionDeclaration.toList(),
             ...this.fromJsonFunctionDeclaration.toList(),
             ...this.fromRdfFunctionDeclaration.toList(),
+            ...this.graphqlTypeVariableStatement.toList(),
             ...this.hashFunctionDeclaration.toList(),
+            ...this.jsonTypeAliasDeclaration.toList(),
             ...this.jsonZodSchemaFunctionDeclaration.toList(),
+            ...this.identifierTypeDeclarations,
             ...this.sparqlFunctionDeclarations,
             ...this.toJsonFunctionDeclaration.toList(),
             ...this.toRdfFunctionDeclaration.toList(),
         ];
-        if (moduleStatements.length > 0) {
+        if (staticModuleStatements.length > 0) {
             declarations.push({
                 isExported: this.export,
                 kind: StructureKind.Module,
-                name: this.name,
-                statements: moduleStatements,
+                name: this.staticModuleName,
+                statements: staticModuleStatements,
             });
         }
         return declarations;
@@ -87,16 +175,26 @@ export class ObjectUnionType extends DeclaredType {
         return Maybe.of(this._discriminatorProperty);
     }
     get equalsFunction() {
-        return `${this.name}.equals`;
+        return `${this.staticModuleName}.${syntheticNamePrefix}equals`;
+    }
+    get graphqlName() {
+        return new Type.GraphqlName(`${this.staticModuleName}.${syntheticNamePrefix}GraphQL`);
+    }
+    get identifierTypeAlias() {
+        return `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
     }
     get jsonName() {
-        return this.memberTypes
-            .map((memberType) => memberType.jsonName)
-            .join(" | ");
+        return new Type.JsonName(this.memberTypes.map((memberType) => memberType.jsonName).join(" | "));
     }
     get mutable() {
         return this.memberTypes.some((memberType) => memberType.mutable);
     }
+    get objectSetMethodNames() {
+        return objectSetMethodNames.bind(this)();
+    }
+    get staticModuleName() {
+        return this.name;
+    }
     get thisVariable() {
         return `_${camelCase(this.name)}`;
     }
@@ -108,18 +206,19 @@ export class ObjectUnionType extends DeclaredType {
             let returnExpression;
             switch (memberType.declarationType) {
                 case "class":
-                    returnExpression = `left.equals(right as unknown as ${memberType.name})`;
+                    returnExpression = `left.${syntheticNamePrefix}equals(right as unknown as ${memberType.name})`;
                     break;
                 case "interface":
-                    returnExpression = `${memberType.name}.equals(left, right as unknown as ${memberType.name})`;
+                    returnExpression = `${memberType.staticModuleName}.${syntheticNamePrefix}equals(left, right as unknown as ${memberType.name})`;
                     break;
             }
-            return `case "${memberType.name}": return ${returnExpression};`;
+            return `${memberType.discriminatorPropertyValues.map((discriminatorPropertyValue) => `case "${discriminatorPropertyValue}":`).join("\n")} return ${returnExpression};`;
         });
+        caseBlocks.push('default: left satisfies never; throw new Error("unrecognized type");');
         return Maybe.of({
             isExported: true,
             kind: StructureKind.Function,
-            name: "equals",
+            name: `${syntheticNamePrefix}equals`,
             parameters: [
                 {
                     name: "left",
@@ -130,9 +229,9 @@ export class ObjectUnionType extends DeclaredType {
                     type: this.name,
                 },
             ],
-            returnType: "EqualsResult",
+            returnType: `${syntheticNamePrefix}EqualsResult`,
             statements: `\
-return strictEquals(left.type, right.type).chain(() => {
+return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right.${syntheticNamePrefix}type).chain(() => {
   switch (left.${this._discriminatorProperty.name}) {
    ${caseBlocks.join(" ")}
   }
@@ -140,13 +239,13 @@ return strictEquals(left.type, right.type).chain(() => {
         });
     }
     get fromJsonFunctionDeclaration() {
-        if (!this.features.has("fromJson")) {
+        if (!this.features.has("json")) {
             return Maybe.empty();
         }
         return Maybe.of({
             isExported: true,
             kind: StructureKind.Function,
-            name: "fromJson",
+            name: `${syntheticNamePrefix}fromJson`,
             parameters: [
                 {
                     name: "json",
@@ -156,7 +255,7 @@ return strictEquals(left.type, right.type).chain(() => {
             returnType: `purify.Either<zod.ZodError, ${this.name}>`,
             statements: [
                 `return ${this.memberTypes.reduce((expression, memberType) => {
-                    const memberTypeExpression = `(${memberType.name}.fromJson(json) as purify.Either<zod.ZodError, ${this.name}>)`;
+                    const memberTypeExpression = `(${memberType.staticModuleName}.${syntheticNamePrefix}fromJson(json) as purify.Either<zod.ZodError, ${this.name}>)`;
                     return expression.length > 0
                         ? `${expression}.altLazy(() => ${memberTypeExpression})`
                         : memberTypeExpression;
@@ -165,23 +264,28 @@ return strictEquals(left.type, right.type).chain(() => {
         });
     }
     get fromRdfFunctionDeclaration() {
-        if (!this.features.has("fromRdf")) {
+        if (!this.features.has("rdf")) {
             return Maybe.empty();
         }
         return Maybe.of({
             isExported: true,
             kind: StructureKind.Function,
-            name: "fromRdf",
+            name: `${syntheticNamePrefix}fromRdf`,
             parameters: [
                 {
-                    name: "{ ignoreRdfType, resource, ...context }",
-                    type: `{ [_index: string]: any; ignoreRdfType?: boolean; resource: ${this.rdfjsResourceType().name}; }`,
+                    name: "resource",
+                    type: "rdfjsResource.Resource",
+                },
+                {
+                    hasQuestionToken: true,
+                    name: "options",
+                    type: `{ [_index: string]: any; ignoreRdfType?: boolean; languageIn?: readonly string[]; objectSet?: ${syntheticNamePrefix}ObjectSet }`,
                 },
             ],
-            returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>`,
+            returnType: `purify.Either<Error, ${this.name}>`,
             statements: [
                 `return ${this.memberTypes.reduce((expression, memberType) => {
-                    const memberTypeExpression = `(${memberType.name}.fromRdf({ ...context, resource }) as purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>)`;
+                    const memberTypeExpression = `(${memberType.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...options, ignoreRdfType: false }) as purify.Either<Error, ${this.name}>)`;
                     return expression.length > 0
                         ? `${expression}.altLazy(() => ${memberTypeExpression})`
                         : memberTypeExpression;
@@ -189,6 +293,27 @@ return strictEquals(left.type, right.type).chain(() => {
             ],
         });
     }
+    get graphqlTypeVariableStatement() {
+        if (!this.features.has("graphql")) {
+            return Maybe.empty();
+        }
+        return Maybe.of({
+            declarationKind: VariableDeclarationKind.Const,
+            kind: StructureKind.VariableStatement,
+            declarations: [
+                {
+                    name: `${syntheticNamePrefix}GraphQL`,
+                    initializer: `new graphql.GraphQLUnionType(${objectInitializer({
+                        description: this.comment.map(JSON.stringify).extract(),
+                        name: `"${this.name}"`,
+                        resolveType: `(value: ${this.name}) => value.${syntheticNamePrefix}type`,
+                        types: `[${this.memberTypes.map((memberType) => memberType.graphqlName.nullableName).join(", ")}]`,
+                    })})`,
+                },
+            ],
+            isExported: true,
+        });
+    }
     get hashFunctionDeclaration() {
         if (!this.features.has("hash")) {
             return Maybe.empty();
@@ -198,18 +323,19 @@ return strictEquals(left.type, right.type).chain(() => {
             let returnExpression;
             switch (memberType.declarationType) {
                 case "class":
-                    returnExpression = `${this.thisVariable}.hash(${hasherVariable})`;
+                    returnExpression = `${this.thisVariable}.${syntheticNamePrefix}hash(${hasherVariable})`;
                     break;
                 case "interface":
-                    returnExpression = `${memberType.name}.${memberType.hashFunctionName}(${this.thisVariable}, ${hasherVariable})`;
+                    returnExpression = `${memberType.staticModuleName}.${syntheticNamePrefix}hash(${this.thisVariable}, ${hasherVariable})`;
                     break;
             }
-            return `case "${memberType.name}": return ${returnExpression};`;
+            return `${memberType.discriminatorPropertyValues.map((discriminatorPropertyValue) => `case "${discriminatorPropertyValue}":`).join("\n")} return ${returnExpression};`;
         });
+        caseBlocks.push(`default: ${this.thisVariable} satisfies never; throw new Error("unrecognized type");`);
         return Maybe.of({
             isExported: true,
             kind: StructureKind.Function,
-            name: "hash",
+            name: `${syntheticNamePrefix}hash`,
             parameters: [
                 {
                     name: this.thisVariable,
@@ -230,16 +356,48 @@ return strictEquals(left.type, right.type).chain(() => {
             ],
         });
     }
+    get identifierTypeDeclarations() {
+        return [
+            {
+                isExported: true,
+                kind: StructureKind.TypeAlias,
+                name: `${syntheticNamePrefix}Identifier`,
+                type: this.identifierType.name,
+            },
+            {
+                isExported: true,
+                kind: StructureKind.Module,
+                name: `${syntheticNamePrefix}Identifier`,
+                statements: [
+                    this.identifierType.fromStringFunctionDeclaration,
+                    this.identifierType.toStringFunctionDeclaration,
+                ],
+            },
+        ];
+    }
+    get jsonTypeAliasDeclaration() {
+        if (!this.features.has("json")) {
+            return Maybe.empty();
+        }
+        return Maybe.of({
+            isExported: true,
+            kind: StructureKind.TypeAlias,
+            name: `${syntheticNamePrefix}Json`,
+            type: this.memberTypes
+                .map((memberType) => memberType.jsonName)
+                .join(" | "),
+        });
+    }
     get jsonZodSchemaFunctionDeclaration() {
-        if (!this.features.has("fromJson")) {
+        if (!this.features.has("json")) {
             return Maybe.empty();
         }
         const variables = { zod: "zod" };
         return Maybe.of({
             isExported: true,
             kind: StructureKind.Function,
-            name: "jsonZodSchema",
-            statements: `return ${variables.zod}.discriminatedUnion("${this._discriminatorProperty.name}", [${this.memberTypes.map((memberType) => memberType.jsonZodSchema({ variables })).join(", ")}]);`,
+            name: `${syntheticNamePrefix}jsonZodSchema`,
+            statements: `return ${variables.zod}.discriminatedUnion("${this._discriminatorProperty.name}", [${this.memberTypes.map((memberType) => memberType.jsonZodSchema({ context: "type", variables })).join(", ")}]);`,
         });
     }
     get sparqlFunctionDeclarations() {
@@ -252,10 +410,11 @@ return strictEquals(left.type, right.type).chain(() => {
             {
                 isExported: true,
                 kind: StructureKind.Function,
-                name: "sparqlConstructTemplateTriples",
+                name: `${syntheticNamePrefix}sparqlConstructTemplateTriples`,
                 // Accept ignoreRdfType in order to reuse code but don't pass it through, since deserialization may depend on it
                 parameters: [
                     {
+                        hasQuestionToken: true,
                         name: "parameters",
                         type: '{ ignoreRdfType?: boolean, subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                     },
@@ -263,26 +422,27 @@ return strictEquals(left.type, right.type).chain(() => {
                 returnType: "readonly sparqljs.Triple[]",
                 statements: [
                     `return [${this.memberTypes
-                        .map((memberType) => `...${memberType.name}.sparqlConstructTemplateTriples({ subject: parameters.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`)
+                        .map((memberType) => `...${memberType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTemplateTriples({ subject: parameters?.subject ?? dataFactory.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`)
                         .join(", ")}];`,
                 ],
             },
             {
                 isExported: true,
                 kind: StructureKind.Function,
-                name: "sparqlWherePatterns",
+                name: `${syntheticNamePrefix}sparqlWherePatterns`,
                 // Accept ignoreRdfType in order to reuse code but don't pass it through, since deserialization may depend on it
                 parameters: [
                     {
+                        hasQuestionToken: true,
                         name: "parameters",
-                        type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
+                        type: '{ ignoreRdfType?: boolean; languageIn?: readonly string[]; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                     },
                 ],
                 returnType: "readonly sparqljs.Pattern[]",
                 statements: [
                     `return [{ patterns: [${this.memberTypes
                         .map((memberType) => objectInitializer({
-                        patterns: `${memberType.name}.sparqlWherePatterns({ subject: parameters.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`,
+                        patterns: `${memberType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ subject: parameters?.subject ?? dataFactory.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`,
                         type: '"group"',
                     }))
                         .join(", ")}], type: "union" }];`,
@@ -291,37 +451,38 @@ return strictEquals(left.type, right.type).chain(() => {
         ];
     }
     get toJsonFunctionDeclaration() {
-        if (!this.features.has("toJson")) {
+        if (!this.features.has("json")) {
             return Maybe.empty();
         }
         const caseBlocks = this.memberTypes.map((memberType) => {
             let returnExpression;
             switch (memberType.declarationType) {
                 case "class":
-                    returnExpression = `${this.thisVariable}.toJson()`;
+                    returnExpression = `${this.thisVariable}.${syntheticNamePrefix}toJson()`;
                     break;
                 case "interface":
-                    returnExpression = `${memberType.name}.toJson(${this.thisVariable})`;
+                    returnExpression = `${memberType.staticModuleName}.${syntheticNamePrefix}toJson(${this.thisVariable})`;
                     break;
             }
-            return `case "${memberType.name}": return ${returnExpression};`;
+            return `${memberType.discriminatorPropertyValues.map((discriminatorPropertyValue) => `case "${discriminatorPropertyValue}":`).join("\n")} return ${returnExpression};`;
         });
+        caseBlocks.push(`default: ${this.thisVariable} satisfies never; throw new Error("unrecognized type");`);
         return Maybe.of({
             isExported: true,
             kind: StructureKind.Function,
-            name: "toJson",
+            name: `${syntheticNamePrefix}toJson`,
             parameters: [
                 {
                     name: this.thisVariable,
                     type: this.name,
                 },
             ],
-            returnType: this.jsonName,
+            returnType: this.jsonName.toString(),
             statements: `switch (${this.thisVariable}.${this._discriminatorProperty.name}) { ${caseBlocks.join(" ")} }`,
         });
     }
     get toRdfFunctionDeclaration() {
-        if (!this.features.has("toRdf")) {
+        if (!this.features.has("rdf")) {
             return Maybe.empty();
         }
         const parametersVariable = "_parameters";
@@ -329,29 +490,44 @@ return strictEquals(left.type, right.type).chain(() => {
             let returnExpression;
             switch (memberType.declarationType) {
                 case "class":
-                    returnExpression = `${this.thisVariable}.toRdf(${parametersVariable})`;
+                    returnExpression = `${this.thisVariable}.${syntheticNamePrefix}toRdf(${parametersVariable})`;
                     break;
                 case "interface":
-                    returnExpression = `${memberType.name}.toRdf(${this.thisVariable}, ${parametersVariable})`;
+                    returnExpression = `${memberType.staticModuleName}.${syntheticNamePrefix}toRdf(${this.thisVariable}, ${parametersVariable})`;
                     break;
             }
-            return `case "${memberType.name}": return ${returnExpression};`;
+            return `${memberType.discriminatorPropertyValues.map((discriminatorPropertyValue) => `case "${discriminatorPropertyValue}":`).join("\n")} return ${returnExpression};`;
         });
+        caseBlocks.push(`default: ${this.thisVariable} satisfies never; throw new Error("unrecognized type");`);
         return Maybe.of({
             isExported: true,
             kind: StructureKind.Function,
-            name: "toRdf",
+            name: `${syntheticNamePrefix}toRdf`,
             parameters: [
                 {
                     name: this.thisVariable,
                     type: this.name,
                 },
                 {
+                    hasQuestionToken: true,
                     name: parametersVariable,
-                    type: "{ mutateGraph: rdfjsResource.MutableResource.MutateGraph, resourceSet: rdfjsResource.MutableResourceSet }",
+                    type: "{ mutateGraph?: rdfjsResource.MutableResource.MutateGraph, resourceSet?: rdfjsResource.MutableResourceSet }",
                 },
             ],
-            returnType: this.rdfjsResourceType({ mutable: true }).name,
+            returnType: (() => {
+                let returnType;
+                for (const memberType of this.memberTypes) {
+                    const memberRdfjsResourceType = memberType.toRdfjsResourceType;
+                    if (typeof returnType === "undefined") {
+                        returnType = memberRdfjsResourceType;
+                    }
+                    else if (memberRdfjsResourceType !== returnType) {
+                        return "rdfjsResource.Resource";
+                    }
+                }
+                // The types agree
+                return returnType;
+            })(),
             statements: `switch (${this.thisVariable}.${this._discriminatorProperty.name}) { ${caseBlocks.join(" ")} }`,
         });
     }
@@ -366,45 +542,66 @@ return strictEquals(left.type, right.type).chain(() => {
     }
     fromJsonExpression({ variables, }) {
         // Assumes the JSON object has been recursively validated already.
-        return `${this.name}.fromJson(${variables.value}).unsafeCoerce()`;
+        return `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value}).unsafeCoerce()`;
     }
     fromRdfExpression({ variables, }) {
         // Don't ignoreRdfType, we may need it to distinguish the union members
-        return `${variables.resourceValues}.head().chain(value => value.to${this.rdfjsResourceType().named ? "Named" : ""}Resource()).chain(_resource => ${this.name}.fromRdf({ ...${variables.context}, languageIn: ${variables.languageIn}, resource: _resource }))`;
+        return `${variables.resourceValues}.chain(values => values.chainMap(value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...${variables.context}, ignoreRdfType: false, languageIn: ${variables.languageIn}, objectSet: ${variables.objectSet} }))))`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
     }
     hashStatements({ variables, }) {
         switch (this.memberTypes[0].declarationType) {
             case "class":
-                return [`${variables.value}.hash(${variables.hasher});`];
+                return [
+                    `${variables.value}.${syntheticNamePrefix}hash(${variables.hasher});`,
+                ];
             case "interface":
-                return [`${this.name}.hash(${variables.value}, ${variables.hasher});`];
+                return [
+                    `${this.staticModuleName}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
+                ];
         }
     }
+    jsonUiSchemaElement() {
+        return Maybe.empty();
+    }
     jsonZodSchema() {
-        return `${this.name}.jsonZodSchema()`;
+        return `${this.staticModuleName}.${syntheticNamePrefix}jsonZodSchema()`;
     }
-    sparqlConstructTemplateTriples({ context, variables, }) {
-        switch (context) {
-            case "property":
-                return super.sparqlConstructTemplateTriples({ context, variables });
-            case "type":
+    snippetDeclarations(parameters) {
+        const { recursionStack } = parameters;
+        if (recursionStack.some((type) => Object.is(type, this))) {
+            return [];
+        }
+        recursionStack.push(this);
+        const result = this.memberTypes.flatMap((memberType) => memberType.snippetDeclarations(parameters));
+        invariant(Object.is(recursionStack.pop(), this));
+        return result;
+    }
+    sparqlConstructTemplateTriples(parameters) {
+        switch (parameters.context) {
+            case "object":
+                return super.sparqlConstructTemplateTriples(parameters);
+            case "subject":
                 return [
-                    `...${this.name}.sparqlConstructTemplateTriples(${objectInitializer({
-                        subject: variables.subject,
-                        variablePrefix: variables.variablePrefix,
+                    `...${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTemplateTriples(${objectInitializer({
+                        subject: parameters.variables.subject,
+                        variablePrefix: parameters.variables.variablePrefix,
                     })})`,
                 ];
         }
     }
-    sparqlWherePatterns({ context, variables, }) {
-        switch (context) {
-            case "property":
-                return super.sparqlWherePatterns({ context, variables });
-            case "type":
+    sparqlWherePatterns(parameters) {
+        switch (parameters.context) {
+            case "object":
+                return super.sparqlWherePatterns(parameters);
+            case "subject":
                 return [
-                    `...${this.name}.sparqlWherePatterns(${objectInitializer({
-                        subject: variables.subject,
-                        variablePrefix: variables.variablePrefix,
+                    `...${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${objectInitializer({
+                        languageIn: parameters.variables.languageIn,
+                        subject: parameters.variables.subject,
+                        variablePrefix: parameters.variables.variablePrefix,
                     })})`,
                 ];
         }
@@ -412,43 +609,48 @@ return strictEquals(left.type, right.type).chain(() => {
     toJsonExpression({ variables, }) {
         switch (this.memberTypes[0].declarationType) {
             case "class":
-                return `${variables.value}.toJson()`;
+                return `${variables.value}.${syntheticNamePrefix}toJson()`;
             case "interface":
-                throw new Error("not implemented: need a freestanding toJson function like the toRdf function");
-            // return `${this.name}.toJson(${variables.value})`;
+                return `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
         }
     }
     toRdfExpression({ variables, }) {
         const options = `{ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }`;
         switch (this.memberTypes[0].declarationType) {
             case "class":
-                return `${variables.value}.toRdf(${options})`;
+                return `${variables.value}.${syntheticNamePrefix}toRdf(${options})`;
             case "interface":
-                return `${this.name}.toRdf(${variables.value}, ${options})`;
+                return `${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, ${options})`;
         }
     }
     useImports() {
         return [];
     }
-    rdfjsResourceType(options) {
-        const memberRdfjsResourceTypes = [];
-        for (const memberType of this.memberTypes) {
-            const memberRdfjsResourceType = memberType.rdfjsResourceType(options);
-            if (memberRdfjsResourceTypes.some((existingMemberRdfjsResourceType) => existingMemberRdfjsResourceType.name !==
-                memberRdfjsResourceType.name)) {
-                // The types don't agree, return a generic type
-                return {
-                    mutable: !!options?.mutable,
-                    name: "rdfjsResource.Resource",
-                    named: false,
-                };
-            }
-            memberRdfjsResourceTypes.push(memberRdfjsResourceType);
-        }
-        // The types agree
-        return memberRdfjsResourceTypes[0];
-    }
 }
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "discriminatorProperty", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "graphqlName", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "identifierTypeAlias", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "jsonName", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "mutable", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "objectSetMethodNames", null);
 __decorate([
     Memoize()
 ], ObjectUnionType.prototype, "thisVariable", null);