@shaclmate/compiler 2.0.23 → 2.0.24

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

@@ -1,25 +1,76 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { StructureKind } from "ts-morph";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { toRdfFunctionOrMethodDeclaration } from "./toRdfFunctionOrMethodDeclaration.js";
-function fromRdfFunctionDeclarations() {
+function fromRdfFunctionDeclaration() {
+    const statements = [];
+    statements.push("let { ignoreRdfType = false, languageIn, objectSet, ...context } = (options ?? {});", `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet({ dataset: resource.dataset }); }`);
+    let returnExpression;
+    if (this.childObjectTypes.length > 0) {
+        // Can't ignore the RDF type.
+        // Similar to an object union type, alt-chain the fromRdf of the different concrete subclasses together
+        returnExpression = this.childObjectTypes.reduce((expression, childObjectType) => {
+            const childObjectTypeExpression = `(${childObjectType.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...context, ignoreRdfType: false, objectSet }) as purify.Either<Error, ${this.name}>)`;
+            return expression.length > 0
+                ? `${expression}.altLazy(() => ${childObjectTypeExpression})`
+                : childObjectTypeExpression;
+        }, "");
+    }
+    if (!this.abstract) {
+        let propertiesFromRdfExpression = `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ ...context, ignoreRdfType, languageIn, objectSet, resource })`;
+        if (this.declarationType === "class") {
+            propertiesFromRdfExpression = `${propertiesFromRdfExpression}.map(properties => new ${this.name}(properties))`;
+        }
+        if (this.childObjectTypes.length > 0) {
+            invariant(returnExpression);
+            returnExpression = `${returnExpression}.altLazy(() => ${propertiesFromRdfExpression})`;
+        }
+        else {
+            invariant(!returnExpression);
+            returnExpression = propertiesFromRdfExpression;
+        }
+    }
+    if (returnExpression) {
+        statements.push(`return ${returnExpression};`);
+    }
+    if (statements.length === 0) {
+        return Maybe.empty();
+    }
+    return Maybe.of({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: `${syntheticNamePrefix}fromRdf`,
+        parameters: [
+            {
+                name: "resource",
+                type: "rdfjsResource.Resource",
+            },
+            {
+                hasQuestionToken: true,
+                name: "options",
+                type: `{ [_index: string]: any; ignoreRdfType?: boolean; languageIn?: readonly string[]; objectSet?: ${syntheticNamePrefix}ObjectSet; }`,
+            },
+        ],
+        returnType: `purify.Either<Error, ${this.name}>`,
+        statements: statements,
+    });
+}
+function propertiesFromRdfFunctionDeclaration() {
     const initializers = [];
     const propertySignatures = [];
-    const propertiesFromRdfReturnType = [];
-    const propertiesFromRdfStatements = [];
-    if (this.ownProperties.length > 0 || this.parentObjectTypes.length > 0) {
-        propertiesFromRdfStatements.push("// @ts-ignore", `const ${syntheticNamePrefix}objectSet = ${syntheticNamePrefix}objectSetParameter ?? new ${syntheticNamePrefix}RdfjsDatasetObjectSet({ dataset: ${variables.resource}.dataset });`);
-    }
+    const returnType = [];
+    const statements = [];
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        propertiesFromRdfStatements.push(`const ${syntheticNamePrefix}super${parentObjectTypeI}Either = ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ ...${variables.context}, ignoreRdfType: true, languageIn: ${variables.languageIn}, objectSet: ${variables.objectSet}, resource: ${variables.resource} });`, `if (${syntheticNamePrefix}super${parentObjectTypeI}Either.isLeft()) { return ${syntheticNamePrefix}super${parentObjectTypeI}Either; }`, `const ${syntheticNamePrefix}super${parentObjectTypeI} = ${syntheticNamePrefix}super${parentObjectTypeI}Either.unsafeCoerce()`);
+        statements.push(`const ${syntheticNamePrefix}super${parentObjectTypeI}Either = ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ ...${variables.context}, ignoreRdfType: true, languageIn: ${variables.languageIn}, objectSet: ${variables.objectSet}, resource: ${variables.resource} });`, `if (${syntheticNamePrefix}super${parentObjectTypeI}Either.isLeft()) { return ${syntheticNamePrefix}super${parentObjectTypeI}Either; }`, `const ${syntheticNamePrefix}super${parentObjectTypeI} = ${syntheticNamePrefix}super${parentObjectTypeI}Either.unsafeCoerce()`);
         initializers.push(`...${syntheticNamePrefix}super${parentObjectTypeI}`);
-        propertiesFromRdfReturnType.push(`${syntheticNamePrefix}UnwrapR<ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf>>`);
+        returnType.push(`${syntheticNamePrefix}UnwrapR<ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf>>`);
     });
     this.fromRdfType.ifJust((rdfType) => {
         const predicate = rdfjsTermExpression(rdf.type);
-        propertiesFromRdfStatements.push(`\
+        statements.push(`\
 if (!${variables.ignoreRdfType} && !${variables.resource}.isInstanceOf(${syntheticNamePrefix}fromRdfType)) {
   return ${variables.resource}.value(${predicate}).chain(actualRdfType => actualRdfType.toIri()).chain((actualRdfType) => purify.Left(new Error(\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type (actual: \${actualRdfType.value}, expected: ${rdfType.value})\`)));
 }`);
@@ -35,88 +86,28 @@ if (!${variables.ignoreRdfType} && !${variables.resource}.isInstanceOf(${synthet
             variables: propertyFromRdfVariables,
         });
         if (propertyFromRdfStatements.length > 0) {
-            propertiesFromRdfStatements.push(...propertyFromRdfStatements);
+            statements.push(...propertyFromRdfStatements);
             initializers.push(property.name);
             propertySignatures.push(`${property.name}: ${property.type.name};`);
         }
     }
-    propertiesFromRdfStatements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
+    statements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
     if (propertySignatures.length > 0) {
-        propertiesFromRdfReturnType.splice(0, 0, `{ ${propertySignatures.join(" ")} }`);
+        returnType.splice(0, 0, `{ ${propertySignatures.join(" ")} }`);
     }
-    const functionDeclarations = [];
-    functionDeclarations.push({
+    return {
         isExported: true,
         kind: StructureKind.Function,
         name: `${syntheticNamePrefix}propertiesFromRdf`,
         parameters: [
             {
-                name: `{ ignoreRdfType: ${variables.ignoreRdfType}, languageIn: ${variables.languageIn}, objectSet: ${syntheticNamePrefix}objectSetParameter, resource: ${variables.resource},\n// @ts-ignore\n...${variables.context} }`,
-                type: `{ [_index: string]: any; ignoreRdfType?: boolean; languageIn?: readonly string[]; objectSet?: ${syntheticNamePrefix}ObjectSet; resource: rdfjsResource.Resource; }`,
+                name: `{ ignoreRdfType: ${variables.ignoreRdfType}, languageIn: ${variables.languageIn}, objectSet: ${variables.objectSet}, resource: ${variables.resource},\n// @ts-ignore\n...${variables.context} }`,
+                type: `{ [_index: string]: any; ignoreRdfType: boolean; languageIn?: readonly string[]; objectSet: ${syntheticNamePrefix}ObjectSet; resource: rdfjsResource.Resource; }`,
             },
         ],
-        returnType: `purify.Either<Error, ${propertiesFromRdfReturnType.join(" & ")}>`,
-        statements: propertiesFromRdfStatements,
-    });
-    const fromRdfStatements = [];
-    let fromRdfReturnStatement;
-    if (this.abstract) {
-        if (this.childObjectTypes.length > 0) {
-            // Can't ignore the RDF type if we're doing a union.
-            fromRdfStatements.push("const { ignoreRdfType: _, ...otherParameters } = parameters;");
-            // Similar to an object union type, alt-chain the fromRdf of the different concrete subclasses together
-            fromRdfReturnStatement = `return ${this.childObjectTypes.reduce((expression, childObjectType) => {
-                const childObjectTypeExpression = `(${childObjectType.staticModuleName}.${syntheticNamePrefix}fromRdf(otherParameters) as purify.Either<Error, ${this.name}>)`;
-                return expression.length > 0
-                    ? `${expression}.altLazy(() => ${childObjectTypeExpression})`
-                    : childObjectTypeExpression;
-            }, "")};`;
-        }
-    }
-    else {
-        let propertiesFromRdfExpression;
-        switch (this.declarationType) {
-            case "class":
-                propertiesFromRdfExpression = `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf(parameters).map(properties => new ${this.name}(properties))`;
-                break;
-            case "interface":
-                propertiesFromRdfExpression = `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf(parameters)`;
-                break;
-        }
-        if (this.childObjectTypes.length > 0) {
-            // Can't ignore the RDF type if we're trying the child object type.
-            fromRdfStatements.push("const { ignoreRdfType: _, ...otherParameters } = parameters;");
-            fromRdfReturnStatement = `${this.childObjectTypes.reduce((expression, childObjectType) => {
-                const childObjectTypeExpression = `(${childObjectType.staticModuleName}.${syntheticNamePrefix}fromRdf(otherParameters) as purify.Either<Error, ${this.name}>)`;
-                return expression.length > 0
-                    ? `${expression}.altLazy(() => ${childObjectTypeExpression})`
-                    : childObjectTypeExpression;
-            }, "")}.altLazy(() => ${propertiesFromRdfExpression})`;
-        }
-        else {
-            fromRdfReturnStatement = propertiesFromRdfExpression;
-        }
-        fromRdfReturnStatement = `return ${fromRdfReturnStatement};`;
-    }
-    if (fromRdfReturnStatement) {
-        fromRdfStatements.push(fromRdfReturnStatement);
-    }
-    if (fromRdfStatements.length > 0) {
-        functionDeclarations.push({
-            isExported: true,
-            kind: StructureKind.Function,
-            name: `${syntheticNamePrefix}fromRdf`,
-            parameters: [
-                {
-                    name: "parameters",
-                    type: `Parameters<typeof ${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf>[0]`,
-                },
-            ],
-            returnType: `purify.Either<Error, ${this.name}>`,
-            statements: fromRdfStatements,
-        });
-    }
-    return functionDeclarations;
+        returnType: `purify.Either<Error, ${returnType.join(" & ")}>`,
+        statements: statements,
+    };
 }
 export function rdfFunctionDeclarations() {
     if (!this.features.has("rdf")) {
@@ -126,7 +117,8 @@ export function rdfFunctionDeclarations() {
         return [];
     }
     return [
-        ...fromRdfFunctionDeclarations.bind(this)(),
+        ...fromRdfFunctionDeclaration.bind(this)().toList(),
+        propertiesFromRdfFunctionDeclaration.bind(this)(),
         ...toRdfFunctionDeclaration.bind(this)().toList(),
     ];
 }

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

@@ -9,13 +9,13 @@ export function sparqlConstructQueryFunctionDeclaration() {
             {
                 hasQuestionToken: true,
                 name: "parameters",
-                type: '{ ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; subject?: sparqljs.Triple["subject"]; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type">',
+                type: '{ ignoreRdfType?: boolean; languageIn?: readonly string[]; prefixes?: { [prefix: string]: string }; subject?: sparqljs.Triple["subject"]; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type">',
             },
         ],
         returnType: "sparqljs.ConstructQuery",
         statements: [
-            "const { ignoreRdfType, subject, ...queryParameters } = parameters ?? {}",
-            `return { ...queryParameters, prefixes: parameters?.prefixes ?? {}, queryType: "CONSTRUCT", template: (queryParameters.template ?? []).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTemplateTriples({ ignoreRdfType, subject })), type: "query", where: (queryParameters.where ?? []).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ ignoreRdfType, subject })) };`,
+            "const { ignoreRdfType, languageIn, subject, ...queryParameters } = parameters ?? {}",
+            `return { ...queryParameters, prefixes: parameters?.prefixes ?? {}, queryType: "CONSTRUCT", template: (queryParameters.template ?? []).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTemplateTriples({ ignoreRdfType, subject })), type: "query", where: (queryParameters.where ?? []).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ ignoreRdfType, languageIn, subject })) };`,
         ],
     };
 }

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

@@ -9,7 +9,7 @@ export function sparqlConstructQueryStringFunctionDeclaration() {
             {
                 hasQuestionToken: true,
                 name: "parameters",
-                type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"]; variablePrefix?: string; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type"> & sparqljs.GeneratorOptions',
+                type: '{ ignoreRdfType?: boolean; languageIn?: readonly string[]; subject?: sparqljs.Triple["subject"]; variablePrefix?: string; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type"> & sparqljs.GeneratorOptions',
             },
         ],
         returnType: "string",

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

@@ -12,7 +12,11 @@ export function sparqlFunctionDeclarations() {
     if (this.extern) {
         return [];
     }
-    const variables = { subject: "subject", variablePrefix: "variablePrefix" };
+    const variables = {
+        languageIn: "parameters?.languageIn",
+        subject: "subject",
+        variablePrefix: "variablePrefix",
+    };
     const rdfClassVariable = `dataFactory.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
     const rdfTypeVariable = `dataFactory.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     const subjectDefault = camelCase(this.name);
@@ -135,7 +139,7 @@ for (const pattern of propertyPatterns) {
                 {
                     hasQuestionToken: true,
                     name: `${nop ? "_" : ""}parameters`,
-                    type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
+                    type: '{ ignoreRdfType?: boolean; languageIn?: readonly string[]; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                 },
             ],
             returnType: "readonly sparqljs.Pattern[]",

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

@@ -7,8 +7,23 @@ export function toRdfFunctionOrMethodDeclaration() {
         return Maybe.empty();
     }
     this.ensureAtMostOneSuperObjectType();
+    const parameters = [];
+    if (this.declarationType === "interface") {
+        parameters.push({
+            name: this.thisVariable,
+            type: this.name,
+        });
+    }
+    parameters.push({
+        hasQuestionToken: true,
+        name: "options",
+        type: `{ ${variables.ignoreRdfType}?: boolean; ${variables.mutateGraph}?: rdfjsResource.MutableResource.MutateGraph, ${variables.resourceSet}?: rdfjsResource.MutableResourceSet }`,
+    });
     let usedIgnoreRdfTypeVariable = false;
-    const statements = [];
+    const statements = [
+        `const ${variables.mutateGraph} = options?.${variables.mutateGraph};`,
+        `const ${variables.resourceSet} = options?.${variables.resourceSet} ?? new rdfjsResource.MutableResourceSet({ dataFactory, dataset: datasetFactory.dataset() });`,
+    ];
     if (this.parentObjectTypes.length > 0) {
         const superToRdfOptions = `{ ${variables.ignoreRdfType}: true, ${variables.mutateGraph}, ${variables.resourceSet} }`;
         let superToRdfCall;
@@ -42,17 +57,9 @@ export function toRdfFunctionOrMethodDeclaration() {
         }));
     }
     statements.push(`return ${variables.resource};`);
-    const parameters = [];
-    if (this.declarationType === "interface") {
-        parameters.push({
-            name: this.thisVariable,
-            type: this.name,
-        });
+    if (usedIgnoreRdfTypeVariable) {
+        statements.unshift(`const ${variables.ignoreRdfType} = !!options?.ignoreRdfType;`);
     }
-    parameters.push({
-        name: `{ ${usedIgnoreRdfTypeVariable ? `${variables.ignoreRdfType}, ` : ""}${variables.mutateGraph}, ${variables.resourceSet} }`,
-        type: `{ ${variables.ignoreRdfType}?: boolean; ${variables.mutateGraph}?: rdfjsResource.MutableResource.MutateGraph, ${variables.resourceSet}: rdfjsResource.MutableResourceSet }`,
-    });
     return Maybe.of({
         name: `${syntheticNamePrefix}toRdf`,
         parameters,
@@ -63,7 +70,7 @@ export function toRdfFunctionOrMethodDeclaration() {
 const variables = {
     ignoreRdfType: "ignoreRdfType",
     mutateGraph: "mutateGraph",
-    resource: "_resource",
+    resource: "resource",
     resourceSet: "resourceSet",
 };
 //# sourceMappingURL=toRdfFunctionOrMethodDeclaration.js.map

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -13,7 +13,7 @@ export function rdfjsDatasetObjectSetClassDeclaration({ objectTypes, objectUnion
             name: "ObjectIdentifierT",
         },
     };
-    const fromRdfFunctionType = `(parameters: { objectSet: ${syntheticNamePrefix}ObjectSet, resource: rdfjsResource.Resource }) => purify.Either<Error, ${typeParameters.ObjectT.name}>`;
+    const fromRdfFunctionType = `(resource: rdfjsResource.Resource, options: { objectSet: ${syntheticNamePrefix}ObjectSet }) => purify.Either<Error, ${typeParameters.ObjectT.name}>`;
     const reusableMethodDeclarations = [];
     if (objectTypes.length > 0) {
         const parameters = {
@@ -84,7 +84,7 @@ if (query?.where) {
 
   const objects: ${typeParameters.ObjectT.name}[] = [];
   for (const identifier of identifiers) {
-    const either = objectType.${syntheticNamePrefix}fromRdf({ objectSet: this, resource: this.resourceSet.resource(identifier) });
+    const either = objectType.${syntheticNamePrefix}fromRdf(this.resourceSet.resource(identifier), { objectSet: this });
     if (either.isLeft()) {
       return either;
     }
@@ -104,7 +104,7 @@ resources.sort((left, right) => left.identifier.value.localeCompare(right.identi
 const objects: ${typeParameters.ObjectT.name}[] = [];
 let objectI = 0;
 for (const resource of resources) {
-  const either = objectType.${syntheticNamePrefix}fromRdf({ objectSet: this, resource });
+  const either = objectType.${syntheticNamePrefix}fromRdf(resource, { objectSet: this });
   if (either.isLeft()) {
     return either;
   }
@@ -209,7 +209,7 @@ if (query?.where) {
     const resource = this.resourceSet.resource(identifier);
     const lefts: purify.Either<Error, ${typeParameters.ObjectT.name}>[] = [];
     for (const objectType of objectTypes) {
-      const either = objectType.${syntheticNamePrefix}fromRdf({ objectSet: this, resource });
+      const either = objectType.${syntheticNamePrefix}fromRdf(resource, { objectSet: this });
       if (either.isRight()) {
         objects.push(either.unsafeCoerce());
         break;
@@ -241,7 +241,7 @@ resources.sort((left, right) => left.resource.identifier.value.localeCompare(rig
 let objectI = 0;
 const objects: ${typeParameters.ObjectT.name}[] = [];
 for (const { objectType, resource } of resources) {
-  const either = objectType.${syntheticNamePrefix}fromRdf({ objectSet: this, resource });
+  const either = objectType.${syntheticNamePrefix}fromRdf(resource, { objectSet: this });
   if (either.isLeft()) {
     return either;
   }

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -17,7 +17,7 @@ export function sparqlObjectSetClassDeclaration({ objectTypes, objectUnionTypes,
         constructObjectType: {
             name: "objectType",
             type: `{\
-  ${syntheticNamePrefix}fromRdf: (parameters: { objectSet: ${syntheticNamePrefix}ObjectSet, resource: rdfjsResource.Resource }) => purify.Either<Error, ${typeParameters.ObjectT.name}>;
+  ${syntheticNamePrefix}fromRdf: (resource: rdfjsResource.Resource, options: { objectSet: ${syntheticNamePrefix}ObjectSet }) => 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};
 }`,
@@ -248,13 +248,13 @@ try {
   return purify.Left(e as Error);
 }
 
-const dataset: rdfjs.DatasetCore = new N3.Store(quads.concat());
+const dataset = datasetFactory.dataset(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 })
-  });
+  const objectEither = objectType.${syntheticNamePrefix}fromRdf(
+    new rdfjsResource.Resource<rdfjs.NamedNode>({ dataset, identifier: identifier as rdfjs.NamedNode }),
+    { objectSet: this }
+  );
   if (objectEither.isLeft()) {
     return objectEither;
   }

package/dist/input/PropertyPath.d.ts

@@ -31,11 +31,10 @@ export interface ZeroOrOnePath {
 }
 export type PropertyPath = AlternativePath | InversePath | OneOrMorePath | PredicatePath | SequencePath | ZeroOrMorePath | ZeroOrOnePath;
 export declare namespace PropertyPath {
-    function $fromRdf({ resource, }: {
+    function $fromRdf(resource: Resource, _?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
-        resource: Resource;
     }): Either<Error, PropertyPath>;
     function $toRdf(_propertyPath: PropertyPath, _options?: any): Resource;
 }

package/dist/input/PropertyPath.js

@@ -3,7 +3,7 @@ import { Either, Left } from "purify-ts";
 import { Resource } from "rdfjs-resource";
 export var PropertyPath;
 (function (PropertyPath) {
-    function $fromRdf({ resource, }) {
+    function $fromRdf(resource, _) {
         // Predicate path
         // sh:path ex:parent
         if (resource.identifier.termType === "NamedNode") {
@@ -18,9 +18,7 @@ export var PropertyPath;
                     if (memberResource.isNothing()) {
                         return Left(new Error(`non-identifier in property path list ${Resource.Identifier.toString(listResource.identifier)}`));
                     }
-                    const member = PropertyPath.$fromRdf({
-                        resource: memberResource.unsafeCoerce(),
-                    });
+                    const member = PropertyPath.$fromRdf(memberResource.unsafeCoerce());
                     if (member.isLeft()) {
                         return member;
                     }
@@ -52,14 +50,14 @@ export var PropertyPath;
             // Inverse path
             // sh:path: [ sh:inversePath ex:parent ]
             if (quad.predicate.equals(sh.inversePath)) {
-                return PropertyPath.$fromRdf({ resource: objectResource }).map((path) => ({
+                return PropertyPath.$fromRdf(objectResource).map((path) => ({
                     kind: "InversePath",
                     path,
                 }));
             }
             // One or more path
             if (quad.predicate.equals(sh.oneOrMorePath)) {
-                return PropertyPath.$fromRdf({ resource: objectResource }).map((path) => ({
+                return PropertyPath.$fromRdf(objectResource).map((path) => ({
                     kind: "OneOrMorePath",
                     path,
                 }));
@@ -74,13 +72,13 @@ export var PropertyPath;
             }
             // Zero or more path
             if (quad.predicate.equals(sh.zeroOrMorePath)) {
-                return PropertyPath.$fromRdf({ resource: objectResource }).map((path) => ({
+                return PropertyPath.$fromRdf(objectResource).map((path) => ({
                     kind: "ZeroOrMorePath",
                     path,
                 }));
             }
             if (quad.predicate.equals(sh.zeroOrOnePath)) {
-                return PropertyPath.$fromRdf({ resource: objectResource }).map((path) => ({
+                return PropertyPath.$fromRdf(objectResource).map((path) => ({
                     kind: "ZeroOrOnePath",
                     path,
                 }));

package/dist/input/ShapesGraph.js

@@ -10,9 +10,8 @@ export class ShapesGraph extends RdfjsShapesGraph {
             dataset,
             factory: {
                 nodeShapeFromRdf({ resource, shapesGraph, }) {
-                    return generated.ShaclmateNodeShape.$fromRdf({
+                    return generated.ShaclmateNodeShape.$fromRdf(resource, {
                         ignoreRdfType: true,
-                        resource,
                     }).map((generatedShape) => new NodeShape({
                         ancestorClassIris: ancestorClassIris(resource, Number.MAX_SAFE_INTEGER),
                         childClassIris: descendantClassIris(resource, 1),
@@ -26,21 +25,18 @@ export class ShapesGraph extends RdfjsShapesGraph {
                     }));
                 },
                 ontologyFromRdf({ resource, }) {
-                    return generated.ShaclmateOntology.$fromRdf({
+                    return generated.ShaclmateOntology.$fromRdf(resource, {
                         ignoreRdfType: true,
-                        resource,
                     }).map((generatedOntology) => new Ontology(generatedOntology));
                 },
                 propertyGroupFromRdf({ resource, }) {
-                    return generated.ShaclCorePropertyGroup.$fromRdf({
+                    return generated.ShaclCorePropertyGroup.$fromRdf(resource, {
                         ignoreRdfType: true,
-                        resource,
                     }).map((generatedPropertyGroup) => new PropertyGroup(generatedPropertyGroup));
                 },
                 propertyShapeFromRdf({ resource, shapesGraph, }) {
-                    return generated.ShaclmatePropertyShape.$fromRdf({
+                    return generated.ShaclmatePropertyShape.$fromRdf(resource, {
                         ignoreRdfType: true,
-                        resource,
                     }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));
                 },
             },