@shaclmate/compiler 2.0.12

package/ast/ObjectType.d.ts

@@ -0,0 +1,88 @@
+import type { NamedNode } from "@rdfjs/types";
+import type { Maybe } from "purify-ts";
+import type { NodeKind } from "shacl-ast";
+import type { PredicatePath } from "shacl-ast";
+import type { Name, Type } from ".";
+import type { MintingStrategy } from "./MintingStrategy";
+export interface ObjectType {
+    /**
+     * Classes generated from this type are abstract / cannot be instantiated themselves.
+     *
+     * Defaults to false.
+     */
+    readonly abstract: boolean;
+    /**
+     * Ancestor (parents, their parents, ad nauseum) ObjectTypes of this ObjectType.
+     *
+     * Mutable to support cycle-handling logic in the transformer.
+     */
+    readonly ancestorObjectTypes: ObjectType[];
+    /**
+     * Immediate child ObjectTypes of this ObjectType.
+     *
+     * Mutable to support cycle-handling logic in the transformer.
+     */
+    readonly childObjectTypes: ObjectType[];
+    /**
+     * Descendant (children, their children, ad nauseum) ObjectTypes of this ObjectType.
+     *
+     * Mutable to support cycle-handling logic in the transformer.
+     */
+    readonly descendantObjectTypes: ObjectType[];
+    /**
+     * Should generated code derived from this ObjectType be visible outside its module?
+     *
+     * Defaults to true.
+     */
+    readonly export: boolean;
+    readonly kind: "ObjectType";
+    /**
+     * If the ObjectType is an RDF list, this is the type of rdf:first.
+     * https://www.w3.org/TR/rdf-schema/#ch_collectionvocab
+     *
+     * Mutable to support cycle-handling logic in the transformer.
+     */
+    listItemType: Maybe<Type>;
+    /**
+     * Strategy for minting new object identifiers. If not specified, require an identifier on construction.
+     */
+    readonly mintingStrategy: Maybe<MintingStrategy>;
+    /**
+     * Name of this ObjectType, usually derived from sh:name or shaclmate:name.
+     */
+    readonly name: Name;
+    /**
+     * The RDF node kinds this ObjectType may be identified by.
+     *
+     * Used to associate instances with an RDF identifier.
+     */
+    readonly nodeKinds: Set<NodeKind.BLANK_NODE | NodeKind.IRI>;
+    /**
+     * Immediate parent ObjectTypes of this Object types.
+     *
+     * Mutable to support cycle-handling logic in the transformer.
+     */
+    readonly parentObjectTypes: ObjectType[];
+    /**
+     * Properties of this ObjectType.
+     *
+     * Mutable to support cycle-handling logic in the transformer.
+     */
+    readonly properties: ObjectType.Property[];
+    /**
+     * The expected rdf:type of instances of this ObjectType.
+     *
+     * This is usually the identifier of an sh:NodeShape that is also an rdfs:Class (i.e., a node shape with implicit
+     * class targets).
+     */
+    readonly rdfType: Maybe<NamedNode>;
+}
+export declare namespace ObjectType {
+    interface Property {
+        readonly inline: boolean;
+        readonly name: Name;
+        readonly path: PredicatePath;
+        readonly type: Type;
+    }
+}
+//# sourceMappingURL=ObjectType.d.ts.map

package/ast/ObjectType.js

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

package/ast/OptionType.d.ts

@@ -0,0 +1,11 @@
+import type { Type } from "./Type.js";
+/**
+ * A type with zero or one values of an item type.
+ *
+ * This is a property with sh:minCount 0 and sh:maxCount 1.
+ */
+export interface OptionType {
+    readonly itemType: Type;
+    readonly kind: "OptionType";
+}
+//# sourceMappingURL=OptionType.d.ts.map

package/ast/OptionType.js

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

package/ast/SetType.d.ts

@@ -0,0 +1,12 @@
+import type { Type } from "./Type.js";
+/**
+ * A set of items of a specific type.
+ *
+ * This is a property with sh:maxCount != 1.
+ */
+export interface SetType {
+    readonly itemType: Type;
+    readonly kind: "SetType";
+    readonly minCount: number;
+}
+//# sourceMappingURL=SetType.d.ts.map

package/ast/SetType.js

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

package/ast/Type.d.ts

@@ -0,0 +1,9 @@
+import type { IdentifierType } from "./IdentifierType.js";
+import type { IntersectionType } from "./IntersectionType.js";
+import type { LiteralType } from "./LiteralType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { OptionType } from "./OptionType";
+import type { SetType } from "./SetType";
+import type { UnionType } from "./UnionType.js";
+export type Type = IdentifierType | IntersectionType | LiteralType | ObjectType | OptionType | SetType | UnionType;
+//# sourceMappingURL=Type.d.ts.map

package/ast/Type.js

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

package/ast/UnionType.d.ts

@@ -0,0 +1,9 @@
+import type { Type } from "./Type.js";
+/**
+ * A disjunction/union of types, corresponding to an sh:or.
+ */
+export interface UnionType {
+    readonly kind: "UnionType";
+    readonly memberTypes: readonly Type[];
+}
+//# sourceMappingURL=UnionType.d.ts.map

package/ast/UnionType.js

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

package/ast/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./Ast.js";
+export * from "./IdentifierType.js";
+export * from "./IntersectionType";
+export * from "./LiteralType.js";
+export * from "./MintingStrategy.js";
+export * from "./Name.js";
+export * from "./ObjectType.js";
+export * from "./UnionType";
+export * from "./Type.js";
+//# sourceMappingURL=index.d.ts.map

package/ast/index.js

@@ -0,0 +1,10 @@
+export * from "./Ast.js";
+export * from "./IdentifierType.js";
+export * from "./IntersectionType";
+export * from "./LiteralType.js";
+export * from "./MintingStrategy.js";
+export * from "./Name.js";
+export * from "./ObjectType.js";
+export * from "./UnionType";
+export * from "./Type.js";
+//# sourceMappingURL=index.js.map

package/generators/index.d.ts

@@ -0,0 +1,3 @@
+export * as json from "./json";
+export * as ts from "./ts";
+//# sourceMappingURL=index.d.ts.map

package/generators/index.js

@@ -0,0 +1,3 @@
+export * as json from "./json";
+export * as ts from "./ts";
+//# sourceMappingURL=index.js.map

package/generators/json/AstJsonGenerator.d.ts

@@ -0,0 +1,7 @@
+import type * as ast from "../../ast";
+export declare class AstJsonGenerator {
+    private readonly ast;
+    constructor(ast: ast.Ast);
+    generate(): string;
+}
+//# sourceMappingURL=AstJsonGenerator.d.ts.map

package/generators/json/AstJsonGenerator.js

@@ -0,0 +1,103 @@
+import * as shaclAst from "shacl-ast";
+function nameToJson(name) {
+    return {
+        curie: name.curie.extract(),
+        identifier: termToJson(name.identifier),
+        shName: name.shName.extract(),
+        shaclmateName: name.shaclmateName.extract(),
+    };
+}
+function nodeKindToJson(nodeKind) {
+    switch (nodeKind) {
+        case shaclAst.NodeKind.BLANK_NODE:
+            return "BlankNode";
+        case shaclAst.NodeKind.IRI:
+            return "NamedNode";
+        case shaclAst.NodeKind.LITERAL:
+            return "Literal";
+    }
+}
+function termToJson(term) {
+    switch (term.termType) {
+        case "BlankNode":
+            return { termType: term.termType, value: term.value };
+        case "Literal":
+            return {
+                datatype: term.datatype.value,
+                language: term.language,
+                termType: term.termType,
+                value: term.value,
+            };
+        case "NamedNode":
+            return { termType: term.termType, value: term.value };
+        default:
+            throw new Error(`unsupported term type: ${term.termType}`);
+    }
+}
+function typeToJson(type) {
+    switch (type.kind) {
+        case "IdentifierType":
+            return {
+                hasValue: type.hasValue.map(termToJson).extract(),
+                kind: type.kind,
+                nodeKinds: [...type.nodeKinds].map(nodeKindToJson),
+            };
+        case "IntersectionType":
+        case "UnionType":
+            return {
+                kind: type.kind,
+                types: type.memberTypes.map((type) => typeToJson(type)),
+            };
+        case "LiteralType": {
+            return {
+                datatype: type.datatype.extract(),
+                hasValue: type.hasValue.map(termToJson).extract(),
+                kind: type.kind,
+                maxExclusive: type.maxExclusive.map(termToJson).extract(),
+                maxInclusive: type.maxInclusive.map(termToJson).extract(),
+                minExclusive: type.minExclusive.map(termToJson).extract(),
+                minInclusive: type.minInclusive.map(termToJson).extract(),
+            };
+        }
+        case "ObjectType":
+            return {
+                kind: type.kind,
+                listItemType: type.listItemType.map(typeToJson).extract(),
+                name: nameToJson(type.name),
+                parentObjectTypes: type.parentObjectTypes.length > 0
+                    ? type.parentObjectTypes.map((type) => nameToJson(type.name))
+                    : undefined,
+                nodeKinds: [...type.nodeKinds].map(nodeKindToJson),
+                rdfType: type.rdfType.map(termToJson).extract(),
+            };
+        case "OptionType":
+            return {
+                itemType: typeToJson(type.itemType),
+                kind: type.kind,
+            };
+        case "SetType":
+            return {
+                itemType: typeToJson(type.itemType),
+                kind: type.kind,
+            };
+    }
+}
+export class AstJsonGenerator {
+    constructor(ast) {
+        this.ast = ast;
+    }
+    generate() {
+        return JSON.stringify({
+            objectTypes: this.ast.objectTypes.map((objectType) => ({
+                kind: objectType.kind,
+                name: nameToJson(objectType.name),
+                properties: objectType.properties.map((property) => ({
+                    name: nameToJson(property.name),
+                    path: property.path.iri.value,
+                    type: typeToJson(property.type),
+                })),
+            })),
+        }, undefined, 2);
+    }
+}
+//# sourceMappingURL=AstJsonGenerator.js.map

package/generators/json/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./AstJsonGenerator.js";
+//# sourceMappingURL=index.d.ts.map

package/generators/json/index.js

@@ -0,0 +1,2 @@
+export * from "./AstJsonGenerator.js";
+//# sourceMappingURL=index.js.map

package/generators/ts/BooleanType.d.ts

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

package/generators/ts/BooleanType.js

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

package/generators/ts/Configuration.d.ts

@@ -0,0 +1,29 @@
+type Feature = "equals" | "fromRdf" | "hash" | "toRdf" | "sparql-graph-patterns";
+export declare class Configuration {
+    readonly dataFactoryImport: string;
+    readonly dataFactoryVariable: string;
+    readonly features: Set<Feature>;
+    readonly objectTypeDeclarationType: "class" | "interface";
+    readonly objectTypeDiscriminatorPropertyName: string;
+    readonly objectTypeIdentifierPropertyName: string;
+    constructor(parameters?: {
+        dataFactoryImport?: string;
+        dataFactoryVariable?: string;
+        features?: Set<Feature>;
+        objectTypeDeclarationType?: "class" | "interface";
+        objectTypeIdentifierPropertyName?: string;
+        objectTypeDiscriminatorPropertyName?: string;
+    });
+}
+export declare namespace Configuration {
+    namespace Defaults {
+        const dataFactoryImport = "import { DataFactory as dataFactory } from \"n3\"";
+        const dataFactoryVariable = "dataFactory";
+        const features: Set<Feature>;
+        const objectTypeDeclarationType: "class";
+        const objectTypeDiscriminatorPropertyName = "type";
+        const objectTypeIdentifierPropertyName = "identifier";
+    }
+}
+export {};
+//# sourceMappingURL=Configuration.d.ts.map

package/generators/ts/Configuration.js

@@ -0,0 +1,40 @@
+export class Configuration {
+    constructor(parameters) {
+        this.features = new Set(parameters?.features ? [...parameters.features] : []);
+        this.dataFactoryImport =
+            parameters?.dataFactoryImport ?? Configuration.Defaults.dataFactoryImport;
+        this.dataFactoryVariable =
+            parameters?.dataFactoryVariable ??
+                Configuration.Defaults.dataFactoryVariable;
+        if (this.features.size === 0) {
+            this.features = Configuration.Defaults.features;
+        }
+        this.objectTypeDeclarationType =
+            parameters?.objectTypeDeclarationType ??
+                Configuration.Defaults.objectTypeDeclarationType;
+        this.objectTypeIdentifierPropertyName =
+            parameters?.objectTypeIdentifierPropertyName ??
+                Configuration.Defaults.objectTypeIdentifierPropertyName;
+        this.objectTypeDiscriminatorPropertyName =
+            parameters?.objectTypeDiscriminatorPropertyName ??
+                Configuration.Defaults.objectTypeDiscriminatorPropertyName;
+    }
+}
+(function (Configuration) {
+    let Defaults;
+    (function (Defaults) {
+        Defaults.dataFactoryImport = 'import { DataFactory as dataFactory } from "n3"';
+        Defaults.dataFactoryVariable = "dataFactory";
+        Defaults.features = new Set([
+            "equals",
+            "fromRdf",
+            "hash",
+            "toRdf",
+            "sparql-graph-patterns",
+        ]);
+        Defaults.objectTypeDeclarationType = "class";
+        Defaults.objectTypeDiscriminatorPropertyName = "type";
+        Defaults.objectTypeIdentifierPropertyName = "identifier";
+    })(Defaults = Configuration.Defaults || (Configuration.Defaults = {}));
+})(Configuration || (Configuration = {}));
+//# sourceMappingURL=Configuration.js.map

package/generators/ts/IdentifierType.d.ts

@@ -0,0 +1,23 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { NodeKind } from "shacl-ast";
+import { RdfjsTermType } from "./RdfjsTermType.js";
+import type { Type } from "./Type";
+export declare class IdentifierType extends RdfjsTermType<BlankNode | NamedNode> {
+    readonly kind = "IdentifierType";
+    private readonly nodeKinds;
+    constructor({ nodeKinds, ...superParameters }: {
+        nodeKinds: Set<NodeKind.BLANK_NODE | NodeKind.IRI>;
+    } & ConstructorParameters<typeof RdfjsTermType<BlankNode | NamedNode>>[0]);
+    get conversions(): readonly Type.Conversion[];
+    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    get isNamedNodeKind(): boolean;
+    get name(): string;
+    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    protected fromRdfResourceValueExpression({ variables, }: {
+        variables: {
+            resourceValue: string;
+        };
+    }): string;
+}
+//# sourceMappingURL=IdentifierType.d.ts.map

package/generators/ts/IdentifierType.js

@@ -0,0 +1,83 @@
+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 { Maybe } from "purify-ts";
+import { NodeKind } from "shacl-ast";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { RdfjsTermType } from "./RdfjsTermType.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression";
+export class IdentifierType extends RdfjsTermType {
+    constructor({ nodeKinds, ...superParameters }) {
+        super(superParameters);
+        this.kind = "IdentifierType";
+        this.nodeKinds = new Set([...nodeKinds]);
+        invariant(this.nodeKinds.size > 0);
+    }
+    get conversions() {
+        return this.defaultValue
+            .map((defaultValue) => [
+            {
+                conversionExpression: () => rdfjsTermExpression(defaultValue, this.configuration),
+                sourceTypeName: "undefined",
+            },
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheck: (value) => `typeof ${value} === "object"`,
+                sourceTypeName: this.name,
+            },
+        ])
+            .orDefault(super.conversions);
+    }
+    get discriminatorProperty() {
+        return Maybe.of({
+            name: "termType",
+            type: "string",
+            values: [...this.nodeKinds].map((nodeKind) => {
+                switch (nodeKind) {
+                    case NodeKind.BLANK_NODE:
+                        return "BlankNode";
+                    case NodeKind.IRI:
+                        return "NamedNode";
+                }
+            }),
+        });
+    }
+    get isNamedNodeKind() {
+        return this.nodeKinds.size === 1 && this.nodeKinds.has(NodeKind.IRI);
+    }
+    get name() {
+        const names = [];
+        if (this.nodeKinds.has(NodeKind.BLANK_NODE)) {
+            names.push("rdfjs.BlankNode");
+        }
+        if (this.nodeKinds.has(NodeKind.IRI)) {
+            names.push("rdfjs.NamedNode");
+        }
+        return names.join(" | ");
+    }
+    hashStatements({ variables, }) {
+        return [
+            `${variables.hasher}.update(rdfjsResource.Resource.Identifier.toString(${variables.value}));`,
+        ];
+    }
+    fromRdfResourceValueExpression({ variables, }) {
+        switch (this.name) {
+            case "rdfjs.BlankNode":
+                throw new Error("not implemented");
+            case "rdfjs.NamedNode":
+                return `${variables.resourceValue}.toIri()`;
+            case "rdfjs.BlankNode | rdfjs.NamedNode":
+                return `${variables.resourceValue}.toIdentifier()`;
+            default:
+                throw new Error(`not implemented: ${this.name}`);
+        }
+    }
+}
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "name", null);
+//# sourceMappingURL=IdentifierType.js.map

package/generators/ts/IntersectionType.d.ts

@@ -0,0 +1,14 @@
+import { Type } from "./Type.js";
+export declare class IntersectionType extends Type {
+    readonly kind = "IntersectionType";
+    readonly memberTypes: readonly Type[];
+    constructor({ memberTypes, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
+        memberTypes: readonly Type[];
+    });
+    get name(): string;
+    equalsFunction(): string;
+    fromRdfExpression(): string;
+    hashStatements(): readonly string[];
+    toRdfExpression(): string;
+}
+//# sourceMappingURL=IntersectionType.d.ts.map

package/generators/ts/IntersectionType.js

@@ -0,0 +1,26 @@
+import { invariant } from "ts-invariant";
+import { Type } from "./Type.js";
+export class IntersectionType extends Type {
+    constructor({ memberTypes, ...superParameters }) {
+        super(superParameters);
+        this.kind = "IntersectionType";
+        invariant(memberTypes.length >= 2);
+        this.memberTypes = memberTypes;
+    }
+    get name() {
+        return `(${this.memberTypes.map((type) => type.name).join(" & ")})`;
+    }
+    equalsFunction() {
+        throw new Error("Method not implemented.");
+    }
+    fromRdfExpression() {
+        throw new Error("Method not implemented.");
+    }
+    hashStatements() {
+        throw new Error("Method not implemented.");
+    }
+    toRdfExpression() {
+        throw new Error("Method not implemented.");
+    }
+}
+//# sourceMappingURL=IntersectionType.js.map

package/generators/ts/ListType.d.ts

@@ -0,0 +1,26 @@
+import type { NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { MintingStrategy } from "../../ast";
+import { Type } from "./Type.js";
+export declare class ListType extends Type {
+    readonly itemType: Type;
+    readonly kind = "ListType";
+    private readonly identifierNodeKind;
+    private readonly mintingStrategy;
+    private readonly rdfType;
+    constructor({ identifierNodeKind, itemType, mintingStrategy, rdfType, ...superParameters }: {
+        identifierNodeKind: ListType["identifierNodeKind"];
+        itemType: Type;
+        mintingStrategy: Maybe<MintingStrategy>;
+        rdfType: Maybe<NamedNode>;
+    } & ConstructorParameters<typeof Type>[0]);
+    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    get importStatements(): readonly string[];
+    get name(): string;
+    chainSparqlGraphPatternExpression({ variables, }: Parameters<Type["chainSparqlGraphPatternExpression"]>[0]): Maybe<Type.SparqlGraphPatternsExpression>;
+    equalsFunction(): string;
+    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+}
+//# sourceMappingURL=ListType.d.ts.map