@shaclmate/compiler 2.0.13 → 2.0.14

package/generators/ts/TypeFactory.js

@@ -1,101 +1,204 @@
 import TermMap from "@rdfjs/term-map";
-import { NodeKind } from "@shaclmate/shacl-ast";
-import { xsd } from "@tpluscode/rdf-ns-builders";
+import TermSet from "@rdfjs/term-set";
+import { rdf, xsd } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
-import { BooleanType } from "./BooleanType";
-import { IdentifierType } from "./IdentifierType";
-import { IntersectionType } from "./IntersectionType";
+import { fromRdf } from "rdf-literal";
+import { logger } from "../../logger.js";
+import { BooleanType } from "./BooleanType.js";
+import { DateTimeType } from "./DateTimeType.js";
+import { IdentifierType } from "./IdentifierType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
 import { NumberType } from "./NumberType.js";
 import { ObjectType } from "./ObjectType.js";
-import { OptionType } from "./OptionType";
-import { SetType } from "./SetType";
+import { ObjectUnionType } from "./ObjectUnionType.js";
+import { OptionType } from "./OptionType.js";
+import { SetType } from "./SetType.js";
 import { StringType } from "./StringType.js";
-import { UnionType } from "./UnionType";
+import { TermType } from "./TermType.js";
+import { UnionType } from "./UnionType.js";
 import { tsName } from "./tsName.js";
 export class TypeFactory {
-    constructor({ configuration }) {
+    constructor({ dataFactoryVariable }) {
         this.cachedObjectTypePropertiesByIdentifier = new TermMap();
         this.cachedObjectTypesByIdentifier = new TermMap();
-        this.configuration = configuration;
+        this.dataFactoryVariable = dataFactoryVariable;
     }
     createTypeFromAstType(astType) {
         switch (astType.kind) {
             case "IdentifierType":
                 return new IdentifierType({
-                    configuration: this.configuration,
+                    dataFactoryVariable: this.dataFactoryVariable,
                     defaultValue: astType.defaultValue,
-                    hasValue: astType.hasValue,
+                    hasValues: astType.hasValues,
+                    in_: astType.in_,
                     nodeKinds: astType.nodeKinds,
                 });
             case "IntersectionType":
-                return new IntersectionType({
-                    configuration: this.configuration,
-                    memberTypes: astType.memberTypes.map((astType) => this.createTypeFromAstType(astType)),
+                throw new Error("not implemented");
+            case "ListType": {
+                return new ListType({
+                    dataFactoryVariable: this.dataFactoryVariable,
+                    identifierNodeKind: astType.identifierNodeKind,
+                    itemType: this.createTypeFromAstType(astType.itemType),
+                    mutable: astType.mutable.orDefault(false),
+                    mintingStrategy: astType.mintingStrategy,
+                    toRdfTypes: astType.toRdfTypes,
                 });
+            }
             case "LiteralType": {
-                const datatype = astType.datatype
-                    .altLazy(() => astType.defaultValue.map((defaultValue) => defaultValue.datatype))
-                    .altLazy(() => astType.hasValue.map((hasValue) => hasValue.datatype))
-                    .extractNullable();
-                if (datatype !== null) {
+                // Look at sh:datatype as well as sh:defaultValue/sh:hasValue/sh:in term datatypes
+                // If there's one common datatype than we can refine the type
+                // Otherwise default to rdfjs.Literal
+                const datatypes = new TermSet();
+                astType.datatype.ifJust((datatype) => datatypes.add(datatype));
+                astType.defaultValue.ifJust((defaultValue) => datatypes.add(defaultValue.datatype));
+                for (const hasValue of astType.hasValues) {
+                    datatypes.add(hasValue.datatype);
+                }
+                for (const value of astType.in_) {
+                    datatypes.add(value.datatype);
+                }
+                if (datatypes.size === 1) {
+                    const datatype = [...datatypes][0];
                     if (datatype.equals(xsd.boolean)) {
                         return new BooleanType({
-                            configuration: this.configuration,
+                            dataFactoryVariable: this.dataFactoryVariable,
                             defaultValue: astType.defaultValue,
-                            hasValue: astType.hasValue,
+                            hasValues: astType.hasValues,
+                            languageIn: [],
+                            in_: astType.in_,
+                            primitiveDefaultValue: astType.defaultValue
+                                .map((value) => fromRdf(value, true))
+                                .filter((value) => typeof value === "boolean"),
+                            primitiveIn: astType.in_
+                                .map((value) => fromRdf(value, true))
+                                .filter((value) => typeof value === "boolean"),
                         });
                     }
-                    if (datatype.equals(xsd.integer)) {
-                        return new NumberType({
-                            configuration: this.configuration,
+                    if (datatype.equals(xsd.dateTime)) {
+                        return new DateTimeType({
+                            dataFactoryVariable: this.dataFactoryVariable,
                             defaultValue: astType.defaultValue,
-                            hasValue: astType.hasValue,
+                            hasValues: astType.hasValues,
+                            in_: astType.in_,
+                            languageIn: [],
+                            primitiveDefaultValue: astType.defaultValue
+                                .map((value) => fromRdf(value, true))
+                                .filter((value) => typeof value === "object" && value instanceof Date),
+                            primitiveIn: astType.in_
+                                .map((value) => fromRdf(value, true))
+                                .filter((value) => typeof value === "object" && value instanceof Date),
                         });
                     }
+                    for (const numberDatatype of [
+                        // Integers
+                        xsd.byte,
+                        xsd.int,
+                        xsd.integer,
+                        xsd.long,
+                        xsd.negativeInteger,
+                        xsd.nonNegativeInteger,
+                        xsd.nonPositiveInteger,
+                        xsd.positiveInteger,
+                        xsd.short,
+                        xsd.unsignedByte,
+                        xsd.unsignedInt,
+                        xsd.unsignedLong,
+                        xsd.unsignedShort,
+                        // Floating point
+                        xsd.decimal,
+                        xsd.double,
+                        xsd.float,
+                    ]) {
+                        if (datatype.equals(numberDatatype)) {
+                            return new NumberType({
+                                dataFactoryVariable: this.dataFactoryVariable,
+                                defaultValue: astType.defaultValue,
+                                hasValues: astType.hasValues,
+                                in_: astType.in_,
+                                languageIn: [],
+                                primitiveDefaultValue: astType.defaultValue
+                                    .map((value) => fromRdf(value, true))
+                                    .filter((value) => typeof value === "number"),
+                                primitiveIn: astType.in_
+                                    .map((value) => fromRdf(value, true))
+                                    .filter((value) => typeof value === "number"),
+                            });
+                        }
+                    }
                     if (datatype.equals(xsd.anyURI) || datatype.equals(xsd.string)) {
                         return new StringType({
-                            configuration: this.configuration,
+                            dataFactoryVariable: this.dataFactoryVariable,
                             defaultValue: astType.defaultValue,
-                            hasValue: astType.hasValue,
+                            hasValues: astType.hasValues,
+                            languageIn: [],
+                            in_: astType.in_,
+                            primitiveDefaultValue: astType.defaultValue.map((value) => value.value),
+                            primitiveIn: astType.in_.map((value) => value.value),
                         });
                     }
+                    if (datatype.equals(rdf.langString)) {
+                        // Drop down
+                    }
+                    else {
+                        logger.warn("unrecognized literal datatype: %s", datatype.value);
+                    }
+                }
+                else if (datatypes.size > 0) {
+                    logger.warn("literal type has multiple datatypes: %s", JSON.stringify([...datatypes].map((datatype) => datatype.value)));
+                }
+                else {
+                    logger.debug("literal type has no datatypes");
                 }
                 return new LiteralType({
-                    configuration: this.configuration,
+                    dataFactoryVariable: this.dataFactoryVariable,
                     defaultValue: astType.defaultValue,
-                    hasValue: astType.hasValue,
+                    hasValues: astType.hasValues,
+                    in_: astType.in_,
+                    languageIn: astType.languageIn,
                 });
             }
-            case "ObjectType": {
-                if (astType.listItemType.isJust()) {
-                    return new ListType({
-                        configuration: this.configuration,
-                        identifierNodeKind: astType.nodeKinds.has(NodeKind.BLANK_NODE)
-                            ? NodeKind.BLANK_NODE
-                            : NodeKind.IRI,
-                        itemType: this.createTypeFromAstType(astType.listItemType.unsafeCoerce()),
-                        mintingStrategy: astType.mintingStrategy,
-                        rdfType: astType.rdfType,
-                    });
-                }
+            case "ObjectIntersectionType":
+                throw new Error("not implemented");
+            case "ObjectType":
                 return this.createObjectTypeFromAstType(astType);
-            }
+            case "ObjectUnionType":
+                return new ObjectUnionType({
+                    comment: astType.comment,
+                    dataFactoryVariable: this.dataFactoryVariable,
+                    export_: astType.export,
+                    features: astType.tsFeatures,
+                    label: astType.label,
+                    memberTypes: astType.memberTypes
+                        .map((astType) => this.createTypeFromAstType(astType))
+                        .filter((memberType) => memberType instanceof ObjectType),
+                    name: tsName(astType.name),
+                });
             case "OptionType":
                 return new OptionType({
-                    configuration: this.configuration,
+                    dataFactoryVariable: this.dataFactoryVariable,
                     itemType: this.createTypeFromAstType(astType.itemType),
                 });
+            case "PlaceholderType":
+                throw new Error(astType.kind);
             case "SetType":
                 return new SetType({
-                    configuration: this.configuration,
+                    dataFactoryVariable: this.dataFactoryVariable,
                     itemType: this.createTypeFromAstType(astType.itemType),
                     minCount: astType.minCount,
                 });
+            case "TermType":
+                return new TermType({
+                    dataFactoryVariable: this.dataFactoryVariable,
+                    defaultValue: astType.defaultValue,
+                    hasValues: astType.hasValues,
+                    in_: astType.in_,
+                    nodeKinds: astType.nodeKinds,
+                });
             case "UnionType":
                 return new UnionType({
-                    configuration: this.configuration,
+                    dataFactoryVariable: this.dataFactoryVariable,
                     memberTypes: astType.memberTypes.map((astType) => this.createTypeFromAstType(astType)),
                 });
         }
@@ -108,29 +211,57 @@ export class TypeFactory {
             }
         }
         const identifierType = new IdentifierType({
-            configuration: this.configuration,
+            dataFactoryVariable: this.dataFactoryVariable,
             defaultValue: Maybe.empty(),
-            hasValue: Maybe.empty(),
+            hasValues: [],
+            in_: [],
             nodeKinds: astType.nodeKinds,
         });
         const objectType = new ObjectType({
             abstract: astType.abstract,
-            configuration: this.configuration,
+            comment: astType.comment,
+            dataFactoryVariable: this.dataFactoryVariable,
+            declarationType: astType.tsObjectDeclarationType,
             export_: astType.export,
-            identifierType,
+            extern: astType.extern,
+            features: astType.tsFeatures,
+            fromRdfType: astType.fromRdfType,
+            imports: astType.tsImports,
+            label: astType.label,
             lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
             lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
             lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
             lazyProperties: () => {
                 const properties = astType.properties.map((astProperty) => this.createObjectTypePropertyFromAstProperty(astProperty));
-                if (astType.parentObjectTypes.length === 0) {
-                    properties.push(new ObjectType.IdentifierProperty({
-                        configuration: this.configuration,
-                        mintingStrategy: astType.mintingStrategy,
-                        name: this.configuration.objectTypeIdentifierPropertyName,
-                        type: identifierType,
-                    }));
-                } // Else parent will have the identifier property
+                let identifierPropertyClassDeclarationVisibility;
+                if (astType.abstract) {
+                    // If the type is abstract, don't declare a property.
+                    identifierPropertyClassDeclarationVisibility = Maybe.empty();
+                }
+                else if (astType.ancestorObjectTypes.some((ancestorObjectType) => !ancestorObjectType.abstract)) {
+                    // If the type has a non-abstract ancestor, that ancestor will declare the identifier property
+                    identifierPropertyClassDeclarationVisibility = Maybe.empty();
+                }
+                else if (astType.descendantObjectTypes.some((descendantObjectType) => !descendantObjectType.abstract)) {
+                    // If the type has a non-abstract descendant, declare the identifier property for it
+                    identifierPropertyClassDeclarationVisibility = Maybe.of("protected");
+                }
+                else {
+                    identifierPropertyClassDeclarationVisibility = Maybe.of("private");
+                }
+                const identifierProperty = new ObjectType.IdentifierProperty({
+                    abstract: astType.abstract,
+                    classDeclarationVisibility: identifierPropertyClassDeclarationVisibility,
+                    dataFactoryVariable: this.dataFactoryVariable,
+                    mintingStrategy: astType.mintingStrategy,
+                    name: astType.tsIdentifierPropertyName,
+                    lazyObjectTypeMutable: () => properties.some((property) => property.mutable || property.type.mutable),
+                    objectTypeDeclarationType: astType.tsObjectDeclarationType,
+                    override: astType.parentObjectTypes.length > 0,
+                    type: identifierType,
+                    visibility: "public",
+                });
+                properties.push(identifierProperty);
                 // Type discriminator property
                 const typeDiscriminatorValues = new Set();
                 if (!astType.abstract) {
@@ -141,25 +272,26 @@ export class TypeFactory {
                         typeDiscriminatorValues.add(descendantObjectType.discriminatorValue);
                     }
                 }
-                properties.push(new ObjectType.TypeDiscriminatorProperty({
-                    abstract: astType.abstract,
-                    configuration: this.configuration,
-                    name: this.configuration.objectTypeDiscriminatorPropertyName,
-                    override: objectType.parentObjectTypes.length > 0 &&
-                        !objectType.parentObjectTypes[0].abstract,
-                    type: {
-                        name: [...typeDiscriminatorValues]
-                            .sort()
-                            .map((name) => `"${name}"`)
-                            .join("|"),
-                    },
-                    value: objectType.discriminatorValue,
-                }));
+                if (typeDiscriminatorValues.size > 0) {
+                    properties.push(new ObjectType.TypeDiscriminatorProperty({
+                        abstract: astType.abstract,
+                        dataFactoryVariable: this.dataFactoryVariable,
+                        name: astType.tsTypeDiscriminatorPropertyName,
+                        objectTypeDeclarationType: objectType.declarationType,
+                        override: objectType.parentObjectTypes.length > 0,
+                        type: new ObjectType.TypeDiscriminatorProperty.Type({
+                            mutable: false,
+                            values: [...typeDiscriminatorValues].sort(),
+                        }),
+                        visibility: "public",
+                        value: objectType.discriminatorValue,
+                    }));
+                }
                 return properties.sort((left, right) => left.name.localeCompare(right.name));
             },
             mintingStrategy: astType.mintingStrategy,
             name: tsName(astType.name),
-            rdfType: astType.rdfType,
+            toRdfTypes: astType.toRdfTypes,
         });
         this.cachedObjectTypesByIdentifier.set(astType.name.identifier, objectType);
         return objectType;
@@ -171,25 +303,16 @@ export class TypeFactory {
                 return cachedProperty;
             }
         }
-        let type;
-        if (astObjectTypeProperty.type.kind === "ObjectType" &&
-            !astObjectTypeProperty.inline) {
-            // Non-inlined object type = its identifier
-            type = new IdentifierType({
-                configuration: this.configuration,
-                defaultValue: Maybe.empty(),
-                hasValue: Maybe.empty(),
-                nodeKinds: astObjectTypeProperty.type.nodeKinds,
-            });
-        }
-        else {
-            type = this.createTypeFromAstType(astObjectTypeProperty.type);
-        }
         const property = new ObjectType.ShaclProperty({
-            configuration: this.configuration,
+            comment: astObjectTypeProperty.comment,
+            dataFactoryVariable: this.dataFactoryVariable,
+            description: astObjectTypeProperty.description,
+            label: astObjectTypeProperty.label,
+            mutable: astObjectTypeProperty.mutable.orDefault(false),
             name: tsName(astObjectTypeProperty.name),
             path: astObjectTypeProperty.path.iri,
-            type,
+            type: this.createTypeFromAstType(astObjectTypeProperty.type),
+            visibility: astObjectTypeProperty.visibility,
         });
         this.cachedObjectTypePropertiesByIdentifier.set(astObjectTypeProperty.name.identifier, property);
         return property;

package/generators/ts/UnionType.d.ts

@@ -1,18 +1,31 @@
 import { Maybe } from "purify-ts";
+import type { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class UnionType extends Type {
     readonly kind = "UnionType";
     readonly memberTypes: readonly Type[];
-    constructor({ memberTypes, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
+    constructor({ memberTypes, name, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
         memberTypes: readonly Type[];
+        name?: string;
     });
-    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    private _name?;
     get name(): string;
-    private get typesSharedDiscriminatorProperty();
-    equalsFunction(): string;
+    get conversions(): readonly Type.Conversion[];
+    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    get equalsFunction(): string;
+    get jsonName(): string;
+    get mutable(): boolean;
+    get useImports(): readonly Import[];
+    private get _discriminatorProperty();
+    private get memberTypeTraits();
+    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression(parameters: Parameters<Type["fromRdfExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    propertySparqlGraphPatternExpression(parameters: Parameters<Type["propertySparqlGraphPatternExpression"]>[0]): Type.SparqlGraphPatternExpression | Type.SparqlGraphPatternsExpression;
+    hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    sparqlConstructTemplateTriples(parameters: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
+    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+    private ternaryExpression;
 }
 //# sourceMappingURL=UnionType.d.ts.map