@shaclmate/compiler 4.0.50 → 4.0.52

package/dist/generators/ts/GraphqlSchema.js

@@ -0,0 +1,87 @@
+import { code } from "./ts-poet-wrapper.js";
+export class GraphqlSchema {
+    configuration;
+    reusables;
+    namedObjectTypes;
+    namedObjectUnionTypes;
+    constructor({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }) {
+        this.configuration = configuration;
+        this.namedObjectTypes = namedObjectTypes;
+        this.namedObjectUnionTypes = namedObjectUnionTypes;
+        this.reusables = reusables;
+    }
+    get declaration() {
+        return code `\
+export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query: ${this.graphqlQueryObjectType} });
+`;
+    }
+    get graphqlQueryObjectType() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        return code `new ${this.reusables.imports.GraphQLObjectType}<null, { objectSet: ${syntheticNamePrefix}ObjectSet }>({ name: "Query", fields: ${[
+            ...this.namedObjectTypes,
+            ...this.namedObjectUnionTypes,
+        ].reduce((fields, namedObjectType) => {
+            fields[namedObjectType.objectSetMethodNames.object] = {
+                args: {
+                    identifier: {
+                        type: code `new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLID})`,
+                    },
+                },
+                resolve: code `\
+  async (_source, args: { identifier: string }, { objectSet }): Promise<${namedObjectType.expression}> => 
+    (await ${this.reusables.imports.EitherAsync}<Error, ${namedObjectType.expression}>(async ({ liftEither }) => 
+      liftEither(await objectSet.${namedObjectType.objectSetMethodNames.object}(await liftEither(${namedObjectType.identifierTypeAlias}.parse(args.identifier))))
+    )).unsafeCoerce()`,
+                type: namedObjectType.graphqlType.expression,
+            };
+            fields[namedObjectType.objectSetMethodNames.objectIdentifiers] = {
+                args: {
+                    limit: {
+                        type: code `${this.reusables.imports.GraphQLInt}`,
+                    },
+                    offset: {
+                        type: code `${this.reusables.imports.GraphQLInt}`,
+                    },
+                },
+                resolve: code `\
+   async (_source, args: { limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly string[]> =>
+    (await objectSet.${namedObjectType.objectSetMethodNames.objectIdentifiers}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined })).unsafeCoerce().map(${namedObjectType.identifierTypeAlias}.stringify)`,
+                type: code `new ${this.reusables.imports.GraphQLNonNull}(new ${this.reusables.imports.GraphQLList}(${this.reusables.imports.GraphQLString}))`,
+            };
+            fields[namedObjectType.objectSetMethodNames.objects] = {
+                args: {
+                    identifiers: {
+                        type: code `new ${this.reusables.imports.GraphQLList}(new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLID}))`,
+                    },
+                    limit: {
+                        type: code `${this.reusables.imports.GraphQLInt}`,
+                    },
+                    offset: {
+                        type: code `${this.reusables.imports.GraphQLInt}`,
+                    },
+                },
+                resolve: code `\
+  async (_source, args: { identifiers: readonly string[] | null; limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly ${namedObjectType.expression}[]> =>
+  (await ${this.reusables.imports.EitherAsync}<Error, readonly ${namedObjectType.expression}[]>(async ({ liftEither }) => {
+    let filter: ${namedObjectType.filterType} | undefined;
+    if (args.identifiers) {
+      const identifiers: ${namedObjectType.identifierTypeAlias}[] = [];
+      for (const identifierArg of args.identifiers) {
+        identifiers.push(await liftEither(${namedObjectType.identifierTypeAlias}.parse(identifierArg)));
+      }
+      filter = { ${syntheticNamePrefix}identifier: { in: identifiers } };
+    }
+    return await liftEither(await objectSet.${namedObjectType.objectSetMethodNames.objects}({ filter, limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined }));
+  })).unsafeCoerce()`,
+                type: code `new ${this.reusables.imports.GraphQLNonNull}(new ${this.reusables.imports.GraphQLList}(${namedObjectType.graphqlType.expression}))`,
+            };
+            fields[namedObjectType.objectSetMethodNames.objectCount] = {
+                resolve: code `\
+  async (_source, _args, { objectSet }): Promise<number> => (await objectSet.${namedObjectType.objectSetMethodNames.objectCount}()).unsafeCoerce()`,
+                type: code `new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLInt})`,
+            };
+            return fields;
+        }, {})} })`;
+    }
+}
+//# sourceMappingURL=GraphqlSchema.js.map

package/dist/generators/ts/IdentifierType.d.ts

@@ -0,0 +1,23 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+import { type IdentifierNodeKind } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
+import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class IdentifierType extends AbstractIdentifierType<BlankNode | NamedNode> {
+    protected readonly inlineExpression: Code;
+    readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
+    readonly filterFunction: Code;
+    readonly filterType: Code;
+    readonly fromRdfResourceValuesFunction: Code;
+    readonly kind = "Identifier";
+    readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
+    readonly parseFunction: Code;
+    readonly schemaType: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
+    constructor(parameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "hasValues" | "in_">);
+    fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
+    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
+    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
+}
+//# sourceMappingURL=IdentifierType.d.ts.map

package/dist/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 { NodeKind } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
+import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import { arrayOf, code } from "./ts-poet-wrapper.js";
+export class IdentifierType extends AbstractIdentifierType {
+    inlineExpression = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
+    conversionFunction = Maybe.of({
+        code: code `${this.reusables.snippets.convertToIdentifier}`,
+        sourceTypes: [
+            {
+                expression: code `${this.reusables.imports.BlankNode}`,
+                jsType: this.jsTypes[0],
+            },
+            {
+                expression: code `${this.reusables.imports.NamedNode}`,
+                jsType: this.jsTypes[0],
+            },
+            {
+                // To NamedNode
+                expression: code `string`,
+                jsType: { typeof: "string" },
+            },
+            {
+                // To BlankNode
+                expression: code `undefined`,
+                jsType: { typeof: "undefined" },
+            },
+        ],
+    });
+    filterFunction = code `${this.reusables.snippets.filterIdentifier}`;
+    filterType = code `${this.reusables.snippets.IdentifierFilter}`;
+    fromRdfResourceValuesFunction = code `${this.reusables.snippets.identifierFromRdfResourceValues}`;
+    kind = "Identifier";
+    nodeKinds = nodeKinds;
+    parseFunction = code `${this.reusables.snippets.parseIdentifier};`;
+    schemaType = code `${this.reusables.snippets.IdentifierSchema}`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.identifierSparqlWherePatterns}`;
+    constructor(parameters) {
+        super({
+            ...parameters,
+            hasValues: [],
+            in_: [],
+        });
+    }
+    fromJsonExpression({ variables, }) {
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>((${variables.value}["@id"].startsWith("_:") ? ${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)) : ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"])))`;
+    }
+    jsonSchema({ includeDiscriminantProperty, }) {
+        const discriminantProperty = includeDiscriminantProperty
+            ? code `, termType: ${this.reusables.imports.z}.enum(${arrayOf(...this.nodeKinds)})`
+            : "";
+        return code `${this.reusables.imports.z}.object({ "@id": ${this.reusables.imports.z}.string().min(1)${discriminantProperty} })`;
+    }
+    jsonType(parameters) {
+        const discriminantProperty = parameters?.includeDiscriminantProperty
+            ? `, readonly termType: "BlankNode" | "NamedNode"`
+            : "";
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+    }
+    toJsonExpression({ includeDiscriminantProperty, variables, }) {
+        const discriminantProperty = includeDiscriminantProperty
+            ? code `, termType: ${variables.value}.termType as ${[...this.nodeKinds].map((nodeKind) => `"${NodeKind.toTermType(nodeKind)}"`).join(" | ")}`
+            : "";
+        const valueToBlankNode = code `{ "@id": \`_:\${${variables.value}.value}\`${discriminantProperty} }`;
+        const valueToNamedNode = code `{ "@id": ${variables.value}.value${discriminantProperty} }`;
+        return code `(${variables.value}.termType === "BlankNode" ? ${valueToBlankNode} : ${valueToNamedNode})`;
+    }
+}
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "jsonType", null);
+const nodeKinds = new Set([
+    "BlankNode",
+    "IRI",
+]);
+//# sourceMappingURL=IdentifierType.js.map

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

@@ -0,0 +1,40 @@
+export declare class Imports {
+    readonly BigDecimal: import("ts-poet/build/Import.js").Import;
+    readonly BlankNode: import("ts-poet/build/Import.js").Import;
+    readonly dataFactory: import("ts-poet/build/Import.js").Import;
+    readonly DatasetCore: import("ts-poet/build/Import.js").Import;
+    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 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;
+    readonly GraphQLDateTime: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLFloat: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLID: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLInt: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLList: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLNonNull: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLObjectType: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLSchema: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLString: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLUnionType: import("ts-poet/build/Import.js").Import;
+    readonly Left: import("ts-poet/build/Import.js").Import;
+    readonly Literal: import("ts-poet/build/Import.js").Import;
+    readonly LiteralFactory: import("ts-poet/build/Import.js").Import;
+    readonly Maybe: import("ts-poet/build/Import.js").Import;
+    readonly NamedNode: import("ts-poet/build/Import.js").Import;
+    readonly NonEmptyList: import("ts-poet/build/Import.js").Import;
+    readonly NTriplesIdentifier: import("ts-poet/build/Import.js").Import;
+    readonly NTriplesTerm: import("ts-poet/build/Import.js").Import;
+    readonly Quad: import("ts-poet/build/Import.js").Import;
+    readonly Quad_Graph: import("ts-poet/build/Import.js").Import;
+    readonly RdfxResourcePropertyPath: import("ts-poet/build/Import.js").Import;
+    readonly Resource: import("ts-poet/build/Import.js").Import;
+    readonly ResourceSet: import("ts-poet/build/Import.js").Import;
+    readonly Right: import("ts-poet/build/Import.js").Import;
+    readonly sparqljs: import("ts-poet/build/Import.js").Import;
+    readonly Variable: import("ts-poet/build/Import.js").Import;
+    readonly z: import("ts-poet/build/Import.js").Import;
+}
+//# sourceMappingURL=Imports.d.ts.map

package/dist/generators/ts/Imports.js

@@ -0,0 +1,41 @@
+import { imp } from "./ts-poet-wrapper.js";
+export class Imports {
+    BigDecimal = imp("Decimal:BigDecimal@decimal.js");
+    BlankNode = imp("BlankNode@@rdfjs/types");
+    dataFactory = imp("dataFactory=@rdfx/data-factory");
+    DatasetCore = imp("DatasetCore@@rdfjs/types");
+    datasetFactory = imp("datasetFactory=@rdfjs/dataset");
+    Either = imp("Either@purify-ts");
+    EitherAsync = imp("EitherAsync@purify-ts");
+    GraphQLBigInt = imp("BigInt:GraphQLBigInt@graphql-scalars");
+    GraphQLBoolean = imp("GraphQLBoolean@graphql");
+    GraphQLDate = imp("Date:GraphQLDate@graphql-scalars");
+    GraphQLDateTime = imp("DateTime:GraphQLDateTime@graphql-scalars");
+    GraphQLFloat = imp("GraphQLFloat@graphql");
+    GraphQLID = imp("GraphQLID@graphql");
+    GraphQLInt = imp("GraphQLInt@graphql");
+    GraphQLList = imp("GraphQLList@graphql");
+    GraphQLNonNull = imp("GraphQLNonNull@graphql");
+    GraphQLObjectType = imp("GraphQLObjectType@graphql");
+    GraphQLSchema = imp("GraphQLSchema@graphql");
+    GraphQLString = imp("GraphQLString@graphql");
+    GraphQLUnionType = imp("GraphQLUnionType@graphql");
+    Left = imp("Left@purify-ts");
+    Literal = imp("Literal@@rdfjs/types");
+    LiteralFactory = imp("LiteralFactory@@rdfx/literal");
+    Maybe = imp("Maybe@purify-ts");
+    NamedNode = imp("NamedNode@@rdfjs/types");
+    NonEmptyList = imp("NonEmptyList@purify-ts");
+    NTriplesIdentifier = imp("NTriplesIdentifier@@rdfx/string");
+    NTriplesTerm = imp("NTriplesTerm@@rdfx/string");
+    Quad = imp("Quad@@rdfjs/types");
+    Quad_Graph = imp("Quad_Graph@@rdfjs/types");
+    RdfxResourcePropertyPath = imp("PropertyPath:RdfxResourcePropertyPath@@rdfx/resource");
+    Resource = imp("Resource@@rdfx/resource");
+    ResourceSet = imp("ResourceSet@@rdfx/resource");
+    Right = imp("Right@purify-ts");
+    sparqljs = imp("sparqljs*sparqljs");
+    Variable = imp("Variable@@rdfjs/types");
+    z = imp("z@zod");
+}
+//# sourceMappingURL=Imports.js.map

package/dist/generators/ts/IntType.d.ts

@@ -0,0 +1,13 @@
+import type { Literal } from "@rdfjs/types";
+import { AbstractNumericType } from "./AbstractNumericType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class IntType extends AbstractNumericType<number> {
+    readonly jsTypes: readonly [{
+        readonly typeof: "number";
+    }];
+    readonly kind = "Int";
+    get fromRdfResourceValuesFunction(): Code;
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
+    literalValueExpression(literal: Literal | number): Code;
+}
+//# sourceMappingURL=IntType.d.ts.map

package/dist/generators/ts/IntType.js

@@ -0,0 +1,30 @@
+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 { LiteralDecoder } from "@rdfx/literal";
+import { Memoize } from "typescript-memoize";
+import { AbstractNumericType } from "./AbstractNumericType.js";
+import { code } from "./ts-poet-wrapper.js";
+export class IntType extends AbstractNumericType {
+    jsTypes = [{ typeof: "number" }];
+    kind = "Int";
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.intFromRdfResourceValues}<${this.expression}>`;
+    }
+    get graphqlType() {
+        return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLInt}`, this.reusables);
+    }
+    literalValueExpression(literal) {
+        return code `${typeof literal === "number" ? literal : LiteralDecoder.decodeIntLiteral(literal).unsafeCoerce()}`;
+    }
+}
+__decorate([
+    Memoize()
+], IntType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], IntType.prototype, "graphqlType", null);
+//# sourceMappingURL=IntType.js.map

package/dist/generators/ts/IriType.d.ts

@@ -0,0 +1,23 @@
+import type { NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class IriType extends AbstractIdentifierType<NamedNode> {
+    readonly filterFunction: Code;
+    readonly filterType: Code;
+    readonly kind = "Iri";
+    readonly nodeKinds: ReadonlySet<"IRI">;
+    readonly schemaType: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
+    get conversionFunction(): Maybe<AbstractIdentifierType.ConversionFunction>;
+    get fromRdfResourceValuesFunction(): Code;
+    get parseFunction(): Code;
+    protected get inlineExpression(): Code;
+    protected get schemaInitializers(): readonly Code[];
+    private get valueTypeExpression();
+    fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<NamedNode>["fromJsonExpression"]>[0]): Code;
+    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<NamedNode>["jsonSchema"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractIdentifierType<NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
+    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<NamedNode>["toJsonExpression"]>[0]): Code;
+}
+//# sourceMappingURL=IriType.d.ts.map

package/dist/generators/ts/IriType.js

@@ -0,0 +1,112 @@
+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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
+export class IriType extends AbstractIdentifierType {
+    filterFunction = code `${this.reusables.snippets.filterIri}`;
+    filterType = code `${this.reusables.snippets.IriFilter}`;
+    kind = "Iri";
+    nodeKinds = nodeKinds;
+    schemaType = code `${this.reusables.snippets.IriSchema}<${this.valueTypeExpression}>`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.iriSparqlWherePatterns}`;
+    get conversionFunction() {
+        invariant(this.jsTypes.length === 1);
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToIri}<${this.valueTypeExpression}>`,
+            sourceTypes: [
+                {
+                    expression: this.valueTypeExpression,
+                    jsType: { typeof: "string" },
+                },
+                {
+                    expression: this.expression,
+                    jsType: this.jsTypes[0],
+                },
+            ],
+        });
+    }
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.iriFromRdfResourceValues}<${this.valueTypeExpression}>`;
+    }
+    get parseFunction() {
+        if (this.in_.length > 0) {
+            return code `(identifier: string) => ${this.reusables.snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${this.reusables.imports.Right}(identifier as ${this.expression});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
+        }
+        return code `${this.reusables.snippets.parseIri}`;
+    }
+    get inlineExpression() {
+        if (this.in_.length > 0) {
+            return code `${this.reusables.imports.NamedNode}<${this.valueTypeExpression}>`;
+        }
+        return code `${this.reusables.imports.NamedNode}`;
+    }
+    get schemaInitializers() {
+        let initializers = super.schemaInitializers;
+        if (this.in_.length > 0) {
+            initializers = initializers.concat(code `in: ${arrayOf(...this.in_.map((in_) => this.rdfjsTermExpression(in_)))}`);
+        }
+        return initializers;
+    }
+    get valueTypeExpression() {
+        return this.in_.length > 0
+            ? code `(${this.in_.map((in_) => `"${in_.value}"`).join(" | ")})`
+            : code `string`;
+    }
+    fromJsonExpression({ variables, }) {
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
+    }
+    jsonSchema({ includeDiscriminantProperty, }) {
+        let idSchema;
+        if (this.in_.length > 0) {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            idSchema = code `${this.reusables.imports.z}.enum(${arrayOf(...this.in_.map((iri) => iri.value))})`;
+        }
+        else {
+            idSchema = code `${this.reusables.imports.z}.string().min(1)`;
+        }
+        const discriminantProperty = includeDiscriminantProperty
+            ? code `, termType: ${this.reusables.imports.z}.literal("NamedNode")`
+            : "";
+        return code `${this.reusables.imports.z}.object({ "@id": ${idSchema}${discriminantProperty} })`;
+    }
+    jsonType(parameters) {
+        const discriminantProperty = parameters?.includeDiscriminantProperty
+            ? `, readonly termType: "NamedNode"`
+            : "";
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": ${this.valueTypeExpression}${discriminantProperty} }`);
+    }
+    toJsonExpression({ includeDiscriminantProperty, variables, }) {
+        const discriminantProperty = includeDiscriminantProperty
+            ? code `, termType: ${variables.value}.termType`
+            : "";
+        return code `{ "@id": ${variables.value}.value${discriminantProperty} }`;
+    }
+}
+__decorate([
+    Memoize()
+], IriType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "parseFunction", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "valueTypeExpression", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "jsonType", null);
+const nodeKinds = new Set(["IRI"]);
+//# sourceMappingURL=IriType.js.map

package/dist/generators/ts/LazyOptionType.d.ts

@@ -0,0 +1,36 @@
+import { Maybe } from "purify-ts";
+import { AbstractLazyType } from "./AbstractLazyType.js";
+import type { OptionType } from "./OptionType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+type Super = AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>;
+declare const Super: (abstract new ({ partialType, resolveType, ...superParameters }: {
+    partialType: OptionType<AbstractLazyType.ItemTypeConstraint>;
+    resolveType: OptionType<AbstractLazyType.ItemTypeConstraint>;
+} & {
+    name: Maybe<string>;
+    comment: Maybe<string>;
+    configuration: import("./TsGenerator.js").TsGenerator.Configuration;
+    label: Maybe<string>;
+    logger: import("ts-log").Logger;
+    reusables: import("./Reusables.js").Reusables;
+    shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode;
+}) => AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>) & {
+    readonly GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+    JsType: typeof import("./AbstractType.js").AbstractType.JsType;
+};
+export declare class LazyOptionType extends Super {
+    readonly graphqlArgs: Super["graphqlArgs"];
+    readonly kind = "LazyOption";
+    get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
+    protected get runtimeClass(): {
+        name: Code;
+        partialPropertyName: string;
+        rawName: Code;
+    };
+    fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
+    get fromRdfResourceValuesFunction(): Code;
+    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
+}
+export {};
+//# sourceMappingURL=LazyOptionType.d.ts.map

package/dist/generators/ts/LazyOptionType.js

@@ -0,0 +1,75 @@
+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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractLazyType } from "./AbstractLazyType.js";
+import { code } from "./ts-poet-wrapper.js";
+const Super = (AbstractLazyType);
+export class LazyOptionType extends Super {
+    graphqlArgs = Maybe.empty();
+    kind = "LazyOption";
+    get conversionFunction() {
+        invariant(this.jsTypes.length === 1);
+        invariant(this.resolveType.jsTypes.length === 1);
+        invariant(this.resolveType.itemType.jsTypes.length === 1);
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToLazyOption}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            sourceTypes: [
+                {
+                    expression: this.expression,
+                    jsType: this.jsTypes[0],
+                },
+                {
+                    expression: this.resolveType.expression,
+                    jsType: this.resolveType.jsTypes[0],
+                },
+                {
+                    expression: this.resolveType.itemType.expression,
+                    jsType: this.resolveType.itemType.jsTypes[0],
+                },
+                {
+                    expression: code `undefined`,
+                    jsType: { typeof: "undefined" },
+                },
+            ],
+        });
+    }
+    get runtimeClass() {
+        return {
+            name: code `${this.reusables.snippets.LazyOption}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
+            partialPropertyName: "partial",
+            rawName: code `${this.reusables.snippets.LazyOption}`,
+        };
+    }
+    fromJsonExpression(parameters) {
+        return code `${this.partialType.fromJsonExpression(parameters)}.map(partial => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: partial, resolver: (partial) => Promise.resolve(${this.reusables.imports.Left}(new Error(\`unable to resolve \${partial} deserialized from JSON\`))) }))`;
+    }
+    get fromRdfResourceValuesFunction() {
+        return code `\
+(
+    (
+      (values, { objectSet, schema, ...otherOptions }) =>
+        ${this.partialType.fromRdfResourceValuesFunction}(values, { ...otherOptions, objectSet, schema: schema.partialType })
+          .map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (partial, options) => objectSet.${this.resolveType.itemType.objectSetMethodNames.object}(partial.${this.configuration.syntheticNamePrefix}identifier(), options) })))
+    ) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>
+)`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return code `${variables.value}.resolve().then(either => either.unsafeCoerce().extractNullable())`;
+    }
+}
+__decorate([
+    Memoize()
+], LazyOptionType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], LazyOptionType.prototype, "runtimeClass", null);
+__decorate([
+    Memoize()
+], LazyOptionType.prototype, "fromRdfResourceValuesFunction", null);
+//# sourceMappingURL=LazyOptionType.js.map

package/dist/generators/ts/LazySetType.d.ts

@@ -0,0 +1,20 @@
+import { Maybe } from "purify-ts";
+import { AbstractLazyType } from "./AbstractLazyType.js";
+import type { SetType } from "./SetType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class LazySetType extends AbstractLazyType<SetType<AbstractLazyType.ItemTypeConstraint>, SetType<AbstractLazyType.ItemTypeConstraint>> {
+    readonly graphqlArgs: Super["graphqlArgs"];
+    readonly kind = "LazySet";
+    get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
+    protected get runtimeClass(): {
+        name: Code;
+        partialPropertyName: string;
+        rawName: Code;
+    };
+    fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
+    get fromRdfResourceValuesFunction(): Code;
+    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
+}
+type Super = AbstractLazyType<SetType<AbstractLazyType.ItemTypeConstraint>, SetType<AbstractLazyType.ItemTypeConstraint>>;
+export {};
+//# sourceMappingURL=LazySetType.d.ts.map