@shaclmate/compiler 4.0.36 → 4.0.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.36",
+    "@shaclmate/shacl-ast": "4.0.37",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
@@ -68,5 +68,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.36"
+  "version": "4.0.37"
 }

package/dist/generators/ts/graphqlSchemaVariableStatement.d.ts

@@ -1,10 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { NamedObjectType } from "./NamedObjectType.js";
-import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { TsGenerator } from "./TsGenerator.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare function graphqlSchemaVariableStatement(this: TsGenerator, { namedObjectTypes, namedObjectUnionTypes, }: {
-    namedObjectTypes: readonly NamedObjectType[];
-    namedObjectUnionTypes: NamedObjectUnionType[];
-}): Maybe<Code>;
-//# sourceMappingURL=graphqlSchemaVariableStatement.d.ts.map

package/dist/generators/ts/graphqlSchemaVariableStatement.js

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

package/dist/generators/ts/objectSetDeclarations.d.ts

@@ -1,9 +0,0 @@
-import type { NamedObjectType } from "./NamedObjectType.js";
-import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { TsGenerator } from "./TsGenerator.js";
-import type { Code } from "./ts-poet-wrapper.js";
-export declare function objectSetDeclarations(this: TsGenerator, { namedObjectUnionTypes, ...parameters }: {
-    namedObjectTypes: readonly NamedObjectType[];
-    namedObjectUnionTypes: readonly NamedObjectUnionType[];
-}): readonly Code[];
-//# sourceMappingURL=objectSetDeclarations.d.ts.map

package/dist/generators/ts/objectSetDeclarations.js

@@ -1,27 +0,0 @@
-import { objectSetInterfaceDeclaration } from "./objectSetInterfaceDeclaration.js";
-import { rdfjsDatasetObjectSetClassDeclaration } from "./rdfjsDatasetObjectSetClassDeclaration.js";
-import { sparqlObjectSetClassDeclaration } from "./sparqlObjectSetClassDeclaration.js";
-export function objectSetDeclarations({ namedObjectUnionTypes, ...parameters }) {
-    const namedObjectTypes = parameters.namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern && !namedObjectType.synthetic);
-    const declarations = [];
-    if (this.configuration.features.has("ObjectSet")) {
-        declarations.push(objectSetInterfaceDeclaration.call(this, {
-            namedObjectTypes: namedObjectTypes,
-            namedObjectUnionTypes,
-        }));
-    }
-    if (this.configuration.features.has("RdfjsDatasetObjectSet")) {
-        declarations.push(rdfjsDatasetObjectSetClassDeclaration.call(this, {
-            namedObjectTypes: namedObjectTypes,
-            namedObjectUnionTypes,
-        }));
-    }
-    if (this.configuration.features.has("SparqlObjectSet")) {
-        declarations.push(sparqlObjectSetClassDeclaration.call(this, {
-            namedObjectTypes: namedObjectTypes,
-            namedObjectUnionTypes,
-        }));
-    }
-    return declarations;
-}
-//# sourceMappingURL=objectSetDeclarations.js.map

package/dist/generators/ts/objectSetInterfaceDeclaration.d.ts

@@ -1,9 +0,0 @@
-import type { NamedObjectType } from "./NamedObjectType.js";
-import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { TsGenerator } from "./TsGenerator.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare function objectSetInterfaceDeclaration(this: TsGenerator, { namedObjectTypes, namedObjectUnionTypes, }: {
-    namedObjectTypes: readonly NamedObjectType[];
-    namedObjectUnionTypes: readonly NamedObjectUnionType[];
-}): Code;
-//# sourceMappingURL=objectSetInterfaceDeclaration.d.ts.map

package/dist/generators/ts/objectSetInterfaceDeclaration.js

@@ -1,26 +0,0 @@
-import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
-export function objectSetInterfaceDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
-    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-    return code `\
-export interface ${syntheticNamePrefix}ObjectSet {
-  ${joinCode(namedObjectTypes
-        .flatMap((namedObjectType) => Object.values(objectSetMethodSignatures.call(this, { namedObjectType })))
-        .concat(namedObjectUnionTypes.flatMap((namedObjectUnionType) => Object.values(objectSetMethodSignatures.call(this, {
-        namedObjectType: namedObjectUnionType,
-    }))))
-        .map((methodSignature) => code `${methodSignature.name}(${methodSignature.parameters}): ${methodSignature.returnType};`), { on: "\n\n" })}
-}
-
-export namespace ${syntheticNamePrefix}ObjectSet {
-  export interface Query<ObjectFilterT, ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}> {
-    readonly filter?: ObjectFilterT;
-    readonly graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}>;
-    readonly identifiers?: readonly ObjectIdentifierT[];
-    readonly limit?: number;
-    readonly offset?: number;
-    readonly preferredLanguages?: readonly string[];
-  }
-}`;
-}
-//# sourceMappingURL=objectSetInterfaceDeclaration.js.map

package/dist/generators/ts/objectSetMethodSignatures.d.ts

@@ -1,18 +0,0 @@
-import type { NamedObjectType } from "./NamedObjectType.js";
-import type { TsGenerator } from "./TsGenerator.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare function objectSetMethodSignatures(this: TsGenerator, parameters: {
-    namedObjectType: {
-        readonly filterType: Code;
-        readonly identifierTypeAlias: Code;
-        readonly objectSetMethodNames: NamedObjectType.ObjectSetMethodNames;
-        readonly name: string;
-    };
-    parameterNamePrefix?: string;
-    queryT?: string;
-}): Readonly<Record<keyof NamedObjectType.ObjectSetMethodNames, {
-    readonly name: string;
-    readonly parameters: Code;
-    readonly returnType: Code;
-}>>;
-//# sourceMappingURL=objectSetMethodSignatures.d.ts.map

package/dist/generators/ts/objectSetMethodSignatures.js

@@ -1,31 +0,0 @@
-import { code } from "./ts-poet-wrapper.js";
-export function objectSetMethodSignatures(parameters) {
-    const { namedObjectType } = parameters;
-    const parameterNamePrefix = parameters?.parameterNamePrefix ?? "";
-    const queryT = parameters.queryT ??
-        `${this.configuration.syntheticNamePrefix}ObjectSet.Query`;
-    const methodNames = namedObjectType.objectSetMethodNames;
-    return {
-        object: {
-            name: methodNames.object,
-            parameters: code `${parameterNamePrefix}identifier: ${namedObjectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
-            returnType: code `Promise<${this.reusables.imports.Either}<Error, ${namedObjectType.name}>>`,
-        },
-        objectCount: {
-            name: methodNames.objectCount,
-            parameters: code `${parameterNamePrefix}query?: Pick<${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>, "filter">`,
-            returnType: code `Promise<${this.reusables.imports.Either}<Error, number>>`,
-        },
-        objectIdentifiers: {
-            name: methodNames.objectIdentifiers,
-            parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
-            returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]>>`,
-        },
-        objects: {
-            name: methodNames.objects,
-            parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
-            returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name}[]>>`,
-        },
-    };
-}
-//# sourceMappingURL=objectSetMethodSignatures.js.map

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.d.ts

@@ -1,9 +0,0 @@
-import type { NamedObjectType } from "./NamedObjectType.js";
-import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { TsGenerator } from "./TsGenerator.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare function rdfjsDatasetObjectSetClassDeclaration(this: TsGenerator, { namedObjectTypes, namedObjectUnionTypes, }: {
-    namedObjectTypes: readonly NamedObjectType[];
-    namedObjectUnionTypes: readonly NamedObjectUnionType[];
-}): Code;
-//# sourceMappingURL=rdfjsDatasetObjectSetClassDeclaration.d.ts.map

package/dist/generators/ts/sparqlObjectSetClassDeclaration.d.ts

@@ -1,9 +0,0 @@
-import type { NamedObjectType } from "./NamedObjectType.js";
-import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { TsGenerator } from "./TsGenerator.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare function sparqlObjectSetClassDeclaration(this: TsGenerator, { namedObjectTypes, namedObjectUnionTypes, }: {
-    namedObjectTypes: readonly NamedObjectType[];
-    namedObjectUnionTypes: readonly NamedObjectUnionType[];
-}): Code;
-//# sourceMappingURL=sparqlObjectSetClassDeclaration.d.ts.map