@shaclmate/compiler 4.0.40 → 4.0.41

package/dist/generators/ts/UnionType.js

@@ -32,32 +32,11 @@ export class UnionType extends AbstractType {
                     discriminantValues = [this.discriminant.memberValues[memberI]];
                     break;
                 case "Hybrid":
-                    discriminantValues =
-                        this.discriminant.memberValues[memberI].ownValues;
+                    discriminantValues = this.discriminant.memberValues[memberI].values;
                     break;
                 case "Intrinsic": {
-                    // A member type's combined discriminant property values are its "own" values plus any descendant values that are
-                    // not the "own" values of some other member type.
-                    // So if you have type A, type B, and B inherits A, then
-                    // A has
-                    //   own discriminant property values: ["A"]
-                    //   descendant discriminant property values: ["B"]
-                    // and B has
-                    //  own discriminant property values: ["B"]
-                    //  descendant discriminant property values ["B"]
-                    // In this case A shouldn't have "B" as a combined discriminant property value since it's "claimed" by B.
-                    const memberOwnDiscriminantPropertyValues = new Set();
-                    for (const member of members) {
-                        for (const ownDiscriminantPropertyValue of member.type.discriminantProperty.unsafeCoerce()
-                            .ownValues) {
-                            memberOwnDiscriminantPropertyValues.add(ownDiscriminantPropertyValue);
-                        }
-                    }
-                    discriminantValues = member.type.discriminantProperty
-                        .unsafeCoerce()
-                        .ownValues.concat(member.type.discriminantProperty
-                        .unsafeCoerce()
-                        .descendantValues.filter((value) => !memberOwnDiscriminantPropertyValues.has(value)));
+                    discriminantValues =
+                        member.type.discriminantProperty.unsafeCoerce().values;
                     break;
                 }
                 case "Typeof":
@@ -90,7 +69,7 @@ export class UnionType extends AbstractType {
                     includeDiscriminantProperty: this.discriminant.kind === "Intrinsic" ||
                         (this.discriminant.kind === "Hybrid" &&
                             this.discriminant.memberValues[memberI].kind === "Intrinsic"),
-                }).name,
+                }).expression,
                 jsonTypeCheck: typeCheck(true),
                 primaryDiscriminantValue: discriminantValues[0],
                 type: member.type,
@@ -136,14 +115,17 @@ export class UnionType extends AbstractType {
         return Maybe.of({
             code: code `${this.reusables.snippets.identityConversionFunction}`,
             sourceTypes: this.discriminant.kind === "Typeof"
-                ? this.members.map(({ primaryDiscriminantValue, type }) => ({
+                ? this.members.flatMap(({ type }) => type.jsTypes.map((jsType) => ({
                     expression: type.expression,
-                    typeof: primaryDiscriminantValue,
-                }))
+                    jsType,
+                })))
                 : [
                     {
                         expression: this.expression,
-                        typeof: "object",
+                        jsType: {
+                            instanceof: "Object",
+                            typeof: "object",
+                        },
                     },
                 ],
         });
@@ -174,22 +156,20 @@ ${joinCode(staticModuleDeclarations
                 return Maybe.of({
                     descendantValues: [],
                     jsonName: this.discriminant.jsonName,
-                    ownValues: this.discriminant.memberValues,
                     name: this.discriminant.name,
+                    values: this.discriminant.memberValues,
                 });
             case "Hybrid":
                 return Maybe.of({
-                    descendantValues: [],
                     jsonName: this.discriminant.jsonName,
-                    ownValues: this.discriminant.memberValues.flatMap((_) => _.ownValues),
                     name: "termType",
+                    values: this.discriminant.memberValues.flatMap((_) => _.values),
                 });
             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),
+                    values: this.discriminant.memberValues,
                 });
             case "Typeof":
                 return Maybe.empty();
@@ -238,7 +218,7 @@ ${joinCode(staticModuleDeclarations
         return code `export const schema = () => ${this.inlineJsonSchema}.meta(${meta});`;
     }
     get jsonTypeAliasDeclaration() {
-        return code `export type Json = ${this.inlineJsonType.name}`;
+        return code `export type Json = ${this.inlineJsonType.expression}`;
     }
     get members() {
         return this.lazyMembers();
@@ -272,8 +252,16 @@ ${joinCode(staticModuleDeclarations
         }
         return set;
     }
-    get typeofs() {
-        return [...new Set(this.members.flatMap((member) => member.type.typeofs))];
+    get jsTypes() {
+        const jsTypes = [];
+        for (const member of this.members) {
+            for (const memberJsType of member.type.jsTypes) {
+                if (!jsTypes.some((jsType) => AbstractType.JsType.equals(jsType, memberJsType))) {
+                    jsTypes.push(memberJsType);
+                }
+            }
+        }
+        return jsTypes;
     }
     get valueSparqlConstructTriplesFunction() {
         return this.alias
@@ -327,7 +315,7 @@ if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeC
     }
     get inlineFromJsonFunction() {
         return code `\
-((value: ${this.jsonType().name}): ${this.reusables.imports.Either}<Error, ${this.expression}> => {
+((value: ${this.jsonType().expression}): ${this.reusables.imports.Either}<Error, ${this.expression}> => {
 ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${type.fromJsonExpression({
             variables: {
                 value: code `(${unwrap(code `value`)} as ${jsonType})`,
@@ -468,7 +456,7 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
     }
     get inlineToJsonFunction() {
         return code `\
-((value: ${this.expression}): ${this.jsonType().name} => {
+((value: ${this.expression}): ${this.jsonType().expression} => {
 ${joinCode(this.members.map(({ typeCheck, typeToJsonExpression, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(typeToJsonExpression(unwrap(code `value`)))}; }`))}
 
   throw new Error("unable to serialize to JSON");
@@ -621,13 +609,13 @@ export namespace Json {
             .map((alias) => code `${alias}.Json.schema()`)
             .orDefault(this.inlineJsonSchema);
         if (context === "property" && this.recursive) {
-            return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.jsonType().name}> => ${expression})`;
+            return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.jsonType().expression}> => ${expression})`;
         }
         return expression;
     }
     jsonType() {
         return this.alias
-            .map((alias) => new AbstractType.JsonType(`${alias}.Json`))
+            .map((alias) => new AbstractType.JsonType(code `${alias}.Json`))
             .orDefault(this.inlineJsonType);
     }
     jsonUiSchemaElement() {
@@ -683,7 +671,7 @@ __decorate([
 ], UnionType.prototype, "toRdfResourceValueTypes", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "typeofs", null);
+], UnionType.prototype, "jsTypes", null);
 __decorate([
     Memoize()
 ], UnionType.prototype, "valueSparqlConstructTriplesFunction", null);
@@ -743,7 +731,7 @@ export var Discriminant;
         // intrinsic
         {
             let inlineDiscriminantProperty;
-            const memberValues = [];
+            let memberValues = [];
             for (const memberType of memberTypes) {
                 const memberTypeDiscriminantProperty = memberType.discriminantProperty.extract();
                 if (!memberTypeDiscriminantProperty) {
@@ -758,10 +746,7 @@ export var Discriminant;
                     inlineDiscriminantProperty = undefined;
                     break;
                 }
-                memberValues.push({
-                    descendantValues: memberTypeDiscriminantProperty.descendantValues,
-                    ownValues: memberTypeDiscriminantProperty.ownValues,
-                });
+                memberValues = memberValues.concat(memberTypeDiscriminantProperty.values);
             }
             if (inlineDiscriminantProperty) {
                 return {
@@ -774,15 +759,17 @@ export var Discriminant;
         }
         // typeof
         {
+            const memberTypeofs = [];
             const memberTypeofsSet = new Set();
             for (const memberType of memberTypes) {
-                for (const memberTypeof of memberType.typeofs) {
-                    memberTypeofsSet.add(memberTypeof);
+                for (const memberJsType of memberType.jsTypes) {
+                    memberTypeofs.push(memberJsType.typeof);
+                    memberTypeofsSet.add(memberJsType.typeof);
                 }
             }
             if (memberTypeofsSet.size === memberTypes.length) {
                 return {
-                    memberValues: memberTypes.flatMap((memberType) => memberType.typeofs),
+                    memberValues: memberTypeofs,
                     kind: "Typeof",
                 };
             }
@@ -790,7 +777,7 @@ export var Discriminant;
         // hybrid
         // If some member type is an RDF/JS term then reuse "termType" as the discriminant.
         if (memberTypes.some((memberType) => termTypes(memberType).size > 0)) {
-            const extrinsicMemberTypeNamesSet = new Set();
+            const extrinsicMemberTypeAliasesSet = new Set();
             let extrinsicMemberTypeCount = 0;
             for (const memberType of memberTypes) {
                 if (termTypes(memberType).size > 0) {
@@ -798,7 +785,7 @@ export var Discriminant;
                 }
                 extrinsicMemberTypeCount++;
                 if (memberType.alias.isJust()) {
-                    extrinsicMemberTypeNamesSet.add(memberType.alias.extract());
+                    extrinsicMemberTypeAliasesSet.add(memberType.alias.extract());
                 }
                 else {
                     break;
@@ -812,12 +799,12 @@ export var Discriminant;
                     if (memberTermTypes.size > 0) {
                         return {
                             kind: "Intrinsic",
-                            ownValues: [...memberTermTypes],
+                            values: [...memberTermTypes],
                         };
                     }
                     return {
                         kind: "Extrinsic",
-                        ownValues: extrinsicMemberTypeNamesSet.size === extrinsicMemberTypeCount
+                        values: extrinsicMemberTypeAliasesSet.size === extrinsicMemberTypeCount
                             ? [memberType.alias.unsafeCoerce()]
                             : [memberTypeI.toString()],
                     };
@@ -829,7 +816,7 @@ export var Discriminant;
         {
             let memberValues;
             {
-                const memberTypeNames = memberTypes.map((memberType) => memberType.alias.orDefault(memberType.typeofs[0]));
+                const memberTypeNames = memberTypes.map((memberType) => memberType.alias.orDefault(memberType.jsTypes[0].typeof));
                 const memberTypeNamesSet = new Set(memberTypeNames);
                 if (memberTypeNamesSet.size === memberTypeNames.length) {
                     memberValues = memberTypeNames;

package/dist/generators/ts/ZodGenerator.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from "ts-log";
-import * as ast from "../../ast/index.js";
+import type * as ast from "../../ast/index.js";
 import type { Generator } from "../Generator.js";
 export declare class ZodGenerator implements Generator {
     private readonly logger;

package/dist/generators/ts/ZodGenerator.js

@@ -1,4 +1,3 @@
-import * as ast from "../../ast/index.js";
 import { ObjectType_jsonSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonSchemaFunctionDeclaration.js";
 import { ObjectType_jsonTypeAliasDeclaration } from "./_ObjectType/ObjectType_jsonTypeAliasDeclaration.js";
 import { Reusables } from "./Reusables.js";
@@ -19,24 +18,32 @@ export class ZodGenerator {
             reusables,
         });
         const declarations = [];
-        for (const namedObjectType of ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => typeFactory.createObjectType(astObjectType))) {
-            declarations.push(code `\
-export namespace ${namedObjectType.alias.unsafeCoerce()} {
-  ${joinCode(ObjectType_jsonTypeAliasDeclaration.call(namedObjectType).toList())}
+        for (const astNamedType of ast_.namedTypes) {
+            switch (astNamedType.kind) {
+                case "Object": {
+                    const tsNamedObjectType = typeFactory.createObjectType(astNamedType);
+                    declarations.push(code `\
+export namespace ${tsNamedObjectType.alias.unsafeCoerce()} {
+  ${joinCode(ObjectType_jsonTypeAliasDeclaration.call(tsNamedObjectType).toList())}
 
   export namespace Json {
-    ${joinCode(ObjectType_jsonSchemaFunctionDeclaration.call(namedObjectType).toList())}
+    ${joinCode(ObjectType_jsonSchemaFunctionDeclaration.call(tsNamedObjectType).toList())}
   }
 }`);
-        }
-        for (const astNamedUnionType of ast_.namedUnionTypes.map((astNamedUnionType) => typeFactory.createUnionType(astNamedUnionType))) {
-            declarations.push(code `\
-export namespace ${astNamedUnionType.alias.unsafeCoerce()} {
-  ${astNamedUnionType.jsonTypeAliasDeclaration}
+                    break;
+                }
+                case "Union": {
+                    const tsNamedUnionType = typeFactory.createUnionType(astNamedType);
+                    declarations.push(code `\
+export namespace ${tsNamedUnionType.alias.unsafeCoerce()} {
+  ${tsNamedUnionType.jsonTypeAliasDeclaration}
   export namespace Json {
-    ${astNamedUnionType.jsonSchemaFunctionDeclaration}
+    ${tsNamedUnionType.jsonSchemaFunctionDeclaration}
   }
 }`);
+                    break;
+                }
+            }
         }
         declarations.splice(0, 0, joinCode(reusables.snippets.ifUsed, { on: "\n\n" }));
         return joinCode(declarations, { on: "\n\n" }).toString({});

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

@@ -1,6 +1,5 @@
 import { Maybe } from "purify-ts";
 import type { Logger } from "ts-log";
-import type { ObjectType } from "../ObjectType.js";
 import type { Reusables } from "../Reusables.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import type { TsGenerator } from "../TsGenerator.js";
@@ -9,7 +8,9 @@ import { type Code } from "../ts-poet-wrapper.js";
 export declare abstract class AbstractProperty<TypeT extends Pick<Type, "expression" | "filterFunction" | "mutable" | "schema">> {
     protected readonly configuration: TsGenerator.Configuration;
     protected readonly logger: Logger;
-    protected readonly objectType: ObjectType;
+    protected readonly objectType: {
+        readonly alias: Maybe<string>;
+    };
     protected readonly reusables: Reusables;
     /**
      * Optional parameter to include in the parameters object of constructor function.
@@ -73,7 +74,9 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "express
         configuration: TsGenerator.Configuration;
         logger: Logger;
         name: string;
-        objectType: ObjectType;
+        objectType: {
+            readonly alias: Maybe<string>;
+        };
         reusables: Reusables;
         type: TypeT;
     });

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

@@ -8,9 +8,10 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
     readonly kind = "Discriminant";
     readonly mutable = false;
     readonly recursive = false;
-    constructor({ type, ...superParameters }: {
-        type: DiscriminantProperty.Type;
-    } & ConstructorParameters<typeof AbstractProperty>[0]);
+    readonly value: string;
+    constructor({ value, ...superParameters }: {
+        value: string;
+    } & Omit<ConstructorParameters<typeof AbstractProperty>[0], "type">);
     get declaration(): Code;
     get jsonName(): string;
     get jsonSchema(): AbstractProperty<DiscriminantProperty.Type>["jsonSchema"];
@@ -27,21 +28,16 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
     toJsonInitializer({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["toJsonInitializer"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements(): readonly Code[];
     toStringInitializer(): Maybe<Code>;
+    get values(): readonly string[];
 }
 export declare namespace DiscriminantProperty {
     class Type {
+        readonly value: string;
         readonly filterFunction: Code;
-        readonly mutable: boolean;
-        readonly descendantValues: readonly string[];
-        readonly ownValues: readonly string[];
-        constructor({ descendantValues, mutable, ownValues, }: {
-            descendantValues: readonly string[];
-            mutable: boolean;
-            ownValues: readonly string[];
-        });
+        readonly mutable = false;
+        constructor(value: string);
         get expression(): Code;
         get schema(): Code;
-        get values(): string[];
     }
 }
 //# sourceMappingURL=DiscriminantProperty.d.ts.map

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

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
+import { code, literalOf } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export class DiscriminantProperty extends AbstractProperty {
     constructorParameter = Maybe.empty();
@@ -15,8 +15,10 @@ export class DiscriminantProperty extends AbstractProperty {
     kind = "Discriminant";
     mutable = false;
     recursive = false;
-    constructor({ type, ...superParameters }) {
-        super({ ...superParameters, type });
+    value;
+    constructor({ value, ...superParameters }) {
+        super({ ...superParameters, type: new DiscriminantProperty.Type(value) });
+        this.value = value;
     }
     get declaration() {
         return code `readonly ${this.name}: ${this.type.expression};`;
@@ -27,9 +29,7 @@ export class DiscriminantProperty extends AbstractProperty {
     get jsonSchema() {
         return Maybe.of({
             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])})`,
+            schema: code `${this.reusables.imports.z}.literal(${literalOf(this.value)})`,
         });
     }
     get jsonSignature() {
@@ -42,7 +42,7 @@ export class DiscriminantProperty extends AbstractProperty {
     //   return super.schemaInitializers.concat(code`type: ${this.type.schema}`);
     // }
     get constValue() {
-        return code `${literalOf(this.objectType.discriminantValue)} as const`;
+        return code `${literalOf(this.value)} as const`;
     }
     constructorInitializer() {
         return Maybe.empty();
@@ -54,15 +54,9 @@ export class DiscriminantProperty extends AbstractProperty {
         return Maybe.empty();
     }
     hashStatements({ variables, }) {
-        if (this.objectType.parentObjectTypes.length > 0) {
-            return [];
-        }
         return [code `${variables.hasher}.update(${variables.value});`];
     }
     jsonUiSchemaElement({ variables, }) {
-        if (this.objectType.parentObjectTypes.length > 0) {
-            return Maybe.empty();
-        }
         const scope = code `\`\${${variables.scopePrefix}}/properties/${this.jsonName}\``;
         return Maybe.of(code `{ rule: { condition: { schema: { const: ${this.constValue} }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
     }
@@ -81,6 +75,9 @@ export class DiscriminantProperty extends AbstractProperty {
     toStringInitializer() {
         return Maybe.empty();
     }
+    get values() {
+        return [this.value];
+    }
 }
 __decorate([
     Memoize()
@@ -91,33 +88,22 @@ __decorate([
 __decorate([
     Memoize()
 ], DiscriminantProperty.prototype, "jsonSignature", null);
+__decorate([
+    Memoize()
+], DiscriminantProperty.prototype, "values", null);
 (function (DiscriminantProperty) {
     class Type {
+        value;
         filterFunction = code `nonextant`;
-        mutable;
-        descendantValues;
-        ownValues;
-        constructor({ descendantValues, mutable, ownValues, }) {
-            this.descendantValues = descendantValues;
-            this.mutable = mutable;
-            this.ownValues = ownValues;
+        mutable = false;
+        constructor(value) {
+            this.value = value;
         }
         get expression() {
-            return code `${this.values.map((name) => `"${name}"`).join(" | ")}`;
+            return code `${literalOf(this.value)}`;
         }
         get schema() {
             throw new Error("should never be called");
-            // const initializers: Record<string, unknown> = {};
-            // if (this.descendantValues.length > 0) {
-            //   initializers["descendantValues"] = this.descendantValues;
-            // }
-            // if (this.ownValues.length > 0) {
-            //   initializers["ownValues"] = this.ownValues;
-            // }
-            // return code`${initializers}`;
-        }
-        get values() {
-            return this.ownValues.concat(this.descendantValues);
         }
     }
     __decorate([
@@ -126,9 +112,6 @@ __decorate([
     __decorate([
         Memoize()
     ], Type.prototype, "schema", null);
-    __decorate([
-        Memoize()
-    ], Type.prototype, "values", null);
     DiscriminantProperty.Type = Type;
 })(DiscriminantProperty || (DiscriminantProperty = {}));
 //# sourceMappingURL=DiscriminantProperty.js.map

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

@@ -17,17 +17,17 @@ export class IdentifierProperty extends AbstractProperty {
     recursive = false;
     get constructorParameter() {
         let hasQuestionToken = false;
-        const typeNames = [code `(() => ${this.typeExpression})`];
+        const typeExpressions = [code `(() => ${this.typeExpression})`];
         for (const type of this.type.conversionFunction.unsafeCoerce()
             .sourceTypes) {
-            if (type.typeof === "undefined") {
+            if (type.jsType.typeof === "undefined") {
                 hasQuestionToken = true;
             }
             else {
-                typeNames.push(code `${type.expression}`);
+                typeExpressions.push(code `${type.expression}`);
             }
         }
-        return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeNames, { on: "|" })};`);
+        return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeExpressions, { on: "|" })};`);
     }
     get declaration() {
         return code `readonly ${this.name}: () => ${this.typeExpression};`;
@@ -46,7 +46,7 @@ export class IdentifierProperty extends AbstractProperty {
             description: Maybe.empty(),
             name: `_${this.name.substring(syntheticNamePrefix.length)}`,
             resolve: code `(source) => ${this.typeExpression}.stringify(${this.accessExpression({ variables: { object: code `source` } })})`,
-            type: this.type.graphqlType.name,
+            type: this.type.graphqlType.expression,
         });
     }
     get jsonSchema() {

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

@@ -6,40 +6,22 @@ export function ObjectType_createFunctionDeclaration() {
         return Maybe.empty();
     }
     const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParameter.toList());
-    const parametersType = [];
-    if (parametersPropertySignatures.length > 0) {
-        parametersType.push(code `{ ${joinCode(parametersPropertySignatures)} }`);
-    }
-    for (const parentObjectType of this.parentObjectTypes) {
-        parametersType.push(code `Parameters<typeof ${parentObjectType.alias.unsafeCoerce()}.create>[0]`);
-    }
-    if (parametersType.length === 0) {
-        parametersType.push(code `object`);
-    }
-    const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
-        parametersPropertySignatures.every((propertySignature) => propertySignature.toCodeString([]).indexOf("?:") !== -1);
+    const parametersType = parametersPropertySignatures.length > 0
+        ? code `{ ${joinCode(parametersPropertySignatures)} }`
+        : code `object`;
+    const parametersHasQuestionToken = parametersPropertySignatures.every((propertySignature) => propertySignature.toCodeString([]).indexOf("?:") !== -1);
     const parametersVariable = code `parameters${parametersHasQuestionToken ? "?" : ""}`;
-    const parametersSignature = code `parameters${parametersHasQuestionToken ? "?" : ""}: ${joinCode(parametersType, { on: " & " })}`;
-    const chains = [];
-    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        chains.push({
-            expression: code `${parentObjectType.alias.unsafeCoerce()}.create(parameters)`,
-            variable: `super${parentObjectTypeI}`,
-        });
-    });
+    const parametersSignature = code `parameters${parametersHasQuestionToken ? "?" : ""}: ${parametersType}`;
     const propertyInitializers = this.properties.flatMap((property) => property
         .constructorInitializer({
         variables: { parameters: parametersVariable },
     })
         .toList());
     invariant(propertyInitializers.length > 0);
-    chains.push({
-        expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} })`,
-        variable: "properties",
+    let returnExpression = code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} })`;
+    this.discriminantProperty.ifJust((discriminantProperty) => {
+        returnExpression = code `${returnExpression}.map(properties => ({ ...properties, ${discriminantProperty.name}: ${literalOf(discriminantProperty.value)} as const }))`;
     });
-    let returnExpression = code `{ ${chains
-        .map((chain) => `...${chain.variable}`)
-        .join(", ")}, ${this._discriminantProperty.name}: ${literalOf(this.discriminantValue)} as const }`;
     const monkeyPatchMethods = [];
     if (this.configuration.features.has("Object.toJson")) {
         monkeyPatchMethods.push("toJson");
@@ -48,11 +30,8 @@ export function ObjectType_createFunctionDeclaration() {
         monkeyPatchMethods.push(`${this.configuration.syntheticNamePrefix}toString`);
     }
     if (monkeyPatchMethods.length > 0) {
-        returnExpression = code `${this.reusables.snippets.monkeyPatchObject}(${returnExpression}, { ${monkeyPatchMethods.join(", ")} })`;
+        returnExpression = code `${returnExpression}.map(object => ${this.reusables.snippets.monkeyPatchObject}(object, { ${monkeyPatchMethods.join(", ")} }))`;
     }
-    returnExpression = chains
-        .toReversed()
-        .reduce((acc, { expression, variable }, chainI) => code `(${expression}).${chainI === 0 ? "map" : "chain"}(${variable} => ${acc})`, returnExpression);
     return Maybe.of(code `\
 export function create(${parametersSignature}): ${this.reusables.imports.Either}<Error, ${this.expression}> {
   return ${returnExpression};

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

@@ -5,10 +5,6 @@ export function ObjectType_equalsFunctionDeclaration() {
         return Maybe.empty();
     }
     const chain = [];
-    // For every parent, find the nearest equals implementation
-    for (const parentObjectType of this.parentObjectTypes) {
-        chain.push(code `${parentObjectType.equalsFunction}(left, right)`);
-    }
     for (const property of this.properties) {
         if (property.kind === "Discriminant") {
             continue;

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

@@ -5,9 +5,6 @@ export function ObjectType_filterFunctionDeclaration() {
         return Maybe.empty();
     }
     const statements = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(code `if (!${parentObjectType.filterFunction}(filter, value)) { return false; }`);
-    }
     if (this.properties.length > 0) {
         for (const property of this.properties) {
             property.filterProperty.ifJust(({ name }) => {

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

@@ -16,9 +16,6 @@ export function ObjectType_filterTypeDeclaration() {
             members.push(code `{ ${joinCode(Object.entries(filterProperties).map(([name, type]) => code `readonly ${name}?: ${type}`), { on: ";" })} }`);
         }
     }
-    for (const parentObjectType of this.parentObjectTypes) {
-        members.push(code `${parentObjectType.alias.unsafeCoerce()}.Filter`);
-    }
     return Maybe.of(code `\
 export type Filter = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`);
 }

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

@@ -14,10 +14,6 @@ export function ObjectType_focusSparqlConstructTriplesFunctionDeclaration() {
     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.alias.unsafeCoerce()}.focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
-        triplesVariableDeclarationKeyword = "let";
-    }
     if (this.fromRdfType.isJust()) {
         statements.push(code `\
 if (!parameters?.ignoreRdfType) {