@shaclmate/compiler 2.0.22 → 2.0.23

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -0,0 +1,415 @@
+import { Scope, StructureKind, } from "ts-morph";
+import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
+export function sparqlObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }) {
+    const typeParameters = {
+        ObjectT: {
+            name: "ObjectT",
+        },
+        ObjectIdentifierT: {
+            constraint: "rdfjs.BlankNode | rdfjs.NamedNode",
+            name: "ObjectIdentifierT",
+        },
+    };
+    const sparqlWherePatternsFunctionType = `(parameters?: { subject?: sparqljs.Triple["subject"]; }) => readonly sparqljs.Pattern[]`;
+    const parameters = {
+        constructObjectType: {
+            name: "objectType",
+            type: `{\
+  ${syntheticNamePrefix}fromRdf: (parameters: { objectSet: ${syntheticNamePrefix}ObjectSet, resource: rdfjsResource.Resource }) => purify.Either<Error, ${typeParameters.ObjectT.name}>;
+  ${syntheticNamePrefix}sparqlConstructQueryString: (parameters?: { subject?: sparqljs.Triple["subject"]; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type"> & sparqljs.GeneratorOptions) => string;
+  ${syntheticNamePrefix}sparqlWherePatterns: ${sparqlWherePatternsFunctionType};
+}`,
+        },
+        query: {
+            hasQuestionToken: true,
+            name: "query",
+            type: `${syntheticNamePrefix}SparqlObjectSet.Query<${typeParameters.ObjectIdentifierT.name}>`,
+        },
+        selectObjectTypeType: {
+            name: "objectType",
+            type: `{ ${syntheticNamePrefix}sparqlWherePatterns: ${sparqlWherePatternsFunctionType} }`,
+        },
+        where: {
+            hasQuestionToken: true,
+            name: "where",
+            type: `${syntheticNamePrefix}SparqlObjectSet.Where<${typeParameters.ObjectIdentifierT.name}>`,
+        },
+    };
+    return [
+        {
+            ctors: [
+                {
+                    parameters: [
+                        {
+                            name: "{ sparqlClient }",
+                            type: `{ sparqlClient: ${syntheticNamePrefix}SparqlObjectSet["${syntheticNamePrefix}sparqlClient"] }`,
+                        },
+                    ],
+                    statements: [
+                        `this.${syntheticNamePrefix}sparqlClient = sparqlClient;`,
+                    ],
+                },
+            ],
+            implements: [`${syntheticNamePrefix}ObjectSet`],
+            isExported: true,
+            kind: StructureKind.Class,
+            name: `${syntheticNamePrefix}SparqlObjectSet`,
+            // methods: [
+            methods: [...objectTypes, ...objectUnionTypes].flatMap((objectType) => {
+                if (!objectType.features.has("sparql")) {
+                    return unsupportedObjectSetMethodDeclarations({
+                        objectType,
+                    });
+                }
+                const methodSignatures = objectSetMethodSignatures({
+                    objectType,
+                    queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
+                });
+                const runtimeObjectType = objectType.staticModuleName;
+                return [
+                    {
+                        ...methodSignatures.object,
+                        kind: StructureKind.Method,
+                        isAsync: true,
+                        statements: [
+                            `return (await this.${methodSignatures.objects.name}({ where: { identifiers: [identifier], type: "identifiers" } })).map(objects => objects[0]);`,
+                        ],
+                    },
+                    {
+                        ...methodSignatures.objectIdentifiers,
+                        kind: StructureKind.Method,
+                        isAsync: true,
+                        statements: [
+                            `return this.${syntheticNamePrefix}objectIdentifiers<${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
+                        ],
+                    },
+                    {
+                        ...methodSignatures.objects,
+                        kind: StructureKind.Method,
+                        isAsync: true,
+                        statements: [
+                            `return this.${syntheticNamePrefix}objects<${objectType.name}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
+                        ],
+                    },
+                    {
+                        ...methodSignatures.objectsCount,
+                        isAsync: true,
+                        kind: StructureKind.Method,
+                        statements: [
+                            `return this.${syntheticNamePrefix}objectsCount<${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
+                        ],
+                    },
+                ];
+            }).concat({
+                kind: StructureKind.Method,
+                name: `${syntheticNamePrefix}mapBindingsToCount`,
+                parameters: [
+                    {
+                        name: "bindings",
+                        type: "readonly Record<string, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>[]",
+                    },
+                    {
+                        name: "variable",
+                        type: "string",
+                    },
+                ],
+                returnType: "purify.Either<Error, number>",
+                scope: Scope.Protected,
+                statements: [
+                    `\
+if (bindings.length === 0) {
+  return purify.Left(new Error("empty result rows"));
+}
+if (bindings.length > 1) {
+  return purify.Left(new Error("more than one result row"));
+}
+const count = bindings[0][variable];
+if (typeof count === "undefined") {
+  return purify.Left(new Error("no 'count' variable in result row"));
+}
+if (count.termType !== "Literal") {
+  return purify.Left(new Error("'count' variable is not a Literal"));
+}
+const parsedCount = Number.parseInt(count.value);
+if (Number.isNaN(parsedCount)) {
+  return purify.Left(new Error("'count' variable is NaN"));
+}
+return purify.Either.of(parsedCount);`,
+                ],
+            }, {
+                kind: StructureKind.Method,
+                name: `${syntheticNamePrefix}mapBindingsToIdentifiers`,
+                parameters: [
+                    {
+                        name: "bindings",
+                        type: "readonly Record<string, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>[]",
+                    },
+                    {
+                        name: "variable",
+                        type: "string",
+                    },
+                ],
+                returnType: "readonly rdfjs.NamedNode[]",
+                scope: Scope.Protected,
+                statements: [
+                    `\
+const identifiers: rdfjs.NamedNode[] = [];
+for (const bindings_ of bindings) {
+  const identifier = bindings_[variable];
+  if (
+    typeof identifier !== "undefined" &&
+    identifier.termType === "NamedNode"
+  ) {
+    identifiers.push(identifier);
+  }
+}
+return identifiers;`,
+                ],
+            }, {
+                kind: StructureKind.Method,
+                isAsync: true,
+                name: `${syntheticNamePrefix}objectIdentifiers`,
+                parameters: [parameters.selectObjectTypeType, parameters.query],
+                returnType: `Promise<purify.Either<Error, readonly ${typeParameters.ObjectIdentifierT.name}[]>>`,
+                scope: Scope.Protected,
+                statements: [
+                    `\
+const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
+if (limit <= 0) {
+  return purify.Either.of([]);
+}
+
+let offset = query?.offset ?? 0;
+if (offset < 0) {
+  offset = 0;
+}
+
+const wherePatterns = this.${syntheticNamePrefix}wherePatterns(objectType, query?.where).filter(pattern => pattern.type !== "optional");
+if (wherePatterns.length === 0) {
+  return purify.Left(new Error("no required SPARQL WHERE patterns for identifiers"));
+}
+
+const selectQueryString = \
+  this.${syntheticNamePrefix}sparqlGenerator.stringify({
+    distinct: true,
+    limit: limit < Number.MAX_SAFE_INTEGER ? limit : undefined,
+    offset,
+    order: query?.order ? query.order(this.${syntheticNamePrefix}objectVariable).concat() : [{ expression: this.${syntheticNamePrefix}objectVariable }],
+    prefixes: {},
+    queryType: "SELECT",
+    type: "query",
+    variables: [this.${syntheticNamePrefix}objectVariable],
+    where: wherePatterns
+  });
+  
+return purify.EitherAsync(async () =>
+  this.${syntheticNamePrefix}mapBindingsToIdentifiers(
+    await this.${syntheticNamePrefix}sparqlClient.queryBindings(selectQueryString),
+    this.${syntheticNamePrefix}objectVariable.value,
+  ) as readonly ${typeParameters.ObjectIdentifierT.name}[],
+);`,
+                ],
+                typeParameters: [typeParameters.ObjectIdentifierT],
+            }, {
+                isAsync: true,
+                kind: StructureKind.Method,
+                name: `${syntheticNamePrefix}objects`,
+                parameters: [parameters.constructObjectType, parameters.query],
+                returnType: `Promise<purify.Either<Error, readonly ${typeParameters.ObjectT.name}[]>>`,
+                statements: [
+                    `\
+const identifiersEither = await this.${syntheticNamePrefix}objectIdentifiers<${typeParameters.ObjectIdentifierT.name}>(objectType, query);
+if (identifiersEither.isLeft()) {
+  return identifiersEither;
+}
+const identifiers = identifiersEither.unsafeCoerce();
+if (identifiers.length === 0) {
+  return purify.Either.of([]);
+}
+
+const constructQueryString = objectType.${syntheticNamePrefix}sparqlConstructQueryString({
+  subject: this.${syntheticNamePrefix}objectVariable,
+  where: [{
+    type: "values" as const,
+    values: identifiers.map((identifier) => {
+      const valuePatternRow: sparqljs.ValuePatternRow = {};
+      valuePatternRow["?object"] = identifier as rdfjs.NamedNode;
+      return valuePatternRow;
+    }),
+  }]
+});
+
+let quads: readonly rdfjs.Quad[];
+try {
+  quads = await this.${syntheticNamePrefix}sparqlClient.queryQuads(constructQueryString);
+} catch (e) {
+  return purify.Left(e as Error);
+}
+
+const dataset: rdfjs.DatasetCore = new N3.Store(quads.concat());
+const objects: ${typeParameters.ObjectT.name}[] = [];
+for (const identifier of identifiers) {
+  const objectEither = objectType.${syntheticNamePrefix}fromRdf({
+    objectSet: this,
+    resource: new rdfjsResource.Resource<rdfjs.NamedNode>({ dataset, identifier: identifier as rdfjs.NamedNode })
+  });
+  if (objectEither.isLeft()) {
+    return objectEither;
+  }
+  objects.push(objectEither.unsafeCoerce());
+}
+return purify.Either.of(objects);`,
+                ],
+                typeParameters: [
+                    typeParameters.ObjectT,
+                    typeParameters.ObjectIdentifierT,
+                ],
+            }, {
+                kind: StructureKind.Method,
+                isAsync: true,
+                name: `${syntheticNamePrefix}objectsCount`,
+                parameters: [parameters.selectObjectTypeType, parameters.query],
+                returnType: "Promise<purify.Either<Error, number>>",
+                scope: Scope.Protected,
+                statements: [
+                    `\
+const wherePatterns = this.${syntheticNamePrefix}wherePatterns(objectType, query?.where).filter(pattern => pattern.type !== "optional");
+if (wherePatterns.length === 0) {
+  return purify.Left(new Error("no required SPARQL WHERE patterns for count"));
+}
+
+const selectQueryString = \
+  this.${syntheticNamePrefix}sparqlGenerator.stringify({
+    prefixes: {},
+    queryType: "SELECT",
+    type: "query",
+    variables: [
+      {
+        expression: {
+          aggregation: "COUNT",
+          distinct: true,
+          expression: this.${syntheticNamePrefix}objectVariable,
+          type: "aggregate",
+        },
+        variable: this.${syntheticNamePrefix}countVariable,
+      },
+    ],
+    where: wherePatterns
+  });
+
+return purify.EitherAsync(async ({ liftEither }) =>
+  liftEither(
+    this.${syntheticNamePrefix}mapBindingsToCount(
+      await this.${syntheticNamePrefix}sparqlClient.queryBindings(selectQueryString),
+      this.${syntheticNamePrefix}countVariable.value,
+    ),
+  ),
+);`,
+                ],
+                typeParameters: [typeParameters.ObjectIdentifierT],
+            }, {
+                kind: StructureKind.Method,
+                name: `${syntheticNamePrefix}wherePatterns`,
+                parameters: [parameters.selectObjectTypeType, parameters.where],
+                returnType: "sparqljs.Pattern[]",
+                scope: Scope.Protected,
+                statements: [
+                    `\
+const patterns: sparqljs.Pattern[] = [];
+
+// Patterns should be most to least specific.
+
+if (where) {
+  // Assign a separate variable so the compiler catches any missing cases
+  let wherePatterns: readonly sparqljs.Pattern[];
+  switch (where.type) {
+    case "identifiers": {
+      const valuePatternRowKey = \`?\${this.${syntheticNamePrefix}objectVariable.value}\`;
+      wherePatterns = [{
+        type: "values" as const,
+        values: where.identifiers.map((identifier) => {
+          const valuePatternRow: sparqljs.ValuePatternRow = {};
+          valuePatternRow[valuePatternRowKey] = identifier as rdfjs.NamedNode;
+          return valuePatternRow;
+        }),
+      }];
+      break;
+    }
+    case "sparql-patterns": {
+      wherePatterns = where.sparqlPatterns(this.${syntheticNamePrefix}objectVariable);
+      break;
+    }
+    case "triple-objects": {
+      wherePatterns = [{
+        triples: [{
+          subject: where.subject,
+          predicate: where.predicate,
+          object: this.${syntheticNamePrefix}objectVariable
+        }],
+        type: "bgp"
+      }];
+      break;
+    }
+  }
+  patterns.push(...wherePatterns);
+}
+
+patterns.push(...objectType.${syntheticNamePrefix}sparqlWherePatterns({ subject: this.${syntheticNamePrefix}objectVariable }));
+
+return patterns;`,
+                ],
+                typeParameters: [typeParameters.ObjectIdentifierT],
+            }),
+            properties: [
+                {
+                    initializer: `dataFactory.variable!("count");`,
+                    isReadonly: true,
+                    name: `${syntheticNamePrefix}countVariable`,
+                    scope: Scope.Protected,
+                },
+                {
+                    initializer: `dataFactory.variable!("object");`,
+                    isReadonly: true,
+                    name: `${syntheticNamePrefix}objectVariable`,
+                    scope: Scope.Protected,
+                },
+                {
+                    isReadonly: true,
+                    name: `${syntheticNamePrefix}sparqlClient`,
+                    scope: Scope.Protected,
+                    type: "{ queryBindings: (query: string) => Promise<readonly Record<string, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>[]>; queryQuads: (query: string) => Promise<readonly rdfjs.Quad[]>; }",
+                },
+                {
+                    initializer: "new sparqljs.Generator()",
+                    isReadonly: true,
+                    name: `${syntheticNamePrefix}sparqlGenerator`,
+                    scope: Scope.Protected,
+                },
+            ],
+        },
+        {
+            isExported: true,
+            kind: StructureKind.Module,
+            name: `${syntheticNamePrefix}SparqlObjectSet`,
+            statements: [
+                {
+                    isExported: true,
+                    kind: StructureKind.TypeAlias,
+                    name: "Query",
+                    type: `Omit<${syntheticNamePrefix}ObjectSet.Query<${typeParameters.ObjectIdentifierT.name}>, "where"> & { readonly order?: (objectVariable: rdfjs.Variable) => readonly sparqljs.Ordering[]; readonly where?: Where<${typeParameters.ObjectIdentifierT.name}> }`,
+                    typeParameters: [typeParameters.ObjectIdentifierT],
+                },
+                {
+                    kind: StructureKind.TypeAlias,
+                    isExported: true,
+                    name: "Where",
+                    type: `${syntheticNamePrefix}ObjectSet.Where<${typeParameters.ObjectIdentifierT.name}> | { readonly sparqlPatterns: (objectVariable: rdfjs.Variable) => readonly sparqljs.Pattern[]; readonly type: "sparql-patterns" }`,
+                    typeParameters: [typeParameters.ObjectIdentifierT],
+                },
+            ],
+        },
+    ];
+}
+//# sourceMappingURL=sparqlObjectSetClassDeclaration.js.map

package/dist/generators/ts/syntheticNamePrefix.d.ts

@@ -0,0 +1,2 @@
+export declare const syntheticNamePrefix = "$";
+//# sourceMappingURL=syntheticNamePrefix.d.ts.map

package/dist/generators/ts/syntheticNamePrefix.js

@@ -0,0 +1,2 @@
+export const syntheticNamePrefix = "$";
+//# sourceMappingURL=syntheticNamePrefix.js.map

package/dist/generators/ts/tsName.js

@@ -1,19 +1,33 @@
 import { Resource } from "rdfjs-resource";
 import { stringToValidTsIdentifier } from "./stringToValidTsIdentifier.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+function* tsNameAlternatives(astName) {
+    yield astName.shaclmateName.extract();
+    yield astName.shName.extract()?.replace(" ", "_");
+    yield astName.label.extract()?.replace(" ", "_");
+    yield astName.propertyPath
+        .chain((propertyPath) => propertyPath.uniqueLocalPart())
+        .extract();
+    yield astName.propertyPath
+        .chain((propertyPath) => propertyPath.curie.map((curie) => `${curie.prefix}_${curie.reference}`))
+        .extract();
+    if (astName.identifier.termType === "NamedNode") {
+        yield astName.identifier.uniqueLocalPart().extract();
+        yield astName.identifier.curie
+            .map((curie) => `${curie.prefix}_${curie.reference}`)
+            .extract();
+    }
+    yield astName.propertyPath
+        .map((propertyPath) => Resource.Identifier.toString(propertyPath))
+        .extract();
+    yield Resource.Identifier.toString(astName.identifier);
+}
 export function tsName(astName) {
-    for (const tsNameAlternative of [
-        astName.shaclmateName.extract(),
-        astName.shName.extract()?.replace(" ", "_"),
-        astName.label.extract()?.replace(" ", "_"),
-        astName.curie.map((curie) => curie.replace(":", "_")).extract(),
-        astName.propertyPath
-            .chain((propertyPath) => propertyPath.curie.map((curie) => curie.replace(":", "_")))
-            .extract(),
-        astName.propertyPath
-            .map((propertyPath) => Resource.Identifier.toString(propertyPath.identifier))
-            .extract(),
-        Resource.Identifier.toString(astName.identifier),
-    ]) {
+    const syntheticName = astName.syntheticName.extract();
+    if (syntheticName) {
+        return `${syntheticNamePrefix}${syntheticName}`;
+    }
+    for (const tsNameAlternative of tsNameAlternatives(astName)) {
         if (tsNameAlternative) {
             return stringToValidTsIdentifier(tsNameAlternative);
         }

package/dist/generators/ts/unsupportedObjectSetMethodDeclarations.d.ts

@@ -0,0 +1,10 @@
+import { type MethodDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "./ObjectType.js";
+export declare function unsupportedObjectSetMethodDeclarations({ objectType, }: {
+    objectType: {
+        readonly identifierTypeAlias: string;
+        readonly objectSetMethodNames: ObjectType.ObjectSetMethodNames;
+        readonly name: string;
+    };
+}): readonly MethodDeclarationStructure[];
+//# sourceMappingURL=unsupportedObjectSetMethodDeclarations.d.ts.map

package/dist/generators/ts/unsupportedObjectSetMethodDeclarations.js

@@ -0,0 +1,19 @@
+import { StructureKind } from "ts-morph";
+import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+export function unsupportedObjectSetMethodDeclarations({ objectType, }) {
+    return Object.entries(objectSetMethodSignatures({ objectType })).map(([methodName, methodSignature]) => ({
+        ...methodSignature,
+        kind: StructureKind.Method,
+        parameters: methodSignature.parameters
+            ? methodSignature.parameters.map((parameter) => ({
+                ...parameter,
+                name: `_${parameter.name}`,
+            }))
+            : methodSignature.parameters,
+        isAsync: true,
+        statements: methodName === "objects"
+            ? [`return [purify.Left(new Error("${methodName}: not supported"))];`]
+            : [`return purify.Left(new Error("${methodName}: not supported"));`],
+    }));
+}
+//# sourceMappingURL=unsupportedObjectSetMethodDeclarations.js.map

package/dist/input/NodeShape.d.ts

@@ -1,18 +1,18 @@
 import type { NamedNode } from "@rdfjs/types";
-import { NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
+import { type IdentifierNodeKind, NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
+import type * as generated from "./generated.js";
 import type { IdentifierMintingStrategy, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
 import type { Shape } from "./Shape.js";
-import type * as generated from "./generated.js";
 import type { Ontology, PropertyGroup, PropertyShape, ShapesGraph } from "./index.js";
 export declare class NodeShape extends ShaclCoreNodeShape<any, Ontology, PropertyGroup, PropertyShape, Shape> {
-    readonly isClass: boolean;
-    readonly isList: boolean;
     private readonly ancestorClassIris;
     private readonly childClassIris;
     private readonly descendantClassIris;
     private readonly generatedShaclmateNodeShape;
     private readonly parentClassIris;
+    readonly isClass: boolean;
+    readonly isList: boolean;
     constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedShaclmateNodeShape, isClass, isList, parentClassIris, shapesGraph, }: {
         ancestorClassIris: readonly NamedNode[];
         generatedShaclmateNodeShape: generated.ShaclmateNodeShape;
@@ -32,16 +32,14 @@ export declare class NodeShape extends ShaclCoreNodeShape<any, Ontology, Propert
     get fromRdfType(): Maybe<NamedNode>;
     get identifierMintingStrategy(): Maybe<IdentifierMintingStrategy>;
     get mutable(): Maybe<boolean>;
-    get nodeKinds(): Set<"BlankNode" | "NamedNode">;
+    get nodeKinds(): Set<IdentifierNodeKind>;
     get parentNodeShapes(): readonly NodeShape[];
+    get rdfType(): Maybe<NamedNode>;
     get shaclmateName(): Maybe<string>;
     get toRdfTypes(): readonly NamedNode[];
     get tsFeatures(): Maybe<Set<TsFeature>>;
     get tsImports(): readonly string[];
     get tsObjectDeclarationType(): Maybe<TsObjectDeclarationType>;
-    get tsObjectIdentifierPrefixPropertyName(): Maybe<string>;
-    get tsObjectIdentifierPropertyName(): Maybe<string>;
-    get tsObjectTypeDiscriminatorPropertyName(): Maybe<string>;
     private get _mintingStrategy();
 }
 //# sourceMappingURL=NodeShape.d.ts.map

package/dist/input/NodeShape.js

@@ -1,14 +1,14 @@
-import { NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
+import { NodeShape as ShaclCoreNodeShape, } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 import { tsFeatures } from "./tsFeatures.js";
 export class NodeShape extends ShaclCoreNodeShape {
-    isClass;
-    isList;
     ancestorClassIris;
     childClassIris;
     descendantClassIris;
     generatedShaclmateNodeShape;
     parentClassIris;
+    isClass;
+    isList;
     constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedShaclmateNodeShape, isClass, isList, parentClassIris, shapesGraph, }) {
         super(generatedShaclmateNodeShape, shapesGraph);
         this.ancestorClassIris = ancestorClassIris;
@@ -44,19 +44,7 @@ export class NodeShape extends ShaclCoreNodeShape {
         return this.generatedShaclmateNodeShape.extern;
     }
     get fromRdfType() {
-        // Check for an explicit shaclmate:fromRdfType
-        const fromRdfType = this.generatedShaclmateNodeShape.fromRdfType;
-        if (fromRdfType.isJust()) {
-            return fromRdfType;
-        }
-        // No explicit shaclmate:fromRdfType
-        // If the shape is a class, not abstract, and identified by an IRI then use the shape IRI as the fromRdfType.
-        if (!this.abstract.orDefault(false) &&
-            this.isClass &&
-            this.identifier.termType === "NamedNode") {
-            return Maybe.of(this.identifier);
-        }
-        return Maybe.empty();
+        return this.generatedShaclmateNodeShape.fromRdfType;
     }
     get identifierMintingStrategy() {
         const thisMintingStrategy = this._mintingStrategy;
@@ -106,28 +94,26 @@ export class NodeShape extends ShaclCoreNodeShape {
             ? this.parentClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri).toList())
             : [];
     }
+    get rdfType() {
+        // Check for an explicit shaclmate:rdfType
+        const rdfType = this.generatedShaclmateNodeShape.rdfType;
+        if (rdfType.isJust()) {
+            return rdfType;
+        }
+        // No explicit shaclmate:rdfType
+        // If the shape is a class, not abstract, and identified by an IRI then use the shape IRI as the fromRdfType.
+        if (!this.abstract.orDefault(false) &&
+            this.isClass &&
+            this.identifier.termType === "NamedNode") {
+            return Maybe.of(this.identifier);
+        }
+        return Maybe.empty();
+    }
     get shaclmateName() {
         return this.generatedShaclmateNodeShape.name;
     }
     get toRdfTypes() {
-        // Look for one or more explicit shaclmate:toRdfType's
-        const toRdfTypes = this.generatedShaclmateNodeShape.toRdfTypes.concat();
-        // Ensure the toRdfTypes includes the fromRdfType if there is one
-        this.fromRdfType.ifJust((fromRdfType) => {
-            if (!toRdfTypes.some((toRdfType) => toRdfType.equals(fromRdfType))) {
-                toRdfTypes.push(fromRdfType);
-            }
-        });
-        if (toRdfTypes.length === 0) {
-            // No explicit shaclmate:toRdfType's
-            // If the shape is a class, not abstract, and identified by an IRI then use the shape IRI as the fromRdfType.
-            if (!this.abstract.orDefault(false) &&
-                this.isClass &&
-                this.identifier.termType === "NamedNode") {
-                toRdfTypes.push(this.identifier);
-            }
-        }
-        return toRdfTypes;
+        return this.generatedShaclmateNodeShape.toRdfTypes;
     }
     get tsFeatures() {
         return tsFeatures(this.generatedShaclmateNodeShape).altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsFeatures));
@@ -149,16 +135,6 @@ export class NodeShape extends ShaclCoreNodeShape {
         })
             .altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsObjectDeclarationType));
     }
-    get tsObjectIdentifierPrefixPropertyName() {
-        return this.generatedShaclmateNodeShape.tsObjectIdentifierPrefixPropertyName.altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsObjectIdentifierPrefixPropertyName));
-    }
-    get tsObjectIdentifierPropertyName() {
-        return this.generatedShaclmateNodeShape.tsObjectIdentifierPrefixPropertyName.altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsObjectIdentifierPropertyName));
-    }
-    get tsObjectTypeDiscriminatorPropertyName() {
-        return this.generatedShaclmateNodeShape
-            .tsObjectTypeDiscriminatorPropertyName;
-    }
     get _mintingStrategy() {
         return this.generatedShaclmateNodeShape.identifierMintingStrategy.map((iri) => {
             switch (iri.value) {

package/dist/input/Ontology.d.ts

@@ -5,11 +5,8 @@ import type * as generated from "./generated.js";
 export declare class Ontology extends OwlOntology {
     private readonly generatedShaclmateOntology;
     constructor(generatedShaclmateOntology: generated.ShaclmateOntology);
-    get tsDataFactoryVariable(): Maybe<string>;
     get tsFeatures(): Maybe<Set<TsFeature>>;
     get tsImports(): readonly string[];
     get tsObjectDeclarationType(): Maybe<TsObjectDeclarationType>;
-    get tsObjectIdentifierPrefixPropertyName(): Maybe<string>;
-    get tsObjectIdentifierPropertyName(): Maybe<string>;
 }
 //# sourceMappingURL=Ontology.d.ts.map

package/dist/input/Ontology.js

@@ -6,9 +6,6 @@ export class Ontology extends OwlOntology {
         super(generatedShaclmateOntology);
         this.generatedShaclmateOntology = generatedShaclmateOntology;
     }
-    get tsDataFactoryVariable() {
-        return this.generatedShaclmateOntology.tsDataFactoryVariable;
-    }
     get tsFeatures() {
         return tsFeatures(this.generatedShaclmateOntology);
     }
@@ -27,11 +24,5 @@ export class Ontology extends OwlOntology {
             }
         });
     }
-    get tsObjectIdentifierPrefixPropertyName() {
-        return this.generatedShaclmateOntology.tsObjectIdentifierPrefixPropertyName;
-    }
-    get tsObjectIdentifierPropertyName() {
-        return this.generatedShaclmateOntology.tsObjectIdentifierPropertyName;
-    }
 }
 //# sourceMappingURL=Ontology.js.map