@shaclmate/compiler 2.0.22 → 2.0.24

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

@@ -1,27 +1,31 @@
-import type { TsFeature } from "../../enums/index.js";
+import { Maybe } from "purify-ts";
 import { Import } from "./Import.js";
 import { Type } from "./Type.js";
-export declare class OptionType extends Type {
-    readonly itemType: Type;
+export declare class OptionType<ItemTypeT extends Type> extends Type {
+    readonly discriminatorProperty: Maybe<Type.DiscriminatorProperty>;
+    readonly itemType: ItemTypeT;
     readonly kind = "OptionType";
-    constructor({ itemType, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
-        itemType: Type;
+    readonly typeof = "object";
+    constructor({ itemType }: {
+        itemType: ItemTypeT;
     });
     get conversions(): readonly Type.Conversion[];
     get equalsFunction(): string;
-    get jsonName(): string;
+    get graphqlName(): Type.GraphqlName;
+    get jsonName(): Type.JsonName;
     get mutable(): boolean;
     get name(): string;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression(parameters: Parameters<Type["fromRdfExpression"]>[0]): string;
+    graphqlResolveExpression(parameters: Parameters<Type["graphqlResolveExpression"]>[0]): string;
     hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonUiSchemaElement(parameters: Parameters<Type["jsonUiSchemaElement"]>[0]): ReturnType<Type["jsonUiSchemaElement"]>;
     jsonZodSchema(parameters: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    snippetDeclarations(features: Set<TsFeature>): readonly string[];
-    sparqlConstructTemplateTriples({ context, variables, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-    sparqlWherePatterns({ context, variables, }: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
+    snippetDeclarations(parameters: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
+    sparqlConstructTemplateTriples(parameters: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
-    useImports(features: Set<TsFeature>): readonly Import[];
+    useImports(parameters: Parameters<Type["useImports"]>[0]): readonly Import[];
 }
 //# sourceMappingURL=OptionType.d.ts.map

package/dist/generators/ts/OptionType.js

@@ -5,14 +5,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 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";
 import { Type } from "./Type.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 export class OptionType extends Type {
+    discriminatorProperty = Maybe.empty();
     itemType;
     kind = "OptionType";
-    constructor({ itemType, ...superParameters }) {
-        super(superParameters);
+    typeof = "object";
+    constructor({ itemType }) {
+        super();
         this.itemType = itemType;
     }
     get conversions() {
@@ -38,10 +43,19 @@ export class OptionType extends Type {
         return conversions;
     }
     get equalsFunction() {
-        return `((left, right) => maybeEquals(left, right, ${this.itemType.equalsFunction}))`;
+        return `((left, right) => ${syntheticNamePrefix}maybeEquals(left, right, ${this.itemType.equalsFunction}))`;
+    }
+    get graphqlName() {
+        invariant(!this.itemType.graphqlName.nullable);
+        return new Type.GraphqlName(this.itemType.graphqlName.toString(), {
+            nullable: true,
+        });
     }
     get jsonName() {
-        return `(${this.itemType.jsonName}) | undefined`;
+        invariant(!this.itemType.jsonName.optional);
+        return new Type.JsonName(this.itemType.jsonName.toString(), {
+            optional: true,
+        });
     }
     get mutable() {
         return this.itemType.mutable;
@@ -52,23 +66,27 @@ export class OptionType extends Type {
     fromJsonExpression({ variables, }) {
         const expression = `purify.Maybe.fromNullable(${variables.value})`;
         const itemFromJsonExpression = this.itemType.fromJsonExpression({
-            variables: { value: "_item" },
+            variables: { value: "item" },
         });
-        return itemFromJsonExpression === "_item"
+        return itemFromJsonExpression === "item"
             ? expression
-            : `${expression}.map(_item => (${itemFromJsonExpression}))`;
+            : `${expression}.map(item => (${itemFromJsonExpression}))`;
     }
     fromRdfExpression(parameters) {
-        return `purify.Either.of(${this.itemType.fromRdfExpression(parameters)}.toMaybe())`;
+        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()`;
     }
     hashStatements({ depth, variables, }) {
         return [
-            `${variables.value}.ifJust((_value${depth}) => { ${this.itemType
+            `${variables.value}.ifJust((value${depth}) => { ${this.itemType
                 .hashStatements({
                 depth: depth + 1,
                 variables: {
                     hasher: variables.hasher,
-                    value: `_value${depth}`,
+                    value: `value${depth}`,
                 },
             })
                 .join("\n")} })`,
@@ -80,56 +98,66 @@ export class OptionType extends Type {
     jsonZodSchema(parameters) {
         return `${this.itemType.jsonZodSchema(parameters)}.optional()`;
     }
-    snippetDeclarations(features) {
+    snippetDeclarations(parameters) {
         const snippetDeclarations = this.itemType
-            .snippetDeclarations(features)
+            .snippetDeclarations(parameters)
             .concat();
-        if (features.has("equals")) {
+        if (parameters.features.has("equals")) {
             snippetDeclarations.push(SnippetDeclarations.maybeEquals);
         }
         return snippetDeclarations;
     }
-    sparqlConstructTemplateTriples({ context, variables, }) {
-        switch (context) {
-            case "property":
-                return super.sparqlConstructTemplateTriples({ context, variables });
-            case "type":
-                return this.itemType.sparqlConstructTemplateTriples({
-                    context,
-                    variables,
-                });
+    sparqlConstructTemplateTriples(parameters) {
+        switch (parameters.context) {
+            case "object":
+                return super.sparqlConstructTemplateTriples(parameters);
+            case "subject":
+                return this.itemType.sparqlConstructTemplateTriples(parameters);
         }
     }
-    sparqlWherePatterns({ context, variables, }) {
-        switch (context) {
-            case "property": {
-                const patterns = super.sparqlWherePatterns({ context, variables });
+    sparqlWherePatterns(parameters) {
+        switch (parameters.context) {
+            case "object": {
+                const patterns = this.itemType.sparqlWherePatterns(parameters);
                 if (patterns.length === 0) {
                     return [];
                 }
                 return [`{ patterns: [${patterns.join(", ")}], type: "optional" }`];
             }
-            case "type": {
-                return this.itemType.sparqlWherePatterns({ context, variables });
+            case "subject": {
+                throw new Error("should never be called");
+                // return this.itemType.sparqlWherePatterns(parameters);
             }
         }
     }
     toJsonExpression({ variables, }) {
-        return `${variables.value}.map(_item => (${this.itemType.toJsonExpression({ variables: { value: "_item" } })})).extract()`;
+        return `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: "item" } })})).extract()`;
     }
     toRdfExpression({ variables, }) {
         const itemTypeToRdfExpression = this.itemType.toRdfExpression({
-            variables: { ...variables, value: "_value" },
+            variables: { ...variables, value: "value" },
         });
-        if (itemTypeToRdfExpression === "_value") {
+        if (itemTypeToRdfExpression === "value") {
             return variables.value;
         }
-        return `${variables.value}.map((_value) => ${itemTypeToRdfExpression})`;
+        return `${variables.value}.map((value) => ${itemTypeToRdfExpression})`;
     }
-    useImports(features) {
-        return [...this.itemType.useImports(features), Import.PURIFY];
+    useImports(parameters) {
+        return [...this.itemType.useImports(parameters), Import.PURIFY];
     }
 }
+__decorate([
+    Memoize()
+], OptionType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "graphqlName", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "jsonName", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "name", null);

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

@@ -1,7 +1,6 @@
 import { Maybe } from "purify-ts";
-import type { TsFeature } from "../../enums/index.js";
 import { LiteralType } from "./LiteralType.js";
-import type { Type } from "./Type.js";
+import { Type } from "./Type.js";
 export declare abstract class PrimitiveType<ValueT extends boolean | Date | string | number> extends LiteralType {
     readonly equalsFunction: string;
     readonly primitiveDefaultValue: Maybe<ValueT>;
@@ -11,11 +10,30 @@ export declare abstract class PrimitiveType<ValueT extends boolean | Date | stri
         primitiveIn: readonly ValueT[];
     } & ConstructorParameters<typeof LiteralType>[0]);
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
-    get jsonName(): string;
+    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: Set<TsFeature>): 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

package/dist/generators/ts/PrimitiveType.js

@@ -1,8 +1,17 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { LiteralType } from "./LiteralType.js";
 import { SnippetDeclarations } from "./SnippetDeclarations.js";
+import { Type } from "./Type.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 export class PrimitiveType extends LiteralType {
-    equalsFunction = "strictEquals";
+    equalsFunction = `${syntheticNamePrefix}strictEquals`;
     primitiveDefaultValue;
     primitiveIn;
     constructor({ primitiveDefaultValue, primitiveIn, ...superParameters }) {
@@ -14,26 +23,45 @@ export class PrimitiveType extends LiteralType {
         return Maybe.empty();
     }
     get jsonName() {
-        return this.name;
+        return new Type.JsonName(this.name);
     }
     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;
+    }
     hashStatements({ variables, }) {
         return [`${variables.hasher}.update(${variables.value}.toString());`];
     }
-    snippetDeclarations(features) {
+    snippetDeclarations({ features, }) {
         const snippetDeclarations = [];
         if (features.has("equals")) {
             snippetDeclarations.push(SnippetDeclarations.strictEquals);
         }
         return snippetDeclarations;
     }
+    sparqlWherePatterns(parameters) {
+        return super.sparqlWherePatterns({ ...parameters, ignoreLanguageIn: true });
+    }
     toJsonExpression({ variables, }) {
         return variables.value;
     }
-    propertyFilterRdfResourceValuesExpression({ variables, }) {
-        return variables.resourceValues;
-    }
 }
+__decorate([
+    Memoize()
+], PrimitiveType.prototype, "jsonName", null);
 //# sourceMappingURL=PrimitiveType.js.map

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

@@ -1,31 +1,35 @@
-import type { TsFeature } from "../../enums/index.js";
+import { Maybe } from "purify-ts";
 import type { Import } from "./Import.js";
 import { Type } from "./Type.js";
-export declare class SetType extends Type {
-    readonly itemType: Type;
-    readonly kind = "SetType";
-    private readonly minCount;
+export declare class SetType<ItemTypeT extends Type> extends Type {
+    readonly discriminatorProperty: Maybe<Type.DiscriminatorProperty>;
+    readonly itemType: ItemTypeT;
     private readonly _mutable;
-    constructor({ itemType, minCount, mutable, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
-        itemType: Type;
+    private readonly minCount;
+    readonly kind = "SetType";
+    readonly typeof = "object";
+    constructor({ itemType, minCount, mutable, }: {
+        itemType: ItemTypeT;
         mutable: boolean;
         minCount: number;
     });
     get conversions(): readonly Type.Conversion[];
     get equalsFunction(): string;
-    get jsonName(): string;
+    get graphqlName(): Type.GraphqlName;
+    get jsonName(): Type.JsonName;
     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"]>;
     jsonZodSchema(parameters: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    snippetDeclarations(features: Set<TsFeature>): readonly string[];
-    sparqlConstructTemplateTriples({ context, variables, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-    sparqlWherePatterns({ context, variables, }: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
+    snippetDeclarations(parameters: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
+    sparqlConstructTemplateTriples(parameters: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
-    useImports(features: Set<TsFeature>): readonly Import[];
+    useImports(parameters: Parameters<Type["useImports"]>[0]): readonly Import[];
 }
 //# sourceMappingURL=SetType.d.ts.map

package/dist/generators/ts/SetType.js

@@ -4,18 +4,21 @@ 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 { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
-import { objectInitializer } from "./objectInitializer.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 export class SetType extends Type {
+    discriminatorProperty = Maybe.empty();
     itemType;
-    kind = "SetType";
-    minCount;
     _mutable;
-    constructor({ itemType, minCount, mutable, ...superParameters }) {
-        super(superParameters);
+    minCount;
+    kind = "SetType";
+    typeof = "object";
+    constructor({ itemType, minCount, mutable, }) {
+        super();
         this.itemType = itemType;
         this.minCount = minCount;
         invariant(this.minCount >= 0);
@@ -30,8 +33,11 @@ export class SetType extends Type {
                 sourceTypeName: "undefined",
             });
             conversions.push({
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => `Array.isArray(${value})`,
+                // Defensive copy
+                conversionExpression: (value) => `${value}${this.mutable ? ".concat()" : ""}`,
+                // Array.isArray doesn't narrow correctly
+                // sourceTypeCheckExpression: (value) => `Array.isArray(${value})`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
                 sourceTypeName: `readonly (${this.itemType.name})[]`,
             });
         }
@@ -45,10 +51,17 @@ export class SetType extends Type {
         return conversions;
     }
     get equalsFunction() {
-        return `((left, right) => arrayEquals(left, right, ${this.itemType.equalsFunction}))`;
+        return `((left, right) => ${syntheticNamePrefix}arrayEquals(left, right, ${this.itemType.equalsFunction}))`;
+    }
+    get graphqlName() {
+        return new Type.GraphqlName(`new graphql.GraphQLList(${this.itemType.graphqlName})`);
     }
     get jsonName() {
-        return `readonly (${this.itemType.jsonName})[]`;
+        const name = `readonly (${this.itemType.jsonName})[]`;
+        if (this.minCount === 0) {
+            return new Type.JsonName(name, { optional: true });
+        }
+        return new Type.JsonName(name);
     }
     get mutable() {
         return this._mutable || this.itemType.mutable;
@@ -68,29 +81,35 @@ export class SetType extends Type {
             expression = `purify.NonEmptyList.fromArray(${expression}).unsafeCoerce()`;
         }
         const itemFromJsonExpression = this.itemType.fromJsonExpression({
-            variables: { value: "_item" },
+            variables: { value: "item" },
         });
-        return itemFromJsonExpression === "_item"
+        return itemFromJsonExpression === "item"
             ? expression
-            : `${expression}.map(_item => (${itemFromJsonExpression}))`;
+            : `${expression}.map(item => (${itemFromJsonExpression}))`;
     }
-    fromRdfExpression({ variables, }) {
-        const itemFromRdfExpression = this.itemType.fromRdfExpression({
-            variables: { ...variables, resourceValues: "_item.toValues()" },
-        });
-        if (this._mutable || this.minCount === 0) {
-            return `purify.Either.of([...${variables.resourceValues}.flatMap(_item => ${itemFromRdfExpression}.toMaybe().toList())])`;
+    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 `purify.NonEmptyList.fromArray([...${variables.resourceValues}.flatMap(_item => ${itemFromRdfExpression}.toMaybe().toList())]).toEither(new rdfjsResource.Resource.ValueError(${objectInitializer({ focusResource: variables.resource, message: `\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} is empty\``, predicate: variables.predicate })}))`;
+        chain.push(`map(valuesArray => rdfjsResource.Resource.Values.fromValue({ object: valuesArray , predicate: ${variables.predicate}, subject: ${variables.resource} }))`);
+        return chain.join(".");
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
     }
     hashStatements({ depth, variables, }) {
         return [
-            `for (const _item${depth} of ${variables.value}) { ${this.itemType
+            `for (const item${depth} of ${variables.value}) { ${this.itemType
                 .hashStatements({
                 depth: depth + 1,
                 variables: {
                     hasher: variables.hasher,
-                    value: `_item${depth}`,
+                    value: `item${depth}`,
                 },
             })
                 .join("\n")} }`,
@@ -104,32 +123,32 @@ export class SetType extends Type {
         if (this.minCount > 0) {
             schema = `${schema}.nonempty().min(${this.minCount})`;
         }
+        else {
+            schema = `${schema}.default(() => [])`;
+        }
         return schema;
     }
-    snippetDeclarations(features) {
+    snippetDeclarations(parameters) {
         const snippetDeclarations = this.itemType
-            .snippetDeclarations(features)
+            .snippetDeclarations(parameters)
             .concat();
-        if (features.has("equals")) {
+        if (parameters.features.has("equals")) {
             snippetDeclarations.push(SnippetDeclarations.arrayEquals);
         }
         return snippetDeclarations;
     }
-    sparqlConstructTemplateTriples({ context, variables, }) {
-        switch (context) {
-            case "property":
-                return super.sparqlConstructTemplateTriples({ context, variables });
-            case "type":
-                return this.itemType.sparqlConstructTemplateTriples({
-                    context,
-                    variables,
-                });
+    sparqlConstructTemplateTriples(parameters) {
+        switch (parameters.context) {
+            case "object":
+                return super.sparqlConstructTemplateTriples(parameters);
+            case "subject":
+                return this.itemType.sparqlConstructTemplateTriples(parameters);
         }
     }
-    sparqlWherePatterns({ context, variables, }) {
-        switch (context) {
-            case "property": {
-                const patterns = super.sparqlWherePatterns({ context, variables });
+    sparqlWherePatterns(parameters) {
+        switch (parameters.context) {
+            case "object": {
+                const patterns = this.itemType.sparqlWherePatterns(parameters);
                 if (patterns.length === 0) {
                     return [];
                 }
@@ -137,23 +156,36 @@ export class SetType extends Type {
                     ? patterns
                     : [`{ patterns: [${patterns.join(", ")}], type: "optional" }`];
             }
-            case "type": {
-                return this.itemType.sparqlWherePatterns({ context, variables });
+            case "subject": {
+                throw new Error("should never be called");
+                // return this.itemType.sparqlWherePatterns(parameters);
             }
         }
     }
     toJsonExpression({ variables, }) {
-        return `${variables.value}.map(_item => (${this.itemType.toJsonExpression({ variables: { value: "_item" } })}))`;
+        return `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: "item" } })}))`;
     }
     toRdfExpression({ variables, }) {
-        return `${variables.value}.map((_item) => ${this.itemType.toRdfExpression({
-            variables: { ...variables, value: "_item" },
+        return `${variables.value}.map((item) => ${this.itemType.toRdfExpression({
+            variables: { ...variables, value: "item" },
         })})`;
     }
-    useImports(features) {
-        return this.itemType.useImports(features);
+    useImports(parameters) {
+        return this.itemType.useImports(parameters);
     }
 }
+__decorate([
+    Memoize()
+], SetType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], SetType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], SetType.prototype, "graphqlName", null);
+__decorate([
+    Memoize()
+], SetType.prototype, "jsonName", null);
 __decorate([
     Memoize()
 ], SetType.prototype, "name", null);

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

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