@shaclmate/compiler 4.0.94 → 4.0.96

package/dist/generators/ts/AbstractDiscriminatedUnionType.js

@@ -7,34 +7,46 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { AbstractDiscriminatedUnionType_conversionFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_conversionFunctionExpression.js";
-import { AbstractDiscriminatedUnionType_equalsFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_equalsFunctionExpression.js";
-import { AbstractDiscriminatedUnionType_filterFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_filterFunctionExpression.js";
+import { AbstractDiscriminatedUnionType_conversionFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_conversionFunction.js";
+import { AbstractDiscriminatedUnionType_equalsFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_equalsFunction.js";
+import { AbstractDiscriminatedUnionType_filterFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_filterFunction.js";
 import { AbstractDiscriminatedUnionType_filterTypeExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_filterTypeExpression.js";
-import { AbstractDiscriminatedUnionType_fromJsonFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromJsonFunctionExpression.js";
-import { AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.js";
-import { AbstractDiscriminatedUnionType_hashFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_hashFunctionExpression.js";
+import { AbstractDiscriminatedUnionType_fromJsonObjectFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromJsonObjectFunction.js";
+import { AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromRdfResourceValuesFunction.js";
+import { AbstractDiscriminatedUnionType_hashFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_hashFunction.js";
 import { AbstractDiscriminatedUnionType_inferDiscriminant } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inferDiscriminant.js";
 import { AbstractDiscriminatedUnionType_inlineExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inlineExpression.js";
-import { AbstractDiscriminatedUnionType_jsonSchemaExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_jsonSchemaExpression.js";
-import { AbstractDiscriminatedUnionType_jsonTypeLiteral } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_jsonTypeLiteral.js";
 import { AbstractDiscriminatedUnionType_schemaTypeExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.js";
-import { AbstractDiscriminatedUnionType_toJsonFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonFunctionExpression.js";
-import { AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression.js";
-import { AbstractDiscriminatedUnionType_toStringFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toStringFunctionExpression.js";
-import { AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.js";
-import { AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.js";
-import { AbstractType } from "./AbstractType.js";
+import { AbstractDiscriminatedUnionType_toJsonObjectFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonObjectFunction.js";
+import { AbstractDiscriminatedUnionType_toLoggableFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toLoggableFunction.js";
+import { AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toRdfResourceValuesFunction.js";
+import { AbstractDiscriminatedUnionType_toStringFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toStringFunction.js";
+import { AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunction.js";
+import { AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunction.js";
+import { AbstractCompoundType } from "./AbstractCompoundType.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
-export class AbstractDiscriminatedUnionType extends AbstractType {
+export class AbstractDiscriminatedUnionType extends AbstractCompoundType {
     discriminant;
+    equalsFunctionExpression = AbstractDiscriminatedUnionType_equalsFunctionExpression;
+    filterFunctionExpression = AbstractDiscriminatedUnionType_filterFunctionExpression;
+    filterTypeExpression = AbstractDiscriminatedUnionType_filterTypeExpression;
+    fromJsonObjectFunctionExpression = AbstractDiscriminatedUnionType_fromJsonObjectFunctionExpression;
+    fromRdfResourceValuesFunctionExpression = AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression;
+    hashFunctionExpression = AbstractDiscriminatedUnionType_hashFunctionExpression;
+    schemaTypeExpression = AbstractDiscriminatedUnionType_schemaTypeExpression;
+    toJsonObjectFunctionExpression = AbstractDiscriminatedUnionType_toJsonObjectFunctionExpression;
+    toLoggableFunctionExpression = AbstractDiscriminatedUnionType_toLoggableFunctionExpression;
+    toRdfResourceValuesFunctionExpression = AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression;
+    toStringFunctionExpression = AbstractDiscriminatedUnionType_toStringFunctionExpression;
+    valueSparqlConstructTriplesFunctionExpression = AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression;
+    valueSparqlWherePatternsFunctionExpression = AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression;
     graphqlArgs = Maybe.empty();
-    identifierType;
+    identifierProperty;
     recursive;
     validationFunction = Maybe.empty();
-    constructor({ identifierType, members, recursive, ...superParameters }) {
+    constructor({ identifierProperty, members, recursive, ...superParameters }) {
         super(superParameters);
-        this.identifierType = identifierType;
+        this.identifierProperty = identifierProperty;
         invariant(members.length >= 2);
         this.recursive = recursive;
         this.discriminant = AbstractDiscriminatedUnionType_inferDiscriminant.call(this, members);
@@ -49,7 +61,8 @@ export class AbstractDiscriminatedUnionType extends AbstractType {
                     break;
                 case "Intrinsic": {
                     discriminantValues =
-                        member.type.discriminantProperty.unsafeCoerce().values;
+                        member.type.discriminatedType.unsafeCoerce().discriminantProperty
+                            .values;
                     break;
                 }
                 case "Typeof":
@@ -59,41 +72,26 @@ export class AbstractDiscriminatedUnionType extends AbstractType {
                     throw this.discriminant;
             }
             invariant(discriminantValues.length > 0);
-            const typeCheck = (json) => (instance) => {
-                const discriminant = this.discriminant; // To get type narrowing to work
-                if (discriminant.kind === "Typeof") {
-                    return code `(${joinCode(discriminantValues.map((discriminantValue) => code `typeof ${instance} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
-                }
-                // Causes problems in mixed Object | other dicriminated unions
-                // if (discriminant.kind === "Intrinsic" && !json) {
-                //   switch (member.type.kind) {
-                //     case "Object":
-                //     case "ObjectDiscriminatedUnion":
-                //       return code`${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(${instance})`;
-                //   }
-                // }
-                const discriminantName = json
-                    ? discriminant.jsonName
-                    : discriminant.name;
-                return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}["${discriminantName}"] === ${literalOf(discriminantValue)}`), { on: " || " })})`;
-            };
             return {
                 discriminantValues,
-                jsonType: member.type.jsonType({
-                    includeDiscriminantProperty: this.discriminant.kind === "Intrinsic" ||
-                        (this.discriminant.kind === "Hybrid" &&
-                            this.discriminant.memberValues[memberI].kind === "Intrinsic"),
-                }).expression,
-                jsonTypeCheck: typeCheck(true),
                 primaryDiscriminantValue: discriminantValues[0],
                 type: member.type,
-                typeCheck: typeCheck(false),
-                typeToJsonExpression: (valueVariable) => member.type.toJsonExpression({
-                    includeDiscriminantProperty: this.discriminant.kind === "Intrinsic" ||
-                        (this.discriminant.kind === "Hybrid" &&
-                            this.discriminant.memberValues[memberI].kind === "Intrinsic"),
-                    variables: { value: valueVariable },
-                }),
+                typeCheck: (instance) => {
+                    const discriminant = this.discriminant; // To get type narrowing to work
+                    if (discriminant.kind === "Typeof") {
+                        return code `(${joinCode(discriminantValues.map((discriminantValue) => code `typeof ${instance} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
+                    }
+                    // Causes problems in mixed Object | other dicriminated unions
+                    // if (discriminant.kind === "Intrinsic" && !json) {
+                    //   switch (member.type.kind) {
+                    //     case "Object":
+                    //     case "ObjectDiscriminatedUnion":
+                    //       return code`${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(${instance})`;
+                    //   }
+                    // }
+                    const discriminantName = discriminant.name;
+                    return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}["${discriminantName}"] === ${literalOf(discriminantValue)}`), { on: " || " })})`;
+                },
                 unwrap: (instance) => {
                     switch (this.discriminant.kind) {
                         case "Extrinsic":
@@ -125,6 +123,9 @@ export class AbstractDiscriminatedUnionType extends AbstractType {
             };
         });
     }
+    get jsonValueType() {
+        return this.jsonObjectType;
+    }
     get conversionFunction() {
         if (this.conversionFunctionExpression.isNothing()) {
             return this.conversionFunctionExpression;
@@ -136,25 +137,31 @@ export class AbstractDiscriminatedUnionType extends AbstractType {
         }))
             .orDefault(this.conversionFunctionExpression);
     }
-    get discriminantProperty() {
+    get discriminatedType() {
         switch (this.discriminant.kind) {
             case "Extrinsic":
                 return Maybe.of({
-                    jsonName: this.discriminant.jsonName,
-                    name: this.discriminant.name,
-                    values: this.discriminant.memberValues,
+                    discriminantProperty: {
+                        name: this.discriminant.name,
+                        values: this.discriminant.memberValues,
+                    },
+                    expression: this.expression,
                 });
             case "Hybrid":
                 return Maybe.of({
-                    jsonName: this.discriminant.jsonName,
-                    name: "termType",
-                    values: this.discriminant.memberValues.flatMap((_) => _.values),
+                    discriminantProperty: {
+                        name: "termType",
+                        values: this.discriminant.memberValues.flatMap((_) => _.values),
+                    },
+                    expression: this.expression,
                 });
             case "Intrinsic":
                 return Maybe.of({
-                    jsonName: this.discriminant.jsonName,
-                    name: this.discriminant.name,
-                    values: this.discriminant.memberValues,
+                    discriminantProperty: {
+                        name: this.discriminant.name,
+                        values: this.discriminant.memberValues,
+                    },
+                    expression: this.expression,
                 });
             case "Typeof":
                 return Maybe.empty();
@@ -162,25 +169,35 @@ export class AbstractDiscriminatedUnionType extends AbstractType {
                 throw this.discriminant;
         }
     }
-    get equalsFunction() {
-        return this.name
-            .map((name) => code `${name}.equals`)
-            .orDefault(AbstractDiscriminatedUnionType_equalsFunctionExpression.call(this));
-    }
-    get filterFunction() {
-        return this.name
-            .map((name) => code `${name}.filter`)
-            .orDefault(AbstractDiscriminatedUnionType_filterFunctionExpression.call(this));
-    }
-    get filterType() {
-        return this.name
-            .map((name) => code `${name}.Filter`)
-            .orDefault(AbstractDiscriminatedUnionType_filterTypeExpression.call(this));
-    }
-    get fromRdfResourceValuesFunction() {
-        return this.name
-            .map((name) => code `${name}.fromRdfResourceValues`)
-            .orDefault(AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.call(this));
+    get jsonObjectType() {
+        return this.jsonTypeFactory.createJsonDiscriminatedUnionType(this.members.flatMap((member) => {
+            const memberJsonObjectType = member.type.jsonObjectType;
+            switch (memberJsonObjectType.kind) {
+                case "JsonDiscriminatedUnion":
+                    return memberJsonObjectType.members;
+                case "JsonObject":
+                    return [
+                        {
+                            discriminantValue: member.primaryDiscriminantValue,
+                            type: memberJsonObjectType,
+                        },
+                    ];
+                case "JsonIntersection":
+                    if (memberJsonObjectType.memberTypes.every((member) => member.kind === "JsonObject")) {
+                        return [
+                            {
+                                discriminantValue: member.primaryDiscriminantValue,
+                                type: memberJsonObjectType,
+                            },
+                        ];
+                    }
+                    break;
+            }
+            throw new Error(`unable to create JSON discriminated union from ${memberJsonObjectType.kind}`);
+        }), {
+            name: this.name.map((name) => [name, "Json"]).extract(),
+            recursive: this.recursive,
+        });
     }
     get graphqlType() {
         const name = this.name.extract();
@@ -188,77 +205,22 @@ export class AbstractDiscriminatedUnionType extends AbstractType {
             !this.members.every((member) => member.type.kind === "Object")) {
             throw new Error("not implemented");
         }
-        return new AbstractType.GraphqlType(code `${name}.GraphQL`, this.reusables);
-    }
-    get hashFunction() {
-        return this.name
-            .map((name) => code `${name}.hash`)
-            .orDefault(AbstractDiscriminatedUnionType_hashFunctionExpression.call(this));
+        return new AbstractCompoundType.GraphqlType(code `${name}.GraphQL`, this.reusables);
     }
     get jsTypes() {
         const jsTypes = [];
         for (const member of this.members) {
             for (const memberJsType of member.type.jsTypes) {
-                if (!jsTypes.some((jsType) => AbstractType.JsType.equals(jsType, memberJsType))) {
+                if (!jsTypes.some((jsType) => AbstractCompoundType.JsType.equals(jsType, memberJsType))) {
                     jsTypes.push(memberJsType);
                 }
             }
         }
         return jsTypes;
     }
-    get jsonSchemaFunctionDeclaration() {
-        let expression = AbstractDiscriminatedUnionType_jsonSchemaExpression.call(this);
-        const meta = {
-        // id: this.name,
-        };
-        this.comment.ifJust((description) => {
-            meta["description"] = description;
-        });
-        this.label.ifJust((label) => {
-            meta["title"] = label;
-        });
-        if (Object.keys(meta).length > 0) {
-            expression = code `${expression}.meta(${meta})`;
-        }
-        return code `export const schema = () => ${expression};`;
-    }
-    get jsonTypeAliasDeclaration() {
-        return code `export type Json = ${AbstractDiscriminatedUnionType_jsonTypeLiteral.call(this).expression}`;
-    }
     get members() {
         return this.lazyMembers();
     }
-    get mutable() {
-        return this.members.some((member) => member.type.mutable);
-    }
-    get referencesNamedType() {
-        return (this.name.isJust() ||
-            this.members.some((member) => member.type.referencesNamedType));
-    }
-    get schemaType() {
-        return this.name
-            .map(() => code `typeof ${this.schema}`)
-            .orDefault(AbstractDiscriminatedUnionType_schemaTypeExpression.call(this));
-    }
-    get toRdfResourceValueTypes() {
-        const set = new Set();
-        for (const member of this.members) {
-            for (const value of member.type.toRdfResourceValueTypes) {
-                set.add(value);
-            }
-        }
-        return set;
-    }
-    get valueSparqlConstructTriplesFunction() {
-        return this.name
-            .map((name) => code `${name}.valueSparqlConstructTriples`)
-            .orDefault(AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.call(this));
-    }
-    get valueSparqlWherePatternsFunction() {
-        return this.name
-            .map((name) => code `${name}.valueSparqlWherePatterns`)
-            .orDefault(AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.call(this));
-    }
     get inlineExpression() {
         return AbstractDiscriminatedUnionType_inlineExpression.call(this);
     }
@@ -271,39 +233,6 @@ export class AbstractDiscriminatedUnionType extends AbstractType {
     get conversionFunctionExpression() {
         return AbstractDiscriminatedUnionType_conversionFunctionExpression.call(this);
     }
-    fromJsonExpression({ variables, }) {
-        return code `${this.name.map((name) => code `${name}.fromJson`).orDefault(AbstractDiscriminatedUnionType_fromJsonFunctionExpression.call(this))}(${variables.value})`;
-    }
-    graphqlResolveExpression({ variables, }) {
-        return variables.value;
-    }
-    jsonSchema({ context, }) {
-        const expression = this.name
-            .map((name) => code `${name}.Json.schema()`)
-            .orDefault(AbstractDiscriminatedUnionType_jsonSchemaExpression.call(this));
-        if (context === "property" && this.recursive) {
-            return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.jsonType().expression}> => ${expression})`;
-        }
-        return expression;
-    }
-    jsonType() {
-        return this.name
-            .map((name) => new AbstractType.JsonType(code `${name}.Json`))
-            .orDefault(AbstractDiscriminatedUnionType_jsonTypeLiteral.call(this));
-    }
-    jsonUiSchemaElement() {
-        return Maybe.empty();
-    }
-    toJsonExpression({ variables, }) {
-        return code `${this.name.map((name) => code `${name}.toJson`).orDefault(AbstractDiscriminatedUnionType_toJsonFunctionExpression.call(this))}(${variables.value})`;
-    }
-    toRdfResourceValuesExpression({ variables, }) {
-        const { value: valueVariable, ...otherVariables } = variables;
-        return code `${this.name.map((name) => code `${name}.toRdfResourceValues`).orDefault(AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression.call(this))}(${valueVariable}, ${otherVariables})`;
-    }
-    toStringExpression({ variables, }) {
-        return code `${this.name.map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString`).orDefault(AbstractDiscriminatedUnionType_toStringFunctionExpression.call(this))}(${variables.value})`;
-    }
     staticModuleDeclarations(name) {
         const staticModuleDeclarations = {
             ...super.staticModuleDeclarations(name),
@@ -312,63 +241,6 @@ export class AbstractDiscriminatedUnionType extends AbstractType {
             staticModuleDeclarations["convert"] =
                 code `export const convert = ${conversionFunction.code};`;
         });
-        if (this.configuration.features.has("Object.equals")) {
-            staticModuleDeclarations["equals"] =
-                code `export const equals = ${AbstractDiscriminatedUnionType_equalsFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.filter")) {
-            staticModuleDeclarations["Filter"] =
-                code `export type Filter = ${AbstractDiscriminatedUnionType_filterTypeExpression.call(this)};`;
-            staticModuleDeclarations["filter"] =
-                code `export const filter = ${AbstractDiscriminatedUnionType_filterFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.hash")) {
-            staticModuleDeclarations["hash"] =
-                code `export const hash = ${AbstractDiscriminatedUnionType_hashFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.JSON.type")) {
-            staticModuleDeclarations["Json.type"] =
-                code `${this.jsonTypeAliasDeclaration}`;
-        }
-        if (this.configuration.features.has("Object.JSON.schema")) {
-            staticModuleDeclarations["Json.namespace"] = code `\
-export namespace Json {
-  ${this.jsonSchemaFunctionDeclaration}
-
-  export function parse(json: unknown): ${this.reusables.imports.Either}<Error, Json> {
-    const jsonSafeParseResult = schema().safeParse(json);
-    if (!jsonSafeParseResult.success) { return ${this.reusables.imports.Left}(jsonSafeParseResult.error); }
-    return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
-  }
-}`;
-        }
-        if (this.configuration.features.has("Object.fromJson")) {
-            staticModuleDeclarations["fromJson"] =
-                code `export const fromJson = ${AbstractDiscriminatedUnionType_fromJsonFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.fromRdf")) {
-            staticModuleDeclarations["fromRdfResourceValues"] =
-                code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${name}, ${this.schemaType}> = ${AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.toJson")) {
-            staticModuleDeclarations["toJson"] =
-                code `export const toJson = ${AbstractDiscriminatedUnionType_toJsonFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.toRdf")) {
-            staticModuleDeclarations["toRdfResourceValues"] =
-                code `export const toRdfResourceValues = ${AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.SPARQL")) {
-            staticModuleDeclarations["valueSparqlConstructTriples"] =
-                code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.call(this)};`;
-            staticModuleDeclarations["valueSparqlWherePatterns"] =
-                code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.toString")) {
-            const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-            staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
-                code `export const ${syntheticNamePrefix}toString = ${AbstractDiscriminatedUnionType_toStringFunctionExpression.call(this)};`;
-        }
         return staticModuleDeclarations;
     }
     lazyMembers;
@@ -378,53 +250,23 @@ __decorate([
 ], AbstractDiscriminatedUnionType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
-], AbstractDiscriminatedUnionType.prototype, "discriminantProperty", null);
-__decorate([
-    Memoize()
-], AbstractDiscriminatedUnionType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], AbstractDiscriminatedUnionType.prototype, "filterFunction", null);
-__decorate([
-    Memoize()
-], AbstractDiscriminatedUnionType.prototype, "filterType", null);
+], AbstractDiscriminatedUnionType.prototype, "discriminatedType", null);
 __decorate([
     Memoize()
-], AbstractDiscriminatedUnionType.prototype, "fromRdfResourceValuesFunction", null);
+], AbstractDiscriminatedUnionType.prototype, "jsonObjectType", null);
 __decorate([
     Memoize()
 ], AbstractDiscriminatedUnionType.prototype, "graphqlType", null);
-__decorate([
-    Memoize()
-], AbstractDiscriminatedUnionType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
 ], AbstractDiscriminatedUnionType.prototype, "jsTypes", null);
 __decorate([
     Memoize()
 ], AbstractDiscriminatedUnionType.prototype, "members", null);
-__decorate([
-    Memoize()
-], AbstractDiscriminatedUnionType.prototype, "mutable", null);
-__decorate([
-    Memoize()
-], AbstractDiscriminatedUnionType.prototype, "schemaType", null);
-__decorate([
-    Memoize()
-], AbstractDiscriminatedUnionType.prototype, "toRdfResourceValueTypes", null);
-__decorate([
-    Memoize()
-], AbstractDiscriminatedUnionType.prototype, "valueSparqlConstructTriplesFunction", null);
-__decorate([
-    Memoize()
-], AbstractDiscriminatedUnionType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
 ], AbstractDiscriminatedUnionType.prototype, "inlineExpression", null);
 __decorate([
     Memoize()
 ], AbstractDiscriminatedUnionType.prototype, "conversionFunctionExpression", null);
-__decorate([
-    Memoize()
-], AbstractDiscriminatedUnionType.prototype, "jsonType", null);
 //# sourceMappingURL=AbstractDiscriminatedUnionType.js.map

package/dist/generators/ts/AbstractIdentifierType.d.ts

@@ -1,18 +1,23 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
 import { AbstractTermType } from "./AbstractTermType.js";
+import type { Callable } from "./Callable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractIdentifierType<IdentifierT extends BlankNode | NamedNode> extends AbstractTermType<NamedNode, IdentifierT> {
+    readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     readonly jsTypes: readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
     }];
     abstract readonly kind: "BlankNode" | "Identifier" | "Iri";
     abstract readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
-    abstract readonly parseFunction: Code;
-    readonly stringifyFunction: Code;
-    get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
+    abstract readonly parseFunction: Callable;
+    get discriminatedType(): Maybe<AbstractTermType.DiscriminatedType>;
+    get jsonObjectType(): AbstractTermType["jsonObjectType"];
+    get jsonValueType(): AbstractTermType["jsonValueType"];
     graphqlResolveExpression({ variables: { value }, }: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
+    toLoggableExpression({ variables, }: Parameters<AbstractTermType<NamedNode>["toLoggableExpression"]>[0]): Code;
 }
 export declare namespace AbstractIdentifierType {
     type ConversionFunction = AbstractTermType.ConversionFunction;

package/dist/generators/ts/AbstractIdentifierType.js

@@ -4,22 +4,51 @@ 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 { AbstractTermType } from "./AbstractTermType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class AbstractIdentifierType extends AbstractTermType {
+    graphqlType = new AbstractTermType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
     jsTypes = [
         { instanceof: "Object", typeof: "object" },
     ];
-    stringifyFunction = code `${this.reusables.imports.NTriplesTerm}.stringify`;
-    get graphqlType() {
-        return new AbstractTermType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
+    get discriminatedType() {
+        return Maybe.of({
+            discriminantProperty: {
+                jsonName: "termType",
+                name: "termType",
+                values: [...this.termTypes],
+            },
+            expression: this.expression,
+        });
+    }
+    get jsonObjectType() {
+        return this.jsonTypeFactory.createJsonObjectType({
+            "@id": { type: this.jsonValueType },
+        }, {
+            snippet: this.reusables.snippets.IdentifierJsonObject,
+        });
+    }
+    get jsonValueType() {
+        return this.jsonTypeFactory.createJsonStringType({
+            minLength: 1n,
+        });
     }
     graphqlResolveExpression({ variables: { value }, }) {
-        return code `${this.reusables.imports.NTriplesTerm}.stringify(${value})`;
+        return code `${this.reusables.imports.NTriplesIdentifier}.stringify(${value})`;
+    }
+    toLoggableExpression({ variables, }) {
+        return code `${variables.value}.value`;
     }
 }
 __decorate([
     Memoize()
-], AbstractIdentifierType.prototype, "graphqlType", null);
+], AbstractIdentifierType.prototype, "discriminatedType", null);
+__decorate([
+    Memoize()
+], AbstractIdentifierType.prototype, "jsonObjectType", null);
+__decorate([
+    Memoize()
+], AbstractIdentifierType.prototype, "jsonValueType", null);
 //# sourceMappingURL=AbstractIdentifierType.js.map

package/dist/generators/ts/AbstractIntersectionType.d.ts

@@ -0,0 +1,48 @@
+import { Maybe } from "purify-ts";
+import { AbstractIntersectionType_equalsFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_equalsFunction.js";
+import { AbstractIntersectionType_filterFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_filterFunction.js";
+import { AbstractIntersectionType_hashFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_hashFunction.js";
+import { AbstractIntersectionType_toLoggableFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_toLoggableFunction.js";
+import { AbstractIntersectionType_toStringFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_toStringFunction.js";
+import { AbstractIntersectionType_valueSparqlConstructTriplesFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_valueSparqlConstructTriplesFunction.js";
+import { AbstractIntersectionType_valueSparqlWherePatternsFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_valueSparqlWherePatternsFunction.js";
+import { AbstractCompoundType } from "./AbstractCompoundType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { Type } from "./Type.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractIntersectionType<MemberTypeT extends Type> extends AbstractCompoundType<AbstractIntersectionType.Member<MemberTypeT>, MemberTypeT> {
+    protected equalsFunctionExpression: typeof AbstractIntersectionType_equalsFunctionExpression;
+    protected filterFunctionExpression: typeof AbstractIntersectionType_filterFunctionExpression;
+    protected hashFunctionExpression: typeof AbstractIntersectionType_hashFunctionExpression;
+    protected toLoggableFunctionExpression: typeof AbstractIntersectionType_toLoggableFunctionExpression;
+    protected toStringFunctionExpression: typeof AbstractIntersectionType_toStringFunctionExpression;
+    protected valueSparqlConstructTriplesFunctionExpression: typeof AbstractIntersectionType_valueSparqlConstructTriplesFunctionExpression;
+    protected valueSparqlWherePatternsFunctionExpression: typeof AbstractIntersectionType_valueSparqlWherePatternsFunctionExpression;
+    readonly conversionFunction: AbstractCompoundType<AbstractIntersectionType.Member<MemberTypeT>, MemberTypeT>["conversionFunction"];
+    readonly graphqlArgs: AbstractCompoundType<AbstractIntersectionType.Member<MemberTypeT>, MemberTypeT>["graphqlArgs"];
+    readonly identifierProperty: Maybe<ObjectType.IdentifierProperty>;
+    abstract readonly kind: "ObjectIntersection" | "Intersection";
+    readonly members: readonly AbstractIntersectionType.Member<MemberTypeT>[];
+    readonly recursive: boolean;
+    readonly validationFunction: AbstractCompoundType<AbstractIntersectionType.Member<MemberTypeT>, MemberTypeT>["validationFunction"];
+    constructor({ identifierProperty, members, recursive, ...superParameters }: {
+        identifierProperty: Maybe<ObjectType.IdentifierProperty>;
+        members: readonly AbstractIntersectionType.Member<MemberTypeT>[];
+        recursive: boolean;
+        synthetic: boolean;
+    } & ConstructorParameters<typeof AbstractCompoundType<AbstractIntersectionType.Member<MemberTypeT>, MemberTypeT>>[0]);
+    get graphqlType(): AbstractCompoundType.GraphqlType;
+    get jsTypes(): AbstractCompoundType<AbstractIntersectionType.Member<MemberTypeT>, MemberTypeT>["jsTypes"];
+    protected get inlineExpression(): Code;
+    protected get schemaInitializers(): readonly Code[];
+    protected filterTypeExpression(): Code;
+    protected schemaTypeExpression(): Code;
+}
+export declare namespace AbstractIntersectionType {
+    type DiscriminatedType = AbstractCompoundType.DiscriminatedType;
+    type JsonType = AbstractCompoundType.JsonType;
+    interface Member<TypeT extends Type> {
+        readonly type: TypeT;
+    }
+}
+//# sourceMappingURL=AbstractIntersectionType.d.ts.map