@shaclmate/compiler 2.0.13 → 2.0.14

package/generators/ts/TsGenerator.js

@@ -1,119 +1,63 @@
-import { Project, StructureKind, } from "ts-morph";
-import { Configuration as GlobalConfiguration } from "./Configuration.js";
+import { Project, } from "ts-morph";
+import * as ast from "../../ast/index.js";
+import { ObjectType } from "./ObjectType.js";
+import { ObjectUnionType } from "./ObjectUnionType.js";
 import { TypeFactory } from "./TypeFactory.js";
-import { tsName } from "./tsName.js";
 export class TsGenerator {
-    constructor(ast, configuration) {
-        this.ast = ast;
-        this.configuration = configuration ?? new TsGenerator.Configuration();
-    }
-    generate() {
-        const astObjectTypes = this.ast.objectTypes.concat();
-        astObjectTypes.sort((left, right) => {
-            if (left.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.name.identifier.equals(right.name.identifier))) {
-                // Right is an ancestor of left, right must come first
-                return 1;
-            }
-            if (right.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.name.identifier.equals(left.name.identifier))) {
-                // Left is an ancestor of right, left must come first
-                return -1;
-            }
-            // Neither is an ancestor of the other, sort by name
-            return tsName(left.name).localeCompare(tsName(right.name));
-        });
+    generate(ast_) {
+        const sortedAstObjectTypes = ast.ObjectType.toposort(ast_.objectTypes);
         const project = new Project({
             useInMemoryFileSystem: true,
         });
         const sourceFile = project.createSourceFile("generated.ts");
-        const typeFactory = new TypeFactory({ configuration: this.configuration });
-        const objectTypes = astObjectTypes.flatMap((astObjectType) => {
-            const type = typeFactory.createTypeFromAstType(astObjectType);
-            return type.kind === "ObjectType" ? [type] : [];
+        const typeFactory = new TypeFactory({
+            dataFactoryVariable: ast_.tsDataFactoryVariable,
+        });
+        this.addDeclarations({
+            objectTypes: sortedAstObjectTypes.flatMap((astObjectType) => {
+                const type = typeFactory.createTypeFromAstType(astObjectType);
+                return type instanceof ObjectType ? [type] : [];
+            }),
+            objectUnionTypes: ast_.objectUnionTypes.flatMap((astObjectUnionType) => {
+                const type = typeFactory.createTypeFromAstType(astObjectUnionType);
+                return type instanceof ObjectUnionType ? [type] : [];
+            }),
+            sourceFile,
         });
-        this.addDeclarations(objectTypes, sourceFile);
         sourceFile.saveSync();
         return project.getFileSystem().readFileSync(sourceFile.getFilePath());
     }
-    addDeclarations(objectTypes, sourceFile) {
-        this.addImportDeclarations(objectTypes, sourceFile);
-        for (const objectType of objectTypes) {
-            switch (this.configuration.objectTypeDeclarationType) {
-                case "class":
-                    sourceFile.addClass(objectType.classDeclaration());
-                    break;
-                case "interface":
-                    sourceFile.addInterface(objectType.interfaceDeclaration());
-                    break;
-            }
-            const moduleStatements = [];
-            if (this.configuration.features.has("equals") &&
-                this.configuration.objectTypeDeclarationType === "interface") {
-                moduleStatements.push(objectType.equalsFunctionDeclaration());
-            }
-            if (this.configuration.features.has("fromRdf")) {
-                moduleStatements.push(objectType.fromRdfFunctionDeclaration());
-            }
-            if (this.configuration.features.has("hash")) {
-                moduleStatements.push(objectType.hashFunctionDeclaration());
-            }
-            if (this.configuration.features.has("sparql-graph-patterns")) {
-                if (objectType.parentObjectTypes.length > 1) {
-                    throw new RangeError(`object type '${objectType.name}' has multiple super object types, can't use with SPARQL graph patterns`);
+    addDeclarations({ objectTypes, objectUnionTypes, sourceFile, }) {
+        // sourceFile.addStatements(this.configuration.dataFactoryImport);
+        sourceFile.addStatements('import { DataFactory as dataFactory } from "n3"');
+        // Gather imports
+        const imports = [];
+        for (const declaredType of [...objectTypes, ...objectUnionTypes]) {
+            imports.push(...declaredType.declarationImports);
+        }
+        // Deduplicate and add imports
+        const addedStringImports = new Set();
+        const addedStructureImports = [];
+        for (const import_ of imports) {
+            if (typeof import_ === "string") {
+                if (!addedStringImports.has(import_)) {
+                    sourceFile.addStatements([import_]);
                 }
-                moduleStatements.push(objectType.sparqlGraphPatternsClassDeclaration());
+                addedStringImports.add(import_);
+                continue;
             }
-            if (this.configuration.features.has("toRdf") &&
-                this.configuration.objectTypeDeclarationType === "interface") {
-                moduleStatements.push(objectType.toRdfFunctionDeclaration());
+            if (!addedStructureImports.find((addedStructureImport) => addedStructureImport.moduleSpecifier === import_.moduleSpecifier)) {
+                sourceFile.addStatements([import_]);
+                addedStructureImports.push(import_);
             }
-            sourceFile.addModule({
-                isExported: objectType.export_,
-                kind: StructureKind.Module,
-                name: objectType.name,
-                statements: moduleStatements,
-            });
-        }
-    }
-    addImportDeclarations(objectTypes, sourceFile) {
-        sourceFile.addImportDeclaration({
-            moduleSpecifier: "purify-ts",
-            namespaceImport: "purify",
-        });
-        sourceFile.addImportDeclaration({
-            isTypeOnly: true,
-            moduleSpecifier: "@rdfjs/types",
-            namespaceImport: "rdfjs",
-        });
-        sourceFile.addStatements(this.configuration.dataFactoryImport);
-        if (this.configuration.features.has("equals")) {
-            sourceFile.addImportDeclaration({
-                moduleSpecifier: "purify-ts-helpers",
-                namespaceImport: "purifyHelpers",
-            });
         }
-        if (this.configuration.features.has("fromRdf") ||
-            this.configuration.features.has("toRdf")) {
-            sourceFile.addImportDeclaration({
-                moduleSpecifier: "rdfjs-resource",
-                namespaceImport: "rdfjsResource",
-            });
-        }
-        if (this.configuration.features.has("sparql-graph-patterns")) {
-            sourceFile.addImportDeclaration({
-                moduleSpecifier: "@kos-kit/sparql-builder",
-                namespaceImport: "sparqlBuilder",
-            });
-        }
-        const typeImportStatements = new Set();
+        // Add type declarations
         for (const objectType of objectTypes) {
-            for (const importStatement of objectType.importStatements) {
-                typeImportStatements.add(importStatement);
-            }
+            sourceFile.addStatements(objectType.declarations);
+        }
+        for (const objectUnionType of objectUnionTypes) {
+            sourceFile.addStatements(objectUnionType.declarations);
         }
-        sourceFile.addStatements([...typeImportStatements]);
     }
 }
-(function (TsGenerator) {
-    TsGenerator.Configuration = GlobalConfiguration;
-})(TsGenerator || (TsGenerator = {}));
 //# sourceMappingURL=TsGenerator.js.map

package/generators/ts/Type.d.ts

@@ -1,73 +1,147 @@
+import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import type * as ast from "../../ast";
-import type { Configuration } from "./Configuration.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 {
-    abstract readonly kind: ast.Type["kind"] | "ListType";
-    abstract readonly name: string;
-    protected readonly configuration: Configuration;
-    constructor({ configuration, }: {
-        configuration: Configuration;
-    });
     /**
      * Expressions that convert a source type or types to this type. It should include the type itself.
      */
-    get conversions(): readonly Type.Conversion[];
+    abstract readonly conversions: readonly Type.Conversion[];
     /**
-     * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
+     * A function (reference or declaration) that compares two property values of this type, returning a
+     * purifyHelpers.Equatable.EqualsResult.
      */
-    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    abstract readonly equalsFunction: string;
     /**
-     * Imports used by other methods on this type.
+     * JSON-compatible returned by propertyToJsonExpression.
      */
-    get importStatements(): readonly string[];
+    abstract readonly jsonName: string;
     /**
-     * An optional sparqlBuilder.GraphPattern expression that's chained to the object of another pattern, such as a list item.
-     *
-     * If the type is e.g., an RDF/JS term it won't have additional graph patterns beyond the basic (s, p, o), and this
-     * method will return nothing.
+     * Is a value of this type mutable?
      */
-    chainSparqlGraphPatternExpression(_: {
-        variables: {
-            subject: string;
-        };
-    }): Maybe<Type.SparqlGraphPatternExpression | Type.SparqlGraphPatternsExpression>;
+    abstract readonly mutable: boolean;
     /**
-     * A function (reference or declaration) that compares two values of this type, returning a
-     * purifyHelpers.Equatable.EqualsResult.
+     * Name of the type.
+     */
+    abstract readonly name: string;
+    /**
+     * Imports necessary to use this type.
+     */
+    abstract readonly useImports: readonly Import[];
+    protected readonly dataFactoryVariable: string;
+    constructor({ dataFactoryVariable, }: {
+        dataFactoryVariable: string;
+    });
+    /**
+     * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
      */
-    abstract equalsFunction(): string;
+    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    /**
+     * An expression that converts a JSON object in the same format as the propertyToJsonExpression to a value of this type.
+     */
+    abstract fromJsonExpression(parameters: {
+        variables: {
+            value: string;
+        };
+    }): string;
     /**
      * An expression that converts a rdfjsResource.Resource.Values to an Either of value/values
-     * of this type.
+     * of this type for a property.
      */
     abstract fromRdfExpression(parameters: {
         variables: {
+            context: string;
+            languageIn: string;
             predicate: string;
             resource: string;
             resourceValues: string;
         };
     }): string;
     /**
-     * Statements that use hasher.update to hash a value of this type.
+     * 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[];
     /**
-     * An sparqlBuilder.GraphPattern expression for a property, typically building a basic graph pattern.
+     * Element object for a JSON Forms UI schema.
      */
-    propertySparqlGraphPatternExpression({ variables, }: {
+    jsonUiSchemaElement(_parameters: {
+        variables: {
+            scopePrefix: string;
+        };
+    }): Maybe<string>;
+    /**
+     * Zod schema for the JSON version of the type (the result of propertyToJson).
+     */
+    abstract jsonZodSchema(parameters: {
+        variables: {
+            zod: string;
+        };
+    }): 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) By an ObjectType.Property. The property expects a basic graph pattern (subject, property path, property object). The property calls this method to get additional triples in which the propertyObject is the subject. For example, if the type is a nested object, it would include (propertyObject, nestedPredicate, nestedObject) triples.
+     * (2) By another Type. 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 properties should return an empty array.
+     */
+    sparqlConstructTemplateTriples({ context, variables, }: {
+        context: "property";
         variables: {
             object: string;
             predicate: string;
             subject: string;
+            variablePrefix: string;
+        };
+    } | {
+        context: "type";
+        variables: {
+            subject: string;
+            variablePrefix: string;
         };
-    }): Type.SparqlGraphPatternExpression | Type.SparqlGraphPatternsExpression;
+    }): readonly string[];
     /**
-     * An expression that converts a value of this type to one that that can be .add'd to
+     * 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({ context, variables, }: {
+        context: "property";
+        variables: {
+            object: string;
+            predicate: string;
+            subject: string;
+            variablePrefix: string;
+        };
+    } | {
+        context: "type";
+        variables: {
+            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 one that that can be .add'd to
      * an rdfjsResource.Resource.
      */
     abstract toRdfExpression(parameters: {
@@ -79,30 +153,17 @@ export declare abstract class Type {
             value: string;
         };
     }): string;
+    protected rdfjsTermExpression(rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">): string;
 }
 export declare namespace Type {
     interface Conversion {
         readonly conversionExpression: (value: string) => string;
-        readonly sourceTypeCheckExpression?: (value: string) => string;
+        readonly sourceTypeCheckExpression: (value: string) => string;
         readonly sourceTypeName: string;
     }
     interface DiscriminatorProperty {
         readonly name: string;
         readonly values: readonly string[];
     }
-    class SparqlGraphPatternExpression {
-        private readonly value;
-        constructor(value: string);
-        toSparqlGraphPatternExpression(): this;
-        toSparqlGraphPatternsExpression(): SparqlGraphPatternExpression;
-        toString(): string;
-    }
-    class SparqlGraphPatternsExpression {
-        private readonly value;
-        constructor(value: string);
-        toSparqlGraphPatternExpression(): SparqlGraphPatternExpression;
-        toSparqlGraphPatternsExpression(): this;
-        toString(): string;
-    }
 }
 //# sourceMappingURL=Type.d.ts.map

package/generators/ts/Type.js

@@ -1,18 +1,15 @@
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { rdfjsTermExpression } from "./_ObjectType/rdfjsTermExpression.js";
+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 {
-    constructor({ configuration, }) {
-        this.configuration = configuration;
-    }
-    /**
-     * Expressions that convert a source type or types to this type. It should include the type itself.
-     */
-    get conversions() {
-        return [
-            {
-                conversionExpression: (value) => value,
-                sourceTypeName: this.name,
-            },
-        ];
+    constructor({ dataFactoryVariable, }) {
+        this.dataFactoryVariable = dataFactoryVariable;
     }
     /**
      * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
@@ -21,63 +18,83 @@ export class Type {
         return Maybe.empty();
     }
     /**
-     * Imports used by other methods on this type.
+     * Element object for a JSON Forms UI schema.
      */
-    get importStatements() {
-        return [];
+    jsonUiSchemaElement(_parameters) {
+        return Maybe.empty();
     }
     /**
-     * An optional sparqlBuilder.GraphPattern expression that's chained to the object of another pattern, such as a list item.
+     * 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) By an ObjectType.Property. The property expects a basic graph pattern (subject, property path, property object). The property calls this method to get additional triples in which the propertyObject is the subject. For example, if the type is a nested object, it would include (propertyObject, nestedPredicate, nestedObject) triples.
+     * (2) By another Type. For example, ListType calls this method to with the item variable as a subject in order to chain additional patterns on items.
      *
-     * If the type is e.g., an RDF/JS term it won't have additional graph patterns beyond the basic (s, p, o), and this
-     * method will return nothing.
+     * Term types with no additional properties should return an empty array.
      */
-    chainSparqlGraphPatternExpression(_) {
-        return Maybe.empty();
+    sparqlConstructTemplateTriples({ context, variables, }) {
+        switch (context) {
+            case "property": {
+                const objectPrefix = `${this.dataFactoryVariable}.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({
+                    context: "type",
+                    variables: {
+                        subject: variables.object,
+                        variablePrefix: variables.object.substring(objectPrefix.length, variables.object.length - objectSuffix.length),
+                    },
+                }));
+            }
+            case "type":
+                return [];
+        }
     }
     /**
-     * An sparqlBuilder.GraphPattern expression for a property, typically building a basic graph pattern.
+     * 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.
      */
-    propertySparqlGraphPatternExpression({ variables, }) {
-        let expression = `sparqlBuilder.GraphPattern.basic(${variables.subject}, ${variables.predicate}, ${variables.object})`;
-        this.chainSparqlGraphPatternExpression({
-            variables: { subject: "object" },
-        }).ifJust((chainSparqlGraphPatternExpression) => {
-            expression = `sparqlBuilder.GraphPattern.group(${expression}.chainObject(object => ${chainSparqlGraphPatternExpression.toSparqlGraphPatternsExpression()}))`;
-        });
-        return new Type.SparqlGraphPatternExpression(expression);
-    }
-}
-(function (Type) {
-    class SparqlGraphPatternExpression {
-        constructor(value) {
-            this.value = value;
-        }
-        toSparqlGraphPatternExpression() {
-            return this;
-        }
-        toSparqlGraphPatternsExpression() {
-            return new SparqlGraphPatternExpression(`[${this.value}]`);
-        }
-        toString() {
-            return this.value;
+    sparqlWherePatterns({ context, variables, }) {
+        switch (context) {
+            case "property": {
+                const objectPrefix = `${this.dataFactoryVariable}.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({
+                    context: "type",
+                    variables: {
+                        subject: variables.object,
+                        variablePrefix: variables.object.substring(objectPrefix.length, variables.object.length - objectSuffix.length),
+                    },
+                }));
+            }
+            case "type":
+                return [];
         }
     }
-    Type.SparqlGraphPatternExpression = SparqlGraphPatternExpression;
-    class SparqlGraphPatternsExpression {
-        constructor(value) {
-            this.value = value;
-        }
-        toSparqlGraphPatternExpression() {
-            return new SparqlGraphPatternExpression(`sparqlBuilder.GraphPattern.group(${this.value})`);
-        }
-        toSparqlGraphPatternsExpression() {
-            return this;
-        }
-        toString() {
-            return this.value;
-        }
+    rdfjsTermExpression(rdfjsTerm) {
+        return rdfjsTermExpression({
+            dataFactoryVariable: this.dataFactoryVariable,
+            rdfjsTerm,
+        });
     }
-    Type.SparqlGraphPatternsExpression = SparqlGraphPatternsExpression;
-})(Type || (Type = {}));
+}
 //# sourceMappingURL=Type.js.map

package/generators/ts/TypeFactory.d.ts

@@ -1,12 +1,11 @@
-import type * as ast from "../../ast";
-import type { Configuration } from "./Configuration";
+import type * as ast from "../../ast/index.js";
 import type { Type } from "./Type.js";
 export declare class TypeFactory {
     private cachedObjectTypePropertiesByIdentifier;
     private cachedObjectTypesByIdentifier;
-    private readonly configuration;
-    constructor({ configuration }: {
-        configuration: Configuration;
+    private readonly dataFactoryVariable;
+    constructor({ dataFactoryVariable }: {
+        dataFactoryVariable: string;
     });
     createTypeFromAstType(astType: ast.Type): Type;
     private createObjectTypeFromAstType;