@shaclmate/compiler 4.0.93 → 4.0.95

package/dist/generators/ts/TypeFactory.js

@@ -6,6 +6,7 @@ import { Maybe } from "purify-ts";
 import reservedTsIdentifiers_ from "reserved-identifiers";
 import { invariant } from "ts-invariant";
 import * as ast from "../../ast/index.js";
+import { AbstractType_JsonTypeFactory } from "./_AbstractType/AbstractType_JsonType.js";
 import { BigDecimalType } from "./BigDecimalType.js";
 import { BigIntType } from "./BigIntType.js";
 import { BlankNodeType } from "./BlankNodeType.js";
@@ -25,6 +26,7 @@ import { LazyType } from "./LazyType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
 import { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
+import { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import { ObjectType } from "./ObjectType.js";
 import { OptionType } from "./OptionType.js";
 import { SetType } from "./SetType.js";
@@ -32,48 +34,180 @@ import { StringType } from "./StringType.js";
 import { TermType } from "./TermType.js";
 export class TypeFactory {
     configuration;
+    constructorParameters;
+    jsonTypeFactory;
     logger;
-    reusables;
-    cachedObjectDiscriminatedUnionTypesByShapeIdentifier = new TermMap();
-    cachedObjectTypePropertiesByShapeIdentifier = new TermMap();
-    cachedObjectTypesByShapeIdentifier = new TermMap();
+    cachedObjectTypeShaclPropertiesByShapeIdentifier = new TermMap();
+    cachedTypesByShapeIdentifier = new TermMap();
     constructor({ configuration, logger, reusables, }) {
         this.configuration = configuration;
+        this.jsonTypeFactory = new AbstractType_JsonTypeFactory({
+            configuration,
+            reusables,
+        });
         this.logger = logger;
-        this.reusables = reusables;
+        this.constructorParameters = {
+            configuration,
+            logger,
+            jsonTypeFactory: this.jsonTypeFactory,
+            reusables,
+        };
+    }
+    createDiscriminatedUnionType(astType) {
+        if (astType.isStructDiscriminatedUnionType()) {
+            return this.createObjectDiscriminatedUnionType(astType);
+        }
+        return new DiscriminatedUnionType({
+            ...this.constructorParameters,
+            comment: astType.comment,
+            identifierProperty: Maybe.empty(),
+            label: astType.label,
+            members: astType.members.map((member) => ({
+                discriminantValue: member.discriminantValue,
+                type: this.createType(member.type),
+            })),
+            name: astType.name.map((name) => this.tsName(name)),
+            recursive: astType.recursive,
+            shapeIdentifier: astType.shapeIdentifier,
+            synthetic: astType.synthetic,
+        });
+    }
+    createIntersectionType(astType) {
+        if (astType.isStructIntersectionType()) {
+            return this.createObjectIntersectionType(astType);
+        }
+        throw new Error("non-object intersection types are unsupported");
+    }
+    createObjectDiscriminatedUnionType(astType) {
+        {
+            const cachedType = this.cachedTypesByShapeIdentifier.get(astType.shapeIdentifier);
+            if (cachedType) {
+                invariant(cachedType.kind === "ObjectDiscriminatedUnion", cachedType.kind);
+                return cachedType;
+            }
+        }
+        const objectDiscriminatedUnionIdentifierType = this.createIdentifierType(ast.StructCompoundType.identifierType(astType));
+        const objectDiscriminatedUnionTypeName = astType.name.map((name) => this.tsName(name));
+        const objectDiscriminatedUnionType = new ObjectDiscriminatedUnionType({
+            ...this.constructorParameters,
+            comment: astType.comment,
+            identifierProperty: astType.isStructDiscriminatedUnionType() &&
+                astType.members.every((member) => {
+                    switch (member.type.kind) {
+                        case "DiscriminatedUnion":
+                            return member.type.members.every((member) => member.type.identifierField.isJust());
+                        case "Struct":
+                            return member.type.identifierField.isJust();
+                        default:
+                            member.type;
+                            throw new Error("should never reach this point");
+                    }
+                })
+                ? Maybe.of(new ObjectType.IdentifierProperty({
+                    ...this.constructorParameters,
+                    name: `${this.configuration.syntheticNamePrefix}identifier`,
+                    objectType: { name: objectDiscriminatedUnionTypeName },
+                    type: objectDiscriminatedUnionIdentifierType,
+                }))
+                : Maybe.empty(),
+            identifierType: objectDiscriminatedUnionIdentifierType,
+            label: astType.label,
+            members: ast.StructCompoundType.memberStructTypes(astType).map((astStructType) => ({
+                discriminantValue: Maybe.empty(),
+                type: this.createObjectType(astStructType),
+            })),
+            name: objectDiscriminatedUnionTypeName,
+            recursive: astType.recursive,
+            shapeIdentifier: astType.shapeIdentifier,
+            synthetic: astType.synthetic,
+        });
+        this.cachedTypesByShapeIdentifier.set(astType.shapeIdentifier, objectDiscriminatedUnionType);
+        return objectDiscriminatedUnionType;
+    }
+    createObjectIntersectionType(astType) {
+        {
+            const cachedType = this.cachedTypesByShapeIdentifier.get(astType.shapeIdentifier);
+            if (cachedType) {
+                invariant(cachedType.kind === "ObjectIntersection", cachedType.kind);
+                return cachedType;
+            }
+        }
+        const objectIntersectionIdentifierType = this.createIdentifierType(ast.StructCompoundType.identifierType(astType));
+        const objectIntersectionTypeName = astType.name.map((name) => this.tsName(name));
+        const objectIntersectionType = new ObjectIntersectionType({
+            ...this.constructorParameters,
+            comment: astType.comment,
+            identifierProperty: astType.isStructIntersectionType() &&
+                astType.members.every((member) => {
+                    switch (member.type.kind) {
+                        case "Intersection":
+                            return member.type.members.every((member) => member.type.identifierField.isJust());
+                        case "Struct":
+                            return member.type.identifierField.isJust();
+                        default:
+                            member.type;
+                            throw new Error("should never reach this point");
+                    }
+                })
+                ? Maybe.of(new ObjectType.IdentifierProperty({
+                    ...this.constructorParameters,
+                    name: `${this.configuration.syntheticNamePrefix}identifier`,
+                    objectType: { name: objectIntersectionTypeName },
+                    type: objectIntersectionIdentifierType,
+                }))
+                : Maybe.empty(),
+            identifierType: objectIntersectionIdentifierType,
+            label: astType.label,
+            members: ast.StructCompoundType.memberStructTypes(astType).map((astStructType) => ({
+                type: this.createObjectType(astStructType),
+            })),
+            name: objectIntersectionTypeName,
+            recursive: astType.recursive,
+            shapeIdentifier: astType.shapeIdentifier,
+            synthetic: astType.synthetic,
+        });
+        this.cachedTypesByShapeIdentifier.set(astType.shapeIdentifier, objectIntersectionType);
+        return objectIntersectionType;
     }
     createObjectType(astType) {
         {
-            const cachedObjectType = this.cachedObjectTypesByShapeIdentifier.get(astType.shapeIdentifier);
-            if (cachedObjectType) {
-                return cachedObjectType;
+            const cachedType = this.cachedTypesByShapeIdentifier.get(astType.shapeIdentifier);
+            if (cachedType) {
+                invariant(cachedType.kind === "Object", cachedType.kind);
+                return cachedType;
             }
         }
+        const objectTypeName = astType.name.map((name) => this.tsName(name, { synthetic: astType.synthetic }));
+        const objectTypeStub = { name: objectTypeName };
         const discriminantProperty = astType.name.map((name) => new ObjectType.DiscriminantProperty({
-            configuration: this.configuration,
-            logger: this.logger,
-            objectType: { name: astType.name },
-            reusables: this.reusables,
+            ...this.constructorParameters,
+            objectType: objectTypeStub,
             value: name,
         }));
+        const identifierType = this.createIdentifierType(astType.identifierType);
+        const identifierProperty = astType.identifierField.map(() => new ObjectType.IdentifierProperty({
+            ...this.constructorParameters,
+            name: `${this.configuration.syntheticNamePrefix}identifier`,
+            objectType: objectTypeStub,
+            type: identifierType,
+        }));
         const rdfTypeProperty = astType.fromRdfType.map((fromRdfType) => new ObjectType.RdfTypeProperty({
-            configuration: this.configuration,
+            ...this.constructorParameters,
             fromRdfType,
-            logger: this.logger,
-            objectType: { name: astType.name },
-            reusables: this.reusables,
+            objectType: objectTypeStub,
             toRdfTypes: astType.toRdfTypes,
         }));
-        const identifierType = this.createIdentifierType(astType.identifierType);
         const objectType = new ObjectType({
+            ...this.constructorParameters,
             discriminantProperty,
             comment: astType.comment,
-            configuration: this.configuration,
             extern: astType.extern,
+            identifierProperty,
             identifierType,
             label: astType.label,
             lazyProperties: (objectType) => {
                 const properties = astType.fields
+                    .filter((field) => field.kind === "Shacl")
                     .toSorted((left, right) => {
                     if (left.order < right.order) {
                         return -1;
@@ -83,73 +217,42 @@ export class TypeFactory {
                     }
                     return this.tsName(left.name).localeCompare(this.tsName(right.name));
                 })
-                    .map((astField) => this.createObjectTypeProperty({
+                    .map((astField) => this.createObjectTypeShaclProperty({
                     astStructField: astField,
                     objectType,
                 }));
-                discriminantProperty.ifJust((discriminantProperty) => {
-                    properties.splice(0, 0, discriminantProperty);
-                });
-                rdfTypeProperty.ifJust((rdfTypeProperty) => {
-                    properties.splice(0, 0, rdfTypeProperty);
-                });
-                properties.splice(0, 0, new ObjectType.IdentifierProperty({
-                    configuration: this.configuration,
-                    logger: this.logger,
-                    name: `${this.configuration.syntheticNamePrefix}identifier`,
-                    objectType,
-                    reusables: this.reusables,
-                    type: identifierType,
-                }));
+                for (const specialProperty of [
+                    discriminantProperty,
+                    rdfTypeProperty,
+                    identifierProperty,
+                ]) {
+                    specialProperty.ifJust((specialProperty) => {
+                        properties.splice(0, 0, specialProperty);
+                    });
+                }
                 return properties;
             },
-            logger: this.logger,
-            name: astType.name.map((name) => this.tsName(name, { synthetic: astType.synthetic })),
+            name: objectTypeName,
             rdfTypeProperty,
             recursive: astType.recursive,
-            reusables: this.reusables,
             shapeIdentifier: astType.shapeIdentifier,
             synthetic: astType.synthetic,
         });
-        this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, objectType);
+        this.cachedTypesByShapeIdentifier.set(astType.shapeIdentifier, objectType);
         return objectType;
     }
-    createObjectDiscriminatedUnionType(astType) {
-        {
-            const cachedObjectDiscriminatedUnionType = this.cachedObjectDiscriminatedUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
-            if (cachedObjectDiscriminatedUnionType) {
-                return cachedObjectDiscriminatedUnionType;
-            }
-        }
-        const objectDiscriminatedUnionType = new ObjectDiscriminatedUnionType({
-            comment: astType.comment,
-            configuration: this.configuration,
-            identifierType: Maybe.of(this.createIdentifierType(ast.StructCompoundType.identifierType(astType))),
-            label: astType.label,
-            logger: this.logger,
-            members: ast.StructCompoundType.memberStructTypes(astType).map((astStructType) => ({
-                discriminantValue: Maybe.empty(),
-                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.cachedObjectDiscriminatedUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, objectDiscriminatedUnionType);
-        return objectDiscriminatedUnionType;
-    }
     createType(astType, parameters) {
         switch (astType.kind) {
             case "BlankNode":
                 return this.createBlankNodeType(astType);
             case "DefaultValue":
                 return this.createDefaultValueType(astType);
+            case "DiscriminatedUnion":
+                return this.createDiscriminatedUnionType(astType);
             case "Identifier":
                 return this.createIdentifierType(astType);
             case "Intersection":
-                throw new Error("not implemented");
+                return this.createIntersectionType(astType);
             case "Iri":
                 return this.createIriType(astType);
             case "Lazy":
@@ -170,39 +273,14 @@ export class TypeFactory {
                 return this.createObjectType(astType);
             case "Term":
                 return this.createTermType(astType);
-            case "DiscriminatedUnion":
-                return this.createDiscriminatedUnionType(astType);
-        }
-    }
-    createDiscriminatedUnionType(astType) {
-        if (astType.isStructDiscriminatedUnionType()) {
-            return this.createObjectDiscriminatedUnionType(astType);
         }
-        return new DiscriminatedUnionType({
-            comment: astType.comment,
-            configuration: this.configuration,
-            identifierType: Maybe.empty(),
-            label: astType.label,
-            logger: this.logger,
-            members: astType.members.map((member) => ({
-                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({
+            ...this.constructorParameters,
             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,
         });
     }
@@ -212,14 +290,12 @@ export class TypeFactory {
         });
         invariant(DefaultValueType.isItemType(itemType));
         return new DefaultValueType({
+            ...this.constructorParameters,
             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,
         });
     }
@@ -229,12 +305,10 @@ export class TypeFactory {
                 return this.createBlankNodeType(astType);
             case "Identifier":
                 return new IdentifierType({
+                    ...this.constructorParameters,
                     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":
@@ -243,53 +317,45 @@ export class TypeFactory {
     }
     createIriType(astType) {
         return new IriType({
+            ...this.constructorParameters,
             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,
         });
     }
     createLazyOptionType(astType) {
         return new LazyOptionType({
+            ...this.constructorParameters,
             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,
         });
     }
     createLazySetType(astType) {
         return new LazySetType({
+            ...this.constructorParameters,
             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,
         });
     }
     createLazyType(astType) {
         return new LazyType({
+            ...this.constructorParameters,
             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,
         });
     }
@@ -297,15 +363,13 @@ export class TypeFactory {
         const itemType = this.createType(astType.itemType);
         invariant(ListType.isItemType(itemType));
         return new ListType({
+            ...this.constructorParameters,
             comment: astType.comment,
-            configuration: this.configuration,
             identifierNodeKind: astType.identifierNodeKind,
             itemType,
             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,
         });
@@ -330,39 +394,37 @@ export class TypeFactory {
         }
         if (datatypes.size === 1) {
             const datatype = [...datatypes][0];
-            const typeParameters = {
+            const constructorParameters = {
+                ...this.constructorParameters,
                 comment: astType.comment,
-                configuration: this.configuration,
                 datatype,
                 hasValues: astType.hasValues,
                 in_: astType.in_,
                 label: astType.label,
                 languageIn: astType.languageIn,
-                logger: this.logger,
                 name: astType.name.map((name) => this.tsName(name)),
-                reusables: this.reusables,
                 shapeIdentifier: astType.shapeIdentifier,
             };
             if (datatype.equals(rdf.langString)) {
-                return new LangStringType(typeParameters);
+                return new LangStringType(constructorParameters);
             }
             const datatypeDefinition = literalDatatypeDefinitions[datatype.value];
             if (datatypeDefinition) {
                 switch (datatypeDefinition.kind) {
                     case "bigdecimal":
-                        return new BigDecimalType(typeParameters);
+                        return new BigDecimalType(constructorParameters);
                     case "bigint":
-                        return new BigIntType(typeParameters);
+                        return new BigIntType(constructorParameters);
                     case "boolean":
-                        return new BooleanType(typeParameters);
+                        return new BooleanType(constructorParameters);
                     case "date":
                     case "datetime":
-                        return new (datatypeDefinition.kind === "date" ? DateType : DateTimeType)(typeParameters);
+                        return new (datatypeDefinition.kind === "date" ? DateType : DateTimeType)(constructorParameters);
                     case "float":
                     case "int":
-                        return new (datatypeDefinition.kind === "float" ? FloatType : IntType)(typeParameters);
+                        return new (datatypeDefinition.kind === "float" ? FloatType : IntType)(constructorParameters);
                     case "string":
-                        return new StringType(typeParameters);
+                        return new StringType(constructorParameters);
                 }
             }
             this.logger.warn("unrecognized literal datatype: %s", datatype.value);
@@ -374,54 +436,49 @@ export class TypeFactory {
         //   // this.logger.debug("literal type has no datatypes");
         // }
         return new LiteralType({
+            ...this.constructorParameters,
             comment: astType.comment,
-            configuration: this.configuration,
             hasValues: astType.hasValues,
             in_: astType.in_,
             label: astType.label,
             languageIn: astType.languageIn,
-            logger: this.logger,
             name: astType.name.map((name) => this.tsName(name)),
-            reusables: this.reusables,
             shapeIdentifier: astType.shapeIdentifier,
         });
     }
-    createObjectTypeProperty({ astStructField, objectType, }) {
+    createObjectTypeShaclProperty({ astStructField, objectType, }) {
         {
-            const cachedProperty = this.cachedObjectTypePropertiesByShapeIdentifier.get(astStructField.shapeIdentifier);
+            const cachedProperty = this.cachedObjectTypeShaclPropertiesByShapeIdentifier.get(astStructField.shapeIdentifier);
             if (cachedProperty) {
                 return cachedProperty;
             }
         }
         const property = new ObjectType.ShaclProperty({
+            ...this.constructorParameters,
             comment: astStructField.comment,
-            configuration: this.configuration,
             description: astStructField.description,
             display: astStructField.display,
             label: astStructField.label,
-            logger: this.logger,
+            minCount: astStructField.minCount,
             mutable: astStructField.mutable,
             name: this.tsName(astStructField.name),
             objectType,
             path: astStructField.path,
             recursive: !!astStructField.recursive,
-            reusables: this.reusables,
             type: this.createType(astStructField.type),
         });
-        this.cachedObjectTypePropertiesByShapeIdentifier.set(astStructField.shapeIdentifier, property);
+        this.cachedObjectTypeShaclPropertiesByShapeIdentifier.set(astStructField.shapeIdentifier, property);
         return property;
     }
     createOptionType(astType) {
         const itemType = this.createType(astType.itemType);
         invariant(OptionType.isItemType(itemType));
         return new OptionType({
+            ...this.constructorParameters,
             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,
         });
     }
@@ -429,29 +486,25 @@ export class TypeFactory {
         const itemType = this.createType(astType.itemType);
         invariant(SetType.isItemType(itemType));
         return new SetType({
+            ...this.constructorParameters,
             comment: astType.comment,
-            configuration: this.configuration,
             itemType,
             label: astType.label,
-            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({
+            ...this.constructorParameters,
             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,
         });
     }

package/dist/generators/ts/UberObjectDiscriminatedUnionType.d.ts

@@ -1,5 +1,6 @@
 import type { Logger } from "@rdfx/logger";
 import { Maybe } from "purify-ts";
+import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
 import type { Reusables } from "./Reusables.js";
 import type { TsGenerator } from "./TsGenerator.js";
@@ -14,16 +15,19 @@ export declare class UberObjectDiscriminatedUnionType {
     constructor({ configuration, members, reusables, }: {
         configuration: TsGenerator.Configuration;
         logger: Logger;
-        members: readonly ObjectType[];
+        members: readonly UberObjectDiscriminatedUnionType.Member[];
         reusables: Reusables;
     });
     get declaration(): Maybe<Code>;
     private get equalsFunctionDeclaration();
     private get name();
-    private get toJsonFunctionDeclaration();
+    private get toJsonObjectFunctionDeclaration();
     private get toRdfResourceFunctionDeclaration();
     private get hashFunctionDeclaration();
     private get toStringFunctionDeclaration();
     private memberTypeSwitch;
 }
+export declare namespace UberObjectDiscriminatedUnionType {
+    type Member = ObjectIntersectionType | ObjectType;
+}
 //# sourceMappingURL=UberObjectDiscriminatedUnionType.d.ts.map