@shaclmate/compiler 4.0.50 → 4.0.52

package/dist/generators/ts/TsGenerator.js

@@ -0,0 +1,292 @@
+import dataFactory from "@rdfx/data-factory";
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { BlankNodeType } from "./BlankNodeType.js";
+import { GraphqlSchema } from "./GraphqlSchema.js";
+import { IdentifierType } from "./IdentifierType.js";
+import { IriType } from "./IriType.js";
+import { ObjectSetType } from "./ObjectSetType.js";
+import { ObjectUnionType } from "./ObjectUnionType.js";
+import { RdfjsDatasetObjectSetType } from "./RdfjsDatasetObjectSetType.js";
+import { Reusables } from "./Reusables.js";
+import { SparqlObjectSetType } from "./SparqlObjectSetType.js";
+import { TypeFactory } from "./TypeFactory.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+function compareTsNamedType(left, right) {
+    return left.name.unsafeCoerce().localeCompare(right.name.unsafeCoerce());
+}
+export class TsGenerator {
+    configuration;
+    logger;
+    constructor({ configuration, logger, }) {
+        this.configuration = configuration;
+        this.logger = logger;
+    }
+    generate(ast_) {
+        const configuration = TsGenerator.Configuration.finalize(ast_, this.configuration);
+        const reusables = new Reusables({
+            configuration,
+            logger: this.logger,
+        });
+        const typeFactory = new TypeFactory({
+            configuration,
+            logger: this.logger,
+            reusables,
+        });
+        let declarations = [];
+        const tsNamedTypes = [];
+        const tsNamedObjectTypes = [];
+        const tsNamedObjectUnionTypes = [];
+        for (const astNamedType of ast_.namedTypes) {
+            const tsNamedType = typeFactory.createType(astNamedType);
+            tsNamedTypes.push(tsNamedType);
+            if (astNamedType.kind === "Struct") {
+                for (const tsImport of astNamedType.tsImports) {
+                    declarations.push(code `${tsImport}`);
+                }
+            }
+            switch (tsNamedType.kind) {
+                case "Object":
+                    tsNamedObjectTypes.push(tsNamedType);
+                    break;
+                case "ObjectUnion":
+                    tsNamedObjectUnionTypes.push(tsNamedType);
+                    break;
+            }
+        }
+        tsNamedTypes.sort(compareTsNamedType);
+        tsNamedObjectTypes.sort(compareTsNamedType);
+        tsNamedObjectUnionTypes.sort(compareTsNamedType);
+        for (const tsNamedType of tsNamedTypes) {
+            switch (tsNamedType.kind) {
+                case "ObjectUnion":
+                case "Union":
+                    continue; // Declare compound types last.
+            }
+            tsNamedType.declaration.ifJust((declaration) => {
+                declarations.push(declaration);
+            });
+        }
+        // Declare compound types last.
+        for (const tsNamedType of tsNamedTypes) {
+            switch (tsNamedType.kind) {
+                case "ObjectUnion":
+                case "Union":
+                    break;
+                default:
+                    continue;
+            }
+            tsNamedType.declaration.ifJust((declaration) => {
+                declarations.push(declaration);
+            });
+        }
+        switch (tsNamedObjectTypes.length) {
+            case 0:
+                break;
+            case 1:
+                declarations.push(code `type ${configuration.syntheticNamePrefix}Object = ${tsNamedObjectTypes[0].expression};`);
+                break;
+            default: {
+                const uberObjectUnionType = this.synthesizeUberObjectUnionType({
+                    configuration,
+                    namedObjectTypes: tsNamedObjectTypes,
+                    reusables,
+                });
+                declarations = declarations.concat(uberObjectUnionType.declaration.toList());
+                tsNamedObjectUnionTypes.push(uberObjectUnionType);
+            }
+        }
+        declarations.push(...this.objectSetTypeDeclarations({
+            configuration,
+            namedObjectTypes: tsNamedObjectTypes,
+            namedObjectUnionTypes: tsNamedObjectUnionTypes,
+            reusables,
+        }));
+        if (configuration.features.has("GraphQL")) {
+            const graphqlNamedObjectTypes = tsNamedObjectTypes.filter((tsNamedObjectType) => !tsNamedObjectType.synthetic);
+            const graphqlNamedObjectUnionTypes = tsNamedObjectUnionTypes.filter((tsNamedObjectUnionType) => !tsNamedObjectUnionType.synthetic);
+            if (graphqlNamedObjectTypes.length > 0) {
+                declarations.push(new GraphqlSchema({
+                    configuration,
+                    logger: this.logger,
+                    namedObjectTypes: graphqlNamedObjectTypes,
+                    namedObjectUnionTypes: graphqlNamedObjectUnionTypes,
+                    reusables,
+                }).declaration);
+            }
+        }
+        declarations.splice(0, 0, joinCode(reusables.snippets.ifUsed, { on: "\n\n" }));
+        return joinCode(declarations).toString({});
+    }
+    objectSetTypeDeclarations({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }) {
+        const constructorParameters = {
+            configuration,
+            logger: this.logger,
+            namedObjectTypes: namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern && !namedObjectType.synthetic),
+            namedObjectUnionTypes,
+            reusables,
+        };
+        const declarations = [];
+        if (configuration.features.has("ObjectSet")) {
+            declarations.push(new ObjectSetType(constructorParameters).declaration);
+        }
+        if (configuration.features.has("RdfjsDatasetObjectSet")) {
+            declarations.push(new RdfjsDatasetObjectSetType(constructorParameters).declaration);
+        }
+        if (configuration.features.has("SparqlObjectSet")) {
+            declarations.push(new SparqlObjectSetType(constructorParameters).declaration);
+        }
+        return declarations;
+    }
+    /**
+     * Synthesize the $Object union.
+     */
+    synthesizeUberObjectUnionType({ configuration, namedObjectTypes, reusables, }) {
+        const filteredNamedObjectTypes = namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern && !namedObjectType.synthetic);
+        invariant(filteredNamedObjectTypes.length > 0);
+        const nodeKinds = filteredNamedObjectTypes.reduce((nodeKinds, namedObjectType) => {
+            for (const nodeKind of namedObjectType.identifierType.nodeKinds) {
+                nodeKinds.add(nodeKind);
+            }
+            return nodeKinds;
+        }, new Set());
+        let identifierType;
+        if (nodeKinds.size === 2) {
+            identifierType = new IdentifierType({
+                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({
+                        name: Maybe.empty(),
+                        comment: Maybe.empty(),
+                        configuration,
+                        label: Maybe.empty(),
+                        logger: this.logger,
+                        reusables,
+                        shapeIdentifier: dataFactory.blankNode(),
+                    });
+                    break;
+                case "IRI":
+                    identifierType = new IriType({
+                        name: Maybe.empty(),
+                        comment: Maybe.empty(),
+                        configuration,
+                        hasValues: [],
+                        in_: [],
+                        label: Maybe.empty(),
+                        logger: this.logger,
+                        reusables,
+                        shapeIdentifier: dataFactory.blankNode(),
+                    });
+                    break;
+            }
+        }
+        return new ObjectUnionType({
+            name: Maybe.of(`${configuration.syntheticNamePrefix}Object`),
+            comment: Maybe.empty(),
+            configuration,
+            identifierType: Maybe.of(identifierType),
+            label: Maybe.empty(),
+            logger: this.logger,
+            members: filteredNamedObjectTypes.map((namedObjectType) => ({
+                discriminantValue: Maybe.empty(),
+                type: namedObjectType,
+            })),
+            recursive: false,
+            reusables,
+            shapeIdentifier: dataFactory.blankNode(),
+            synthetic: true,
+        });
+    }
+}
+(function (TsGenerator) {
+    let Configuration;
+    (function (Configuration) {
+        Configuration.default_ = {
+            features: new Set([
+                "Object.create",
+                "Object.equals",
+                "Object.hash",
+                "JSON",
+                "RDF",
+            ]),
+            syntheticNamePrefix: "$",
+        };
+        const featureDependenciesStatic = {
+            GraphQL: ["ObjectSet"],
+            // Alias for other features, not dependencies per se
+            JSON: ["Object.JSON"],
+            "Object.create": ["Object.schema", "Object.toString", "Object.type"],
+            "Object.equals": ["Object.type"],
+            "Object.filter": ["Object.type"],
+            "Object.fromJson": ["Object.create", "Object.JSON.type", "Object.type"],
+            "Object.fromRdf": ["Object.create", "Object.schema"],
+            "Object.hash": [],
+            // Alias for other features, not dependencies per se
+            "Object.JSON": [
+                "Object.fromJson",
+                "Object.JSON.parse",
+                "Object.JSON.schema",
+                "Object.JSON.type",
+                "Object.JSON.uiSchema",
+                "Object.toJson",
+            ],
+            "Object.JSON.parse": ["Object.JSON.schema", "Object.JSON.type"],
+            "Object.JSON.type": [],
+            "Object.JSON.schema": ["Object.JSON.type"],
+            "Object.JSON.uiSchema": [],
+            // Alias for other features, not dependencies per se
+            "Object.RDF": ["Object.fromRdf", "Object.toRdf"],
+            "Object.schema": [],
+            "Object.toJson": ["Object.JSON.type", "Object.type"],
+            "Object.toRdf": ["Object.schema", "Object.type"],
+            "Object.toString": ["Object.type"],
+            "Object.SPARQL": ["Object.schema"],
+            "Object.type": [], // Implies Object.Identifier
+            ObjectSet: ["Object.filter"],
+            // Alias for other features, not dependencies per se
+            RDF: ["Object.RDF", "RdfjsDatasetObjectSet"],
+            RdfjsDatasetObjectSet: ["Object.fromRdf", "ObjectSet"],
+            SPARQL: ["Object.SPARQL", "SparqlObjectSet"],
+            SparqlObjectSet: ["Object.SPARQL", "ObjectSet"],
+        };
+        function finalize(ast, partialConfiguration) {
+            const requestedFeatures = partialConfiguration?.features ?? Configuration.default_.features;
+            const featureDependencies = Object.fromEntries(Object.entries(featureDependenciesStatic).map(([k, v]) => [k, [...v]]));
+            if (ast.lazyTypesCount > 0) {
+                featureDependencies["Object.fromJson"].push("ObjectSet");
+                featureDependencies["Object.fromRdf"].push("ObjectSet", "RdfjsDatasetObjectSet");
+            }
+            const inferredFeatures = new Set(requestedFeatures);
+            {
+                const inferredFeaturesQueue = [...requestedFeatures];
+                while (inferredFeaturesQueue.length > 0) {
+                    const feature = inferredFeaturesQueue.shift();
+                    for (const featureDependency of featureDependencies[feature]) {
+                        if (!inferredFeatures.has(featureDependency)) {
+                            inferredFeatures.add(featureDependency);
+                            inferredFeaturesQueue.push(featureDependency);
+                        }
+                    }
+                }
+            }
+            return {
+                features: inferredFeatures,
+                finalized: true,
+                syntheticNamePrefix: partialConfiguration?.syntheticNamePrefix ??
+                    Configuration.default_.syntheticNamePrefix,
+            };
+        }
+        Configuration.finalize = finalize;
+    })(Configuration = TsGenerator.Configuration || (TsGenerator.Configuration = {}));
+})(TsGenerator || (TsGenerator = {}));
+//# sourceMappingURL=TsGenerator.js.map

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

@@ -0,0 +1,25 @@
+import type { BigDecimalType } from "./BigDecimalType.js";
+import type { BigIntType } from "./BigIntType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { BooleanType } from "./BooleanType.js";
+import type { DateTimeType } from "./DateTimeType.js";
+import type { DateType } from "./DateType.js";
+import type { DefaultValueType } from "./DefaultValueType.js";
+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 { 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";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { OptionType } from "./OptionType.js";
+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 | 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/Type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Type.js.map

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

@@ -0,0 +1,43 @@
+import type { Literal, NamedNode } from "@rdfjs/types";
+import type { Logger } from "ts-log";
+import * as ast from "../../ast/index.js";
+import { ObjectType } from "./ObjectType.js";
+import { ObjectUnionType } from "./ObjectUnionType.js";
+import type { Reusables } from "./Reusables.js";
+import type { TsGenerator } from "./TsGenerator.js";
+import type { Type } from "./Type.js";
+import { UnionType } from "./UnionType.js";
+export declare class TypeFactory {
+    private readonly configuration;
+    private readonly logger;
+    private readonly reusables;
+    private cachedObjectUnionTypesByShapeIdentifier;
+    private cachedObjectTypePropertiesByShapeIdentifier;
+    private cachedObjectTypesByShapeIdentifier;
+    constructor({ configuration, logger, reusables, }: {
+        configuration: TsGenerator.Configuration;
+        logger: Logger;
+        reusables: Reusables;
+    });
+    createObjectType(astType: ast.StructType): ObjectType;
+    createObjectUnionType(astType: ast.StructUnionType): ObjectUnionType;
+    createType(astType: ast.Type, parameters?: {
+        defaultValue?: Literal | NamedNode;
+    }): Type;
+    createUnionType(astType: ast.UnionType): ObjectUnionType | UnionType<Type>;
+    private createBlankNodeType;
+    private createDefaultValueType;
+    private createIdentifierType;
+    private createIriType;
+    private createLazyOptionType;
+    private createLazySetType;
+    private createLazyType;
+    private createListType;
+    private createLiteralType;
+    private createObjectTypeProperty;
+    private createOptionType;
+    private createSetType;
+    private createTermType;
+    private tsName;
+}
+//# sourceMappingURL=TypeFactory.d.ts.map