@shaclmate/compiler 2.0.23 → 3.0.0

package/dist/generators/ts/ObjectType.js

@@ -19,7 +19,6 @@ import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 export class ObjectType extends DeclaredType {
     imports;
     comment;
-    identifierMintingStrategy;
     label;
     toRdfTypes;
     abstract;
@@ -30,14 +29,13 @@ export class ObjectType extends DeclaredType {
     staticModuleName;
     synthetic;
     typeof = "object";
-    constructor({ abstract, comment, declarationType, extern, fromRdfType, imports, identifierMintingStrategy, label, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, staticModuleName, synthetic, toRdfTypes, ...superParameters }) {
+    constructor({ abstract, comment, declarationType, extern, fromRdfType, imports, label, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, staticModuleName, synthetic, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.abstract = abstract;
         this.comment = comment;
         this.declarationType = declarationType;
         this.extern = extern;
         this.fromRdfType = fromRdfType;
-        this.identifierMintingStrategy = identifierMintingStrategy;
         this.imports = imports;
         this.label = label;
         // Lazily initialize some members in getters to avoid recursive construction
@@ -85,7 +83,6 @@ export class ObjectType extends DeclaredType {
         }
         if (this.features.has("json")) {
             imports.push(Import.ZOD);
-            imports.push(Import.ZOD_TO_JSON_SCHEMA);
         }
         if (this.features.has("rdf")) {
             imports.push(Import.PURIFY);
@@ -124,6 +121,12 @@ export class ObjectType extends DeclaredType {
         }
         return declarations;
     }
+    get descendantFromRdfTypes() {
+        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfType.toList());
+    }
+    get descendantFromRdfTypeVariables() {
+        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfTypeVariable.toList());
+    }
     get descendantObjectTypes() {
         return this.lazyDescendantObjectTypes();
     }
@@ -171,7 +174,7 @@ export class ObjectType extends DeclaredType {
             case "class":
                 return `new ${this.name}(${parameters})`;
             case "interface":
-                return `${this.staticModuleName}.create(${parameters})`;
+                return `${this.staticModuleName}.${syntheticNamePrefix}create(${parameters})`;
         }
     }
     get objectSetMethodNames() {
@@ -223,7 +226,7 @@ export class ObjectType extends DeclaredType {
         return `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value}).unsafeCoerce()`;
     }
     fromRdfExpression({ variables, }) {
-        return `${variables.resourceValues}.head().chain(value => value.toResource()).chain(_resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf({ ...${variables.context}, ${variables.ignoreRdfType ? "ignoreRdfType: true, " : ""}languageIn: ${variables.languageIn}, objectSet: ${variables.objectSet}, resource: _resource }))`;
+        return `${variables.resourceValues}.chain(values => values.chainMap(value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...${variables.context}, ${variables.ignoreRdfType ? "ignoreRdfType: true, " : ""}objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages} }))))`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
@@ -301,6 +304,7 @@ export class ObjectType extends DeclaredType {
                 return [
                     `...${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${objectInitializer({
                         ignoreRdfType: parameters.allowIgnoreRdfType ? true : undefined, // Can ignore the rdf:type when the object is nested
+                        preferredLanguages: parameters.variables.preferredLanguages,
                         subject: parameters.variables.subject,
                         variablePrefix: parameters.variables.variablePrefix,
                     })})`,
@@ -349,6 +353,12 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "descendantFromRdfTypes", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "descendantFromRdfTypeVariables", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "descendantObjectTypes", null);

package/dist/generators/ts/ObjectUnionType.d.ts

@@ -13,6 +13,7 @@ declare class MemberType {
         universe: readonly ObjectType[];
     });
     get declarationType(): import("../../enums/TsObjectDeclarationType.js").TsObjectDeclarationType;
+    get descendantFromRdfTypeVariables(): readonly string[];
     get discriminatorPropertyValues(): readonly string[];
     get features(): Set<import("../../enums/TsFeature.js").TsFeature>;
     get fromRdfType(): Maybe<import("@rdfjs/types").NamedNode<string>>;
@@ -25,6 +26,7 @@ declare class MemberType {
     get staticModuleName(): string;
     get toRdfjsResourceType(): string;
     jsonZodSchema(parameters: Parameters<DeclaredType["jsonZodSchema"]>[0]): string;
+    newExpression(parameters: Parameters<ObjectType["newExpression"]>[0]): string;
     snippetDeclarations(parameters: Parameters<DeclaredType["snippetDeclarations"]>[0]): readonly string[];
     useImports(): readonly Import[];
 }

package/dist/generators/ts/ObjectUnionType.js

@@ -28,6 +28,9 @@ class MemberType {
     get declarationType() {
         return this.delegate.declarationType;
     }
+    get descendantFromRdfTypeVariables() {
+        return this.delegate.descendantFromRdfTypeVariables;
+    }
     get discriminatorPropertyValues() {
         // A member type's combined discriminator property values are its "own" values plus any descendant values that are
         // not the "own" values of some other member type.
@@ -81,6 +84,9 @@ class MemberType {
     jsonZodSchema(parameters) {
         return this.delegate.jsonZodSchema(parameters);
     }
+    newExpression(parameters) {
+        return this.delegate.newExpression(parameters);
+    }
     snippetDeclarations(parameters) {
         return this.delegate.snippetDeclarations(parameters);
     }
@@ -270,14 +276,19 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
             name: `${syntheticNamePrefix}fromRdf`,
             parameters: [
                 {
-                    name: "{ ignoreRdfType, objectSet, resource, ...context }",
-                    type: `{ [_index: string]: any; ignoreRdfType?: boolean; objectSet?: ${syntheticNamePrefix}ObjectSet, resource: rdfjsResource.Resource; }`,
+                    name: "resource",
+                    type: "rdfjsResource.Resource",
+                },
+                {
+                    hasQuestionToken: true,
+                    name: "options",
+                    type: `{ [_index: string]: any; ignoreRdfType?: boolean; objectSet?: ${syntheticNamePrefix}ObjectSet; preferredLanguages?: readonly string[] }`,
                 },
             ],
             returnType: `purify.Either<Error, ${this.name}>`,
             statements: [
                 `return ${this.memberTypes.reduce((expression, memberType) => {
-                    const memberTypeExpression = `(${memberType.staticModuleName}.${syntheticNamePrefix}fromRdf({ ...context, objectSet, resource }) as purify.Either<Error, ${this.name}>)`;
+                    const memberTypeExpression = `(${memberType.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...options, ignoreRdfType: false }) as purify.Either<Error, ${this.name}>)`;
                     return expression.length > 0
                         ? `${expression}.altLazy(() => ${memberTypeExpression})`
                         : memberTypeExpression;
@@ -298,7 +309,7 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
                     initializer: `new graphql.GraphQLUnionType(${objectInitializer({
                         description: this.comment.map(JSON.stringify).extract(),
                         name: `"${this.name}"`,
-                        resolveType: `function (value: ${this.name}) { return value.${syntheticNamePrefix}type; }`,
+                        resolveType: `(value: ${this.name}) => value.${syntheticNamePrefix}type`,
                         types: `[${this.memberTypes.map((memberType) => memberType.graphqlName.nullableName).join(", ")}]`,
                     })})`,
                 },
@@ -427,7 +438,7 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
                     {
                         hasQuestionToken: true,
                         name: "parameters",
-                        type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
+                        type: '{ ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                     },
                 ],
                 returnType: "readonly sparqljs.Pattern[]",
@@ -501,8 +512,9 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
                     type: this.name,
                 },
                 {
+                    hasQuestionToken: true,
                     name: parametersVariable,
-                    type: "{ mutateGraph: rdfjsResource.MutableResource.MutateGraph, resourceSet: rdfjsResource.MutableResourceSet }",
+                    type: "{ mutateGraph?: rdfjsResource.MutableResource.MutateGraph, resourceSet?: rdfjsResource.MutableResourceSet }",
                 },
             ],
             returnType: (() => {
@@ -537,7 +549,7 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
     }
     fromRdfExpression({ variables, }) {
         // Don't ignoreRdfType, we may need it to distinguish the union members
-        return `${variables.resourceValues}.head().chain(value => value.toResource()).chain(_resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf({ ...${variables.context}, languageIn: ${variables.languageIn}, objectSet: ${variables.objectSet}, resource: _resource }))`;
+        return `${variables.resourceValues}.chain(values => values.chainMap(value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...${variables.context}, ignoreRdfType: false, objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages} }))))`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
@@ -590,6 +602,7 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
             case "subject":
                 return [
                     `...${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${objectInitializer({
+                        preferredLanguages: parameters.variables.preferredLanguages,
                         subject: parameters.variables.subject,
                         variablePrefix: parameters.variables.variablePrefix,
                     })})`,
@@ -601,8 +614,7 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
             case "class":
                 return `${variables.value}.${syntheticNamePrefix}toJson()`;
             case "interface":
-                throw new Error("not implemented: need a freestanding toJson function like the toRdf function");
-            // return `${this.name}.toJson(${variables.value})`;
+                return `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
         }
     }
     toRdfExpression({ variables, }) {

package/dist/generators/ts/OptionType.d.ts

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { Import } from "./Import.js";
 import { Type } from "./Type.js";
-export declare class OptionType<ItemTypeT extends Type = Type> extends Type {
+export declare class OptionType<ItemTypeT extends Type> extends Type {
     readonly discriminatorProperty: Maybe<Type.DiscriminatorProperty>;
     readonly itemType: ItemTypeT;
     readonly kind = "OptionType";

package/dist/generators/ts/OptionType.js

@@ -4,8 +4,8 @@ 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 { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
+import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Import } from "./Import.js";
 import { SnippetDeclarations } from "./SnippetDeclarations.js";
@@ -73,7 +73,8 @@ export class OptionType extends Type {
             : `${expression}.map(item => (${itemFromJsonExpression}))`;
     }
     fromRdfExpression(parameters) {
-        return `${this.itemType.fromRdfExpression(parameters)}.map(value => purify.Maybe.of(value)).chainLeft(error => error instanceof rdfjsResource.Resource.MissingValueError ? purify.Right(purify.Maybe.empty()) : purify.Left(error))`;
+        const { variables } = parameters;
+        return `${this.itemType.fromRdfExpression(parameters)}.map(values => values.length > 0 ? values.map(value => purify.Maybe.of(value)) : rdfjsResource.Resource.Values.fromValue<purify.Maybe<${this.itemType.name}>>({ object: purify.Maybe.empty(), predicate: ${variables.predicate}, subject: ${variables.resource} }))`;
     }
     graphqlResolveExpression(parameters) {
         return `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;
@@ -117,14 +118,15 @@ export class OptionType extends Type {
     sparqlWherePatterns(parameters) {
         switch (parameters.context) {
             case "object": {
-                const patterns = super.sparqlWherePatterns(parameters);
+                const patterns = this.itemType.sparqlWherePatterns(parameters);
                 if (patterns.length === 0) {
                     return [];
                 }
                 return [`{ patterns: [${patterns.join(", ")}], type: "optional" }`];
             }
             case "subject": {
-                return this.itemType.sparqlWherePatterns(parameters);
+                throw new Error("should never be called");
+                // return this.itemType.sparqlWherePatterns(parameters);
             }
         }
     }

package/dist/generators/ts/PrimitiveType.d.ts

@@ -15,7 +15,7 @@ export declare abstract class PrimitiveType<ValueT extends boolean | Date | stri
     graphqlResolveExpression({ variables, }: Parameters<Type["graphqlResolveExpression"]>[0]): string;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     snippetDeclarations({ features, }: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
+    sparqlWherePatterns(parameters: Parameters<LiteralType["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
-    protected propertyFilterRdfResourceValuesExpression({ variables, }: Parameters<LiteralType["propertyFilterRdfResourceValuesExpression"]>[0]): string;
 }
 //# sourceMappingURL=PrimitiveType.d.ts.map

package/dist/generators/ts/PrimitiveType.js

@@ -41,12 +41,15 @@ export class PrimitiveType extends LiteralType {
         }
         return snippetDeclarations;
     }
+    sparqlWherePatterns(parameters) {
+        return super.sparqlWherePatterns({
+            ...parameters,
+            ignoreLiteralLanguage: parameters.ignoreLiteralLanguage ?? true,
+        });
+    }
     toJsonExpression({ variables, }) {
         return variables.value;
     }
-    propertyFilterRdfResourceValuesExpression({ variables, }) {
-        return variables.resourceValues;
-    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/SetType.d.ts

@@ -1,11 +1,11 @@
 import { Maybe } from "purify-ts";
 import type { Import } from "./Import.js";
 import { Type } from "./Type.js";
-export declare class SetType<ItemTypeT extends Type = Type> extends Type {
-    private readonly _mutable;
-    private readonly minCount;
+export declare class SetType<ItemTypeT extends Type> extends Type {
     readonly discriminatorProperty: Maybe<Type.DiscriminatorProperty>;
     readonly itemType: ItemTypeT;
+    private readonly _mutable;
+    private readonly minCount;
     readonly kind = "SetType";
     readonly typeof = "object";
     constructor({ itemType, minCount, mutable, }: {
@@ -20,7 +20,7 @@ export declare class SetType<ItemTypeT extends Type = Type> extends Type {
     get mutable(): boolean;
     get name(): string;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    fromRdfExpression(parameters: Parameters<Type["fromRdfExpression"]>[0]): string;
     graphqlResolveExpression({ variables, }: Parameters<Type["graphqlResolveExpression"]>[0]): string;
     hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonUiSchemaElement(parameters: Parameters<Type["jsonUiSchemaElement"]>[0]): ReturnType<Type["jsonUiSchemaElement"]>;

package/dist/generators/ts/SetType.js

@@ -11,10 +11,10 @@ import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 export class SetType extends Type {
-    _mutable;
-    minCount;
     discriminatorProperty = Maybe.empty();
     itemType;
+    _mutable;
+    minCount;
     kind = "SetType";
     typeof = "object";
     constructor({ itemType, minCount, mutable, }) {
@@ -87,15 +87,17 @@ export class SetType extends Type {
             ? expression
             : `${expression}.map(item => (${itemFromJsonExpression}))`;
     }
-    fromRdfExpression({ variables, }) {
-        const itemFromRdfExpression = this.itemType.fromRdfExpression({
-            variables: { ...variables, resourceValues: "item.toValues()" },
-        });
-        const arrayFromRdfExpression = `purify.Either.sequence(${variables.resourceValues}.map(item => ${itemFromRdfExpression}))`;
-        if (this._mutable || this.minCount === 0) {
-            return arrayFromRdfExpression;
+    fromRdfExpression(parameters) {
+        const { variables } = parameters;
+        const chain = [this.itemType.fromRdfExpression(parameters)];
+        if (this.minCount === 0 || this._mutable) {
+            chain.push(`map(values => values.toArray()${this._mutable ? ".concat()" : ""})`);
+        }
+        else {
+            chain.push(`chain(values => purify.NonEmptyList.fromArray(values.toArray()).toEither(new Error(\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} is an empty set\`)))`);
         }
-        return `${arrayFromRdfExpression}.chain(array => purify.NonEmptyList.fromArray(array).toEither(new Error(\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} is an empty set\`)))`;
+        chain.push(`map(valuesArray => rdfjsResource.Resource.Values.fromValue({ object: valuesArray , predicate: ${variables.predicate}, subject: ${variables.resource} }))`);
+        return chain.join(".");
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
@@ -146,7 +148,7 @@ export class SetType extends Type {
     sparqlWherePatterns(parameters) {
         switch (parameters.context) {
             case "object": {
-                const patterns = super.sparqlWherePatterns(parameters);
+                const patterns = this.itemType.sparqlWherePatterns(parameters);
                 if (patterns.length === 0) {
                     return [];
                 }
@@ -155,7 +157,8 @@ export class SetType extends Type {
                     : [`{ patterns: [${patterns.join(", ")}], type: "optional" }`];
             }
             case "subject": {
-                return this.itemType.sparqlWherePatterns(parameters);
+                throw new Error("should never be called");
+                // return this.itemType.sparqlWherePatterns(parameters);
             }
         }
     }

package/dist/generators/ts/SnippetDeclarations.d.ts

@@ -1,14 +1,15 @@
 export declare namespace SnippetDeclarations {
     const arrayEquals = "/**\n * Compare two arrays element-wise with the provided elementEquals function.\n */  \nexport function $arrayEquals<T>(\n  leftArray: readonly T[],\n  rightArray: readonly T[],\n  elementEquals: (left: T, right: T) => boolean | $EqualsResult,\n): $EqualsResult {\n  if (leftArray.length !== rightArray.length) {\n    return purify.Left({\n      left: leftArray,\n      right: rightArray,\n      type: \"ArrayLength\",\n    });\n  }\n\n  for (\n    let leftElementIndex = 0;\n    leftElementIndex < leftArray.length;\n    leftElementIndex++\n  ) {\n    const leftElement = leftArray[leftElementIndex];\n\n    const rightUnequals: $EqualsResult.Unequal[] = [];\n    for (\n      let rightElementIndex = 0;\n      rightElementIndex < rightArray.length;\n      rightElementIndex++\n    ) {\n      const rightElement = rightArray[rightElementIndex];\n\n      const leftElementEqualsRightElement =\n        $EqualsResult.fromBooleanEqualsResult(\n          leftElement,\n          rightElement,\n          elementEquals(leftElement, rightElement),\n        );\n      if (leftElementEqualsRightElement.isRight()) {\n        break; // left element === right element, break out of the right iteration\n      }\n      rightUnequals.push(\n        leftElementEqualsRightElement.extract() as $EqualsResult.Unequal,\n      );\n    }\n\n    if (rightUnequals.length === rightArray.length) {\n      // All right elements were unequal to the left element\n      return purify.Left({\n        left: {\n          array: leftArray,\n          element: leftElement,\n          elementIndex: leftElementIndex,\n        },\n        right: {\n          array: rightArray,\n          unequals: rightUnequals,\n        },\n        type: \"ArrayElement\",\n      });\n    }\n    // Else there was a right element equal to the left element, continue to the next left element\n  }\n\n  return $EqualsResult.Equal;\n}\n";
+    const arrayIntersection = "export function $arrayIntersection<T>(left: readonly T[], right: readonly T[]): readonly T[] {\n  if (left.length === 0) {\n    return right;\n  }\n  if (right.length === 0) {\n    return left;\n  }\n\n  const intersection = new Set<T>();\n  if (left.length <= right.length) {\n    const rightSet = new Set(right);\n    for (const leftElement of left) {\n      if (rightSet.has(leftElement)) {\n        intersection.add(leftElement);\n      }\n    }\n  } else {\n    const leftSet = new Set(left);\n    for (const rightElement of right) {\n      if (leftSet.has(rightElement)) {\n        intersection.add(rightElement);\n      }  \n    }\n  }\n  return [...intersection];\n}";
     const booleanEquals = "/**\n * Compare two objects with equals(other: T): boolean methods and return an $EqualsResult.\n */\nexport function $booleanEquals<T extends { equals: (other: T) => boolean }>(\n  left: T,\n  right: T,\n): $EqualsResult {\n  return $EqualsResult.fromBooleanEqualsResult(\n    left,\n    right,\n    left.equals(right),\n  );\n}";
     const dateEquals = "/**\n * Compare two Dates and return an $EqualsResult.\n */\nexport function $dateEquals(left: Date, right: Date): $EqualsResult {\n  return $EqualsResult.fromBooleanEqualsResult(\n    left,\n    right,\n    left.getTime() === right.getTime(),\n  );\n}";
     const EqualsResult = "export type $EqualsResult = purify.Either<$EqualsResult.Unequal, true>;\n\nexport namespace $EqualsResult {\n  export const Equal: $EqualsResult = purify.Either.of<Unequal, true>(true);\n\n  export function fromBooleanEqualsResult(\n    left: any,\n    right: any,\n    equalsResult: boolean | $EqualsResult,\n  ): $EqualsResult {\n    if (typeof equalsResult !== \"boolean\") {\n      return equalsResult;\n    }\n\n    if (equalsResult) {\n      return Equal;\n    }\n\n    return purify.Left({ left, right, type: \"BooleanEquals\" });\n  }\n\n  export type Unequal =\n  | {\n    readonly left: {\n      readonly array: readonly any[];\n      readonly element: any;\n      readonly elementIndex: number;\n    };\n    readonly right: {\n      readonly array: readonly any[];\n      readonly unequals: readonly Unequal[];\n    };\n    readonly type: \"ArrayElement\";\n  }\n  | {\n    readonly left: readonly any[];\n    readonly right: readonly any[];\n    readonly type: \"ArrayLength\";\n  }\n  | {\n    readonly left: any;\n    readonly right: any;\n    readonly type: \"BooleanEquals\";\n  }\n  | {\n    readonly left: any;\n    readonly right: any;\n    readonly type: \"LeftError\";\n  }\n  | {\n    readonly right: any;\n    readonly type: \"LeftNull\";\n  }\n  | {\n    readonly left: bigint | boolean | number | string;\n    readonly right: bigint | boolean | number | string;\n    readonly type: \"Primitive\";\n  }\n  | {\n    readonly left: any;\n    readonly right: any;\n    readonly propertyName: string;\n    readonly propertyValuesUnequal: Unequal;\n    readonly type: \"Property\";\n  }\n  | {\n    readonly left: any;\n    readonly right: any;\n    readonly type: \"RightError\";\n  }\n  | {\n    readonly left: any;\n    readonly type: \"RightNull\";\n  };\n}    \n";
     const maybeEquals = "export function $maybeEquals<T>(\n  leftMaybe: purify.Maybe<T>,\n  rightMaybe: purify.Maybe<T>,\n  valueEquals: (left: T, right: T) => boolean | $EqualsResult,\n): $EqualsResult {\n  if (leftMaybe.isJust()) {\n    if (rightMaybe.isJust()) {\n      return $EqualsResult.fromBooleanEqualsResult(\n        leftMaybe,\n        rightMaybe,\n        valueEquals(leftMaybe.unsafeCoerce(), rightMaybe.unsafeCoerce()),\n      );\n    }\n    return purify.Left({\n      left: leftMaybe.unsafeCoerce(),\n      type: \"RightNull\",\n    });\n  }\n\n  if (rightMaybe.isJust()) {\n    return purify.Left({\n      right: rightMaybe.unsafeCoerce(),\n      type: \"LeftNull\",\n    });\n  }\n\n  return $EqualsResult.Equal;\n}";
-    const LazyObjectSet = "/**\n * 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.\n */\nexport class $LazyObjectSet<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { $identifier: ObjectIdentifierT }, StubObjectT extends { $identifier: ObjectIdentifierT }> {\n  private readonly resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<purify.Either<Error, readonly ResolvedObjectT[]>>;\n  readonly stubs: readonly StubObjectT[];\n\n  constructor({ resolver, stubs }: {\n    resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<purify.Either<Error, readonly ResolvedObjectT[]>>,\n    stubs: readonly StubObjectT[]\n  }) {\n    this.resolver = resolver;\n    this.stubs = stubs;\n  }\n\n  async resolve(): Promise<purify.Either<Error, readonly ResolvedObjectT[]>> {\n    if (this.stubs.length === 0) {\n      return purify.Either.of([]);\n    }\n    return await this.resolver(this.stubs.map(stub => stub.$identifier));\n  }\n}";
+    const LazyObjectSet = "/**\n * 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.\n */\nexport class $LazyObjectSet<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { $identifier: ObjectIdentifierT }, StubObjectT extends { $identifier: ObjectIdentifierT }> {\n  private readonly resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<purify.Either<Error, readonly ResolvedObjectT[]>>;\n  readonly stubs: readonly StubObjectT[];\n\n  constructor({ resolver, stubs }: {\n    resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<purify.Either<Error, readonly ResolvedObjectT[]>>,\n    stubs: readonly StubObjectT[]\n  }) {\n    this.resolver = resolver;\n    this.stubs = stubs;\n  }\n\n  async resolve(options?: { limit?: number; offset?: number }): Promise<purify.Either<Error, readonly ResolvedObjectT[]>> {\n    if (this.stubs.length === 0) {\n      return purify.Either.of([]);\n    }\n\n    const limit = options?.limit ?? Number.MAX_SAFE_INTEGER;\n    if (limit <= 0) {\n      return purify.Either.of([]);\n    }\n\n    let offset = options?.offset ?? 0;\n    if (offset < 0) {\n      offset = 0;\n    }\n\n    return await this.resolver(this.stubs.slice(offset, offset + limit).map(stub => stub.$identifier));\n  }\n}";
     const LazyOptionalObject = "/**\n * 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.\n */\nexport class $LazyOptionalObject<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { $identifier: ObjectIdentifierT }, StubObjectT extends { $identifier: ObjectIdentifierT }> {\n  private readonly resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>;\n  readonly stub: purify.Maybe<StubObjectT>;\n\n  constructor({ resolver, stub }: {\n    resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>,\n    stub: purify.Maybe<StubObjectT>\n  }) {\n    this.resolver = resolver;\n    this.stub = stub;\n  }\n\n  async resolve(): Promise<purify.Either<Error, purify.Maybe<ResolvedObjectT>>> {\n    if (this.stub.isNothing()) {\n      return purify.Either.of(purify.Maybe.empty());\n    }\n    return (await this.resolver(this.stub.unsafeCoerce().$identifier)).map(purify.Maybe.of);\n  }\n}";
     const LazyRequiredObject = "/**\n * 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.\n */\nexport class $LazyRequiredObject<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { $identifier: ObjectIdentifierT }, StubObjectT extends { $identifier: ObjectIdentifierT }> {\n  private readonly resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>;\n  readonly stub: StubObjectT;\n\n  constructor({ resolver, stub }: {\n    resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>,\n    stub: StubObjectT\n  }) {\n    this.resolver = resolver;\n    this.stub = stub;\n  }\n\n  resolve(): Promise<purify.Either<Error, ResolvedObjectT>> {\n    return this.resolver(this.stub.$identifier);\n  }\n}";
     const RdfVocabularies = "export namespace $RdfVocabularies {\n  export namespace rdf {\n    export const first = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#first\");\n    export const nil = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#nil\");\n    export const rest = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#rest\");\n    export const subject = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#subject\");\n    export const type = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#type\");\n  }\n\n  export namespace rdfs {\n    export const subClassOf = dataFactory.namedNode(\"http://www.w3.org/2000/01/rdf-schema#subClassOf\");\n  }\n\n  export namespace xsd {\n    export const boolean = dataFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#boolean\");\n    export const date = dataFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#date\");\n    export const dateTime = dataFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#dateTime\");\n    export const integer = dataFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#integer\");\n  }\n}";
-    const sparqlInstancesOfPattern = "/**\n * A sparqljs.Pattern that's the equivalent of ?subject rdf:type/rdfs:subClassOf* ?rdfType .\n */\nexport function $sparqlInstancesOfPattern({ rdfType, subject }: { rdfType: rdfjs.NamedNode, subject: sparqljs.Triple[\"subject\"] }): sparqljs.Pattern {\n  return {\n    triples: [\n      {\n        subject,\n        predicate: {\n          items: [\n            $RdfVocabularies.rdf.type,\n            {\n              items: [$RdfVocabularies.rdfs.subClassOf],\n              pathType: \"*\",\n              type: \"path\",\n            },\n          ],\n          pathType: \"/\",\n          type: \"path\",\n        },\n        object: rdfType,\n      },\n    ],\n    type: \"bgp\",\n  };\n}";
+    const sparqlInstancesOfPattern = "/**\n * A sparqljs.Pattern that's the equivalent of ?subject rdf:type/rdfs:subClassOf* ?rdfType .\n */\nexport function $sparqlInstancesOfPattern({ rdfType, subject }: { rdfType: rdfjs.NamedNode | rdfjs.Variable, subject: sparqljs.Triple[\"subject\"] }): sparqljs.Pattern {\n  return {\n    triples: [\n      {\n        subject,\n        predicate: {\n          items: [\n            $RdfVocabularies.rdf.type,\n            {\n              items: [$RdfVocabularies.rdfs.subClassOf],\n              pathType: \"*\",\n              type: \"path\",\n            },\n          ],\n          pathType: \"/\",\n          type: \"path\",\n        },\n        object: rdfType,\n      },\n    ],\n    type: \"bgp\",\n  };\n}";
     const strictEquals = "/**\n * Compare two values for strict equality (===), returning an $EqualsResult rather than a boolean.\n */\nexport function $strictEquals<T extends bigint | boolean | number | string>(\n  left: T,\n  right: T,\n): $EqualsResult {\n  return $EqualsResult.fromBooleanEqualsResult(left, right, left === right);\n}";
     const UnwrapL = "type $UnwrapL<T> = T extends purify.Either<infer L, any> ? L : never";
     const UnwrapR = "type $UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never";

package/dist/generators/ts/SnippetDeclarations.js

@@ -68,6 +68,33 @@ export function ${syntheticNamePrefix}arrayEquals<T>(
   return ${syntheticNamePrefix}EqualsResult.Equal;
 }
 `;
+    SnippetDeclarations.arrayIntersection = `\
+export function ${syntheticNamePrefix}arrayIntersection<T>(left: readonly T[], right: readonly T[]): readonly T[] {
+  if (left.length === 0) {
+    return right;
+  }
+  if (right.length === 0) {
+    return left;
+  }
+
+  const intersection = new Set<T>();
+  if (left.length <= right.length) {
+    const rightSet = new Set(right);
+    for (const leftElement of left) {
+      if (rightSet.has(leftElement)) {
+        intersection.add(leftElement);
+      }
+    }
+  } else {
+    const leftSet = new Set(left);
+    for (const rightElement of right) {
+      if (leftSet.has(rightElement)) {
+        intersection.add(rightElement);
+      }  
+    }
+  }
+  return [...intersection];
+}`;
     SnippetDeclarations.booleanEquals = `\
 /**
  * Compare two objects with equals(other: T): boolean methods and return an ${syntheticNamePrefix}EqualsResult.
@@ -215,11 +242,22 @@ export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends rdfjs
     this.stubs = stubs;
   }
 
-  async resolve(): Promise<purify.Either<Error, readonly ResolvedObjectT[]>> {
+  async resolve(options?: { limit?: number; offset?: number }): 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));
+
+    const limit = options?.limit ?? Number.MAX_SAFE_INTEGER;
+    if (limit <= 0) {
+      return purify.Either.of([]);
+    }
+
+    let offset = options?.offset ?? 0;
+    if (offset < 0) {
+      offset = 0;
+    }
+
+    return await this.resolver(this.stubs.slice(offset, offset + limit).map(stub => stub.${syntheticNamePrefix}identifier));
   }
 }`;
     SnippetDeclarations.LazyOptionalObject = `\
@@ -290,7 +328,7 @@ export namespace ${syntheticNamePrefix}RdfVocabularies {
 /**
  * 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 {
+export function ${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType, subject }: { rdfType: rdfjs.NamedNode | rdfjs.Variable, subject: sparqljs.Triple["subject"] }): sparqljs.Pattern {
   return {
     triples: [
       {

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

@@ -6,9 +6,10 @@ export declare class StringType extends PrimitiveType<string> {
     get conversions(): readonly Type.Conversion[];
     get graphqlName(): Type.GraphqlName;
     get name(): string;
+    protected fromRdfExpressionChain({ variables, }: Parameters<PrimitiveType<string>["fromRdfExpressionChain"]>[0]): ReturnType<PrimitiveType<string>["fromRdfExpressionChain"]>;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    propertyFromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<string>["propertyFromRdfResourceValueExpression"]>[0]): string;
+    sparqlWherePatterns(parameters: Parameters<PrimitiveType<string>["sparqlWherePatterns"]>[0]): readonly string[];
     toRdfExpression({ variables, }: Parameters<PrimitiveType<string>["toRdfExpression"]>[0]): string;
 }
 //# sourceMappingURL=StringType.d.ts.map

package/dist/generators/ts/StringType.js

@@ -37,6 +37,15 @@ export class StringType extends PrimitiveType {
         }
         return this.typeof;
     }
+    fromRdfExpressionChain({ variables, }) {
+        const inChain = this.primitiveIn.length > 0
+            ? `.chain(string_ => { switch (string_) { ${this.primitiveIn.map((value) => `case "${value}":`).join(" ")} return purify.Either.of<Error, ${this.name}>(string_); default: return purify.Left<Error, ${this.name}>(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "value.toTerm()", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })`
+            : "";
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            valueTo: `chain(values => values.chainMap(value => value.toString()${inChain}))`,
+        };
+    }
     hashStatements({ variables, }) {
         return [`${variables.hasher}.update(${variables.value});`];
     }
@@ -50,13 +59,11 @@ export class StringType extends PrimitiveType {
                 return `${variables.zod}.enum(${JSON.stringify(this.primitiveIn)})`;
         }
     }
-    propertyFromRdfResourceValueExpression({ variables, }) {
-        let expression = `${variables.resourceValue}.toString()`;
-        if (this.primitiveIn.length > 0) {
-            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;
+    sparqlWherePatterns(parameters) {
+        return super.sparqlWherePatterns({
+            ...parameters,
+            ignoreLiteralLanguage: false,
+        });
     }
     toRdfExpression({ variables, }) {
         return this.primitiveDefaultValue

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

@@ -30,7 +30,24 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     get jsonName(): Type.JsonName;
     get name(): string;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    fromRdfExpression(parameters: Parameters<Type["fromRdfExpression"]>[0]): string;
+    /**
+     * The fromRdfExpression for a term type can be decomposed into multiple sub-expressions with different purposes:
+     *
+     * defaultValues: add the default value to the values sequence if the latter doesn't contain values already
+     * hasValues: test whether the values sequence has sh:hasValue values
+     * languageIn: filter the values sequence to literals with the right sh:languageIn (or runtime languageIn)
+     * valueTo: convert values in the values sequence to the appropriate term type/sub-type (literal, string, etc.)
+     *
+     * Considering the sub-expressions as a record instead of an array allows them to be selectively overridden by subclasses.
+     */
+    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): {
+        defaultValue?: string;
+        hasValues?: string;
+        languageIn?: string;
+        preferredLanguages?: string;
+        valueTo: string;
+    };
     graphqlResolveExpression(_parameters: Parameters<Type["graphqlResolveExpression"]>[0]): string;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonUiSchemaElement(): Maybe<string>;
@@ -40,23 +57,5 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
     useImports(): readonly Import[];
-    /**
-     * Filter the rdfjsResource.Resource.Values to those that are relevant to the type.
-     *
-     * This is done before
-     */
-    protected propertyFilterRdfResourceValuesExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
-    /**
-     * Convert an rdfjsResource.Resource.Value to a value of this type.
-     * @param variables
-     * @protected
-     */
-    protected propertyFromRdfResourceValueExpression({ variables, }: {
-        variables: {
-            predicate: string;
-            resource: string;
-            resourceValue: string;
-        };
-    }): string;
 }
 //# sourceMappingURL=TermType.d.ts.map