@shaclmate/compiler 4.0.99 → 4.0.101

package/dist/generators/ts/AbstractBuiltinType.d.ts

@@ -0,0 +1,23 @@
+import { AbstractType } from "./AbstractType.js";
+import type { SchemaObject } from "./SchemaObject.js";
+/**
+ * Abstract base class for built-in types (container types, term types, et al.) -- anything that is not user-defined.
+ */
+export declare abstract class AbstractBuiltinType extends AbstractType {
+    get schema(): SchemaObject<SchemaObject.AbstractType | SchemaObject.BuiltinType>;
+}
+export declare namespace AbstractBuiltinType {
+    type ConversionFunction = AbstractType.ConversionFunction;
+    namespace ConversionFunction {
+        const SourceType: typeof import("./_AbstractType/AbstractType_ConversionFunction.js").AbstractType_ConversionFunction.SourceType;
+        type SourceType = AbstractType.ConversionFunction.SourceType;
+    }
+    type DiscriminatedType = AbstractType.DiscriminatedType;
+    const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
+    type GraphqlType = AbstractType.GraphqlType;
+    type JsType = AbstractType.JsType;
+    const JsType: typeof import("./_AbstractType/AbstractType_JsType.js").AbstractType_JsType;
+    type JsonType = AbstractType.JsonType;
+    type JsonTypeFactory = AbstractType.JsonTypeFactory;
+}
+//# sourceMappingURL=AbstractBuiltinType.d.ts.map

package/dist/generators/ts/AbstractBuiltinType.js

@@ -0,0 +1,18 @@
+import { AbstractType } from "./AbstractType.js";
+/**
+ * Abstract base class for built-in types (container types, term types, et al.) -- anything that is not user-defined.
+ */
+export class AbstractBuiltinType extends AbstractType {
+    get schema() {
+        return super.schema;
+    }
+}
+(function (AbstractBuiltinType) {
+    let ConversionFunction;
+    (function (ConversionFunction) {
+        ConversionFunction.SourceType = AbstractType.ConversionFunction.SourceType;
+    })(ConversionFunction = AbstractBuiltinType.ConversionFunction || (AbstractBuiltinType.ConversionFunction = {}));
+    AbstractBuiltinType.GraphqlType = AbstractType.GraphqlType;
+    AbstractBuiltinType.JsType = AbstractType.JsType;
+})(AbstractBuiltinType || (AbstractBuiltinType = {}));
+//# sourceMappingURL=AbstractBuiltinType.js.map

package/dist/generators/ts/AbstractUserDefinedType.d.ts

@@ -0,0 +1,71 @@
+import { AbstractType } from "./AbstractType.js";
+import type { Callable } from "./Callable.js";
+import type { CodeThunk } from "./CodeThunk.js";
+import { SchemaObject } from "./SchemaObject.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for user-defined types (compound types, object types).
+ */
+export declare abstract class AbstractUserDefinedType extends AbstractType {
+    get equalsFunction(): Callable;
+    get filterFunction(): Callable;
+    get schema(): SchemaObject<SchemaObject.UserDefinedType>;
+    get filterType(): Code;
+    get fromJsonValueFunction(): Callable;
+    get fromJsonObjectFunction(): Callable;
+    get fromRdfResourceValuesFunction(): Callable;
+    get hashFunction(): Callable;
+    get toJsonValueFunction(): Callable;
+    get toJsonObjectFunction(): Callable;
+    get toLoggableFunction(): Callable;
+    get toRdfResourceValuesFunction(): Callable;
+    get toStringFunction(): Callable;
+    get valueSparqlConstructTriplesFunction(): Callable;
+    get valueSparqlWherePatternsFunction(): Callable;
+    protected get toRdfResourceValueTypesExpression(): Code;
+    graphqlResolveExpression({ variables, }: {
+        variables: {
+            value: Code;
+        };
+    }): Code;
+    toLoggableExpression({ variables, }: Parameters<AbstractType["toLoggableExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+    protected _function({ type, unannotatedExpression, unqualifiedName, }: {
+        type: CodeThunk;
+        unannotatedExpression: CodeThunk;
+        unqualifiedName: string;
+    }): Callable;
+    protected abstract equalsFunctionExpression(): Code;
+    protected equalsFunctionType(): Code;
+    protected abstract filterFunctionExpression(): Code;
+    protected filterFunctionType(): Code;
+    protected abstract filterTypeExpression(): Code;
+    protected abstract fromJsonObjectFunctionExpression(): Code;
+    protected fromJsonObjectFunctionType(): Code;
+    protected abstract fromRdfResourceValuesFunctionExpression(): Code;
+    protected fromRdfResourceValuesFunctionType(): Code;
+    protected abstract hashFunctionExpression(): Code;
+    protected hashFunctionType(): Code;
+    protected staticModuleDeclarations(name: string): Record<string, Code>;
+    protected abstract toJsonObjectFunctionExpression(): Code;
+    protected toJsonObjectFunctionType(): Code;
+    protected abstract toLoggableFunctionExpression(): Code;
+    protected toLoggableFunctionType(): Code;
+    protected abstract toRdfResourceValuesFunctionExpression(): Code;
+    protected toRdfResourceValuesFunctionType(): Code;
+    protected abstract toStringFunctionExpression(): Code;
+    protected toStringFunctionType(): Code;
+    protected abstract valueSparqlConstructTriplesFunctionExpression(): Code;
+    protected valueSparqlConstructTriplesType(): Code;
+    protected abstract valueSparqlWherePatternsFunctionExpression(): Code;
+    protected valueSparqlWherePatternsFunctionType(): Code;
+}
+export declare namespace AbstractUserDefinedType {
+    type ConversionFunction = AbstractType.ConversionFunction;
+    type DiscriminatedType = AbstractType.DiscriminatedType;
+    type GraphqlType = AbstractType.GraphqlType;
+    type JsonType = AbstractType.JsonType;
+    type JsType = AbstractType.JsType;
+}
+//# sourceMappingURL=AbstractUserDefinedType.d.ts.map

package/dist/generators/ts/AbstractUserDefinedType.js

@@ -0,0 +1,285 @@
+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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractType } from "./AbstractType.js";
+import { DeclaredCallable } from "./DeclaredCallable.js";
+import { InlineCallable } from "./InlineCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for user-defined types (compound types, object types).
+ */
+export class AbstractUserDefinedType extends AbstractType {
+    get equalsFunction() {
+        return this._function({
+            type: () => this.equalsFunctionType(),
+            unannotatedExpression: () => this.equalsFunctionExpression(),
+            unqualifiedName: "equals",
+        });
+    }
+    get filterFunction() {
+        return this._function({
+            type: () => this.filterFunctionType(),
+            unannotatedExpression: () => this.filterFunctionExpression(),
+            unqualifiedName: "filter",
+        });
+    }
+    get schema() {
+        return new SchemaObject({
+            properties: super.schema.properties,
+            type: new SchemaObject.UserDefinedType({
+                members: { kind: code `kind: ${literalOf(this.kind)}` },
+                name: this.name.map((name) => code `${name}.Schema`),
+            }),
+            variable: this.name.map((name) => code `${name}.schema`),
+        });
+    }
+    get filterType() {
+        return this.name
+            .map((name) => code `${name}.Filter`)
+            .orDefaultLazy(() => this.filterTypeExpression());
+    }
+    get fromJsonValueFunction() {
+        return this.fromJsonObjectFunction;
+    }
+    get fromJsonObjectFunction() {
+        return this._function({
+            type: () => this.fromJsonObjectFunctionType(),
+            unannotatedExpression: () => this.fromJsonObjectFunctionExpression(),
+            unqualifiedName: "fromJson",
+        });
+    }
+    get fromRdfResourceValuesFunction() {
+        return this._function({
+            type: () => this.fromRdfResourceValuesFunctionType(),
+            unannotatedExpression: () => this.fromRdfResourceValuesFunctionExpression(),
+            unqualifiedName: "fromRdfResourceValues",
+        });
+    }
+    get hashFunction() {
+        return this._function({
+            type: () => this.hashFunctionType(),
+            unannotatedExpression: () => this.hashFunctionExpression(),
+            unqualifiedName: "hash",
+        });
+    }
+    get toJsonValueFunction() {
+        return this.toJsonObjectFunction;
+    }
+    get toJsonObjectFunction() {
+        return this._function({
+            type: () => this.toJsonObjectFunctionType(),
+            unannotatedExpression: () => this.toJsonObjectFunctionExpression(),
+            unqualifiedName: "toJson",
+        });
+    }
+    get toLoggableFunction() {
+        return this._function({
+            type: () => this.toLoggableFunctionType(),
+            unannotatedExpression: () => this.toLoggableFunctionExpression(),
+            unqualifiedName: "toLoggable",
+        });
+    }
+    get toRdfResourceValuesFunction() {
+        return this._function({
+            type: () => this.toRdfResourceValuesFunctionType(),
+            unannotatedExpression: () => this.toRdfResourceValuesFunctionExpression(),
+            unqualifiedName: "toRdfResourceValues",
+        });
+    }
+    get toStringFunction() {
+        return this._function({
+            type: () => this.toStringFunctionType(),
+            unannotatedExpression: () => this.toStringFunctionExpression(),
+            unqualifiedName: `${this.configuration.syntheticNamePrefix}toString`,
+        });
+    }
+    get valueSparqlConstructTriplesFunction() {
+        return this._function({
+            type: () => this.valueSparqlConstructTriplesType(),
+            unannotatedExpression: () => this.valueSparqlConstructTriplesFunctionExpression(),
+            unqualifiedName: "valueSparqlConstructTriples",
+        });
+    }
+    get valueSparqlWherePatternsFunction() {
+        return this._function({
+            type: () => this.valueSparqlWherePatternsFunctionType(),
+            unannotatedExpression: () => this.valueSparqlWherePatternsFunctionExpression(),
+            unqualifiedName: "valueSparqlWherePatterns",
+        });
+    }
+    get toRdfResourceValueTypesExpression() {
+        return joinCode([...this.toRdfResourceValueTypes].map((toRdfResourceValueType) => {
+            switch (toRdfResourceValueType) {
+                case "BlankNode":
+                    return code `${this.reusables.imports.BlankNode}`;
+                case "Literal":
+                    return code `${this.reusables.imports.Literal}`;
+                case "NamedNode":
+                    return code `${this.reusables.imports.NamedNode}`;
+                default:
+                    toRdfResourceValueType;
+                    throw new Error();
+            }
+        }), { on: " | " });
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+    toLoggableExpression({ variables, }) {
+        return code `${this.toLoggableFunction.unannotatedUsage}(${variables.value})`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        const { value: valueVariable, ...otherVariables } = variables;
+        return code `${this.toRdfResourceValuesFunction.unannotatedUsage}(${valueVariable}, ${otherVariables})`;
+    }
+    toStringExpression({ variables, }) {
+        return code `${this.toStringFunction.unannotatedUsage}(${variables.value})`;
+    }
+    _function({ type, unannotatedExpression, unqualifiedName, }) {
+        return this.name
+            .map((name) => new DeclaredCallable({
+            qualifiedName: [name, unqualifiedName],
+            type,
+            unannotatedExpression,
+        }))
+            .orDefault(new InlineCallable(unannotatedExpression, { type }));
+    }
+    equalsFunctionType() {
+        return code `${this.reusables.snippets.EqualsFunction}<${this.expression}>`;
+    }
+    filterFunctionType() {
+        return code `${this.reusables.snippets.FilterFunction}<${this.filterType}, ${this.expression}>`;
+    }
+    fromJsonObjectFunctionType() {
+        return code `${this.reusables.snippets.FromJsonFunction}<${this.jsonObjectType.expression}, ${this.expression}, undefined>`;
+    }
+    fromRdfResourceValuesFunctionType() {
+        return code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schema.type.expression}>`;
+    }
+    hashFunctionType() {
+        return code `${this.reusables.snippets.HashFunction}<${this.expression}>`;
+    }
+    staticModuleDeclarations(name) {
+        const staticModuleDeclarations = {
+            ...super.staticModuleDeclarations(name),
+        };
+        function addFunctionDeclaration(function_) {
+            invariant(function_ instanceof DeclaredCallable);
+            staticModuleDeclarations[function_.unqualifiedName] =
+                code `export ${function_.declaration}`;
+        }
+        if (this.configuration.features.has("Object.equals")) {
+            addFunctionDeclaration(this.equalsFunction);
+        }
+        if (this.configuration.features.has("Object.filter")) {
+            staticModuleDeclarations["Filter"] =
+                code `export type Filter = ${this.filterTypeExpression()};`;
+            addFunctionDeclaration(this.filterFunction);
+        }
+        if (this.configuration.features.has("Object.hash")) {
+            // Hash functions take a generic parameter and const declaration like this can't have type parameters.
+            addFunctionDeclaration(this.hashFunction);
+        }
+        if (this.configuration.features.has("Object.JSON.type")) {
+            this.jsonObjectType.declaration.ifJust((jsonTypeDeclaration) => {
+                staticModuleDeclarations["JSON"] = jsonTypeDeclaration;
+            });
+        }
+        if (this.configuration.features.has("Object.fromJson")) {
+            addFunctionDeclaration(this.fromJsonObjectFunction);
+        }
+        if (this.configuration.features.has("Object.fromRdf")) {
+            addFunctionDeclaration(this.fromRdfResourceValuesFunction);
+        }
+        if (this.configuration.features.has("Object.schema")) {
+            staticModuleDeclarations["schema"] =
+                code `export const schema = ${this.schema.literalExpression};`;
+            staticModuleDeclarations["Schema"] =
+                code `export type Schema = typeof schema;`;
+        }
+        if (this.configuration.features.has("Object.SPARQL")) {
+            addFunctionDeclaration(this.valueSparqlConstructTriplesFunction);
+            addFunctionDeclaration(this.valueSparqlWherePatternsFunction);
+        }
+        if (this.configuration.features.has("Object.toJson")) {
+            addFunctionDeclaration(this.toJsonObjectFunction);
+        }
+        if (this.configuration.features.has("Object.toLoggable")) {
+            addFunctionDeclaration(this.toLoggableFunction);
+        }
+        if (this.configuration.features.has("Object.toRdf")) {
+            addFunctionDeclaration(this.toRdfResourceValuesFunction);
+        }
+        if (this.configuration.features.has("Object.toString")) {
+            addFunctionDeclaration(this.toStringFunction);
+        }
+        return staticModuleDeclarations;
+    }
+    toJsonObjectFunctionType() {
+        return code `${this.reusables.snippets.ToJsonFunction}<${this.expression}, ${this.jsonObjectType.expression}>`;
+    }
+    toLoggableFunctionType() {
+        return code `${this.reusables.snippets.ToLoggableFunction}<${this.expression}>`;
+    }
+    toRdfResourceValuesFunctionType() {
+        return code `${this.reusables.snippets.ToRdfResourceValuesFunction}<${this.expression}, ${this.toRdfResourceValueTypesExpression}>`;
+    }
+    toStringFunctionType() {
+        return code `${this.reusables.snippets.ToStringFunction}<${this.expression}>`;
+    }
+    valueSparqlConstructTriplesType() {
+        return code `${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schema.type.expression}>`;
+    }
+    valueSparqlWherePatternsFunctionType() {
+        return code `${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schema.type.expression}>`;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "fromJsonObjectFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "hashFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "toJsonObjectFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "toLoggableFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "toRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "toStringFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "toRdfResourceValueTypesExpression", null);
+//# sourceMappingURL=AbstractUserDefinedType.js.map

package/dist/generators/ts/BuiltinCallable.d.ts

@@ -0,0 +1,14 @@
+import { AbstractCallable } from "./AbstractCallable.js";
+import type { Snippet } from "./Snippet.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * A callable that's a reference to a built-in snippet, an import, or a global function.
+ *
+ * Callers assume the referent carries its own type annotations, so there's no distinction between annotated and unannotated usage.
+ */
+export declare class BuiltinCallable extends AbstractCallable {
+    readonly annotatedUsage: Code;
+    readonly unannotatedUsage: Code;
+    constructor(reference: Code | Snippet);
+}
+//# sourceMappingURL=BuiltinCallable.d.ts.map

package/dist/generators/ts/BuiltinCallable.js

@@ -0,0 +1,16 @@
+import { AbstractCallable } from "./AbstractCallable.js";
+import { code } from "./ts-poet-wrapper.js";
+/**
+ * A callable that's a reference to a built-in snippet, an import, or a global function.
+ *
+ * Callers assume the referent carries its own type annotations, so there's no distinction between annotated and unannotated usage.
+ */
+export class BuiltinCallable extends AbstractCallable {
+    annotatedUsage;
+    unannotatedUsage;
+    constructor(reference) {
+        super();
+        this.annotatedUsage = this.unannotatedUsage = code `${reference}`;
+    }
+}
+//# sourceMappingURL=BuiltinCallable.js.map

package/dist/generators/ts/Imports.d.ts

@@ -6,6 +6,7 @@ export declare class Imports {
     readonly datasetFactory: import("ts-poet/build/Import.js").Import;
     readonly Either: import("ts-poet/build/Import.js").Import;
     readonly EitherAsync: import("ts-poet/build/Import.js").Import;
+    readonly expandIri: import("ts-poet/build/Import.js").Import;
     readonly GraphQLBigInt: import("ts-poet/build/Import.js").Import;
     readonly GraphQLBoolean: import("ts-poet/build/Import.js").Import;
     readonly GraphQLDate: import("ts-poet/build/Import.js").Import;

package/dist/generators/ts/Imports.js

@@ -7,6 +7,7 @@ export class Imports {
     datasetFactory = imp("datasetFactory@@rdfx/collection");
     Either = imp("Either@purify-ts");
     EitherAsync = imp("EitherAsync@purify-ts");
+    expandIri = imp("expandIri@@rdfx/curie");
     GraphQLBigInt = imp("BigInt:GraphQLBigInt@graphql-scalars");
     GraphQLBoolean = imp("GraphQLBoolean@graphql");
     GraphQLDate = imp("Date:GraphQLDate@graphql-scalars");

package/dist/generators/ts/SchemaObject.d.ts

@@ -0,0 +1,98 @@
+import type { Maybe } from "purify-ts";
+import { CodeThunk } from "./CodeThunk.js";
+import type { Snippet } from "./Snippet.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * Runtime schema/metadata objects for types and properties.
+ */
+export declare class SchemaObject<TypeT extends SchemaObject.Type> {
+    /**
+     * Object literal properties, usually property assignments like name: value
+     * without a terminating comma.
+     *
+     * Note the name is repeated between the key and the value:
+     *   { name: code`name: value` }
+     * Only the value is incorporated into generated code. The keys are used to sort properties.
+     *
+     * This enables overwriting in the *Type tree while also supporting non-property assignments such as
+     *   { name: code`get name() { return value; }` }
+     * or
+     *   { shorthand: code `shorthand` }
+     */
+    readonly properties: Readonly<Record<string, CodeThunk>>;
+    /**
+     * Type of the schema object.
+     */
+    readonly type: TypeT;
+    /**
+     * Variable pointing to the schema object.
+     */
+    readonly variable: Maybe<Code>;
+    constructor({ properties, type, variable, }: {
+        properties: Readonly<Record<string, CodeThunk>>;
+        type: TypeT;
+        variable: Maybe<Code>;
+    });
+    /**
+     * Expression for this schema object, either the variable or a literal expression.
+     */
+    get expression(): Code;
+    /**
+     * Literal expression of the schema object e.g., { name1: value1, name2: value2 }
+     */
+    get literalExpression(): Code;
+    toString(): string;
+}
+export declare namespace SchemaObject {
+    /**
+     * Placeholder for abstract base classes.
+     */
+    class AbstractType {
+        private readonly ownerKind;
+        constructor(ownerKind: string);
+        get expression(): Code;
+        toString(): string;
+    }
+    /**
+     * A built-in schema object type from a snippet or import.
+     */
+    class BuiltinType {
+        readonly expression: Code;
+        constructor(expression: Code | Snippet);
+        toString(): string;
+    }
+    /**
+     * A user-defined schema object type, typically corresponding to user-defined types.
+     */
+    class UserDefinedType {
+        /**
+         * Members of the schema object type, usually property signatures like name: string.
+         *
+         * Note the name is repeated between the key and the value:
+         *   { name: code`name: string` }
+         * This enables overwriting in the *Type tree. Unlike property assignments (above),
+         * we don't really need to support other member types (index signatures, methods, et al.).
+         * Rather, the name is repeated here for consistency with property assignments.
+         */
+        readonly members: Readonly<Record<string, CodeThunk>>;
+        /**
+         * Name of the type, can be used in type annotations.
+         */
+        readonly name: Maybe<Code>;
+        constructor({ members, name, }: {
+            members: Readonly<Record<string, CodeThunk>>;
+            name: Maybe<Code>;
+        });
+        /**
+         * Expression of the schema object type, either the name or a literal expression.
+         */
+        get expression(): Code;
+        /**
+         * Literal expression of the schema object type e.g., { name1: string, name2: string }.
+         */
+        get literalExpression(): Code;
+        toString(): string;
+    }
+    type Type = AbstractType | BuiltinType | UserDefinedType;
+}
+//# sourceMappingURL=SchemaObject.d.ts.map