@shaclmate/compiler 4.0.29 → 4.0.31

package/dist/generators/ts/_NamedObjectType/AbstractProperty.js

@@ -6,11 +6,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { removeUndefined } from "../removeUndefined.js";
 import { code, literalOf } from "../ts-poet-wrapper.js";
 export class AbstractProperty {
     logger;
     namedObjectType;
+    reusables;
+    rdfjsTermExpression;
     /**
      * TypeScript identifier-safe name of the property.
      */
@@ -19,11 +22,17 @@ export class AbstractProperty {
      * Property type
   .   */
     type;
-    constructor({ logger, name, namedObjectType, type, }) {
+    constructor({ logger, name, namedObjectType, reusables, type, }) {
         this.logger = logger;
         this.name = name;
         this.namedObjectType = namedObjectType;
+        this.reusables = reusables;
         this.type = type;
+        this.rdfjsTermExpression = rdfjsTermExpression.bind({
+            imports: this.reusables.imports,
+            logger: this.logger,
+            snippets: this.reusables.snippets,
+        });
     }
     /**
      * TypeScript object describing this type, for runtime use.

package/dist/generators/ts/_NamedObjectType/DiscriminantProperty.d.ts

@@ -12,12 +12,12 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
         type: DiscriminantProperty.Type;
     } & ConstructorParameters<typeof AbstractProperty>[0]);
     get declaration(): Code;
+    get jsonName(): string;
     get jsonSchema(): AbstractProperty<DiscriminantProperty.Type>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
     private get initializer();
-    private get override();
     constructorStatements(): readonly Code[];
-    fromJsonStatements(): readonly Code[];
+    fromJsonExpression(): Maybe<Code>;
     fromRdfResourceValuesExpression(): Maybe<Code>;
     hashStatements({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<Code>;

package/dist/generators/ts/_NamedObjectType/DiscriminantProperty.js

@@ -6,7 +6,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-import { imports } from "../imports.js";
 import { removeUndefined } from "../removeUndefined.js";
 import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
@@ -23,49 +22,43 @@ export class DiscriminantProperty extends AbstractProperty {
     get declaration() {
         return code `readonly ${this.name}: ${this.type.name};`;
     }
+    get jsonName() {
+        return "@type";
+    }
     get jsonSchema() {
-        if (this.override) {
-            return Maybe.empty();
-        }
         return Maybe.of({
-            key: this.name,
+            key: this.jsonName,
             schema: this.type.values.length > 1
-                ? code `${imports.z}.enum(${arrayOf(...this.type.values)})`
-                : code `${imports.z}.literal(${literalOf(this.type.values[0])})`,
+                ? code `${this.reusables.imports.z}.enum(${arrayOf(...this.type.values)})`
+                : code `${this.reusables.imports.z}.literal(${literalOf(this.type.values[0])})`,
         });
     }
     get jsonSignature() {
-        if (this.override) {
-            return Maybe.empty();
-        }
-        return Maybe.of(code `readonly ${this.name}: ${this.type.name}`);
+        return Maybe.of(code `readonly "${this.jsonName}": ${this.type.name}`);
     }
     get initializer() {
         return code `${literalOf(this.namedObjectType.discriminantValue)} as const`;
     }
-    get override() {
-        return this.namedObjectType.parentObjectTypes.length > 0;
-    }
     constructorStatements() {
         return [code `const ${this.name} = ${this.initializer};`];
     }
-    fromJsonStatements() {
-        return [code `const ${this.name} = ${this.initializer};`];
+    fromJsonExpression() {
+        return Maybe.empty();
     }
     fromRdfResourceValuesExpression() {
-        return Maybe.of(code `${imports.Right}<${literalOf(this.namedObjectType.discriminantValue)}>(${this.initializer})`);
+        return Maybe.empty();
     }
     hashStatements({ variables, }) {
-        if (this.override) {
+        if (this.namedObjectType.parentObjectTypes.length > 0) {
             return [];
         }
         return [code `${variables.hasher}.update(${variables.value});`];
     }
     jsonUiSchemaElement({ variables, }) {
-        if (this.override) {
+        if (this.namedObjectType.parentObjectTypes.length > 0) {
             return Maybe.empty();
         }
-        const scope = code `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
+        const scope = code `\`\${${variables.scopePrefix}}/properties/${this.jsonName}\``;
         return Maybe.of(code `{ rule: { condition: { schema: { const: ${this.initializer} }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
     }
     sparqlConstructTriplesExpression() {
@@ -75,10 +68,7 @@ export class DiscriminantProperty extends AbstractProperty {
         return Maybe.empty();
     }
     toJsonObjectMemberExpression({ variables, }) {
-        if (this.override) {
-            return Maybe.empty();
-        }
-        return Maybe.of(code `${this.name}: ${variables.value}`);
+        return Maybe.of(code `"${this.jsonName}": ${variables.value}`);
     }
     toRdfRdfResourceValuesStatements() {
         return [];
@@ -87,6 +77,9 @@ export class DiscriminantProperty extends AbstractProperty {
         return Maybe.empty();
     }
 }
+__decorate([
+    Memoize()
+], DiscriminantProperty.prototype, "jsonName", null);
 __decorate([
     Memoize()
 ], DiscriminantProperty.prototype, "jsonSchema", null);

package/dist/generators/ts/_NamedObjectType/IdentifierProperty.d.ts

@@ -24,7 +24,7 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
     get jsonSignature(): Maybe<Code>;
     accessExpression({ variables, }: Parameters<AbstractProperty<BlankNodeType | IdentifierType | IriType>["accessExpression"]>[0]): Code;
     constructorStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorStatements"]>[0]): readonly Code[];
-    fromJsonStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonStatements"]>[0]): readonly Code[];
+    fromJsonExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonExpression"]>[0]): Maybe<Code>;
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromRdfResourceValuesExpression"]>[0]): Maybe<Code>;
     hashStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<Code>;

package/dist/generators/ts/_NamedObjectType/IdentifierProperty.js

@@ -10,8 +10,6 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { codeEquals } from "../codeEquals.js";
-import { imports } from "../imports.js";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
@@ -59,10 +57,10 @@ export class IdentifierProperty extends AbstractProperty {
         if (this.type.in_.length > 0 && this.type.kind === "IriType") {
             // Treat sh:in as a union of the IRIs
             // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            schema = code `${imports.z}.enum(${arrayOf(...this.type.in_.map((iri) => iri.value))})`;
+            schema = code `${this.reusables.imports.z}.enum(${arrayOf(...this.type.in_.map((iri) => iri.value))})`;
         }
         else {
-            schema = code `${imports.z}.string().min(1)`;
+            schema = code `${this.reusables.imports.z}.string().min(1)`;
         }
         return Maybe.of({
             key: "@id",
@@ -95,26 +93,24 @@ export class IdentifierProperty extends AbstractProperty {
             conversionBranches.push(code `if (${conversion.sourceTypeCheckExpression(parameterVariable)}) { ${this.name} = () => ${conversion.conversionExpression(parameterVariable)}; }`);
         }
         if (this.type.nodeKinds.has("BlankNode")) {
-            conversionBranches.push(code `if (${parameterVariable} === undefined) { const ${syntheticNamePrefix}eagerIdentifier = ${imports.dataFactory}.blankNode(); ${this.name} = () => ${syntheticNamePrefix}eagerIdentifier; }`);
+            conversionBranches.push(code `if (${parameterVariable} === undefined) { const ${syntheticNamePrefix}eagerIdentifier = ${this.reusables.imports.dataFactory}.blankNode(); ${this.name} = () => ${syntheticNamePrefix}eagerIdentifier; }`);
         }
         // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
         conversionBranches.push(code `{ ${this.name} = (${parameterVariable}) satisfies never;\n }`);
         statements.push(joinCode(conversionBranches, { on: " else " }));
         return statements;
     }
-    fromJsonStatements({ variables, }) {
-        return [
-            code `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: variables.jsonObject } })};`,
-        ];
+    fromJsonExpression({ variables, }) {
+        return Maybe.of(this.type.fromJsonExpression({
+            variables: { value: variables.jsonObject },
+        }));
     }
     fromRdfResourceValuesExpression({ variables, }) {
         return Maybe.of(code `${this.type.fromRdfResourceValuesExpression({
             variables: {
                 ...variables,
-                propertyPath: rdfjsTermExpression(rdf.subject, {
-                    logger: this.logger,
-                }),
-                resourceValues: code `${imports.Right}(new ${imports.Resource}.Value(${{ dataFactory: imports.dataFactory, focusResource: variables.resource, propertyPath: rdfjsTermExpression(rdf.subject, { logger: this.logger }), term: code `${variables.resource}.identifier` }}).toValues())`,
+                propertyPath: this.rdfjsTermExpression(rdf.subject),
+                resourceValues: code `${this.reusables.imports.Right}(new ${this.reusables.imports.Resource}.Value(${{ dataFactory: this.reusables.imports.dataFactory, focusResource: variables.resource, propertyPath: this.rdfjsTermExpression(rdf.subject), term: code `${variables.resource}.identifier` }}).toValues())`,
             },
         })}.chain(values => values.head())`);
     }
@@ -135,7 +131,7 @@ export class IdentifierProperty extends AbstractProperty {
                 ignoreRdfType: true, // Unused
                 preferredLanguages: variables.preferredLanguages,
                 propertyPatterns: code `[]`,
-                schema: code `${this.namedObjectType.name}.${syntheticNamePrefix}schema.properties.${this.name}.type()`,
+                schema: code `${this.namedObjectType.name}.schema.properties.${this.name}.type()`,
                 valueVariable: variables.focusIdentifier,
                 variablePrefix: variables.variablePrefix, // Unused
             }})`,

package/dist/generators/ts/_NamedObjectType/NamedObjectType_createFunctionDeclaration.js

@@ -1,6 +1,5 @@
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_createFunctionDeclaration() {
     if (!this.features.has("create")) {
@@ -12,7 +11,7 @@ export function NamedObjectType_createFunctionDeclaration() {
         parametersType.push(code `{ ${joinCode(parametersPropertySignatures)} }`);
     }
     for (const parentObjectType of this.parentObjectTypes) {
-        parametersType.push(code `Parameters<typeof ${parentObjectType.name}.${syntheticNamePrefix}create>[0]`);
+        parametersType.push(code `Parameters<typeof ${parentObjectType.name}.create>[0]`);
     }
     if (parametersType.length === 0) {
         parametersType.push(code `object`);
@@ -21,7 +20,7 @@ export function NamedObjectType_createFunctionDeclaration() {
     const omitPropertyNames = [];
     const propertyStatements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        propertyInitializers.push(`...${parentObjectType.name}.${syntheticNamePrefix}create(parameters)`);
+        propertyInitializers.push(`...${parentObjectType.name}.create(parameters)`);
     }
     const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
         parametersPropertySignatures.every((propertySignature) => propertySignature.toCodeString([]).indexOf("?:") !== -1);
@@ -44,7 +43,7 @@ export function NamedObjectType_createFunctionDeclaration() {
     invariant(propertyInitializers.length > 0);
     invariant(propertyStatements.length > 0);
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}create(parameters${parametersHasQuestionToken ? "?" : ""}: ${joinCode(parametersType, { on: " & " })}): ${omitPropertyNames.length === 0 ? this.name : `Omit<${this.name}, ${omitPropertyNames.map((omitPropertyName) => `"${omitPropertyName}"`).join(" | ")}>`} {
+export function create(parameters${parametersHasQuestionToken ? "?" : ""}: ${joinCode(parametersType, { on: " & " })}): ${omitPropertyNames.length === 0 ? this.name : `Omit<${this.name}, ${omitPropertyNames.map((omitPropertyName) => `"${omitPropertyName}"`).join(" | ")}>`} {
   ${joinCode(propertyStatements)}
   return { ${propertyInitializers.join(", ")} };
 }`);

package/dist/generators/ts/_NamedObjectType/NamedObjectType_equalsFunctionDeclaration.js

@@ -1,6 +1,4 @@
 import { Maybe } from "purify-ts";
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_equalsFunctionDeclaration() {
     if (!this.features.has("equals")) {
@@ -9,7 +7,7 @@ export function NamedObjectType_equalsFunctionDeclaration() {
     const chain = [];
     // For every parent, find the nearest equals implementation
     for (const parentObjectType of this.parentObjectTypes) {
-        chain.push(code `${parentObjectType.name}.${syntheticNamePrefix}equals(left, right)`);
+        chain.push(code `${parentObjectType.name}.equals(left, right)`);
     }
     for (const property of this.properties) {
         if (property.kind === "DiscriminantProperty") {
@@ -18,7 +16,7 @@ export function NamedObjectType_equalsFunctionDeclaration() {
         chain.push(code `(${property.type.equalsFunction})(${property.accessExpression({ variables: { object: code `left` } })}, ${property.accessExpression({ variables: { object: code `right` } })}).mapLeft(propertyValuesUnequal => ({ left, right, propertyName: "${property.name}", propertyValuesUnequal, type: "property" as const }))`);
     }
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}equals(left: ${this.name}, right: ${this.name}): ${snippets.EqualsResult} {
+export function equals(left: ${this.name}, right: ${this.name}): ${this.reusables.snippets.EqualsResult} {
   return ${joinCode(chain.map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : code `chain(() => ${chainPart})`), { on: "." })}
 }`);
 }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_filterFunctionDeclaration.js

@@ -1,4 +1,3 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_filterFunctionDeclaration() {
     const statements = [];
@@ -14,7 +13,7 @@ export function NamedObjectType_filterFunctionDeclaration() {
     }
     statements.push(code `return true;`);
     return code `\
-export function ${syntheticNamePrefix}filter(filter: ${this.filterType}, value: ${this.name}): boolean {
+export function filter(filter: ${this.filterType}, value: ${this.name}): boolean {
   ${joinCode(statements)}
 }`;
 }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_filterTypeDeclaration.js

@@ -1,4 +1,3 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_filterTypeDeclaration() {
     const members = [];
@@ -14,9 +13,9 @@ export function NamedObjectType_filterTypeDeclaration() {
         }
     }
     for (const parentObjectType of this.parentObjectTypes) {
-        members.push(code `${parentObjectType.name}.${syntheticNamePrefix}Filter`);
+        members.push(code `${parentObjectType.name}.Filter`);
     }
     return code `\
-export type ${syntheticNamePrefix}Filter = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`;
+export type Filter = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`;
 }
 //# sourceMappingURL=NamedObjectType_filterTypeDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.js

@@ -1,9 +1,5 @@
 import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
-import { imports } from "../imports.js";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 const variables = {
     filter: code `parameters.filter`,
@@ -14,20 +10,20 @@ export function NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration()
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
-    const rdfClassVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
-    const rdfTypeVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+    const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
+    const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     let triplesVariableDeclarationKeyword = "const";
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(code `triples = triples.concat(${parentObjectType.name}.${syntheticNamePrefix}focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
+        statements.push(code `triples = triples.concat(${parentObjectType.name}.focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
         triplesVariableDeclarationKeyword = "let";
     }
     if (this.fromRdfType.isJust()) {
         statements.push(code `\
 if (!parameters?.ignoreRdfType) {
   triples.push(
-    { subject: ${variables.focusIdentifier}, predicate: ${rdfjsTermExpression(rdf.type, { logger: this.logger })}, object: ${rdfTypeVariable} },
-    { subject: ${rdfTypeVariable}, predicate: ${rdfjsTermExpression(rdfs.subClassOf, { logger: this.logger })}, object: ${rdfClassVariable} }
+    { subject: ${variables.focusIdentifier}, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} },
+    { subject: ${rdfTypeVariable}, predicate: ${this.rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }
   );
 }`);
     }
@@ -45,10 +41,10 @@ if (!parameters?.ignoreRdfType) {
         });
     }
     return Maybe.of(code `\
-export const ${syntheticNamePrefix}focusSparqlConstructTriples: ${snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
+export const focusSparqlConstructTriples: ${this.reusables.snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
 ${statements.length > 0
         ? joinCode([
-            code `${triplesVariableDeclarationKeyword} triples: ${imports.sparqljs}.Triple[] = [];`,
+            code `${triplesVariableDeclarationKeyword} triples: ${this.reusables.imports.sparqljs}.Triple[] = [];`,
             ...statements,
             code `return triples;`,
         ])

package/dist/generators/ts/_NamedObjectType/NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.js

@@ -1,9 +1,5 @@
 import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
-import { imports } from "../imports.js";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 const variables = {
     filter: code `parameters.filter`,
@@ -15,13 +11,13 @@ export function NamedObjectType_focusSparqlWherePatternsFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
-    const rdfClassVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
-    const rdfTypeVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+    const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
+    const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     let patternsVariableDeclarationKeyword = "const";
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
         statements.push(code `\
-patterns = patterns.concat(${parentObjectType.name}.${syntheticNamePrefix}focusSparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
+patterns = patterns.concat(${parentObjectType.name}.focusSparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
         patternsVariableDeclarationKeyword = "let";
     }
     if (this.fromRdfType.isJust()) {
@@ -36,18 +32,18 @@ if (!parameters?.ignoreRdfType) {
     {
       type: "values" as const,
       values: [${joinCode(fromRdfTypeVariables, { on: "," })}].map((identifier) => {
-        const valuePatternRow: ${imports.sparqljs}.ValuePatternRow = {};
-        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as ${imports.NamedNode};
+        const valuePatternRow: ${this.reusables.imports.sparqljs}.ValuePatternRow = {};
+        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as ${this.reusables.imports.NamedNode};
         return valuePatternRow;
       }),
     },
-    ${snippets.sparqlInstancesOfPattern}({ rdfType: ${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject: ${variables.focusIdentifier} }),`
-            : code `${snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: ${variables.focusIdentifier} }),`}
+    ${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject: ${variables.focusIdentifier} }),`
+            : code `${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: ${variables.focusIdentifier} }),`}
     {
       triples: [
         {
           subject: ${variables.focusIdentifier},
-          predicate: ${rdfjsTermExpression(rdf.type, { logger: this.logger })},
+          predicate: ${this.rdfjsTermExpression(rdf.type)},
           object: rdfTypeVariable
         }
       ],
@@ -60,7 +56,7 @@ if (!parameters?.ignoreRdfType) {
             {
               subject: rdfTypeVariable,
               predicate: {
-                items: [${rdfjsTermExpression(rdfs.subClassOf, { logger: this.logger })}],
+                items: [${this.rdfjsTermExpression(rdfs.subClassOf)}],
                 pathType: "+" as const,
                 type: "path" as const
               },
@@ -93,10 +89,10 @@ if (!parameters?.ignoreRdfType) {
         });
     }
     return Maybe.of(code `\
-export const ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
+export const focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
 ${statements.length > 0
         ? joinCode([
-            code `${patternsVariableDeclarationKeyword} patterns: ${snippets.SparqlPattern}[] = [];`,
+            code `${patternsVariableDeclarationKeyword} patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
             ...statements,
             code `return patterns;`,
         ])

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromJsonFunctionDeclaration.js

@@ -1,13 +1,31 @@
 import { Maybe } from "purify-ts";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code } from "../ts-poet-wrapper.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+const variables = {
+    jsonObject: code `${syntheticNamePrefix}json`,
+};
 export function NamedObjectType_fromJsonFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
+    const initializers = [];
+    const statements = [];
+    this.parentObjectTypes.forEach((parentObjectType) => {
+        initializers.push(code `...${parentObjectType.name}.fromJson(${variables.jsonObject})`);
+    });
+    for (const property of this.properties) {
+        property
+            .fromJsonExpression({
+            variables,
+        })
+            .ifJust((propertyFromJsonExpression) => {
+            initializers.push(code `${property.name}: ${propertyFromJsonExpression}`);
+        });
+    }
+    statements.push(code `return create({ ${joinCode(initializers, { on: ", " })} });`);
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}fromJson(json: ${this.jsonType().name}): ${this.name} {
-  return ${syntheticNamePrefix}create(${syntheticNamePrefix}propertiesFromJson(json));
+export function fromJson(${variables.jsonObject}: ${this.jsonType().name}): ${this.name} {
+${joinCode(statements, { on: "\n" })}
 }`);
 }
 //# sourceMappingURL=NamedObjectType_fromJsonFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromRdfResourceFunctionDeclaration.js

@@ -1,18 +1,93 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
-import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
+const optionsVariable = `_${syntheticNamePrefix}options`;
+const variables = {
+    context: code `${optionsVariable}.context`,
+    graph: code `${optionsVariable}.graph`,
+    ignoreRdfType: code `${optionsVariable}.ignoreRdfType`,
+    objectSet: code `${optionsVariable}.objectSet`,
+    preferredLanguages: code `${optionsVariable}.preferredLanguages`,
+    resource: code `${syntheticNamePrefix}resource`,
+};
+const propertyFromRdfResourceValuesExpressionVariable = {
+    context: variables.context,
+    graph: variables.graph,
+    preferredLanguages: variables.preferredLanguages,
+    objectSet: variables.objectSet,
+    resource: variables.resource,
+};
 export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
+    const chains = [];
+    const initializers = [];
+    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
+        chains.push({
+            expression: code `${parentObjectType.name}._fromRdfResource(${variables.resource}, { ...${optionsVariable}, ignoreRdfType: true })`,
+            variable: `${syntheticNamePrefix}super${parentObjectTypeI}`,
+        });
+        initializers.push(code `...${syntheticNamePrefix}super${parentObjectTypeI}`);
+    });
+    this.fromRdfType.ifJust((fromRdfType) => {
+        const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();
+        const predicate = this.rdfjsTermExpression(rdf.type);
+        // Check the expected type and its known subtypes
+        const cases = new Set();
+        cases.add(fromRdfType.value);
+        for (const descendantFromRdfType of this.descendantFromRdfTypes) {
+            cases.add(descendantFromRdfType.value);
+        }
+        chains.push({
+            expression: code `!${variables.ignoreRdfType} ? ${variables.resource}.value(${predicate}, ${{ graph: variables.graph }})
+    .chain(actualRdfType => actualRdfType.toIri())
+    .chain((actualRdfType) => {
+      // Check the expected type and its known subtypes
+      switch (actualRdfType.value) {
+        ${[...cases].map((fromRdfType) => `case "${fromRdfType}":`).join("\n")}
+          return ${this.reusables.imports.Right}(true as const);
+      }
+
+      // Check arbitrary rdfs:subClassOf's of the expected type
+      if (${variables.resource}.isInstanceOf(${fromRdfTypeVariable}, ${{ graph: variables.graph }})) {
+        return ${this.reusables.imports.Right}(true as const);
+      }
+
+      return ${this.reusables.imports.Left}(new Error(\`\${${variables.resource}.identifier} has unexpected RDF type (actual: \${actualRdfType.value}, expected: ${fromRdfType.value})\`));
+    }) : ${this.reusables.imports.Right}(true as const)`,
+            variable: "_rdfTypeCheck",
+        });
+    });
+    for (const property of this.properties) {
+        property
+            .fromRdfResourceValuesExpression({
+            variables: propertyFromRdfResourceValuesExpressionVariable,
+        })
+            .ifJust((propertyFromRdfExpression) => {
+            chains.push({
+                expression: propertyFromRdfExpression,
+                variable: property.name,
+            });
+            initializers.push(code `${property.name}`);
+        });
+    }
+    const statements = [];
+    const resultExpression = code `${this.name}.create({ ${joinCode(initializers, { on: "," })} })`;
+    if (chains.length === 0) {
+        statements.push(code `return ${this.reusables.imports.Right}(${resultExpression});`);
+    }
+    else {
+        statements.push(code `return ${chains
+            .reverse()
+            .reduce((acc, { expression, variable }, chainI) => code `(${expression}).${chainI === 0 ? "map" : "chain"}(${variable} => ${acc})`, code `(${resultExpression})`)}`);
+    }
     return Maybe.of(code `\
-export const ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => {
-${joinCode([
-        code `let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});`,
-        code `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset); }`,
-        code `return ${code `${this.name}.${syntheticNamePrefix}propertiesFromRdfResource(resource, { context, graph, ignoreRdfType, objectSet, preferredLanguages }).map(${syntheticNamePrefix}create)`};`,
-    ])}
-};`);
+export const _fromRdfResource: ${this.reusables.snippets._FromRdfResourceFunction}<${this.name}> = (${variables.resource}, ${optionsVariable}) => {
+${joinCode(statements)}
+}
+
+export const fromRdfResource = ${this.reusables.snippets.wrap_FromRdfResourceFunction}(_fromRdfResource);`);
 }
 //# sourceMappingURL=NamedObjectType_fromRdfResourceFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromRdfResourceValuesFunctionDeclaration.js

@@ -1,16 +1,14 @@
 import { Maybe } from "purify-ts";
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_fromRdfResourceValuesFunctionDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export const ${syntheticNamePrefix}fromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${this.name}> = (values, options) => 
+export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}> = (values, options) => 
   values.chain(
     values => values.chainMap(
-      value => value.toResource().chain(resource => ${this.name}.${syntheticNamePrefix}fromRdfResource(resource, options))
+      value => value.toResource().chain(resource => ${this.name}.fromRdfResource(resource, options))
     )
   );`);
 }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromRdfTypeVariableStatement.js

@@ -1,13 +1,10 @@
 import { Maybe } from "purify-ts";
-import { imports } from "../imports.js";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_fromRdfTypeVariableStatement() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
     return this.fromRdfType.map((fromRdfType) => code `\
-export const ${syntheticNamePrefix}fromRdfType: ${imports.NamedNode}<string> = ${rdfjsTermExpression(fromRdfType, { logger: this.logger })};`);
+export const fromRdfType: ${this.reusables.imports.NamedNode}<string> = ${this.rdfjsTermExpression(fromRdfType)};`);
 }
 //# sourceMappingURL=NamedObjectType_fromRdfTypeVariableStatement.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_graphqlTypeVariableStatement.js

@@ -1,5 +1,4 @@
 import { Maybe } from "purify-ts";
-import { imports } from "../imports.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_graphqlTypeVariableStatement() {
@@ -10,7 +9,7 @@ export function NamedObjectType_graphqlTypeVariableStatement() {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export const ${syntheticNamePrefix}GraphQL = new ${imports.GraphQLObjectType}<${this.name}, { objectSet: ${syntheticNamePrefix}ObjectSet }>(${{
+export const GraphQL = new ${this.reusables.imports.GraphQLObjectType}<${this.name}, { objectSet: ${syntheticNamePrefix}ObjectSet }>(${{
         description: this.comment.extract(),
         fields: code `() => (${this.properties.reduce((fields, property) => {
             property.graphqlField.ifJust((field) => {