@shaclmate/compiler 2.0.24 → 3.0.0

package/dist/generators/ts/PrimitiveType.js

@@ -28,19 +28,6 @@ export class PrimitiveType extends LiteralType {
     fromJsonExpression({ variables, }) {
         return variables.value;
     }
-    fromRdfExpressionChain({ variables, }) {
-        return {
-            ...super.fromRdfExpressionChain({ variables }),
-            languageIn: undefined,
-            valueTo: `chain(values => values.chainMap(value => ${this.fromRdfResourceValueExpression({
-                variables: {
-                    predicate: variables.predicate,
-                    resource: variables.resource,
-                    resourceValue: "value",
-                },
-            })}))`,
-        };
-    }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
@@ -55,7 +42,10 @@ export class PrimitiveType extends LiteralType {
         return snippetDeclarations;
     }
     sparqlWherePatterns(parameters) {
-        return super.sparqlWherePatterns({ ...parameters, ignoreLanguageIn: true });
+        return super.sparqlWherePatterns({
+            ...parameters,
+            ignoreLiteralLanguage: parameters.ignoreLiteralLanguage ?? true,
+        });
     }
     toJsonExpression({ variables, }) {
         return variables.value;

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

@@ -1,5 +1,6 @@
 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";
@@ -8,7 +9,7 @@ export declare namespace SnippetDeclarations {
     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.
@@ -301,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 fromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<string>["fromRdfResourceValueExpression"]>[0]): 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"]>;
+    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,13 +37,14 @@ export class StringType extends PrimitiveType {
         }
         return this.typeof;
     }
-    fromRdfResourceValueExpression({ 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;
+    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});`];
@@ -58,6 +59,12 @@ export class StringType extends PrimitiveType {
                 return `${variables.zod}.enum(${JSON.stringify(this.primitiveIn)})`;
         }
     }
+    sparqlWherePatterns(parameters) {
+        return super.sparqlWherePatterns({
+            ...parameters,
+            ignoreLiteralLanguage: false,
+        });
+    }
     toRdfExpression({ variables, }) {
         return this.primitiveDefaultValue
             .map((defaultValue) => `${variables.value} !== "${defaultValue}" ? ${variables.value} : undefined`)

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

@@ -31,11 +31,22 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     get name(): string;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[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;
-        valueTo?: string;
+        preferredLanguages?: string;
+        valueTo: string;
     };
     graphqlResolveExpression(_parameters: Parameters<Type["graphqlResolveExpression"]>[0]): string;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];

package/dist/generators/ts/TermType.js

@@ -133,11 +133,22 @@ export class TermType extends Type {
             chain.defaultValue,
             chain.hasValues,
             chain.languageIn,
+            chain.preferredLanguages,
             chain.valueTo,
         ]
             .filter((_) => typeof _ !== "undefined")
             .join(".");
     }
+    /**
+     * 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.
+     */
     fromRdfExpressionChain({ variables, }) {
         let valueToExpression = "purify.Either.of<Error, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>(value.toTerm())";
         if (this.nodeKinds.size < 3) {

package/dist/generators/ts/TsGenerator.js

@@ -1,5 +1,7 @@
+import { invariant } from "ts-invariant";
 import { Project, } from "ts-morph";
 import * as ast from "../../ast/index.js";
+import { Import } from "./Import.js";
 import { ObjectType } from "./ObjectType.js";
 import { ObjectUnionType } from "./ObjectUnionType.js";
 import { TypeFactory } from "./TypeFactory.js";
@@ -27,36 +29,43 @@ export class TsGenerator {
         return project.getFileSystem().readFileSync(sourceFile.getFilePath());
     }
     addStatements({ objectTypes, objectUnionTypes, sourceFile, }) {
-        // sourceFile.addStatements(this.configuration.dataFactoryImport);
-        sourceFile.addStatements([
-            'import { DataFactory as dataFactory, StoreFactory as _DatasetFactory } from "n3";',
-            "const datasetFactory: rdfjs.DatasetCoreFactory = new _DatasetFactory();",
-        ]);
         const declaredTypes = [
             ...objectTypes,
             ...objectUnionTypes,
         ];
         // Gather imports
-        const imports = [];
+        const imports = [Import.DATA_FACTORY, Import.DATASET_FACTORY];
         for (const declaredType of declaredTypes) {
             imports.push(...declaredType.declarationImports);
         }
         // Deduplicate and add imports
-        const addedStringImports = new Set();
-        const addedStructureImports = [];
+        const stringImports = new Set();
+        const structureImports = [];
         for (const import_ of imports) {
             if (typeof import_ === "string") {
-                if (!addedStringImports.has(import_)) {
-                    sourceFile.addStatements([import_]);
-                }
-                addedStringImports.add(import_);
+                stringImports.add(import_);
+                continue;
+            }
+            const importWithSameModuleSpecifier = structureImports.find((structureImport) => structureImport.moduleSpecifier === import_.moduleSpecifier);
+            if (!importWithSameModuleSpecifier) {
+                structureImports.push(import_);
                 continue;
             }
-            if (!addedStructureImports.find((addedStructureImport) => addedStructureImport.moduleSpecifier === import_.moduleSpecifier)) {
-                sourceFile.addStatements([import_]);
-                addedStructureImports.push(import_);
+            // Merge named imports
+            invariant(!import_.namespaceImport);
+            invariant(Array.isArray(import_.namedImports) &&
+                import_.namedImports.every((value) => typeof value === "string"));
+            invariant(!importWithSameModuleSpecifier.namespaceImport);
+            invariant(Array.isArray(importWithSameModuleSpecifier.namedImports) &&
+                importWithSameModuleSpecifier.namedImports.every((value) => typeof value === "string"));
+            for (const newNamedImport of import_.namedImports) {
+                if (!importWithSameModuleSpecifier.namedImports.includes(newNamedImport)) {
+                    importWithSameModuleSpecifier.namedImports.push(newNamedImport);
+                }
             }
         }
+        sourceFile.addStatements([...stringImports]);
+        sourceFile.addStatements(structureImports);
         // Deduplicate and add snippet declarations
         const addedSnippetDeclarations = new Set();
         for (const declaredType of declaredTypes) {

package/dist/generators/ts/Type.d.ts

@@ -50,22 +50,21 @@ export declare abstract class Type {
         };
     }): string;
     /**
-     * An expression that converts a purify.Either<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>> to
-     * (1) a purify.Either<Error, rdfjsResource.Resource.Values<this type>> if this is an item type (identifier, object, et al.) or
-     * (2) a purify.Either<Error, cardinality type> if this is a cardinality type
+     * An expression that converts a purify.Either<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>> to a
+     * purify.Either<Error, rdfjsResource.Resource.Values<this type>>.
      *
      * Some types need to filter on the set of all objects/values of a (subject, predicate). For example, all sh:hasValue values must be present in the set for any values
      * to be considered valid. Similar
      *
-     * Values may also need to be sorted. For example, applying sh:languageIn should sort the values in the order of the specified languages so that the first value
-     * (if it exists) is always of the first specified language -- a common situation when sh:maxCount is 1.
+     * Values may also need to be sorted. For example, specifying preferredLanguages should sort the values in the order of the specified languages so that the first value
+     * (if it exists) is always of the first preferred language.
      */
     abstract fromRdfExpression(parameters: {
         variables: {
             context: string;
             ignoreRdfType?: boolean;
-            languageIn: string;
             objectSet: string;
+            preferredLanguages: string;
             predicate: string;
             resource: string;
             resourceValues: string;
@@ -160,9 +159,9 @@ export declare abstract class Type {
         allowIgnoreRdfType: boolean;
         context: "object";
         variables: {
-            languageIn: string;
             object: string;
             predicate: string;
+            preferredLanguages: string;
             subject: string;
             variablePrefix: string;
         };
@@ -170,7 +169,7 @@ export declare abstract class Type {
         allowIgnoreRdfType: boolean;
         context: "subject";
         variables: {
-            languageIn: string;
+            preferredLanguages: string;
             subject: string;
             variablePrefix: string;
         };

package/dist/generators/ts/Type.js

@@ -66,7 +66,7 @@ export class Type {
                     allowIgnoreRdfType,
                     context: "subject",
                     variables: {
-                        languageIn: variables.languageIn,
+                        preferredLanguages: variables.preferredLanguages,
                         subject: variables.object,
                         variablePrefix: variables.object.substring(objectPrefix.length, variables.object.length - objectSuffix.length),
                     },

package/dist/generators/ts/TypeFactory.js

@@ -332,13 +332,14 @@ export class TypeFactory {
                     if (datatype.equals(xsd.anyURI) || datatype.equals(xsd.string)) {
                         if (astType.defaultValue.isNothing() &&
                             astType.hasValues.length === 0 &&
-                            astType.in_.length === 0) {
+                            astType.in_.length === 0 &&
+                            astType.languageIn.length === 0) {
                             return this.cachedStringType;
                         }
                         return new StringType({
                             defaultValue: astType.defaultValue,
                             hasValues: astType.hasValues,
-                            languageIn: [],
+                            languageIn: astType.languageIn,
                             in_: astType.in_,
                             primitiveDefaultValue: astType.defaultValue.map((value) => value.value),
                             primitiveIn: astType.in_.map((value) => value.value),

package/dist/generators/ts/_ObjectType/Property.d.ts

@@ -96,8 +96,8 @@ export declare abstract class Property<TypeT extends Pick<Type, "mutable" | "nam
     abstract fromRdfStatements(parameters: {
         variables: {
             context: string;
-            languageIn: string;
             objectSet: string;
+            preferredLanguages: string;
             resource: string;
         };
     }): readonly string[];
@@ -147,7 +147,7 @@ export declare abstract class Property<TypeT extends Pick<Type, "mutable" | "nam
      */
     abstract sparqlWherePatterns(parameters: {
         variables: {
-            languageIn: string;
+            preferredLanguages: string;
             subject: string;
             variablePrefix: string;
         };

package/dist/generators/ts/_ObjectType/ShaclProperty.js

@@ -170,9 +170,9 @@ export class ShaclProperty extends Property {
             allowIgnoreRdfType: true,
             context: "object",
             variables: {
-                languageIn: variables.languageIn,
                 object: `dataFactory.variable!(${objectString})`,
                 predicate: this.predicate,
+                preferredLanguages: variables.preferredLanguages,
                 subject: variables.subject,
                 variablePrefix: objectString,
             },

package/dist/generators/ts/_ObjectType/jsonFunctionDeclarations.js

@@ -100,7 +100,7 @@ function jsonSchemaFunctionDeclaration() {
         kind: StructureKind.Function,
         name: `${syntheticNamePrefix}jsonSchema`,
         statements: [
-            `return zodToJsonSchema(${syntheticNamePrefix}jsonZodSchema());`,
+            `return zod.toJSONSchema(${syntheticNamePrefix}jsonZodSchema());`,
         ],
     };
 }

package/dist/generators/ts/_ObjectType/rdfFunctionDeclarations.js

@@ -7,7 +7,7 @@ import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { toRdfFunctionOrMethodDeclaration } from "./toRdfFunctionOrMethodDeclaration.js";
 function fromRdfFunctionDeclaration() {
     const statements = [];
-    statements.push("let { ignoreRdfType = false, languageIn, objectSet, ...context } = (options ?? {});", `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet({ dataset: resource.dataset }); }`);
+    statements.push("let { ignoreRdfType = false, objectSet, preferredLanguages, ...context } = (options ?? {});", `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet({ dataset: resource.dataset }); }`);
     let returnExpression;
     if (this.childObjectTypes.length > 0) {
         // Can't ignore the RDF type.
@@ -20,7 +20,7 @@ function fromRdfFunctionDeclaration() {
         }, "");
     }
     if (!this.abstract) {
-        let propertiesFromRdfExpression = `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ ...context, ignoreRdfType, languageIn, objectSet, resource })`;
+        let propertiesFromRdfExpression = `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ ...context, ignoreRdfType, objectSet, preferredLanguages, resource })`;
         if (this.declarationType === "class") {
             propertiesFromRdfExpression = `${propertiesFromRdfExpression}.map(properties => new ${this.name}(properties))`;
         }
@@ -51,7 +51,7 @@ function fromRdfFunctionDeclaration() {
             {
                 hasQuestionToken: true,
                 name: "options",
-                type: `{ [_index: string]: any; ignoreRdfType?: boolean; languageIn?: readonly string[]; objectSet?: ${syntheticNamePrefix}ObjectSet; }`,
+                type: `{ [_index: string]: any; ignoreRdfType?: boolean; objectSet?: ${syntheticNamePrefix}ObjectSet; preferredLanguages?: readonly string[]; }`,
             },
         ],
         returnType: `purify.Either<Error, ${this.name}>`,
@@ -64,20 +64,39 @@ function propertiesFromRdfFunctionDeclaration() {
     const returnType = [];
     const statements = [];
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        statements.push(`const ${syntheticNamePrefix}super${parentObjectTypeI}Either = ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ ...${variables.context}, ignoreRdfType: true, languageIn: ${variables.languageIn}, objectSet: ${variables.objectSet}, resource: ${variables.resource} });`, `if (${syntheticNamePrefix}super${parentObjectTypeI}Either.isLeft()) { return ${syntheticNamePrefix}super${parentObjectTypeI}Either; }`, `const ${syntheticNamePrefix}super${parentObjectTypeI} = ${syntheticNamePrefix}super${parentObjectTypeI}Either.unsafeCoerce()`);
+        statements.push(`const ${syntheticNamePrefix}super${parentObjectTypeI}Either = ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ ...${variables.context}, ignoreRdfType: true, objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages}, resource: ${variables.resource} });`, `if (${syntheticNamePrefix}super${parentObjectTypeI}Either.isLeft()) { return ${syntheticNamePrefix}super${parentObjectTypeI}Either; }`, `const ${syntheticNamePrefix}super${parentObjectTypeI} = ${syntheticNamePrefix}super${parentObjectTypeI}Either.unsafeCoerce()`);
         initializers.push(`...${syntheticNamePrefix}super${parentObjectTypeI}`);
         returnType.push(`${syntheticNamePrefix}UnwrapR<ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf>>`);
     });
-    this.fromRdfType.ifJust((rdfType) => {
+    this.fromRdfType.ifJust((fromRdfType) => {
+        const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();
         const predicate = rdfjsTermExpression(rdf.type);
         statements.push(`\
-if (!${variables.ignoreRdfType} && !${variables.resource}.isInstanceOf(${syntheticNamePrefix}fromRdfType)) {
-  return ${variables.resource}.value(${predicate}).chain(actualRdfType => actualRdfType.toIri()).chain((actualRdfType) => purify.Left(new Error(\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type (actual: \${actualRdfType.value}, expected: ${rdfType.value})\`)));
+if (!${variables.ignoreRdfType}) {
+  const ${syntheticNamePrefix}rdfTypeCheck: purify.Either<Error, true> = ${variables.resource}.value(${predicate})
+    .chain(actualRdfType => actualRdfType.toIri())
+    .chain((actualRdfType) => {
+      // Check the expected type and its known subtypes
+      switch (actualRdfType.value) {
+        ${[`case "${fromRdfType.value}":`].concat(this.descendantFromRdfTypes.map((descendantFromRdfType) => `case "${descendantFromRdfType.value}":`)).join("\n")}
+          return purify.Either.of(true);
+      }
+
+      // Check arbitrary rdfs:subClassOf's of the expected type
+      if (${variables.resource}.isInstanceOf(${fromRdfTypeVariable})) {
+        return purify.Either.of(true);
+      }
+
+      return purify.Left(new Error(\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type (actual: \${actualRdfType.value}, expected: ${fromRdfType.value})\`));
+    });
+  if (${syntheticNamePrefix}rdfTypeCheck.isLeft()) {
+    return ${syntheticNamePrefix}rdfTypeCheck;
+  }
 }`);
     });
     const propertyFromRdfVariables = {
         context: variables.context,
-        languageIn: variables.languageIn,
+        preferredLanguages: variables.preferredLanguages,
         objectSet: variables.objectSet,
         resource: variables.resource,
     };
@@ -101,8 +120,8 @@ if (!${variables.ignoreRdfType} && !${variables.resource}.isInstanceOf(${synthet
         name: `${syntheticNamePrefix}propertiesFromRdf`,
         parameters: [
             {
-                name: `{ ignoreRdfType: ${variables.ignoreRdfType}, languageIn: ${variables.languageIn}, objectSet: ${variables.objectSet}, resource: ${variables.resource},\n// @ts-ignore\n...${variables.context} }`,
-                type: `{ [_index: string]: any; ignoreRdfType: boolean; languageIn?: readonly string[]; objectSet: ${syntheticNamePrefix}ObjectSet; resource: rdfjsResource.Resource; }`,
+                name: `{ ignoreRdfType: ${variables.ignoreRdfType}, objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages}, resource: ${variables.resource},\n// @ts-ignore\n...${variables.context} }`,
+                type: `{ [_index: string]: any; ignoreRdfType: boolean; objectSet: ${syntheticNamePrefix}ObjectSet; preferredLanguages?: readonly string[]; resource: rdfjsResource.Resource; }`,
             },
         ],
         returnType: `purify.Either<Error, ${returnType.join(" & ")}>`,
@@ -137,8 +156,8 @@ function toRdfFunctionDeclaration() {
 const variables = {
     context: `${syntheticNamePrefix}context`,
     ignoreRdfType: `${syntheticNamePrefix}ignoreRdfType`,
-    languageIn: `${syntheticNamePrefix}languageIn`,
     objectSet: `${syntheticNamePrefix}objectSet`,
+    preferredLanguages: `${syntheticNamePrefix}preferredLanguages`,
     resource: `${syntheticNamePrefix}resource`,
 };
 //# sourceMappingURL=rdfFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectType/sparqlConstructQueryFunctionDeclaration.js

@@ -9,13 +9,13 @@ export function sparqlConstructQueryFunctionDeclaration() {
             {
                 hasQuestionToken: true,
                 name: "parameters",
-                type: '{ ignoreRdfType?: boolean; languageIn?: readonly string[]; prefixes?: { [prefix: string]: string }; subject?: sparqljs.Triple["subject"]; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type">',
+                type: '{ ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly string[]; subject?: sparqljs.Triple["subject"]; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type">',
             },
         ],
         returnType: "sparqljs.ConstructQuery",
         statements: [
-            "const { ignoreRdfType, languageIn, subject, ...queryParameters } = parameters ?? {}",
-            `return { ...queryParameters, prefixes: parameters?.prefixes ?? {}, queryType: "CONSTRUCT", template: (queryParameters.template ?? []).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTemplateTriples({ ignoreRdfType, subject })), type: "query", where: (queryParameters.where ?? []).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ ignoreRdfType, languageIn, subject })) };`,
+            "const { ignoreRdfType, preferredLanguages, subject, ...queryParameters } = parameters ?? {}",
+            `return { ...queryParameters, prefixes: parameters?.prefixes ?? {}, queryType: "CONSTRUCT", template: (queryParameters.template ?? []).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTemplateTriples({ ignoreRdfType, subject })), type: "query", where: (queryParameters.where ?? []).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ ignoreRdfType, preferredLanguages, subject })) };`,
         ],
     };
 }

package/dist/generators/ts/_ObjectType/sparqlConstructQueryStringFunctionDeclaration.js

@@ -9,7 +9,7 @@ export function sparqlConstructQueryStringFunctionDeclaration() {
             {
                 hasQuestionToken: true,
                 name: "parameters",
-                type: '{ ignoreRdfType?: boolean; languageIn?: readonly string[]; subject?: sparqljs.Triple["subject"]; variablePrefix?: string; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type"> & sparqljs.GeneratorOptions',
+                type: '{ ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; subject?: sparqljs.Triple["subject"]; variablePrefix?: string; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type"> & sparqljs.GeneratorOptions',
             },
         ],
         returnType: "string",

package/dist/generators/ts/_ObjectType/sparqlFunctionDeclarations.js

@@ -13,7 +13,7 @@ export function sparqlFunctionDeclarations() {
         return [];
     }
     const variables = {
-        languageIn: "parameters?.languageIn",
+        preferredLanguages: "parameters?.preferredLanguages",
         subject: "subject",
         variablePrefix: "variablePrefix",
     };
@@ -45,6 +45,9 @@ for (const pattern of ${parentObjectType.staticModuleName}.${syntheticNamePrefix
         nop = false;
     }
     if (this.fromRdfType.isJust()) {
+        const fromRdfTypeVariables = this.fromRdfTypeVariable
+            .toList()
+            .concat(this.descendantFromRdfTypeVariables);
         sparqlConstructTemplateTriplesStatements.push(`\
 if (!parameters?.ignoreRdfType) {
   triples.push(
@@ -52,25 +55,38 @@ if (!parameters?.ignoreRdfType) {
     { subject: ${rdfTypeVariable}, predicate: ${rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }
   );
 }`);
-        sparqlWherePatternsStatements.push(`\
+        sparqlWherePatternsStatements.push(`const rdfTypeVariable = ${rdfTypeVariable};`, `\
 if (!parameters?.ignoreRdfType) {
-  requiredPatterns.push(${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType: ${syntheticNamePrefix}fromRdfType, subject }));
-  requiredPatterns.push({
-    triples: [
-      {
-        subject,
-        predicate: ${rdfjsTermExpression(rdf.type)},
-        object: ${rdfTypeVariable}
-      }
-    ],
-    type: "bgp" as const
-  });
+  requiredPatterns.push(
+    ${fromRdfTypeVariables.length > 1
+            ? `\
+    {
+      type: "values" as const,
+      values: [${fromRdfTypeVariables.join(", ")}].map((identifier) => {
+        const valuePatternRow: sparqljs.ValuePatternRow = {};
+        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as rdfjs.NamedNode;
+        return valuePatternRow;
+      }),
+    },
+    ${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType: dataFactory.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject }),`
+            : `${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType: ${fromRdfTypeVariables[0]}, subject }),`}
+    {
+      triples: [
+        {
+          subject,
+          predicate: ${rdfjsTermExpression(rdf.type)},
+          object: rdfTypeVariable
+        }
+      ],
+      type: "bgp" as const
+    }
+  );
   optionalPatterns.push({
     patterns: [
       {
         triples: [
           {
-            subject: ${rdfTypeVariable},
+            subject: rdfTypeVariable,
             predicate: {
               items: [${rdfjsTermExpression(rdfs.subClassOf)}],
               pathType: "+" as const,
@@ -139,7 +155,7 @@ for (const pattern of propertyPatterns) {
                 {
                     hasQuestionToken: true,
                     name: `${nop ? "_" : ""}parameters`,
-                    type: '{ ignoreRdfType?: boolean; languageIn?: readonly string[]; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
+                    type: '{ ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                 },
             ],
             returnType: "readonly sparqljs.Pattern[]",

package/dist/generators/ts/forwardingObjectSetClassDeclaration.d.ts

@@ -0,0 +1,8 @@
+import { type ClassDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+export declare function forwardingObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }: {
+    objectTypes: readonly ObjectType[];
+    objectUnionTypes: readonly ObjectUnionType[];
+}): ClassDeclarationStructure;
+//# sourceMappingURL=forwardingObjectSetClassDeclaration.d.ts.map