@shaclmate/compiler 4.0.90 → 4.0.91

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

@@ -15,6 +15,11 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
     kind = "Identifier";
     mutable = false;
     recursive = false;
+    type;
+    constructor({ type, ...superParameters }) {
+        super(superParameters);
+        this.type = type;
+    }
     get constructorParameter() {
         let hasQuestionToken = false;
         const typeExpressions = [code `(() => ${this.typeExpression})`];
@@ -33,7 +38,14 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
         });
     }
     get declaration() {
-        return code `readonly ${this.name}: () => ${this.typeExpression};`;
+        return Maybe.of(code `readonly ${this.name}: () => ${this.typeExpression};`);
+    }
+    equalsExpression({ variables, }) {
+        return Maybe.of(code `${this.reusables.snippets.propertyEquals}(
+        { equalsFunction: ${this.type.equalsFunction}, name: ${literalOf(this.name)} },
+        [left, ${variables.leftObject}.${this.name}()],
+        [right, ${variables.rightObject}.${this.name}()],
+      )`);
     }
     get filterProperty() {
         return Maybe.of({
@@ -41,6 +53,9 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
             type: this.type.filterType,
         });
     }
+    filterExpression({ variables, }) {
+        return Maybe.of(code `${this.type.filterFunction}(${variables.filter}.${this.name}, ${variables.object}.${this.name}())`);
+    }
     get graphqlField() {
         const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         invariant(this.name.startsWith(syntheticNamePrefix));
@@ -48,12 +63,12 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
             args: Maybe.empty(),
             description: Maybe.empty(),
             name: `_${this.name.substring(syntheticNamePrefix.length)}`,
-            resolve: code `(source) => ${this.type.stringifyFunction}(${this.accessExpression({ variables: { object: code `source` } })})`,
+            resolve: code `(source) => ${this.type.stringifyFunction}(source.${this.name}())`,
             type: this.type.graphqlType.expression,
         });
     }
     get hashFunctionParameter() {
-        return code `readonly ${this.name}?: () => ${this.typeExpression};`;
+        return Maybe.of(code `readonly ${this.name}?: () => ${this.typeExpression};`);
     }
     get jsonSchema() {
         let schema;
@@ -95,9 +110,6 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
             .map((name) => code `${name}.schema.properties.${this.name}.type`)
             .orDefaultLazy(() => this.type.schema);
     }
-    accessExpression({ variables, }) {
-        return code `${variables.object}.${this.name}()`;
-    }
     constructorInitializer({ variables, }) {
         const nodeKinds = this.type.nodeKinds;
         let conversionFunction;
@@ -131,7 +143,7 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
     }
     hashStatements({ variables, }) {
         return [
-            code `if (${variables.value}) { ${variables.hasher}.update(${variables.value}().value); }`,
+            code `if (${variables.object}.${this.name}) { ${variables.hasher}.update(${variables.object}.${this.name}().value); }`,
         ];
     }
     jsonUiSchemaElement({ variables, }) {
@@ -159,9 +171,9 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
         const valueToNodeKinds = nodeKinds.map((nodeKind) => {
             switch (nodeKind) {
                 case "BlankNode":
-                    return code `\`_:\${${variables.value}.value}\``;
+                    return code `\`_:\${${variables.object}.${this.name}().value}\``;
                 case "IRI":
-                    return code `${variables.value}.value`;
+                    return code `${variables.object}.${this.name}().value`;
                 default:
                     throw new RangeError(nodeKind);
             }
@@ -170,13 +182,13 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
             return Maybe.of(code `"@id": ${valueToNodeKinds[0]}`);
         }
         invariant(valueToNodeKinds.length === 2);
-        return Maybe.of(code `"@id": ${variables.value}.termType === "${NodeKind.toTermType(nodeKinds[0])}" ? ${valueToNodeKinds[0]} : ${valueToNodeKinds[1]}`);
+        return Maybe.of(code `"@id": ${variables.object}.${this.name}().termType === "${NodeKind.toTermType(nodeKinds[0])}" ? ${valueToNodeKinds[0]} : ${valueToNodeKinds[1]}`);
     }
     toRdfRdfResourceValuesStatements() {
         return [];
     }
-    toStringInitializer(parameters) {
-        return Maybe.of(code `${literalOf(this.name)}: ${this.type.toStringExpression(parameters)}`);
+    toStringInitializer({ variables, }) {
+        return Maybe.of(code `${literalOf(this.name)}: ${this.type.toStringExpression({ variables: { value: code `${variables.object}.${this.name}()` } })}`);
     }
 }
 __decorate([

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

@@ -1,6 +1,7 @@
 import type { Type } from "../Type.js";
 import type { ObjectType_DiscriminantProperty } from "./ObjectType_DiscriminantProperty.js";
 import type { ObjectType_IdentifierProperty } from "./ObjectType_IdentifierProperty.js";
+import type { ObjectType_RdfTypeProperty } from "./ObjectType_RdfTypeProperty.js";
 import type { ObjectType_ShaclProperty } from "./ObjectType_ShaclProperty.js";
-export type ObjectType_Property = ObjectType_IdentifierProperty | ObjectType_ShaclProperty<Type> | ObjectType_DiscriminantProperty;
+export type ObjectType_Property = ObjectType_IdentifierProperty | ObjectType_ShaclProperty<Type> | ObjectType_DiscriminantProperty | ObjectType_RdfTypeProperty;
 //# sourceMappingURL=ObjectType_Property.d.ts.map

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

@@ -0,0 +1,37 @@
+import type { NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { type Code } from "../ts-poet-wrapper.js";
+import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
+export declare class ObjectType_RdfTypeProperty extends ObjectType_AbstractProperty {
+    readonly constructorParameter: ObjectType_AbstractProperty["constructorParameter"];
+    readonly declaration: ObjectType_AbstractProperty["declaration"];
+    readonly filterProperty: ObjectType_AbstractProperty["filterProperty"];
+    readonly fromRdfType: NamedNode;
+    readonly graphqlField: ObjectType_AbstractProperty["graphqlField"];
+    readonly hashFunctionParameter: ObjectType_AbstractProperty["hashFunctionParameter"];
+    readonly jsonSchema: ObjectType_AbstractProperty["jsonSchema"];
+    readonly jsonSignature: ObjectType_AbstractProperty["jsonSignature"];
+    readonly kind = "RdfType";
+    readonly mutable = false;
+    readonly recursive = false;
+    readonly toRdfTypes: readonly NamedNode[];
+    constructor({ configuration, fromRdfType, toRdfTypes, ...superParameters }: {
+        fromRdfType: NamedNode;
+        toRdfTypes: readonly NamedNode[];
+    } & Omit<ConstructorParameters<typeof ObjectType_AbstractProperty>[0], "name">);
+    get schema(): Maybe<Code>;
+    get schemaType(): Maybe<Code>;
+    constructorInitializer(): Maybe<Code>;
+    equalsExpression(): Maybe<Code>;
+    filterExpression(): Maybe<Code>;
+    fromJsonInitializer(): Maybe<Code>;
+    fromRdfResourceValuesInitializer(): Maybe<Code>;
+    hashStatements(): readonly Code[];
+    jsonUiSchemaElement(): Maybe<Code>;
+    sparqlConstructTriplesExpression({ variables, }: Parameters<ObjectType_AbstractProperty["sparqlConstructTriplesExpression"]>[0]): Maybe<Code>;
+    sparqlWherePatternsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>[0]): ReturnType<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>;
+    toJsonInitializer(): Maybe<Code>;
+    toRdfRdfResourceValuesStatements(): readonly Code[];
+    toStringInitializer(): Maybe<Code>;
+}
+//# sourceMappingURL=ObjectType_RdfTypeProperty.d.ts.map

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

@@ -0,0 +1,118 @@
+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 { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
+export class ObjectType_RdfTypeProperty extends ObjectType_AbstractProperty {
+    constructorParameter = Maybe.empty();
+    declaration = Maybe.empty();
+    filterProperty = Maybe.empty();
+    fromRdfType;
+    graphqlField = Maybe.empty();
+    hashFunctionParameter = Maybe.empty();
+    jsonSchema = Maybe.empty();
+    jsonSignature = Maybe.empty();
+    kind = "RdfType";
+    mutable = false;
+    recursive = false;
+    toRdfTypes;
+    constructor({ configuration, fromRdfType, toRdfTypes, ...superParameters }) {
+        super({
+            ...superParameters,
+            configuration,
+            name: `${configuration.syntheticNamePrefix}rdfType`,
+        });
+        this.fromRdfType = fromRdfType;
+        this.toRdfTypes = toRdfTypes;
+    }
+    get schema() {
+        return Maybe.of(code `${{ fromRdfType: this.rdfjsTermExpression(this.fromRdfType), kind: this.kind, toRdfTypes: this.toRdfTypes.map((toRdfType) => this.rdfjsTermExpression(toRdfType)) }}`);
+    }
+    get schemaType() {
+        return Maybe.of(code `${{ fromRdfType: code `${this.reusables.imports.NamedNode}`, kind: this.kind, toRdfTypes: code `readonly ${this.reusables.imports.NamedNode}[]` }}`);
+    }
+    constructorInitializer() {
+        return Maybe.empty();
+    }
+    equalsExpression() {
+        return Maybe.empty();
+    }
+    filterExpression() {
+        return Maybe.empty();
+    }
+    fromJsonInitializer() {
+        return Maybe.empty();
+    }
+    fromRdfResourceValuesInitializer() {
+        return Maybe.empty();
+    }
+    hashStatements() {
+        return [];
+    }
+    jsonUiSchemaElement() {
+        return Maybe.empty();
+    }
+    sparqlConstructTriplesExpression({ variables, }) {
+        const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
+        const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+        return Maybe.of(code `${variables.ignoreRdfType} ? [] : [${joinCode([
+            code `{ subject: ${variables.focusIdentifier}, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} }`,
+            code `{ subject: ${rdfTypeVariable}, predicate: ${this.rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }`,
+        ], {
+            on: ",",
+        })}]`);
+    }
+    sparqlWherePatternsExpression({ variables, }) {
+        const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
+        const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+        return Maybe.of({
+            patterns: code `${variables.ignoreRdfType} ? [] : [${joinCode([
+                code `${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${variables.schema.map((schema) => code `${schema}.properties.${this.name}.fromRdfType`).orDefault(this.rdfjsTermExpression(this.fromRdfType))}, subject: ${variables.focusIdentifier} })`,
+                code `{ triples: [{ subject: ${variables.focusIdentifier}, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} }], type: "bgp" as const }`,
+                code `{
+patterns: [
+  {
+    triples: [
+      {
+        subject: ${rdfTypeVariable},
+        predicate: {
+          items: [${this.rdfjsTermExpression(rdfs.subClassOf)}],
+          pathType: "+" as const,
+          type: "path" as const
+        },
+        object: ${rdfClassVariable}
+      }
+    ],
+    type: "bgp" as const
+  }
+],
+type: "optional" as const
+}`,
+            ], {
+                on: ",",
+            })}]`,
+        });
+    }
+    toJsonInitializer() {
+        return Maybe.empty();
+    }
+    toRdfRdfResourceValuesStatements() {
+        return [];
+    }
+    toStringInitializer() {
+        return Maybe.empty();
+    }
+}
+__decorate([
+    Memoize()
+], ObjectType_RdfTypeProperty.prototype, "equalsExpression", null);
+__decorate([
+    Memoize()
+], ObjectType_RdfTypeProperty.prototype, "filterExpression", null);
+//# sourceMappingURL=ObjectType_RdfTypeProperty.js.map

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

@@ -3,7 +3,7 @@ import { Maybe } from "purify-ts";
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
-export declare class ObjectType_ShaclProperty<TypeT extends Type> extends ObjectType_AbstractProperty<TypeT> {
+export declare class ObjectType_ShaclProperty<TypeT extends Type> extends ObjectType_AbstractProperty {
     private readonly comment;
     private readonly description;
     private readonly display;
@@ -12,7 +12,8 @@ export declare class ObjectType_ShaclProperty<TypeT extends Type> extends Object
     readonly mutable: boolean;
     readonly path: PropertyPath;
     readonly recursive: boolean;
-    constructor({ comment, description, display, label, mutable, path, recursive, ...superParameters }: {
+    readonly type: TypeT;
+    constructor({ comment, description, display, label, mutable, path, recursive, type, ...superParameters }: {
         comment: Maybe<string>;
         description: Maybe<string>;
         display: boolean;
@@ -20,34 +21,37 @@ export declare class ObjectType_ShaclProperty<TypeT extends Type> extends Object
         mutable: boolean;
         path: PropertyPath;
         recursive: boolean;
-    } & ConstructorParameters<typeof ObjectType_AbstractProperty<TypeT>>[0]);
+        type: TypeT;
+    } & ConstructorParameters<typeof ObjectType_AbstractProperty>[0]);
     get constructorParameter(): Maybe<{
         hasQuestionToken: boolean;
         signature: Code;
     }>;
-    get declaration(): Code;
+    get declaration(): Maybe<Code>;
     get filterProperty(): Maybe<{
         name: string;
         type: Code;
     }>;
-    get graphqlField(): ObjectType_AbstractProperty<TypeT>["graphqlField"];
-    get hashFunctionParameter(): Code;
-    get jsonSchema(): ObjectType_AbstractProperty<TypeT>["jsonSchema"];
+    get graphqlField(): ObjectType_AbstractProperty["graphqlField"];
+    get hashFunctionParameter(): Maybe<Code>;
+    get jsonSchema(): ObjectType_AbstractProperty["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
     get schema(): Maybe<Code>;
     get schemaType(): Maybe<Code>;
     private get schemaVariable();
     private get typeSchemaVariable();
-    constructorInitializer({ variables, }: Parameters<ObjectType_AbstractProperty<TypeT>["constructorInitializer"]>[0]): Maybe<Code>;
-    fromJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty<TypeT>["fromJsonInitializer"]>[0]): Maybe<Code>;
-    fromRdfResourceValuesInitializer({ variables, }: Parameters<ObjectType_AbstractProperty<TypeT>["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;
-    hashStatements({ variables, }: Parameters<ObjectType_AbstractProperty<TypeT>["hashStatements"]>[0]): readonly Code[];
-    jsonUiSchemaElement({ variables, }: Parameters<ObjectType_AbstractProperty<TypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    sparqlConstructTriplesExpression({ variables, }: Parameters<ObjectType_AbstractProperty<TypeT>["sparqlConstructTriplesExpression"]>[0]): Maybe<Code>;
-    sparqlWherePatternsExpression({ variables, }: Parameters<ObjectType_AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>[0]): ReturnType<ObjectType_AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>;
-    toJsonInitializer(parameters: Parameters<ObjectType_AbstractProperty<TypeT>["toJsonInitializer"]>[0]): Maybe<Code>;
-    toRdfRdfResourceValuesStatements({ variables, }: Parameters<ObjectType_AbstractProperty<TypeT>["toRdfRdfResourceValuesStatements"]>[0]): readonly Code[];
-    toStringInitializer(parameters: Parameters<ObjectType_AbstractProperty<TypeT>["toStringInitializer"]>[0]): Maybe<Code>;
+    constructorInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["constructorInitializer"]>[0]): Maybe<Code>;
+    equalsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["equalsExpression"]>[0]): Maybe<Code>;
+    filterExpression({ variables, }: Parameters<ObjectType_AbstractProperty["filterExpression"]>[0]): Maybe<Code>;
+    fromJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["fromJsonInitializer"]>[0]): Maybe<Code>;
+    fromRdfResourceValuesInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;
+    hashStatements({ variables, }: Parameters<ObjectType_AbstractProperty["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement({ variables, }: Parameters<ObjectType_AbstractProperty["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    sparqlConstructTriplesExpression({ variables, }: Parameters<ObjectType_AbstractProperty["sparqlConstructTriplesExpression"]>[0]): Maybe<Code>;
+    sparqlWherePatternsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>[0]): ReturnType<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>;
+    toJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toJsonInitializer"]>[0]): Maybe<Code>;
+    toRdfRdfResourceValuesStatements({ variables, }: Parameters<ObjectType_AbstractProperty["toRdfRdfResourceValuesStatements"]>[0]): readonly Code[];
+    toStringInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toStringInitializer"]>[0]): Maybe<Code>;
     private propertyPathToCode;
 }
 //# sourceMappingURL=ObjectType_ShaclProperty.d.ts.map

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

@@ -18,7 +18,8 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
     mutable;
     path;
     recursive;
-    constructor({ comment, description, display, label, mutable, path, recursive, ...superParameters }) {
+    type;
+    constructor({ comment, description, display, label, mutable, path, recursive, type, ...superParameters }) {
         super(superParameters);
         this.comment = comment;
         this.description = description;
@@ -27,6 +28,7 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
         this.mutable = mutable;
         this.path = path;
         this.recursive = recursive;
+        this.type = type;
     }
     get constructorParameter() {
         const conversionFunction = this.type.conversionFunction.extract();
@@ -60,7 +62,7 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
             .ifJust((comment) => {
             declaration = code `${comment}${declaration}`;
         });
-        return declaration;
+        return Maybe.of(declaration);
     }
     get filterProperty() {
         return Maybe.of({
@@ -161,6 +163,16 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
         }
         return Maybe.of(code `${this.name}: ${rhs}`);
     }
+    equalsExpression({ variables, }) {
+        return Maybe.of(code `${this.reusables.snippets.propertyEquals}(
+        { equalsFunction: ${this.type.equalsFunction}, name: ${literalOf(this.name)} },
+        [left, ${variables.leftObject}.${this.name}],
+        [right, ${variables.rightObject}.${this.name}],
+      )`);
+    }
+    filterExpression({ variables, }) {
+        return Maybe.of(code `${this.type.filterFunction}(${variables.filter}.${this.name}, ${variables.object}.${this.name})`);
+    }
     fromJsonInitializer({ variables, }) {
         return Maybe.of(code `${this.name}: ${this.type.fromJsonExpression({
             variables: { value: code `${variables.jsonObject}["${this.name}"]` },
@@ -178,7 +190,7 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
     }
     hashStatements({ variables, }) {
         return [
-            code `${this.type.hashFunction}(${variables.hasher}, ${variables.value});`,
+            code `${this.type.hashFunction}(${variables.hasher}, ${variables.object}.${this.name});`,
         ];
     }
     jsonUiSchemaElement({ variables, }) {
@@ -216,8 +228,8 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
             }})`,
         });
     }
-    toJsonInitializer(parameters) {
-        return Maybe.of(code `${this.name}: ${this.type.toJsonExpression(parameters)}`);
+    toJsonInitializer({ variables, }) {
+        return Maybe.of(code `${this.name}: ${this.type.toJsonExpression({ variables: { value: code `${variables.object}.${this.name}` } })}`);
     }
     toRdfRdfResourceValuesStatements({ variables, }) {
         switch (this.path.termType) {
@@ -234,17 +246,23 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
         const propertyPath = this.objectType.name
             .map(() => code `${this.schemaVariable}.path`)
             .orDefault(this.propertyPathToCode(this.path));
+        const { object: objectVariable, ...otherVariables } = variables;
         return [
             code `${variables.resource}.add(${propertyPath}, ${this.type.toRdfResourceValuesExpression({
-                variables: { ...variables, propertyPath },
+                variables: {
+                    ...otherVariables,
+                    propertyPath,
+                    value: code `${objectVariable}.${this.name}`,
+                },
             })}, ${variables.graph});`,
         ];
     }
-    toStringInitializer(parameters) {
+    toStringInitializer({ variables, }) {
         if (!this.display) {
             return Maybe.empty();
         }
-        return Maybe.of(code `${literalOf(this.name)}: ${this.type.toStringExpression(parameters)}`);
+        const { object: objectVariable, ...otherVariables } = variables;
+        return Maybe.of(code `${literalOf(this.name)}: ${this.type.toStringExpression({ variables: { ...otherVariables, value: code `${objectVariable}.${this.name}` } })}`);
     }
     propertyPathToCode(propertyPath) {
         switch (propertyPath.termType) {

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

@@ -1,15 +1,12 @@
-import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+const variables = {
+    leftObject: code `left`,
+    rightObject: code `right`,
+};
 export function ObjectType_equalsFunctionExpression() {
     const chain = [];
     for (const property of this.properties) {
-        if (property.kind === "Discriminant") {
-            continue;
-        }
-        chain.push(code `${this.reusables.snippets.propertyEquals}(
-        { equalsFunction: ${property.type.equalsFunction}, name: ${literalOf(property.name)} },
-        [left, ${property.accessExpression({ variables: { object: code `left` } })}],
-        [right, ${property.accessExpression({ variables: { object: code `right` } })}],
-      )`);
+        chain.push(...property.equalsExpression({ variables }).toList());
     }
     return code `\
 ((left, right) =>

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

@@ -1,9 +1,18 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
+const variables = {
+    filter: code `filter`,
+    object: code `value`,
+};
 export function ObjectType_filterFunctionExpression() {
     const statements = [];
     for (const property of this.properties) {
-        property.filterProperty.ifJust(({ name }) => {
-            statements.push(code `if (filter.${name} !== undefined && !${property.type.filterFunction}(filter.${name}, ${property.accessExpression({ variables: { object: code `value` } })})) { return false; }`);
+        property
+            .filterExpression({
+            variables,
+        })
+            .ifJust((filterExpression) => {
+            const filterProperty = property.filterProperty.unsafeCoerce();
+            statements.push(code `if (${variables.filter}.${filterProperty.name} !== undefined && !${filterExpression}) { return false; }`);
         });
     }
     statements.push(code `return true;`);

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

@@ -1,24 +1,13 @@
-import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 const variables = {
     filter: code `parameters.filter`,
     focusIdentifier: code `parameters.focusIdentifier`,
+    ignoreRdfType: code `parameters.ignoreRdfType`,
     variablePrefix: code `parameters.variablePrefix`,
 };
 export function ObjectType_focusSparqlConstructTriplesFunctionExpression() {
-    const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
-    const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     let triplesVariableDeclarationKeyword = "const";
     const statements = [];
-    if (this.fromRdfType.isJust()) {
-        statements.push(code `\
-if (!parameters?.ignoreRdfType) {
-  triples.push(
-    { subject: ${variables.focusIdentifier}, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} },
-    { subject: ${rdfTypeVariable}, predicate: ${this.rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }
-  );
-}`);
-    }
     for (const property of this.properties) {
         if (property.recursive) {
             continue;

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

@@ -1,53 +1,15 @@
-import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-const variables = {
-    filter: code `parameters.filter`,
-    preferredLanguages: code `parameters.preferredLanguages`,
-    focusIdentifier: code `parameters.focusIdentifier`,
-    variablePrefix: code `parameters.variablePrefix`,
-};
 export function ObjectType_focusSparqlWherePatternsFunctionExpression() {
-    const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
-    const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     let patternsVariableDeclarationKeyword = "const";
     const statements = [];
-    this.fromRdfTypeVariable.ifJust((fromRdfTypeVariable) => {
-        statements.push(code `const rdfTypeVariable = ${rdfTypeVariable};`, code `\
-if (!parameters?.ignoreRdfType) {
-  patterns.push(
-    ${code `${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariable}, subject: ${variables.focusIdentifier} }),`}
-    {
-      triples: [
-        {
-          subject: ${variables.focusIdentifier},
-          predicate: ${this.rdfjsTermExpression(rdf.type)},
-          object: rdfTypeVariable
-        }
-      ],
-      type: "bgp" as const
-    },
-    {
-      patterns: [
-        {
-          triples: [
-            {
-              subject: rdfTypeVariable,
-              predicate: {
-                items: [${this.rdfjsTermExpression(rdfs.subClassOf)}],
-                pathType: "+" as const,
-                type: "path" as const
-              },
-              object: ${rdfClassVariable}
-            }
-          ],
-          type: "bgp" as const
-        }
-      ],
-      type: "optional" as const
-    }
-  );
-}`);
-    });
+    const variables = {
+        filter: code `parameters.filter`,
+        preferredLanguages: code `parameters.preferredLanguages`,
+        focusIdentifier: code `parameters.focusIdentifier`,
+        ignoreRdfType: code `parameters.ignoreRdfType`,
+        schema: this.name.map((name) => code `${name}.schema`),
+        variablePrefix: code `parameters.variablePrefix`,
+    };
     for (const property of this.properties) {
         if (property.recursive) {
             continue;

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

@@ -8,16 +8,20 @@ export function ObjectType_hashFunctionExpression() {
         const propertyHashStatements = property.hashStatements({
             variables: {
                 hasher: hasherVariable,
-                value: code `${this.thisVariable}.${property.name}`,
+                object: code `${this.thisVariable}`,
             },
         });
         if (propertyHashStatements.length === 0) {
             continue;
         }
         statements = statements.concat(propertyHashStatements);
-        if (!codeEquals(property.hashFunctionParameter, property.declaration)) {
+        const declaration = property.declaration.extract();
+        const hashFunctionParameter = property.hashFunctionParameter.extract();
+        if (declaration &&
+            hashFunctionParameter &&
+            !codeEquals(hashFunctionParameter, declaration)) {
             replacePropertyDeclarations[property.name] =
-                code `${property.hashFunctionParameter}`;
+                code `${hashFunctionParameter}`;
         }
     }
     statements.push(code `return ${hasherVariable};`);

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

@@ -1,10 +1,7 @@
 import { invariant } from "ts-invariant";
-import { arrayOf, code } from "../ts-poet-wrapper.js";
+import { code } from "../ts-poet-wrapper.js";
 export function ObjectType_schemaExpression() {
     const schema = {};
-    this.fromRdfType.ifJust((fromRdfType) => {
-        schema["fromRdfType"] = this.rdfjsTermExpression(fromRdfType);
-    });
     const properties = {};
     for (const property of this.properties) {
         property.schema.ifJust((propertySchema) => {
@@ -13,9 +10,6 @@ export function ObjectType_schemaExpression() {
     }
     invariant(Object.keys(properties).length > 0);
     schema["properties"] = properties;
-    if (this.toRdfTypes.length > 0) {
-        schema["toRdfTypes"] = arrayOf(...this.toRdfTypes.map((toRdfType) => this.rdfjsTermExpression(toRdfType)));
-    }
     return code `${schema} as const`;
 }
 //# sourceMappingURL=ObjectType_schemaExpression.js.map

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

@@ -2,9 +2,6 @@ import { invariant } from "ts-invariant";
 import { code } from "../ts-poet-wrapper.js";
 export function ObjectType_schemaTypeExpression() {
     const schemaType = {};
-    this.fromRdfType.ifJust(() => {
-        schemaType["fromRdfType"] = code `${this.reusables.imports.NamedNode}`;
-    });
     const properties = {};
     for (const property of this.properties) {
         property.schemaType.ifJust((propertySchemaType) => {

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

@@ -4,9 +4,7 @@ export function ObjectType_toJsonFunctionExpression() {
 ((${this.thisVariable}) => JSON.parse(JSON.stringify({ ${joinCode(this.properties.flatMap((property) => property
         .toJsonInitializer({
         variables: {
-            value: property.accessExpression({
-                variables: { object: this.thisVariable },
-            }),
+            object: this.thisVariable,
         },
     })
         .toList()), { on: "," })} } satisfies ${this.jsonType().expression})))`;

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

@@ -7,14 +7,7 @@ export function ObjectType_toRdfResourceFunctionExpression() {
     });
     for (const property of this.properties) {
         statements.push(...property.toRdfRdfResourceValuesStatements({
-            variables: {
-                graph: variables.graph,
-                resource: variables.resource,
-                resourceSet: variables.resourceSet,
-                value: property.accessExpression({
-                    variables: { object: variables.object },
-                }),
-            },
+            variables,
         }));
     }
     statements.push(code `return ${variables.resource};`);