@shaclmate/compiler 4.0.93 → 4.0.95

package/dist/generators/ts/SparqlObjectSetType.js

@@ -38,10 +38,7 @@ export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePre
     this.#sparqlClient = sparqlClient;
   }
 
-${joinCode([
-            ...this.namedObjectTypes,
-            ...this.namedObjectDiscriminatedUnionTypes,
-        ].flatMap((namedObjectType) => {
+${joinCode(this.namedObjectTypes.flatMap((namedObjectType) => {
             const methodSignatures = this.methodSignatures(namedObjectType, {
                 queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
             });

package/dist/generators/ts/StringType.d.ts

@@ -1,26 +1,31 @@
 import type { Literal } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import type { Callable } from "./Callable.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class StringType extends AbstractPrimitiveType<string> {
     private readonly languageIn;
+    protected readonly decodedIn: string[];
     readonly conversionFunction: Maybe<AbstractPrimitiveType.ConversionFunction>;
-    readonly filterFunction: Code;
+    readonly filterFunction: ReferenceCallable;
     readonly filterType: Code;
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    readonly hashFunction: Code;
+    readonly hashFunction: ReferenceCallable;
     readonly jsTypes: readonly [{
         readonly typeof: "string";
     }];
+    readonly jsonValueType: AbstractPrimitiveType.JsonType;
     readonly kind = "String";
-    readonly valueSparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
     constructor({ languageIn, ...superParameters }: {
         languageIn: readonly string[];
     } & ConstructorParameters<typeof AbstractPrimitiveType<string>>[0]);
-    get fromRdfResourceValuesFunction(): Code;
+    get fromJsonObjectFunction(): Callable;
+    get fromJsonValueFunction(): Callable;
+    get fromRdfResourceValuesFunction(): Callable;
     get schemaType(): Code;
     protected get schemaInitializers(): readonly Code[];
-    jsonSchema(parameters: Parameters<AbstractPrimitiveType<string>["jsonSchema"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
     valueExpression(literal: Literal | string): Code;
 }

package/dist/generators/ts/StringType.js

@@ -4,31 +4,46 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { LiteralDecoder } from "@rdfx/literal";
 import { xsd } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { arrayOf, code, literalOf } from "./ts-poet-wrapper.js";
 export class StringType extends AbstractPrimitiveType {
     languageIn;
+    decodedIn = this.in_.map((in_) => LiteralDecoder.decodeStringLiteral(in_).unsafeCoerce());
     conversionFunction = Maybe.empty();
-    filterFunction = code `${this.reusables.snippets.filterString}`;
+    filterFunction = new ReferenceCallable(this.reusables.snippets.filterString);
     filterType = code `${this.reusables.snippets.StringFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
-    hashFunction = code `${this.reusables.snippets.hashString}`;
+    hashFunction = new ReferenceCallable(this.reusables.snippets.hashString);
     jsTypes = [
         {
             typeof: "string",
         },
     ];
+    jsonValueType = this.jsonTypeFactory.createJsonStringType({
+        in_: this.decodedIn,
+        inReference: this.name.isJust() && this.configuration.features.has("Object.schema")
+            ? code `${this.name.extract()}.schema.in`
+            : undefined,
+    });
     kind = "String";
-    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.stringSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.stringSparqlWherePatterns);
     constructor({ languageIn, ...superParameters }) {
         super(superParameters);
         this.languageIn = languageIn;
     }
+    get fromJsonObjectFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.stringFromJsonObject}<${this.expression}>`);
+    }
+    get fromJsonValueFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.stringFromJsonString}<${this.expression}>`);
+    }
     get fromRdfResourceValuesFunction() {
-        return code `${this.reusables.snippets.stringFromRdfResourceValues}<${this.expression}>`;
+        return new ReferenceCallable(code `${this.reusables.snippets.stringFromRdfResourceValues}<${this.expression}>`);
     }
     get schemaType() {
         return code `${this.reusables.snippets.StringSchema}<${this.expression}>`;
@@ -40,19 +55,6 @@ export class StringType extends AbstractPrimitiveType {
         }
         return initializers;
     }
-    jsonSchema(parameters) {
-        if (this.in_.length > 1) {
-            const name = this.name.extract();
-            if (name && this.configuration.features.has("Object.schema")) {
-                // Reuse the type from schema to cut down code
-                return code `${this.reusables.imports.z}.enum(${name}.schema.in)`;
-            }
-            else {
-                return code `${this.reusables.imports.z}.enum(${arrayOf(...this.in_.map((value) => this.valueExpression(value)))})`;
-            }
-        }
-        return super.jsonSchema(parameters);
-    }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.string(${variables.value}${!this.datatype.equals(xsd.string) ? `, ${this.rdfjsTermExpression(this.datatype)}` : ""})]`;
     }
@@ -60,6 +62,12 @@ export class StringType extends AbstractPrimitiveType {
         return code `${literalOf(typeof literal === "string" ? literal : literal.value)}`;
     }
 }
+__decorate([
+    Memoize()
+], StringType.prototype, "fromJsonObjectFunction", null);
+__decorate([
+    Memoize()
+], StringType.prototype, "fromJsonValueFunction", null);
 __decorate([
     Memoize()
 ], StringType.prototype, "fromRdfResourceValuesFunction", null);

package/dist/generators/ts/TermType.d.ts

@@ -2,30 +2,36 @@ import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
 import { NodeKind } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 import { AbstractTermType } from "./AbstractTermType.js";
+import type { Callable } from "./Callable.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class TermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractTermType {
     readonly conversionFunction: Maybe<AbstractTermType.ConversionFunction>;
-    readonly filterFunction: Code;
+    readonly filterFunction: ReferenceCallable;
     readonly jsTypes: readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
     }];
     readonly kind = "Term";
     readonly nodeKinds: ReadonlySet<NodeKind>;
-    readonly valueSparqlWherePatternsFunction: Code;
+    readonly toJsonObjectFunction: ReferenceCallable;
+    readonly toJsonValueFunction: ReferenceCallable;
+    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
     constructor({ nodeKinds, ...superParameters }: ConstructorParameters<typeof AbstractTermType<ConstantTermT, RuntimeTermT>>[0] & {
         nodeKinds: ReadonlySet<NodeKind>;
     });
-    get fromRdfResourceValuesFunction(): Code;
+    get discriminatedType(): Maybe<AbstractTermType.DiscriminatedType>;
     get filterType(): Code;
+    get fromJsonObjectFunction(): Callable;
+    get fromJsonValueFunction(): Callable;
+    get fromRdfResourceValuesFunction(): Callable;
     get graphqlType(): AbstractTermType.GraphqlType;
+    get jsonObjectType(): AbstractTermType["jsonObjectType"];
+    get jsonValueType(): AbstractTermType["jsonValueType"];
     get schemaType(): Code;
     protected get inlineExpression(): Code;
     protected get schemaInitializers(): Code[];
-    fromJsonExpression({ variables, }: Parameters<AbstractTermType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
-    jsonSchema(_parameters: Parameters<AbstractTermType["jsonSchema"]>[0]): Code;
-    jsonType(): AbstractTermType.JsonType;
-    toJsonExpression({ variables, }: Parameters<AbstractTermType["toJsonExpression"]>[0]): Code;
+    toLoggableExpression({ variables, }: Parameters<AbstractTermType["toLoggableExpression"]>[0]): Code;
 }
 //# sourceMappingURL=TermType.d.ts.map

package/dist/generators/ts/TermType.js

@@ -5,36 +5,80 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { NodeKind } from "@shaclmate/shacl-ast";
-import { xsd } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractTermType } from "./AbstractTermType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
 export class TermType extends AbstractTermType {
     conversionFunction = Maybe.empty();
-    filterFunction = code `${this.reusables.snippets.filterTerm}`;
+    filterFunction = new ReferenceCallable(this.reusables.snippets.filterTerm);
     jsTypes = [
         { instanceof: "Object", typeof: "object" },
     ];
     kind = "Term";
     nodeKinds;
-    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.termSparqlWherePatterns}`;
+    toJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.termToJsonObject);
+    toJsonValueFunction = this.toJsonObjectFunction;
+    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.termSparqlWherePatterns);
     constructor({ nodeKinds, ...superParameters }) {
         super(superParameters);
         this.nodeKinds = nodeKinds;
         invariant(this.nodeKinds.has("Literal") &&
             (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("IRI")), "should be IdentifierType or LiteralType");
     }
-    get fromRdfResourceValuesFunction() {
-        return code `${this.reusables.snippets.termFromRdfResourceValues}<${this.expression}>`;
+    get discriminatedType() {
+        return Maybe.of({
+            discriminantProperty: {
+                jsonName: "termType",
+                name: "termType",
+                values: [...this.termTypes],
+            },
+            expression: this.expression,
+        });
     }
     get filterType() {
         return code `${this.reusables.snippets.TermFilter}<${this.expression}>`;
     }
+    get fromJsonObjectFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.termFromJsonObject}<${this.expression}>`);
+    }
+    get fromJsonValueFunction() {
+        return this.fromJsonObjectFunction;
+    }
+    get fromRdfResourceValuesFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.termFromRdfResourceValues}<${this.expression}>`);
+    }
     get graphqlType() {
         throw new Error("not implemented");
     }
+    get jsonObjectType() {
+        // This is a z.union in the snippet but an object here so a discriminant can be added if necessary.
+        return this.jsonTypeFactory.createJsonObjectType({
+            "@id": {
+                type: this.jsonTypeFactory.createJsonStringType({
+                    minLength: 1n,
+                }),
+            },
+            "@language": {
+                optional: true,
+                type: this.jsonTypeFactory.createJsonStringType(),
+            },
+            "@type": {
+                optional: true,
+                type: this.jsonTypeFactory.createJsonStringType(),
+            },
+            "@value": {
+                type: this.jsonTypeFactory.createJsonStringType(),
+            },
+        }, {
+            snippet: this.reusables.snippets.TermJsonObject,
+        });
+    }
+    get jsonValueType() {
+        return this.jsonObjectType;
+    }
     get schemaType() {
         return code `${this.reusables.snippets.TermSchema}<${this.expression}>`;
     }
@@ -58,86 +102,32 @@ export class TermType extends AbstractTermType {
     get schemaInitializers() {
         return super.schemaInitializers.concat(code `types: ${arrayOf(...[...this.nodeKinds].map(NodeKind.toTermType))}`);
     }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${[
-            ...this.nodeKinds,
-        ].reduce((expression, nodeKind) => {
-            let valueToNodeKind;
-            switch (nodeKind) {
-                case "BlankNode":
-                    valueToNodeKind = code `${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2))`;
-                    break;
-                case "IRI":
-                    valueToNodeKind = code `${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"])`;
-                    break;
-                case "Literal":
-                    valueToNodeKind = code `${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined))`;
-                    break;
-                default:
-                    throw new RangeError(nodeKind);
-            }
-            return expression == null
-                ? valueToNodeKind
-                : code `((${variables.value}.termType === "${NodeKind.toTermType(nodeKind)}") ? (${valueToNodeKind}) : (${expression}))`;
-        }, null)})`;
-    }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
     }
-    jsonSchema(_parameters) {
-        return code `${this.reusables.imports.z}.discriminatedUnion("termType", [${joinCode([...this.nodeKinds].map((nodeKind) => {
-            switch (nodeKind) {
-                case "BlankNode":
-                case "IRI":
-                    return code `${this.reusables.imports.z}.object({ "@id": ${this.reusables.imports.z}.string().min(1), termType: ${this.reusables.imports.z}.literal("${NodeKind.toTermType(nodeKind)}") })`;
-                case "Literal":
-                    return code `${this.reusables.imports.z}.object({ "@language": ${this.reusables.imports.z}.string().optional(), "@type": ${this.reusables.imports.z}.string().optional(), "@value": ${this.reusables.imports.z}.string(), termType: ${this.reusables.imports.z}.literal("Literal") })`;
-                default:
-                    throw new RangeError(nodeKind);
-            }
-        }), { on: "," })}])`;
-    }
-    jsonType() {
-        return new AbstractTermType.JsonType(code `{ readonly "@id": string, readonly termType: ${[...this.nodeKinds]
-            .filter((nodeKind) => nodeKind !== "Literal")
-            .map((nodeKind) => `"${NodeKind.toTermType(nodeKind)}"`)
-            .join(" | ")} } | { readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string, readonly termType: "Literal" }`);
-    }
-    toJsonExpression({ variables, }) {
-        return [...this.nodeKinds].reduce((expression, nodeKind) => {
-            let valueToNodeKind;
-            switch (nodeKind) {
-                case "BlankNode":
-                    valueToNodeKind = code `{ "@id": \`_:\${${variables.value}.value}\`, termType: "${NodeKind.toTermType(nodeKind)}" as const }`;
-                    break;
-                case "IRI":
-                    valueToNodeKind = code `{ "@id": ${variables.value}.value, termType: "${NodeKind.toTermType(nodeKind)}" as const }`;
-                    break;
-                case "Literal":
-                    valueToNodeKind = code `{ "@language": ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined, "@type": ${variables.value}.datatype.value !== "${xsd.string.value}" ? ${variables.value}.datatype.value : undefined, "@value": ${variables.value}.value, termType: "${NodeKind.toTermType(nodeKind)}" as const }`;
-                    break;
-                default:
-                    throw new RangeError(nodeKind);
-            }
-            return expression === null
-                ? valueToNodeKind
-                : code `(${variables.value}.termType === "${NodeKind.toTermType(nodeKind)}") ? ${valueToNodeKind} : ${expression}`;
-        }, null);
+    toLoggableExpression({ variables, }) {
+        return code `${this.toJsonObjectFunction.annotatedUsage}(${variables.value})`;
     }
 }
 __decorate([
     Memoize()
-], TermType.prototype, "fromRdfResourceValuesFunction", null);
+], TermType.prototype, "discriminatedType", null);
 __decorate([
     Memoize()
 ], TermType.prototype, "filterType", null);
 __decorate([
     Memoize()
-], TermType.prototype, "schemaType", null);
+], TermType.prototype, "fromJsonObjectFunction", null);
 __decorate([
     Memoize()
-], TermType.prototype, "inlineExpression", null);
+], TermType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], TermType.prototype, "jsonObjectType", null);
 __decorate([
     Memoize()
-], TermType.prototype, "jsonType", null);
+], TermType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], TermType.prototype, "inlineExpression", null);
 //# sourceMappingURL=TermType.js.map

package/dist/generators/ts/TsFeature.d.ts

@@ -1,3 +1,6 @@
 export type TsFeature = (typeof TS_FEATURES)[number];
-export declare const TS_FEATURES: readonly ["GraphQL", "JSON", "Object.create", "Object.equals", "Object.filter", "Object.fromJson", "Object.fromRdf", "Object.hash", "Object.JSON", "Object.JSON.type", "Object.JSON.parse", "Object.JSON.schema", "Object.JSON.uiSchema", "Object.RDF", "Object.schema", "Object.SPARQL", "Object.toJson", "Object.toRdf", "Object.toString", "Object.type", "ObjectSet", "RDF", "RdfjsDatasetObjectSet", "SPARQL", "SparqlObjectSet"];
+export declare const TS_FEATURES: readonly ["GraphQL", "JSON", "LoggingService", "Object.create", "Object.equals", "Object.filter", "Object.fromJson", "Object.fromRdf", "Object.hash", "Object.JSON", "Object.JSON.type", "Object.JSON.parse", "Object.JSON.schema", "Object.JSON.uiSchema", "Object.RDF", "Object.schema", "Object.SPARQL", "Object.toJson", "Object.toLoggable", "Object.toRdf", "Object.toString", "Object.type", "ObjectSet", "RDF", "RdfjsDatasetObjectSet", "SPARQL", "SparqlObjectSet", "Service", "ServiceHttpApi", "ServiceHttpClient"];
+export declare namespace TsFeature {
+    const dependencies: Record<TsFeature, TsFeature[]>;
+}
 //# sourceMappingURL=TsFeature.d.ts.map

package/dist/generators/ts/TsFeature.js

@@ -1,6 +1,7 @@
 export const TS_FEATURES = [
     "GraphQL",
     "JSON",
+    "LoggingService",
     "Object.create",
     "Object.equals",
     "Object.filter",
@@ -16,6 +17,7 @@ export const TS_FEATURES = [
     "Object.schema",
     "Object.SPARQL",
     "Object.toJson",
+    "Object.toLoggable",
     "Object.toRdf",
     "Object.toString",
     "Object.type",
@@ -24,5 +26,54 @@ export const TS_FEATURES = [
     "RdfjsDatasetObjectSet",
     "SPARQL",
     "SparqlObjectSet",
+    "Service",
+    "ServiceHttpApi",
+    "ServiceHttpClient",
 ];
+export var TsFeature;
+(function (TsFeature) {
+    TsFeature.dependencies = {
+        GraphQL: ["ObjectSet"],
+        // Alias for other features, not dependencies per se
+        JSON: ["Object.JSON"],
+        LoggingService: ["Object.toLoggable", "Service"],
+        "Object.create": ["Object.schema", "Object.toString", "Object.type"],
+        "Object.equals": ["Object.type"],
+        "Object.filter": ["Object.type"],
+        "Object.fromJson": ["Object.create", "Object.JSON.type", "Object.type"],
+        "Object.fromRdf": ["Object.create", "Object.schema"],
+        "Object.hash": [],
+        // Alias for other features, not dependencies per se
+        "Object.JSON": [
+            "Object.fromJson",
+            "Object.JSON.parse",
+            "Object.JSON.schema",
+            "Object.JSON.type",
+            "Object.JSON.uiSchema",
+            "Object.toJson",
+        ],
+        "Object.JSON.parse": ["Object.JSON.schema", "Object.JSON.type"],
+        "Object.JSON.type": [],
+        "Object.JSON.schema": ["Object.JSON.type"],
+        "Object.JSON.uiSchema": [],
+        // Alias for other features, not dependencies per se
+        "Object.RDF": ["Object.fromRdf", "Object.toRdf"],
+        "Object.schema": [],
+        "Object.toJson": ["Object.JSON.type", "Object.type"],
+        "Object.toLoggable": ["Object.type"],
+        "Object.toRdf": ["Object.schema", "Object.type"],
+        "Object.toString": ["Object.type"],
+        "Object.SPARQL": ["Object.schema"],
+        "Object.type": [], // Implies Object.Identifier
+        ObjectSet: ["Object.filter"],
+        // Alias for other features, not dependencies per se
+        RDF: ["Object.RDF", "RdfjsDatasetObjectSet"],
+        RdfjsDatasetObjectSet: ["Object.fromRdf", "ObjectSet"],
+        Service: ["Object.type"],
+        ServiceHttpApi: ["Service"],
+        ServiceHttpClient: ["Service"],
+        SPARQL: ["Object.SPARQL", "SparqlObjectSet"],
+        SparqlObjectSet: ["Object.SPARQL", "ObjectSet"],
+    };
+})(TsFeature || (TsFeature = {}));
 //# sourceMappingURL=TsFeature.js.map

package/dist/generators/ts/TsGenerator.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from "@rdfx/logger";
 import type * as ast from "../../ast/index.js";
 import type { Generator } from "../Generator.js";
-import type { TsFeature } from "./TsFeature.js";
+import { TsFeature } from "./TsFeature.js";
 export declare class TsGenerator implements Generator {
     private readonly configuration?;
     private readonly logger;
@@ -11,6 +11,7 @@ export declare class TsGenerator implements Generator {
     });
     generate(ast_: ast.Ast): string;
     private objectSetTypeDeclarations;
+    private serviceDeclarations;
 }
 export declare namespace TsGenerator {
     interface Configuration {