@shaclmate/compiler 3.0.3 → 4.0.0

package/dist/generators/ts/TsGenerator.js

@@ -1,100 +1,43 @@
-import { invariant } from "ts-invariant";
-import { Project, } from "ts-morph";
 import * as ast from "../../ast/index.js";
-import { Import } from "./Import.js";
-import { ObjectType } from "./ObjectType.js";
-import { ObjectUnionType } from "./ObjectUnionType.js";
-import { TypeFactory } from "./TypeFactory.js";
 import { graphqlSchemaVariableStatement } from "./graphqlSchemaVariableStatement.js";
 import { objectSetDeclarations } from "./objectSetDeclarations.js";
+// import { graphqlSchemaVariableStatement } from "./graphqlSchemaVariableStatement.js";
+// import { objectSetDeclarations } from "./objectSetDeclarations.js";
+import { snippets } from "./snippets.js";
+import { synthesizeUberObjectUnionType } from "./synthesizeUberObjectUnionType.js";
+// import { synthesizeUberObjectUnionType } from "./synthesizeUberObjectUnionType.js";
+import { TypeFactory } from "./TypeFactory.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
 export class TsGenerator {
     typeFactory = new TypeFactory();
     generate(ast_) {
-        const project = new Project({
-            useInMemoryFileSystem: true,
-        });
-        const sourceFile = project.createSourceFile("generated.ts");
-        this.addStatements({
-            objectTypes: ast.ObjectType.toposort(ast_.objectTypes).flatMap((astObjectType) => {
-                const type = this.typeFactory.createTypeFromAstType(astObjectType);
-                return type instanceof ObjectType ? [type] : [];
-            }),
-            objectUnionTypes: ast_.objectUnionTypes.flatMap((astObjectUnionType) => {
-                const type = this.typeFactory.createTypeFromAstType(astObjectUnionType);
-                return type instanceof ObjectUnionType ? [type] : [];
-            }),
-            sourceFile,
-        });
-        sourceFile.saveSync();
-        return project.getFileSystem().readFileSync(sourceFile.getFilePath());
-    }
-    addStatements({ objectTypes, objectUnionTypes, sourceFile, }) {
-        const declaredTypes = [
-            ...objectTypes,
-            ...objectUnionTypes,
-        ];
-        // Gather imports
-        const imports = [Import.DATA_FACTORY, Import.DATASET_FACTORY];
-        for (const declaredType of declaredTypes) {
-            imports.push(...declaredType.declarationImports);
+        const declarations = [];
+        const objectTypesToposorted = ast.ObjectType.toposort(ast_.objectTypes).map((astObjectType) => this.typeFactory.createObjectType(astObjectType));
+        const objectUnionTypesToposorted = ast_.objectUnionTypes.map((astObjectUnionType) => this.typeFactory.createObjectUnionType(astObjectUnionType));
+        for (const objectType of objectTypesToposorted) {
+            declarations.push(objectType.declaration);
         }
-        // Deduplicate and add imports
-        const stringImports = new Set();
-        const structureImports = [];
-        for (const import_ of imports) {
-            if (typeof import_ === "string") {
-                stringImports.add(import_);
-                continue;
-            }
-            const importWithSameModuleSpecifier = structureImports.find((structureImport) => structureImport.moduleSpecifier === import_.moduleSpecifier);
-            if (!importWithSameModuleSpecifier) {
-                structureImports.push(import_);
-                continue;
-            }
-            // Merge named imports
-            invariant(!import_.namespaceImport);
-            invariant(Array.isArray(import_.namedImports) &&
-                import_.namedImports.every((value) => typeof value === "string"));
-            invariant(!importWithSameModuleSpecifier.namespaceImport);
-            invariant(Array.isArray(importWithSameModuleSpecifier.namedImports) &&
-                importWithSameModuleSpecifier.namedImports.every((value) => typeof value === "string"));
-            for (const newNamedImport of import_.namedImports) {
-                if (!importWithSameModuleSpecifier.namedImports.includes(newNamedImport)) {
-                    importWithSameModuleSpecifier.namedImports.push(newNamedImport);
-                }
-            }
+        for (const objectUnionType of objectUnionTypesToposorted) {
+            declarations.push(objectUnionType.declaration);
         }
-        sourceFile.addStatements([...stringImports]);
-        sourceFile.addStatements(structureImports);
-        // Deduplicate and add snippet declarations
-        const addedSnippetDeclarations = new Set();
-        for (const declaredType of declaredTypes) {
-            for (const snippetDeclaration of declaredType.snippetDeclarations({
-                features: declaredType.features,
-                recursionStack: [],
-            })) {
-                if (!addedSnippetDeclarations.has(snippetDeclaration)) {
-                    sourceFile.addStatements([snippetDeclaration]);
-                    addedSnippetDeclarations.add(snippetDeclaration);
-                }
-            }
-        }
-        for (const objectType of objectTypes) {
-            sourceFile.addStatements(objectType.declarations);
-        }
-        for (const objectUnionType of objectUnionTypes) {
-            sourceFile.addStatements(objectUnionType.declarations);
-        }
-        const objectTypesSortedByName = objectTypes.toSorted((left, right) => left.name.localeCompare(right.name));
-        const objectUnionTypesSortedByName = objectUnionTypes.toSorted((left, right) => left.name.localeCompare(right.name));
-        sourceFile.addStatements(objectSetDeclarations({
-            objectTypes: objectTypesSortedByName,
-            objectUnionTypes: objectUnionTypesSortedByName,
+        const objectTypesNameSorted = objectTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
+        const objectUnionTypesNameSorted = objectUnionTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
+        const uberObjectUnionType = synthesizeUberObjectUnionType({
+            objectTypes: objectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
+        });
+        declarations.push(uberObjectUnionType.declaration);
+        declarations.push(...objectSetDeclarations({
+            objectTypes: objectTypesNameSorted,
+            objectUnionTypes: objectUnionTypesNameSorted.concat(uberObjectUnionType),
         }));
-        sourceFile.addVariableStatements(graphqlSchemaVariableStatement({
-            objectTypes: objectTypesSortedByName,
-            objectUnionTypes: objectUnionTypesSortedByName,
+        declarations.push(...graphqlSchemaVariableStatement({
+            objectTypes: objectTypesNameSorted,
+            objectUnionTypes: objectUnionTypesNameSorted.concat(uberObjectUnionType),
         }).toList());
+        declarations.splice(0, 0, joinCode(Object.values(snippets)
+            .sort((left, right) => left.usageSiteName.localeCompare(right.usageSiteName))
+            .map((snippet) => code `${snippet.ifUsed}`), { on: "\n\n" }));
+        return joinCode(declarations).toString({});
     }
 }
 //# sourceMappingURL=TsGenerator.js.map

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

@@ -1,246 +1,25 @@
-import type { Maybe } from "purify-ts";
-import type { TsFeature } from "../../enums/index.js";
-import type { Import } from "./Import.js";
-/**
- * Abstract base class for generating TypeScript expressions and statemenst in the TypeScript generator.
- *
- * Subclasses are used for both property types (c.f., property* methods) and node/object types.
- */
-export declare abstract class Type {
-    /**
-     * Expressions that convert a source type or types to this type. It should include the type itself.
-     */
-    abstract readonly conversions: readonly Type.Conversion[];
-    /**
-     * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
-     */
-    abstract readonly discriminatorProperty: Maybe<Type.DiscriminatorProperty>;
-    /**
-     * A function (reference or declaration) that compares two property values of this type, returning a
-     * $EqualsResult.
-     */
-    abstract readonly equalsFunction: string;
-    /**
-     * GraphQL-compatible version of the type.
-     */
-    abstract readonly graphqlName: Type.GraphqlName;
-    /**
-     * JSON-compatible version of the type.
-     */
-    abstract readonly jsonName: Type.JsonName;
-    /**
-     * Is a value of this type mutable?
-     */
-    abstract readonly mutable: boolean;
-    /**
-     * TypeScript name of the type.
-     */
-    abstract readonly name: string;
-    /**
-     * JavaScript typeof the type.
-     */
-    abstract readonly typeof: "boolean" | "object" | "number" | "string";
-    /**
-     * An expression that converts this type's JSON type to a value of this type. It doesn't return a purify.Either because the JSON has
-     * already been validated and converted to the expected JSON type with Zod.
-     */
-    abstract fromJsonExpression(parameters: {
-        variables: {
-            value: string;
-        };
-    }): string;
-    /**
-     * An expression that converts a purify.Either<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>> to a
-     * purify.Either<Error, rdfjsResource.Resource.Values<this type>>.
-     *
-     * Some types need to filter on the set of all objects/values of a (subject, predicate). For example, all sh:hasValue values must be present in the set for any values
-     * to be considered valid. Similar
-     *
-     * Values may also need to be sorted. For example, specifying preferredLanguages should sort the values in the order of the specified languages so that the first value
-     * (if it exists) is always of the first preferred language.
-     */
-    abstract fromRdfExpression(parameters: {
-        variables: {
-            context: string;
-            ignoreRdfType?: boolean;
-            objectSet: string;
-            preferredLanguages: string;
-            predicate: string;
-            resource: string;
-            resourceValues: string;
-        };
-    }): string;
-    /**
-     * An expression that resolves a value of this type in the GraphQL server.
-     */
-    abstract graphqlResolveExpression(parameters: {
-        variables: {
-            args: string;
-            value: string;
-        };
-    }): string;
-    /**
-     * Statements that use hasher.update to hash a property value of this type.
-     */
-    abstract hashStatements(parameters: {
-        depth: number;
-        variables: {
-            hasher: string;
-            value: string;
-        };
-    }): readonly string[];
-    /**
-     * Element object for a JSON Forms UI schema.
-     */
-    abstract jsonUiSchemaElement(parameters: {
-        variables: {
-            scopePrefix: string;
-        };
-    }): Maybe<string>;
-    /**
-     * Zod schema for the JSON type of this type.
-     *
-     * This method is called in two contexts:
-     * "property": from a ShaclProperty, while generating the z.object properties of an ObjectType
-     * "type": from another Type e.g., an OptionType or UnionType
-     *
-     * z.lazy() should only be returned for "property".
-     */
-    abstract jsonZodSchema(parameters: {
-        context: "property" | "type";
-        variables: {
-            zod: string;
-        };
-    }): string;
-    /**
-     * Reusable function, type, and other declarations that are not particular to this type but that type-specific code
-     * relies on. For example, the equals function/method of ObjectType has a custom return type that's the same across all
-     * ObjectType's. Instead of re-declaring the return type anonymously on every equals function, declare a named type
-     * as a snippet and reference it.
-     *
-     * The generator deduplicates snippet declarations across all types before adding them to the source.
-     */
-    abstract snippetDeclarations(parameters: {
-        features: Set<TsFeature>;
-        recursionStack: Type[];
-    }): readonly string[];
-    /**
-     * An array of SPARQL.js CONSTRUCT template triples for a value of this type, as strings (so they can incorporate runtime calls).
-     *
-     * This method is called in two contexts:
-     * (1) When an instance of the type is an "object" of a property.
-     *     This method should return a BGP (variables.subject, variables.predicate, variables.object) and recursively call itself with the variables.object as a "subject" context.
-     * (2) When an instance of the type is a "subject".
-     *     For example, ListType calls this method to with the item variable as a subject in order to chain additional patterns on items. Term types with no additional patterns should return an empty array.
-     */
-    sparqlConstructTemplateTriples({ allowIgnoreRdfType, context, variables, }: {
-        allowIgnoreRdfType: boolean;
-        context: "object";
-        variables: {
-            object: string;
-            predicate: string;
-            subject: string;
-            variablePrefix: string;
-        };
-    } | {
-        allowIgnoreRdfType: boolean;
-        context: "subject";
-        variables: {
-            subject: string;
-            variablePrefix: string;
-        };
-    }): readonly string[];
-    /**
-     * An array of SPARQL.js where patterns for a value of this type, as strings (so they can incorporate runtime calls).
-     *
-     * See note in sparqlConstructTemplateTriples re: how this method is used.
-     */
-    sparqlWherePatterns({ allowIgnoreRdfType, context, variables, }: {
-        allowIgnoreRdfType: boolean;
-        context: "object";
-        variables: {
-            object: string;
-            predicate: string;
-            preferredLanguages: string;
-            subject: string;
-            variablePrefix: string;
-        };
-    } | {
-        allowIgnoreRdfType: boolean;
-        context: "subject";
-        variables: {
-            preferredLanguages: string;
-            subject: string;
-            variablePrefix: string;
-        };
-    }): readonly string[];
-    /**
-     * An expression that converts a value of this type to a JSON-LD compatible value. It can assume the presence
-     * of the correct JSON-LD context.
-     */
-    abstract toJsonExpression(parameters: {
-        variables: {
-            value: string;
-        };
-    }): string;
-    /**
-     * An expression that converts a property value of this type to an array of values that can be .add'd to a rdfjsResource.MutableResource
-     * (BlankNode | Literal | NamedNode | boolean | number | string)[].
-     */
-    abstract toRdfExpression(parameters: {
-        variables: {
-            predicate: string;
-            mutateGraph: string;
-            resource: string;
-            resourceSet: string;
-            value: string;
-        };
-    }): string;
-    /**
-     * Imports necessary to use this type.
-     */
-    abstract useImports(parameters: {
-        features: Set<TsFeature>;
-    }): readonly Import[];
-}
-export declare namespace Type {
-    interface Conversion {
-        readonly conversionExpression: (value: string) => string;
-        readonly sourceTypeCheckExpression: (value: string) => string;
-        readonly sourceTypeName: string;
-    }
-    interface DiscriminatorProperty {
-        readonly name: string;
-        readonly ownValues: readonly string[];
-        readonly descendantValues: readonly string[];
-    }
-    class JsonName {
-        /**
-         * Is the type optional in JSON? Equivalent to ? in TypeScript or | undefined.
-         */
-        readonly optional: boolean;
-        /**
-         * The name of the type when it's required i.e. -- so it should never include "| undefined".
-         */
-        readonly requiredName: string;
-        constructor(requiredName: string, parameters?: {
-            optional: boolean;
-        });
-        toString(): string;
-    }
-    class GraphqlName {
-        /**
-         * Is the type nullable in GraphQL?
-         */
-        readonly nullable: boolean;
-        /**
-         * The name of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
-         */
-        readonly nullableName: string;
-        constructor(nullableName: string, parameters?: {
-            nullable: boolean;
-        });
-        toString(): string;
-    }
-}
+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 { LazyObjectOptionType } from "./LazyObjectOptionType.js";
+import type { LazyObjectSetType } from "./LazyObjectSetType.js";
+import type { LazyObjectType } from "./LazyObjectType.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 | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType<ListType.ItemType> | LiteralType | ObjectType | ObjectUnionType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType | UnionType;
 //# sourceMappingURL=Type.d.ts.map

package/dist/generators/ts/Type.js

@@ -1,122 +1,2 @@
-import { invariant } from "ts-invariant";
-import { objectInitializer } from "./objectInitializer.js";
-/**
- * Abstract base class for generating TypeScript expressions and statemenst in the TypeScript generator.
- *
- * Subclasses are used for both property types (c.f., property* methods) and node/object types.
- */
-export class Type {
-    /**
-     * An array of SPARQL.js CONSTRUCT template triples for a value of this type, as strings (so they can incorporate runtime calls).
-     *
-     * This method is called in two contexts:
-     * (1) When an instance of the type is an "object" of a property.
-     *     This method should return a BGP (variables.subject, variables.predicate, variables.object) and recursively call itself with the variables.object as a "subject" context.
-     * (2) When an instance of the type is a "subject".
-     *     For example, ListType calls this method to with the item variable as a subject in order to chain additional patterns on items. Term types with no additional patterns should return an empty array.
-     */
-    sparqlConstructTemplateTriples({ allowIgnoreRdfType, context, variables, }) {
-        switch (context) {
-            case "object": {
-                const objectPrefix = "dataFactory.variable!(";
-                const objectSuffix = ")";
-                invariant(variables.object.startsWith(objectPrefix));
-                invariant(variables.object.endsWith(objectSuffix));
-                return [
-                    objectInitializer({
-                        object: variables.object,
-                        predicate: variables.predicate,
-                        subject: variables.subject,
-                    }),
-                ].concat(this.sparqlConstructTemplateTriples({
-                    allowIgnoreRdfType,
-                    context: "subject",
-                    variables: {
-                        subject: variables.object,
-                        variablePrefix: variables.object.substring(objectPrefix.length, variables.object.length - objectSuffix.length),
-                    },
-                }));
-            }
-            case "subject":
-                return [];
-        }
-    }
-    /**
-     * An array of SPARQL.js where patterns for a value of this type, as strings (so they can incorporate runtime calls).
-     *
-     * See note in sparqlConstructTemplateTriples re: how this method is used.
-     */
-    sparqlWherePatterns({ allowIgnoreRdfType, context, variables, }) {
-        switch (context) {
-            case "object": {
-                const objectPrefix = "dataFactory.variable!(";
-                const objectSuffix = ")";
-                invariant(variables.object.startsWith(objectPrefix));
-                invariant(variables.object.endsWith(objectSuffix));
-                return [
-                    objectInitializer({
-                        triples: `[${objectInitializer({
-                            object: variables.object,
-                            predicate: variables.predicate,
-                            subject: variables.subject,
-                        })}]`,
-                        type: '"bgp"',
-                    }),
-                ].concat(this.sparqlWherePatterns({
-                    allowIgnoreRdfType,
-                    context: "subject",
-                    variables: {
-                        preferredLanguages: variables.preferredLanguages,
-                        subject: variables.object,
-                        variablePrefix: variables.object.substring(objectPrefix.length, variables.object.length - objectSuffix.length),
-                    },
-                }));
-            }
-            case "subject":
-                return [];
-        }
-    }
-}
-(function (Type) {
-    class JsonName {
-        /**
-         * Is the type optional in JSON? Equivalent to ? in TypeScript or | undefined.
-         */
-        optional;
-        /**
-         * The name of the type when it's required i.e. -- so it should never include "| undefined".
-         */
-        requiredName;
-        constructor(requiredName, parameters) {
-            this.optional = !!parameters?.optional;
-            this.requiredName = requiredName;
-        }
-        toString() {
-            return this.optional
-                ? `(${this.requiredName}) | undefined`
-                : this.requiredName;
-        }
-    }
-    Type.JsonName = JsonName;
-    class GraphqlName {
-        /**
-         * Is the type nullable in GraphQL?
-         */
-        nullable;
-        /**
-         * The name of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
-         */
-        nullableName;
-        constructor(nullableName, parameters) {
-            this.nullable = !!parameters?.nullable;
-            this.nullableName = nullableName;
-        }
-        toString() {
-            return this.nullable
-                ? this.nullableName
-                : `new graphql.GraphQLNonNull(${this.nullableName})`;
-        }
-    }
-    Type.GraphqlName = GraphqlName;
-})(Type || (Type = {}));
+export {};
 //# sourceMappingURL=Type.js.map

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

@@ -1,21 +1,30 @@
+import type { Literal, NamedNode } from "@rdfjs/types";
 import type * as ast from "../../ast/index.js";
 import { ObjectType } from "./ObjectType.js";
+import { ObjectUnionType } from "./ObjectUnionType.js";
 import type { Type } from "./Type.js";
 export declare class TypeFactory {
-    private cachedBooleanType;
-    private cachedDateType;
-    private cachedDateTimeType;
-    private cachedFloatType;
-    private cachedIdentifierType;
-    private cachedIntType;
-    private cachedNamedIdentifierType;
-    private cachedObjectTypePropertiesByIdentifier;
-    private cachedObjectTypesByIdentifier;
-    private cachedObjectUnionTypesByIdentifier;
-    private cachedStringType;
-    createObjectTypeFromAstType(astType: ast.ObjectType): ObjectType;
-    createTypeFromAstType(astType: ast.Type): Type;
-    private createObjectTypePropertyFromAstProperty;
-    private createObjectUnionTypeFromAstType;
+    private cachedObjectTypePropertiesByShapeIdentifier;
+    private cachedObjectTypesByShapeIdentifier;
+    private cachedObjectUnionTypesByShapeIdentifier;
+    createObjectType(astType: ast.ObjectType): ObjectType;
+    createObjectUnionType(astType: ast.ObjectUnionType): ObjectUnionType;
+    createType(astType: ast.Type, parameters?: {
+        defaultValue?: Literal | NamedNode;
+    }): Type;
+    private createBlankNodeType;
+    private createDefaultValueType;
+    private createIdentifierType;
+    private createIriType;
+    private createLazyObjectOptionType;
+    private createLazyObjectSetType;
+    private createLazyObjectType;
+    private createListType;
+    private createLiteralType;
+    private createObjectTypeProperty;
+    private createOptionType;
+    private createSetType;
+    private createTermType;
+    private createUnionType;
 }
 //# sourceMappingURL=TypeFactory.d.ts.map