@shaclmate/compiler 4.0.29 → 4.0.31

package/dist/generators/ts/AbstractType.d.ts

@@ -1,5 +1,7 @@
 import type { Maybe, NonEmptyList } from "purify-ts";
 import type { Logger } from "ts-log";
+import type { Reusables } from "./Reusables.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
@@ -7,6 +9,8 @@ import { type Code } from "./ts-poet-wrapper.js";
  */
 export declare abstract class AbstractType {
     protected readonly logger: Logger;
+    protected readonly reusables: Reusables;
+    protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
     /**
      * Comment from rdfs:comment.
      */
@@ -106,10 +110,11 @@ export declare abstract class AbstractType {
      * - variablePrefix: string prefix to use for new variables
      */
     abstract readonly valueSparqlWherePatternsFunction: Code;
-    constructor({ comment, label, logger, }: {
+    constructor({ comment, label, logger, reusables, }: {
         comment: Maybe<string>;
         label: Maybe<string>;
         logger: Logger;
+        reusables: Reusables;
     });
     /**
      * Helper to compose the result of schema along the type hierarchy.
@@ -255,6 +260,7 @@ export declare namespace AbstractType {
     }
     interface DiscriminantProperty {
         readonly descendantValues: readonly DiscriminantProperty.Value[];
+        readonly jsonName: string;
         readonly name: string;
         readonly ownValues: readonly DiscriminantProperty.Value[];
     }
@@ -270,7 +276,8 @@ export declare namespace AbstractType {
          * The name of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
          */
         readonly nullableName: Code;
-        constructor(nullableName: Code, parameters?: {
+        private readonly reusables;
+        constructor(nullableName: Code, reusables: Reusables, options?: {
             nullable: boolean;
         });
         get name(): Code;

package/dist/generators/ts/AbstractType.js

@@ -6,13 +6,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { imports } from "./imports.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class all types.
  */
 export class AbstractType {
     logger;
+    reusables;
+    rdfjsTermExpression;
     /**
      * Comment from rdfs:comment.
      */
@@ -21,10 +23,16 @@ export class AbstractType {
      * Label from rdfs:label.
      */
     label;
-    constructor({ comment, label, logger, }) {
+    constructor({ comment, label, logger, reusables, }) {
         this.comment = comment;
         this.label = label;
         this.logger = logger;
+        this.reusables = reusables;
+        this.rdfjsTermExpression = rdfjsTermExpression.bind({
+            imports: this.reusables.imports,
+            logger: this.logger,
+            snippets: this.reusables.snippets,
+        });
     }
     /**
      * Helper to compose the result of schema along the type hierarchy.
@@ -46,14 +54,16 @@ export class AbstractType {
          * The name of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
          */
         nullableName;
-        constructor(nullableName, parameters) {
-            this.nullable = !!parameters?.nullable;
+        reusables;
+        constructor(nullableName, reusables, options) {
+            this.nullable = !!options?.nullable;
             this.nullableName = nullableName;
+            this.reusables = reusables;
         }
         get name() {
             return this.nullable
                 ? this.nullableName
-                : code `new ${imports.GraphQLNonNull}(${this.nullableName})`;
+                : code `new ${this.reusables.imports.GraphQLNonNull}(${this.nullableName})`;
         }
     }
     __decorate([

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -48,11 +48,13 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
 }
 type Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
 type ExtrinsicDiscriminant = {
+    readonly jsonName: string;
     readonly kind: "extrinsic";
     readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
     readonly name: string;
 };
 type HybridDiscriminant = {
+    readonly jsonName: string;
     readonly kind: "hybrid";
     readonly memberValues: readonly {
         readonly kind: "extrinsic" | "intrinsic";
@@ -61,6 +63,7 @@ type HybridDiscriminant = {
     readonly name: string;
 };
 type IntrinsicDiscriminant = {
+    readonly jsonName: string;
     readonly kind: "intrinsic";
     readonly memberValues: readonly {
         readonly descendantValues: readonly AbstractType.DiscriminantProperty.Value[];

package/dist/generators/ts/AbstractUnionType.js

@@ -8,9 +8,7 @@ import { Maybe, NonEmptyList } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
-import { imports } from "./imports.js";
 import { removeUndefined } from "./removeUndefined.js";
-import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class AbstractUnionType extends AbstractType {
@@ -79,7 +77,10 @@ export class AbstractUnionType extends AbstractType {
                             return code `${member.type.name}.is${member.type.name}(${instance})`;
                     }
                 }
-                return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}.${discriminant.name} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
+                const discriminantName = json
+                    ? discriminant.jsonName
+                    : discriminant.name;
+                return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}["${discriminantName}"] === ${literalOf(discriminantValue)}`), { on: " || " })})`;
             };
             return {
                 discriminantValues,
@@ -158,18 +159,21 @@ export class AbstractUnionType extends AbstractType {
             case "extrinsic":
                 return Maybe.of({
                     descendantValues: [],
+                    jsonName: this.discriminant.jsonName,
                     ownValues: this.discriminant.memberValues,
                     name: this.discriminant.name,
                 });
             case "hybrid":
                 return Maybe.of({
                     descendantValues: [],
+                    jsonName: this.discriminant.jsonName,
                     ownValues: this.discriminant.memberValues.flatMap((_) => _.ownValues),
                     name: "termType",
                 });
             case "intrinsic":
                 return Maybe.of({
                     descendantValues: this.discriminant.memberValues.flatMap((_) => _.descendantValues),
+                    jsonName: this.discriminant.jsonName,
                     name: this.discriminant.name,
                     ownValues: this.discriminant.memberValues.flatMap((_) => _.ownValues),
                 });
@@ -220,7 +224,7 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
   return ${type.equalsFunction}(${unwrap(code `left`)} as ${type.name}, ${unwrap(code `right`)} as ${type.name});
 }`))}
 
-  return ${imports.Left}({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "boolean" as const }, type: "property" as const });
+  return ${this.reusables.imports.Left}({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "boolean" as const }, type: "property" as const });
 })`;
     }
     get inlineFilterFunction() {
@@ -276,7 +280,7 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
         return code `\
 (((values, _options) =>
     values.chain(values => values.chainMap(value => {
-      const valueAsValues = ${imports.Right}(value.toValues());
+      const valueAsValues = ${this.reusables.imports.Right}(value.toValues());
       return ${this.members.reduce((expression, { type, primaryDiscriminantValue }, memberI) => {
             let typeExpression = type.fromRdfResourceValuesExpression({
                 variables: {
@@ -295,24 +299,24 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
                     this.discriminant.memberValues[memberI].kind === "extrinsic")) {
                 typeExpression = code `${typeExpression}.map(values => values.map(value => ({ ${this.discriminant.name}: ${literalOf(primaryDiscriminantValue)} as const, value }) as (${this.name})))`;
             }
-            typeExpression = code `(${typeExpression} as ${imports.Either}<Error, ${imports.Resource}.Values<${this.name}>>)`;
+            typeExpression = code `(${typeExpression} as ${this.reusables.imports.Either}<Error, ${this.reusables.imports.Resource}.Values<${this.name}>>)`;
             return expression !== null
                 ? code `${expression}.altLazy(() => ${typeExpression})`
                 : typeExpression;
         }, null)}.chain(values => values.head());
     }))
-) satisfies ${snippets.FromRdfResourceValuesFunction}<${this.name}>)`;
+) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}>)`;
     }
     get inlineJsonSchema() {
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
             case "extrinsic":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
+                return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `${this.reusables.imports.z}.object({ ${discriminant.name}: ${this.reusables.imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
             case "hybrid":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
+                return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
                         case "extrinsic":
-                            return code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
+                            return code `${this.reusables.imports.z}.object({ ${discriminant.name}: ${this.reusables.imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
                         case "intrinsic":
                             return type.jsonSchema({
                                 includeDiscriminantProperty: true,
@@ -323,12 +327,12 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
                     }
                 }), { on: "," })}]).readonly()`;
             case "intrinsic":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type }) => type.jsonSchema({
+                return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type }) => type.jsonSchema({
                     includeDiscriminantProperty: true,
                     context: "type",
                 })), { on: "," })}]).readonly()`;
             case "typeof":
-                return code `${imports.z}.union([${joinCode(this.members.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
+                return code `${this.reusables.imports.z}.union([${joinCode(this.members.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
             default:
                 throw discriminant;
         }
@@ -398,11 +402,11 @@ ${joinCode(this.members.map(({ typeCheck, typeToJsonExpression, unwrap, wrap })
 (((value, _options): (${joinCode([...this.toRdfResourceValueTypes].map((toRdfResourceValueType) => {
             switch (toRdfResourceValueType) {
                 case "BlankNode":
-                    return code `${imports.BlankNode}`;
+                    return code `${this.reusables.imports.BlankNode}`;
                 case "Literal":
-                    return code `${imports.Literal}`;
+                    return code `${this.reusables.imports.Literal}`;
                 case "NamedNode":
-                    return code `${imports.NamedNode}`;
+                    return code `${this.reusables.imports.NamedNode}`;
                 default:
                     toRdfResourceValueType;
                     throw new Error();
@@ -419,7 +423,7 @@ ${joinCode(this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeChe
         })}; }`))}
 
   throw new Error("unable to serialize to RDF");
-}) satisfies ${snippets.ToRdfResourceValuesFunction}<${this.name}>)`;
+}) satisfies ${this.reusables.snippets.ToRdfResourceValuesFunction}<${this.name}>)`;
     }
     get inlineToStringFunction() {
         return code `\
@@ -434,24 +438,24 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
     get inlineValueSparqlConstructTriplesFunction() {
         return code `\
 ((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
-  let triples: ${imports.sparqljs}.Triple[] = [];
+  let triples: ${this.reusables.imports.sparqljs}.Triple[] = [];
 
   ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
 triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }));`))}
   
   return triples;
-}) satisfies ${snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
+}) satisfies ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
     }
     get inlineValueSparqlWherePatternsFunction() {
         return code `\
 ((({ filter, schema, ...otherParameters }) => {
-  const unionPatterns: ${imports.sparqljs}.GroupPattern[] = [];
+  const unionPatterns: ${this.reusables.imports.sparqljs}.GroupPattern[] = [];
 
   ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
 unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }).concat(), type: "group" });`))}
   
   return [{ patterns: unionPatterns, type: "union" }];
-}) satisfies ${snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
+}) satisfies ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
     }
     get schemaObject() {
         return {
@@ -539,6 +543,7 @@ export var Discriminant;
         // extrinsic with user-specified values
         if (members.some((member) => member.discriminantValue.isJust())) {
             return {
+                jsonName: "type",
                 kind: "extrinsic",
                 memberValues: members.map((member, memberI) => member.discriminantValue.orDefault(memberI)),
                 name: "type",
@@ -547,19 +552,20 @@ export var Discriminant;
         const memberTypes = members.map((member) => member.type);
         // intrinsic
         {
-            let inlineDiscriminantPropertyName;
+            let inlineDiscriminantProperty;
             const memberValues = [];
             for (const memberType of memberTypes) {
                 const memberTypeDiscriminantProperty = memberType.discriminantProperty.extract();
                 if (!memberTypeDiscriminantProperty) {
-                    inlineDiscriminantPropertyName = undefined;
+                    inlineDiscriminantProperty = undefined;
                     break;
                 }
-                if (!inlineDiscriminantPropertyName) {
-                    inlineDiscriminantPropertyName = memberTypeDiscriminantProperty.name;
+                if (!inlineDiscriminantProperty) {
+                    inlineDiscriminantProperty = memberTypeDiscriminantProperty;
                 }
-                else if (memberTypeDiscriminantProperty.name !== inlineDiscriminantPropertyName) {
-                    inlineDiscriminantPropertyName = undefined;
+                else if (memberTypeDiscriminantProperty.name !==
+                    inlineDiscriminantProperty.name) {
+                    inlineDiscriminantProperty = undefined;
                     break;
                 }
                 memberValues.push({
@@ -567,11 +573,12 @@ export var Discriminant;
                     ownValues: memberTypeDiscriminantProperty.ownValues,
                 });
             }
-            if (inlineDiscriminantPropertyName) {
+            if (inlineDiscriminantProperty) {
                 return {
+                    jsonName: inlineDiscriminantProperty.jsonName,
                     kind: "intrinsic",
                     memberValues,
-                    name: inlineDiscriminantPropertyName,
+                    name: inlineDiscriminantProperty.name,
                 };
             }
         }
@@ -608,6 +615,7 @@ export var Discriminant;
                 }
             }
             return {
+                jsonName: "termType",
                 kind: "hybrid",
                 memberValues: memberTypes.map((memberType, memberTypeI) => {
                     const memberTermTypes = termTypes(memberType);
@@ -650,6 +658,7 @@ export var Discriminant;
             }
             invariant(memberValues.length === memberTypes.length);
             return {
+                jsonName: "type",
                 kind: "extrinsic",
                 name: "type",
                 memberValues: memberValues,

package/dist/generators/ts/BigDecimalType.d.ts

@@ -3,19 +3,19 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigDecimalType extends AbstractLiteralType {
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "BigDecimalType";
     readonly name: Code;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     get conversions(): readonly AbstractLiteralType.Conversion[];
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     hashStatements({ variables, }: Parameters<AbstractLiteralType["hashStatements"]>[0]): readonly Code[];
-    jsonType(): AbstractLiteralType.JsonType;
     jsonSchema(): Code;
+    jsonType(): AbstractLiteralType.JsonType;
     toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractLiteralType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractLiteralType["fromRdfExpressionChain"]>;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractLiteralType["toRdfResourceValuesExpression"]>[0]): Code;
+    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractLiteralType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractLiteralType["fromRdfExpressionChain"]>;
 }
 //# sourceMappingURL=BigDecimalType.d.ts.map

package/dist/generators/ts/BigDecimalType.js

@@ -6,22 +6,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { imports } from "./imports.js";
-import { snippets } from "./snippets.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BigDecimalType extends AbstractLiteralType {
-    filterFunction = code `${snippets.filterBigDecimal}`;
-    filterType = code `${snippets.NumericFilter}<${imports.BigDecimal}>`;
-    graphqlType = new AbstractLiteralType.GraphqlType(code `${imports.GraphQLString}`);
+    filterFunction = code `${this.reusables.snippets.filterBigDecimal}`;
+    filterType = code `${this.reusables.snippets.NumericFilter}<${this.reusables.imports.BigDecimal}>`;
     kind = "BigDecimalType";
-    name = code `${imports.BigDecimal}`;
-    schemaType = code `${snippets.NumericSchema}<${imports.BigDecimal}>`;
-    valueSparqlWherePatternsFunction = code `${snippets.bigDecimalSparqlWherePatterns}`;
+    name = code `${this.reusables.imports.BigDecimal}`;
+    schemaType = code `${this.reusables.snippets.NumericSchema}<${this.reusables.imports.BigDecimal}>`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.bigDecimalSparqlWherePatterns}`;
     get conversions() {
         return [
             // {
             //   conversionExpression: (value) =>
-            //     code`new ${imports.BigDecimal}(${value}.toString())`,
+            //     code`new ${this.reusables.imports.BigDecimal}(${value}.toString())`,
             //   sourceTypeCheckExpression: (value) =>
             //     code`typeof ${value} === "bigint"`,
             //   sourceTypeName: code`bigint`,
@@ -30,12 +27,12 @@ export class BigDecimalType extends AbstractLiteralType {
             {
                 conversionExpression: (value) => value,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: code `${imports.BigDecimal}`,
+                sourceTypeName: code `${this.reusables.imports.BigDecimal}`,
                 sourceTypeof: "object",
             },
             // {
             //   conversionExpression: (value) =>
-            //     code`new ${imports.BigDecimal}(${value})`,
+            //     code`new ${this.reusables.imports.BigDecimal}(${value})`,
             //   sourceTypeCheckExpression: (value) =>
             //     code`typeof ${value} === "number"`,
             //   sourceTypeName: code`number`,
@@ -43,7 +40,7 @@ export class BigDecimalType extends AbstractLiteralType {
             // },
             // {
             //   conversionExpression: (value) =>
-            //     code`new ${imports.BigDecimal}(${value})`,
+            //     code`new ${this.reusables.imports.BigDecimal}(${value})`,
             //   sourceTypeCheckExpression: (value) =>
             //     code`typeof ${value} === "string"`,
             //   sourceTypeName: code`string`,
@@ -51,8 +48,11 @@ export class BigDecimalType extends AbstractLiteralType {
             // },
         ];
     }
+    get graphqlType() {
+        return new AbstractLiteralType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
+    }
     fromJsonExpression({ variables, }) {
-        return code `new ${imports.BigDecimal}(${variables.value})`;
+        return code `new ${this.reusables.imports.BigDecimal}(${variables.value})`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.toFixed()`;
@@ -60,32 +60,35 @@ export class BigDecimalType extends AbstractLiteralType {
     hashStatements({ variables, }) {
         return [code `${variables.hasher}.update(${variables.value}.toFixed());`];
     }
+    jsonSchema() {
+        return code `${this.reusables.imports.z}.string()`;
+    }
     jsonType() {
         return new AbstractLiteralType.JsonType("string");
     }
-    jsonSchema() {
-        return code `${imports.z}.string()`;
-    }
     toJsonExpression({ variables, }) {
         return code `${variables.value}.toFixed()`;
     }
+    toRdfResourceValuesExpression({ variables, }) {
+        return code `[${this.reusables.snippets.bigDecimalLiteral}(${variables.value})]`;
+    }
     fromRdfExpressionChain({ variables, }) {
         return {
             ...super.fromRdfExpressionChain({ variables }),
-            valueTo: code `chain(values => values.chainMap(value => value.toLiteral().chain(${snippets.decodeBigDecimalLiteral})))`,
+            valueTo: code `chain(values => values.chainMap(value => value.toLiteral().chain(${this.reusables.snippets.decodeBigDecimalLiteral})))`,
         };
     }
-    toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.bigDecimalLiteral}(${variables.value})]`;
-    }
 }
 __decorate([
     Memoize()
 ], BigDecimalType.prototype, "conversions", null);
 __decorate([
     Memoize()
-], BigDecimalType.prototype, "jsonType", null);
+], BigDecimalType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
 ], BigDecimalType.prototype, "jsonSchema", null);
+__decorate([
+    Memoize()
+], BigDecimalType.prototype, "jsonType", null);
 //# sourceMappingURL=BigDecimalType.js.map

package/dist/generators/ts/BigIntType.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 BigIntType extends AbstractNumericType<bigint> {
-    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "BigIntType";
     readonly typeofs: NonEmptyList<"bigint">;
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     get conversions(): readonly AbstractNumericType.Conversion[];
     fromJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromJsonExpression"]>[0]): Code;
     jsonSchema(_parameters: Parameters<AbstractNumericType<bigint>["jsonSchema"]>[0]): Code;

package/dist/generators/ts/BigIntType.js

@@ -7,12 +7,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { NonEmptyList } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
-import { imports } from "./imports.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class BigIntType extends AbstractNumericType {
-    graphqlType = new AbstractNumericType.GraphqlType(code `${imports.GraphQLBigInt}`);
     kind = "BigIntType";
     typeofs = NonEmptyList(["bigint"]);
+    get graphqlType() {
+        return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLBigInt}`, this.reusables);
+    }
     get conversions() {
         if (this.in_.length > 0) {
             return super.conversions;
@@ -34,11 +35,11 @@ export class BigIntType extends AbstractNumericType {
     jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
-                return code `${imports.z}.string()`;
+                return code `${this.reusables.imports.z}.string()`;
             case 1:
-                return code `${imports.z}.literal(${literalOf(this.primitiveIn[0].toString())})`;
+                return code `${this.reusables.imports.z}.literal(${literalOf(this.primitiveIn[0].toString())})`;
             default:
-                return code `${imports.z}.enum([${joinCode(this.primitiveIn.map((value) => code `${literalOf(value.toString())}`), { on: "," })}])`;
+                return code `${this.reusables.imports.z}.enum([${joinCode(this.primitiveIn.map((value) => code `${literalOf(value.toString())}`), { on: "," })}])`;
         }
     }
     jsonType() {
@@ -54,6 +55,9 @@ export class BigIntType extends AbstractNumericType {
         return `${value.toString()}n`;
     }
 }
+__decorate([
+    Memoize()
+], BigIntType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
 ], BigIntType.prototype, "jsonType", null);

package/dist/generators/ts/BlankNodeType.js

@@ -7,18 +7,16 @@ 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 { snippets } from "./snippets.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BlankNodeType extends AbstractIdentifierType {
-    filterFunction = code `${snippets.filterBlankNode}`;
-    filterType = code `${snippets.BlankNodeFilter}`;
-    parseFunction = code `${snippets.parseBlankNode};`;
+    filterFunction = code `${this.reusables.snippets.filterBlankNode}`;
+    filterType = code `${this.reusables.snippets.BlankNodeFilter}`;
+    parseFunction = code `${this.reusables.snippets.parseBlankNode};`;
     kind = "BlankNodeType";
-    name = code `${imports.BlankNode}`;
+    name = code `${this.reusables.imports.BlankNode}`;
     nodeKinds = nodeKinds;
-    schemaType = code `${snippets.BlankNodeSchema}`;
-    valueSparqlWherePatternsFunction = code `${snippets.blankNodeSparqlWherePatterns}`;
+    schemaType = code `${this.reusables.snippets.BlankNodeSchema}`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.blankNodeSparqlWherePatterns}`;
     constructor(superParameters) {
         super({
             ...superParameters,
@@ -27,7 +25,7 @@ export class BlankNodeType extends AbstractIdentifierType {
         });
     }
     fromJsonExpression({ variables, }) {
-        return code `${imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2))`;
+        return code `${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2))`;
     }
     jsonType(parameters) {
         const discriminantProperty = parameters?.includeDiscriminantProperty
@@ -37,9 +35,9 @@ export class BlankNodeType extends AbstractIdentifierType {
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${imports.z}.literal("BlankNode")`
+            ? code `, termType: ${this.reusables.imports.z}.literal("BlankNode")`
             : "";
-        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/BooleanType.d.ts

@@ -4,11 +4,11 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "BooleanType";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     readonly typeofs: NonEmptyList<"boolean">;
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     get name(): string;
     protected get schemaObject(): {
         in: boolean[] | undefined;

package/dist/generators/ts/BooleanType.js

@@ -7,18 +7,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { NonEmptyList } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
-import { imports } from "./imports.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import { snippets } from "./snippets.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BooleanType extends AbstractPrimitiveType {
-    filterFunction = code `${snippets.filterBoolean}`;
-    filterType = code `${snippets.BooleanFilter}`;
-    graphqlType = new AbstractPrimitiveType.GraphqlType(code `${imports.GraphQLBoolean}`);
+    filterFunction = code `${this.reusables.snippets.filterBoolean}`;
+    filterType = code `${this.reusables.snippets.BooleanFilter}`;
     kind = "BooleanType";
-    schemaType = code `${snippets.BooleanSchema}`;
-    valueSparqlWherePatternsFunction = code `${snippets.booleanSparqlWherePatterns}`;
+    schemaType = code `${this.reusables.snippets.BooleanSchema}`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.booleanSparqlWherePatterns}`;
     typeofs = NonEmptyList(["boolean"]);
+    get graphqlType() {
+        return new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLBoolean}`, this.reusables);
+    }
     get name() {
         if (this.primitiveIn.length > 0) {
             return `${this.primitiveIn.map((value) => value.toString()).join(" | ")}`;
@@ -33,12 +32,12 @@ export class BooleanType extends AbstractPrimitiveType {
     }
     jsonSchema(_parameters) {
         if (this.primitiveIn.length === 1) {
-            return code `${imports.z}.literal(${this.primitiveIn[0]})`;
+            return code `${this.reusables.imports.z}.literal(${this.primitiveIn[0]})`;
         }
-        return code `${imports.z}.boolean()`;
+        return code `${this.reusables.imports.z}.boolean()`;
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.literalFactory}.boolean(${variables.value}, ${rdfjsTermExpression(this.datatype, { logger: this.logger })})]`;
+        return code `[${this.reusables.snippets.literalFactory}.boolean(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
     fromRdfExpressionChain({ variables, }) {
         return {
@@ -49,6 +48,9 @@ export class BooleanType extends AbstractPrimitiveType {
         };
     }
 }
+__decorate([
+    Memoize()
+], BooleanType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
 ], BooleanType.prototype, "name", null);