@shaclmate/compiler 4.0.41 → 4.0.42

package/dist/generators/ts/TermType.js

@@ -10,17 +10,15 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractTermType } from "./AbstractTermType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
 export class TermType extends AbstractTermType {
     conversionFunction = Maybe.empty();
     filterFunction = code `${this.reusables.snippets.filterTerm}`;
-    filterType = code `${this.reusables.snippets.TermFilter}`;
-    kind = "Term";
-    nodeKinds;
-    schemaType = code `${this.reusables.snippets.TermSchema}`;
     jsTypes = [
         { instanceof: "Object", typeof: "object" },
     ];
+    kind = "Term";
+    nodeKinds;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.termSparqlWherePatterns}`;
     constructor({ nodeKinds, ...superParameters }) {
         super(superParameters);
@@ -28,7 +26,19 @@ export class TermType extends AbstractTermType {
         invariant(this.nodeKinds.has("Literal") &&
             (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("IRI")), "should be IdentifierType or LiteralType");
     }
-    get expression() {
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.termFromRdfResourceValues}<${this.expression}>`;
+    }
+    get filterType() {
+        return code `${this.reusables.snippets.TermFilter}<${this.expression}>`;
+    }
+    get graphqlType() {
+        throw new Error("not implemented");
+    }
+    get schemaType() {
+        return code `${this.reusables.snippets.TermSchema}<${this.expression}>`;
+    }
+    get inlineExpression() {
         return code `(${joinCode([...this.nodeKinds]
             .map((nodeKind) => {
             switch (nodeKind) {
@@ -45,8 +55,8 @@ export class TermType extends AbstractTermType {
         })
             .map((import_) => code `${import_}`), { on: " | " })})`;
     }
-    get graphqlType() {
-        throw new Error("not implemented");
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `types: ${arrayOf(...[...this.nodeKinds].map(NodeKind.toTermType))}`);
     }
     fromJsonExpression({ variables, }) {
         return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${[
@@ -117,7 +127,16 @@ export class TermType extends AbstractTermType {
 }
 __decorate([
     Memoize()
-], TermType.prototype, "expression", null);
+], TermType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], TermType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], TermType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], TermType.prototype, "inlineExpression", null);
 __decorate([
     Memoize()
 ], TermType.prototype, "jsonType", null);

package/dist/generators/ts/TsGenerator.js

@@ -1,3 +1,4 @@
+import dataFactory from "@rdfx/data-factory";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { BlankNodeType } from "./BlankNodeType.js";
@@ -12,7 +13,7 @@ import { SparqlObjectSetType } from "./SparqlObjectSetType.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 function compareTsNamedType(left, right) {
-    return left.alias.unsafeCoerce().localeCompare(right.alias.unsafeCoerce());
+    return left.name.unsafeCoerce().localeCompare(right.name.unsafeCoerce());
 }
 export class TsGenerator {
     configuration;
@@ -39,7 +40,7 @@ export class TsGenerator {
         for (const astNamedType of ast_.namedTypes) {
             const tsNamedType = typeFactory.createType(astNamedType);
             tsNamedTypes.push(tsNamedType);
-            if (astNamedType.kind === "Object") {
+            if (astNamedType.kind === "Struct") {
                 for (const tsImport of astNamedType.tsImports) {
                     declarations.push(code `${tsImport}`);
                 }
@@ -152,29 +153,31 @@ export class TsGenerator {
         let identifierType;
         if (nodeKinds.size === 2) {
             identifierType = new IdentifierType({
-                alias: Maybe.empty(),
+                name: Maybe.empty(),
                 comment: Maybe.empty(),
                 configuration,
                 label: Maybe.empty(),
                 logger: this.logger,
                 reusables,
+                shapeIdentifier: dataFactory.blankNode(),
             });
         }
         else {
             switch ([...nodeKinds][0]) {
                 case "BlankNode":
                     identifierType = new BlankNodeType({
-                        alias: Maybe.empty(),
+                        name: Maybe.empty(),
                         comment: Maybe.empty(),
                         configuration,
                         label: Maybe.empty(),
                         logger: this.logger,
                         reusables,
+                        shapeIdentifier: dataFactory.blankNode(),
                     });
                     break;
                 case "IRI":
                     identifierType = new IriType({
-                        alias: Maybe.empty(),
+                        name: Maybe.empty(),
                         comment: Maybe.empty(),
                         configuration,
                         hasValues: [],
@@ -182,12 +185,13 @@ export class TsGenerator {
                         label: Maybe.empty(),
                         logger: this.logger,
                         reusables,
+                        shapeIdentifier: dataFactory.blankNode(),
                     });
                     break;
             }
         }
         return new ObjectUnionType({
-            alias: Maybe.of(`${configuration.syntheticNamePrefix}Object`),
+            name: Maybe.of(`${configuration.syntheticNamePrefix}Object`),
             comment: Maybe.empty(),
             configuration,
             identifierType: Maybe.of(identifierType),
@@ -199,6 +203,7 @@ export class TsGenerator {
             })),
             recursive: false,
             reusables,
+            shapeIdentifier: dataFactory.blankNode(),
             synthetic: true,
         });
     }

package/dist/generators/ts/Type.d.ts

@@ -9,9 +9,9 @@ import type { FloatType } from "./FloatType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IntType } from "./IntType.js";
 import type { IriType } from "./IriType.js";
-import type { LazyObjectOptionType } from "./LazyObjectOptionType.js";
-import type { LazyObjectSetType } from "./LazyObjectSetType.js";
-import type { LazyObjectType } from "./LazyObjectType.js";
+import type { LazyOptionType } from "./LazyOptionType.js";
+import type { LazySetType } from "./LazySetType.js";
+import type { LazyType } from "./LazyType.js";
 import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
 import type { ObjectType } from "./ObjectType.js";
@@ -21,5 +21,5 @@ import type { SetType } from "./SetType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
 import type { UnionType } from "./UnionType.js";
-export type Type = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType<ListType.ItemType> | LiteralType | ObjectUnionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType | UnionType<Type>;
+export type Type = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LazyOptionType | LazySetType | LazyType | ListType<ListType.ItemType> | LiteralType | ObjectUnionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType | UnionType<Type>;
 //# sourceMappingURL=Type.d.ts.map

package/dist/generators/ts/TypeFactory.d.ts

@@ -19,8 +19,8 @@ export declare class TypeFactory {
         logger: Logger;
         reusables: Reusables;
     });
-    createObjectType(astType: ast.ObjectType): ObjectType;
-    createObjectUnionType(astType: ast.ObjectUnionType): ObjectUnionType;
+    createObjectType(astType: ast.StructType): ObjectType;
+    createObjectUnionType(astType: ast.StructUnionType): ObjectUnionType;
     createType(astType: ast.Type, parameters?: {
         defaultValue?: Literal | NamedNode;
     }): Type;
@@ -29,9 +29,9 @@ export declare class TypeFactory {
     private createDefaultValueType;
     private createIdentifierType;
     private createIriType;
-    private createLazyObjectOptionType;
-    private createLazyObjectSetType;
-    private createLazyObjectType;
+    private createLazyOptionType;
+    private createLazySetType;
+    private createLazyType;
     private createListType;
     private createLiteralType;
     private createObjectTypeProperty;

package/dist/generators/ts/TypeFactory.js

@@ -18,9 +18,9 @@ import { FloatType } from "./FloatType.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { IntType } from "./IntType.js";
 import { IriType } from "./IriType.js";
-import { LazyObjectOptionType } from "./LazyObjectOptionType.js";
-import { LazyObjectSetType } from "./LazyObjectSetType.js";
-import { LazyObjectType } from "./LazyObjectType.js";
+import { LazyOptionType } from "./LazyOptionType.js";
+import { LazySetType } from "./LazySetType.js";
+import { LazyType } from "./LazyType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
 import { ObjectType } from "./ObjectType.js";
@@ -53,13 +53,12 @@ export class TypeFactory {
             configuration: this.configuration,
             logger: this.logger,
             name: `${this.configuration.syntheticNamePrefix}type`,
-            objectType: { alias: astType.name },
+            objectType: { name: astType.name },
             reusables: this.reusables,
             value: name,
         }));
         const identifierType = this.createIdentifierType(astType.identifierType);
         const objectType = new ObjectType({
-            alias: astType.name.map((name) => this.tsName(name, { synthetic: astType.synthetic })),
             discriminantProperty,
             comment: astType.comment,
             configuration: this.configuration,
@@ -68,7 +67,7 @@ export class TypeFactory {
             identifierType,
             label: astType.label,
             lazyProperties: (objectType) => {
-                const properties = astType.properties
+                const properties = astType.fields
                     .toSorted((left, right) => {
                     if (left.order < right.order) {
                         return -1;
@@ -78,8 +77,8 @@ export class TypeFactory {
                     }
                     return this.tsName(left.name).localeCompare(this.tsName(right.name));
                 })
-                    .map((astProperty) => this.createObjectTypeProperty({
-                    astObjectTypeProperty: astProperty,
+                    .map((astField) => this.createObjectTypeProperty({
+                    astStructField: astField,
                     objectType,
                 }));
                 discriminantProperty.ifJust((discriminantProperty) => {
@@ -96,8 +95,10 @@ export class TypeFactory {
                 return properties;
             },
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name, { synthetic: astType.synthetic })),
             recursive: astType.recursive,
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
             synthetic: astType.synthetic,
             toRdfTypes: astType.toRdfTypes,
         });
@@ -112,18 +113,19 @@ export class TypeFactory {
             }
         }
         const objectUnionType = new ObjectUnionType({
-            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
-            identifierType: Maybe.of(this.createIdentifierType(ast.ObjectCompoundType.identifierType(astType))),
+            identifierType: Maybe.of(this.createIdentifierType(ast.StructCompoundType.identifierType(astType))),
             label: astType.label,
             logger: this.logger,
-            members: ast.ObjectCompoundType.memberObjectTypes(astType).map((namedObjectType) => ({
+            members: ast.StructCompoundType.memberStructTypes(astType).map((astStructType) => ({
                 discriminantValue: Maybe.empty(),
-                type: this.createObjectType(namedObjectType),
+                type: this.createObjectType(astStructType),
             })),
+            name: astType.name.map((name) => this.tsName(name)),
             recursive: astType.recursive,
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
             synthetic: astType.synthetic,
         });
         this.cachedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, objectUnionType);
@@ -141,22 +143,22 @@ export class TypeFactory {
                 throw new Error("not implemented");
             case "Iri":
                 return this.createIriType(astType);
-            case "LazyObjectOption":
-                return this.createLazyObjectOptionType(astType);
-            case "LazyObjectSet":
-                return this.createLazyObjectSetType(astType);
-            case "LazyObject":
-                return this.createLazyObjectType(astType);
+            case "Lazy":
+                return this.createLazyType(astType);
+            case "LazyOption":
+                return this.createLazyOptionType(astType);
+            case "LazySet":
+                return this.createLazySetType(astType);
             case "List":
                 return this.createListType(astType);
             case "Literal":
                 return this.createLiteralType(astType, parameters);
-            case "Object":
-                return this.createObjectType(astType);
             case "Option":
                 return this.createOptionType(astType);
             case "Set":
                 return this.createSetType(astType);
+            case "Struct":
+                return this.createObjectType(astType);
             case "Term":
                 return this.createTermType(astType);
             case "Union":
@@ -164,11 +166,10 @@ export class TypeFactory {
         }
     }
     createUnionType(astType) {
-        if (astType.isObjectUnionType()) {
+        if (astType.isStructUnionType()) {
             return this.createObjectUnionType(astType);
         }
         return new UnionType({
-            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             identifierType: Maybe.empty(),
@@ -178,19 +179,22 @@ export class TypeFactory {
                 discriminantValue: member.discriminantValue,
                 type: this.createType(member.type),
             })),
+            name: astType.name.map((name) => this.tsName(name)),
             recursive: astType.recursive,
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
             synthetic: astType.synthetic,
         });
     }
     createBlankNodeType(astType) {
         return new BlankNodeType({
-            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
     createDefaultValueType(astType) {
@@ -199,14 +203,15 @@ export class TypeFactory {
         });
         invariant(DefaultValueType.isItemType(itemType));
         return new DefaultValueType({
-            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             defaultValue: astType.defaultValue,
             itemType,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
     createIdentifierType(astType) {
@@ -215,12 +220,13 @@ export class TypeFactory {
                 return this.createBlankNodeType(astType);
             case "Identifier":
                 return new IdentifierType({
-                    alias: astType.name.map((name) => this.tsName(name)),
                     comment: astType.comment,
                     configuration: this.configuration,
                     label: astType.label,
                     logger: this.logger,
+                    name: astType.name.map((name) => this.tsName(name)),
                     reusables: this.reusables,
+                    shapeIdentifier: astType.shapeIdentifier,
                 });
             case "Iri":
                 return this.createIriType(astType);
@@ -228,57 +234,60 @@ export class TypeFactory {
     }
     createIriType(astType) {
         return new IriType({
-            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             hasValues: astType.hasValues,
             in_: astType.in_,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
-    createLazyObjectOptionType(astType) {
-        return new LazyObjectOptionType({
-            alias: astType.name.map((name) => this.tsName(name)),
+    createLazyOptionType(astType) {
+        return new LazyOptionType({
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             partialType: this.createOptionType(astType.partialType),
             resolveType: this.createOptionType(astType.resolveType),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
-    createLazyObjectSetType(astType) {
-        return new LazyObjectSetType({
-            alias: astType.name.map((name) => this.tsName(name)),
+    createLazySetType(astType) {
+        return new LazySetType({
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             partialType: this.createSetType(astType.partialType),
             resolveType: this.createSetType(astType.resolveType),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
-    createLazyObjectType(astType) {
-        return new LazyObjectType({
-            alias: astType.name.map((name) => this.tsName(name)),
+    createLazyType(astType) {
+        return new LazyType({
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             partialType: this.createType(astType.partialType),
             resolveType: this.createType(astType.resolveType),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
     createListType(astType) {
         const itemType = this.createType(astType.itemType);
         invariant(ListType.isItemType(itemType));
         return new ListType({
-            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             identifierNodeKind: astType.identifierNodeKind,
@@ -286,7 +295,9 @@ export class TypeFactory {
             label: astType.label,
             logger: this.logger,
             mutable: astType.mutable,
+            name: astType.name.map((name) => this.tsName(name)),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
             toRdfTypes: astType.toRdfTypes,
         });
     }
@@ -315,7 +326,6 @@ export class TypeFactory {
                 switch (datatypeDefinition.kind) {
                     case "bigdecimal":
                         return new BigDecimalType({
-                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             hasValues: astType.hasValues,
@@ -323,11 +333,12 @@ export class TypeFactory {
                             label: astType.label,
                             languageIn: [],
                             logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
                             reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
                         });
                     case "bigint":
                         return new BigIntType({
-                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             datatype,
@@ -336,12 +347,13 @@ export class TypeFactory {
                             label: astType.label,
                             languageIn: [],
                             logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
                             primitiveIn: astType.in_.map((value) => LiteralDecoder.decodeBigIntLiteral(value).unsafeCoerce()),
                             reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
                         });
                     case "boolean":
                         return new BooleanType({
-                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             datatype,
@@ -350,13 +362,14 @@ export class TypeFactory {
                             languageIn: [],
                             in_: astType.in_,
                             logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
                             primitiveIn: astType.in_.map((value) => LiteralDecoder.decodeBooleanLiteral(value).unsafeCoerce()),
                             reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
                         });
                     case "date":
                     case "datetime":
                         return new (datatypeDefinition.kind === "date" ? DateType : DateTimeType)({
-                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             datatype,
@@ -365,15 +378,16 @@ export class TypeFactory {
                             label: astType.label,
                             languageIn: [],
                             logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
                             primitiveIn: astType.in_.map((value) => (datatypeDefinition.kind === "date"
                                 ? LiteralDecoder.decodeDateLiteral
                                 : LiteralDecoder.decodeDateTimeLiteral)(value).unsafeCoerce()),
                             reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
                         });
                     case "float":
                     case "int":
                         return new (datatypeDefinition.kind === "float" ? FloatType : IntType)({
-                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             datatype,
@@ -382,15 +396,16 @@ export class TypeFactory {
                             label: astType.label,
                             languageIn: [],
                             logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
                             primitiveIn: astType.in_.map((value) => (datatypeDefinition.kind === "float"
                                 ? LiteralDecoder.decodeFloatLiteral
                                 : LiteralDecoder.decodeIntLiteral)(value).unsafeCoerce()),
                             reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
                         });
                     case "string":
                         if (!datatype.equals(rdf.langString)) {
                             return new StringType({
-                                alias: astType.name.map((name) => this.tsName(name)),
                                 comment: astType.comment,
                                 configuration: this.configuration,
                                 datatype,
@@ -399,8 +414,10 @@ export class TypeFactory {
                                 label: astType.label,
                                 languageIn: astType.languageIn,
                                 logger: this.logger,
+                                name: astType.name.map((name) => this.tsName(name)),
                                 primitiveIn: astType.in_.map((value) => value.value),
                                 reusables: this.reusables,
+                                shapeIdentifier: astType.shapeIdentifier,
                             });
                         }
                         break;
@@ -420,7 +437,6 @@ export class TypeFactory {
         //   // this.logger.debug("literal type has no datatypes");
         // }
         return new LiteralType({
-            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             hasValues: astType.hasValues,
@@ -428,52 +444,54 @@ export class TypeFactory {
             label: astType.label,
             languageIn: astType.languageIn,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
-    createObjectTypeProperty({ astObjectTypeProperty, objectType, }) {
+    createObjectTypeProperty({ astStructField, objectType, }) {
         {
-            const cachedProperty = this.cachedObjectTypePropertiesByShapeIdentifier.get(astObjectTypeProperty.shapeIdentifier);
+            const cachedProperty = this.cachedObjectTypePropertiesByShapeIdentifier.get(astStructField.shapeIdentifier);
             if (cachedProperty) {
                 return cachedProperty;
             }
         }
         const property = new ObjectType.ShaclProperty({
-            comment: astObjectTypeProperty.comment,
+            comment: astStructField.comment,
             configuration: this.configuration,
-            description: astObjectTypeProperty.description,
-            display: astObjectTypeProperty.display,
-            label: astObjectTypeProperty.label,
+            description: astStructField.description,
+            display: astStructField.display,
+            label: astStructField.label,
             logger: this.logger,
-            mutable: astObjectTypeProperty.mutable,
+            mutable: astStructField.mutable,
+            name: this.tsName(astStructField.name),
             objectType,
-            name: this.tsName(astObjectTypeProperty.name),
-            path: astObjectTypeProperty.path,
-            recursive: !!astObjectTypeProperty.recursive,
+            path: astStructField.path,
+            recursive: !!astStructField.recursive,
             reusables: this.reusables,
-            type: this.createType(astObjectTypeProperty.type),
+            type: this.createType(astStructField.type),
         });
-        this.cachedObjectTypePropertiesByShapeIdentifier.set(astObjectTypeProperty.shapeIdentifier, property);
+        this.cachedObjectTypePropertiesByShapeIdentifier.set(astStructField.shapeIdentifier, property);
         return property;
     }
     createOptionType(astType) {
         const itemType = this.createType(astType.itemType);
         invariant(OptionType.isItemType(itemType));
         return new OptionType({
-            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             itemType,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
     createSetType(astType) {
         const itemType = this.createType(astType.itemType);
         invariant(SetType.isItemType(itemType));
         return new SetType({
-            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             itemType,
@@ -481,20 +499,23 @@ export class TypeFactory {
             logger: this.logger,
             mutable: astType.mutable,
             minCount: astType.minCount,
+            name: astType.name.map((name) => this.tsName(name)),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
     createTermType(astType) {
         return new TermType({
-            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             hasValues: astType.hasValues,
             in_: astType.in_,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             nodeKinds: astType.nodeKinds,
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
     tsName(name, options) {