@shaclmate/compiler 2.0.23 → 2.0.24

package/dist/generators/ts/PrimitiveType.js

@@ -28,6 +28,19 @@ 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;
     }
@@ -41,12 +54,12 @@ export class PrimitiveType extends LiteralType {
         }
         return snippetDeclarations;
     }
+    sparqlWherePatterns(parameters) {
+        return super.sparqlWherePatterns({ ...parameters, ignoreLanguageIn: true });
+    }
     toJsonExpression({ variables, }) {
         return variables.value;
     }
-    propertyFilterRdfResourceValuesExpression({ variables, }) {
-        return variables.resourceValues;
-    }
 }
 __decorate([
     Memoize()

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

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

package/dist/generators/ts/SetType.js

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

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

@@ -4,7 +4,7 @@ export declare namespace SnippetDeclarations {
     const dateEquals = "/**\n * Compare two Dates and return an $EqualsResult.\n */\nexport function $dateEquals(left: Date, right: Date): $EqualsResult {\n  return $EqualsResult.fromBooleanEqualsResult(\n    left,\n    right,\n    left.getTime() === right.getTime(),\n  );\n}";
     const EqualsResult = "export type $EqualsResult = purify.Either<$EqualsResult.Unequal, true>;\n\nexport namespace $EqualsResult {\n  export const Equal: $EqualsResult = purify.Either.of<Unequal, true>(true);\n\n  export function fromBooleanEqualsResult(\n    left: any,\n    right: any,\n    equalsResult: boolean | $EqualsResult,\n  ): $EqualsResult {\n    if (typeof equalsResult !== \"boolean\") {\n      return equalsResult;\n    }\n\n    if (equalsResult) {\n      return Equal;\n    }\n\n    return purify.Left({ left, right, type: \"BooleanEquals\" });\n  }\n\n  export type Unequal =\n  | {\n    readonly left: {\n      readonly array: readonly any[];\n      readonly element: any;\n      readonly elementIndex: number;\n    };\n    readonly right: {\n      readonly array: readonly any[];\n      readonly unequals: readonly Unequal[];\n    };\n    readonly type: \"ArrayElement\";\n  }\n  | {\n    readonly left: readonly any[];\n    readonly right: readonly any[];\n    readonly type: \"ArrayLength\";\n  }\n  | {\n    readonly left: any;\n    readonly right: any;\n    readonly type: \"BooleanEquals\";\n  }\n  | {\n    readonly left: any;\n    readonly right: any;\n    readonly type: \"LeftError\";\n  }\n  | {\n    readonly right: any;\n    readonly type: \"LeftNull\";\n  }\n  | {\n    readonly left: bigint | boolean | number | string;\n    readonly right: bigint | boolean | number | string;\n    readonly type: \"Primitive\";\n  }\n  | {\n    readonly left: any;\n    readonly right: any;\n    readonly propertyName: string;\n    readonly propertyValuesUnequal: Unequal;\n    readonly type: \"Property\";\n  }\n  | {\n    readonly left: any;\n    readonly right: any;\n    readonly type: \"RightError\";\n  }\n  | {\n    readonly left: any;\n    readonly type: \"RightNull\";\n  };\n}    \n";
     const maybeEquals = "export function $maybeEquals<T>(\n  leftMaybe: purify.Maybe<T>,\n  rightMaybe: purify.Maybe<T>,\n  valueEquals: (left: T, right: T) => boolean | $EqualsResult,\n): $EqualsResult {\n  if (leftMaybe.isJust()) {\n    if (rightMaybe.isJust()) {\n      return $EqualsResult.fromBooleanEqualsResult(\n        leftMaybe,\n        rightMaybe,\n        valueEquals(leftMaybe.unsafeCoerce(), rightMaybe.unsafeCoerce()),\n      );\n    }\n    return purify.Left({\n      left: leftMaybe.unsafeCoerce(),\n      type: \"RightNull\",\n    });\n  }\n\n  if (rightMaybe.isJust()) {\n    return purify.Left({\n      right: rightMaybe.unsafeCoerce(),\n      type: \"LeftNull\",\n    });\n  }\n\n  return $EqualsResult.Equal;\n}";
-    const LazyObjectSet = "/**\n * Type of lazy properties that return a set of objects. This is a class instead of an interface so it can be instanceof'd elsewhere.\n */\nexport class $LazyObjectSet<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { $identifier: ObjectIdentifierT }, StubObjectT extends { $identifier: ObjectIdentifierT }> {\n  private readonly resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<purify.Either<Error, readonly ResolvedObjectT[]>>;\n  readonly stubs: readonly StubObjectT[];\n\n  constructor({ resolver, stubs }: {\n    resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<purify.Either<Error, readonly ResolvedObjectT[]>>,\n    stubs: readonly StubObjectT[]\n  }) {\n    this.resolver = resolver;\n    this.stubs = stubs;\n  }\n\n  async resolve(): Promise<purify.Either<Error, readonly ResolvedObjectT[]>> {\n    if (this.stubs.length === 0) {\n      return purify.Either.of([]);\n    }\n    return await this.resolver(this.stubs.map(stub => stub.$identifier));\n  }\n}";
+    const LazyObjectSet = "/**\n * Type of lazy properties that return a set of objects. This is a class instead of an interface so it can be instanceof'd elsewhere.\n */\nexport class $LazyObjectSet<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { $identifier: ObjectIdentifierT }, StubObjectT extends { $identifier: ObjectIdentifierT }> {\n  private readonly resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<purify.Either<Error, readonly ResolvedObjectT[]>>;\n  readonly stubs: readonly StubObjectT[];\n\n  constructor({ resolver, stubs }: {\n    resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<purify.Either<Error, readonly ResolvedObjectT[]>>,\n    stubs: readonly StubObjectT[]\n  }) {\n    this.resolver = resolver;\n    this.stubs = stubs;\n  }\n\n  async resolve(options?: { limit?: number; offset?: number }): Promise<purify.Either<Error, readonly ResolvedObjectT[]>> {\n    if (this.stubs.length === 0) {\n      return purify.Either.of([]);\n    }\n\n    const limit = options?.limit ?? Number.MAX_SAFE_INTEGER;\n    if (limit <= 0) {\n      return purify.Either.of([]);\n    }\n\n    let offset = options?.offset ?? 0;\n    if (offset < 0) {\n      offset = 0;\n    }\n\n    return await this.resolver(this.stubs.slice(offset, offset + limit).map(stub => stub.$identifier));\n  }\n}";
     const LazyOptionalObject = "/**\n * Type of lazy properties that return a single optional object. This is a class instead of an interface so it can be instanceof'd elsewhere.\n */\nexport class $LazyOptionalObject<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { $identifier: ObjectIdentifierT }, StubObjectT extends { $identifier: ObjectIdentifierT }> {\n  private readonly resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>;\n  readonly stub: purify.Maybe<StubObjectT>;\n\n  constructor({ resolver, stub }: {\n    resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>,\n    stub: purify.Maybe<StubObjectT>\n  }) {\n    this.resolver = resolver;\n    this.stub = stub;\n  }\n\n  async resolve(): Promise<purify.Either<Error, purify.Maybe<ResolvedObjectT>>> {\n    if (this.stub.isNothing()) {\n      return purify.Either.of(purify.Maybe.empty());\n    }\n    return (await this.resolver(this.stub.unsafeCoerce().$identifier)).map(purify.Maybe.of);\n  }\n}";
     const LazyRequiredObject = "/**\n * Type of lazy properties that return a single required object. This is a class instead of an interface so it can be instanceof'd elsewhere.\n */\nexport class $LazyRequiredObject<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { $identifier: ObjectIdentifierT }, StubObjectT extends { $identifier: ObjectIdentifierT }> {\n  private readonly resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>;\n  readonly stub: StubObjectT;\n\n  constructor({ resolver, stub }: {\n    resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>,\n    stub: StubObjectT\n  }) {\n    this.resolver = resolver;\n    this.stub = stub;\n  }\n\n  resolve(): Promise<purify.Either<Error, ResolvedObjectT>> {\n    return this.resolver(this.stub.$identifier);\n  }\n}";
     const RdfVocabularies = "export namespace $RdfVocabularies {\n  export namespace rdf {\n    export const first = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#first\");\n    export const nil = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#nil\");\n    export const rest = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#rest\");\n    export const subject = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#subject\");\n    export const type = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#type\");\n  }\n\n  export namespace rdfs {\n    export const subClassOf = dataFactory.namedNode(\"http://www.w3.org/2000/01/rdf-schema#subClassOf\");\n  }\n\n  export namespace xsd {\n    export const boolean = dataFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#boolean\");\n    export const date = dataFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#date\");\n    export const dateTime = dataFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#dateTime\");\n    export const integer = dataFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#integer\");\n  }\n}";

package/dist/generators/ts/SnippetDeclarations.js

@@ -215,11 +215,22 @@ export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends rdfjs
     this.stubs = stubs;
   }
 
-  async resolve(): Promise<purify.Either<Error, readonly ResolvedObjectT[]>> {
+  async resolve(options?: { limit?: number; offset?: number }): Promise<purify.Either<Error, readonly ResolvedObjectT[]>> {
     if (this.stubs.length === 0) {
       return purify.Either.of([]);
     }
-    return await this.resolver(this.stubs.map(stub => stub.${syntheticNamePrefix}identifier));
+
+    const limit = options?.limit ?? Number.MAX_SAFE_INTEGER;
+    if (limit <= 0) {
+      return purify.Either.of([]);
+    }
+
+    let offset = options?.offset ?? 0;
+    if (offset < 0) {
+      offset = 0;
+    }
+
+    return await this.resolver(this.stubs.slice(offset, offset + limit).map(stub => stub.${syntheticNamePrefix}identifier));
   }
 }`;
     SnippetDeclarations.LazyOptionalObject = `\

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

@@ -6,9 +6,9 @@ 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;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    propertyFromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<string>["propertyFromRdfResourceValueExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<PrimitiveType<string>["toRdfExpression"]>[0]): string;
 }
 //# sourceMappingURL=StringType.d.ts.map

package/dist/generators/ts/StringType.js

@@ -37,6 +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;
+    }
     hashStatements({ variables, }) {
         return [`${variables.hasher}.update(${variables.value});`];
     }
@@ -50,14 +58,6 @@ export class StringType extends PrimitiveType {
                 return `${variables.zod}.enum(${JSON.stringify(this.primitiveIn)})`;
         }
     }
-    propertyFromRdfResourceValueExpression({ variables, }) {
-        let expression = `${variables.resourceValue}.toString()`;
-        if (this.primitiveIn.length > 0) {
-            const eitherTypeParameters = `<Error, ${this.name}>`;
-            expression = `${expression}.chain(value => { switch (value) { ${this.primitiveIn.map((value) => `case "${value}":`).join(" ")} return purify.Either.of${eitherTypeParameters}(value); default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })`;
-        }
-        return expression;
-    }
     toRdfExpression({ variables, }) {
         return this.primitiveDefaultValue
             .map((defaultValue) => `${variables.value} !== "${defaultValue}" ? ${variables.value} : undefined`)

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

@@ -30,7 +30,13 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     get jsonName(): Type.JsonName;
     get name(): string;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    fromRdfExpression(parameters: Parameters<Type["fromRdfExpression"]>[0]): string;
+    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): {
+        defaultValue?: string;
+        hasValues?: string;
+        languageIn?: string;
+        valueTo?: string;
+    };
     graphqlResolveExpression(_parameters: Parameters<Type["graphqlResolveExpression"]>[0]): string;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonUiSchemaElement(): Maybe<string>;
@@ -40,23 +46,5 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
     useImports(): readonly Import[];
-    /**
-     * Filter the rdfjsResource.Resource.Values to those that are relevant to the type.
-     *
-     * This is done before
-     */
-    protected propertyFilterRdfResourceValuesExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
-    /**
-     * Convert an rdfjsResource.Resource.Value to a value of this type.
-     * @param variables
-     * @protected
-     */
-    protected propertyFromRdfResourceValueExpression({ variables, }: {
-        variables: {
-            predicate: string;
-            resource: string;
-            resourceValue: string;
-        };
-    }): string;
 }
 //# sourceMappingURL=TermType.d.ts.map

package/dist/generators/ts/TermType.js

@@ -120,31 +120,51 @@ export class TermType extends Type {
                 : `((${variables.value}.termType === "${nodeKind}") ? (${valueToNodeKind}) : (${expression}))`;
         }, "");
     }
-    fromRdfExpression({ variables, }) {
-        const chain = [
-            this.propertyFilterRdfResourceValuesExpression({ variables }),
-        ];
-        // Have an rdfjsResource.Resource.Values here
-        if (this.hasValues.length === 1) {
-            chain.push(`find(value => value.toTerm().equals(${rdfjsTermExpression(this.hasValues[0])}))`);
-        }
-        else {
-            chain.push("head()");
+    fromRdfExpression(parameters) {
+        // invariant(
+        //   this.nodeKinds.has("Literal") &&
+        //     (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")),
+        //   "IdentifierType and LiteralType should override",
+        // );
+        const chain = this.fromRdfExpressionChain(parameters);
+        const { variables } = parameters;
+        return [
+            variables.resourceValues,
+            chain.defaultValue,
+            chain.hasValues,
+            chain.languageIn,
+            chain.valueTo,
+        ]
+            .filter((_) => typeof _ !== "undefined")
+            .join(".");
+    }
+    fromRdfExpressionChain({ variables, }) {
+        let valueToExpression = "purify.Either.of<Error, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>(value.toTerm())";
+        if (this.nodeKinds.size < 3) {
+            const eitherTypeParameters = `<Error, ${this.name}>`;
+            valueToExpression = `${valueToExpression}.chain(term => {
+  switch (term.termType) {
+  ${[...this.nodeKinds].map((nodeKind) => `case "${nodeKind}":`).join("\n")} return purify.Either.of${eitherTypeParameters}(term);
+  default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "term", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })}));         
+}})`;
         }
-        // Have an rdfjsResource.Resource.Value here
-        this.defaultValue.ifJust((defaultValue) => {
-            // alt the default value before trying to convert the rdfjsResource.Resource.Value to the type
-            chain.push(`alt(purify.Either.of(new rdfjsResource.Resource.Value(${objectInitializer({ subject: variables.resource, predicate: variables.predicate, object: rdfjsTermExpression(defaultValue) })})))`);
-        });
-        // Last step: convert the rdfjsResource.Resource.Value to the type
-        chain.push(`chain(value => ${this.propertyFromRdfResourceValueExpression({
-            variables: {
-                predicate: variables.predicate,
-                resource: variables.resource,
-                resourceValue: "value",
-            },
-        })})`);
-        return chain.join(".");
+        return {
+            defaultValue: this.defaultValue
+                .map((defaultValue) => `map(values => values.length > 0 ? values : new rdfjsResource.Resource.Value(${objectInitializer({ subject: variables.resource, predicate: variables.predicate, object: rdfjsTermExpression(defaultValue) })}).toValues())`)
+                .extract(),
+            hasValues: this.hasValues.length > 0
+                ? `chain(values => {
+  for (const hasValue of [${this.hasValues.map(rdfjsTermExpression).join(", ")}]) {
+    const findResult = values.find(value => value.toTerm().equals(hasValue));
+    if (findResult.isLeft()) {
+      return findResult;
+    }
+  }
+  return purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(values);
+})`
+                : undefined,
+            valueTo: `chain(values => values.chainMap(value => ${valueToExpression}))`,
+        };
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
@@ -231,33 +251,6 @@ export class TermType extends Type {
         }
         return imports;
     }
-    /**
-     * Filter the rdfjsResource.Resource.Values to those that are relevant to the type.
-     *
-     * This is done before
-     */
-    propertyFilterRdfResourceValuesExpression({ variables, }) {
-        return variables.resourceValues;
-    }
-    /**
-     * Convert an rdfjsResource.Resource.Value to a value of this type.
-     * @param variables
-     * @protected
-     */
-    propertyFromRdfResourceValueExpression({ variables, }) {
-        invariant(this.nodeKinds.has("Literal") &&
-            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
-        let expression = `purify.Either.of<Error, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>(${variables.resourceValue}.toTerm())`;
-        if (this.nodeKinds.size < 3) {
-            const eitherTypeParameters = `<Error, ${this.name}>`;
-            expression = `${expression}.chain(term => {
-  switch (term.termType) {
-  ${[...this.nodeKinds].map((nodeKind) => `case "${nodeKind}":`).join("\n")} return purify.Either.of${eitherTypeParameters}(term);
-  default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "term", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })}));         
-}})`;
-        }
-        return expression;
-    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/TsGenerator.js

@@ -28,7 +28,10 @@ export class TsGenerator {
     }
     addStatements({ objectTypes, objectUnionTypes, sourceFile, }) {
         // sourceFile.addStatements(this.configuration.dataFactoryImport);
-        sourceFile.addStatements('import N3, { DataFactory as dataFactory } from "n3"');
+        sourceFile.addStatements([
+            'import { DataFactory as dataFactory, StoreFactory as _DatasetFactory } from "n3";',
+            "const datasetFactory: rdfjs.DatasetCoreFactory = new _DatasetFactory();",
+        ]);
         const declaredTypes = [
             ...objectTypes,
             ...objectUnionTypes,

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

@@ -50,8 +50,15 @@ export declare abstract class Type {
         };
     }): string;
     /**
-     * An expression that converts a rdfjsResource.Resource.Values to a purify.Either of value/values
-     * of this type for a property.
+     * 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
+     *
+     * 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.
      */
     abstract fromRdfExpression(parameters: {
         variables: {
@@ -69,6 +76,7 @@ export declare abstract class Type {
      */
     abstract graphqlResolveExpression(parameters: {
         variables: {
+            args: string;
             value: string;
         };
     }): string;
@@ -152,6 +160,7 @@ export declare abstract class Type {
         allowIgnoreRdfType: boolean;
         context: "object";
         variables: {
+            languageIn: string;
             object: string;
             predicate: string;
             subject: string;
@@ -161,6 +170,7 @@ export declare abstract class Type {
         allowIgnoreRdfType: boolean;
         context: "subject";
         variables: {
+            languageIn: string;
             subject: string;
             variablePrefix: string;
         };

package/dist/generators/ts/Type.js

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

package/dist/generators/ts/TypeFactory.d.ts

@@ -2,9 +2,17 @@ import type * as ast from "../../ast/index.js";
 import { ObjectType } from "./ObjectType.js";
 import type { Type } from "./Type.js";
 export declare class TypeFactory {
+    private cachedBooleanType;
+    private cachedDateType;
+    private cachedDateTimeType;
+    private cachedFloatType;
+    private cachedIdentifierType;
+    private cachedIntType;
+    private cachedNamedIdentifierType;
     private cachedObjectTypePropertiesByIdentifier;
     private cachedObjectTypesByIdentifier;
     private cachedObjectUnionTypesByIdentifier;
+    private cachedStringType;
     createObjectTypeFromAstType(astType: ast.ObjectType): ObjectType;
     createTypeFromAstType(astType: ast.Type): Type;
     private createObjectTypePropertyFromAstProperty;