@shaclmate/compiler 4.0.30 → 4.0.31

package/dist/generators/ts/AbstractTermType.js

@@ -77,9 +77,10 @@ export class AbstractTermType extends AbstractType {
     }
     get discriminantProperty() {
         return Maybe.of({
+            descendantValues: [],
+            jsonName: "termType",
             name: "termType",
             ownValues: [...this.nodeKinds].map(NodeKind.toTermType),
-            descendantValues: [],
             type: "string",
         });
     }

package/dist/generators/ts/AbstractType.d.ts

@@ -260,6 +260,7 @@ export declare namespace AbstractType {
     }
     interface DiscriminantProperty {
         readonly descendantValues: readonly DiscriminantProperty.Value[];
+        readonly jsonName: string;
         readonly name: string;
         readonly ownValues: readonly DiscriminantProperty.Value[];
     }

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -48,11 +48,13 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
 }
 type Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
 type ExtrinsicDiscriminant = {
+    readonly jsonName: string;
     readonly kind: "extrinsic";
     readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
     readonly name: string;
 };
 type HybridDiscriminant = {
+    readonly jsonName: string;
     readonly kind: "hybrid";
     readonly memberValues: readonly {
         readonly kind: "extrinsic" | "intrinsic";
@@ -61,6 +63,7 @@ type HybridDiscriminant = {
     readonly name: string;
 };
 type IntrinsicDiscriminant = {
+    readonly jsonName: string;
     readonly kind: "intrinsic";
     readonly memberValues: readonly {
         readonly descendantValues: readonly AbstractType.DiscriminantProperty.Value[];

package/dist/generators/ts/AbstractUnionType.js

@@ -77,7 +77,10 @@ export class AbstractUnionType extends AbstractType {
                             return code `${member.type.name}.is${member.type.name}(${instance})`;
                     }
                 }
-                return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}.${discriminant.name} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
+                const discriminantName = json
+                    ? discriminant.jsonName
+                    : discriminant.name;
+                return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}["${discriminantName}"] === ${literalOf(discriminantValue)}`), { on: " || " })})`;
             };
             return {
                 discriminantValues,
@@ -156,18 +159,21 @@ export class AbstractUnionType extends AbstractType {
             case "extrinsic":
                 return Maybe.of({
                     descendantValues: [],
+                    jsonName: this.discriminant.jsonName,
                     ownValues: this.discriminant.memberValues,
                     name: this.discriminant.name,
                 });
             case "hybrid":
                 return Maybe.of({
                     descendantValues: [],
+                    jsonName: this.discriminant.jsonName,
                     ownValues: this.discriminant.memberValues.flatMap((_) => _.ownValues),
                     name: "termType",
                 });
             case "intrinsic":
                 return Maybe.of({
                     descendantValues: this.discriminant.memberValues.flatMap((_) => _.descendantValues),
+                    jsonName: this.discriminant.jsonName,
                     name: this.discriminant.name,
                     ownValues: this.discriminant.memberValues.flatMap((_) => _.ownValues),
                 });
@@ -537,6 +543,7 @@ export var Discriminant;
         // extrinsic with user-specified values
         if (members.some((member) => member.discriminantValue.isJust())) {
             return {
+                jsonName: "type",
                 kind: "extrinsic",
                 memberValues: members.map((member, memberI) => member.discriminantValue.orDefault(memberI)),
                 name: "type",
@@ -545,19 +552,20 @@ export var Discriminant;
         const memberTypes = members.map((member) => member.type);
         // intrinsic
         {
-            let inlineDiscriminantPropertyName;
+            let inlineDiscriminantProperty;
             const memberValues = [];
             for (const memberType of memberTypes) {
                 const memberTypeDiscriminantProperty = memberType.discriminantProperty.extract();
                 if (!memberTypeDiscriminantProperty) {
-                    inlineDiscriminantPropertyName = undefined;
+                    inlineDiscriminantProperty = undefined;
                     break;
                 }
-                if (!inlineDiscriminantPropertyName) {
-                    inlineDiscriminantPropertyName = memberTypeDiscriminantProperty.name;
+                if (!inlineDiscriminantProperty) {
+                    inlineDiscriminantProperty = memberTypeDiscriminantProperty;
                 }
-                else if (memberTypeDiscriminantProperty.name !== inlineDiscriminantPropertyName) {
-                    inlineDiscriminantPropertyName = undefined;
+                else if (memberTypeDiscriminantProperty.name !==
+                    inlineDiscriminantProperty.name) {
+                    inlineDiscriminantProperty = undefined;
                     break;
                 }
                 memberValues.push({
@@ -565,11 +573,12 @@ export var Discriminant;
                     ownValues: memberTypeDiscriminantProperty.ownValues,
                 });
             }
-            if (inlineDiscriminantPropertyName) {
+            if (inlineDiscriminantProperty) {
                 return {
+                    jsonName: inlineDiscriminantProperty.jsonName,
                     kind: "intrinsic",
                     memberValues,
-                    name: inlineDiscriminantPropertyName,
+                    name: inlineDiscriminantProperty.name,
                 };
             }
         }
@@ -606,6 +615,7 @@ export var Discriminant;
                 }
             }
             return {
+                jsonName: "termType",
                 kind: "hybrid",
                 memberValues: memberTypes.map((memberType, memberTypeI) => {
                     const memberTermTypes = termTypes(memberType);
@@ -648,6 +658,7 @@ export var Discriminant;
             }
             invariant(memberValues.length === memberTypes.length);
             return {
+                jsonName: "type",
                 kind: "extrinsic",
                 name: "type",
                 memberValues: memberValues,

package/dist/generators/ts/ListType.js

@@ -79,7 +79,7 @@ export class ListType extends AbstractCollectionType {
   },
   {
     currentSubListResource: null,
-    listResource: resourceSet.resource(${mintListIdentifierFunction}()),
+    listResource: ${variables.resourceSet}.resource(${mintListIdentifierFunction}()),
   } as {
     currentSubListResource: ${resourceTypeName} | null;
     listResource: ${resourceTypeName};

package/dist/generators/ts/NamedObjectType.js

@@ -30,8 +30,6 @@ import { NamedObjectType_jsonSchemaFunctionDeclaration } from "./_NamedObjectTyp
 import { NamedObjectType_jsonTypeAliasDeclaration } from "./_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.js";
 import { NamedObjectType_jsonUiSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonUiSchemaFunctionDeclaration.js";
 import { NamedObjectType_objectSetMethodNames } from "./_NamedObjectType/NamedObjectType_objectSetMethodNames.js";
-import { NamedObjectType_propertiesFromJsonFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_propertiesFromJsonFunctionDeclaration.js";
-import { NamedObjectType_propertiesFromRdfResourceFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.js";
 import { NamedObjectType_schemaVariableStatement } from "./_NamedObjectType/NamedObjectType_schemaVariableStatement.js";
 import { NamedObjectType_sparqlConstructQueryFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.js";
 import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
@@ -108,7 +106,7 @@ export class NamedObjectType extends AbstractType {
                 ? [
                     code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`,
                 ]
-                : []), NamedObjectType_filterFunctionDeclaration.call(this), NamedObjectType_filterTypeDeclaration.call(this), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), NamedObjectType_isTypeFunctionDeclaration.call(this), ...NamedObjectType_propertiesFromJsonFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.bind(this)().toList(), NamedObjectType_schemaVariableStatement.call(this), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.bind({
+                : []), NamedObjectType_filterFunctionDeclaration.call(this), NamedObjectType_filterTypeDeclaration.call(this), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), NamedObjectType_isTypeFunctionDeclaration.call(this), NamedObjectType_schemaVariableStatement.call(this), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.bind({
                 features: this.features,
                 filterType: this.filterType,
                 name: this.name,
@@ -139,6 +137,7 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     }
     get discriminantProperty() {
         return Maybe.of({
+            jsonName: this._discriminantProperty.jsonName,
             name: this._discriminantProperty.name,
             ownValues: this._discriminantProperty.type.ownValues,
             descendantValues: this._discriminantProperty.type.descendantValues,

package/dist/generators/ts/NamedObjectUnionType.js

@@ -189,9 +189,9 @@ ${{
             return {};
         }
         return singleEntryRecord(`toRdfResource`, code `\
-export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${this.name}> = (value, options) => {
+export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${this.name}> = (object, options) => {
 ${joinCode(this.members
-            .map((member) => code `if (${member.type.name}.is${member.type.name}(value)) { return ${member.type.name}.toRdfResource(value, options); }`)
+            .map((member) => code `if (${member.type.name}.is${member.type.name}(object)) { return ${member.type.name}.toRdfResource(object, options); }`)
             .concat(code `throw new Error("unrecognized type");`))}
 };`);
     }

package/dist/generators/ts/Snippets.d.ts

@@ -38,7 +38,6 @@ export declare class Snippets {
     get MaybeSchema(): Snippet;
     get NumericFilter(): Snippet;
     get NumericSchema(): Snippet;
-    get PropertiesFromRdfResourceFunction(): Snippet;
     get PropertyPath(): Snippet;
     get RdfVocabularies(): Snippet;
     get ShaclPropertySchema(): Snippet;
@@ -54,6 +53,8 @@ export declare class Snippets {
     get UnwrapR(): Snippet;
     get ValueSparqlConstructTriplesFunction(): Snippet;
     get ValueSparqlWherePatternsFunction(): Snippet;
+    get _FromRdfResourceFunction(): Snippet;
+    get _ToRdfResourceFunction(): Snippet;
     get arrayEquals(): Snippet;
     get arrayIntersection(): Snippet;
     get bigDecimalLiteral(): Snippet;
@@ -117,6 +118,8 @@ export declare class Snippets {
     get termFilterSparqlPatterns(): Snippet;
     get termSchemaSparqlPatterns(): Snippet;
     get termSparqlWherePatterns(): Snippet;
+    get wrap_FromRdfResourceFunction(): Snippet;
+    get wrap_ToRdfResourceFunction(): Snippet;
     protected get snippets(): Snippets;
     private snippet;
 }

package/dist/generators/ts/Snippets.js

@@ -6,6 +6,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
+import { snippets__FromRdfResourceFunction } from "./_snippets/snippets__FromRdfResourceFunction.js";
+import { snippets__ToRdfResourceFunction } from "./_snippets/snippets__ToRdfResourceFunction.js";
 import { snippets_arrayEquals } from "./_snippets/snippets_arrayEquals.js";
 import { snippets_arrayIntersection } from "./_snippets/snippets_arrayIntersection.js";
 import { snippets_BlankNodeFilter } from "./_snippets/snippets_BlankNodeFilter.js";
@@ -80,7 +82,6 @@ import { snippets_NumericFilter } from "./_snippets/snippets_NumericFilter.js";
 import { snippets_NumericSchema } from "./_snippets/snippets_NumericSchema.js";
 import { snippets_normalizeSparqlWherePatterns } from "./_snippets/snippets_normalizeSparqlWherePatterns.js";
 import { snippets_numericSparqlWherePatterns } from "./_snippets/snippets_numericSparqlWherePatterns.js";
-import { snippets_PropertiesFromRdfResourceFunction } from "./_snippets/snippets_PropertiesFromRdfResourceFunction.js";
 import { snippets_PropertyPath } from "./_snippets/snippets_PropertyPath.js";
 import { snippets_parseBlankNode } from "./_snippets/snippets_parseBlankNode.js";
 import { snippets_parseIdentifier } from "./_snippets/snippets_parseIdentifier.js";
@@ -113,6 +114,8 @@ import { snippets_termSparqlWherePatterns } from "./_snippets/snippets_termSparq
 import { snippets_UnwrapR } from "./_snippets/snippets_UnwrapR.js";
 import { snippets_ValueSparqlConstructTriplesFunction } from "./_snippets/snippets_ValueSparqlConstructTriplesFunction.js";
 import { snippets_ValueSparqlWherePatternsFunction } from "./_snippets/snippets_ValueSparqlWherePatternsFunction.js";
+import { snippets_wrap_FromRdfResourceFunction } from "./_snippets/snippets_wrap_FromRdfResourceFunction.js";
+import { snippets_wrap_ToRdfResourceFunction } from "./_snippets/snippets_wrap_ToRdfResourceFunction.js";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
@@ -210,9 +213,6 @@ export class Snippets {
     get NumericSchema() {
         return this.snippet(snippets_NumericSchema);
     }
-    get PropertiesFromRdfResourceFunction() {
-        return this.snippet(snippets_PropertiesFromRdfResourceFunction);
-    }
     get PropertyPath() {
         return this.snippet(snippets_PropertyPath);
     }
@@ -258,6 +258,12 @@ export class Snippets {
     get ValueSparqlWherePatternsFunction() {
         return this.snippet(snippets_ValueSparqlWherePatternsFunction);
     }
+    get _FromRdfResourceFunction() {
+        return this.snippet(snippets__FromRdfResourceFunction);
+    }
+    get _ToRdfResourceFunction() {
+        return this.snippet(snippets__ToRdfResourceFunction);
+    }
     get arrayEquals() {
         return this.snippet(snippets_arrayEquals);
     }
@@ -463,6 +469,12 @@ export class Snippets {
     get termSparqlWherePatterns() {
         return this.snippet(snippets_termSparqlWherePatterns);
     }
+    get wrap_FromRdfResourceFunction() {
+        return this.snippet(snippets_wrap_FromRdfResourceFunction);
+    }
+    get wrap_ToRdfResourceFunction() {
+        return this.snippet(snippets_wrap_ToRdfResourceFunction);
+    }
     get snippets() {
         return this;
     }
@@ -567,9 +579,6 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "NumericSchema", null);
-__decorate([
-    Memoize()
-], Snippets.prototype, "PropertiesFromRdfResourceFunction", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "PropertyPath", null);
@@ -615,6 +624,12 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "ValueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "_FromRdfResourceFunction", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "_ToRdfResourceFunction", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "arrayEquals", null);
@@ -801,4 +816,10 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "termSparqlWherePatterns", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "wrap_FromRdfResourceFunction", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "wrap_ToRdfResourceFunction", null);
 //# sourceMappingURL=Snippets.js.map

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

@@ -101,13 +101,13 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
         };
     }): readonly Code[];
     /**
-     * Statements to deserialize JSON for this property (as described by toJsonObjectMember) to a typed value of the property.
+     * Expression to deserialize JSON for this property (as described by toJsonObjectMember) to a typed value of the property.
      */
-    abstract fromJsonStatements(parameters: {
+    abstract fromJsonExpression(parameters: {
         variables: {
             jsonObject: Code;
         };
-    }): readonly Code[];
+    }): Maybe<Code>;
     /**
      * Expression to deserialize this property on the given rdfjsResource.Resource to a Either<Error, this property type>.
      */

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

@@ -22,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 `${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 `${this.reusables.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() {
@@ -74,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 [];
@@ -86,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

@@ -100,10 +100,10 @@ export class IdentifierProperty extends AbstractProperty {
         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({

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

@@ -1,12 +1,31 @@
 import { Maybe } from "purify-ts";
-import { code } from "../ts-poet-wrapper.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.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 fromJson(json: ${this.jsonType().name}): ${this.name} {
-  return create(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,17 +1,93 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 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 fromRdfResource: ${this.reusables.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}.propertiesFromRdfResource(resource, { context, graph, ignoreRdfType, objectSet, preferredLanguages }).map(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