@shaclmate/compiler 2.0.23 → 3.0.0

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

@@ -22,8 +22,20 @@ export function graphqlTypeVariableStatement() {
                     description: this.comment.map(JSON.stringify).extract(),
                     fields: `() => (${objectInitializer(this.properties.reduce((fields, property) => {
                         property.graphqlField.ifJust((field) => {
-                            const { name: fieldName, ...fieldProps } = field;
-                            fields[fieldName] = objectInitializer(fieldProps);
+                            fields[field.name] = objectInitializer({
+                                args: field.args
+                                    .map((args) => objectInitializer(Object.entries(args).reduce((argObjects, [argName, arg]) => {
+                                    argObjects[argName] = objectInitializer(arg);
+                                    return argObjects;
+                                }, {})))
+                                    .extract(),
+                                description: field.description
+                                    .map(JSON.stringify)
+                                    .extract(),
+                                name: JSON.stringify(field.name),
+                                resolve: field.resolve,
+                                type: field.type,
+                            });
                         });
                         return fields;
                     }, {}))})`,

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

@@ -100,7 +100,7 @@ function jsonSchemaFunctionDeclaration() {
         kind: StructureKind.Function,
         name: `${syntheticNamePrefix}jsonSchema`,
         statements: [
-            `return zodToJsonSchema(${syntheticNamePrefix}jsonZodSchema());`,
+            `return zod.toJSONSchema(${syntheticNamePrefix}jsonZodSchema());`,
         ],
     };
 }

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

@@ -1,32 +1,102 @@
 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, objectSet, preferredLanguages, ...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, objectSet, preferredLanguages, 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; objectSet?: ${syntheticNamePrefix}ObjectSet; preferredLanguages?: readonly string[]; }`,
+            },
+        ],
+        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, objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages}, 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) => {
+    this.fromRdfType.ifJust((fromRdfType) => {
+        const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();
         const predicate = rdfjsTermExpression(rdf.type);
-        propertiesFromRdfStatements.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})\`)));
+        statements.push(`\
+if (!${variables.ignoreRdfType}) {
+  const ${syntheticNamePrefix}rdfTypeCheck: purify.Either<Error, true> = ${variables.resource}.value(${predicate})
+    .chain(actualRdfType => actualRdfType.toIri())
+    .chain((actualRdfType) => {
+      // Check the expected type and its known subtypes
+      switch (actualRdfType.value) {
+        ${[`case "${fromRdfType.value}":`].concat(this.descendantFromRdfTypes.map((descendantFromRdfType) => `case "${descendantFromRdfType.value}":`)).join("\n")}
+          return purify.Either.of(true);
+      }
+
+      // Check arbitrary rdfs:subClassOf's of the expected type
+      if (${variables.resource}.isInstanceOf(${fromRdfTypeVariable})) {
+        return purify.Either.of(true);
+      }
+
+      return purify.Left(new Error(\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type (actual: \${actualRdfType.value}, expected: ${fromRdfType.value})\`));
+    });
+  if (${syntheticNamePrefix}rdfTypeCheck.isLeft()) {
+    return ${syntheticNamePrefix}rdfTypeCheck;
+  }
 }`);
     });
     const propertyFromRdfVariables = {
         context: variables.context,
-        languageIn: variables.languageIn,
+        preferredLanguages: variables.preferredLanguages,
         objectSet: variables.objectSet,
         resource: variables.resource,
     };
@@ -35,88 +105,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}, objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages}, resource: ${variables.resource},\n// @ts-ignore\n...${variables.context} }`,
+                type: `{ [_index: string]: any; ignoreRdfType: boolean; objectSet: ${syntheticNamePrefix}ObjectSet; preferredLanguages?: readonly string[]; 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 +136,8 @@ export function rdfFunctionDeclarations() {
         return [];
     }
     return [
-        ...fromRdfFunctionDeclarations.bind(this)(),
+        ...fromRdfFunctionDeclaration.bind(this)().toList(),
+        propertiesFromRdfFunctionDeclaration.bind(this)(),
         ...toRdfFunctionDeclaration.bind(this)().toList(),
     ];
 }
@@ -145,8 +156,8 @@ function toRdfFunctionDeclaration() {
 const variables = {
     context: `${syntheticNamePrefix}context`,
     ignoreRdfType: `${syntheticNamePrefix}ignoreRdfType`,
-    languageIn: `${syntheticNamePrefix}languageIn`,
     objectSet: `${syntheticNamePrefix}objectSet`,
+    preferredLanguages: `${syntheticNamePrefix}preferredLanguages`,
     resource: `${syntheticNamePrefix}resource`,
 };
 //# sourceMappingURL=rdfFunctionDeclarations.js.map

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; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly 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, preferredLanguages, 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, preferredLanguages, 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; preferredLanguages?: 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 = {
+        preferredLanguages: "parameters?.preferredLanguages",
+        subject: "subject",
+        variablePrefix: "variablePrefix",
+    };
     const rdfClassVariable = `dataFactory.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
     const rdfTypeVariable = `dataFactory.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     const subjectDefault = camelCase(this.name);
@@ -41,6 +45,9 @@ for (const pattern of ${parentObjectType.staticModuleName}.${syntheticNamePrefix
         nop = false;
     }
     if (this.fromRdfType.isJust()) {
+        const fromRdfTypeVariables = this.fromRdfTypeVariable
+            .toList()
+            .concat(this.descendantFromRdfTypeVariables);
         sparqlConstructTemplateTriplesStatements.push(`\
 if (!parameters?.ignoreRdfType) {
   triples.push(
@@ -48,25 +55,38 @@ if (!parameters?.ignoreRdfType) {
     { subject: ${rdfTypeVariable}, predicate: ${rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }
   );
 }`);
-        sparqlWherePatternsStatements.push(`\
+        sparqlWherePatternsStatements.push(`const rdfTypeVariable = ${rdfTypeVariable};`, `\
 if (!parameters?.ignoreRdfType) {
-  requiredPatterns.push(${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType: ${syntheticNamePrefix}fromRdfType, subject }));
-  requiredPatterns.push({
-    triples: [
-      {
-        subject,
-        predicate: ${rdfjsTermExpression(rdf.type)},
-        object: ${rdfTypeVariable}
-      }
-    ],
-    type: "bgp" as const
-  });
+  requiredPatterns.push(
+    ${fromRdfTypeVariables.length > 1
+            ? `\
+    {
+      type: "values" as const,
+      values: [${fromRdfTypeVariables.join(", ")}].map((identifier) => {
+        const valuePatternRow: sparqljs.ValuePatternRow = {};
+        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as rdfjs.NamedNode;
+        return valuePatternRow;
+      }),
+    },
+    ${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType: dataFactory.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject }),`
+            : `${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType: ${fromRdfTypeVariables[0]}, subject }),`}
+    {
+      triples: [
+        {
+          subject,
+          predicate: ${rdfjsTermExpression(rdf.type)},
+          object: rdfTypeVariable
+        }
+      ],
+      type: "bgp" as const
+    }
+  );
   optionalPatterns.push({
     patterns: [
       {
         triples: [
           {
-            subject: ${rdfTypeVariable},
+            subject: rdfTypeVariable,
             predicate: {
               items: [${rdfjsTermExpression(rdfs.subClassOf)}],
               pathType: "+" as const,
@@ -135,7 +155,7 @@ for (const pattern of propertyPatterns) {
                 {
                     hasQuestionToken: true,
                     name: `${nop ? "_" : ""}parameters`,
-                    type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
+                    type: '{ ignoreRdfType?: boolean; preferredLanguages?: 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/forwardingObjectSetClassDeclaration.d.ts

@@ -0,0 +1,8 @@
+import { type ClassDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+export declare function forwardingObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }: {
+    objectTypes: readonly ObjectType[];
+    objectUnionTypes: readonly ObjectUnionType[];
+}): ClassDeclarationStructure;
+//# sourceMappingURL=forwardingObjectSetClassDeclaration.d.ts.map

package/dist/generators/ts/forwardingObjectSetClassDeclaration.js

@@ -0,0 +1,29 @@
+import { Scope, StructureKind } from "ts-morph";
+import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+export function forwardingObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }) {
+    const delegateName = `${syntheticNamePrefix}delegate`;
+    return {
+        getAccessors: [
+            {
+                isAbstract: true,
+                name: delegateName,
+                scope: Scope.Protected,
+                returnType: `${syntheticNamePrefix}ObjectSet`,
+            },
+        ],
+        implements: [`${syntheticNamePrefix}ObjectSet`],
+        isAbstract: true,
+        isExported: true,
+        kind: StructureKind.Class,
+        name: `${syntheticNamePrefix}ForwardingObjectSet`,
+        methods: [...objectTypes, ...objectUnionTypes].flatMap((objectType) => Object.values(objectSetMethodSignatures({ objectType })).map((methodSignature) => ({
+            ...methodSignature,
+            kind: StructureKind.Method,
+            statements: [
+                `return this.${delegateName}.${methodSignature.name}(${methodSignature.parameters.map((parameter) => parameter.name).join(", ")});`,
+            ],
+        }))),
+    };
+}
+//# sourceMappingURL=forwardingObjectSetClassDeclaration.js.map

package/dist/generators/ts/objectSetDeclarations.js

@@ -1,3 +1,4 @@
+import { forwardingObjectSetClassDeclaration } from "./forwardingObjectSetClassDeclaration.js";
 import { objectSetInterfaceDeclaration } from "./objectSetInterfaceDeclaration.js";
 import { rdfjsDatasetObjectSetClassDeclaration } from "./rdfjsDatasetObjectSetClassDeclaration.js";
 import { sparqlObjectSetClassDeclaration } from "./sparqlObjectSetClassDeclaration.js";
@@ -41,6 +42,7 @@ export function objectSetDeclarations({ objectUnionTypes, ...parameters }) {
             objectTypes,
             objectUnionTypes,
         }),
+        forwardingObjectSetClassDeclaration({ objectTypes, objectUnionTypes }),
     ];
     if (objectTypesWithRdfFeatureCount > 0) {
         statements.push(rdfjsDatasetObjectSetClassDeclaration({

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -13,13 +13,14 @@ 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 objectTypeType = `{ ${syntheticNamePrefix}fromRdf: ${fromRdfFunctionType}; ${syntheticNamePrefix}fromRdfTypes: readonly rdfjs.NamedNode[] }`;
     const reusableMethodDeclarations = [];
     if (objectTypes.length > 0) {
         const parameters = {
             objectType: {
                 name: "objectType",
-                type: `{ ${syntheticNamePrefix}fromRdf: ${fromRdfFunctionType}; ${syntheticNamePrefix}fromRdfType?: rdfjs.NamedNode }`,
+                type: objectTypeType,
             },
             query: {
                 hasQuestionToken: true,
@@ -84,7 +85,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;
     }
@@ -93,18 +94,25 @@ if (query?.where) {
   return purify.Either.of(objects);
 }
 
-if (!objectType.${syntheticNamePrefix}fromRdfType) {
+if (objectType.${syntheticNamePrefix}fromRdfTypes.length === 0) {
   return purify.Either.of([]);
 }
 
-const resources = [...this.resourceSet.instancesOf(objectType.${syntheticNamePrefix}fromRdfType)];
+const resources: rdfjsResource.Resource[] = [];
+for (const fromRdfType of objectType.${syntheticNamePrefix}fromRdfTypes) {
+  for (const resource of this.resourceSet.instancesOf(fromRdfType)) {
+    if (!resources.some(existingResource => existingResource.identifier.equals(resource.identifier))) {
+      resources.push(resource);
+    }
+  }
+}
 // Sort resources by identifier so limit and offset are deterministic
 resources.sort((left, right) => left.identifier.value.localeCompare(right.identifier.value));
 
 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;
   }
@@ -138,7 +146,6 @@ return purify.Either.of(objects);
         });
     }
     if (objectUnionTypes.length > 0) {
-        const objectTypeType = `{ ${syntheticNamePrefix}fromRdf: ${fromRdfFunctionType}; ${syntheticNamePrefix}fromRdfType?: rdfjs.NamedNode }`;
         const parameters = {
             objectTypes: {
                 name: "objectTypes",
@@ -209,7 +216,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;
@@ -226,22 +233,25 @@ if (query?.where) {
 
 const resources: { objectType: ${objectTypeType}, resource: rdfjsResource.Resource }[] = [];
 for (const objectType of objectTypes) {
-  if (!objectType.${syntheticNamePrefix}fromRdfType) {
+  if (objectType.${syntheticNamePrefix}fromRdfTypes.length === 0) {
     continue;
   }
 
-  for (const resource of this.resourceSet.instancesOf(objectType.${syntheticNamePrefix}fromRdfType)) {
-    resources.push({ objectType, resource });
+  for (const fromRdfType of objectType.${syntheticNamePrefix}fromRdfTypes) {
+    for (const resource of this.resourceSet.instancesOf(fromRdfType)) {
+      if (!resources.some(({ resource: existingResource }) => existingResource.identifier.equals(resource.identifier))) {
+        resources.push({ objectType, resource });
+      }
+    }
   }
 }
-
 // Sort resources by identifier so limit and offset are deterministic
 resources.sort((left, right) => left.resource.identifier.value.localeCompare(right.resource.identifier.value));
 
 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;
   }
@@ -300,16 +310,13 @@ return purify.Either.of(objects);
             }
             const methodSignatures = objectSetMethodSignatures({ objectType });
             let runtimeObjectType;
+            const runtimeObjectType_ = (objectType) => `{ ${syntheticNamePrefix}fromRdf: ${objectType.staticModuleName}.${syntheticNamePrefix}fromRdf, ${syntheticNamePrefix}fromRdfTypes: [${objectType.fromRdfTypeVariable.toList().concat(objectType.descendantFromRdfTypeVariables).join(", ")}] }`;
             switch (objectType.kind) {
                 case "ObjectType":
-                    runtimeObjectType = objectType.fromRdfType.isJust()
-                        ? `${objectType.staticModuleName}`
-                        : `{ ...${objectType.staticModuleName}, ${syntheticNamePrefix}fromRdfType: undefined }`;
+                    runtimeObjectType = runtimeObjectType_(objectType);
                     break;
                 case "ObjectUnionType":
-                    runtimeObjectType = `[${objectType.memberTypes.map((memberType) => memberType.fromRdfType.isJust()
-                        ? `${memberType.staticModuleName}`
-                        : `{ ...${memberType.staticModuleName}, ${syntheticNamePrefix}fromRdfType: undefined }`)}]`;
+                    runtimeObjectType = `[${objectType.memberTypes.map((memberType) => runtimeObjectType_(memberType)).join(", ")}]`;
                     break;
             }
             return [

package/dist/generators/ts/rdfjsTermExpression.js

@@ -8,11 +8,11 @@ export function rdfjsTermExpression(rdfjsTerm) {
         case "Literal":
             if (rdfjsTerm.datatype.equals(xsd.string)) {
                 if (rdfjsTerm.language.length === 0) {
-                    return `dataFactory.literal("${rdfjsTerm.value}")`;
+                    return `dataFactory.literal(${JSON.stringify(rdfjsTerm.value)})`;
                 }
-                return `dataFactory.literal("${rdfjsTerm.value}", "${rdfjsTerm.language}")`;
+                return `dataFactory.literal(${JSON.stringify(rdfjsTerm.value)}, "${rdfjsTerm.language}")`;
             }
-            return `dataFactory.literal("${rdfjsTerm.value}", ${rdfjsTermExpression(rdfjsTerm.datatype)})`;
+            return `dataFactory.literal(${JSON.stringify(rdfjsTerm.value)}, ${rdfjsTermExpression(rdfjsTerm.datatype)})`;
         case "NamedNode": {
             if (rdfjsTerm.value.startsWith(rdf[""].value)) {
                 const unqualifiedName = rdfjsTerm.value.substring(rdf[""].value.length);