@shaclmate/compiler 3.0.3 → 4.0.0

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

@@ -1,119 +1,136 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { NodeKind } from "@shaclmate/shacl-ast";
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
 import { logger } from "../../../logger.js";
-import { Import } from "../Import.js";
-import { SnippetDeclarations } from "../SnippetDeclarations.js";
+import { codeEquals } from "../codeEquals.js";
+import { imports } from "../imports.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { Property } from "./Property.js";
-export class IdentifierProperty extends Property {
-    getAccessorScope;
+import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
+import { AbstractProperty } from "./AbstractProperty.js";
+export class IdentifierProperty extends AbstractProperty {
     identifierMintingStrategy;
     identifierPrefixPropertyName;
-    override;
-    propertyDeclarationVisibility;
     typeAlias;
-    abstract;
-    equalsFunction = Maybe.of(`${syntheticNamePrefix}booleanEquals`);
+    kind = "IdentifierProperty";
     mutable = false;
     recursive = false;
-    constructor({ abstract, getAccessorScope, identifierMintingStrategy, identifierPrefixPropertyName, override, propertyDeclarationVisibility, typeAlias, ...superParameters }) {
+    constructor({ identifierMintingStrategy, identifierPrefixPropertyName, typeAlias, ...superParameters }) {
         super(superParameters);
         invariant(this.visibility === "public");
-        this.abstract = abstract;
-        this.getAccessorScope = getAccessorScope;
-        this.propertyDeclarationVisibility = propertyDeclarationVisibility;
         this.identifierMintingStrategy = identifierMintingStrategy;
         this.identifierPrefixPropertyName = identifierPrefixPropertyName;
-        this.override = override;
         this.typeAlias = typeAlias;
     }
-    get constructorParametersPropertySignature() {
-        if (this.objectType.declarationType === "class" && this.abstract) {
-            return Maybe.empty();
-        }
-        const typeNames = new Set(); // Remove duplicates with a set
-        for (const conversion of this.type.conversions) {
-            if (conversion.sourceTypeName !== "undefined") {
-                typeNames.add(conversion.sourceTypeName);
+    get constructorParametersSignature() {
+        if (this.abstract) {
+            const declarationModifiers = this.declarationModifiers.extractNullable();
+            if (declarationModifiers === null || declarationModifiers.abstract) {
+                // If the property is not declared or it's declared abstract, we just pass up parameters to super as-is.
+                return Maybe.empty();
             }
         }
-        let hasQuestionToken;
-        switch (this.objectType.declarationType) {
-            case "class":
-                hasQuestionToken = this.identifierMintingStrategy.isJust();
-                break;
-            case "interface": {
-                const identifierMintingStrategy = this.identifierMintingStrategy.extract();
-                hasQuestionToken =
-                    typeof identifierMintingStrategy !== "undefined" &&
-                        identifierMintingStrategy !== "sha256";
-                break;
+        const hasQuestionToken = this.identifierMintingStrategy.isJust() ||
+            this.objectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
+            this.objectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust());
+        const typeNames = [];
+        for (const conversion of this.type.conversions) {
+            if (conversion.sourceTypeof !== "undefined" &&
+                !typeNames.some((typeName) => codeEquals(typeName, conversion.sourceTypeName))) {
+                typeNames.push(code `${conversion.sourceTypeName}`);
             }
         }
+        return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeNames, { on: "|" })};`);
+    }
+    get declaration() {
+        return this.declarationModifiers.map(({ abstract, hasQuestionToken, override, readonly, visibility }) => code `${visibility ? `${visibility} ` : ""}${abstract ? "abstract " : ""}${override ? "override " : ""}${readonly ? "readonly " : ""}${this.declarationName}${hasQuestionToken ? "?" : ""}: ${this.typeAlias};`);
+    }
+    get equalsFunction() {
+        return Maybe.of(this.type.equalsFunction);
+    }
+    get filterProperty() {
         return Maybe.of({
-            hasQuestionToken,
-            isReadonly: true,
             name: this.name,
-            type: [...typeNames].sort().join(" | "),
+            type: this.type.filterType,
         });
     }
-    get declarationImports() {
-        const imports = this.type.useImports().concat();
-        this.identifierMintingStrategy.ifJust((identifierMintingStrategy) => {
-            switch (identifierMintingStrategy) {
-                case "sha256":
-                    imports.push(Import.SHA256);
-                    break;
-                case "uuidv4":
-                    imports.push(Import.UUID);
-                    break;
-            }
-        });
-        return imports;
-    }
     get getAccessorDeclaration() {
-        if (this.getAccessorScope.isNothing()) {
-            return Maybe.empty();
-        }
-        invariant(this.getAccessorScope.unsafeCoerce() === "public");
+        // If this, an ancestor, or a descendant has an identifier minting strategy then all classes in the hierarchy must
+        // have get accessors.
+        const checkIdentifierTermTypeStatements = (identifierVariable, identifierVariableNodeKinds) => {
+            if (this.type.nodeKinds.size === 2) {
+                return [];
+            }
+            const expectedNodeKind = this.type.kind === "IriType" ? "IRI" : "BlankNode";
+            if (identifierVariableNodeKinds) {
+                if (identifierVariableNodeKinds.size === 1 &&
+                    identifierVariableNodeKinds.has(expectedNodeKind)) {
+                    return [];
+                }
+            }
+            return [
+                code `if (${identifierVariable}.termType !== "${NodeKind.toTermType(expectedNodeKind)}") { throw new Error(\`expected identifier to be ${expectedNodeKind}, not \${${identifierVariable}.termType}\`); }`,
+            ];
+        };
         if (this.identifierMintingStrategy.isJust()) {
+            // Mint the identifier lazily in the get accessor
             let memoizeMintedIdentifier;
             let mintIdentifier;
             switch (this.identifierMintingStrategy.unsafeCoerce()) {
                 case "blankNode":
                     memoizeMintedIdentifier = true;
-                    mintIdentifier = "dataFactory.blankNode()";
+                    mintIdentifier = code `${imports.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())}\`)`;
+                    mintIdentifier = code `${imports.dataFactory}.namedNode(\`\${this.${this.identifierPrefixPropertyName}}\${this.${syntheticNamePrefix}hashShaclProperties(${imports.sha256}.create())}\`)`;
                     break;
                 case "uuidv4":
                     memoizeMintedIdentifier = true;
-                    mintIdentifier = `dataFactory.namedNode(\`\${this.${this.identifierPrefixPropertyName}}\${uuid.v4()}\`)`;
+                    mintIdentifier = code `${imports.dataFactory}.namedNode(\`\${this.${this.identifierPrefixPropertyName}}\${${imports.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}`,
-                ],
-            });
+            return Maybe.of(code `\
+      ${this.override ? "override " : ""} get ${this.name}(): ${this.typeAlias} { ${joinCode([
+                code `if (this._${this.name} === undefined) { ${memoizeMintedIdentifier ? code `this._${this.name} = ${mintIdentifier};` : code `return ${mintIdentifier};`} }`,
+                ...checkIdentifierTermTypeStatements(`this._${this.name}`),
+                code `return this._${this.name};`,
+            ])} }`);
         }
-        invariant(this.propertyDeclaration.isNothing());
-        return Maybe.of({
-            leadingTrivia: this.override ? "override " : undefined,
-            name: this.name,
-            returnType: this.typeAlias,
-            statements: [`return super.${this.name} as ${this.typeAlias}`],
-        });
+        // If this object type has an ancestor or a descendant with an identifier minting strategy, declare a get accessor.
+        if (this.objectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
+            this.objectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust())) {
+            if (this.objectType.parentObjectTypes.length > 0) {
+                // If this object type isn't the root, delegate up.
+                const checkSuperIdentifierTermTypeStatements = checkIdentifierTermTypeStatements("identifier", this.objectType.parentObjectTypes[0].identifierType.nodeKinds);
+                if (checkSuperIdentifierTermTypeStatements.length === 0) {
+                    return Maybe.empty(); // Don't need a get accessor just to return super.identifier.
+                }
+                return Maybe.of(code `override get ${this.name}(): ${this.typeAlias} { ${joinCode([
+                    code `const identifier = super.${this.name};`,
+                    ...checkSuperIdentifierTermTypeStatements,
+                    code `return identifier;`,
+                ])} }`);
+            }
+            // This object type is the root but it has no identifier minting strategy.
+            // Just return the declared property in the get accessor.
+            // Subclasses will override the get accessor.
+            return Maybe.of(code `${this.override ? "override " : ""}get ${this.name}(): ${this.typeAlias} { ${joinCode([
+                code `if (this.${this.declarationName} === undefined) { throw new Error("unable to mint identifier"); }`,
+                code `return this.${this.declarationName};`,
+            ])}`);
+        }
+        // None of the object type hierarchy has an identifier minting strategy, don't need a get accessor
+        return Maybe.empty();
     }
     get graphqlField() {
         invariant(this.name.startsWith(syntheticNamePrefix));
@@ -121,193 +138,223 @@ export class IdentifierProperty extends Property {
             args: Maybe.empty(),
             description: Maybe.empty(),
             name: `_${this.name.substring(syntheticNamePrefix.length)}`,
-            resolve: `(source) => ${this.typeAlias}.toString(source.${this.name})`,
-            type: this.type.graphqlName.toString(),
+            resolve: code `(source) => ${this.typeAlias}.toString(source.${this.name})`,
+            type: this.type.graphqlType.name,
         });
     }
-    get jsonPropertySignature() {
+    get jsonSignature() {
+        return Maybe.of(code `readonly "@id": string`);
+    }
+    get jsonZodSchema() {
+        let schema;
+        if (this.type.in_.length > 0 && this.type.kind === "IriType") {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            schema = code `${imports.z}.enum(${arrayOf(...this.type.in_.map((iri) => iri.value))})`;
+        }
+        else {
+            schema = code `${imports.z}.string().min(1)`;
+        }
         return Maybe.of({
-            isReadonly: true,
-            name: "@id",
-            type: "string",
+            key: "@id",
+            schema,
         });
     }
+    // protected override get schemaObject() {
+    //   return {
+    //     ...super.schemaObject,
+    //     identifierMintingStrategy: this.identifierMintingStrategy
+    //       .map((_) => code`${literalOf(_)} as const`)
+    //       .extract(),
+    //   };
+    // }
+    get abstract() {
+        return this.objectType.abstract;
+    }
+    get declarationModifiers() {
+        if (this.objectType.declarationType === "interface") {
+            return Maybe.of({ readonly: true });
+        }
+        if (this.objectType.parentObjectTypes.length > 0) {
+            // An ancestor will declare the identifier property.
+            return Maybe.empty();
+        }
+        if (this.identifierMintingStrategy.isJust() ||
+            this.objectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
+            this.objectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust())) {
+            return Maybe.of({
+                hasQuestionToken: true,
+                visibility: this.objectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust())
+                    ? "protected"
+                    : "private",
+            });
+        }
+        if (this.abstract) {
+            // Declare the property abstract and public
+            return Maybe.of({
+                abstract: true,
+                override: this.override,
+                readonly: true,
+            });
+        }
+        // Declare the property public
+        return Maybe.of({
+            override: this.override,
+            readonly: true,
+        });
+    }
+    get declarationName() {
+        if (this.objectType.declarationType === "class" &&
+            (this.identifierMintingStrategy.isJust() ||
+                this.objectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
+                this.objectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust()))) {
+            // If this, an ancestor, or a descendant has an identifier minting strategy, declare the identifier property
+            // private or protected and prefix its name with _ in order to avoid a conflict with the get accessor name.
+            return `_${this.name}`;
+        }
+        return this.name;
+    }
+    get override() {
+        return this.objectType.parentObjectTypes.length > 0;
+    }
     constructorStatements({ variables, }) {
+        const constructorParametersSignature = this.constructorParametersSignature.extractNullable();
+        if (constructorParametersSignature === null) {
+            return [];
+        }
         let lhs;
         const statements = [];
         const typeConversions = this.type.conversions;
         switch (this.objectType.declarationType) {
             case "class": {
-                if (this.abstract) {
-                    return [];
-                }
-                if (this.propertyDeclaration.isNothing()) {
+                if (this.declaration.isNothing()) {
                     return [];
                 }
-                const propertyDeclaration = this.propertyDeclaration.unsafeCoerce();
-                if (typeConversions.length === 1) {
-                    return [`this.${propertyDeclaration.name} = ${variables.parameter};`];
-                }
-                lhs = `this.${propertyDeclaration.name}`;
+                lhs = `this.${this.declarationName}`;
                 break;
             }
             case "interface":
-                if (typeConversions.length === 1) {
-                    return [`const ${this.name} = ${variables.parameter};`];
-                }
                 lhs = this.name;
-                statements.push(`let ${this.name}: ${this.typeAlias};`);
+                statements.push(code `let ${this.name}: ${this.typeAlias};`);
                 break;
         }
         const conversionBranches = [];
         for (const conversion of typeConversions) {
-            invariant(conversion.sourceTypeName !== "undefined");
-            conversionBranches.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${lhs} = ${conversion.conversionExpression(variables.parameter)}; }`);
+            invariant(conversion.sourceTypeof !== "undefined");
+            conversionBranches.push(code `if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${lhs} = ${conversion.conversionExpression(variables.parameter)}; }`);
         }
         this.identifierMintingStrategy.ifJust((identifierMintingStrategy) => {
             switch (this.objectType.declarationType) {
                 case "class":
-                    conversionBranches.push(`if (typeof ${variables.parameter} === "undefined") { }`);
+                    // The identifier will be minted lazily in the get accessor
+                    invariant(this.getAccessorDeclaration.isJust());
+                    conversionBranches.push(code `if (${variables.parameter} === undefined) { }`);
                     break;
                 case "interface": {
                     let mintIdentifier;
                     switch (identifierMintingStrategy) {
                         case "blankNode":
-                            mintIdentifier = "dataFactory.blankNode()";
+                            mintIdentifier = code `${imports.dataFactory}.blankNode()`;
                             break;
                         case "sha256":
                             logger.warn("minting %s identifiers with %s is unsupported", this.objectType.declarationType, identifierMintingStrategy);
                             return;
                         case "uuidv4":
-                            mintIdentifier = `dataFactory.namedNode(\`\${${variables.parameters}.${this.identifierPrefixPropertyName} ?? "urn:shaclmate:${this.objectType.discriminatorValue}:"}\${uuid.v4()}\`)`;
+                            mintIdentifier = code `${imports.dataFactory}.namedNode(\`\${${variables.parameters}.${this.identifierPrefixPropertyName} ?? "urn:shaclmate:${this.objectType.discriminantValue}:"}\${${imports.uuid}.v4()}\`)`;
                             break;
                     }
-                    conversionBranches.push(`if (typeof ${variables.parameter} === "undefined") { ${lhs} = ${mintIdentifier}; }`);
+                    conversionBranches.push(code `if (${variables.parameter} === undefined) { ${lhs} = ${mintIdentifier}; }`);
                 }
             }
         });
         // 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(`{ ${lhs} = (${variables.parameter}) satisfies never;\n }`);
-        statements.push(conversionBranches.join(" else "));
+        conversionBranches.push(code `{ ${lhs} = (${variables.parameter}) satisfies never;\n }`);
+        statements.push(joinCode(conversionBranches, { on: " else " }));
         return statements;
     }
     fromJsonStatements({ variables, }) {
         return [
-            `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: variables.jsonObject } })};`,
+            code `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: variables.jsonObject } })};`,
         ];
     }
-    fromRdfStatements({ variables, }) {
-        if (this.type.in_.length > 0 && this.type.isNamedNodeKind) {
-            // Treat sh:in as a union of the IRIs
-            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            return [
-                `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)} })); }`,
-            ];
-        }
-        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;
+    fromRdfExpression({ variables, }) {
+        return Maybe.of(code `${this.type.fromRdfExpression({
+            variables: {
+                ...variables,
+                propertyPath: rdfjsTermExpression(rdf.subject),
+                resourceValues: code `${imports.Right}(new ${imports.Resource}.Value(${{ dataFactory: imports.dataFactory, focusResource: variables.resource, propertyPath: rdfjsTermExpression(rdf.subject), term: code `${variables.resource}.identifier` }}).toValues())`,
+            },
+        })}.chain(values => values.head())`);
     }
     hashStatements({ variables, }) {
-        return [`${variables.hasher}.update(${variables.value}.value);`];
+        return [code `${variables.hasher}.update(${variables.value}.value);`];
     }
     jsonUiSchemaElement({ variables, }) {
-        return Maybe.of(`{ label: "Identifier", scope: \`\${${variables.scopePrefix}}/properties/${this.jsonPropertySignature.unsafeCoerce().name}\`, type: "Control" }`);
-    }
-    jsonZodSchema({ variables, }) {
-        let schema;
-        if (this.type.in_.length > 0 && this.type.isNamedNodeKind) {
-            // Treat sh:in as a union of the IRIs
-            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            schema = `${variables.zod}.enum(${JSON.stringify(this.type.in_.map((iri) => iri.value))})`;
-        }
-        else {
-            schema = `${variables.zod}.string().min(1)`;
-        }
-        return Maybe.of({
-            key: this.jsonPropertySignature.unsafeCoerce().name,
-            schema,
-        });
+        return Maybe.of(code `{ label: "Identifier", scope: \`\${${variables.scopePrefix}}/properties/@id\`, type: "Control" }`);
     }
-    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.propertyDeclarationVisibility.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.propertyDeclarationVisibility
-                    .map(Property.visibilityToScope)
-                    .unsafeCoerce(),
-                type: `${this.typeAlias}`,
-            });
-        }
-        // Immutable, public identifier property, no getter
-        return Maybe.of({
-            isReadonly: true,
-            name: this.name,
-            type: this.typeAlias,
-        });
+    sparqlConstructTriplesExpression() {
+        return Maybe.empty();
     }
-    get propertySignature() {
+    sparqlWherePatternsExpression({ variables, }) {
         return Maybe.of({
-            isReadonly: true,
-            name: this.name,
-            type: this.typeAlias,
+            condition: code `${variables.focusIdentifier}.termType === "Variable"`,
+            patterns: code `${this.type.sparqlWherePatternsFunction}(${{
+                filter: code `${variables.filter}?.${this.name}`,
+                preferredLanguages: variables.preferredLanguages,
+                propertyPatterns: code `[]`,
+                schema: code `${this.objectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.objectType.identifierProperty.name}.type()`,
+                valueVariable: variables.focusIdentifier,
+                variablePrefix: variables.variablePrefix, // Unused
+            }})`,
         });
     }
-    snippetDeclarations() {
-        const snippetDeclarations = [];
-        if (this.objectType.features.has("equals")) {
-            snippetDeclarations.push(SnippetDeclarations.booleanEquals);
-        }
-        return snippetDeclarations;
-    }
-    sparqlConstructTemplateTriples() {
-        return [];
-    }
-    sparqlWherePatterns() {
-        return [];
-    }
-    toJsonObjectMember({ variables, }) {
+    toJsonObjectMemberExpression({ 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`;
+                    return code `\`_:\${${variables.value}.value}\``;
+                case "IRI":
+                    return code `${variables.value}.value`;
                 default:
                     throw new RangeError(nodeKind);
             }
         });
         if (valueToNodeKinds.length === 1) {
-            return Maybe.of(`"@id": ${valueToNodeKinds[0]}`);
+            return Maybe.of(code `"@id": ${valueToNodeKinds[0]}`);
         }
         invariant(valueToNodeKinds.length === 2);
-        return Maybe.of(`"@id": ${variables.value}.termType === "${nodeKinds[0]}" ? ${valueToNodeKinds[0]} : ${valueToNodeKinds[1]}`);
+        return Maybe.of(code `"@id": ${variables.value}.termType === "${NodeKind.toTermType(nodeKinds[0])}" ? ${valueToNodeKinds[0]} : ${valueToNodeKinds[1]}`);
     }
     toRdfStatements() {
         return [];
     }
 }
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "constructorParametersSignature", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "declaration", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "filterProperty", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "getAccessorDeclaration", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "graphqlField", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "jsonSignature", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "jsonZodSchema", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "declarationModifiers", null);
 //# sourceMappingURL=IdentifierProperty.js.map

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

@@ -0,0 +1,4 @@
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_classDeclaration(this: ObjectType): Code;
+//# sourceMappingURL=ObjectType_classDeclaration.d.ts.map

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

@@ -0,0 +1,69 @@
+import { Maybe } from "purify-ts";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, def, joinCode } from "../ts-poet-wrapper.js";
+import { tsComment } from "../tsComment.js";
+import { ObjectType_equalsFunctionOrMethodDeclaration } from "./ObjectType_equalsFunctionOrMethodDeclaration.js";
+import { ObjectType_hashFunctionOrMethodDeclarations } from "./ObjectType_hashFunctionOrMethodDeclarations.js";
+import { ObjectType_toJsonFunctionOrMethodDeclaration } from "./ObjectType_toJsonFunctionOrMethodDeclaration.js";
+import { ObjectType_toRdfFunctionOrMethodDeclaration } from "./ObjectType_toRdfFunctionOrMethodDeclaration.js";
+function ObjectType_constructorDeclaration() {
+    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersSignature.toList());
+    const parametersType = [];
+    if (parametersPropertySignatures.length > 0) {
+        parametersType.push(code `{ ${joinCode(parametersPropertySignatures)} }`);
+    }
+    if (this.parentObjectTypes.length > 0) {
+        // Pass up parameters
+        parametersType.push(code `ConstructorParameters<typeof ${this.parentObjectTypes[0].name}>[0]`);
+    }
+    if (parametersType.length === 0) {
+        parametersType.push(code `object`);
+    }
+    const statements = [];
+    if (this.parentObjectTypes.length > 0) {
+        // An ancestor object type may be extern so we always have a constructor and always pass up parameters instead
+        // of trying to sense whether we need to or not.
+        statements.push(code `super(parameters);`);
+    }
+    const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
+        parametersPropertySignatures.every((propertySignature) => propertySignature.toCodeString([]).indexOf("?:") !== -1);
+    const parametersVariable = code `parameters${parametersHasQuestionToken ? "?" : ""}`;
+    const propertyStatements = this.properties.flatMap((property) => property.constructorStatements({
+        variables: {
+            parameter: code `${parametersVariable}.${property.name}`,
+            parameters: parametersVariable,
+        },
+    }));
+    statements.push(...propertyStatements);
+    return code `\
+${propertyStatements.length === 0 ? "// biome-ignore lint/complexity/noUselessConstructor: Always have a constructor" : ""}
+constructor(${statements.length > 0 ? "parameters" : "_parameters"}${parametersHasQuestionToken ? "?" : ""}: ${joinCode(parametersType, { on: " & " })}) {
+${joinCode(statements)}
+}`;
+}
+export function ObjectType_classDeclaration() {
+    this.ensureAtMostOneSuperObjectType();
+    return code `\
+${this.comment
+        .alt(this.label)
+        .map(tsComment)
+        .orDefault("")}${this.export ? "export " : ""}${this.abstract ? "abstract " : ""}class ${def(this.name)}${this.parentObjectTypes.length > 0 ? ` extends ${this.parentObjectTypes[0].name}` : ""} {
+${joinCode([
+        ...this.properties.flatMap((property) => property.declaration.toList()),
+        ObjectType_constructorDeclaration.bind(this)(),
+        ...this.properties.flatMap((property) => property.getAccessorDeclaration.toList()),
+        ...ObjectType_equalsFunctionOrMethodDeclaration.bind(this)().toList(),
+        ...ObjectType_hashFunctionOrMethodDeclarations.bind(this)(),
+        ...ObjectType_toJsonFunctionOrMethodDeclaration.bind(this)().toList(),
+        ...ObjectType_toRdfFunctionOrMethodDeclaration.bind(this)().toList(),
+        ...ObjectType_toStringMethodDeclaration.bind(this)().toList(),
+    ], { on: "\n\n" })}
+}`;
+}
+function ObjectType_toStringMethodDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `${this.parentObjectTypes.length > 0 ? "override " : ""}toString(): string { return JSON.stringify(this.${syntheticNamePrefix}toJson()); }`);
+}
+//# sourceMappingURL=ObjectType_classDeclaration.js.map

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

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_createFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_createFunctionDeclaration.d.ts.map