@shaclmate/compiler 2.0.13 → 2.0.14

package/generators/ts/_ObjectType/IdentifierProperty.js

@@ -1,58 +1,120 @@
 import { Maybe } from "purify-ts";
-import { Scope, } from "ts-morph";
-import { MintingStrategy } from "../../../ast";
+import { invariant } from "ts-invariant";
+import { Import } from "../Import.js";
 import { Property } from "./Property.js";
 export class IdentifierProperty extends Property {
-    constructor({ mintingStrategy, ...superParameters }) {
+    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, mintingStrategy, objectTypeDeclarationType, override, ...superParameters }) {
         super(superParameters);
         this.equalsFunction = "purifyHelpers.Equatable.booleanEquals";
-        this.mintingStrategy = mintingStrategy;
-    }
-    get classConstructorParametersPropertySignature() {
-        return Maybe.of({
-            hasQuestionToken: this.mintingStrategy.isJust(),
-            isReadonly: true,
-            name: this.name,
-            type: this.type.name,
-        });
+        this.mutable = false;
+        invariant(this.visibility === "public");
+        this.abstract = abstract;
+        this.classDeclarationVisibility = classDeclarationVisibility;
+        if (mintingStrategy.isJust()) {
+            this.mintingStrategy = mintingStrategy.unsafeCoerce();
+        }
+        else if (this.type.nodeKinds.has("BlankNode")) {
+            this.mintingStrategy = "blankNode";
+        }
+        else {
+            this.mintingStrategy = "none";
+        }
+        this.objectTypeDeclarationType = objectTypeDeclarationType;
+        this.lazyObjectTypeMutable = lazyObjectTypeMutable;
+        this.override = override;
     }
     get classGetAccessorDeclaration() {
-        if (!this.mintingStrategy.isJust()) {
+        if (this.abstract) {
             return Maybe.empty();
         }
         let mintIdentifier;
-        switch (this.mintingStrategy.unsafeCoerce()) {
-            case MintingStrategy.SHA256:
+        switch (this.mintingStrategy) {
+            case "blankNode":
+                mintIdentifier = "dataFactory.blankNode()";
+                break;
+            case "none":
+                // If there's no minting strategy the identifier will be required by the constructor and assigned to a public property.
+                return Maybe.empty();
+            case "sha256":
                 mintIdentifier =
                     "dataFactory.namedNode(`urn:shaclmate:object:${this.type}:${this.hash(sha256.create())}`)";
                 break;
-            case MintingStrategy.UUIDv4:
+            case "uuidv4":
                 mintIdentifier =
                     "dataFactory.namedNode(`urn:shaclmate:object:${this.type}:${uuid.v4()}`)";
                 break;
         }
         return Maybe.of({
+            leadingTrivia: this.override ? "override " : undefined,
             name: this.name,
             returnType: this.type.name,
             statements: [
-                `if (typeof this._${this.name} === "undefined") { this._${this.name} = ${mintIdentifier}; } return this._${this.name};`,
+                this.lazyObjectTypeMutable()
+                    ? `return (typeof this._${this.name} !== "undefined") ? this._${this.name} : ${mintIdentifier}`
+                    : `if (typeof this._${this.name} === "undefined") { this._${this.name} = ${mintIdentifier}; } return this._${this.name};`,
             ],
         });
     }
     get classPropertyDeclaration() {
-        if (this.mintingStrategy.isJust()) {
-            // Mutable _identifier that will be lazily initialized by the getter
-            return {
-                name: `_${this.name}`,
-                scope: Scope.Private,
-                type: `${this.type.name} | undefined`,
-            };
+        if (this.abstract) {
+            // Abstract version of the accessor
+            // Work around a ts-morph bug that puts the override keyword before the abstract keyword
+            return Maybe.of({
+                hasOverrideKeyword: this.abstract && this.override ? undefined : this.override,
+                isAbstract: this.abstract && this.override ? undefined : this.abstract,
+                isReadonly: true,
+                leadingTrivia: this.abstract && this.override ? "abstract override " : undefined,
+                name: this.name,
+                type: this.type.name,
+            });
         }
-        return {
+        // See note in TypeFactory re: the logic of whether to declare the identifier in the class or not.
+        if (!this.classDeclarationVisibility.isJust()) {
+            return Maybe.empty();
+        }
+        switch (this.mintingStrategy) {
+            case "none":
+                // Immutable, public identifier property, no getter
+                return Maybe.of({
+                    name: this.name,
+                    type: this.type.name,
+                });
+            default:
+                // Mutable _identifier property that will be lazily initialized by the getter to mint the identifier
+                return Maybe.of({
+                    name: `_${this.name}`,
+                    scope: this.classDeclarationVisibility
+                        .map(Property.visibilityToScope)
+                        .unsafeCoerce(),
+                    type: `${this.type.name} | undefined`,
+                });
+        }
+    }
+    get constructorParametersPropertySignature() {
+        if (this.objectTypeDeclarationType === "class" && this.abstract) {
+            return Maybe.empty();
+        }
+        return Maybe.of({
+            hasQuestionToken: this.objectTypeDeclarationType === "class" &&
+                this.mintingStrategy !== "none",
             isReadonly: true,
             name: this.name,
             type: this.type.name,
-        };
+        });
+    }
+    get declarationImports() {
+        const imports = this.type.useImports.concat();
+        if (this.objectTypeDeclarationType === "class") {
+            switch (this.mintingStrategy) {
+                case "sha256":
+                    imports.push(Import.SHA256);
+                    break;
+                case "uuidv4":
+                    imports.push(Import.UUID);
+                    break;
+            }
+        }
+        return imports;
     }
     get interfacePropertySignature() {
         return {
@@ -61,19 +123,69 @@ export class IdentifierProperty extends Property {
             type: this.type.name,
         };
     }
+    get jsonPropertySignature() {
+        return {
+            isReadonly: true,
+            name: "@id",
+            type: "string",
+        };
+    }
     classConstructorStatements({ variables, }) {
+        if (this.abstract) {
+            return [];
+        }
+        return this.classPropertyDeclaration
+            .map((classPropertyDeclaration) => [
+            `this.${classPropertyDeclaration.name} = ${variables.parameter};`,
+        ])
+            .orDefault([]);
+    }
+    fromJsonStatements({ variables, }) {
         return [
-            `this.${this.mintingStrategy.isJust() ? "_" : ""}${this.name} = ${variables.parameter};`,
+            `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: variables.jsonObject } })};`,
         ];
     }
     fromRdfStatements({ variables, }) {
         return [`const ${this.name} = ${variables.resource}.identifier`];
     }
-    hashStatements(parameters) {
-        return this.type.hashStatements(parameters);
+    hashStatements() {
+        return [];
+    }
+    interfaceConstructorStatements({ variables, }) {
+        return [`const ${this.name} = ${variables.parameter}`];
     }
-    sparqlGraphPatternExpression() {
-        return Maybe.empty();
+    jsonUiSchemaElement({ variables, }) {
+        return Maybe.of(`{ label: "Identifier", scope: \`\${${variables.scopePrefix}}/properties/${this.jsonPropertySignature.name}\`, type: "Control" }`);
+    }
+    jsonZodSchema({ variables, }) {
+        return {
+            key: this.jsonPropertySignature.name,
+            schema: `${variables.zod}.string().min(1)`,
+        };
+    }
+    sparqlConstructTemplateTriples() {
+        return [];
+    }
+    sparqlWherePatterns() {
+        return [];
+    }
+    toJsonObjectMember({ variables, }) {
+        const nodeKinds = [...this.type.nodeKinds];
+        const valueToNodeKinds = nodeKinds.map((nodeKind) => {
+            switch (nodeKind) {
+                case "BlankNode":
+                    return `\`_:\${${variables.value}.value}\``;
+                case "NamedNode":
+                    return `${variables.value}.value`;
+                default:
+                    throw new RangeError(nodeKind);
+            }
+        });
+        if (valueToNodeKinds.length === 1) {
+            return `"@id": ${valueToNodeKinds[0]}`;
+        }
+        invariant(valueToNodeKinds.length === 2);
+        return `"@id": ${variables.value}.termType === "${nodeKinds[0]}" ? ${valueToNodeKinds[0]} : ${valueToNodeKinds[1]}`;
     }
     toRdfStatements() {
         return [];

package/generators/ts/_ObjectType/Property.d.ts

@@ -1,38 +1,154 @@
+import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
-import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
-import type { Configuration } from "../Configuration.js";
+import { type GetAccessorDeclarationStructure, type OptionalKind, type PropertyDeclarationStructure, type PropertySignatureStructure, Scope } from "ts-morph";
+import type { PropertyVisibility } from "../../../enums/index.js";
+import type { Import } from "../Import.js";
 import type { Type } from "../Type.js";
 export declare abstract class Property<TypeT extends {
+    readonly mutable: boolean;
     readonly name: string;
 }> {
-    abstract readonly classConstructorParametersPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
+    /**
+     * Optional get accessor to include in a class declaration of the object type.
+     */
     abstract readonly classGetAccessorDeclaration: Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    abstract readonly classPropertyDeclaration: OptionalKind<PropertyDeclarationStructure>;
+    /**
+     * Optional property declaration to include in a class declaration of the object type.
+     */
+    abstract readonly classPropertyDeclaration: Maybe<OptionalKind<PropertyDeclarationStructure>>;
+    /**
+     * Optional property to include in the parameters object of a class constructor.
+     */
+    abstract readonly constructorParametersPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
+    /**
+     * Function declaration that takes two values of the property and compares them, returning and purifyHelpers.Equatable.EqualsResult.
+     */
     abstract readonly equalsFunction: string;
+    /**
+     * Signature of the property in an interface version of the object.
+     */
     abstract readonly interfacePropertySignature: OptionalKind<PropertySignatureStructure>;
+    /**
+     * Signature of the property when serialized to JSON (the type of toJsonObjectMember).
+     */
+    abstract readonly jsonPropertySignature: OptionalKind<PropertySignatureStructure>;
+    /**
+     * Is the property reassignable?
+     */
+    abstract readonly mutable: boolean;
+    /**
+     * TypeScript identifier-safe name of the property.
+     */
     readonly name: string;
+    /**
+     * Property type
+  .   */
     readonly type: TypeT;
-    protected readonly configuration: Configuration;
-    constructor({ configuration, name, type, }: {
-        configuration: Configuration;
+    /**
+     * Property visibility: private, protected, public.
+     */
+    readonly visibility: PropertyVisibility;
+    protected readonly dataFactoryVariable: string;
+    constructor({ dataFactoryVariable, name, type, visibility, }: {
+        dataFactoryVariable: string;
         name: string;
         type: TypeT;
+        visibility: PropertyVisibility;
     });
-    get importStatements(): readonly string[];
+    /**
+     * Imports this property requires when declared in an object.
+     */
+    get declarationImports(): readonly Import[];
+    protected static visibilityToScope(visibility: PropertyVisibility): Scope | undefined;
+    /**
+     * Statements to assign the parameter of described by constructorParametersPropertySignature to a class member.
+     */
     abstract classConstructorStatements(parameters: {
         variables: {
             parameter: string;
         };
     }): readonly string[];
+    /**
+     * Statements to deserialize JSON for this property (as described by toJsonObjectMember) to a typed value of the property.
+     */
+    abstract fromJsonStatements(parameters: {
+        variables: {
+            jsonObject: string;
+        };
+    }): readonly string[];
+    /**
+     * Statements to deserialize RDF for this property to a typed value of the property.
+     */
     abstract fromRdfStatements(parameters: {
         variables: {
+            context: string;
+            languageIn: string;
             resource: string;
         };
     }): readonly string[];
+    /**
+     * Statements to hash this property using a hasher instance.
+     */
     abstract hashStatements(parameters: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    abstract sparqlGraphPatternExpression(): Maybe<string>;
+    /**
+     * Companion to classConstructorStatements with a similar purpose in an interface's create() function.
+     */
+    abstract interfaceConstructorStatements(parameters: {
+        variables: {
+            parameter: string;
+        };
+    }): readonly string[];
+    /**
+     * Element object (usually a control https://jsonforms.io/docs/uischema/controls) for a JSON Forms UI schema.
+     */
+    abstract jsonUiSchemaElement(parameters: {
+        variables: {
+            scopePrefix: string;
+        };
+    }): Maybe<string>;
+    /**
+     * zod Object key: schema pair on the property serialized by toJsonObjectMember.
+     */
+    abstract jsonZodSchema(parameters: {
+        variables: {
+            zod: string;
+        };
+    }): {
+        readonly key: string;
+        readonly schema: string;
+    };
+    /**
+     * An array of SPARQL.js CONSTRUCT template triples for this property as strings (so they can incorporate runtime calls).
+     */
+    abstract sparqlConstructTemplateTriples(parameters: {
+        variables: {
+            subject: string;
+            variablePrefix: string;
+        };
+    }): readonly string[];
+    /**
+     * An array of SPARQL.js where patterns for this property as strings (so they can incorporate runtime calls).
+     */
+    abstract sparqlWherePatterns(parameters: {
+        variables: {
+            subject: string;
+            variablePrefix: string;
+        };
+    }): readonly string[];
+    /**
+     * property: expression to serialize a property to a JSON object member.
+     */
+    abstract toJsonObjectMember(parameters: {
+        variables: {
+            value: string;
+        };
+    }): string;
+    /**
+     * Statements to serialize this property to an RDF resource.
+     */
     abstract toRdfStatements(parameters: {
         variables: Omit<Parameters<Type["toRdfExpression"]>[0]["variables"], "predicate">;
     }): readonly string[];
+    protected rdfjsTermExpression(rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">): string;
 }
 //# sourceMappingURL=Property.d.ts.map

package/generators/ts/_ObjectType/Property.js

@@ -1,11 +1,33 @@
+import { Scope, } from "ts-morph";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 export class Property {
-    constructor({ configuration, name, type, }) {
-        this.configuration = configuration;
+    constructor({ dataFactoryVariable, name, type, visibility, }) {
+        this.dataFactoryVariable = dataFactoryVariable;
         this.name = name;
         this.type = type;
+        this.visibility = visibility;
     }
-    get importStatements() {
+    /**
+     * Imports this property requires when declared in an object.
+     */
+    get declarationImports() {
         return [];
     }
+    static visibilityToScope(visibility) {
+        switch (visibility) {
+            case "private":
+                return Scope.Private;
+            case "protected":
+                return Scope.Protected;
+            case "public":
+                return undefined;
+        }
+    }
+    rdfjsTermExpression(rdfjsTerm) {
+        return rdfjsTermExpression({
+            dataFactoryVariable: this.dataFactoryVariable,
+            rdfjsTerm,
+        });
+    }
 }
 //# sourceMappingURL=Property.js.map

package/generators/ts/_ObjectType/ShaclProperty.d.ts

@@ -1,25 +1,43 @@
 import type * as rdfjs from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
+import type { IdentifierType } from "../IdentifierType.js";
+import type { Import } from "../Import.js";
 import type { Type } from "../Type.js";
 import { Property } from "./Property.js";
 export declare class ShaclProperty extends Property<Type> {
+    readonly mutable: boolean;
+    private readonly comment;
+    private readonly description;
+    private readonly label;
     private readonly path;
-    constructor({ path, ...superParameters }: {
+    constructor({ comment, description, label, mutable, path, ...superParameters }: {
+        comment: Maybe<string>;
+        description: Maybe<string>;
+        label: Maybe<string>;
+        mutable: boolean;
         path: rdfjs.NamedNode;
         type: Type;
     } & 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 equalsFunction(): string;
-    get importStatements(): readonly string[];
     get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get jsonPropertySignature(): OptionalKind<PropertySignatureStructure>;
+    private get declarationComment();
     private get pathExpression();
     classConstructorStatements({ variables, }: Parameters<Property<Type>["classConstructorStatements"]>[0]): readonly string[];
+    fromJsonStatements({ variables, }: Parameters<Property<IdentifierType>["fromJsonStatements"]>[0]): readonly string[];
     fromRdfStatements({ variables, }: Parameters<Property<Type>["fromRdfStatements"]>[0]): readonly string[];
     hashStatements(parameters: Parameters<Property<Type>["hashStatements"]>[0]): readonly string[];
-    sparqlGraphPatternExpression(): Maybe<string>;
+    interfaceConstructorStatements({ variables, }: Parameters<Property<Type>["interfaceConstructorStatements"]>[0]): readonly string[];
+    jsonUiSchemaElement({ variables, }: Parameters<Property<Type>["jsonUiSchemaElement"]>[0]): Maybe<string>;
+    jsonZodSchema(parameters: Parameters<Property<Type>["jsonZodSchema"]>[0]): ReturnType<Property<Type>["jsonZodSchema"]>;
+    sparqlConstructTemplateTriples({ variables, }: Parameters<Property<Type>["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns({ variables, }: Parameters<Property<Type>["sparqlWherePatterns"]>[0]): readonly string[];
+    toJsonObjectMember(parameters: Parameters<Property<Type>["toJsonObjectMember"]>[0]): string;
     toRdfStatements({ variables, }: Parameters<Property<Type>["toRdfStatements"]>[0]): readonly string[];
 }
 //# sourceMappingURL=ShaclProperty.d.ts.map

package/generators/ts/_ObjectType/ShaclProperty.js

@@ -7,13 +7,30 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { pascalCase } from "change-case";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
+import { tsComment } from "../tsComment.js";
 import { Property } from "./Property.js";
 export class ShaclProperty extends Property {
-    constructor({ path, ...superParameters }) {
+    constructor({ comment, description, label, mutable, path, ...superParameters }) {
         super(superParameters);
+        this.comment = comment;
+        this.description = description;
+        this.label = label;
+        this.mutable = mutable;
         this.path = path;
     }
-    get classConstructorParametersPropertySignature() {
+    get classGetAccessorDeclaration() {
+        return Maybe.empty();
+    }
+    get classPropertyDeclaration() {
+        return Maybe.of({
+            isReadonly: !this.mutable,
+            leadingTrivia: this.declarationComment,
+            name: this.name,
+            scope: Property.visibilityToScope(this.visibility),
+            type: this.type.name,
+        });
+    }
+    get constructorParametersPropertySignature() {
         let hasQuestionToken = false;
         const typeNames = new Set(); // Remove duplicates with a set
         for (const conversion of this.type.conversions) {
@@ -27,35 +44,41 @@ export class ShaclProperty extends Property {
         return Maybe.of({
             hasQuestionToken,
             isReadonly: true,
+            leadingTrivia: this.declarationComment,
             name: this.name,
             type: [...typeNames].sort().join(" | "),
         });
     }
-    get classGetAccessorDeclaration() {
-        return Maybe.empty();
+    get declarationImports() {
+        return this.type.useImports;
     }
-    get classPropertyDeclaration() {
+    get equalsFunction() {
+        return this.type.equalsFunction;
+    }
+    get interfacePropertySignature() {
         return {
-            isReadonly: true,
+            isReadonly: !this.mutable,
+            leadingTrivia: this.declarationComment,
             name: this.name,
             type: this.type.name,
         };
     }
-    get equalsFunction() {
-        return this.type.equalsFunction();
-    }
-    get importStatements() {
-        return this.type.importStatements;
-    }
-    get interfacePropertySignature() {
+    get jsonPropertySignature() {
         return {
             isReadonly: true,
             name: this.name,
-            type: this.type.name,
+            type: this.type.jsonName,
         };
     }
+    get declarationComment() {
+        return this.comment
+            .alt(this.description)
+            .alt(this.label)
+            .map(tsComment)
+            .extract();
+    }
     get pathExpression() {
-        return `${this.configuration.dataFactoryVariable}.namedNode("${this.path.value}")`;
+        return `${this.dataFactoryVariable}.namedNode("${this.path.value}")`;
     }
     classConstructorStatements({ variables, }) {
         const typeConversions = this.type.conversions;
@@ -64,12 +87,17 @@ export class ShaclProperty extends Property {
         }
         const statements = [];
         for (const conversion of this.type.conversions) {
-            statements.push(`if (${conversion.sourceTypeCheckExpression ? conversion.sourceTypeCheckExpression(variables.parameter) : `typeof ${variables.parameter} === "${conversion.sourceTypeName}"`}) { this.${this.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
+            statements.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { this.${this.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
         }
         // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
-        statements.push(`{ this.${this.name} = ${variables.parameter}; // never\n }`);
+        statements.push(`{ this.${this.name} =( ${variables.parameter}) as never;\n }`);
         return [statements.join(" else ")];
     }
+    fromJsonStatements({ variables, }) {
+        return [
+            `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: `${variables.jsonObject}["${this.name}"]` } })};`,
+        ];
+    }
     fromRdfStatements({ variables, }) {
         return [
             `const _${this.name}Either: purify.Either<rdfjsResource.Resource.ValueError, ${this.type.name}> = ${this.type.fromRdfExpression({ variables: { ...variables, predicate: this.pathExpression, resourceValues: `${variables.resource}.values(${this.pathExpression}, { unique: true })` } })};`,
@@ -80,17 +108,63 @@ export class ShaclProperty extends Property {
     hashStatements(parameters) {
         return this.type.hashStatements(parameters);
     }
-    sparqlGraphPatternExpression() {
-        return Maybe.of(this.type
-            .propertySparqlGraphPatternExpression({
+    interfaceConstructorStatements({ variables, }) {
+        const typeConversions = this.type.conversions;
+        if (typeConversions.length === 1) {
+            return [`const ${this.name} = ${variables.parameter};`];
+        }
+        const statements = [`let ${this.name}: ${this.type.name};`];
+        const conversionBranches = [];
+        for (const conversion of this.type.conversions) {
+            conversionBranches.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${this.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
+        }
+        // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
+        conversionBranches.push(`{ ${this.name} =( ${variables.parameter}) as never;\n }`);
+        statements.push(conversionBranches.join(" else "));
+        return statements;
+    }
+    jsonUiSchemaElement({ variables, }) {
+        const scope = `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
+        return this.type
+            .jsonUiSchemaElement({ variables: { scopePrefix: scope } })
+            .altLazy(() => Maybe.of(`{ ${this.label.isJust() ? `label: "${this.label.unsafeCoerce()}", ` : ""}scope: ${scope}, type: "Control" }`));
+    }
+    jsonZodSchema(parameters) {
+        let schema = this.type.jsonZodSchema(parameters);
+        this.comment.alt(this.description).ifJust((description) => {
+            schema = `${schema}.describe(${JSON.stringify(description)})`;
+        });
+        return {
+            key: this.name,
+            schema,
+        };
+    }
+    sparqlConstructTemplateTriples({ variables, }) {
+        const objectString = `\`\${${variables.variablePrefix}}${pascalCase(this.name)}\``;
+        return this.type.sparqlConstructTemplateTriples({
+            context: "property",
+            variables: {
+                object: `${this.dataFactoryVariable}.variable!(${objectString})`,
+                predicate: this.rdfjsTermExpression(this.path),
+                subject: variables.subject,
+                variablePrefix: objectString,
+            },
+        });
+    }
+    sparqlWherePatterns({ variables, }) {
+        const objectString = `\`\${${variables.variablePrefix}}${pascalCase(this.name)}\``;
+        return this.type.sparqlWherePatterns({
+            context: "property",
             variables: {
-                object: `this.variable("${pascalCase(this.name)}")`,
-                predicate: this.pathExpression,
-                subject: "this.subject",
+                object: `${this.dataFactoryVariable}.variable!(${objectString})`,
+                predicate: this.rdfjsTermExpression(this.path),
+                subject: variables.subject,
+                variablePrefix: objectString,
             },
-        })
-            .toSparqlGraphPatternExpression()
-            .toString());
+        });
+    }
+    toJsonObjectMember(parameters) {
+        return `${this.name}: ${this.type.toJsonExpression(parameters)}`;
     }
     toRdfStatements({ variables, }) {
         return [