@shaclmate/compiler 2.0.23 → 2.0.24

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

@@ -7,7 +7,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;
+    fromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<boolean>["fromRdfResourceValueExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<PrimitiveType<string>["toRdfExpression"]>[0]): string;
 }
 //# sourceMappingURL=BooleanType.d.ts.map

package/dist/generators/ts/BooleanType.js

@@ -43,7 +43,7 @@ export class BooleanType extends PrimitiveType {
         }
         return `${variables.zod}.boolean()`;
     }
-    propertyFromRdfResourceValueExpression({ variables, }) {
+    fromRdfResourceValueExpression({ variables, }) {
         let expression = `${variables.resourceValue}.toBoolean()`;
         if (this.primitiveIn.length === 1) {
             const eitherTypeParameters = `<Error, ${this.name}>`;

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

@@ -15,7 +15,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;
+    fromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<number>["fromRdfResourceValueExpression"]>[0]): string;
     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,7 +54,7 @@ export class DateTimeType extends PrimitiveType {
     jsonZodSchema({ variables, }) {
         return `${variables.zod}.string().${this.zodDatatype}()`;
     }
-    propertyFromRdfResourceValueExpression({ variables, }) {
+    fromRdfResourceValueExpression({ variables, }) {
         let expression = `${variables.resourceValue}.toDate()`;
         if (this.primitiveIn.length > 0) {
             const eitherTypeParameters = `<Error, ${this.name}>`;

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

@@ -12,9 +12,14 @@ 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<Type["fromRdfExpression"]>[0]): {
+        defaultValue?: string;
+        hasValues?: string;
+        languageIn?: string;
+        valueTo?: string;
+    };
     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,
+            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/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: {
+                            languageIn: parameters.variables.languageIn,
                             subject: item0Variable,
                             variablePrefix: variablePrefix("Item0"),
                         },
@@ -213,6 +223,7 @@ export class ListType extends Type {
                         allowIgnoreRdfType: true,
                         context: "subject",
                         variables: {
+                            languageIn: parameters.variables.languageIn,
                             subject: itemNVariable,
                             variablePrefix: variablePrefix("ItemN"),
                         },

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

@@ -8,10 +8,17 @@ 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<Type["fromRdfExpression"]>[0]): {
+        defaultValue?: string;
+        hasValues?: string;
+        languageIn?: string;
+        valueTo?: string;
+    };
     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;
+    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0] & {
+        ignoreLanguageIn?: 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

@@ -5,6 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { xsd } from "@tpluscode/rdf-ns-builders";
+import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { TermType } from "./TermType.js";
 import { Type } from "./Type.js";
@@ -23,6 +24,49 @@ 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: `chain(values => {
+      const literalValuesEither = values.chainMap(value => value.toLiteral());
+      if (literalValuesEither.isLeft()) {
+        return literalValuesEither;
+      }
+      const literalValues = literalValuesEither.unsafeCoerce();
+
+      const nonUniqueLanguageIn = ${variables.languageIn} ?? ${JSON.stringify(this.languageIn)};
+      if (nonUniqueLanguageIn.length === 0) {
+        return purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjs.Literal>>(literalValues);
+      }
+
+      let uniqueLanguageIn: string[];
+      if (nonUniqueLanguageIn.length === 1) {
+        uniqueLanguageIn = [nonUniqueLanguageIn[0]];
+      } else {
+        uniqueLanguageIn = [];
+        for (const languageIn of nonUniqueLanguageIn) {
+          if (uniqueLanguageIn.indexOf(languageIn) === -1) {
+            uniqueLanguageIn.push(languageIn);
+          }
+        }
+      }
+
+      // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
+      // Within a languageIn the literals may be in any order.
+      let filteredLiteralValues: rdfjsResource.Resource.Values<rdfjs.Literal> | undefined;
+      for (const languageIn of uniqueLanguageIn) {
+        if (!filteredLiteralValues) {
+          filteredLiteralValues = literalValues.filter(value => value.language === languageIn);
+        } else {
+          filteredLiteralValues = filteredLiteralValues.concat(...literalValues.filter(value => value.language === languageIn).toArray());
+        }
+      }
+
+      return purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjs.Literal>>(filteredLiteralValues!);
+    })`,
+            valueTo: undefined,
+        };
+    }
     hashStatements({ depth, variables, }) {
         return [
             `${variables.hasher}.update(${variables.value}.datatype.value);`,
@@ -32,25 +76,45 @@ 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()`;
+    sparqlWherePatterns(parameters) {
+        const { context, ignoreLanguageIn, variables } = parameters;
+        const superPatterns = super.sparqlWherePatterns(parameters);
+        if (ignoreLanguageIn || context === "subject") {
+            return superPatterns;
+        }
+        invariant(this.name.indexOf("rdfjs.Literal") !== -1, this.name);
+        return superPatterns.concat(`...[(${variables.languageIn} && ${variables.languageIn}.length > 0) ? ${variables.languageIn} : ${JSON.stringify(this.languageIn)}]
+        .filter(languagesIn => languagesIn.length > 0)
+        .map(languagesIn =>
+          languagesIn.map(languageIn => 
+            ({
+              type: "operation" as const,
+              operator: "=",
+              args: [
+                { type: "operation" as const, operator: "lang", args: [${variables.object}] },
+                dataFactory.literal(languageIn)
+              ]
+            })
+          )
+        )
+        .map(langEqualsExpressions => 
+          ({
+            type: "filter" as const,
+            expression:
+              langEqualsExpressions.length === 1
+                ? langEqualsExpressions[0]
+                :
+                  {
+                    type: "operation" as const,
+                    operator: "||",
+                    args: langEqualsExpressions
+                  },
+          })
+        )`);
     }
     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

@@ -6,7 +6,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 fromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<number>["fromRdfResourceValueExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<PrimitiveType<string>["toRdfExpression"]>[0]): string;
 }
 //# sourceMappingURL=NumberType.d.ts.map

package/dist/generators/ts/NumberType.js

@@ -43,7 +43,7 @@ export class NumberType extends PrimitiveType {
                 return `${variables.zod}.union([${this.primitiveIn.map((value) => `${variables.zod}.literal(${value})`).join(", ")}])`;
         }
     }
-    propertyFromRdfResourceValueExpression({ variables, }) {
+    fromRdfResourceValueExpression({ variables, }) {
         let expression = `${variables.resourceValue}.toNumber()`;
         if (this.primitiveIn.length > 0) {
             const eitherTypeParameters = `<Error, ${this.name}>`;

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;

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
@@ -171,7 +169,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 +221,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, " : ""}languageIn: ${variables.languageIn}, objectSet: ${variables.objectSet} }))))`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
@@ -301,6 +299,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
+                        languageIn: parameters.variables.languageIn,
                         subject: parameters.variables.subject,
                         variablePrefix: parameters.variables.variablePrefix,
                     })})`,

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

@@ -25,6 +25,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

@@ -81,6 +81,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 +273,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; languageIn?: readonly string[]; objectSet?: ${syntheticNamePrefix}ObjectSet }`,
                 },
             ],
             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 +306,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 +435,7 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
                     {
                         hasQuestionToken: true,
                         name: "parameters",
-                        type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
+                        type: '{ ignoreRdfType?: boolean; languageIn?: readonly string[]; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                     },
                 ],
                 returnType: "readonly sparqljs.Pattern[]",
@@ -501,8 +509,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 +546,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, languageIn: ${variables.languageIn}, objectSet: ${variables.objectSet} }))))`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
@@ -590,6 +599,7 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
             case "subject":
                 return [
                     `...${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${objectInitializer({
+                        languageIn: parameters.variables.languageIn,
                         subject: parameters.variables.subject,
                         variablePrefix: parameters.variables.variablePrefix,
                     })})`,
@@ -601,8 +611,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

@@ -12,10 +12,28 @@ export declare abstract class PrimitiveType<ValueT extends boolean | Date | stri
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get jsonName(): Type.JsonName;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
+    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): {
+        defaultValue?: string;
+        hasValues?: string;
+        languageIn?: string;
+        valueTo?: string;
+    };
     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<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
-    protected propertyFilterRdfResourceValuesExpression({ variables, }: Parameters<LiteralType["propertyFilterRdfResourceValuesExpression"]>[0]): string;
+    /**
+     * Convert an rdfjsResource.Resource.Value to a value of this type.
+     * @param variables
+     * @protected
+     */
+    protected abstract fromRdfResourceValueExpression({ variables, }: {
+        variables: {
+            predicate: string;
+            resource: string;
+            resourceValue: string;
+        };
+    }): string;
 }
 //# sourceMappingURL=PrimitiveType.d.ts.map