@shaclmate/compiler 2.0.20 → 2.0.23

package/dist/generators/ts/_ObjectType/IdentifierPrefixProperty.d.ts

@@ -1,31 +1,32 @@
-import type { IdentifierType } from "generators/ts/IdentifierType.js";
-import type { Import } from "generators/ts/Import.js";
 import { Maybe } from "purify-ts";
 import { type GetAccessorDeclarationStructure, type OptionalKind, type PropertyDeclarationStructure, type PropertySignatureStructure } from "ts-morph";
+import type { IdentifierType } from "../IdentifierType.js";
+import type { Import } from "../Import.js";
 import type { StringType } from "../StringType.js";
 import { Property } from "./Property.js";
 export declare class IdentifierPrefixProperty extends Property<StringType> {
-    readonly equalsFunction = "strictEquals";
-    readonly mutable = false;
     private readonly own;
+    readonly declarationImports: readonly Import[];
+    readonly equalsFunction = "$strictEquals";
+    readonly graphqlField: Property<StringType>["graphqlField"];
+    readonly propertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
+    readonly jsonPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
+    readonly mutable = false;
+    readonly recursive = false;
     constructor({ own, ...superParameters }: {
         own: boolean;
         type: StringType;
     } & ConstructorParameters<typeof Property>[0]);
-    get classGetAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    get classPropertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
     get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    get declarationImports(): readonly Import[];
-    get interfacePropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    get jsonPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    get snippetDeclarations(): readonly string[];
-    classConstructorStatements({ variables, }: Parameters<Property<IdentifierType>["classConstructorStatements"]>[0]): readonly string[];
+    constructorStatements({ variables, }: Parameters<Property<IdentifierType>["constructorStatements"]>[0]): readonly string[];
     fromJsonStatements(): readonly string[];
     fromRdfStatements(): readonly string[];
+    get getAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
     hashStatements(): readonly string[];
-    interfaceConstructorStatements(): readonly string[];
     jsonUiSchemaElement(): Maybe<string>;
     jsonZodSchema(): ReturnType<Property<IdentifierType>["jsonZodSchema"]>;
+    get propertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
+    snippetDeclarations(): readonly string[];
     sparqlConstructTemplateTriples(): readonly string[];
     sparqlWherePatterns(): readonly string[];
     toJsonObjectMember(): Maybe<string>;

package/dist/generators/ts/_ObjectType/IdentifierPrefixProperty.js

@@ -2,37 +2,22 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Scope, } from "ts-morph";
 import { SnippetDeclarations } from "../SnippetDeclarations.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { Property } from "./Property.js";
 export class IdentifierPrefixProperty extends Property {
-    equalsFunction = "strictEquals";
-    mutable = false;
     own;
+    declarationImports = [];
+    equalsFunction = `${syntheticNamePrefix}strictEquals`;
+    graphqlField = Maybe.empty();
+    propertySignature = Maybe.empty();
+    jsonPropertySignature = Maybe.empty();
+    mutable = false;
+    recursive = false;
     constructor({ own, ...superParameters }) {
         super(superParameters);
         invariant(this.visibility === "protected");
         this.own = own;
     }
-    get classGetAccessorDeclaration() {
-        return Maybe.of({
-            leadingTrivia: `protected ${!this.own ? "override " : ""}`,
-            name: this.name,
-            returnType: this.type.name,
-            statements: [
-                `return (typeof this._${this.name} !== "undefined") ? this._${this.name} : \`urn:shaclmate:\${this.type}:\``,
-            ],
-        });
-    }
-    get classPropertyDeclaration() {
-        return this.own
-            ? Maybe.of({
-                hasQuestionToken: true,
-                isReadonly: true,
-                name: `_${this.name}`,
-                scope: Scope.Protected,
-                type: this.type.name,
-            })
-            : Maybe.empty();
-    }
     get constructorParametersPropertySignature() {
         return Maybe.of({
             hasQuestionToken: true,
@@ -41,28 +26,17 @@ export class IdentifierPrefixProperty extends Property {
             type: this.type.name,
         });
     }
-    get declarationImports() {
-        return [];
-    }
-    get interfacePropertySignature() {
-        return Maybe.empty();
-    }
-    get jsonPropertySignature() {
-        return Maybe.empty();
-    }
-    get snippetDeclarations() {
-        const snippetDeclarations = [];
-        if (this.objectType.features.has("equals")) {
-            snippetDeclarations.push(SnippetDeclarations.strictEquals);
+    constructorStatements({ variables, }) {
+        switch (this.objectType.declarationType) {
+            case "class":
+                return this.propertyDeclaration
+                    .map((propertyDeclaration) => [
+                    `this.${propertyDeclaration.name} = ${variables.parameter};`,
+                ])
+                    .orDefault([]);
+            case "interface":
+                return [];
         }
-        return snippetDeclarations;
-    }
-    classConstructorStatements({ variables, }) {
-        return this.classPropertyDeclaration
-            .map((classPropertyDeclaration) => [
-            `this.${classPropertyDeclaration.name} = ${variables.parameter};`,
-        ])
-            .orDefault([]);
     }
     fromJsonStatements() {
         return [];
@@ -70,10 +44,17 @@ export class IdentifierPrefixProperty extends Property {
     fromRdfStatements() {
         return [];
     }
-    hashStatements() {
-        return [];
+    get getAccessorDeclaration() {
+        return Maybe.of({
+            leadingTrivia: `protected ${!this.own ? "override " : ""}`,
+            name: this.name,
+            returnType: this.type.name,
+            statements: [
+                `return (typeof this._${this.name} !== "undefined") ? this._${this.name} : \`urn:shaclmate:\${this.${syntheticNamePrefix}type}:\``,
+            ],
+        });
     }
-    interfaceConstructorStatements() {
+    hashStatements() {
         return [];
     }
     jsonUiSchemaElement() {
@@ -82,6 +63,24 @@ export class IdentifierPrefixProperty extends Property {
     jsonZodSchema() {
         return Maybe.empty();
     }
+    get propertyDeclaration() {
+        return this.own
+            ? Maybe.of({
+                hasQuestionToken: true,
+                isReadonly: true,
+                name: `_${this.name}`,
+                scope: Scope.Protected,
+                type: this.type.name,
+            })
+            : Maybe.empty();
+    }
+    snippetDeclarations() {
+        const snippetDeclarations = [];
+        if (this.objectType.features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.strictEquals);
+        }
+        return snippetDeclarations;
+    }
     sparqlConstructTemplateTriples() {
         return [];
     }

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

@@ -1,37 +1,44 @@
 import { Maybe } from "purify-ts";
-import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
+import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure, Scope } from "ts-morph";
 import type { IdentifierMintingStrategy, 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 abstract: boolean;
-    readonly equalsFunction = "booleanEquals";
-    readonly mutable = false;
-    private readonly classDeclarationVisibility;
+    private readonly classGetAccessorScope;
+    private readonly classPropertyDeclarationVisibility;
     private readonly identifierMintingStrategy;
+    private readonly identifierPrefixPropertyName;
     private readonly override;
-    constructor({ abstract, classDeclarationVisibility, identifierMintingStrategy, override, ...superParameters }: {
+    private readonly typeAlias;
+    readonly abstract: boolean;
+    readonly equalsFunction = "$booleanEquals";
+    readonly mutable = false;
+    readonly recursive = false;
+    constructor({ abstract, classGetAccessorScope, classPropertyDeclarationVisibility, identifierMintingStrategy, identifierPrefixPropertyName, override, typeAlias, ...superParameters }: {
         abstract: boolean;
-        classDeclarationVisibility: Maybe<PropertyVisibility>;
+        classGetAccessorScope: Maybe<Scope>;
+        classPropertyDeclarationVisibility: Maybe<PropertyVisibility>;
         identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
+        identifierPrefixPropertyName: string;
         override: boolean;
         type: IdentifierType;
+        typeAlias: string;
     } & ConstructorParameters<typeof Property>[0]);
-    get classGetAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    get classPropertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
     get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get declarationImports(): readonly Import[];
-    get interfacePropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    get getAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
+    get graphqlField(): Property<IdentifierType>["graphqlField"];
     get jsonPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    get snippetDeclarations(): readonly string[];
-    classConstructorStatements({ variables, }: Parameters<Property<IdentifierType>["classConstructorStatements"]>[0]): readonly string[];
+    constructorStatements({ variables, }: Parameters<Property<IdentifierType>["constructorStatements"]>[0]): readonly string[];
     fromJsonStatements({ variables, }: Parameters<Property<IdentifierType>["fromJsonStatements"]>[0]): readonly string[];
     fromRdfStatements({ variables, }: Parameters<Property<IdentifierType>["fromRdfStatements"]>[0]): readonly string[];
     hashStatements({ variables, }: Parameters<Property<IdentifierType>["hashStatements"]>[0]): 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"]>;
+    get propertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
+    get propertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    snippetDeclarations(): readonly string[];
     sparqlConstructTemplateTriples(): readonly string[];
     sparqlWherePatterns(): readonly string[];
     toJsonObjectMember({ variables, }: Parameters<Property<IdentifierType>["toJsonObjectMember"]>[0]): Maybe<string>;

package/dist/generators/ts/_ObjectType/IdentifierProperty.js

@@ -3,92 +3,31 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Import } from "../Import.js";
 import { SnippetDeclarations } from "../SnippetDeclarations.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { Property } from "./Property.js";
 export class IdentifierProperty extends Property {
-    abstract;
-    equalsFunction = "booleanEquals";
-    mutable = false;
-    classDeclarationVisibility;
+    classGetAccessorScope;
+    classPropertyDeclarationVisibility;
     identifierMintingStrategy;
+    identifierPrefixPropertyName;
     override;
-    constructor({ abstract, classDeclarationVisibility, identifierMintingStrategy, override, ...superParameters }) {
+    typeAlias;
+    abstract;
+    equalsFunction = `${syntheticNamePrefix}booleanEquals`;
+    mutable = false;
+    recursive = false;
+    constructor({ abstract, classGetAccessorScope, classPropertyDeclarationVisibility, identifierMintingStrategy, identifierPrefixPropertyName, override, typeAlias, ...superParameters }) {
         super(superParameters);
         invariant(this.visibility === "public");
         this.abstract = abstract;
-        this.classDeclarationVisibility = classDeclarationVisibility;
+        this.classGetAccessorScope = classGetAccessorScope;
+        this.classPropertyDeclarationVisibility =
+            classPropertyDeclarationVisibility;
         this.identifierMintingStrategy = identifierMintingStrategy;
+        this.identifierPrefixPropertyName = identifierPrefixPropertyName;
         this.override = override;
-    }
-    get classGetAccessorDeclaration() {
-        if (this.abstract) {
-            return Maybe.empty();
-        }
-        if (this.identifierMintingStrategy.isNothing()) {
-            return Maybe.empty();
-        }
-        let memoizeMintedIdentifier;
-        let mintIdentifier;
-        switch (this.identifierMintingStrategy.unsafeCoerce()) {
-            case "blankNode":
-                memoizeMintedIdentifier = true;
-                mintIdentifier = "dataFactory.blankNode()";
-                break;
-            case "sha256":
-                // If the object is mutable don't memoize the minted identifier, since the hash will change if the object mutates.
-                memoizeMintedIdentifier = !this.objectType.mutable();
-                mintIdentifier =
-                    "dataFactory.namedNode(`${this.identifierPrefix}${this.hashShaclProperties(sha256.create())}`)";
-                break;
-            case "uuidv4":
-                memoizeMintedIdentifier = true;
-                mintIdentifier =
-                    "dataFactory.namedNode(`${this.identifierPrefix}${uuid.v4()}`)";
-                break;
-        }
-        return Maybe.of({
-            leadingTrivia: this.override ? "override " : undefined,
-            name: this.name,
-            returnType: this.type.name,
-            statements: [
-                memoizeMintedIdentifier
-                    ? `if (typeof this._${this.name} === "undefined") { this._${this.name} = ${mintIdentifier}; } return this._${this.name};`
-                    : `return (typeof this._${this.name} !== "undefined") ? this._${this.name} : ${mintIdentifier}`,
-            ],
-        });
-    }
-    get classPropertyDeclaration() {
-        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,
-            });
-        }
-        // 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();
-        }
-        if (this.identifierMintingStrategy.isJust()) {
-            // 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`,
-            });
-        }
-        // Immutable, public identifier property, no getter
-        return Maybe.of({
-            isReadonly: true,
-            name: this.name,
-            type: this.type.name,
-        });
+        this.typeAlias = typeAlias;
     }
     get constructorParametersPropertySignature() {
         if (this.objectType.declarationType === "class" && this.abstract) {
@@ -125,11 +64,54 @@ export class IdentifierProperty extends Property {
         }
         return imports;
     }
-    get interfacePropertySignature() {
+    get getAccessorDeclaration() {
+        if (this.classGetAccessorScope.isNothing()) {
+            return Maybe.empty();
+        }
+        invariant(this.classGetAccessorScope.unsafeCoerce() === "public");
+        if (this.identifierMintingStrategy.isJust()) {
+            let memoizeMintedIdentifier;
+            let mintIdentifier;
+            switch (this.identifierMintingStrategy.unsafeCoerce()) {
+                case "blankNode":
+                    memoizeMintedIdentifier = true;
+                    mintIdentifier = "dataFactory.blankNode()";
+                    break;
+                case "sha256":
+                    // If the object is mutable don't memoize the minted identifier, since the hash will change if the object mutates.
+                    memoizeMintedIdentifier = !this.objectType.mutable;
+                    mintIdentifier = `dataFactory.namedNode(\`\${this.${this.identifierPrefixPropertyName}}\${this.${syntheticNamePrefix}hashShaclProperties(sha256.create())}\`)`;
+                    break;
+                case "uuidv4":
+                    memoizeMintedIdentifier = true;
+                    mintIdentifier = `dataFactory.namedNode(\`\${this.${this.identifierPrefixPropertyName}}\${uuid.v4()}\`)`;
+                    break;
+            }
+            return Maybe.of({
+                leadingTrivia: this.override ? "override " : undefined,
+                name: this.name,
+                returnType: this.typeAlias,
+                statements: [
+                    memoizeMintedIdentifier
+                        ? `if (typeof this._${this.name} === "undefined") { this._${this.name} = ${mintIdentifier}; } return this._${this.name};`
+                        : `return (typeof this._${this.name} !== "undefined") ? this._${this.name} : ${mintIdentifier}`,
+                ],
+            });
+        }
+        invariant(this.propertyDeclaration.isNothing());
         return Maybe.of({
-            isReadonly: true,
+            leadingTrivia: this.override ? "override " : undefined,
             name: this.name,
-            type: this.type.name,
+            returnType: this.typeAlias,
+            statements: [`return super.${this.name} as ${this.typeAlias}`],
+        });
+    }
+    get graphqlField() {
+        invariant(this.name.startsWith(syntheticNamePrefix));
+        return Maybe.of({
+            name: `_${this.name.substring(syntheticNamePrefix.length)}`,
+            resolve: `(source) => ${this.typeAlias}.toString(source.${this.name})`,
+            type: this.type.graphqlName.toString(),
         });
     }
     get jsonPropertySignature() {
@@ -139,38 +121,45 @@ export class IdentifierProperty extends Property {
             type: "string",
         });
     }
-    get snippetDeclarations() {
-        const snippetDeclarations = [];
-        if (this.objectType.features.has("equals")) {
-            snippetDeclarations.push(SnippetDeclarations.booleanEquals);
-        }
-        return snippetDeclarations;
-    }
-    classConstructorStatements({ variables, }) {
-        if (this.abstract) {
-            return [];
-        }
-        if (this.classPropertyDeclaration.isNothing()) {
-            return [];
-        }
-        const classPropertyDeclaration = this.classPropertyDeclaration.unsafeCoerce();
+    constructorStatements({ variables, }) {
+        let lhs;
+        const statements = [];
         const typeConversions = this.type.conversions;
-        if (typeConversions.length === 1) {
-            return [
-                `this.${classPropertyDeclaration.name} = ${variables.parameter};`,
-            ];
+        switch (this.objectType.declarationType) {
+            case "class": {
+                if (this.abstract) {
+                    return [];
+                }
+                if (this.propertyDeclaration.isNothing()) {
+                    return [];
+                }
+                const propertyDeclaration = this.propertyDeclaration.unsafeCoerce();
+                if (typeConversions.length === 1) {
+                    return [`this.${propertyDeclaration.name} = ${variables.parameter};`];
+                }
+                lhs = `this.${propertyDeclaration.name}`;
+                break;
+            }
+            case "interface":
+                if (typeConversions.length === 1) {
+                    return [`const ${this.name} = ${variables.parameter};`];
+                }
+                lhs = this.name;
+                statements.push(`let ${this.name}: ${this.typeAlias};`);
+                break;
         }
-        const statements = [];
-        for (const conversion of this.type.conversions) {
+        const conversionBranches = [];
+        for (const conversion of typeConversions) {
             invariant(conversion.sourceTypeName !== "undefined");
-            statements.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { this.${classPropertyDeclaration.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
+            conversionBranches.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${lhs} = ${conversion.conversionExpression(variables.parameter)}; }`);
         }
-        if (classPropertyDeclaration.name.startsWith("_")) {
-            statements.push(`if (typeof ${variables.parameter} === "undefined") { }`);
+        if (lhs.startsWith("this._")) {
+            conversionBranches.push(`if (typeof ${variables.parameter} === "undefined") { }`);
         }
         // 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.${classPropertyDeclaration.name} =( ${variables.parameter}) as never;\n }`);
-        return [statements.join(" else ")];
+        conversionBranches.push(`{ ${lhs} = (${variables.parameter}) satisfies never;\n }`);
+        statements.push(conversionBranches.join(" else "));
+        return statements;
     }
     fromJsonStatements({ variables, }) {
         return [
@@ -182,30 +171,20 @@ export class IdentifierProperty extends Property {
             // Treat sh:in as a union of the IRIs
             // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
             return [
-                `let ${this.name}: ${this.type.name};`,
-                `switch (${variables.resource}.identifier.value) { ${this.type.in_.map((iri) => `case "${iri.value}": ${this.name} = ${this.rdfjsTermExpression(iri)}; break;`).join(" ")} default: return purify.Left(new rdfjsResource.Resource.MistypedValueError({ actualValue: ${variables.resource}.identifier, expectedValueType: ${JSON.stringify(this.type.name)}, focusResource: ${variables.resource}, predicate: ${this.rdfjsTermExpression(rdf.subject)} })); }`,
+                `let ${this.name}: ${this.typeAlias};`,
+                `switch (${variables.resource}.identifier.value) { ${this.type.in_.map((iri) => `case "${iri.value}": ${this.name} = ${rdfjsTermExpression(iri)}; break;`).join(" ")} default: return purify.Left(new rdfjsResource.Resource.MistypedValueError({ actualValue: ${variables.resource}.identifier, expectedValueType: ${JSON.stringify(this.type.name)}, focusResource: ${variables.resource}, predicate: ${rdfjsTermExpression(rdf.subject)} })); }`,
             ];
         }
-        return [`const ${this.name} = ${variables.resource}.identifier`];
+        const statements = [];
+        if (this.type.isNamedNodeKind) {
+            statements.push(`if (${variables.resource}.identifier.termType !== "NamedNode") { return purify.Left(new rdfjsResource.Resource.MistypedValueError({ actualValue: ${variables.resource}.identifier, expectedValueType: ${JSON.stringify(this.type.name)}, focusResource: ${variables.resource}, predicate: ${rdfjsTermExpression(rdf.subject)} })); }`);
+        }
+        statements.push(`const ${this.name}: ${this.typeAlias} = ${variables.resource}.identifier;`);
+        return statements;
     }
     hashStatements({ variables, }) {
         return [`${variables.hasher}.update(${variables.value}.value);`];
     }
-    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, }) {
         return Maybe.of(`{ label: "Identifier", scope: \`\${${variables.scopePrefix}}/properties/${this.jsonPropertySignature.unsafeCoerce().name}\`, type: "Control" }`);
     }
@@ -224,6 +203,55 @@ export class IdentifierProperty extends Property {
             schema,
         });
     }
+    get propertyDeclaration() {
+        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.typeAlias,
+            });
+        }
+        // See note in TypeFactory re: the logic of whether to declare the identifier in the class or not.
+        if (!this.classPropertyDeclarationVisibility.isJust()) {
+            return Maybe.empty();
+        }
+        if (this.identifierMintingStrategy.isJust()) {
+            // Mutable _identifier property that will be lazily initialized by the getter to mint the identifier
+            return Maybe.of({
+                hasQuestionToken: true,
+                name: `_${this.name}`,
+                scope: this.classPropertyDeclarationVisibility
+                    .map(Property.visibilityToScope)
+                    .unsafeCoerce(),
+                type: `${this.typeAlias}`,
+            });
+        }
+        // Immutable, public identifier property, no getter
+        return Maybe.of({
+            isReadonly: true,
+            name: this.name,
+            type: this.typeAlias,
+        });
+    }
+    get propertySignature() {
+        return Maybe.of({
+            isReadonly: true,
+            name: this.name,
+            type: this.typeAlias,
+        });
+    }
+    snippetDeclarations() {
+        const snippetDeclarations = [];
+        if (this.objectType.features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.booleanEquals);
+        }
+        return snippetDeclarations;
+    }
     sparqlConstructTemplateTriples() {
         return [];
     }

package/dist/generators/ts/_ObjectType/LazyShaclProperty.d.ts

@@ -0,0 +1,87 @@
+import { Maybe } from "purify-ts";
+import "ts-morph";
+import type { TsFeature } from "../../../enums/TsFeature.js";
+import { Import } from "../Import.js";
+import type { ObjectType } from "../ObjectType.js";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import type { OptionType } from "../OptionType.js";
+import type { SetType } from "../SetType.js";
+import { Type as _Type } from "../Type.js";
+import { ShaclProperty } from "./ShaclProperty.js";
+export declare class LazyShaclProperty<LazyTypeT extends LazyShaclProperty.Type<ResolvedTypeT, StubTypeT>, ResolvedTypeT extends LazyShaclProperty.Type.ResolvedTypeConstraint, StubTypeT extends LazyShaclProperty.Type.StubTypeConstraint> extends ShaclProperty<LazyTypeT> {
+    readonly mutable = false;
+    readonly recursive = false;
+    get graphqlField(): ShaclProperty<LazyShaclProperty.Type<StubTypeT, ResolvedTypeT>>["graphqlField"];
+}
+export declare namespace LazyShaclProperty {
+    export abstract class Type<ResolvedTypeT extends Type.ResolvedTypeConstraint, StubTypeT extends Type.StubTypeConstraint> extends _Type {
+        readonly discriminatorProperty: _Type["discriminatorProperty"];
+        readonly mutable = false;
+        readonly typeof = "object";
+        protected readonly resolvedType: ResolvedTypeT;
+        protected readonly runtimeClass: {
+            readonly name: string;
+            readonly rawName: string;
+            readonly snippetDeclaration: string;
+            readonly stubPropertyName: string;
+        };
+        protected readonly stubType: StubTypeT;
+        constructor({ stubType, resolvedType, runtimeClass, }: {
+            stubType: StubTypeT;
+            resolvedType: ResolvedTypeT;
+            runtimeClass: Type<ResolvedTypeT, StubTypeT>["runtimeClass"];
+        });
+        get conversions(): readonly _Type.Conversion[];
+        get equalsFunction(): string;
+        get graphqlName(): _Type.GraphqlName;
+        graphqlResolveExpression({ variables, }: Parameters<_Type["graphqlResolveExpression"]>[0]): string;
+        hashStatements({ depth, variables, }: Parameters<_Type["hashStatements"]>[0]): readonly string[];
+        get jsonName(): _Type.JsonName;
+        jsonUiSchemaElement(parameters: Parameters<_Type["jsonUiSchemaElement"]>[0]): Maybe<string>;
+        jsonZodSchema(parameters: Parameters<_Type["jsonZodSchema"]>[0]): string;
+        get name(): string;
+        snippetDeclarations(parameters: Parameters<_Type["snippetDeclarations"]>[0]): readonly string[];
+        sparqlConstructTemplateTriples(parameters: Parameters<_Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+        sparqlWherePatterns(parameters: Parameters<_Type["sparqlWherePatterns"]>[0]): readonly string[];
+        toJsonExpression({ variables, }: Parameters<_Type["toJsonExpression"]>[0]): string;
+        toRdfExpression({ variables, }: Parameters<_Type["toRdfExpression"]>[0]): string;
+        useImports(parameters: {
+            features: Set<TsFeature>;
+        }): readonly Import[];
+    }
+    export namespace Type {
+        type ResolvedTypeConstraint = ObjectType | ObjectUnionType | OptionType<ObjectType | ObjectUnionType> | SetType<ObjectType | ObjectUnionType>;
+        type StubTypeConstraint = ResolvedTypeConstraint;
+    }
+    export class ObjectSetType<ResolvedTypeT extends SetType<ObjectType | ObjectUnionType>, StubTypeT extends SetType<ObjectType | ObjectUnionType>> extends Type<ResolvedTypeT, StubTypeT> {
+        constructor({ resolvedType, stubType, }: {
+            resolvedType: ResolvedTypeT;
+            stubType: StubTypeT;
+        });
+        get conversions(): readonly _Type.Conversion[];
+        fromJsonExpression(parameters: Parameters<_Type["fromJsonExpression"]>[0]): string;
+        fromRdfExpression(parameters: Parameters<_Type["fromRdfExpression"]>[0]): string;
+    }
+    abstract class SingleObjectType<ResolvedTypeT extends Exclude<Type.ResolvedTypeConstraint, SetType<ObjectType | ObjectUnionType>>, StubTypeT extends Exclude<Type.StubTypeConstraint, SetType<ObjectType | ObjectUnionType>>> extends Type<ResolvedTypeT, StubTypeT> {
+        fromJsonExpression(parameters: Parameters<_Type["fromJsonExpression"]>[0]): string;
+    }
+    export class OptionalObjectType<ResolvedTypeT extends OptionType<ObjectType | ObjectUnionType>, StubTypeT extends OptionType<ObjectType | ObjectUnionType>> extends SingleObjectType<ResolvedTypeT, StubTypeT> {
+        constructor({ resolvedType, stubType, }: {
+            resolvedType: ResolvedTypeT;
+            stubType: StubTypeT;
+        });
+        get conversions(): readonly _Type.Conversion[];
+        fromRdfExpression(parameters: Parameters<_Type["fromRdfExpression"]>[0]): string;
+        graphqlResolveExpression(parameters: Parameters<_Type["graphqlResolveExpression"]>[0]): string;
+    }
+    export class RequiredObjectType<ResolvedTypeT extends ObjectType | ObjectUnionType, StubTypeT extends ObjectType | ObjectUnionType> extends SingleObjectType<ResolvedTypeT, StubTypeT> {
+        constructor({ resolvedType, stubType, }: {
+            resolvedType: ResolvedTypeT;
+            stubType: StubTypeT;
+        });
+        get conversions(): readonly _Type.Conversion[];
+        fromRdfExpression(parameters: Parameters<_Type["fromRdfExpression"]>[0]): string;
+    }
+    export {};
+}
+//# sourceMappingURL=LazyShaclProperty.d.ts.map