@shaclmate/compiler 4.0.38 → 4.0.40

package/dist/generators/ts/AbstractType.js

@@ -4,10 +4,9 @@ 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 { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import { code, literalOf } from "./ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class all types.
  */
@@ -15,6 +14,10 @@ export class AbstractType {
     configuration;
     logger;
     reusables;
+    /**
+     * Alias for this type.
+     */
+    alias;
     /**
      * Comment from rdfs:comment.
      */
@@ -23,7 +26,8 @@ export class AbstractType {
      * Label from rdfs:label.
      */
     label;
-    constructor({ comment, configuration, label, logger, reusables, }) {
+    constructor({ alias, comment, configuration, label, logger, reusables, }) {
+        this.alias = alias;
         this.comment = comment;
         this.configuration = configuration;
         this.label = label;
@@ -35,17 +39,23 @@ export class AbstractType {
             snippets: this.reusables.snippets,
         });
     }
+    /**
+     * TypeScript object describing this type, for runtime use.
+     */
+    get schema() {
+        return code `{ ${joinCode(this.schemaInitializers.concat(), { on: ", " })} }`;
+    }
     /**
      * Helper to compose the result of schema along the type hierarchy.
      */
-    get schemaObject() {
-        invariant(this.kind.endsWith("Type"));
-        return {
-            kind: code `${literalOf(this.kind.substring(0, this.kind.length - "Type".length))} as const`,
-        };
+    get schemaInitializers() {
+        return [code `kind: ${literalOf(this.kind)} as const`];
     }
     rdfjsTermExpression;
 }
+__decorate([
+    Memoize()
+], AbstractType.prototype, "schema", null);
 (function (AbstractType) {
     class GraphqlType {
         /**

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

@@ -3,12 +3,12 @@ import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigDecimalType extends AbstractLiteralType {
-    readonly name: Code;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
+    readonly expression: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly hashFunction: Code;
-    readonly kind = "BigDecimalType";
+    readonly kind = "BigDecimal";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;

package/dist/generators/ts/BigDecimalType.js

@@ -9,19 +9,19 @@ import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 export class BigDecimalType extends AbstractLiteralType {
-    name = code `${this.reusables.imports.BigDecimal}`;
     conversionFunction = Maybe.empty();
+    expression = code `${this.reusables.imports.BigDecimal}`;
     filterFunction = code `${this.reusables.snippets.filterBigDecimal}`;
     filterType = code `${this.reusables.snippets.NumericFilter}<${this.reusables.imports.BigDecimal}>`;
     hashFunction = code `${this.reusables.snippets.hashBigDecimal}`;
-    kind = "BigDecimalType";
+    kind = "BigDecimal";
     schemaType = code `${this.reusables.snippets.NumericSchema}<${this.reusables.imports.BigDecimal}>`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.bigDecimalSparqlWherePatterns}`;
     get graphqlType() {
         return new AbstractLiteralType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
     }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.encase<Error, ${this.name}>(() => new ${this.name}(${variables.value}))`;
+        return code `${this.reusables.imports.Either}.encase<Error, ${this.expression}>(() => new ${this.expression}(${variables.value}))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.toFixed()`;

package/dist/generators/ts/BigIntType.d.ts

@@ -2,7 +2,7 @@ import type { Literal } from "@rdfjs/types";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigIntType extends AbstractNumericType<bigint> {
-    readonly kind = "BigIntType";
+    readonly kind = "BigInt";
     readonly typeofs: "bigint"[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     fromJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromJsonExpression"]>[0]): Code;

package/dist/generators/ts/BigIntType.js

@@ -9,7 +9,7 @@ import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class BigIntType extends AbstractNumericType {
-    kind = "BigIntType";
+    kind = "BigInt";
     typeofs = ["bigint"];
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLBigInt}`, this.reusables);
@@ -17,9 +17,9 @@ export class BigIntType extends AbstractNumericType {
     fromJsonExpression({ variables, }) {
         let expression = code `BigInt(${variables.value})`;
         if (this.primitiveIn.length > 0) {
-            expression = code `${expression} as ${this.name}`;
+            expression = code `${expression} as ${this.expression}`;
         }
-        return code `${this.reusables.imports.Either}.encase<Error, ${this.name}>(() => ${expression})`;
+        return code `${this.reusables.imports.Either}.encase<Error, ${this.expression}>(() => ${expression})`;
     }
     jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {

package/dist/generators/ts/BlankNodeType.d.ts

@@ -4,18 +4,18 @@ import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
     readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
+    readonly expression: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly parseFunction: Code;
-    readonly kind = "BlankNodeType";
-    readonly name: Code;
+    readonly kind = "BlankNode";
     readonly nodeKinds: ReadonlySet<"BlankNode">;
+    readonly parseFunction: Code;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     constructor(superParameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode>>[0], "hasValues" | "in_">);
     fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<BlankNode>["fromJsonExpression"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode>["jsonSchema"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<BlankNode>["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractIdentifierType<BlankNode>["fromRdfResourceValuesExpressionChain"]>[0]): {
         valueTo: Code;

package/dist/generators/ts/BlankNodeType.js

@@ -13,21 +13,21 @@ export class BlankNodeType extends AbstractIdentifierType {
         code: code `${this.reusables.snippets.convertToBlankNode}`,
         sourceTypes: [
             {
-                name: code `${this.reusables.imports.BlankNode}`,
+                expression: code `${this.reusables.imports.BlankNode}`,
                 typeof: "object",
             },
             {
-                name: "undefined",
+                expression: code `undefined`,
                 typeof: "undefined",
             },
         ],
     });
+    expression = code `${this.reusables.imports.BlankNode}`;
     filterFunction = code `${this.reusables.snippets.filterBlankNode}`;
     filterType = code `${this.reusables.snippets.BlankNodeFilter}`;
-    parseFunction = code `${this.reusables.snippets.parseBlankNode};`;
-    kind = "BlankNodeType";
-    name = code `${this.reusables.imports.BlankNode}`;
+    kind = "BlankNode";
     nodeKinds = nodeKinds;
+    parseFunction = code `${this.reusables.snippets.parseBlankNode};`;
     schemaType = code `${this.reusables.snippets.BlankNodeSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.blankNodeSparqlWherePatterns}`;
     constructor(superParameters) {
@@ -38,13 +38,7 @@ export class BlankNodeType extends AbstractIdentifierType {
         });
     }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)))`;
-    }
-    jsonType(parameters) {
-        const discriminantProperty = parameters?.includeDiscriminantProperty
-            ? `, readonly termType: "BlankNode"`
-            : "";
-        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)))`;
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
@@ -52,6 +46,12 @@ export class BlankNodeType extends AbstractIdentifierType {
             : "";
         return code `${this.reusables.imports.z}.object({ "@id": ${this.reusables.imports.z}.string().min(1)${discriminantProperty} })`;
     }
+    jsonType(parameters) {
+        const discriminantProperty = parameters?.includeDiscriminantProperty
+            ? `, readonly termType: "BlankNode"`
+            : "";
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+    }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         const discriminantProperty = includeDiscriminantProperty
             ? code `, termType: ${variables.value}.termType`

package/dist/generators/ts/BooleanType.d.ts

@@ -6,11 +6,11 @@ export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     readonly filterType: Code;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
-    readonly kind = "BooleanType";
-    readonly schemaType: Code;
+    readonly kind = "Boolean";
     readonly typeofs: "boolean"[];
     readonly valueSparqlWherePatternsFunction: Code;
-    get name(): string;
+    get expression(): Code;
+    get schemaType(): Code;
     jsonSchema(_parameters: Parameters<AbstractPrimitiveType<number>["jsonSchema"]>[0]): Code;
     literalExpression(literal: boolean | Literal): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfResourceValuesExpression"]>[0]): Code;

package/dist/generators/ts/BooleanType.js

@@ -13,15 +13,17 @@ export class BooleanType extends AbstractPrimitiveType {
     filterType = code `${this.reusables.snippets.BooleanFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLBoolean}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashBoolean}`;
-    kind = "BooleanType";
-    schemaType = code `${this.reusables.snippets.BooleanSchema}`;
+    kind = "Boolean";
     typeofs = ["boolean"];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.booleanSparqlWherePatterns}`;
-    get name() {
+    get expression() {
         if (this.primitiveIn.length > 0) {
-            return `${this.primitiveIn.map((value) => value.toString()).join(" | ")}`;
+            return code `${this.primitiveIn.map((value) => value.toString()).join(" | ")}`;
         }
-        return `boolean`;
+        return code `boolean`;
+    }
+    get schemaType() {
+        return code `${this.reusables.snippets.BooleanSchema}<${this.expression}>`;
     }
     jsonSchema(_parameters) {
         if (this.primitiveIn.length === 1) {
@@ -46,5 +48,8 @@ export class BooleanType extends AbstractPrimitiveType {
 }
 __decorate([
     Memoize()
-], BooleanType.prototype, "name", null);
+], BooleanType.prototype, "expression", null);
+__decorate([
+    Memoize()
+], BooleanType.prototype, "schemaType", null);
 //# sourceMappingURL=BooleanType.js.map

package/dist/generators/ts/DateTimeType.d.ts

@@ -4,7 +4,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateTimeType extends AbstractDateType {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
-    readonly kind = "DateTimeType";
+    readonly kind = "DateTime";
     jsonSchema(_parameters: Parameters<AbstractDateType["jsonSchema"]>[0]): Code;
     literalExpression(literal: Date | Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;

package/dist/generators/ts/DateTimeType.js

@@ -4,7 +4,7 @@ import { code } from "./ts-poet-wrapper.js";
 export class DateTimeType extends AbstractDateType {
     graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDateTime}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashDateTime}`;
-    kind = "DateTimeType";
+    kind = "DateTime";
     jsonSchema(_parameters) {
         return code `${this.reusables.imports.z}.iso.datetime()`;
     }

package/dist/generators/ts/DateType.d.ts

@@ -5,7 +5,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateType extends AbstractDateType {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
-    readonly kind = "DateType";
+    readonly kind = "Date";
     jsonSchema(_parameters: Parameters<DateTimeType["jsonSchema"]>[0]): Code;
     literalExpression(literal: Date | Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;

package/dist/generators/ts/DateType.js

@@ -5,7 +5,7 @@ import { code } from "./ts-poet-wrapper.js";
 export class DateType extends AbstractDateType {
     graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDate}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashDate}`;
-    kind = "DateType";
+    kind = "Date";
     jsonSchema(_parameters) {
         return code `${this.reusables.imports.z}.iso.date()`;
     }

package/dist/generators/ts/DefaultValueType.d.ts

@@ -9,7 +9,7 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     readonly defaultValue: Literal | NamedNode;
     readonly discriminantProperty: Maybe<AbstractType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly kind = "DefaultValueType";
+    readonly kind = "DefaultValue";
     readonly typeofs: "object"[];
     readonly validationFunction: Maybe<Code>;
     constructor({ defaultValue, ...superParameters }: {
@@ -17,20 +17,16 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
     get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
     get equalsFunction(): Code;
+    get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
     get hashFunction(): Code;
     get mutable(): boolean;
-    get name(): Code | string;
     get schemaType(): Code;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
-    protected get schemaObject(): {
-        defaultValue: Code;
-        item: Code;
-        kind: Code;
-    };
+    protected get schemaInitializers(): Code[];
     private get defaultValueExpression();
     fromJsonExpression(parameters: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;

package/dist/generators/ts/DefaultValueType.js

@@ -13,7 +13,7 @@ export class DefaultValueType extends AbstractContainerType {
     defaultValue;
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
-    kind = "DefaultValueType";
+    kind = "DefaultValue";
     typeofs = ["object"];
     validationFunction = this.itemType.validationFunction;
     constructor({ defaultValue, ...superParameters }) {
@@ -27,7 +27,7 @@ export class DefaultValueType extends AbstractContainerType {
             sourceTypes: itemConversionFunction.sourceTypes
                 .filter((sourceType) => sourceType.typeof !== "undefined")
                 .concat({
-                name: "undefined",
+                expression: code `undefined`,
                 typeof: "undefined",
             }),
         });
@@ -35,6 +35,9 @@ export class DefaultValueType extends AbstractContainerType {
     get equalsFunction() {
         return this.itemType.equalsFunction;
     }
+    get expression() {
+        return this.itemType.expression;
+    }
     get filterFunction() {
         return this.itemType.filterFunction;
     }
@@ -50,11 +53,8 @@ export class DefaultValueType extends AbstractContainerType {
     get mutable() {
         return this.itemType.mutable;
     }
-    get name() {
-        return this.itemType.name;
-    }
     get schemaType() {
-        return code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.name}, ${this.itemType.schemaType}>`;
+        return code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.expression}, ${this.itemType.schemaType}>`;
     }
     get valueSparqlConstructTriplesFunction() {
         return this.itemType.valueSparqlConstructTriplesFunction;
@@ -62,24 +62,20 @@ export class DefaultValueType extends AbstractContainerType {
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            defaultValue: this.defaultValueExpression,
-        };
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `defaultValue: ${this.defaultValueExpression}`);
     }
     get defaultValueExpression() {
         switch (this.itemType.kind) {
-            case "IdentifierType":
-            case "IriType":
-            case "LiteralType":
-            case "TermType":
+            case "Identifier":
+            case "Iri":
+            case "Literal":
+            case "Term":
                 return this.rdfjsTermExpression(this.defaultValue);
-            case "AnonymousUnionType":
-            case "ListType":
-            case "NamedObjectType":
-            case "NamedObjectUnionType":
-            case "NamedUnionType":
+            case "List":
+            case "Object":
+            case "ObjectUnion":
+            case "Union":
                 throw new RangeError(`not implemented ${this.itemType.kind}`);
         }
         invariant(this.defaultValue.termType === "Literal");
@@ -136,7 +132,7 @@ __decorate([
 ], DefaultValueType.prototype, "defaultValueExpression", null);
 (function (DefaultValueType) {
     function isItemType(type) {
-        if (type.kind === "BlankNodeType") {
+        if (type.kind === "BlankNode") {
             return false;
         }
         return AbstractContainerType.isItemType(type);

package/dist/generators/ts/FloatType.d.ts

@@ -2,7 +2,7 @@ import type { Literal } from "@rdfjs/types";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class FloatType extends AbstractNumericType<number> {
-    readonly kind = "FloatType";
+    readonly kind = "Float";
     readonly typeofs: "number"[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     literalExpression(literal: Literal | number): Code;

package/dist/generators/ts/FloatType.js

@@ -9,7 +9,7 @@ import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class FloatType extends AbstractNumericType {
-    kind = "FloatType";
+    kind = "Float";
     typeofs = ["number"];
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLFloat}`, this.reusables);

package/dist/generators/ts/GraphqlSchema.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from "ts-log";
-import type { NamedObjectType } from "./NamedObjectType.js";
-import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { Reusables } from "./Reusables.js";
 import type { TsGenerator } from "./TsGenerator.js";
 import { type Code } from "./ts-poet-wrapper.js";
@@ -12,8 +12,8 @@ export declare class GraphqlSchema {
     constructor({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }: {
         configuration: TsGenerator.Configuration;
         logger: Logger;
-        namedObjectTypes: readonly NamedObjectType[];
-        namedObjectUnionTypes: readonly NamedObjectUnionType[];
+        namedObjectTypes: readonly ObjectType[];
+        namedObjectUnionTypes: readonly ObjectUnionType[];
         reusables: Reusables;
     });
     get declaration(): Code;

package/dist/generators/ts/GraphqlSchema.js

@@ -28,8 +28,8 @@ export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query
                     },
                 },
                 resolve: code `\
-  async (_source, args: { identifier: string }, { objectSet }): Promise<${namedObjectType.name}> => 
-    (await ${this.reusables.imports.EitherAsync}<Error, ${namedObjectType.name}>(async ({ liftEither }) => 
+  async (_source, args: { identifier: string }, { objectSet }): Promise<${namedObjectType.expression}> => 
+    (await ${this.reusables.imports.EitherAsync}<Error, ${namedObjectType.expression}>(async ({ liftEither }) => 
       liftEither(await objectSet.${namedObjectType.objectSetMethodNames.object}(await liftEither(${namedObjectType.identifierTypeAlias}.parse(args.identifier))))
     )).unsafeCoerce()`,
                 type: namedObjectType.graphqlType.name,
@@ -61,8 +61,8 @@ export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query
                     },
                 },
                 resolve: code `\
-  async (_source, args: { identifiers: readonly string[] | null; limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly ${namedObjectType.name}[]> =>
-  (await ${this.reusables.imports.EitherAsync}<Error, readonly ${namedObjectType.name}[]>(async ({ liftEither }) => {
+  async (_source, args: { identifiers: readonly string[] | null; limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly ${namedObjectType.expression}[]> =>
+  (await ${this.reusables.imports.EitherAsync}<Error, readonly ${namedObjectType.expression}[]>(async ({ liftEither }) => {
     let filter: ${namedObjectType.filterType} | undefined;
     if (args.identifiers) {
       const identifiers: ${namedObjectType.identifierTypeAlias}[] = [];

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

@@ -5,18 +5,18 @@ import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IdentifierType extends AbstractIdentifierType<BlankNode | NamedNode> {
     readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
+    readonly expression: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly parseFunction: Code;
-    readonly kind = "IdentifierType";
-    readonly name: Code;
+    readonly kind = "Identifier";
     readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
+    readonly parseFunction: Code;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     constructor(parameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "hasValues" | "in_">);
     fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractIdentifierType<BlankNode | NamedNode>["fromRdfResourceValuesExpressionChain"]>;
 }

package/dist/generators/ts/IdentifierType.js

@@ -14,29 +14,29 @@ export class IdentifierType extends AbstractIdentifierType {
         code: code `${this.reusables.snippets.convertToIdentifier}`,
         sourceTypes: [
             {
-                name: code `${this.reusables.imports.BlankNode}`,
+                expression: code `${this.reusables.imports.BlankNode}`,
                 typeof: "object",
             },
             {
-                name: code `${this.reusables.imports.NamedNode}`,
+                expression: code `${this.reusables.imports.NamedNode}`,
                 typeof: "object",
             },
             {
-                name: "string",
+                expression: code `string`,
                 typeof: "string",
             },
             {
-                name: "undefined",
+                expression: code `undefined`,
                 typeof: "undefined",
             },
         ],
     });
+    expression = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
     filterFunction = code `${this.reusables.snippets.filterIdentifier}`;
     filterType = code `${this.reusables.snippets.IdentifierFilter}`;
-    parseFunction = code `${this.reusables.snippets.parseIdentifier};`;
-    kind = "IdentifierType";
-    name = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
+    kind = "Identifier";
     nodeKinds = nodeKinds;
+    parseFunction = code `${this.reusables.snippets.parseIdentifier};`;
     schemaType = code `${this.reusables.snippets.IdentifierSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.identifierSparqlWherePatterns}`;
     constructor(parameters) {
@@ -47,13 +47,7 @@ export class IdentifierType extends AbstractIdentifierType {
         });
     }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>((${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
-            ? `, readonly termType: "BlankNode" | "NamedNode"`
-            : "";
-        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>((${variables.value}["@id"].startsWith("_:") ? ${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)) : ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"])))`;
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
@@ -61,6 +55,12 @@ export class IdentifierType extends AbstractIdentifierType {
             : "";
         return code `${this.reusables.imports.z}.object({ "@id": ${this.reusables.imports.z}.string().min(1)${discriminantProperty} })`;
     }
+    jsonType(parameters) {
+        const discriminantProperty = parameters?.includeDiscriminantProperty
+            ? `, readonly termType: "BlankNode" | "NamedNode"`
+            : "";
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+    }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         const discriminantProperty = includeDiscriminantProperty
             ? code `, termType: ${variables.value}.termType as ${[...this.nodeKinds].map((nodeKind) => `"${NodeKind.toTermType(nodeKind)}"`).join(" | ")}`

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

@@ -2,7 +2,7 @@ import type { Literal } from "@rdfjs/types";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IntType extends AbstractNumericType<number> {
-    readonly kind = "IntType";
+    readonly kind = "Int";
     readonly typeofs: "number"[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     literalExpression(literal: Literal | number): Code;

package/dist/generators/ts/IntType.js

@@ -9,7 +9,7 @@ import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class IntType extends AbstractNumericType {
-    kind = "IntType";
+    kind = "Int";
     typeofs = ["number"];
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLInt}`, this.reusables);

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

@@ -5,13 +5,15 @@ 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 kind = "Iri";
     readonly nodeKinds: ReadonlySet<"IRI">;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     get conversionFunction(): Maybe<AbstractIdentifierType.ConversionFunction>;
-    get name(): Code;
+    get expression(): Code;
     get parseFunction(): Code;
+    protected get schemaInitializers(): readonly Code[];
+    private get valueTypeExpression();
     fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<NamedNode>["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractIdentifierType<NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;