@shaclmate/compiler 3.0.3 → 4.0.0

package/dist/generators/ts/IdentifierType.js

@@ -4,191 +4,64 @@ 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 { StructureKind, VariableDeclarationKind, } from "ts-morph";
+import { NodeKind } from "@shaclmate/shacl-ast";
 import { Memoize } from "typescript-memoize";
-import { TermType } from "./TermType.js";
-import { Type } from "./Type.js";
-export class IdentifierType extends TermType {
+import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import { AbstractTermType } from "./AbstractTermType.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
+import { arrayOf, code } from "./ts-poet-wrapper.js";
+export class IdentifierType extends AbstractIdentifierType {
+    filterFunction = code `${snippets.filterIdentifier}`;
+    filterType = code `${snippets.IdentifierFilter}`;
+    fromStringFunction = code `export const fromString = ${snippets.identifierFromString};`;
     kind = "IdentifierType";
-    get conversions() {
-        return super.conversions.concat([
-            {
-                conversionExpression: (value) => `dataFactory.namedNode(${value})`,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "string"`,
-                sourceTypeName: this.in_.length > 0
-                    ? this.in_.map((iri) => `"${iri.value}"`).join(" | ")
-                    : "string",
-            },
-        ]);
+    name = code `(${imports.BlankNode} | ${imports.NamedNode})`;
+    nodeKinds = nodeKinds;
+    schemaType = code `${snippets.IdentifierSchema}`;
+    sparqlWherePatternsFunction = code `${snippets.identifierSparqlWherePatterns}`;
+    constructor(parameters) {
+        super({
+            ...parameters,
+            hasValues: [],
+            in_: [],
+        });
     }
-    get fromStringFunctionDeclaration() {
-        if (this.nodeKinds.has("BlankNode") &&
-            this.nodeKinds.has("NamedNode") &&
-            this.in_.length === 0) {
-            // Wrap rdfjsResource.Resource.Identifier.fromString
-            return {
-                isExported: true,
-                kind: StructureKind.Function,
-                name: "fromString",
-                parameters: [
-                    {
-                        name: "identifier",
-                        type: "string",
-                    },
-                ],
-                returnType: "purify.Either<Error, rdfjsResource.Resource.Identifier>",
-                statements: [
-                    "return purify.Either.encase(() => rdfjsResource.Resource.Identifier.fromString({ dataFactory, identifier }));",
-                ],
-            };
-        }
-        const expressions = [
-            "purify.Either.encase(() => rdfjsResource.Resource.Identifier.fromString({ dataFactory, identifier }))",
-        ];
-        if (this.isNamedNodeKind) {
-            expressions.push(`chain((identifier) => (identifier.termType === "NamedNode") ? purify.Either.of(identifier) : purify.Left(new Error("expected identifier to be NamedNode")))`);
-            if (this.in_.length > 0) {
-                expressions.push(`chain((identifier) => { switch (identifier.value) { ${this.in_.map((iri) => `case "${iri.value}": return purify.Either.of(identifier as rdfjs.NamedNode<"${iri.value}">);`).join(" ")} default: return purify.Left(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`);
-            }
-        }
-        return {
-            isExported: true,
-            kind: StructureKind.Function,
-            name: "fromString",
-            parameters: [
-                {
-                    name: "identifier",
-                    type: "string",
-                },
-            ],
-            returnType: `purify.Either<Error, ${this.name}>`,
-            statements: [
-                `return ${expressions.join(".")} as purify.Either<Error, ${this.name}>;`,
-            ],
-        };
-    }
-    get graphqlName() {
-        return new Type.GraphqlName("graphql.GraphQLString");
-    }
-    get isNamedNodeKind() {
-        return this.nodeKinds.size === 1 && this.nodeKinds.has("NamedNode");
-    }
-    get jsonName() {
-        if (this.in_.length > 0 && this.isNamedNodeKind) {
-            // Treat sh:in as a union of the IRIs
-            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            return new Type.JsonName(`{ readonly "@id": ${this.in_.map((iri) => `"${iri.value}"`).join(" | ")} }`);
-        }
-        return new Type.JsonName(`{ readonly "@id": string }`);
+    fromJsonExpression({ variables, }) {
+        return code `(${variables.value}["@id"].startsWith("_:") ? ${imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)) : ${imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
     }
-    get name() {
-        if (this.in_.length > 0 && this.isNamedNodeKind) {
-            // Treat sh:in as a union of the IRIs
-            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            return `rdfjs.NamedNode<${this.in_
-                .map((iri) => `"${iri.value}"`)
-                .join(" | ")}>`;
-        }
-        return `(${[...this.nodeKinds]
-            .map((nodeKind) => `rdfjs.${nodeKind}`)
-            .join(" | ")})`;
+    jsonType(parameters) {
+        const discriminantProperty = parameters?.includeDiscriminantProperty
+            ? `, readonly termType: "BlankNode" | "NamedNode"`
+            : "";
+        return new AbstractTermType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
     }
-    get toStringFunctionDeclaration() {
-        // Re-export rdfjsResource.Resource.Identifier.toString
-        return {
-            declarationKind: VariableDeclarationKind.Const,
-            isExported: true,
-            kind: StructureKind.VariableStatement,
-            declarations: [
-                {
-                    initializer: "rdfjsResource.Resource.Identifier.toString",
-                    leadingTrivia: "// biome-ignore lint/suspicious/noShadowRestrictedNames:",
-                    name: "toString",
-                },
-            ],
-        };
+    jsonZodSchema({ includeDiscriminantProperty, }) {
+        const discriminantProperty = includeDiscriminantProperty
+            ? code `, termType: ${imports.z}.enum(${arrayOf(...this.nodeKinds)})`
+            : "";
+        return code `${imports.z}.object({ "@id": ${imports.z}.string().min(1)${discriminantProperty} })`;
     }
-    fromJsonExpression({ variables, }) {
-        const valueToBlankNode = `dataFactory.blankNode(${variables.value}["@id"].substring(2))`;
-        const valueToNamedNode = `dataFactory.namedNode(${variables.value}["@id"])`;
-        if (this.nodeKinds.size === 2) {
-            return `(${variables.value}["@id"].startsWith("_:") ? ${valueToBlankNode} : ${valueToNamedNode})`;
-        }
-        switch ([...this.nodeKinds][0]) {
-            case "BlankNode":
-                return valueToBlankNode;
-            case "NamedNode":
-                return valueToNamedNode;
-        }
+    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})`;
     }
     fromRdfExpressionChain({ variables, }) {
-        let valueToExpression;
-        if (this.nodeKinds.size === 2) {
-            valueToExpression = "value.toIdentifier()";
-        }
-        else if (this.isNamedNodeKind) {
-            valueToExpression = "value.toIri()";
-            if (this.in_.length > 0) {
-                const eitherTypeParameters = `<Error, ${this.name}>`;
-                valueToExpression = `${valueToExpression}.chain(iri => { switch (iri.value) { ${this.in_.map((iri) => `case "${iri.value}": return purify.Either.of${eitherTypeParameters}(iri as rdfjs.NamedNode<"${iri.value}">);`).join(" ")} default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError({ actualValue: iri, expectedValueType: ${JSON.stringify(this.name)}, focusResource: ${variables.resource}, predicate: ${variables.predicate} })); } } )`;
-            }
-        }
-        else {
-            throw new Error("not implemented");
-        }
         return {
             ...super.fromRdfExpressionChain({ variables }),
-            valueTo: `chain(values => values.chainMap(value => ${valueToExpression}))`,
+            valueTo: code `chain(values => values.chainMap(value => value.toIdentifier()))`,
         };
     }
-    graphqlResolveExpression({ variables: { value }, }) {
-        return `rdfjsResource.Resource.Identifier.toString(${value})`;
-    }
-    jsonZodSchema({ variables, }) {
-        let idSchema;
-        if (this.in_.length > 0 && this.isNamedNodeKind) {
-            // Treat sh:in as a union of the IRIs
-            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            idSchema = `${variables.zod}.enum(${JSON.stringify(this.in_.map((iri) => iri.value))})`;
-        }
-        else {
-            idSchema = `${variables.zod}.string().min(1)`;
-        }
-        return `${variables.zod}.object({ "@id": ${idSchema} })`;
-    }
-    toJsonExpression({ variables, }) {
-        const valueToBlankNode = `{ "@id": \`_:\${${variables.value}.value}\` }`;
-        const valueToNamedNode = `{ "@id": ${variables.value}.value }`;
-        if (this.nodeKinds.size === 2) {
-            return `(${variables.value}.termType === "BlankNode" ? ${valueToBlankNode} : ${valueToNamedNode})`;
-        }
-        switch ([...this.nodeKinds][0]) {
-            case "BlankNode":
-                return valueToBlankNode;
-            case "NamedNode":
-                return valueToNamedNode;
-        }
-    }
 }
 __decorate([
     Memoize()
-], IdentifierType.prototype, "conversions", null);
-__decorate([
-    Memoize()
-], IdentifierType.prototype, "fromStringFunctionDeclaration", null);
-__decorate([
-    Memoize()
-], IdentifierType.prototype, "graphqlName", null);
-__decorate([
-    Memoize()
-], IdentifierType.prototype, "isNamedNodeKind", null);
-__decorate([
-    Memoize()
-], IdentifierType.prototype, "jsonName", null);
-__decorate([
-    Memoize()
-], IdentifierType.prototype, "name", null);
-__decorate([
-    Memoize()
-], IdentifierType.prototype, "toStringFunctionDeclaration", null);
+], IdentifierType.prototype, "jsonType", null);
+const nodeKinds = new Set([
+    "BlankNode",
+    "IRI",
+]);
 //# sourceMappingURL=IdentifierType.js.map

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

@@ -1,6 +1,11 @@
-import { NumberType } from "./NumberType.js";
-import { Type } from "./Type.js";
-export declare class IntType extends NumberType {
-    get graphqlName(): Type.GraphqlName;
+import { NonEmptyList } from "purify-ts";
+import { AbstractNumericType } from "./AbstractNumericType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class IntType extends AbstractNumericType<number> {
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly kind = "IntType";
+    readonly typeofs: NonEmptyList<"number">;
+    protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<number>["fromRdfResourceValueExpression"]>[0]): Code;
+    protected literalOf(value: number): string;
 }
 //# sourceMappingURL=IntType.d.ts.map

package/dist/generators/ts/IntType.js

@@ -1,18 +1,16 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Memoize } from "typescript-memoize";
-import { NumberType } from "./NumberType.js";
-import { Type } from "./Type.js";
-export class IntType extends NumberType {
-    get graphqlName() {
-        return new Type.GraphqlName("graphql.GraphQLInt");
+import { NonEmptyList } from "purify-ts";
+import { AbstractNumericType } from "./AbstractNumericType.js";
+import { imports } from "./imports.js";
+import { code } from "./ts-poet-wrapper.js";
+export class IntType extends AbstractNumericType {
+    graphqlType = new AbstractNumericType.GraphqlType(code `${imports.GraphQLInt}`);
+    kind = "IntType";
+    typeofs = NonEmptyList(["number"]);
+    fromRdfResourceValueExpression({ variables, }) {
+        return code `${variables.value}.toInt(${this.primitiveIn.length > 0 ? `${JSON.stringify(this.primitiveIn)} as const` : ""})`;
+    }
+    literalOf(value) {
+        return value.toString();
     }
 }
-__decorate([
-    Memoize()
-], IntType.prototype, "graphqlName", null);
 //# sourceMappingURL=IntType.js.map

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

@@ -0,0 +1,24 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import { AbstractTermType } from "./AbstractTermType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class IriType extends AbstractIdentifierType<NamedNode> {
+    readonly filterFunction: Code;
+    readonly filterType: Code;
+    readonly kind = "IriType";
+    readonly nodeKinds: ReadonlySet<"IRI">;
+    readonly schemaType: Code;
+    readonly sparqlWherePatternsFunction: Code;
+    get fromStringFunction(): Code;
+    get name(): Code;
+    protected get schemaObject(): {
+        in: Code[] | undefined;
+        kind: Code;
+    };
+    fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
+    jsonZodSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>[0]): Code;
+    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
+    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractTermType["fromRdfExpressionChain"]>;
+}
+//# sourceMappingURL=IriType.d.ts.map

package/dist/generators/ts/IriType.js

@@ -0,0 +1,106 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
+import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import { AbstractTermType } from "./AbstractTermType.js";
+import { imports } from "./imports.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+import { snippets } from "./snippets.js";
+import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
+export class IriType extends AbstractIdentifierType {
+    filterFunction = code `${snippets.filterIri}`;
+    filterType = code `${snippets.IriFilter}`;
+    kind = "IriType";
+    nodeKinds = nodeKinds;
+    schemaType = code `${snippets.IriSchema}`;
+    sparqlWherePatternsFunction = code `${snippets.iriSparqlWherePatterns}`;
+    get fromStringFunction() {
+        const expressions = [
+            code `${imports.Either}.encase(() => ${imports.Resource}.Identifier.fromString({ ${imports.dataFactory}, identifier }))`,
+            code `chain((identifier) => (identifier.termType === "NamedNode") ? ${imports.Right}(identifier) : ${imports.Left}(new Error("expected identifier to be NamedNode")))`,
+        ];
+        if (this.in_.length > 0) {
+            expressions.push(code `chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${imports.Right}(identifier as ${imports.NamedNode}<"${iri.value}">);`))} default: return ${imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`);
+        }
+        return code `\
+export function fromString(identifier: string): ${imports.Either}<Error, ${this.name}> {
+  return ${joinCode(expressions, { on: "." })} as ${imports.Either}<Error, ${this.name}>;
+}`;
+    }
+    get name() {
+        if (this.in_.length > 0) {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            return code `${imports.NamedNode}<${this.in_
+                .map((iri) => `"${iri.value}"`)
+                .join(" | ")}>`;
+        }
+        return code `${imports.NamedNode}`;
+    }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            in: this.in_.length > 0
+                ? this.in_.map(rdfjsTermExpression).concat()
+                : undefined,
+        };
+    }
+    fromJsonExpression({ variables, }) {
+        return code `${imports.dataFactory}.namedNode(${variables.value}["@id"])`;
+    }
+    jsonType(parameters) {
+        const discriminantProperty = parameters?.includeDiscriminantProperty
+            ? `, readonly termType: "NamedNode"`
+            : "";
+        if (this.in_.length > 0) {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            return new AbstractTermType.JsonType(code `{ readonly "@id": ${this.in_.map((iri) => `"${iri.value}"`).join(" | ")}${discriminantProperty} }`);
+        }
+        return new AbstractTermType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+    }
+    jsonZodSchema({ 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 `${imports.z}.enum(${arrayOf(...this.in_.map((iri) => iri.value))})`;
+        }
+        else {
+            idSchema = code `${imports.z}.string().min(1)`;
+        }
+        const discriminantProperty = includeDiscriminantProperty
+            ? code `, termType: ${imports.z}.literal("NamedNode")`
+            : "";
+        return code `${imports.z}.object({ "@id": ${idSchema}${discriminantProperty} })`;
+    }
+    toJsonExpression({ includeDiscriminantProperty, variables, }) {
+        const discriminantProperty = includeDiscriminantProperty
+            ? code `, termType: ${variables.value}.termType`
+            : "";
+        return code `{ "@id": ${variables.value}.value${discriminantProperty} }`;
+    }
+    fromRdfExpressionChain({ variables, }) {
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            valueTo: code `chain(values => values.chainMap(value => value.toIri(${this.in_.length > 0
+                ? code `[${joinCode(this.in_.map((in_) => rdfjsTermExpression(in_)), { on: ", " })}]`
+                : ""})))`,
+        };
+    }
+}
+__decorate([
+    Memoize()
+], IriType.prototype, "fromStringFunction", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "name", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "jsonType", null);
+const nodeKinds = new Set(["IRI"]);
+//# sourceMappingURL=IriType.js.map

package/dist/generators/ts/LazyObjectOptionType.d.ts

@@ -0,0 +1,31 @@
+import { Maybe } from "purify-ts";
+import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
+import type { OptionType } from "./OptionType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+type Super = AbstractLazyObjectType<OptionType<AbstractLazyObjectType.ObjectTypeConstraint>, OptionType<AbstractLazyObjectType.ObjectTypeConstraint>>;
+declare const Super: (abstract new ({ partialType, resolveType, runtimeClass, ...superParameters }: {
+    partialType: OptionType<AbstractLazyObjectType.ObjectTypeConstraint>;
+    resolveType: OptionType<AbstractLazyObjectType.ObjectTypeConstraint>;
+    runtimeClass: {
+        readonly name: Code;
+        readonly partialPropertyName: string;
+        readonly rawName: Code;
+    };
+} & {
+    comment: Maybe<string>;
+    label: Maybe<string>;
+}) => AbstractLazyObjectType<OptionType<AbstractLazyObjectType.ObjectTypeConstraint>, OptionType<AbstractLazyObjectType.ObjectTypeConstraint>>) & {
+    readonly GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+};
+export declare class LazyObjectOptionType extends Super {
+    readonly kind = "LazyObjectOptionType";
+    readonly graphqlArgs: Super["graphqlArgs"];
+    constructor({ partialType, resolveType, ...superParameters }: Omit<ConstructorParameters<typeof AbstractLazyObjectType<OptionType<AbstractLazyObjectType.ObjectTypeConstraint>, OptionType<AbstractLazyObjectType.ObjectTypeConstraint>>>[0], "runtimeClass">);
+    get conversions(): readonly AbstractLazyObjectType.Conversion[];
+    fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
+    fromRdfExpression(parameters: Parameters<Super["fromRdfExpression"]>[0]): Code;
+    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
+}
+export {};
+//# sourceMappingURL=LazyObjectOptionType.d.ts.map

package/dist/generators/ts/LazyObjectOptionType.js

@@ -0,0 +1,87 @@
+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 { Memoize } from "typescript-memoize";
+import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
+import { code } from "./ts-poet-wrapper.js";
+const Super = (AbstractLazyObjectType);
+export class LazyObjectOptionType extends Super {
+    kind = "LazyObjectOptionType";
+    graphqlArgs = Maybe.empty();
+    constructor({ partialType, resolveType, ...superParameters }) {
+        super({
+            ...superParameters,
+            partialType,
+            resolveType,
+            runtimeClass: {
+                name: code `${snippets.LazyObjectOption}<${resolveType.itemType.identifierTypeAlias}, ${partialType.itemType.name}, ${resolveType.itemType.name}>`,
+                partialPropertyName: "partial",
+                rawName: code `${snippets.LazyObjectOption}`,
+            },
+        });
+    }
+    get conversions() {
+        const conversions = super.conversions.concat();
+        if (this.partialType.itemType.kind === "ObjectType") {
+            conversions.push({
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => ${this.partialType.itemType.newExpression({ parameters: code `object` })}), resolver: async () => ${imports.Right}((${value} as ${imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
+                sourceTypeCheckExpression: (value) => code `${imports.Maybe}.isMaybe(${value})`,
+                sourceTypeName: code `${imports.Maybe}<${this.resolveType.itemType.name}>`,
+                sourceTypeof: "object",
+            }, {
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${imports.Maybe}.of(${this.partialType.itemType.newExpression({ parameters: value })}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
+                // Don't check instanceof value since the ObjectUnionType may be an interface
+                // Rely on the fact that this will be the last type check on an object
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
+                sourceTypeName: this.resolveType.itemType.name,
+                sourceTypeof: "object",
+            });
+        }
+        else if (this.resolveType.itemType.kind === "ObjectUnionType" &&
+            this.partialType.itemType.kind === "ObjectUnionType" &&
+            this.resolveType.itemType.memberTypes.length ===
+                this.partialType.itemType.memberTypes.length) {
+            const maybeMap = code `.map(object => { ${this.resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType: this.resolveType.itemType, partialObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} })`;
+            conversions.push({
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}${maybeMap}, resolver: async () => ${imports.Right}((${value} as ${imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
+                sourceTypeCheckExpression: (value) => code `${imports.Maybe}.isMaybe(${value})`,
+                sourceTypeName: code `${imports.Maybe}<${this.resolveType.itemType.name}>`,
+                sourceTypeof: "object",
+            }, {
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${imports.Maybe}.of(${value})${maybeMap}, resolver: async () => ${imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
+                // Don't check instanceof value since the ObjectUnionType may be an interface
+                // Rely on the fact that this will be the last type check on an object
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
+                sourceTypeName: this.resolveType.itemType.name,
+                sourceTypeof: "object",
+            });
+        }
+        conversions.push({
+            conversionExpression: () => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${imports.Maybe}.empty(), resolver: async () => { throw new Error("should never be called"); } })`,
+            sourceTypeCheckExpression: (value) => code `${value} === undefined`,
+            sourceTypeName: code `undefined`,
+            sourceTypeof: "undefined",
+        });
+        return conversions;
+    }
+    fromJsonExpression(parameters) {
+        return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${imports.Left}(new Error(\`unable to resolve identifier \${${imports.Resource}.Identifier.toString(identifier)} deserialized from JSON\`))) })`;
+    }
+    fromRdfExpression(parameters) {
+        const { variables } = parameters;
+        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.object}(identifier) })))`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return code `${variables.value}.resolve().then(either => either.unsafeCoerce().extractNullable())`;
+    }
+}
+__decorate([
+    Memoize()
+], LazyObjectOptionType.prototype, "conversions", null);
+//# sourceMappingURL=LazyObjectOptionType.js.map

package/dist/generators/ts/LazyObjectSetType.d.ts

@@ -0,0 +1,15 @@
+import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
+import type { SetType } from "./SetType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class LazyObjectSetType extends AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>> {
+    readonly graphqlArgs: Super["graphqlArgs"];
+    readonly kind = "LazyObjectSetType";
+    constructor({ partialType, resolveType, ...superParameters }: Omit<ConstructorParameters<typeof AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>>>[0], "runtimeClass">);
+    get conversions(): readonly AbstractLazyObjectType.Conversion[];
+    fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
+    fromRdfExpression(parameters: Parameters<Super["fromRdfExpression"]>[0]): Code;
+    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
+}
+type Super = AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>>;
+export {};
+//# sourceMappingURL=LazyObjectSetType.d.ts.map

package/dist/generators/ts/LazyObjectSetType.js

@@ -0,0 +1,78 @@
+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 { Memoize } from "typescript-memoize";
+import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
+import { code } from "./ts-poet-wrapper.js";
+export class LazyObjectSetType extends AbstractLazyObjectType {
+    graphqlArgs = Maybe.of({
+        limit: {
+            type: code `${imports.GraphQLInt}`,
+        },
+        offset: {
+            type: code `${imports.GraphQLInt}`,
+        },
+    });
+    kind = "LazyObjectSetType";
+    constructor({ partialType, resolveType, ...superParameters }) {
+        super({
+            ...superParameters,
+            partialType,
+            resolveType,
+            runtimeClass: {
+                name: code `${snippets.LazyObjectSet}<${resolveType.itemType.identifierTypeAlias}, ${partialType.itemType.name}, ${resolveType.itemType.name}>`,
+                partialPropertyName: "partials",
+                rawName: code `${snippets.LazyObjectSet}`,
+            },
+        });
+    }
+    get conversions() {
+        const conversions = super.conversions.concat();
+        if (this.partialType.itemType.kind === "ObjectType") {
+            conversions.push({
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => ${this.partialType.itemType.newExpression({ parameters: code `object` })}), resolver: async () => ${imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
+                sourceTypeName: code `readonly ${this.resolveType.itemType.name}[]`,
+                sourceTypeof: "object",
+            });
+        }
+        else if (this.resolveType.itemType.kind === "ObjectUnionType" &&
+            this.partialType.itemType.kind === "ObjectUnionType" &&
+            this.resolveType.itemType.memberTypes.length ===
+                this.partialType.itemType.memberTypes.length) {
+            conversions.push({
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => { ${this.resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType: this.resolveType.itemType, partialObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} }), resolver: async () => ${imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
+                sourceTypeName: code `readonly ${this.resolveType.itemType.name}[]`,
+                sourceTypeof: "object",
+            });
+        }
+        conversions.push({
+            conversionExpression: () => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: [], resolver: async () => { throw new Error("should never be called"); } })`,
+            sourceTypeCheckExpression: (value) => code `${value} === undefined`,
+            sourceTypeName: code `undefined`,
+            sourceTypeof: "undefined",
+        });
+        return conversions;
+    }
+    fromJsonExpression(parameters) {
+        return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: () => Promise.resolve(${imports.Left}(new Error("unable to resolve identifiers deserialized from JSON"))) })`;
+    }
+    fromRdfExpression(parameters) {
+        const { variables } = parameters;
+        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifiers) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers }) })))`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return code `(${variables.value}.resolve({ limit: ${variables.args}.limit, offset: ${variables.args}.offset })).then(either => either.unsafeCoerce())`;
+    }
+}
+__decorate([
+    Memoize()
+], LazyObjectSetType.prototype, "conversions", null);
+//# sourceMappingURL=LazyObjectSetType.js.map