@shaclmate/compiler 2.0.23 → 3.0.0

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.js

@@ -0,0 +1,14 @@
+/**
+ * Try to convert a shape to a type using some heuristics.
+ *
+ * We don't try to handle exotic cases allowed by the SHACL spec, such as combinations of sh:in and sh:node. Instead we assume
+ * a shape has one type.
+ */
+export function transformShapeToAstType(shape, shapeStack) {
+    // Try to transform the property shape into an AST type without cardinality constraints
+    return this.transformShapeToAstCompositeType(shape, shapeStack)
+        .altLazy(() => this.transformShapeToAstIdentifierType(shape, shapeStack))
+        .altLazy(() => this.transformShapeToAstLiteralType(shape, shapeStack))
+        .altLazy(() => this.transformShapeToAstTermType(shape, shapeStack));
+}
+//# sourceMappingURL=transformShapeToAstType.js.map

package/dist/ast/OptionType.d.ts

@@ -1,8 +1,6 @@
 import type { Type } from "./Type.js";
 /**
  * A type with zero or one values of an item type.
- *
- * This is a property with sh:minCount 0 and sh:maxCount 1.
  */
 export interface OptionType<ItemTypeT extends Type = Type> {
     readonly itemType: ItemTypeT;

package/dist/ast/SetType.d.ts

@@ -2,15 +2,10 @@ import type { Maybe } from "purify-ts";
 import type { Type } from "./Type.js";
 /**
  * An unordered set of items of a specific type.
- *
- * This is a property with sh:maxCount != 1.
  */
 export interface SetType<ItemTypeT extends Type = Type> {
-    /**
-     * Set item type.
-     */
-    readonly itemType: ItemTypeT;
     readonly kind: "SetType";
+    readonly itemType: ItemTypeT;
     /**
      * Minimum number of items in the set.
      */

package/dist/ast/index.d.ts

@@ -7,6 +7,7 @@ export * from "./Name.js";
 export * from "./ObjectIntersectionType.js";
 export * from "./ObjectType.js";
 export * from "./ObjectUnionType.js";
+export * from "./SetType.js";
 export * from "./UnionType.js";
 export * from "./TermType.js";
 export * from "./Type.js";

package/dist/ast/index.js

@@ -7,6 +7,7 @@ export * from "./Name.js";
 export * from "./ObjectIntersectionType.js";
 export * from "./ObjectType.js";
 export * from "./ObjectUnionType.js";
+export * from "./SetType.js";
 export * from "./UnionType.js";
 export * from "./TermType.js";
 export * from "./Type.js";

package/dist/generators/json/AstJsonGenerator.js

@@ -119,11 +119,17 @@ export class AstJsonGenerator {
                 kind: objectType.kind,
                 name: nameToJson(objectType.name),
                 properties: objectType.properties.map((property) => ({
-                    name: nameToJson(property.name),
+                    comment: property.comment.extract(),
+                    description: property.description.extract(),
+                    label: property.label.extract(),
                     mutable: property.mutable.extract(),
+                    name: nameToJson(property.name),
+                    order: property.order,
                     path: property.path.iri.value,
                     recursive: property.recursive ? true : undefined,
+                    stubType: property.stubType.map(typeToJson).extract(),
                     type: typeToJson(property.type),
+                    visibility: property.visibility,
                 })),
             })),
         }, undefined, 2);

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

@@ -1,4 +1,5 @@
 import { PrimitiveType } from "./PrimitiveType.js";
+import type { TermType } from "./TermType.js";
 import { Type } from "./Type.js";
 export declare class BooleanType extends PrimitiveType<boolean> {
     readonly kind = "BooleanType";
@@ -7,7 +8,7 @@ export declare class BooleanType extends PrimitiveType<boolean> {
     get graphqlName(): Type.GraphqlName;
     get name(): string;
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    propertyFromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<boolean>["propertyFromRdfResourceValueExpression"]>[0]): string;
+    protected fromRdfExpressionChain({ variables, }: Parameters<TermType["fromRdfExpressionChain"]>[0]): ReturnType<TermType["fromRdfExpressionChain"]>;
     toRdfExpression({ variables, }: Parameters<PrimitiveType<string>["toRdfExpression"]>[0]): string;
 }
 //# sourceMappingURL=BooleanType.d.ts.map

package/dist/generators/ts/BooleanType.js

@@ -43,13 +43,18 @@ export class BooleanType extends PrimitiveType {
         }
         return `${variables.zod}.boolean()`;
     }
-    propertyFromRdfResourceValueExpression({ variables, }) {
-        let expression = `${variables.resourceValue}.toBoolean()`;
+    fromRdfExpressionChain({ variables, }) {
+        let fromRdfResourceValueExpression = "value.toBoolean()";
         if (this.primitiveIn.length === 1) {
             const eitherTypeParameters = `<Error, ${this.name}>`;
-            expression = `${expression}.chain(value => value === ${this.primitiveIn[0]} ? purify.Either.of${eitherTypeParameters}(value) : purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})))`;
+            fromRdfResourceValueExpression = `${fromRdfResourceValueExpression}.chain(value => value === ${this.primitiveIn[0]} ? purify.Either.of${eitherTypeParameters}(value) : 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;
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            languageIn: undefined,
+            preferredLanguages: undefined,
+            valueTo: `chain(values => values.chainMap(value => ${fromRdfResourceValueExpression}))`,
+        };
     }
     toRdfExpression({ variables, }) {
         return this.primitiveDefaultValue

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

@@ -1,5 +1,6 @@
 import type { NamedNode } from "@rdfjs/types";
 import { PrimitiveType } from "./PrimitiveType.js";
+import type { TermType } from "./TermType.js";
 import { Type } from "./Type.js";
 export declare class DateTimeType extends PrimitiveType<Date> {
     protected readonly xsdDatatype: NamedNode;
@@ -15,7 +16,7 @@ export declare class DateTimeType extends PrimitiveType<Date> {
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    propertyFromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<number>["propertyFromRdfResourceValueExpression"]>[0]): string;
+    protected fromRdfExpressionChain({ variables, }: Parameters<TermType["fromRdfExpressionChain"]>[0]): ReturnType<TermType["fromRdfExpressionChain"]>;
     snippetDeclarations({ features, }: Parameters<PrimitiveType<Date>["snippetDeclarations"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<PrimitiveType<Date>["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<PrimitiveType<Date>["toRdfExpression"]>[0]): string;

package/dist/generators/ts/DateTimeType.js

@@ -54,13 +54,18 @@ export class DateTimeType extends PrimitiveType {
     jsonZodSchema({ variables, }) {
         return `${variables.zod}.string().${this.zodDatatype}()`;
     }
-    propertyFromRdfResourceValueExpression({ variables, }) {
-        let expression = `${variables.resourceValue}.toDate()`;
+    fromRdfExpressionChain({ variables, }) {
+        let fromRdfResourceValueExpression = "value.toDate()";
         if (this.primitiveIn.length > 0) {
             const eitherTypeParameters = `<Error, ${this.name}>`;
-            expression = `${expression}.chain(value => { ${this.primitiveIn.map((value) => `if (value.getTime() === ${value.getTime()}) { return purify.Either.of${eitherTypeParameters}(value); }`).join(" ")} return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: `rdfLiteral.toRdf(value, ${objectInitializer({ dataFactory: "dataFactory", datatype: rdfjsTermExpression(this.xsdDatatype) })})`, expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); })`;
+            fromRdfResourceValueExpression = `${fromRdfResourceValueExpression}.chain(value => { ${this.primitiveIn.map((value) => `if (value.getTime() === ${value.getTime()}) { return purify.Either.of${eitherTypeParameters}(value); }`).join(" ")} return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: `rdfLiteral.toRdf(value, ${objectInitializer({ dataFactory: "dataFactory", datatype: rdfjsTermExpression(this.xsdDatatype) })})`, expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); })`;
         }
-        return expression;
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            languageIn: undefined,
+            preferredLanguages: undefined,
+            valueTo: `chain(values => values.chainMap(value => ${fromRdfResourceValueExpression}))`,
+        };
     }
     snippetDeclarations({ features, }) {
         const snippetDeclarations = [];

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

@@ -12,9 +12,9 @@ export declare class IdentifierType extends TermType<NamedNode, BlankNode | Name
     get name(): string;
     get toStringFunctionDeclaration(): VariableStatementStructure;
     fromJsonExpression({ variables, }: Parameters<TermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): string;
+    protected fromRdfExpressionChain({ variables, }: Parameters<TermType["fromRdfExpressionChain"]>[0]): ReturnType<TermType["fromRdfExpressionChain"]>;
     graphqlResolveExpression({ variables: { value }, }: Parameters<Type["graphqlResolveExpression"]>[0]): string;
     jsonZodSchema({ variables, }: Parameters<TermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>[0]): ReturnType<TermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>;
     toJsonExpression({ variables, }: Parameters<TermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): string;
-    protected propertyFromRdfResourceValueExpression({ variables, }: Parameters<TermType<NamedNode, BlankNode | NamedNode>["propertyFromRdfResourceValueExpression"]>[0]): string;
 }
 //# sourceMappingURL=IdentifierType.d.ts.map

package/dist/generators/ts/IdentifierType.js

@@ -121,6 +121,26 @@ export class IdentifierType extends TermType {
                 return valueToNamedNode;
         }
     }
+    fromRdfExpressionChain({ variables, }) {
+        let valueToExpression;
+        if (this.nodeKinds.size === 2) {
+            valueToExpression = "value.toIdentifier()";
+        }
+        else if (this.isNamedNodeKind) {
+            valueToExpression = "value.toIri()";
+            if (this.in_.length > 0) {
+                const eitherTypeParameters = `<Error, ${this.name}>`;
+                valueToExpression = `${valueToExpression}.chain(iri => { switch (iri.value) { ${this.in_.map((iri) => `case "${iri.value}": return purify.Either.of${eitherTypeParameters}(iri as rdfjs.NamedNode<"${iri.value}">);`).join(" ")} default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError({ actualValue: iri, expectedValueType: ${JSON.stringify(this.name)}, focusResource: ${variables.resource}, predicate: ${variables.predicate} })); } } )`;
+            }
+        }
+        else {
+            throw new Error("not implemented");
+        }
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            valueTo: `chain(values => values.chainMap(value => ${valueToExpression}))`,
+        };
+    }
     graphqlResolveExpression({ variables: { value }, }) {
         return `rdfjsResource.Resource.Identifier.toString(${value})`;
     }
@@ -149,20 +169,6 @@ export class IdentifierType extends TermType {
                 return valueToNamedNode;
         }
     }
-    propertyFromRdfResourceValueExpression({ variables, }) {
-        if (this.nodeKinds.size === 2) {
-            return `${variables.resourceValue}.toIdentifier()`;
-        }
-        if (this.isNamedNodeKind) {
-            let expression = `${variables.resourceValue}.toIri()`;
-            if (this.in_.length > 0) {
-                const eitherTypeParameters = `<Error, ${this.name}>`;
-                expression = `${expression}.chain(iri => { switch (iri.value) { ${this.in_.map((iri) => `case "${iri.value}": return purify.Either.of${eitherTypeParameters}(iri as rdfjs.NamedNode<"${iri.value}">);`).join(" ")} default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError({ actualValue: iri, expectedValueType: ${JSON.stringify(this.name)}, focusResource: ${variables.resource}, predicate: ${variables.predicate} })); } } )`;
-            }
-            return expression;
-        }
-        throw new Error(`not implemented: ${this.name}`);
-    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/Import.d.ts

@@ -4,6 +4,8 @@ export type Import = ImportDeclarationStructure | string;
  * Singleton values for common imports.
  */
 export declare namespace Import {
+    const DATA_FACTORY: Import;
+    const DATASET_FACTORY: Import;
     const GRAPHQL: Import;
     const GRAPHQL_SCALARS: Import;
     const PURIFY: Import;
@@ -14,6 +16,5 @@ export declare namespace Import {
     const SPARQLJS: Import;
     const UUID: Import;
     const ZOD: Import;
-    const ZOD_TO_JSON_SCHEMA: Import;
 }
 //# sourceMappingURL=Import.d.ts.map

package/dist/generators/ts/Import.js

@@ -4,61 +4,66 @@ import { StructureKind } from "ts-morph";
  */
 export var Import;
 (function (Import) {
+    Import.DATA_FACTORY = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["dataFactory"],
+    };
+    Import.DATASET_FACTORY = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["datasetFactory"],
+    };
     Import.GRAPHQL = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "graphql",
-        namespaceImport: "graphql",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["graphql"],
     };
     Import.GRAPHQL_SCALARS = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "graphql-scalars",
-        namespaceImport: "graphqlScalars",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["graphqlScalars"],
     };
     Import.PURIFY = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "purify-ts",
-        namespaceImport: "purify",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["purify"],
     };
     Import.RDF_LITERAL = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "rdf-literal",
-        namespaceImport: "rdfLiteral",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["rdfLiteral"],
     };
     Import.RDFJS_RESOURCE = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "rdfjs-resource",
-        namespaceImport: "rdfjsResource",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["rdfjsResource"],
     };
     Import.RDFJS_TYPES = {
         isTypeOnly: true,
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@rdfjs/types",
-        namespaceImport: "rdfjs",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["rdfjs"],
     };
     Import.SHA256 = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "js-sha256",
+        moduleSpecifier: "@shaclmate/runtime",
         namedImports: ["sha256"],
     };
     Import.SPARQLJS = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "sparqljs",
-        namespaceImport: "sparqljs",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["sparqljs"],
     };
     Import.UUID = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "uuid",
-        namespaceImport: "uuid",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["uuid"],
     };
     Import.ZOD = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "zod",
-        namedImports: [{ alias: "zod", name: "z" }],
-    };
-    Import.ZOD_TO_JSON_SCHEMA = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "zod-to-json-schema",
-        namedImports: [{ name: "zodToJsonSchema" }],
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["zod"],
     };
 })(Import || (Import = {}));
 //# sourceMappingURL=Import.js.map

package/dist/generators/ts/ListType.js

@@ -63,11 +63,20 @@ export class ListType extends Type {
         return `${variables.value}.map(item => (${this.itemType.fromJsonExpression({ variables: { value: "item" } })}))`;
     }
     fromRdfExpression({ variables, }) {
-        const chain = [variables.resourceValues];
-        chain.push("head()");
-        chain.push("chain(value => value.toList())");
-        chain.push(`chain(values => purify.Either.sequence(values.map(value => ${this.itemType.fromRdfExpression({ variables: { ...variables, resourceValues: "value.toValues()" } })})))`);
-        return chain.join(".");
+        return [
+            variables.resourceValues,
+            "chain(values => values.chainMap(value => value.toList()))", // Resource.Values<Resource.Value> to Resource.Values<Resource.Value[]>
+            `chain(valueLists =>
+        valueLists.chainMap(
+          valueList => ${this.itemType.fromRdfExpression({
+                variables: {
+                    ...variables,
+                    resourceValues: `purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(rdfjsResource.Resource.Values.fromArray({ objects: valueList, predicate: ${variables.predicate}, subject: ${variables.resource} }))`,
+                },
+            })}
+      ))`, // Resource.Values<Resource.Value[]> to Resource.Values<item type arrays>
+            `map(valueLists => valueLists.map(valueList => valueList.toArray()${this.mutable ? ".concat()" : ""}))`, // Convert inner Resource.Values to arrays
+        ].join(".");
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
@@ -180,6 +189,7 @@ export class ListType extends Type {
                         allowIgnoreRdfType: true,
                         context: "subject",
                         variables: {
+                            preferredLanguages: parameters.variables.preferredLanguages,
                             subject: item0Variable,
                             variablePrefix: variablePrefix("Item0"),
                         },
@@ -213,6 +223,7 @@ export class ListType extends Type {
                         allowIgnoreRdfType: true,
                         context: "subject",
                         variables: {
+                            preferredLanguages: parameters.variables.preferredLanguages,
                             subject: itemNVariable,
                             variablePrefix: variablePrefix("ItemN"),
                         },

package/dist/generators/ts/LiteralType.d.ts

@@ -8,10 +8,13 @@ export declare class LiteralType extends TermType<Literal, Literal> {
     } & Omit<ConstructorParameters<typeof TermType<Literal, Literal>>[0], "nodeKinds">);
     get jsonName(): Type.JsonName;
     fromJsonExpression({ variables, }: Parameters<TermType<Literal, Literal>["fromJsonExpression"]>[0]): string;
+    protected fromRdfExpressionChain({ variables, }: Parameters<TermType<Literal>["fromRdfExpressionChain"]>[0]): ReturnType<TermType<Literal>["fromRdfExpressionChain"]>;
     hashStatements({ depth, variables, }: Parameters<TermType<Literal, Literal>["hashStatements"]>[0]): readonly string[];
     jsonZodSchema({ variables, }: Parameters<TermType<Literal, Literal>["jsonZodSchema"]>[0]): ReturnType<TermType<Literal, Literal>["jsonZodSchema"]>;
-    propertyFromRdfResourceValueExpression({ variables, }: Parameters<TermType<Literal, Literal>["propertyFromRdfResourceValueExpression"]>[0]): string;
+    snippetDeclarations(parameters: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
+    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0] & {
+        ignoreLiteralLanguage?: boolean;
+    }): readonly string[];
     toJsonExpression({ variables, }: Parameters<TermType<Literal, Literal>["toJsonExpression"]>[0]): string;
-    protected propertyFilterRdfResourceValuesExpression({ variables, }: Parameters<TermType<Literal, Literal>["propertyFilterRdfResourceValuesExpression"]>[0]): string;
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/generators/ts/LiteralType.js

@@ -6,8 +6,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { xsd } from "@tpluscode/rdf-ns-builders";
 import { Memoize } from "typescript-memoize";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { TermType } from "./TermType.js";
 import { Type } from "./Type.js";
+import { objectInitializer } from "./objectInitializer.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 export class LiteralType extends TermType {
     languageIn;
     constructor({ languageIn, ...superParameters }) {
@@ -23,6 +26,39 @@ export class LiteralType extends TermType {
     fromJsonExpression({ variables, }) {
         return `dataFactory.literal(${variables.value}["@value"], typeof ${variables.value}["@language"] !== "undefined" ? ${variables.value}["@language"] : (typeof ${variables.value}["@type"] !== "undefined" ? dataFactory.namedNode(${variables.value}["@type"]) : undefined))`;
     }
+    fromRdfExpressionChain({ variables, }) {
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            languageIn: this.languageIn.length > 0
+                ? `chain(values => values.chainMap(value => value.toLiteral().chain(literalValue => { switch (literalValue.language) { ${this.languageIn.map((languageIn) => `case "${languageIn}":`).join(" ")} return purify.Either.of(value); default: return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "literalValue", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })))`
+                : undefined,
+            preferredLanguages: `chain(values => {
+        if (!${variables.preferredLanguages} || ${variables.preferredLanguages}.length === 0) {
+          return purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(values);
+        }
+
+        const literalValuesEither = values.chainMap(value => value.toLiteral());
+        if (literalValuesEither.isLeft()) {
+          return literalValuesEither;
+        }
+        const literalValues = literalValuesEither.unsafeCoerce();
+
+        // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
+        // Within a preferredLanguage the literals may be in any order.
+        let filteredLiteralValues: rdfjsResource.Resource.Values<rdfjs.Literal> | undefined;
+        for (const preferredLanguage of ${variables.preferredLanguages}) {
+          if (!filteredLiteralValues) {
+            filteredLiteralValues = literalValues.filter(value => value.language === preferredLanguage);
+          } else {
+            filteredLiteralValues = filteredLiteralValues.concat(...literalValues.filter(value => value.language === preferredLanguage).toArray());
+          }
+        }
+
+        return purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(filteredLiteralValues!.map(literalValue => new rdfjsResource.Resource.Value({ object: literalValue, predicate: ${variables.predicate}, subject: ${variables.resource} })));
+      })`,
+            valueTo: "chain(values => values.chainMap(value => value.toLiteral()))",
+        };
+    }
     hashStatements({ depth, variables, }) {
         return [
             `${variables.hasher}.update(${variables.value}.datatype.value);`,
@@ -32,25 +68,55 @@ export class LiteralType extends TermType {
     jsonZodSchema({ variables, }) {
         return `${variables.zod}.object({ "@language": ${variables.zod}.string().optional(), "@type": ${variables.zod}.string().optional(), "@value": ${variables.zod}.string() })`;
     }
-    propertyFromRdfResourceValueExpression({ variables, }) {
-        return `${variables.resourceValue}.toLiteral()`;
+    snippetDeclarations(parameters) {
+        let snippetDeclarations = super.snippetDeclarations(parameters);
+        const { features } = parameters;
+        if (features.has("sparql") && this.languageIn.length > 0) {
+            snippetDeclarations = snippetDeclarations.concat(SnippetDeclarations.arrayIntersection);
+        }
+        return snippetDeclarations;
+    }
+    sparqlWherePatterns(parameters) {
+        const { context, ignoreLiteralLanguage, variables } = parameters;
+        const superPatterns = super.sparqlWherePatterns(parameters);
+        if (ignoreLiteralLanguage || context === "subject") {
+            return superPatterns;
+        }
+        return superPatterns.concat(`...[${this.languageIn.length > 0
+            ? `[...${syntheticNamePrefix}arrayIntersection(${JSON.stringify(this.languageIn)}, ${variables.preferredLanguages} ?? [])]`
+            : `(${variables.preferredLanguages} ?? [])`}]
+        .filter(languages => languages.length > 0)
+        .map(languages =>
+          languages.map(language => 
+            ({
+              type: "operation" as const,
+              operator: "=",
+              args: [
+                { type: "operation" as const, operator: "lang", args: [${variables.object}] },
+                dataFactory.literal(language)
+              ]
+            })
+          )
+        )
+        .map(langEqualsExpressions => 
+          ({
+            type: "filter" as const,
+            expression: langEqualsExpressions.reduce((reducedExpression, langEqualsExpression) => {
+              if (reducedExpression === null) {
+                return langEqualsExpression;
+              }
+              return {
+                type: "operation" as const,
+                operator: "||",
+                args: [reducedExpression, langEqualsExpression]
+              };
+            }, null as sparqljs.Expression | null) as sparqljs.Expression
+          })
+        )`);
     }
     toJsonExpression({ variables, }) {
         return `{ "@language": ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined, "@type": ${variables.value}.datatype.value !== "${xsd.string.value}" ? ${variables.value}.datatype.value : undefined, "@value": ${variables.value}.value }`;
     }
-    propertyFilterRdfResourceValuesExpression({ variables, }) {
-        return `${variables.resourceValues}.filter(_value => {
-  const _languageInOrDefault = ${variables.languageIn} ?? ${JSON.stringify(this.languageIn)};
-  if (_languageInOrDefault.length === 0) {
-    return true;
-  }
-  const _valueLiteral = _value.toLiteral().toMaybe().extract();
-  if (typeof _valueLiteral === "undefined") {
-    return false;
-  }
-  return _languageInOrDefault.some(_languageIn => _languageIn === _valueLiteral.language);
-})`;
-    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/NumberType.d.ts

@@ -1,4 +1,5 @@
 import { PrimitiveType } from "./PrimitiveType.js";
+import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
 export declare abstract class NumberType extends PrimitiveType<number> {
     readonly kind = "NumberType";
@@ -6,7 +7,7 @@ export declare abstract class NumberType extends PrimitiveType<number> {
     get conversions(): readonly Type.Conversion[];
     get name(): string;
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    propertyFromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<number>["propertyFromRdfResourceValueExpression"]>[0]): string;
+    protected fromRdfExpressionChain({ variables, }: Parameters<TermType["fromRdfExpressionChain"]>[0]): ReturnType<TermType["fromRdfExpressionChain"]>;
     toRdfExpression({ variables, }: Parameters<PrimitiveType<string>["toRdfExpression"]>[0]): string;
 }
 //# sourceMappingURL=NumberType.d.ts.map

package/dist/generators/ts/NumberType.js

@@ -43,13 +43,18 @@ export class NumberType extends PrimitiveType {
                 return `${variables.zod}.union([${this.primitiveIn.map((value) => `${variables.zod}.literal(${value})`).join(", ")}])`;
         }
     }
-    propertyFromRdfResourceValueExpression({ variables, }) {
-        let expression = `${variables.resourceValue}.toNumber()`;
+    fromRdfExpressionChain({ variables, }) {
+        let fromRdfResourceValueExpression = "value.toNumber()";
         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 })})); } })`;
+            fromRdfResourceValueExpression = `${fromRdfResourceValueExpression}.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;
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            languageIn: undefined,
+            preferredLanguages: undefined,
+            valueTo: `chain(values => values.chainMap(value => ${fromRdfResourceValueExpression}))`,
+        };
     }
     toRdfExpression({ variables, }) {
         return this.primitiveDefaultValue

package/dist/generators/ts/ObjectType.d.ts

@@ -10,7 +10,6 @@ import { Type } from "./Type.js";
 export declare class ObjectType extends DeclaredType {
     private readonly imports;
     protected readonly comment: Maybe<string>;
-    protected readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
     protected readonly label: Maybe<string>;
     protected readonly toRdfTypes: readonly NamedNode[];
     readonly abstract: boolean;
@@ -21,7 +20,7 @@ export declare class ObjectType extends DeclaredType {
     readonly staticModuleName: string;
     readonly synthetic: boolean;
     readonly 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 }: {
         abstract: boolean;
         comment: Maybe<string>;
         declarationType: TsObjectDeclarationType;
@@ -45,6 +44,8 @@ export declare class ObjectType extends DeclaredType {
     get conversions(): readonly Type.Conversion[];
     get declarationImports(): readonly Import[];
     get declarations(): (ClassDeclarationStructure | InterfaceDeclarationStructure | ModuleDeclarationStructure)[];
+    get descendantFromRdfTypes(): readonly NamedNode[];
+    get descendantFromRdfTypeVariables(): readonly string[];
     get descendantObjectTypes(): readonly ObjectType[];
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get discriminatorValue(): string;