@shaclmate/compiler 2.0.12

package/generators/ts/RdfjsTermType.js

@@ -0,0 +1,46 @@
+import { Type } from "./Type.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression";
+/**
+ * Abstract base class for IdentifierType and LiteralType.
+ */
+export class RdfjsTermType extends Type {
+    constructor({ defaultValue, hasValue, ...superParameters }) {
+        super(superParameters);
+        this.defaultValue = defaultValue;
+        this.hasValue = hasValue;
+    }
+    equalsFunction() {
+        return "purifyHelpers.Equatable.booleanEquals";
+    }
+    fromRdfExpression({ variables, }) {
+        const chain = [`${variables.resourceValues}.head()`];
+        this.hasValue.ifJust((hasValue) => {
+            chain.push(`chain<rdfjsResource.Resource.ValueError, ${this.name}>(_identifier => _identifier.equals(${rdfjsTermExpression(hasValue, this.configuration)}) ? purify.Either.of(_identifier) : purify.Left(new rdfjsResource.Resource.MistypedValueError({ actualValue: _identifier, expectedValueType: "${hasValue.termType}", focusResource: ${variables.resource}, predicate: ${variables.predicate})))`);
+        });
+        this.defaultValue.ifJust((defaultValue) => {
+            chain.push(`alt(purify.Either.of(new rdfjsResource.Resource.Value({ subject: ${variables.resource}, predicate: ${variables.predicate}, object: ${rdfjsTermExpression(defaultValue, this.configuration)} })))`);
+        });
+        chain.push(`chain(value => ${this.fromRdfResourceValueExpression({
+            variables: { resourceValue: "value" },
+        })})`);
+        return chain.join(".");
+    }
+    propertySparqlGraphPatternExpression({ variables, }) {
+        let expression = super
+            .propertySparqlGraphPatternExpression({
+            variables,
+        })
+            .toSparqlGraphPatternExpression()
+            .toString();
+        if (this.defaultValue.isJust()) {
+            expression = `sparqlBuilder.GraphPattern.optional(${expression})`;
+        }
+        return new Type.SparqlGraphPatternExpression(expression);
+    }
+    toRdfExpression({ variables, }) {
+        return this.defaultValue
+            .map((defaultValue) => `!${variables.value}.equals(${rdfjsTermExpression(defaultValue, this.configuration)}) ? ${variables.value} : undefined`)
+            .orDefault(variables.value);
+    }
+}
+//# sourceMappingURL=RdfjsTermType.js.map

package/generators/ts/SetType.d.ts

@@ -0,0 +1,19 @@
+import { Type } from "./Type.js";
+export declare class SetType extends Type {
+    readonly itemType: Type;
+    readonly kind = "SetType";
+    private readonly minCount;
+    constructor({ itemType, minCount, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
+        itemType: Type;
+        minCount: number;
+    });
+    get conversions(): readonly Type.Conversion[];
+    get name(): string;
+    chainSparqlGraphPatternExpression(parameters: Parameters<Type["chainSparqlGraphPatternExpression"]>[0]): ReturnType<Type["chainSparqlGraphPatternExpression"]>;
+    equalsFunction(): string;
+    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    propertySparqlGraphPatternExpression(parameters: Parameters<Type["propertySparqlGraphPatternExpression"]>[0]): Type.SparqlGraphPatternExpression | Type.SparqlGraphPatternsExpression;
+    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+}
+//# sourceMappingURL=SetType.d.ts.map

package/generators/ts/SetType.js

@@ -0,0 +1,76 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
+import { Type } from "./Type.js";
+export class SetType extends Type {
+    constructor({ itemType, minCount, ...superParameters }) {
+        super(superParameters);
+        this.kind = "SetType";
+        this.itemType = itemType;
+        this.minCount = minCount;
+    }
+    get conversions() {
+        return [
+            {
+                conversionExpression: () => "[]",
+                sourceTypeName: "undefined",
+            },
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => `Array.isArray(${value})`,
+                sourceTypeName: this.name,
+            },
+        ];
+    }
+    get name() {
+        return `readonly (${this.itemType.name})[]`;
+    }
+    chainSparqlGraphPatternExpression(parameters) {
+        return this.itemType.chainSparqlGraphPatternExpression(parameters);
+    }
+    equalsFunction() {
+        const itemTypeEqualsFunction = this.itemType.equalsFunction();
+        if (itemTypeEqualsFunction === "purifyHelpers.Equatable.equals") {
+            return "purifyHelpers.Equatable.arrayEquals";
+        }
+        return `(left, right) => purifyHelpers.Arrays.equals(left, right, ${itemTypeEqualsFunction})`;
+    }
+    fromRdfExpression({ variables, }) {
+        return `purify.Either.of([...${variables.resourceValues}.flatMap(value => ${this.itemType.fromRdfExpression({ variables: { ...variables, resourceValues: "value.toValues()" } })}.toMaybe().toList())])`;
+    }
+    hashStatements({ variables, }) {
+        return [
+            `for (const element of ${variables.value}) { ${this.itemType
+                .hashStatements({
+                variables: {
+                    hasher: variables.hasher,
+                    value: "element",
+                },
+            })
+                .join("\n")} }`,
+        ];
+    }
+    propertySparqlGraphPatternExpression(parameters) {
+        if (this.minCount === 0) {
+            return new Type.SparqlGraphPatternExpression(`sparqlBuilder.GraphPattern.optional(${this.itemType.propertySparqlGraphPatternExpression(parameters).toSparqlGraphPatternExpression()})`);
+        }
+        return this.itemType.propertySparqlGraphPatternExpression(parameters);
+    }
+    toRdfExpression({ variables, }) {
+        const itemTypeToRdfExpression = this.itemType.toRdfExpression({
+            variables: { ...variables, value: "value" },
+        });
+        if (itemTypeToRdfExpression === "value") {
+            return variables.value;
+        }
+        return `${variables.value}.map((value) => ${itemTypeToRdfExpression})`;
+    }
+}
+__decorate([
+    Memoize()
+], SetType.prototype, "name", null);
+//# sourceMappingURL=SetType.js.map

package/generators/ts/StringType.d.ts

@@ -0,0 +1,7 @@
+import { PrimitiveType } from "./PrimitiveType.js";
+export declare class StringType extends PrimitiveType {
+    get name(): string;
+    fromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType["fromRdfResourceValueExpression"]>[0]): string;
+    hashStatements({ variables, }: Parameters<PrimitiveType["hashStatements"]>[0]): readonly string[];
+}
+//# sourceMappingURL=StringType.d.ts.map

package/generators/ts/StringType.js

@@ -0,0 +1,13 @@
+import { PrimitiveType } from "./PrimitiveType.js";
+export class StringType extends PrimitiveType {
+    get name() {
+        return "string";
+    }
+    fromRdfResourceValueExpression({ variables, }) {
+        return `${variables.resourceValue}.toString()`;
+    }
+    hashStatements({ variables, }) {
+        return [`${variables.hasher}.update(${variables.value});`];
+    }
+}
+//# sourceMappingURL=StringType.js.map

package/generators/ts/TsGenerator.d.ts

@@ -0,0 +1,15 @@
+import type * as ast from "../../ast";
+import { Configuration as GlobalConfiguration } from "./Configuration.js";
+export declare class TsGenerator {
+    private ast;
+    protected readonly configuration: TsGenerator.Configuration;
+    constructor(ast: ast.Ast, configuration?: TsGenerator.Configuration);
+    generate(): string;
+    private addDeclarations;
+    private addImportDeclarations;
+}
+export declare namespace TsGenerator {
+    const Configuration: typeof GlobalConfiguration;
+    type Configuration = GlobalConfiguration;
+}
+//# sourceMappingURL=TsGenerator.d.ts.map

package/generators/ts/TsGenerator.js

@@ -0,0 +1,119 @@
+import { Project, StructureKind, } from "ts-morph";
+import { Configuration as GlobalConfiguration } from "./Configuration.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));
+        });
+        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] : [];
+        });
+        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`);
+                }
+                moduleStatements.push(objectType.sparqlGraphPatternsClassDeclaration());
+            }
+            if (this.configuration.features.has("toRdf") &&
+                this.configuration.objectTypeDeclarationType === "interface") {
+                moduleStatements.push(objectType.toRdfFunctionDeclaration());
+            }
+            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();
+        for (const objectType of objectTypes) {
+            for (const importStatement of objectType.importStatements) {
+                typeImportStatements.add(importStatement);
+            }
+        }
+        sourceFile.addStatements([...typeImportStatements]);
+    }
+}
+(function (TsGenerator) {
+    TsGenerator.Configuration = GlobalConfiguration;
+})(TsGenerator || (TsGenerator = {}));
+//# sourceMappingURL=TsGenerator.js.map

package/generators/ts/Type.d.ts

@@ -0,0 +1,108 @@
+import { Maybe } from "purify-ts";
+import type * as ast from "../../ast";
+import type { Configuration } from "./Configuration.js";
+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[];
+    /**
+     * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
+     */
+    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    /**
+     * Imports used by other methods on this type.
+     */
+    get importStatements(): readonly 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.
+     */
+    chainSparqlGraphPatternExpression(_: {
+        variables: {
+            subject: string;
+        };
+    }): Maybe<Type.SparqlGraphPatternExpression | Type.SparqlGraphPatternsExpression>;
+    /**
+     * A function (reference or declaration) that compares two values of this type, returning a
+     * purifyHelpers.Equatable.EqualsResult.
+     */
+    abstract equalsFunction(): string;
+    /**
+     * An expression that converts a rdfjsResource.Resource.Values to an Either of value/values
+     * of this type.
+     */
+    abstract fromRdfExpression(parameters: {
+        variables: {
+            predicate: string;
+            resource: string;
+            resourceValues: string;
+        };
+    }): string;
+    /**
+     * Statements that use hasher.update to hash a value of this type.
+     */
+    abstract hashStatements(parameters: {
+        variables: {
+            hasher: string;
+            value: string;
+        };
+    }): readonly string[];
+    /**
+     * An sparqlBuilder.GraphPattern expression for a property, typically building a basic graph pattern.
+     */
+    propertySparqlGraphPatternExpression({ variables, }: {
+        variables: {
+            object: string;
+            predicate: string;
+            subject: string;
+        };
+    }): Type.SparqlGraphPatternExpression | Type.SparqlGraphPatternsExpression;
+    /**
+     * An expression that converts a value of this type to one that that can be .add'd to
+     * an rdfjsResource.Resource.
+     */
+    abstract toRdfExpression(parameters: {
+        variables: {
+            predicate: string;
+            mutateGraph: string;
+            resource: string;
+            resourceSet: string;
+            value: string;
+        };
+    }): string;
+}
+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 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

@@ -0,0 +1,83 @@
+import { Maybe } from "purify-ts";
+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,
+            },
+        ];
+    }
+    /**
+     * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
+     */
+    get discriminatorProperty() {
+        return Maybe.empty();
+    }
+    /**
+     * Imports used by other methods on this type.
+     */
+    get importStatements() {
+        return [];
+    }
+    /**
+     * 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.
+     */
+    chainSparqlGraphPatternExpression(_) {
+        return Maybe.empty();
+    }
+    /**
+     * An sparqlBuilder.GraphPattern expression for a property, typically building a basic graph pattern.
+     */
+    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;
+        }
+    }
+    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;
+        }
+    }
+    Type.SparqlGraphPatternsExpression = SparqlGraphPatternsExpression;
+})(Type || (Type = {}));
+//# sourceMappingURL=Type.js.map

package/generators/ts/TypeFactory.d.ts

@@ -0,0 +1,15 @@
+import type * as ast from "../../ast";
+import type { Configuration } from "./Configuration";
+import type { Type } from "./Type.js";
+export declare class TypeFactory {
+    private cachedObjectTypePropertiesByIdentifier;
+    private cachedObjectTypesByIdentifier;
+    private readonly configuration;
+    constructor({ configuration }: {
+        configuration: Configuration;
+    });
+    createTypeFromAstType(astType: ast.Type): Type;
+    private createObjectTypeFromAstType;
+    private createObjectTypePropertyFromAstProperty;
+}
+//# sourceMappingURL=TypeFactory.d.ts.map