@shaclmate/compiler 4.0.28 → 4.0.30

package/dist/generators/ts/FloatType.js

@@ -1,11 +1,19 @@
+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 { NonEmptyList } from "purify-ts";
+import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
-import { imports } from "./imports.js";
 import { code } from "./ts-poet-wrapper.js";
 export class FloatType extends AbstractNumericType {
     kind = "FloatType";
-    graphqlType = new AbstractNumericType.GraphqlType(code `${imports.GraphQLFloat}`);
     typeofs = NonEmptyList(["number"]);
+    get graphqlType() {
+        return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLFloat}`, this.reusables);
+    }
     fromRdfResourceValueExpression({ variables, }) {
         return code `${variables.value}.toFloat(${this.primitiveIn.length > 0 ? `${JSON.stringify(this.primitiveIn)} as const` : ""})`;
     }
@@ -13,4 +21,7 @@ export class FloatType extends AbstractNumericType {
         return value.toString();
     }
 }
+__decorate([
+    Memoize()
+], FloatType.prototype, "graphqlType", null);
 //# sourceMappingURL=FloatType.js.map

package/dist/generators/ts/IdentifierType.js

@@ -8,18 +8,16 @@ import { NodeKind } from "@shaclmate/shacl-ast";
 import { Memoize } from "typescript-memoize";
 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}`;
-    parseFunction = code `${snippets.parseIdentifier};`;
+    filterFunction = code `${this.reusables.snippets.filterIdentifier}`;
+    filterType = code `${this.reusables.snippets.IdentifierFilter}`;
+    parseFunction = code `${this.reusables.snippets.parseIdentifier};`;
     kind = "IdentifierType";
-    name = code `(${imports.BlankNode} | ${imports.NamedNode})`;
+    name = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
     nodeKinds = nodeKinds;
-    schemaType = code `${snippets.IdentifierSchema}`;
-    valueSparqlWherePatternsFunction = code `${snippets.identifierSparqlWherePatterns}`;
+    schemaType = code `${this.reusables.snippets.IdentifierSchema}`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.identifierSparqlWherePatterns}`;
     constructor(parameters) {
         super({
             ...parameters,
@@ -28,7 +26,7 @@ export class IdentifierType extends AbstractIdentifierType {
         });
     }
     fromJsonExpression({ variables, }) {
-        return code `(${variables.value}["@id"].startsWith("_:") ? ${imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)) : ${imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
+        return code `(${variables.value}["@id"].startsWith("_:") ? ${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)) : ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
     }
     jsonType(parameters) {
         const discriminantProperty = parameters?.includeDiscriminantProperty
@@ -38,9 +36,9 @@ export class IdentifierType extends AbstractIdentifierType {
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${imports.z}.enum(${arrayOf(...this.nodeKinds)})`
+            ? code `, termType: ${this.reusables.imports.z}.enum(${arrayOf(...this.nodeKinds)})`
             : "";
-        return code `${imports.z}.object({ "@id": ${imports.z}.string().min(1)${discriminantProperty} })`;
+        return code `${this.reusables.imports.z}.object({ "@id": ${this.reusables.imports.z}.string().min(1)${discriminantProperty} })`;
     }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         const discriminantProperty = includeDiscriminantProperty

package/dist/generators/ts/{imports.d.ts → Imports.d.ts}

@@ -1,4 +1,4 @@
-export declare const imports: {
+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;
@@ -36,5 +36,5 @@ export declare const imports: {
     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
+}
+//# 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

@@ -2,9 +2,9 @@ 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">;
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<number>["fromRdfResourceValueExpression"]>[0]): Code;
     protected literalOf(value: number): string;
 }

package/dist/generators/ts/IntType.js

@@ -1,11 +1,19 @@
+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 { NonEmptyList } from "purify-ts";
+import { Memoize } from "typescript-memoize";
 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"]);
+    get graphqlType() {
+        return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLInt}`, this.reusables);
+    }
     fromRdfResourceValueExpression({ variables, }) {
         return code `${variables.value}.toInt(${this.primitiveIn.length > 0 ? `${JSON.stringify(this.primitiveIn)} as const` : ""})`;
     }
@@ -13,4 +21,7 @@ export class IntType extends AbstractNumericType {
         return value.toString();
     }
 }
+__decorate([
+    Memoize()
+], IntType.prototype, "graphqlType", null);
 //# sourceMappingURL=IntType.js.map

package/dist/generators/ts/IriType.js

@@ -7,45 +7,40 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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}`;
+    filterFunction = code `${this.reusables.snippets.filterIri}`;
+    filterType = code `${this.reusables.snippets.IriFilter}`;
     kind = "IriType";
     nodeKinds = nodeKinds;
-    schemaType = code `${snippets.IriSchema}`;
-    valueSparqlWherePatternsFunction = code `${snippets.iriSparqlWherePatterns}`;
+    schemaType = code `${this.reusables.snippets.IriSchema}`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.iriSparqlWherePatterns}`;
     get parseFunction() {
         if (this.in_.length > 0) {
-            return code `(identifier: string) => ${snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${imports.Right}(identifier as ${this.name});`))} default: return ${imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
+            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.name});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
         }
-        return code `${snippets.parseIri}`;
+        return code `${this.reusables.snippets.parseIri}`;
     }
     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_
+            return code `${this.reusables.imports.NamedNode}<${this.in_
                 .map((iri) => `"${iri.value}"`)
                 .join(" | ")}>`;
         }
-        return code `${imports.NamedNode}`;
+        return code `${this.reusables.imports.NamedNode}`;
     }
     get schemaObject() {
         return {
             ...super.schemaObject,
             in: this.in_.length > 0
-                ? this.in_
-                    .map((in_) => rdfjsTermExpression(in_, { logger: this.logger }))
-                    .concat()
+                ? this.in_.map((in_) => this.rdfjsTermExpression(in_)).concat()
                 : undefined,
         };
     }
     fromJsonExpression({ variables, }) {
-        return code `${imports.dataFactory}.namedNode(${variables.value}["@id"])`;
+        return code `${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"])`;
     }
     jsonType(parameters) {
         const discriminantProperty = parameters?.includeDiscriminantProperty
@@ -63,15 +58,15 @@ export class IriType extends AbstractIdentifierType {
         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))})`;
+            idSchema = code `${this.reusables.imports.z}.enum(${arrayOf(...this.in_.map((iri) => iri.value))})`;
         }
         else {
-            idSchema = code `${imports.z}.string().min(1)`;
+            idSchema = code `${this.reusables.imports.z}.string().min(1)`;
         }
         const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${imports.z}.literal("NamedNode")`
+            ? code `, termType: ${this.reusables.imports.z}.literal("NamedNode")`
             : "";
-        return code `${imports.z}.object({ "@id": ${idSchema}${discriminantProperty} })`;
+        return code `${this.reusables.imports.z}.object({ "@id": ${idSchema}${discriminantProperty} })`;
     }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         const discriminantProperty = includeDiscriminantProperty
@@ -83,7 +78,7 @@ export class IriType extends AbstractIdentifierType {
         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_, { logger: this.logger })), { on: ", " })}]`
+                ? code `[${joinCode(this.in_.map((in_) => this.rdfjsTermExpression(in_)), { on: ", " })}]`
                 : ""})))`,
         };
     }

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

@@ -3,27 +3,27 @@ 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 }: {
+declare const Super: (abstract new ({ partialType, resolveType, ...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>;
     logger: import("ts-log").Logger;
+    reusables: import("./Reusables.js").Reusables;
 }) => 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">);
+    readonly kind = "LazyObjectOptionType";
     get conversions(): readonly AbstractLazyObjectType.Conversion[];
+    protected get runtimeClass(): {
+        name: Code;
+        partialPropertyName: string;
+        rawName: Code;
+    };
     fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<Super["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;

package/dist/generators/ts/LazyObjectOptionType.js

@@ -7,36 +7,21 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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 { syntheticNamePrefix } from "./syntheticNamePrefix.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}`,
-            },
-        });
-    }
+    kind = "LazyObjectOptionType";
     get conversions() {
         const conversions = super.conversions.concat();
         if (this.partialType.itemType.kind === "NamedObjectType") {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(${this.partialType.itemType.name}.${syntheticNamePrefix}create), 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}>`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(${this.partialType.itemType.name}.create), resolver: async () => ${this.reusables.imports.Right}((${value} as ${this.reusables.imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
+                sourceTypeCheckExpression: (value) => code `${this.reusables.imports.Maybe}.isMaybe(${value})`,
+                sourceTypeName: code `${this.reusables.imports.Maybe}<${this.resolveType.itemType.name}>`,
                 sourceTypeof: "object",
             }, {
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${imports.Maybe}.of(${this.partialType.itemType.name}.${syntheticNamePrefix}create(${value})), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.reusables.imports.Maybe}.of(${this.partialType.itemType.name}.create(${value})), resolver: async () => ${this.reusables.imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
                 // Don't check instanceof value since the NamedObjectUnionType 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"`,
@@ -50,12 +35,12 @@ export class LazyObjectOptionType extends Super {
                 this.partialType.itemType.members.length) {
             const maybeMap = code `.map(object => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType.itemType, partialNamedObjectUnionType: 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}>`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}${maybeMap}, resolver: async () => ${this.reusables.imports.Right}((${value} as ${this.reusables.imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
+                sourceTypeCheckExpression: (value) => code `${this.reusables.imports.Maybe}.isMaybe(${value})`,
+                sourceTypeName: code `${this.reusables.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}) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.reusables.imports.Maybe}.of(${value})${maybeMap}, resolver: async () => ${this.reusables.imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
                 // Don't check instanceof value since the NamedObjectUnionType 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"`,
@@ -64,15 +49,22 @@ export class LazyObjectOptionType extends Super {
             });
         }
         conversions.push({
-            conversionExpression: () => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${imports.Maybe}.empty(), resolver: async () => { throw new Error("should never be called"); } })`,
+            conversionExpression: () => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.reusables.imports.Maybe}.empty(), resolver: async () => { throw new Error("should never be called"); } })`,
             sourceTypeCheckExpression: (value) => code `${value} === undefined`,
             sourceTypeName: code `undefined`,
             sourceTypeof: "undefined",
         });
         return conversions;
     }
+    get runtimeClass() {
+        return {
+            name: code `${this.reusables.snippets.LazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>`,
+            partialPropertyName: "partial",
+            rawName: code `${this.reusables.snippets.LazyObjectOption}`,
+        };
+    }
     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 \${identifier} deserialized from JSON\`))) })`;
+        return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${this.reusables.imports.Left}(new Error(\`unable to resolve identifier \${identifier} deserialized from JSON\`))) })`;
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
@@ -85,4 +77,7 @@ export class LazyObjectOptionType extends Super {
 __decorate([
     Memoize()
 ], LazyObjectOptionType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], LazyObjectOptionType.prototype, "runtimeClass", null);
 //# sourceMappingURL=LazyObjectOptionType.js.map

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

@@ -4,8 +4,12 @@ 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[];
+    protected get runtimeClass(): {
+        name: Code;
+        partialPropertyName: string;
+        rawName: Code;
+    };
     fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<Super["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;

package/dist/generators/ts/LazyObjectSetType.js

@@ -7,37 +7,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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 { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 export class LazyObjectSetType extends AbstractLazyObjectType {
     graphqlArgs = Maybe.of({
         limit: {
-            type: code `${imports.GraphQLInt}`,
+            type: code `${this.reusables.imports.GraphQLInt}`,
         },
         offset: {
-            type: code `${imports.GraphQLInt}`,
+            type: code `${this.reusables.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 === "NamedObjectType") {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(${this.partialType.itemType.name}.${syntheticNamePrefix}create), resolver: async () => ${imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(${this.partialType.itemType.name}.create), resolver: async () => ${this.reusables.imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: code `readonly ${this.resolveType.itemType.name}[]`,
                 sourceTypeof: "object",
@@ -48,7 +33,7 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
             this.resolveType.itemType.members.length ===
                 this.partialType.itemType.members.length) {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType.itemType, partialNamedObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} }), resolver: async () => ${imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType.itemType, partialNamedObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} }), resolver: async () => ${this.reusables.imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: code `readonly ${this.resolveType.itemType.name}[]`,
                 sourceTypeof: "object",
@@ -62,8 +47,15 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
         });
         return conversions;
     }
+    get runtimeClass() {
+        return {
+            name: code `${this.reusables.snippets.LazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>`,
+            partialPropertyName: "partials",
+            rawName: code `${this.reusables.snippets.LazyObjectSet}`,
+        };
+    }
     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"))) })`;
+        return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: () => Promise.resolve(${this.reusables.imports.Left}(new Error("unable to resolve identifiers deserialized from JSON"))) })`;
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;

package/dist/generators/ts/LazyObjectType.d.ts

@@ -3,8 +3,12 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class LazyObjectType extends AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint> {
     readonly graphqlArgs: Super["graphqlArgs"];
     readonly kind = "LazyObjectType";
-    constructor({ partialType, resolveType, ...superParameters }: Omit<ConstructorParameters<typeof AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint>>[0], "runtimeClass">);
     get conversions(): readonly AbstractLazyObjectType.Conversion[];
+    protected get runtimeClass(): {
+        name: Code;
+        partialPropertyName: string;
+        rawName: Code;
+    };
     fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<Super["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;

package/dist/generators/ts/LazyObjectType.js

@@ -1,29 +1,21 @@
+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 { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 export class LazyObjectType extends AbstractLazyObjectType {
     graphqlArgs = Maybe.empty();
     kind = "LazyObjectType";
-    constructor({ partialType, resolveType, ...superParameters }) {
-        super({
-            ...superParameters,
-            partialType,
-            resolveType,
-            runtimeClass: {
-                name: code `${snippets.LazyObject}<${resolveType.identifierTypeAlias}, ${partialType.name}, ${resolveType.name}>`,
-                partialPropertyName: "partial",
-                rawName: code `${snippets.LazyObject}`,
-            },
-        });
-    }
     get conversions() {
         const conversions = super.conversions.concat();
         if (this.partialType.kind === "NamedObjectType") {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.name}.${syntheticNamePrefix}create(${value}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.name}.create(${value}), resolver: async () => ${this.reusables.imports.Right}(${value} as ${this.resolveType.name}) })`,
                 // Don't check instanceof value since the NamedObjectType 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"`,
@@ -35,7 +27,7 @@ export class LazyObjectType extends AbstractLazyObjectType {
             this.partialType.kind === "NamedObjectUnionType" &&
             this.resolveType.members.length === this.partialType.members.length) {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ((object: ${this.resolveType.name}) => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType, partialNamedObjectUnionType: this.partialType, variables: { resolvedObjectUnion: code `object` } })} })(${value}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ((object: ${this.resolveType.name}) => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType, partialNamedObjectUnionType: this.partialType, variables: { resolvedObjectUnion: code `object` } })} })(${value}), resolver: async () => ${this.reusables.imports.Right}(${value} as ${this.resolveType.name}) })`,
                 // Don't check instanceof value since the NamedObjectUnionType 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"`,
@@ -45,8 +37,15 @@ export class LazyObjectType extends AbstractLazyObjectType {
         }
         return conversions;
     }
+    get runtimeClass() {
+        return {
+            name: code `${this.reusables.snippets.LazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.name}, ${this.resolveType.name}>`,
+            partialPropertyName: "partial",
+            rawName: code `${this.reusables.snippets.LazyObject}`,
+        };
+    }
     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 \${identifier} deserialized from JSON\`))) })`;
+        return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${this.reusables.imports.Left}(new Error(\`unable to resolve identifier \${identifier} deserialized from JSON\`))) })`;
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
@@ -56,4 +55,7 @@ export class LazyObjectType extends AbstractLazyObjectType {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce())`;
     }
 }
+__decorate([
+    Memoize()
+], LazyObjectType.prototype, "runtimeClass", null);
 //# sourceMappingURL=LazyObjectType.js.map