@shaclmate/compiler 2.0.13 → 2.0.15

package/generators/ts/UnionType.js

@@ -8,152 +8,259 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { Type } from "./Type.js";
-const syntheticTypeDiscriminatorPropertyName = "type";
-function syntheticTypeDiscriminatorValue({ type, typeIndex, }) {
-    return `${typeIndex}-${type.name}`;
-}
+import { objectInitializer } from "./objectInitializer.js";
 export class UnionType extends Type {
-    constructor({ memberTypes, ...superParameters }) {
+    constructor({ memberTypes, name, ...superParameters }) {
         super(superParameters);
         this.kind = "UnionType";
         invariant(memberTypes.length >= 2);
         this.memberTypes = memberTypes;
+        this._name = name;
+    }
+    get name() {
+        if (typeof this._name === "undefined") {
+            switch (this._discriminatorProperty.kind) {
+                case "shared":
+                    // If every type shares a discriminator (e.g., RDF/JS "termType" or generated ObjectType "type"),
+                    // just join their names with "|"
+                    this._name = `(${this.memberTypes.map((memberType) => memberType.name).join(" | ")})`;
+                    break;
+                case "synthetic":
+                    this._name = `(${this.memberTypeTraits.map((memberTypeTraits) => `{ ${this._discriminatorProperty.name}: "${memberTypeTraits.discriminatorPropertyValues[0]}", value: ${memberTypeTraits.memberType.name} }`).join(" | ")})`;
+                    break;
+            }
+        }
+        return this._name;
+    }
+    get conversions() {
+        return [
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+                sourceTypeName: this.name,
+            },
+        ];
     }
     get discriminatorProperty() {
-        return this.typesSharedDiscriminatorProperty.altLazy(() => Maybe.of({
-            name: syntheticTypeDiscriminatorPropertyName,
-            values: this.memberTypes.map((_, typeIndex) => typeIndex.toString()),
-        }));
+        return Maybe.of(this._discriminatorProperty);
     }
-    get name() {
-        if (this.typesSharedDiscriminatorProperty.isJust()) {
-            // If every type shares a discriminator (e.g., RDF/JS "termType" or generated ObjectType "type"),
-            // just join their names with "|"
-            return `(${this.memberTypes.map((type) => type.name).join(" | ")})`;
+    get equalsFunction() {
+        return `
+(left: ${this.name}, right: ${this.name}) => {
+${this.memberTypeTraits
+            .flatMap((memberTypeTraits) => memberTypeTraits.discriminatorPropertyValues.map((value) => `if (left.${this._discriminatorProperty.name} === "${value}" && right.${this._discriminatorProperty.name} === "${value}") {
+  return ${memberTypeTraits.memberType.equalsFunction}(${memberTypeTraits.payload("left")}, ${memberTypeTraits.payload("right")});
+}`))
+            .join("\n")}
+
+  return purify.Left({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "BooleanEquals" as const }, type: "Property" as const });
+}`;
+    }
+    get jsonName() {
+        switch (this._discriminatorProperty.kind) {
+            case "shared":
+                return this.memberTypes
+                    .map((memberType) => memberType.jsonName)
+                    .join(" | ");
+            case "synthetic":
+                return `(${this.memberTypeTraits.map((memberTypeTraits) => `{ ${this._discriminatorProperty.name}: "${memberTypeTraits.discriminatorPropertyValues[0]}", value: ${memberTypeTraits.memberType.jsonName} }`).join(" | ")})`;
+            default:
+                throw new RangeError(this._discriminatorProperty.kind);
         }
-        return `(${this.memberTypes.map((type, typeIndex) => `{ ${syntheticTypeDiscriminatorPropertyName}: "${syntheticTypeDiscriminatorValue({ type, typeIndex })}", value: ${type.name} }`).join(" | ")})`;
-    }
-    get typesSharedDiscriminatorProperty() {
-        // Do all the composed types share a single discriminator property?
-        let typesSharedDiscriminatorProperty;
-        for (const type of this.memberTypes) {
-            const typeDiscriminatorProperty = type.discriminatorProperty.extract();
-            if (!typeDiscriminatorProperty) {
-                return Maybe.empty();
+    }
+    get mutable() {
+        return this.memberTypes.some((memberType) => memberType.mutable);
+    }
+    get _discriminatorProperty() {
+        let sharedDiscriminatorProperty;
+        for (const memberType of this.memberTypes) {
+            const memberTypeDiscriminatorProperty = memberType.discriminatorProperty.extract();
+            if (!memberTypeDiscriminatorProperty) {
+                sharedDiscriminatorProperty = undefined;
+                break;
             }
-            if (!typesSharedDiscriminatorProperty) {
-                typesSharedDiscriminatorProperty = {
-                    name: typeDiscriminatorProperty.name,
-                    values: typeDiscriminatorProperty.values.concat(),
+            if (!sharedDiscriminatorProperty) {
+                sharedDiscriminatorProperty = {
+                    name: memberTypeDiscriminatorProperty.name,
+                    values: memberTypeDiscriminatorProperty.values.concat(),
                 };
             }
-            else if (typeDiscriminatorProperty.name === typesSharedDiscriminatorProperty.name) {
-                typesSharedDiscriminatorProperty.values =
-                    typesSharedDiscriminatorProperty.values.concat(typeDiscriminatorProperty.values);
+            else if (memberTypeDiscriminatorProperty.name ===
+                sharedDiscriminatorProperty.name) {
+                sharedDiscriminatorProperty.values =
+                    sharedDiscriminatorProperty.values.concat(memberTypeDiscriminatorProperty.values);
             }
             else {
-                return Maybe.empty();
+                sharedDiscriminatorProperty = undefined;
+                break;
             }
         }
-        return Maybe.fromNullable(typesSharedDiscriminatorProperty);
+        if (sharedDiscriminatorProperty) {
+            return {
+                ...sharedDiscriminatorProperty,
+                kind: "shared",
+            };
+        }
+        return {
+            kind: "synthetic",
+            name: "type",
+            values: this.memberTypes.map((memberType, memberTypeIndex) => `${memberTypeIndex}-${memberType.name}`),
+        };
     }
-    equalsFunction() {
-        return `
-(left: ${this.name}, right: ${this.name}) => {
-${this.memberTypes
-            .flatMap((type, typeIndex) => this.typesSharedDiscriminatorProperty
-            .map((typesSharedDiscriminatorProperty) => {
-            // Types share a discriminator property already, use it
-            return type.discriminatorProperty.unsafeCoerce().values.map((value) => `if (left.${typesSharedDiscriminatorProperty.name} === "${value}" && right.${typesSharedDiscriminatorProperty.name} === "${value}") {
-  return ${type.equalsFunction()}(left, right);
-}`);
-        })
-            .orDefaultLazy(() => [
-            // Types don't share a discriminator property, have to use the one we synthesized
-            `if (left.${syntheticTypeDiscriminatorPropertyName} === "${syntheticTypeDiscriminatorValue({ type, typeIndex })}" && right.${syntheticTypeDiscriminatorPropertyName} === "${syntheticTypeDiscriminatorValue({ type, typeIndex })}") {
-  return ${type.equalsFunction()}(left.value, right.value);
-}`,
-        ]))
-            .join("\n")}
-
-  return purify.Left({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "BooleanEquals" }, type: "Property" });
-}`;
+    get memberTypeTraits() {
+        switch (this._discriminatorProperty.kind) {
+            case "shared":
+                return this.memberTypes.map((memberType) => ({
+                    discriminatorPropertyValues: memberType.discriminatorProperty.unsafeCoerce().values,
+                    memberType,
+                    payload: (instance) => instance,
+                }));
+            case "synthetic":
+                return this.memberTypes.map((memberType, memberTypeIndex) => ({
+                    discriminatorPropertyValues: [
+                        `${memberTypeIndex}-${memberType.name}`,
+                    ],
+                    memberType,
+                    payload: (instance) => `${instance}.value`,
+                }));
+            default:
+                throw new RangeError(this._discriminatorProperty.kind);
+        }
+    }
+    fromJsonExpression({ variables, }) {
+        return this.ternaryExpression({
+            memberTypeExpression: (memberTypeTraits) => {
+                let typeExpression = memberTypeTraits.memberType.fromJsonExpression({
+                    variables: {
+                        value: memberTypeTraits.payload(variables.value),
+                    },
+                });
+                if (this._discriminatorProperty.kind === "synthetic") {
+                    typeExpression = `{ ${this._discriminatorProperty.name}: "${memberTypeTraits.discriminatorPropertyValues[0]}" as const, value: ${typeExpression} }`;
+                }
+                return typeExpression;
+            },
+            variables,
+        });
     }
     fromRdfExpression(parameters) {
-        let expression = "";
-        this.memberTypes.forEach((type, typeIndex) => {
-            let typeExpression = type.fromRdfExpression(parameters);
-            if (!this.typesSharedDiscriminatorProperty.isJust()) {
-                typeExpression = `${typeExpression}.map(value => ({ type: "${typeIndex}-${type.name}" as const, value }) as (${this.name}))`;
+        return this.memberTypeTraits.reduce((expression, memberTypeTraits) => {
+            let typeExpression = memberTypeTraits.memberType.fromRdfExpression(parameters);
+            if (this._discriminatorProperty.kind === "synthetic") {
+                typeExpression = `${typeExpression}.map(value => ({ ${this._discriminatorProperty.name}: "${memberTypeTraits.discriminatorPropertyValues[0]}" as const, value }) as (${this.name}))`;
             }
             typeExpression = `(${typeExpression} as purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>)`;
-            expression =
-                expression.length > 0
-                    ? `${expression}.altLazy(() => ${typeExpression})`
-                    : typeExpression;
-        });
-        return expression;
+            return expression.length > 0
+                ? `${expression}.altLazy(() => ${typeExpression})`
+                : typeExpression;
+        }, "");
     }
-    hashStatements({ variables, }) {
+    hashStatements({ depth, variables, }) {
         const caseBlocks = [];
-        this.memberTypes.forEach((type, typeIndex) => {
-            if (this.typesSharedDiscriminatorProperty.isJust()) {
-                for (const typeDiscriminatorPropertyValue of type.discriminatorProperty.unsafeCoerce()
-                    .values) {
-                    caseBlocks.push(`case "${typeDiscriminatorPropertyValue}": { ${type.hashStatements({
-                        variables,
-                    })}; break; }`);
-                }
-            }
-            else {
-                caseBlocks.push(`case "${syntheticTypeDiscriminatorValue({
-                    type,
-                    typeIndex,
-                })}": { ${type.hashStatements({ variables: { hasher: variables.hasher, value: `${variables}.value` } })}; break; }`);
+        for (const memberTypeTraits of this.memberTypeTraits) {
+            for (const discriminatorPropertyValue of memberTypeTraits.discriminatorPropertyValues) {
+                caseBlocks.push(`case "${discriminatorPropertyValue}": { ${memberTypeTraits.memberType
+                    .hashStatements({
+                    depth: depth + 1,
+                    variables: {
+                        hasher: variables.hasher,
+                        value: `${memberTypeTraits.payload(variables.value)}`,
+                    },
+                })
+                    .join("\n")}; break; }`);
             }
-        });
-        const switchValue = this.typesSharedDiscriminatorProperty
-            .map((typeSharedDiscriminatorProperty) => `${variables.value}.${typeSharedDiscriminatorProperty.name}`)
-            .orDefaultLazy(() => `${variables.value}.${syntheticTypeDiscriminatorPropertyName}`);
-        return [`switch (${switchValue}) { ${caseBlocks.join("\n")} }`];
-    }
-    propertySparqlGraphPatternExpression(parameters) {
-        return new Type.SparqlGraphPatternExpression(`sparqlBuilder.GraphPattern.union(${this.memberTypes
-            .map((type) => type
-            .propertySparqlGraphPatternExpression(parameters)
-            .toSparqlGraphPatternExpression()
-            .toString())
-            .join(", ")})`);
+        }
+        return [
+            `switch (${variables.value}.${this._discriminatorProperty.name}) { ${caseBlocks.join("\n")} }`,
+        ];
     }
-    toRdfExpression({ variables, }) {
-        let expression = "";
-        this.memberTypes.forEach((type, typeIndex) => {
-            if (this.typesSharedDiscriminatorProperty.isJust()) {
-                if (expression.length === 0) {
-                    expression = type.toRdfExpression({
-                        variables,
-                    });
-                }
-                else {
-                    expression = `(${type.discriminatorProperty
-                        .unsafeCoerce()
-                        .values.map((value) => `${variables.value}.${this.typesSharedDiscriminatorProperty.unsafeCoerce().name} === "${value}"`)
-                        .join(" || ")}) ? ${type.toRdfExpression({ variables })} : ${expression}`;
-                }
-            }
-            else {
-                if (expression.length === 0) {
-                    expression = type.toRdfExpression({
-                        variables: { ...variables, value: `${variables.value}.value` },
-                    });
-                }
-                else {
-                    // No shared type discriminator between the types, use the one we synthesized
-                    expression = `(${variables.value}.${syntheticTypeDiscriminatorPropertyName} === "${syntheticTypeDiscriminatorValue({ type, typeIndex })}") ? (${type.toRdfExpression({ variables: { ...variables, value: `${variables.value}.value` } })}) : (${expression})`;
+    jsonZodSchema({ variables, }) {
+        switch (this._discriminatorProperty.kind) {
+            case "shared":
+                return `${variables.zod}.discriminatedUnion("${this._discriminatorProperty.name}", [${this.memberTypes
+                    .map((memberType) => memberType.jsonZodSchema({ variables }))
+                    .join(", ")}])`;
+            case "synthetic":
+                return `${variables.zod}.discriminatedUnion("${this._discriminatorProperty.name}", [${this.memberTypeTraits
+                    .map((memberTypeTraits) => `${variables.zod}.object({ ${this._discriminatorProperty.name}: ${variables.zod}.literal("${memberTypeTraits.discriminatorPropertyValues[0]}"), value: ${memberTypeTraits.memberType.jsonZodSchema({ variables })} })`)
+                    .join(", ")}])`;
+            default:
+                throw new RangeError(this._discriminatorProperty.kind);
+        }
+    }
+    sparqlConstructTemplateTriples(parameters) {
+        return this.memberTypes.reduce((array, memberType) => array.concat(memberType.sparqlConstructTemplateTriples(parameters)), []);
+    }
+    sparqlWherePatterns(parameters) {
+        let haveEmptyGroup = false; // Only need one empty group
+        return [
+            `{ patterns: [${this.memberTypes
+                .flatMap((memberType) => {
+                const groupPatterns = memberType.sparqlWherePatterns(parameters);
+                if (groupPatterns.length === 0) {
+                    if (haveEmptyGroup) {
+                        return [];
+                    }
+                    haveEmptyGroup = true;
+                    return [objectInitializer({ patterns: "[]", type: '"group"' })];
                 }
-            }
+                return [
+                    objectInitializer({
+                        patterns: `[${groupPatterns.join(", ")}]`,
+                        type: '"group"',
+                    }),
+                ];
+            })
+                .join(", ")}], type: "union" }`,
+        ];
+    }
+    toJsonExpression({ variables, }) {
+        switch (this._discriminatorProperty.kind) {
+            case "shared":
+                return this.ternaryExpression({
+                    memberTypeExpression: (memberTypeTraits) => memberTypeTraits.memberType.toJsonExpression({
+                        variables: {
+                            ...variables,
+                            value: memberTypeTraits.payload(variables.value),
+                        },
+                    }),
+                    variables,
+                });
+            case "synthetic":
+                return this.ternaryExpression({
+                    memberTypeExpression: (memberTypeTraits) => `{ ${this._discriminatorProperty.name}: "${memberTypeTraits.discriminatorPropertyValues[0]}" as const, value: ${memberTypeTraits.memberType.toJsonExpression({
+                        variables: {
+                            ...variables,
+                            value: memberTypeTraits.payload(variables.value),
+                        },
+                    })} }`,
+                    variables,
+                });
+        }
+    }
+    toRdfExpression({ variables, }) {
+        return this.ternaryExpression({
+            memberTypeExpression: (memberTypeTraits) => memberTypeTraits.memberType.toRdfExpression({
+                variables: {
+                    ...variables,
+                    value: memberTypeTraits.payload(variables.value),
+                },
+            }),
+            variables,
         });
-        return expression;
+    }
+    useImports(features) {
+        return this.memberTypes.flatMap((memberType) => memberType.useImports(features));
+    }
+    ternaryExpression({ memberTypeExpression, variables, }) {
+        return this.memberTypeTraits.reduce((expression, memberTypeTraits) => {
+            if (expression.length === 0) {
+                return memberTypeExpression(memberTypeTraits);
+            }
+            return `(${memberTypeTraits.discriminatorPropertyValues
+                .map((value) => `${variables.value}.${this._discriminatorProperty.name} === "${value}"`)
+                .join(" || ")}) ? ${memberTypeExpression(memberTypeTraits)} : ${expression}`;
+        }, "");
     }
 }
 __decorate([
@@ -161,5 +268,8 @@ __decorate([
 ], UnionType.prototype, "discriminatorProperty", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "typesSharedDiscriminatorProperty", null);
+], UnionType.prototype, "_discriminatorProperty", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "memberTypeTraits", null);
 //# sourceMappingURL=UnionType.js.map

package/generators/ts/_ObjectType/IdentifierProperty.d.ts

@@ -1,23 +1,42 @@
 import { Maybe } from "purify-ts";
-import { type GetAccessorDeclarationStructure, type OptionalKind, type PropertyDeclarationStructure, type PropertySignatureStructure } from "ts-morph";
-import { MintingStrategy } from "../../../ast";
+import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
+import type { MintingStrategy, PropertyVisibility } from "../../../enums/index.js";
 import type { IdentifierType } from "../IdentifierType.js";
+import { Import } from "../Import.js";
 import { Property } from "./Property.js";
 export declare class IdentifierProperty extends Property<IdentifierType> {
-    readonly equalsFunction = "purifyHelpers.Equatable.booleanEquals";
+    readonly abstract: boolean;
+    readonly equalsFunction = "booleanEquals";
+    readonly mutable = false;
+    private readonly classDeclarationVisibility;
+    private readonly lazyObjectTypeMutable;
     private readonly mintingStrategy;
-    constructor({ mintingStrategy, ...superParameters }: {
+    private readonly override;
+    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, mintingStrategy, override, ...superParameters }: {
+        abstract: boolean;
+        classDeclarationVisibility: Maybe<PropertyVisibility>;
+        lazyObjectTypeMutable: () => boolean;
         mintingStrategy: Maybe<MintingStrategy>;
+        override: boolean;
         type: IdentifierType;
     } & ConstructorParameters<typeof Property>[0]);
-    get classConstructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get classGetAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    get classPropertyDeclaration(): OptionalKind<PropertyDeclarationStructure>;
+    get classPropertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
+    get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    get declarationImports(): readonly Import[];
     get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get jsonPropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get snippetDeclarations(): readonly string[];
     classConstructorStatements({ variables, }: Parameters<Property<IdentifierType>["classConstructorStatements"]>[0]): readonly string[];
+    fromJsonStatements({ variables, }: Parameters<Property<IdentifierType>["fromJsonStatements"]>[0]): readonly string[];
     fromRdfStatements({ variables, }: Parameters<Property<IdentifierType>["fromRdfStatements"]>[0]): readonly string[];
-    hashStatements(parameters: Parameters<Property<IdentifierType>["hashStatements"]>[0]): readonly string[];
-    sparqlGraphPatternExpression(): Maybe<string>;
+    hashStatements(): readonly string[];
+    interfaceConstructorStatements({ variables, }: Parameters<Property<IdentifierType>["interfaceConstructorStatements"]>[0]): readonly string[];
+    jsonUiSchemaElement({ variables, }: Parameters<Property<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<string>;
+    jsonZodSchema({ variables, }: Parameters<Property<IdentifierType>["jsonZodSchema"]>[0]): ReturnType<Property<IdentifierType>["jsonZodSchema"]>;
+    sparqlConstructTemplateTriples(): readonly string[];
+    sparqlWherePatterns(): readonly string[];
+    toJsonObjectMember({ variables, }: Parameters<Property<IdentifierType>["toJsonObjectMember"]>[0]): string;
     toRdfStatements(): readonly string[];
 }
 //# sourceMappingURL=IdentifierProperty.d.ts.map