@shaclmate/compiler 2.0.22 → 2.0.23

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

@@ -0,0 +1,152 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { StructureKind } from "ts-morph";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { toRdfFunctionOrMethodDeclaration } from "./toRdfFunctionOrMethodDeclaration.js";
+function fromRdfFunctionDeclarations() {
+    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 });`);
+    }
+    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()`);
+        initializers.push(`...${syntheticNamePrefix}super${parentObjectTypeI}`);
+        propertiesFromRdfReturnType.push(`${syntheticNamePrefix}UnwrapR<ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf>>`);
+    });
+    this.fromRdfType.ifJust((rdfType) => {
+        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})\`)));
+}`);
+    });
+    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) {
+            propertiesFromRdfStatements.push(...propertyFromRdfStatements);
+            initializers.push(property.name);
+            propertySignatures.push(`${property.name}: ${property.type.name};`);
+        }
+    }
+    propertiesFromRdfStatements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
+    if (propertySignatures.length > 0) {
+        propertiesFromRdfReturnType.splice(0, 0, `{ ${propertySignatures.join(" ")} }`);
+    }
+    const functionDeclarations = [];
+    functionDeclarations.push({
+        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; }`,
+            },
+        ],
+        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;
+}
+export function rdfFunctionDeclarations() {
+    if (!this.features.has("rdf")) {
+        return [];
+    }
+    if (this.extern) {
+        return [];
+    }
+    return [
+        ...fromRdfFunctionDeclarations.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,9 +1,10 @@
 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,
@@ -14,7 +15,7 @@ export function sparqlConstructQueryFunctionDeclaration() {
         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 })) };`,
+            `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 })) };`,
         ],
     };
 }

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,9 +1,10 @@
 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,
@@ -13,7 +14,7 @@ export function sparqlConstructQueryStringFunctionDeclaration() {
         ],
         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() {
@@ -11,67 +13,133 @@ export function sparqlFunctionDeclarations() {
         return [];
     }
     const variables = { subject: "subject", variablePrefix: "variablePrefix" };
-    const rdfTypeVariable = `${this.dataFactoryVariable}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+    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`,
+                    hasQuestionToken: true,
+                    name: `${nop ? "_" : ""}parameters`,
                     type: '{ ignoreRdfType?: boolean; 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,13 +1,9 @@
-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();
@@ -18,10 +14,10 @@ export function toRdfFunctionOrMethodDeclaration() {
         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 +30,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) {
@@ -58,10 +54,16 @@ export function toRdfFunctionOrMethodDeclaration() {
         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

package/dist/generators/ts/graphqlSchemaVariableStatement.js

@@ -0,0 +1,86 @@
+import { Maybe } from "purify-ts";
+import { objectInitializer } from "./objectInitializer.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+function graphqlQueryObjectType({ objectTypes, objectUnionTypes, }) {
+    return `new graphql.GraphQLObjectType<null, { objectSet: ${syntheticNamePrefix}ObjectSet }>({ name: "Query", fields: ${objectInitializer([...objectTypes, ...objectUnionTypes].reduce((fields, objectType) => {
+        fields[objectType.objectSetMethodNames.object] = objectInitializer({
+            args: objectInitializer({
+                identifier: objectInitializer({
+                    type: "new graphql.GraphQLNonNull(graphql.GraphQLID)",
+                }),
+            }),
+            resolve: `\
+async (_source, args: { identifier: string }, { objectSet }): Promise<${objectType.name}> => 
+  (await purify.EitherAsync<Error, ${objectType.name}>(async ({ liftEither }) => 
+    liftEither(await objectSet.${objectType.objectSetMethodNames.object}(await liftEither(${objectType.identifierTypeAlias}.fromString(args.identifier))))
+  )).unsafeCoerce()`,
+            type: objectType.graphqlName.toString(),
+        });
+        fields[objectType.objectSetMethodNames.objectIdentifiers] =
+            objectInitializer({
+                args: objectInitializer({
+                    limit: objectInitializer({
+                        type: "graphql.GraphQLInt",
+                    }),
+                    offset: objectInitializer({
+                        type: "graphql.GraphQLInt",
+                    }),
+                }),
+                resolve: `\
+ async (_source, args: { limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly string[]> =>
+  (await objectSet.${objectType.objectSetMethodNames.objectIdentifiers}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined })).unsafeCoerce().map(${objectType.identifierTypeAlias}.toString)`,
+                type: "new graphql.GraphQLNonNull(new graphql.GraphQLList(graphql.GraphQLString))",
+            });
+        fields[objectType.objectSetMethodNames.objects] = objectInitializer({
+            args: objectInitializer({
+                identifiers: objectInitializer({
+                    type: "new graphql.GraphQLList(new graphql.GraphQLNonNull(graphql.GraphQLID))",
+                }),
+                limit: objectInitializer({
+                    type: "graphql.GraphQLInt",
+                }),
+                offset: objectInitializer({
+                    type: "graphql.GraphQLInt",
+                }),
+            }),
+            resolve: `\
+async (_source, args: { identifiers: readonly string[] | null; limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly ${objectType.name}[]> =>
+(await purify.EitherAsync<Error, readonly ${objectType.name}[]>(async ({ liftEither }) => {
+  let where: $ObjectSet.Where<${objectType.identifierTypeAlias}> | undefined;
+  if (args.identifiers) {
+    const identifiers: ${objectType.identifierTypeAlias}[] = [];
+    for (const identifierArg of args.identifiers) {
+      identifiers.push(await liftEither(${objectType.identifierTypeAlias}.fromString(identifierArg)));
+    }
+    where = { identifiers, type: "identifiers" };
+  }
+  return await liftEither(await objectSet.${objectType.objectSetMethodNames.objects}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined, where }));
+})).unsafeCoerce()`,
+            type: `new graphql.GraphQLNonNull(new graphql.GraphQLList(${objectType.graphqlName}))`,
+        });
+        fields[objectType.objectSetMethodNames.objectsCount] =
+            objectInitializer({
+                resolve: `\
+async (_source, _args, { objectSet }): Promise<number> => (await objectSet.${objectType.objectSetMethodNames.objectsCount}()).unsafeCoerce()`,
+                type: "new graphql.GraphQLNonNull(graphql.GraphQLInt)",
+            });
+        return fields;
+    }, {}))} })`;
+}
+export function graphqlSchemaVariableStatement(parameters) {
+    const objectTypes = parameters.objectTypes.filter((objectType) => objectType.features.has("graphql") && !objectType.synthetic);
+    const objectUnionTypes = parameters.objectUnionTypes.filter((objectUnionType) => objectUnionType.features.has("graphql"));
+    if (objectTypes.length === 0) {
+        return Maybe.empty();
+    }
+    return Maybe.of({
+        isExported: true,
+        declarations: [
+            {
+                name: "graphqlSchema",
+                initializer: `new graphql.GraphQLSchema({ query: ${graphqlQueryObjectType({ objectTypes, objectUnionTypes })} })`,
+            },
+        ],
+    });
+}
+//# sourceMappingURL=graphqlSchemaVariableStatement.js.map

package/dist/generators/ts/objectSetDeclarations.d.ts

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

package/dist/generators/ts/objectSetDeclarations.js

@@ -0,0 +1,59 @@
+import { objectSetInterfaceDeclaration } from "./objectSetInterfaceDeclaration.js";
+import { rdfjsDatasetObjectSetClassDeclaration } from "./rdfjsDatasetObjectSetClassDeclaration.js";
+import { sparqlObjectSetClassDeclaration } from "./sparqlObjectSetClassDeclaration.js";
+export function objectSetDeclarations({ objectUnionTypes, ...parameters }) {
+    const objectTypes = parameters.objectTypes.filter((objectType) => !objectType.abstract && !objectType.extern && !objectType.synthetic);
+    let objectTypesWithRdfFeatureCount = 0;
+    let objectTypesWithSparqlFeatureCount = 0;
+    for (const objectType of objectTypes) {
+        if (!objectType.features.has("rdf") && !objectType.features.has("sparql")) {
+            continue;
+        }
+        if (objectType.features.has("rdf")) {
+            objectTypesWithRdfFeatureCount++;
+        }
+        if (objectType.features.has("sparql")) {
+            objectTypesWithSparqlFeatureCount++;
+        }
+    }
+    let objectUnionTypesWithRdfFeatureCount = 0;
+    let objectUnionTypesWithSparqlFeatureCount = 0;
+    for (const objectUnionType of objectUnionTypes) {
+        if (!objectUnionType.features.has("rdf") &&
+            !objectUnionType.features.has("sparql")) {
+            continue;
+        }
+        if (objectUnionType.features.has("rdf")) {
+            objectUnionTypesWithRdfFeatureCount++;
+        }
+        if (objectUnionType.features.has("sparql")) {
+            objectUnionTypesWithSparqlFeatureCount++;
+        }
+    }
+    if (objectTypesWithRdfFeatureCount === 0 &&
+        objectTypesWithSparqlFeatureCount === 0 &&
+        objectUnionTypesWithRdfFeatureCount === 0 &&
+        objectUnionTypesWithSparqlFeatureCount === 0) {
+        return [];
+    }
+    const statements = [
+        ...objectSetInterfaceDeclaration({
+            objectTypes,
+            objectUnionTypes,
+        }),
+    ];
+    if (objectTypesWithRdfFeatureCount > 0) {
+        statements.push(rdfjsDatasetObjectSetClassDeclaration({
+            objectTypes,
+            objectUnionTypes,
+        }));
+    }
+    if (objectTypesWithSparqlFeatureCount > 0) {
+        statements.push(...sparqlObjectSetClassDeclaration({
+            objectTypes,
+            objectUnionTypes,
+        }));
+    }
+    return statements;
+}
+//# sourceMappingURL=objectSetDeclarations.js.map