@shaclmate/compiler 2.0.22 → 2.0.24

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

@@ -0,0 +1,18 @@
+import { camelCase, trainCase } from "change-case";
+import plur from "plur";
+export function objectSetMethodNames() {
+    const prefixSingular = camelCase(this.name);
+    const thisNameParts = trainCase(this.name).split("-");
+    let prefixPlural = camelCase(`${thisNameParts.slice(0, thisNameParts.length - 1).join("")}${plur(thisNameParts[thisNameParts.length - 1])}`);
+    if (prefixPlural === prefixSingular) {
+        // Happens with singular-s nouns like "series"
+        prefixPlural = `${prefixPlural}s`;
+    }
+    return {
+        object: prefixSingular,
+        objectIdentifiers: `${prefixSingular}Identifiers`,
+        objects: prefixPlural,
+        objectsCount: `${prefixPlural}Count`,
+    };
+}
+//# sourceMappingURL=objectSetMethodNames.js.map

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

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

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

@@ -0,0 +1,37 @@
+import { Maybe } from "purify-ts";
+import { StructureKind, VariableDeclarationKind, } from "ts-morph";
+import { objectInitializer } from "../objectInitializer.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { ShaclProperty } from "./ShaclProperty.js";
+export function propertiesVariableStatement() {
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    const propertiesObject = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        propertiesObject.push(`...${parentObjectType.staticModuleName}.${syntheticNamePrefix}properties`);
+    }
+    for (const property of this.properties) {
+        if (!(property instanceof ShaclProperty)) {
+            continue;
+        }
+        const propertyObject = {};
+        if (this.features.has("rdf")) {
+            propertyObject["identifier"] = rdfjsTermExpression(property.path);
+        }
+        propertiesObject.push(`${property.name}: ${objectInitializer(propertyObject)}`);
+    }
+    return Maybe.of({
+        declarationKind: VariableDeclarationKind.Const,
+        kind: StructureKind.VariableStatement,
+        declarations: [
+            {
+                name: `${syntheticNamePrefix}properties`,
+                initializer: `{${propertiesObject.join(", ")}}`,
+            },
+        ],
+        isExported: true,
+    });
+}
+//# sourceMappingURL=propertiesVariableStatement.js.map

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

@@ -0,0 +1,4 @@
+import { type FunctionDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function rdfFunctionDeclarations(this: ObjectType): readonly FunctionDeclarationStructure[];
+//# sourceMappingURL=rdfFunctionDeclarations.d.ts.map

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

@@ -0,0 +1,144 @@
+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 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 returnType = [];
+    const statements = [];
+    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
+        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}`);
+        returnType.push(`${syntheticNamePrefix}UnwrapR<ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf>>`);
+    });
+    this.fromRdfType.ifJust((rdfType) => {
+        const predicate = rdfjsTermExpression(rdf.type);
+        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})\`)));
+}`);
+    });
+    const propertyFromRdfVariables = {
+        context: variables.context,
+        languageIn: variables.languageIn,
+        objectSet: variables.objectSet,
+        resource: variables.resource,
+    };
+    for (const property of this.properties) {
+        const propertyFromRdfStatements = property.fromRdfStatements({
+            variables: propertyFromRdfVariables,
+        });
+        if (propertyFromRdfStatements.length > 0) {
+            statements.push(...propertyFromRdfStatements);
+            initializers.push(property.name);
+            propertySignatures.push(`${property.name}: ${property.type.name};`);
+        }
+    }
+    statements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
+    if (propertySignatures.length > 0) {
+        returnType.splice(0, 0, `{ ${propertySignatures.join(" ")} }`);
+    }
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: `${syntheticNamePrefix}propertiesFromRdf`,
+        parameters: [
+            {
+                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, ${returnType.join(" & ")}>`,
+        statements: statements,
+    };
+}
+export function rdfFunctionDeclarations() {
+    if (!this.features.has("rdf")) {
+        return [];
+    }
+    if (this.extern) {
+        return [];
+    }
+    return [
+        ...fromRdfFunctionDeclaration.bind(this)().toList(),
+        propertiesFromRdfFunctionDeclaration.bind(this)(),
+        ...toRdfFunctionDeclaration.bind(this)().toList(),
+    ];
+}
+function toRdfFunctionDeclaration() {
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
+    }
+    return toRdfFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((toRdfFunctionOrMethodDeclaration) => ({
+        ...toRdfFunctionOrMethodDeclaration,
+        isExported: true,
+        kind: StructureKind.Function,
+    }));
+}
+const variables = {
+    context: `${syntheticNamePrefix}context`,
+    ignoreRdfType: `${syntheticNamePrefix}ignoreRdfType`,
+    languageIn: `${syntheticNamePrefix}languageIn`,
+    objectSet: `${syntheticNamePrefix}objectSet`,
+    resource: `${syntheticNamePrefix}resource`,
+};
+//# sourceMappingURL=rdfFunctionDeclarations.js.map

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

@@ -1,5 +1,5 @@
 import { type FunctionDeclarationStructure } from "ts-morph";
 export declare function sparqlConstructQueryFunctionDeclaration(this: {
-    readonly name: string;
+    readonly staticModuleName: string;
 }): FunctionDeclarationStructure;
 //# sourceMappingURL=sparqlConstructQueryFunctionDeclaration.d.ts.map

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

@@ -1,20 +1,21 @@
 import { StructureKind } from "ts-morph";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 export function sparqlConstructQueryFunctionDeclaration() {
     return {
-        isExported: true,
         kind: StructureKind.Function,
-        name: "sparqlConstructQuery",
+        isExported: true,
+        name: `${syntheticNamePrefix}sparqlConstructQuery`,
         parameters: [
             {
                 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.name}.sparqlConstructTemplateTriples({ ignoreRdfType, subject })), type: "query", where: (queryParameters.where ?? []).concat(${this.name}.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.d.ts

@@ -1,5 +1,5 @@
 import { type FunctionDeclarationStructure } from "ts-morph";
 export declare function sparqlConstructQueryStringFunctionDeclaration(this: {
-    readonly name: string;
+    readonly staticModuleName: string;
 }): FunctionDeclarationStructure;
 //# sourceMappingURL=sparqlConstructQueryStringFunctionDeclaration.d.ts.map

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

@@ -1,19 +1,20 @@
 import { StructureKind } from "ts-morph";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 export function sparqlConstructQueryStringFunctionDeclaration() {
     return {
         isExported: true,
         kind: StructureKind.Function,
-        name: "sparqlConstructQueryString",
+        name: `${syntheticNamePrefix}sparqlConstructQueryString`,
         parameters: [
             {
                 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",
         statements: [
-            `return new sparqljs.Generator(parameters).stringify(${this.name}.sparqlConstructQuery(parameters));`,
+            `return new sparqljs.Generator(parameters).stringify(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructQuery(parameters));`,
         ],
     };
 }

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

@@ -1,6 +1,8 @@
-import { rdf } from "@tpluscode/rdf-ns-builders";
 import { camelCase } from "change-case";
 import { StructureKind } from "ts-morph";
+import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { sparqlConstructQueryFunctionDeclaration } from "./sparqlConstructQueryFunctionDeclaration.js";
 import { sparqlConstructQueryStringFunctionDeclaration } from "./sparqlConstructQueryStringFunctionDeclaration.js";
 export function sparqlFunctionDeclarations() {
@@ -10,68 +12,138 @@ export function sparqlFunctionDeclarations() {
     if (this.extern) {
         return [];
     }
-    const variables = { subject: "subject", variablePrefix: "variablePrefix" };
-    const rdfTypeVariable = `${this.dataFactoryVariable}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+    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);
-    const preambleStatements = [
-        `const subject = parameters?.subject ?? ${this.dataFactoryVariable}.variable!("${subjectDefault}");`,
+    const sparqlConstructTemplateTriplesStatements = [
+        `const subject = parameters?.subject ?? dataFactory.variable!("${subjectDefault}");`,
+        "const triples: sparqljs.Triple[] = []",
         `const variablePrefix = parameters?.variablePrefix ?? (subject.termType === "Variable" ? subject.value : "${subjectDefault}");`,
     ];
-    const sparqlConstructTemplateTriples = [
-        ...this.parentObjectTypes.map((parentObjectType) => `...${parentObjectType.name}.sparqlConstructTemplateTriples({ ignoreRdfType: true, subject, variablePrefix })`),
-        ...(this.fromRdfType.isJust()
-            ? [
-                `...(parameters?.ignoreRdfType ? [] : [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} }])`,
-            ]
-            : []),
-        ...this.ownProperties.flatMap((property) => property.sparqlConstructTemplateTriples({ variables })),
-    ];
-    const sparqlWherePatterns = [
-        ...this.parentObjectTypes.map((parentObjectType) => `...${parentObjectType.name}.sparqlWherePatterns({ ignoreRdfType: true, subject, variablePrefix })`),
-        ...(this.fromRdfType.isJust()
-            ? [
-                `...(parameters?.ignoreRdfType ? [] : [{ triples: [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${this.rdfjsTermExpression(this.fromRdfType.unsafeCoerce())} }], type: "bgp" as const }, { triples: [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} }], type: "bgp" as const }])`,
-            ]
-            : []),
-        ...this.ownProperties.flatMap((property) => property.sparqlWherePatterns({ variables })),
+    let nop = true;
+    const sparqlWherePatternsStatements = [
+        "const optionalPatterns: sparqljs.OptionalPattern[] = [];",
+        "const requiredPatterns: sparqljs.Pattern[] = [];",
+        `const subject = parameters?.subject ?? dataFactory.variable!("${subjectDefault}");`,
+        `const variablePrefix = parameters?.variablePrefix ?? (subject.termType === "Variable" ? subject.value : "${subjectDefault}");`,
     ];
+    for (const parentObjectType of this.parentObjectTypes) {
+        sparqlConstructTemplateTriplesStatements.push(`triples.push(...${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTemplateTriples({ ignoreRdfType: true, subject, variablePrefix }));`);
+        sparqlWherePatternsStatements.push(`\
+for (const pattern of ${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ ignoreRdfType: true, subject, variablePrefix })) {
+  if (pattern.type === "optional") {
+    optionalPatterns.push(pattern);
+  } else {
+    requiredPatterns.push(pattern);
+  }
+}`);
+        nop = false;
+    }
+    if (this.fromRdfType.isJust()) {
+        sparqlConstructTemplateTriplesStatements.push(`\
+if (!parameters?.ignoreRdfType) {
+  triples.push(
+    { subject, predicate: ${rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} },
+    { subject: ${rdfTypeVariable}, predicate: ${rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }
+  );
+}`);
+        sparqlWherePatternsStatements.push(`\
+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
+  });
+  optionalPatterns.push({
+    patterns: [
+      {
+        triples: [
+          {
+            subject: ${rdfTypeVariable},
+            predicate: {
+              items: [${rdfjsTermExpression(rdfs.subClassOf)}],
+              pathType: "+" as const,
+              type: "path" as const
+            },
+            object: ${rdfClassVariable}
+          }
+        ],
+        type: "bgp" as const
+      }
+    ],
+    type: "optional" as const
+  });
+}`);
+        nop = false;
+    }
+    const propertySparqlWherePatterns = [];
+    for (const property of this.ownProperties) {
+        if (property.recursive) {
+            continue;
+        }
+        for (const triple of property.sparqlConstructTemplateTriples({
+            variables,
+        })) {
+            sparqlConstructTemplateTriplesStatements.push(`triples.push(${triple});`);
+            nop = false;
+        }
+        propertySparqlWherePatterns.push(...property.sparqlWherePatterns({ variables }));
+    }
+    if (propertySparqlWherePatterns.length > 0) {
+        sparqlWherePatternsStatements.push(`\
+const propertyPatterns: readonly sparqljs.Pattern[] = [${propertySparqlWherePatterns.join(", ")}];
+for (const pattern of propertyPatterns) {
+  if (pattern.type === "optional") {
+    optionalPatterns.push(pattern);
+  } else {
+    requiredPatterns.push(pattern);
+  }  
+}`);
+        nop = false;
+    }
+    sparqlConstructTemplateTriplesStatements.push("return triples;");
+    sparqlWherePatternsStatements.push("return requiredPatterns.concat(optionalPatterns);");
     return [
         sparqlConstructQueryFunctionDeclaration.bind(this)(),
         sparqlConstructQueryStringFunctionDeclaration.bind(this)(),
         {
             isExported: true,
             kind: StructureKind.Function,
-            name: "sparqlConstructTemplateTriples",
+            name: `${syntheticNamePrefix}sparqlConstructTemplateTriples`,
             parameters: [
                 {
                     hasQuestionToken: true,
-                    name: `${sparqlConstructTemplateTriples.length === 0 ? "_" : ""}parameters`,
+                    name: `${nop ? "_" : ""}parameters`,
                     type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                 },
             ],
             returnType: "readonly sparqljs.Triple[]",
-            statements: [
-                ...(sparqlConstructTemplateTriples.length > 0
-                    ? preambleStatements
-                    : []),
-                `return [${sparqlConstructTemplateTriples.join(", ")}];`,
-            ],
+            statements: nop ? "return [];" : sparqlConstructTemplateTriplesStatements,
         },
         {
             isExported: true,
             kind: StructureKind.Function,
-            name: "sparqlWherePatterns",
+            name: `${syntheticNamePrefix}sparqlWherePatterns`,
             parameters: [
                 {
-                    name: `${sparqlWherePatterns.length === 0 ? "_" : ""}parameters`,
-                    type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
+                    hasQuestionToken: true,
+                    name: `${nop ? "_" : ""}parameters`,
+                    type: '{ ignoreRdfType?: boolean; languageIn?: readonly string[]; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                 },
             ],
             returnType: "readonly sparqljs.Pattern[]",
-            statements: [
-                ...(sparqlWherePatterns.length > 0 ? preambleStatements : []),
-                `return [${sparqlWherePatterns.join(", ")}];`,
-            ],
+            statements: nop ? "return [];" : sparqlWherePatternsStatements,
         },
     ];
 }

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
-import { toJsonReturnType } from "./toJsonReturnType.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 export function toJsonFunctionOrMethodDeclaration() {
-    if (!this.features.has("toJson")) {
+    if (!this.features.has("json")) {
         return Maybe.empty();
     }
     if (this.declarationType === "class" &&
@@ -14,12 +14,12 @@ export function toJsonFunctionOrMethodDeclaration() {
     switch (this.declarationType) {
         case "class":
             if (this.parentObjectTypes.length > 0) {
-                jsonObjectMembers.push("...super.toJson()");
+                jsonObjectMembers.push(`...super.${syntheticNamePrefix}toJson()`);
             }
             break;
         case "interface":
             for (const parentObjectType of this.parentObjectTypes) {
-                jsonObjectMembers.push(`...${parentObjectType.name}.toJson(${this.thisVariable})`);
+                jsonObjectMembers.push(`...${parentObjectType.staticModuleName}.${syntheticNamePrefix}toJson(${this.thisVariable})`);
             }
             parameters.push({
                 name: this.thisVariable,
@@ -48,9 +48,9 @@ export function toJsonFunctionOrMethodDeclaration() {
     //     break;
     // }
     return Maybe.of({
-        name: "toJson",
+        name: `${syntheticNamePrefix}toJson`,
         parameters,
-        returnType: toJsonReturnType.bind(this)(),
+        returnType: this.jsonName.toString(),
         statements: [
             `return JSON.parse(JSON.stringify({ ${jsonObjectMembers.join(",")} } satisfies ${this.jsonName}));`,
         ],

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

@@ -1,27 +1,38 @@
-import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
-const variables = {
-    ignoreRdfType: "ignoreRdfType",
-    mutateGraph: "mutateGraph",
-    resource: "_resource",
-    resourceSet: "resourceSet",
-};
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 export function toRdfFunctionOrMethodDeclaration() {
-    if (!this.features.has("toRdf")) {
+    if (!this.features.has("rdf")) {
         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;
         switch (this.declarationType) {
             case "class":
-                superToRdfCall = `super.toRdf(${superToRdfOptions})`;
+                superToRdfCall = `super.${syntheticNamePrefix}toRdf(${superToRdfOptions})`;
                 break;
             case "interface":
-                superToRdfCall = `${this.parentObjectTypes[0].name}.toRdf(${this.thisVariable}, ${superToRdfOptions})`;
+                superToRdfCall = `${this.parentObjectTypes[0].staticModuleName}.${syntheticNamePrefix}toRdf(${this.thisVariable}, ${superToRdfOptions})`;
                 break;
         }
         statements.push(`const ${variables.resource} = ${superToRdfCall};`);
@@ -34,7 +45,7 @@ export function toRdfFunctionOrMethodDeclaration() {
         statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableResource(${this.thisVariable}.${this.identifierProperty.name}, { ${variables.mutateGraph} });`);
     }
     if (this.toRdfTypes.length > 0) {
-        statements.push(`if (!${variables.ignoreRdfType}) { ${this.toRdfTypes.map((toRdfType) => `${variables.resource}.add(${variables.resource}.dataFactory.namedNode("${rdf.type.value}"), ${variables.resource}.dataFactory.namedNode("${toRdfType.value}"));`).join(" ")} }`);
+        statements.push(`if (!${variables.ignoreRdfType}) { ${this.toRdfTypes.map((toRdfType) => `${variables.resource}.add(${rdfjsTermExpression(rdf.type)}, ${variables.resource}.dataFactory.namedNode("${toRdfType.value}"));`).join(" ")} }`);
         usedIgnoreRdfTypeVariable = true;
     }
     for (const property of this.properties) {
@@ -46,22 +57,20 @@ 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: "toRdf",
+        name: `${syntheticNamePrefix}toRdf`,
         parameters,
-        returnType: this.rdfjsResourceType({ mutable: true }).name,
+        returnType: this.toRdfjsResourceType,
         statements,
     });
 }
+const variables = {
+    ignoreRdfType: "ignoreRdfType",
+    mutateGraph: "mutateGraph",
+    resource: "resource",
+    resourceSet: "resourceSet",
+};
 //# sourceMappingURL=toRdfFunctionOrMethodDeclaration.js.map

package/dist/generators/ts/graphqlSchemaVariableStatement.d.ts

@@ -0,0 +1,9 @@
+import { Maybe } from "purify-ts";
+import type { OptionalKind, VariableStatementStructure } from "ts-morph";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+export declare function graphqlSchemaVariableStatement(parameters: {
+    objectTypes: readonly ObjectType[];
+    objectUnionTypes: ObjectUnionType[];
+}): Maybe<OptionalKind<VariableStatementStructure>>;
+//# sourceMappingURL=graphqlSchemaVariableStatement.d.ts.map