@shaclmate/compiler 2.0.22 → 2.0.23

package/dist/generators/ts/SnippetDeclarations.js

@@ -1,11 +1,15 @@
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 export var SnippetDeclarations;
 (function (SnippetDeclarations) {
     SnippetDeclarations.arrayEquals = `\
-export function arrayEquals<T>(
+/**
+ * Compare two arrays element-wise with the provided elementEquals function.
+ */  
+export function ${syntheticNamePrefix}arrayEquals<T>(
   leftArray: readonly T[],
   rightArray: readonly T[],
-  elementEquals: (left: T, right: T) => boolean | EqualsResult,
-): EqualsResult {
+  elementEquals: (left: T, right: T) => boolean | ${syntheticNamePrefix}EqualsResult,
+): ${syntheticNamePrefix}EqualsResult {
   if (leftArray.length !== rightArray.length) {
     return purify.Left({
       left: leftArray,
@@ -21,7 +25,7 @@ export function arrayEquals<T>(
   ) {
     const leftElement = leftArray[leftElementIndex];
 
-    const rightUnequals: EqualsResult.Unequal[] = [];
+    const rightUnequals: ${syntheticNamePrefix}EqualsResult.Unequal[] = [];
     for (
       let rightElementIndex = 0;
       rightElementIndex < rightArray.length;
@@ -30,7 +34,7 @@ export function arrayEquals<T>(
       const rightElement = rightArray[rightElementIndex];
 
       const leftElementEqualsRightElement =
-        EqualsResult.fromBooleanEqualsResult(
+        ${syntheticNamePrefix}EqualsResult.fromBooleanEqualsResult(
           leftElement,
           rightElement,
           elementEquals(leftElement, rightElement),
@@ -39,7 +43,7 @@ export function arrayEquals<T>(
         break; // left element === right element, break out of the right iteration
       }
       rightUnequals.push(
-        leftElementEqualsRightElement.extract() as EqualsResult.Unequal,
+        leftElementEqualsRightElement.extract() as ${syntheticNamePrefix}EqualsResult.Unequal,
       );
     }
 
@@ -61,18 +65,18 @@ export function arrayEquals<T>(
     // Else there was a right element equal to the left element, continue to the next left element
   }
 
-  return EqualsResult.Equal;
+  return ${syntheticNamePrefix}EqualsResult.Equal;
 }
 `;
     SnippetDeclarations.booleanEquals = `\
 /**
- * Compare two objects with equals(other: T): boolean methods and return an EqualsResult.
+ * Compare two objects with equals(other: T): boolean methods and return an ${syntheticNamePrefix}EqualsResult.
  */
-export function booleanEquals<T extends { equals: (other: T) => boolean }>(
+export function ${syntheticNamePrefix}booleanEquals<T extends { equals: (other: T) => boolean }>(
   left: T,
   right: T,
-): EqualsResult {
-  return EqualsResult.fromBooleanEqualsResult(
+): ${syntheticNamePrefix}EqualsResult {
+  return ${syntheticNamePrefix}EqualsResult.fromBooleanEqualsResult(
     left,
     right,
     left.equals(right),
@@ -80,104 +84,101 @@ export function booleanEquals<T extends { equals: (other: T) => boolean }>(
 }`;
     SnippetDeclarations.dateEquals = `\
 /**
- * Compare two Dates and return an EqualsResult.
+ * Compare two Dates and return an ${syntheticNamePrefix}EqualsResult.
  */
-export function dateEquals(left: Date, right: Date): EqualsResult {
-  return EqualsResult.fromBooleanEqualsResult(
+export function ${syntheticNamePrefix}dateEquals(left: Date, right: Date): ${syntheticNamePrefix}EqualsResult {
+  return ${syntheticNamePrefix}EqualsResult.fromBooleanEqualsResult(
     left,
     right,
     left.getTime() === right.getTime(),
   );
 }`;
     SnippetDeclarations.EqualsResult = `\
-export type EqualsResult = purify.Either<EqualsResult.Unequal, true>;
-
-export namespace EqualsResult {
-    export const Equal: EqualsResult = purify.Either.of<Unequal, true>(true);
-
-    export function fromBooleanEqualsResult(
-      left: any,
-      right: any,
-      equalsResult: boolean | EqualsResult,
-    ): EqualsResult {
-      if (typeof equalsResult !== "boolean") {
-        return equalsResult;
-      }
+export type ${syntheticNamePrefix}EqualsResult = purify.Either<${syntheticNamePrefix}EqualsResult.Unequal, true>;
 
-      if (equalsResult) {
-        return Equal;
-      }
-      return purify.Left({
-        left,
-        right,
-        type: "BooleanEquals",
-      });
+export namespace ${syntheticNamePrefix}EqualsResult {
+  export const Equal: ${syntheticNamePrefix}EqualsResult = purify.Either.of<Unequal, true>(true);
+
+  export function fromBooleanEqualsResult(
+    left: any,
+    right: any,
+    equalsResult: boolean | ${syntheticNamePrefix}EqualsResult,
+  ): ${syntheticNamePrefix}EqualsResult {
+    if (typeof equalsResult !== "boolean") {
+      return equalsResult;
+    }
+
+    if (equalsResult) {
+      return Equal;
     }
 
-    export type Unequal =
-      | {
-          readonly left: {
-            readonly array: readonly any[];
-            readonly element: any;
-            readonly elementIndex: number;
-          };
-          readonly right: {
-            readonly array: readonly any[];
-            readonly unequals: readonly Unequal[];
-          };
-          readonly type: "ArrayElement";
-        }
-      | {
-          readonly left: readonly any[];
-          readonly right: readonly any[];
-          readonly type: "ArrayLength";
-        }
-      | {
-          readonly left: any;
-          readonly right: any;
-          readonly type: "BooleanEquals";
-        }
-      | {
-          readonly left: any;
-          readonly right: any;
-          readonly type: "LeftError";
-        }
-      | {
-          readonly right: any;
-          readonly type: "LeftNull";
-        }
-      | {
-          readonly left: bigint | boolean | number | string;
-          readonly right: bigint | boolean | number | string;
-          readonly type: "Primitive";
-        }
-      | {
-          readonly left: object;
-          readonly right: object;
-          readonly propertyName: string;
-          readonly propertyValuesUnequal: Unequal;
-          readonly type: "Property";
-        }
-      | {
-          readonly left: any;
-          readonly right: any;
-          readonly type: "RightError";
-        }
-      | {
-          readonly left: any;
-          readonly type: "RightNull";
-        };
+    return purify.Left({ left, right, type: "BooleanEquals" });
+  }
+
+  export type Unequal =
+  | {
+    readonly left: {
+      readonly array: readonly any[];
+      readonly element: any;
+      readonly elementIndex: number;
+    };
+    readonly right: {
+      readonly array: readonly any[];
+      readonly unequals: readonly Unequal[];
+    };
+    readonly type: "ArrayElement";
+  }
+  | {
+    readonly left: readonly any[];
+    readonly right: readonly any[];
+    readonly type: "ArrayLength";
+  }
+  | {
+    readonly left: any;
+    readonly right: any;
+    readonly type: "BooleanEquals";
+  }
+  | {
+    readonly left: any;
+    readonly right: any;
+    readonly type: "LeftError";
+  }
+  | {
+    readonly right: any;
+    readonly type: "LeftNull";
+  }
+  | {
+    readonly left: bigint | boolean | number | string;
+    readonly right: bigint | boolean | number | string;
+    readonly type: "Primitive";
+  }
+  | {
+    readonly left: any;
+    readonly right: any;
+    readonly propertyName: string;
+    readonly propertyValuesUnequal: Unequal;
+    readonly type: "Property";
+  }
+  | {
+    readonly left: any;
+    readonly right: any;
+    readonly type: "RightError";
+  }
+  | {
+    readonly left: any;
+    readonly type: "RightNull";
+  };
 }    
 `;
     SnippetDeclarations.maybeEquals = `\
-export function maybeEquals<T>(
+export function ${syntheticNamePrefix}maybeEquals<T>(
   leftMaybe: purify.Maybe<T>,
   rightMaybe: purify.Maybe<T>,
-  valueEquals: (left: T, right: T) => boolean | EqualsResult,
-): EqualsResult {
+  valueEquals: (left: T, right: T) => boolean | ${syntheticNamePrefix}EqualsResult,
+): ${syntheticNamePrefix}EqualsResult {
   if (leftMaybe.isJust()) {
     if (rightMaybe.isJust()) {
-      return EqualsResult.fromBooleanEqualsResult(
+      return ${syntheticNamePrefix}EqualsResult.fromBooleanEqualsResult(
         leftMaybe,
         rightMaybe,
         valueEquals(leftMaybe.unsafeCoerce(), rightMaybe.unsafeCoerce()),
@@ -196,20 +197,133 @@ export function maybeEquals<T>(
     });
   }
 
-  return EqualsResult.Equal;
-}
-`;
+  return ${syntheticNamePrefix}EqualsResult.Equal;
+}`;
+    SnippetDeclarations.LazyObjectSet = `\
+/**
+ * Type of lazy properties that return a set of objects. This is a class instead of an interface so it can be instanceof'd elsewhere.
+ */
+export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, StubObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
+  private readonly resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<purify.Either<Error, readonly ResolvedObjectT[]>>;
+  readonly stubs: readonly StubObjectT[];
+
+  constructor({ resolver, stubs }: {
+    resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<purify.Either<Error, readonly ResolvedObjectT[]>>,
+    stubs: readonly StubObjectT[]
+  }) {
+    this.resolver = resolver;
+    this.stubs = stubs;
+  }
+
+  async resolve(): Promise<purify.Either<Error, readonly ResolvedObjectT[]>> {
+    if (this.stubs.length === 0) {
+      return purify.Either.of([]);
+    }
+    return await this.resolver(this.stubs.map(stub => stub.${syntheticNamePrefix}identifier));
+  }
+}`;
+    SnippetDeclarations.LazyOptionalObject = `\
+/**
+ * Type of lazy properties that return a single optional object. This is a class instead of an interface so it can be instanceof'd elsewhere.
+ */
+export class ${syntheticNamePrefix}LazyOptionalObject<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, StubObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
+  private readonly resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>;
+  readonly stub: purify.Maybe<StubObjectT>;
+
+  constructor({ resolver, stub }: {
+    resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>,
+    stub: purify.Maybe<StubObjectT>
+  }) {
+    this.resolver = resolver;
+    this.stub = stub;
+  }
+
+  async resolve(): Promise<purify.Either<Error, purify.Maybe<ResolvedObjectT>>> {
+    if (this.stub.isNothing()) {
+      return purify.Either.of(purify.Maybe.empty());
+    }
+    return (await this.resolver(this.stub.unsafeCoerce().${syntheticNamePrefix}identifier)).map(purify.Maybe.of);
+  }
+}`;
+    SnippetDeclarations.LazyRequiredObject = `\
+/**
+ * Type of lazy properties that return a single required object. This is a class instead of an interface so it can be instanceof'd elsewhere.
+ */
+export class ${syntheticNamePrefix}LazyRequiredObject<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, StubObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
+  private readonly resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>;
+  readonly stub: StubObjectT;
+
+  constructor({ resolver, stub }: {
+    resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>,
+    stub: StubObjectT
+  }) {
+    this.resolver = resolver;
+    this.stub = stub;
+  }
+
+  resolve(): Promise<purify.Either<Error, ResolvedObjectT>> {
+    return this.resolver(this.stub.${syntheticNamePrefix}identifier);
+  }
+}`;
+    SnippetDeclarations.RdfVocabularies = `\
+export namespace ${syntheticNamePrefix}RdfVocabularies {
+  export namespace rdf {
+    export const first = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first");
+    export const nil = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil");
+    export const rest = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest");
+    export const subject = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#subject");
+    export const type = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
+  }
+
+  export namespace rdfs {
+    export const subClassOf = dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#subClassOf");
+  }
+
+  export namespace xsd {
+    export const boolean = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#boolean");
+    export const date = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#date");
+    export const dateTime = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#dateTime");
+    export const integer = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer");
+  }
+}`;
+    SnippetDeclarations.sparqlInstancesOfPattern = `\
+/**
+ * A sparqljs.Pattern that's the equivalent of ?subject rdf:type/rdfs:subClassOf* ?rdfType .
+ */
+export function ${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType, subject }: { rdfType: rdfjs.NamedNode, subject: sparqljs.Triple["subject"] }): sparqljs.Pattern {
+  return {
+    triples: [
+      {
+        subject,
+        predicate: {
+          items: [
+            $RdfVocabularies.rdf.type,
+            {
+              items: [$RdfVocabularies.rdfs.subClassOf],
+              pathType: "*",
+              type: "path",
+            },
+          ],
+          pathType: "/",
+          type: "path",
+        },
+        object: rdfType,
+      },
+    ],
+    type: "bgp",
+  };
+}`;
     SnippetDeclarations.strictEquals = `\
 /**
- * Compare two values for strict equality (===), returning an EqualsResult rather than a boolean.
+ * Compare two values for strict equality (===), returning an ${syntheticNamePrefix}EqualsResult rather than a boolean.
  */
-export function strictEquals<T extends bigint | boolean | number | string>(
+export function ${syntheticNamePrefix}strictEquals<T extends bigint | boolean | number | string>(
   left: T,
   right: T,
-): EqualsResult {
-  return EqualsResult.fromBooleanEqualsResult(left, right, left === right);
+): ${syntheticNamePrefix}EqualsResult {
+  return ${syntheticNamePrefix}EqualsResult.fromBooleanEqualsResult(left, right, left === right);
 }`;
-    SnippetDeclarations.UnwrapL = "type UnwrapL<T> = T extends purify.Either<infer L, any> ? L : never";
-    SnippetDeclarations.UnwrapR = "type UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never";
+    SnippetDeclarations.UnwrapL = `type ${syntheticNamePrefix}UnwrapL<T> = T extends purify.Either<infer L, any> ? L : never`;
+    SnippetDeclarations.UnwrapR = `type ${syntheticNamePrefix}UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never`;
 })(SnippetDeclarations || (SnippetDeclarations = {}));
 //# sourceMappingURL=SnippetDeclarations.js.map

package/dist/generators/ts/StringType.d.ts

@@ -1,8 +1,10 @@
 import { PrimitiveType } from "./PrimitiveType.js";
-import type { Type } from "./Type.js";
+import { Type } from "./Type.js";
 export declare class StringType extends PrimitiveType<string> {
     readonly kind = "StringType";
+    readonly typeof = "string";
     get conversions(): readonly Type.Conversion[];
+    get graphqlName(): Type.GraphqlName;
     get name(): string;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;

package/dist/generators/ts/StringType.js

@@ -6,9 +6,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Memoize } from "typescript-memoize";
 import { PrimitiveType } from "./PrimitiveType.js";
+import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class StringType extends PrimitiveType {
     kind = "StringType";
+    typeof = "string";
     get conversions() {
         const conversions = [
             {
@@ -26,11 +28,14 @@ export class StringType extends PrimitiveType {
         });
         return conversions;
     }
+    get graphqlName() {
+        return new Type.GraphqlName("graphql.GraphQLString");
+    }
     get name() {
         if (this.primitiveIn.length > 0) {
             return this.primitiveIn.map((value) => `"${value}"`).join(" | ");
         }
-        return "string";
+        return this.typeof;
     }
     hashStatements({ variables, }) {
         return [`${variables.hasher}.update(${variables.value});`];
@@ -48,7 +53,8 @@ export class StringType extends PrimitiveType {
     propertyFromRdfResourceValueExpression({ variables, }) {
         let expression = `${variables.resourceValue}.toString()`;
         if (this.primitiveIn.length > 0) {
-            expression = `${expression}.chain(value => { switch (value) { ${this.primitiveIn.map((value) => `case "${value}":`).join(" ")} return purify.Either.of(value); default: return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })`;
+            const eitherTypeParameters = `<Error, ${this.name}>`;
+            expression = `${expression}.chain(value => { switch (value) { ${this.primitiveIn.map((value) => `case "${value}":`).join(" ")} return purify.Either.of${eitherTypeParameters}(value); default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })`;
         }
         return expression;
     }
@@ -58,6 +64,12 @@ export class StringType extends PrimitiveType {
             .orDefault(variables.value);
     }
 }
+__decorate([
+    Memoize()
+], StringType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], StringType.prototype, "graphqlName", null);
 __decorate([
     Memoize()
 ], StringType.prototype, "name", null);

package/dist/generators/ts/TermType.d.ts

@@ -1,33 +1,41 @@
 import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import type { TsFeature } from "../../enums/index.js";
 import { Import } from "./Import.js";
 import { Type } from "./Type.js";
 /**
  * Abstract base class for IdentifierType and LiteralType.
+ *
+ * ConstantTermT is the type of sh:defaultValue, sh:hasValue, and sh:in.
+ * RuntimeTermT is the type of values at runtime.
+ *
+ * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:defaultValue et al.
  */
-export declare class TermType<TermT extends BlankNode | Literal | NamedNode> extends Type {
-    readonly defaultValue: Maybe<TermT>;
+export declare class TermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends Type {
+    readonly defaultValue: Maybe<ConstantTermT>;
     readonly equalsFunction: string;
-    readonly hasValues: readonly TermT[];
-    readonly in_: readonly TermT[];
+    readonly hasValues: readonly ConstantTermT[];
+    readonly in_: readonly ConstantTermT[];
     readonly mutable: boolean;
-    readonly nodeKinds: Set<TermT["termType"]>;
-    constructor({ defaultValue, hasValues, in_, nodeKinds, ...superParameters }: {
-        defaultValue: Maybe<TermT>;
-        hasValues: readonly TermT[];
-        in_: readonly TermT[];
-        nodeKinds: Set<TermT["termType"]>;
-    } & ConstructorParameters<typeof Type>[0]);
+    readonly nodeKinds: Set<RuntimeTermT["termType"]>;
+    readonly typeof: "boolean" | "number" | "object" | "string";
+    constructor({ defaultValue, hasValues, in_, nodeKinds, }: {
+        defaultValue: Maybe<ConstantTermT>;
+        hasValues: readonly ConstantTermT[];
+        in_: readonly ConstantTermT[];
+        nodeKinds: Set<RuntimeTermT["termType"]>;
+    });
     get conversions(): readonly Type.Conversion[];
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
-    get jsonName(): string;
+    get graphqlName(): Type.GraphqlName;
+    get jsonName(): Type.JsonName;
     get name(): string;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    graphqlResolveExpression(_parameters: Parameters<Type["graphqlResolveExpression"]>[0]): string;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    jsonUiSchemaElement(): Maybe<string>;
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    snippetDeclarations(features: Set<TsFeature>): readonly string[];
+    snippetDeclarations({ features, }: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
     sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;