@shaclmate/compiler 2.0.23 → 3.0.0

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

@@ -1,29 +1,29 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
+import { logger } from "../../../logger.js";
 import { Import } from "../Import.js";
 import { SnippetDeclarations } from "../SnippetDeclarations.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { Property } from "./Property.js";
 export class IdentifierProperty extends Property {
-    classGetAccessorScope;
-    classPropertyDeclarationVisibility;
+    getAccessorScope;
     identifierMintingStrategy;
     identifierPrefixPropertyName;
     override;
+    propertyDeclarationVisibility;
     typeAlias;
     abstract;
-    equalsFunction = `${syntheticNamePrefix}booleanEquals`;
+    equalsFunction = Maybe.of(`${syntheticNamePrefix}booleanEquals`);
     mutable = false;
     recursive = false;
-    constructor({ abstract, classGetAccessorScope, classPropertyDeclarationVisibility, identifierMintingStrategy, identifierPrefixPropertyName, override, typeAlias, ...superParameters }) {
+    constructor({ abstract, getAccessorScope, identifierMintingStrategy, identifierPrefixPropertyName, override, propertyDeclarationVisibility, typeAlias, ...superParameters }) {
         super(superParameters);
         invariant(this.visibility === "public");
         this.abstract = abstract;
-        this.classGetAccessorScope = classGetAccessorScope;
-        this.classPropertyDeclarationVisibility =
-            classPropertyDeclarationVisibility;
+        this.getAccessorScope = getAccessorScope;
+        this.propertyDeclarationVisibility = propertyDeclarationVisibility;
         this.identifierMintingStrategy = identifierMintingStrategy;
         this.identifierPrefixPropertyName = identifierPrefixPropertyName;
         this.override = override;
@@ -39,9 +39,21 @@ export class IdentifierProperty extends Property {
                 typeNames.add(conversion.sourceTypeName);
             }
         }
+        let hasQuestionToken;
+        switch (this.objectType.declarationType) {
+            case "class":
+                hasQuestionToken = this.identifierMintingStrategy.isJust();
+                break;
+            case "interface": {
+                const identifierMintingStrategy = this.identifierMintingStrategy.extract();
+                hasQuestionToken =
+                    typeof identifierMintingStrategy !== "undefined" &&
+                        identifierMintingStrategy !== "sha256";
+                break;
+            }
+        }
         return Maybe.of({
-            hasQuestionToken: this.objectType.declarationType === "class" &&
-                this.identifierMintingStrategy.isJust(),
+            hasQuestionToken,
             isReadonly: true,
             name: this.name,
             type: [...typeNames].sort().join(" | "),
@@ -49,26 +61,23 @@ export class IdentifierProperty extends Property {
     }
     get declarationImports() {
         const imports = this.type.useImports().concat();
-        if (this.objectType.features.has("hash") &&
-            this.objectType.declarationType === "class") {
-            this.identifierMintingStrategy.ifJust((identifierMintingStrategy) => {
-                switch (identifierMintingStrategy) {
-                    case "sha256":
-                        imports.push(Import.SHA256);
-                        break;
-                    case "uuidv4":
-                        imports.push(Import.UUID);
-                        break;
-                }
-            });
-        }
+        this.identifierMintingStrategy.ifJust((identifierMintingStrategy) => {
+            switch (identifierMintingStrategy) {
+                case "sha256":
+                    imports.push(Import.SHA256);
+                    break;
+                case "uuidv4":
+                    imports.push(Import.UUID);
+                    break;
+            }
+        });
         return imports;
     }
     get getAccessorDeclaration() {
-        if (this.classGetAccessorScope.isNothing()) {
+        if (this.getAccessorScope.isNothing()) {
             return Maybe.empty();
         }
-        invariant(this.classGetAccessorScope.unsafeCoerce() === "public");
+        invariant(this.getAccessorScope.unsafeCoerce() === "public");
         if (this.identifierMintingStrategy.isJust()) {
             let memoizeMintedIdentifier;
             let mintIdentifier;
@@ -109,6 +118,8 @@ export class IdentifierProperty extends Property {
     get graphqlField() {
         invariant(this.name.startsWith(syntheticNamePrefix));
         return Maybe.of({
+            args: Maybe.empty(),
+            description: Maybe.empty(),
             name: `_${this.name.substring(syntheticNamePrefix.length)}`,
             resolve: `(source) => ${this.typeAlias}.toString(source.${this.name})`,
             type: this.type.graphqlName.toString(),
@@ -153,9 +164,28 @@ export class IdentifierProperty extends Property {
             invariant(conversion.sourceTypeName !== "undefined");
             conversionBranches.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${lhs} = ${conversion.conversionExpression(variables.parameter)}; }`);
         }
-        if (lhs.startsWith("this._")) {
-            conversionBranches.push(`if (typeof ${variables.parameter} === "undefined") { }`);
-        }
+        this.identifierMintingStrategy.ifJust((identifierMintingStrategy) => {
+            switch (this.objectType.declarationType) {
+                case "class":
+                    conversionBranches.push(`if (typeof ${variables.parameter} === "undefined") { }`);
+                    break;
+                case "interface": {
+                    let mintIdentifier;
+                    switch (identifierMintingStrategy) {
+                        case "blankNode":
+                            mintIdentifier = "dataFactory.blankNode()";
+                            break;
+                        case "sha256":
+                            logger.warn("minting %s identifiers with %s is unsupported", this.objectType.declarationType, identifierMintingStrategy);
+                            return;
+                        case "uuidv4":
+                            mintIdentifier = `dataFactory.namedNode(\`\${${variables.parameters}.${this.identifierPrefixPropertyName} ?? "urn:shaclmate:${this.objectType.discriminatorValue}:"}\${uuid.v4()}\`)`;
+                            break;
+                    }
+                    conversionBranches.push(`if (typeof ${variables.parameter} === "undefined") { ${lhs} = ${mintIdentifier}; }`);
+                }
+            }
+        });
         // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
         conversionBranches.push(`{ ${lhs} = (${variables.parameter}) satisfies never;\n }`);
         statements.push(conversionBranches.join(" else "));
@@ -217,7 +247,7 @@ export class IdentifierProperty extends Property {
             });
         }
         // See note in TypeFactory re: the logic of whether to declare the identifier in the class or not.
-        if (!this.classPropertyDeclarationVisibility.isJust()) {
+        if (!this.propertyDeclarationVisibility.isJust()) {
             return Maybe.empty();
         }
         if (this.identifierMintingStrategy.isJust()) {
@@ -225,7 +255,7 @@ export class IdentifierProperty extends Property {
             return Maybe.of({
                 hasQuestionToken: true,
                 name: `_${this.name}`,
-                scope: this.classPropertyDeclarationVisibility
+                scope: this.propertyDeclarationVisibility
                     .map(Property.visibilityToScope)
                     .unsafeCoerce(),
                 type: `${this.typeAlias}`,

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

@@ -18,6 +18,9 @@ export declare namespace LazyShaclProperty {
         readonly discriminatorProperty: _Type["discriminatorProperty"];
         readonly mutable = false;
         readonly typeof = "object";
+        abstract readonly graphqlArgs: Maybe<Record<string, {
+            type: string;
+        }>>;
         protected readonly resolvedType: ResolvedTypeT;
         protected readonly runtimeClass: {
             readonly name: string;
@@ -34,7 +37,6 @@ export declare namespace LazyShaclProperty {
         get conversions(): readonly _Type.Conversion[];
         get equalsFunction(): string;
         get graphqlName(): _Type.GraphqlName;
-        graphqlResolveExpression({ variables, }: Parameters<_Type["graphqlResolveExpression"]>[0]): string;
         hashStatements({ depth, variables, }: Parameters<_Type["hashStatements"]>[0]): readonly string[];
         get jsonName(): _Type.JsonName;
         jsonUiSchemaElement(parameters: Parameters<_Type["jsonUiSchemaElement"]>[0]): Maybe<string>;
@@ -61,9 +63,20 @@ export declare namespace LazyShaclProperty {
         get conversions(): readonly _Type.Conversion[];
         fromJsonExpression(parameters: Parameters<_Type["fromJsonExpression"]>[0]): string;
         fromRdfExpression(parameters: Parameters<_Type["fromRdfExpression"]>[0]): string;
+        get graphqlArgs(): Maybe<{
+            limit: {
+                type: string;
+            };
+            offset: {
+                type: string;
+            };
+        }>;
+        graphqlResolveExpression({ variables, }: Parameters<_Type["graphqlResolveExpression"]>[0]): string;
     }
     abstract class SingleObjectType<ResolvedTypeT extends Exclude<Type.ResolvedTypeConstraint, SetType<ObjectType | ObjectUnionType>>, StubTypeT extends Exclude<Type.StubTypeConstraint, SetType<ObjectType | ObjectUnionType>>> extends Type<ResolvedTypeT, StubTypeT> {
         fromJsonExpression(parameters: Parameters<_Type["fromJsonExpression"]>[0]): string;
+        get graphqlArgs(): Type<ResolvedTypeT, ObjectUnionType>["graphqlArgs"];
+        graphqlResolveExpression({ variables, }: Parameters<_Type["graphqlResolveExpression"]>[0]): string;
     }
     export class OptionalObjectType<ResolvedTypeT extends OptionType<ObjectType | ObjectUnionType>, StubTypeT extends OptionType<ObjectType | ObjectUnionType>> extends SingleObjectType<ResolvedTypeT, StubTypeT> {
         constructor({ resolvedType, stubType, }: {

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

@@ -7,23 +7,39 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import "ts-morph";
 import { Memoize } from "typescript-memoize";
+import { invariant } from "ts-invariant";
 import { Import } from "../Import.js";
 import { SnippetDeclarations } from "../SnippetDeclarations.js";
 import { Type as _Type } from "../Type.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { ShaclProperty } from "./ShaclProperty.js";
+function stubObjectUnionTypeToResolvedObjectUnionTypeSwitchStatement({ resolvedObjectUnionType, stubObjectUnionType, variables, }) {
+    invariant(resolvedObjectUnionType.memberTypes.length ===
+        stubObjectUnionType.memberTypes.length);
+    const caseBlocks = resolvedObjectUnionType.memberTypes.map((resolvedObjectType, objectTypeI) => {
+        return `${resolvedObjectType.discriminatorPropertyValues.map((discriminatorPropertyValue) => `case "${discriminatorPropertyValue}":`).join("\n")} return ${stubObjectUnionType.memberTypes[objectTypeI].newExpression({ parameters: variables.value })};`;
+    });
+    caseBlocks.push(`default: ${variables.value} satisfies never; throw new Error("unrecognized type");`);
+    return `switch (${variables.value}.${resolvedObjectUnionType.discriminatorProperty.unsafeCoerce().name}) { ${caseBlocks.join("\n")} }`;
+}
 export class LazyShaclProperty extends ShaclProperty {
     mutable = false;
     recursive = false;
     get graphqlField() {
+        const args = this.type.graphqlArgs;
+        const argsVariable = args.isJust() ? "args" : "_args";
         return Maybe.of({
-            description: this.comment.map(JSON.stringify).extract(),
+            args,
+            description: this.comment.map(JSON.stringify),
             name: this.name,
-            resolve: `async (source) => ${this.type.graphqlResolveExpression({ variables: { value: `source.${this.name}` } })}`,
+            resolve: `async (source, ${argsVariable}) => ${this.type.graphqlResolveExpression({ variables: { args: argsVariable, value: `source.${this.name}` } })}`,
             type: this.type.graphqlName.toString(),
         });
     }
 }
+__decorate([
+    Memoize()
+], LazyShaclProperty.prototype, "graphqlField", null);
 (function (LazyShaclProperty) {
     class Type extends _Type {
         discriminatorProperty = Maybe.empty();
@@ -53,9 +69,6 @@ export class LazyShaclProperty extends ShaclProperty {
         get graphqlName() {
             return this.resolvedType.graphqlName;
         }
-        graphqlResolveExpression({ variables, }) {
-            return `(await ${variables.value}.resolve()).unsafeCoerce()`;
-        }
         hashStatements({ depth, variables, }) {
             return this.stubType.hashStatements({
                 depth: depth + 1,
@@ -129,7 +142,17 @@ export class LazyShaclProperty extends ShaclProperty {
             const conversions = super.conversions.concat();
             if (this.stubType.itemType.kind === "ObjectType") {
                 conversions.push({
-                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${value}.map(parameters => ${this.stubType.itemType.newExpression({ parameters: "parameters" })}), resolver: async () => purify.Either.of(${value} as readonly ${this.resolvedType.itemType.name}[]) })`,
+                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${value}.map(object => ${this.stubType.itemType.newExpression({ parameters: "object" })}), resolver: async () => purify.Either.of(${value} as readonly ${this.resolvedType.itemType.name}[]) })`,
+                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+                    sourceTypeName: `readonly ${this.resolvedType.itemType.name}[]`,
+                });
+            }
+            else if (this.resolvedType.itemType.kind === "ObjectUnionType" &&
+                this.stubType.itemType.kind === "ObjectUnionType" &&
+                this.resolvedType.itemType.memberTypes.length ===
+                    this.stubType.itemType.memberTypes.length) {
+                conversions.push({
+                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${value}.map(object => { ${stubObjectUnionTypeToResolvedObjectUnionTypeSwitchStatement({ resolvedObjectUnionType: this.resolvedType.itemType, stubObjectUnionType: this.stubType.itemType, variables: { value: "object" } })} }), resolver: async () => purify.Either.of(${value} as readonly ${this.resolvedType.itemType.name}[]) })`,
                     sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
                     sourceTypeName: `readonly ${this.resolvedType.itemType.name}[]`,
                 });
@@ -146,17 +169,39 @@ export class LazyShaclProperty extends ShaclProperty {
         }
         fromRdfExpression(parameters) {
             const { variables } = parameters;
-            return `${this.stubType.fromRdfExpression(parameters)}.map(${this.runtimeClass.stubPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}, resolver: (identifiers) => ${variables.objectSet}.${this.resolvedType.itemType.objectSetMethodNames.objects}({ where: { identifiers, type: "identifiers" }}) }))`;
+            return `${this.stubType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.stubPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}, resolver: (identifiers) => ${variables.objectSet}.${this.resolvedType.itemType.objectSetMethodNames.objects}({ where: { identifiers, type: "identifiers" }}) })))`;
+        }
+        get graphqlArgs() {
+            return Maybe.of({
+                limit: {
+                    type: "graphql.GraphQLInt",
+                },
+                offset: {
+                    type: "graphql.GraphQLInt",
+                },
+            });
+        }
+        graphqlResolveExpression({ variables, }) {
+            return `(await ${variables.value}.resolve({ limit: ${variables.args}.limit, offset: ${variables.args}.offset })).unsafeCoerce()`;
         }
     }
     __decorate([
         Memoize()
     ], ObjectSetType.prototype, "conversions", null);
+    __decorate([
+        Memoize()
+    ], ObjectSetType.prototype, "graphqlArgs", null);
     LazyShaclProperty.ObjectSetType = ObjectSetType;
     class SingleObjectType extends Type {
         fromJsonExpression(parameters) {
             return `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${this.stubType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(purify.Left(new Error(\`unable to resolve identifier \${rdfjsResource.Resource.Identifier.toString(identifier)} deserialized from JSON\`))) })`;
         }
+        get graphqlArgs() {
+            return Maybe.empty();
+        }
+        graphqlResolveExpression({ variables, }) {
+            return `(await ${variables.value}.resolve()).unsafeCoerce()`;
+        }
     }
     class OptionalObjectType extends SingleObjectType {
         constructor({ resolvedType, stubType, }) {
@@ -175,11 +220,30 @@ export class LazyShaclProperty extends ShaclProperty {
             const conversions = super.conversions.concat();
             if (this.stubType.itemType.kind === "ObjectType") {
                 conversions.push({
-                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${value}.map(parameters => ${this.stubType.itemType.newExpression({ parameters: "parameters" })}), resolver: async () => purify.Either.of((${value} as purify.Maybe<${this.resolvedType.itemType.name}>).unsafeCoerce()) })`,
+                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${value}.map(object => ${this.stubType.itemType.newExpression({ parameters: "object" })}), resolver: async () => purify.Either.of((${value} as purify.Maybe<${this.resolvedType.itemType.name}>).unsafeCoerce()) })`,
                     sourceTypeCheckExpression: (value) => `purify.Maybe.isMaybe(${value})`,
                     sourceTypeName: `purify.Maybe<${this.resolvedType.itemType.name}>`,
                 }, {
                     conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: purify.Maybe.of(${this.stubType.itemType.newExpression({ parameters: value })}), resolver: async () => purify.Either.of(${value} as ${this.resolvedType.itemType.name}) })`,
+                    // Don't check instanceof value since the ObjectUnionType may be an interface
+                    // Rely on the fact that this will be the last type check on an object
+                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+                    sourceTypeName: this.resolvedType.itemType.name,
+                });
+            }
+            else if (this.resolvedType.itemType.kind === "ObjectUnionType" &&
+                this.stubType.itemType.kind === "ObjectUnionType" &&
+                this.resolvedType.itemType.memberTypes.length ===
+                    this.stubType.itemType.memberTypes.length) {
+                const maybeMap = `.map(object => { ${stubObjectUnionTypeToResolvedObjectUnionTypeSwitchStatement({ resolvedObjectUnionType: this.resolvedType.itemType, stubObjectUnionType: this.stubType.itemType, variables: { value: "object" } })} })`;
+                conversions.push({
+                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${value}${maybeMap}, resolver: async () => purify.Either.of((${value} as purify.Maybe<${this.resolvedType.itemType.name}>).unsafeCoerce()) })`,
+                    sourceTypeCheckExpression: (value) => `purify.Maybe.isMaybe(${value})`,
+                    sourceTypeName: `purify.Maybe<${this.resolvedType.itemType.name}>`,
+                }, {
+                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: purify.Maybe.of(${value})${maybeMap}, resolver: async () => purify.Either.of(${value} as ${this.resolvedType.itemType.name}) })`,
+                    // Don't check instanceof value since the ObjectUnionType may be an interface
+                    // Rely on the fact that this will be the last type check on an object
                     sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
                     sourceTypeName: this.resolvedType.itemType.name,
                 });
@@ -193,7 +257,7 @@ export class LazyShaclProperty extends ShaclProperty {
         }
         fromRdfExpression(parameters) {
             const { variables } = parameters;
-            return `${this.stubType.fromRdfExpression(parameters)}.map(${this.runtimeClass.stubPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}, resolver: (identifier) => ${variables.objectSet}.${this.resolvedType.itemType.objectSetMethodNames.object}(identifier) }))`;
+            return `${this.stubType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.stubPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}, resolver: (identifier) => ${variables.objectSet}.${this.resolvedType.itemType.objectSetMethodNames.object}(identifier) })))`;
         }
         graphqlResolveExpression(parameters) {
             return `${super.graphqlResolveExpression(parameters)}.extractNullable()`;
@@ -221,7 +285,21 @@ export class LazyShaclProperty extends ShaclProperty {
             if (this.stubType.kind === "ObjectType") {
                 conversions.push({
                     conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${this.stubType.newExpression({ parameters: value })}, resolver: async () => purify.Either.of(${value} as ${this.resolvedType.name}) })`,
-                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof ${this.resolvedType.name}`,
+                    // Don't check instanceof value since the ObjectType may be an interface
+                    // Rely on the fact that this will be the last type check on an object
+                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+                    sourceTypeName: this.resolvedType.name,
+                });
+            }
+            else if (this.resolvedType.kind === "ObjectUnionType" &&
+                this.stubType.kind === "ObjectUnionType" &&
+                this.resolvedType.memberTypes.length ===
+                    this.stubType.memberTypes.length) {
+                conversions.push({
+                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ((object: ${this.resolvedType.name}) => { ${stubObjectUnionTypeToResolvedObjectUnionTypeSwitchStatement({ resolvedObjectUnionType: this.resolvedType, stubObjectUnionType: this.stubType, variables: { value: "object" } })} })(${value}), resolver: async () => purify.Either.of(${value} as ${this.resolvedType.name}) })`,
+                    // Don't check instanceof value since the ObjectUnionType may be an interface
+                    // Rely on the fact that this will be the last type check on an object
+                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
                     sourceTypeName: this.resolvedType.name,
                 });
             }
@@ -229,7 +307,7 @@ export class LazyShaclProperty extends ShaclProperty {
         }
         fromRdfExpression(parameters) {
             const { variables } = parameters;
-            return `${this.stubType.fromRdfExpression(parameters)}.map(${this.runtimeClass.stubPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}, resolver: (identifier) => ${variables.objectSet}.${this.resolvedType.objectSetMethodNames.object}(identifier) }))`;
+            return `${this.stubType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.stubPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}, resolver: (identifier) => ${variables.objectSet}.${this.resolvedType.objectSetMethodNames.object}(identifier) })))`;
         }
     }
     LazyShaclProperty.RequiredObjectType = RequiredObjectType;

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

@@ -12,7 +12,7 @@ export declare abstract class Property<TypeT extends Pick<Type, "mutable" | "nam
     /**
      * Function declaration that takes two values of the property and compares them, returning an $EqualsResult.
      */
-    abstract readonly equalsFunction: string;
+    abstract readonly equalsFunction: Maybe<string>;
     /**
      * Optional get accessor to include in a class declaration of the object type.
      */
@@ -21,8 +21,12 @@ export declare abstract class Property<TypeT extends Pick<Type, "mutable" | "nam
      * GraphQL.js field definition.
      */
     abstract readonly graphqlField: Maybe<{
+        args: Maybe<Record<string, {
+            type: string;
+        }>>;
+        description: Maybe<string>;
         name: string;
-        description?: string;
+        resolve: string;
         type: string;
     }>;
     /**
@@ -75,6 +79,7 @@ export declare abstract class Property<TypeT extends Pick<Type, "mutable" | "nam
     abstract constructorStatements(parameters: {
         variables: {
             parameter: string;
+            parameters: string;
         };
     }): readonly string[];
     /**
@@ -86,13 +91,13 @@ export declare abstract class Property<TypeT extends Pick<Type, "mutable" | "nam
         };
     }): readonly string[];
     /**
-     * Statements to deserialize RDF for this property to a typed value of the property.
+     * Statements to deserialize this property on the given rdfjsResource.Resource to a typed value of the property.
      */
     abstract fromRdfStatements(parameters: {
         variables: {
             context: string;
-            languageIn: string;
             objectSet: string;
+            preferredLanguages: string;
             resource: string;
         };
     }): readonly string[];
@@ -142,6 +147,7 @@ export declare abstract class Property<TypeT extends Pick<Type, "mutable" | "nam
      */
     abstract sparqlWherePatterns(parameters: {
         variables: {
+            preferredLanguages: string;
             subject: string;
             variablePrefix: string;
         };

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

@@ -15,7 +15,7 @@ export declare abstract class ShaclProperty<TypeT extends Type> extends Property
         label: Maybe<string>;
         path: rdfjs.NamedNode;
     } & ConstructorParameters<typeof Property<TypeT>>[0]);
-    get equalsFunction(): string;
+    get equalsFunction(): Maybe<string>;
     get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     constructorStatements({ variables, }: Parameters<Property<TypeT>["constructorStatements"]>[0]): readonly string[];
     fromJsonStatements({ variables, }: Parameters<Property<TypeT>["fromJsonStatements"]>[0]): readonly string[];

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

@@ -23,7 +23,7 @@ export class ShaclProperty extends Property {
         this.path = path;
     }
     get equalsFunction() {
-        return this.type.equalsFunction;
+        return Maybe.of(this.type.equalsFunction);
     }
     get constructorParametersPropertySignature() {
         let hasQuestionToken = false;
@@ -137,8 +137,16 @@ export class ShaclProperty extends Property {
         // Assume the property has the correct range and ignore the object's RDF type.
         // This also accommodates the case where the object of a property is a dangling identifier that's not the
         // subject of any statements.
+        const typeFromRdfExpression = this.type.fromRdfExpression({
+            variables: {
+                ...variables,
+                ignoreRdfType: true,
+                predicate: this.predicate,
+                resourceValues: `purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(${variables.resource}.values(${syntheticNamePrefix}properties.${this.name}["identifier"], { unique: true }))`,
+            },
+        });
         return [
-            `const _${this.name}Either: purify.Either<Error, ${this.type.name}> = ${this.type.fromRdfExpression({ variables: { ...variables, ignoreRdfType: true, predicate: this.predicate, resourceValues: `${variables.resource}.values(${syntheticNamePrefix}properties.${this.name}["identifier"], { unique: true })` } })};`,
+            `const _${this.name}Either: purify.Either<Error, ${this.type.name}> = ${typeFromRdfExpression}.chain(values => values.head());`,
             `if (_${this.name}Either.isLeft()) { return _${this.name}Either; }`,
             `const ${this.name} = _${this.name}Either.unsafeCoerce();`,
         ];
@@ -164,6 +172,7 @@ export class ShaclProperty extends Property {
             variables: {
                 object: `dataFactory.variable!(${objectString})`,
                 predicate: this.predicate,
+                preferredLanguages: variables.preferredLanguages,
                 subject: variables.subject,
                 variablePrefix: objectString,
             },
@@ -190,6 +199,9 @@ export class ShaclProperty extends Property {
         return `${this.objectType.staticModuleName}.${syntheticNamePrefix}properties.${this.name}["identifier"]`;
     }
 }
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
 ], ShaclProperty.prototype, "constructorParametersPropertySignature", null);

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

@@ -7,7 +7,7 @@ export declare class TypeDiscriminatorProperty extends Property<TypeDiscriminato
     private readonly override;
     readonly constructorParametersPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
     readonly declarationImports: readonly Import[];
-    readonly equalsFunction = "$strictEquals";
+    readonly equalsFunction: Maybe<string>;
     readonly getAccessorDeclaration: Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
     readonly graphqlField: Property<TypeDiscriminatorProperty.Type>["graphqlField"];
     readonly initializer: string;

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

@@ -15,7 +15,7 @@ export class TypeDiscriminatorProperty extends Property {
     override;
     constructorParametersPropertySignature = Maybe.empty();
     declarationImports = [];
-    equalsFunction = `${syntheticNamePrefix}strictEquals`;
+    equalsFunction = Maybe.of(`${syntheticNamePrefix}strictEquals`);
     getAccessorDeclaration = Maybe.empty();
     graphqlField = Maybe.empty();
     initializer;

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

@@ -7,22 +7,19 @@ import { hashFunctionOrMethodDeclarations } from "./hashFunctionOrMethodDeclarat
 import { toJsonFunctionOrMethodDeclaration } from "./toJsonFunctionOrMethodDeclaration.js";
 import { toRdfFunctionOrMethodDeclaration } from "./toRdfFunctionOrMethodDeclaration.js";
 function constructorDeclaration() {
-    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersPropertySignature
-        .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
-        .toList());
-    let parametersType;
+    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersPropertySignature.toList());
+    const parametersType = [];
     if (parametersPropertySignatures.length > 0) {
-        parametersType = `{ ${parametersPropertySignatures.join(", ")} }`;
-    }
-    else {
-        parametersType = "";
+        parametersType.push(`{ ${parametersPropertySignatures
+            .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
+            .join(", ")} }`);
     }
     if (this.parentObjectTypes.length > 0) {
         // Pass up parameters
-        parametersType = `${parametersType}${parametersType.length > 0 ? " & " : ""}ConstructorParameters<typeof ${this.parentObjectTypes[0].name}>[0]`;
+        parametersType.push(`ConstructorParameters<typeof ${this.parentObjectTypes[0].name}>[0]`);
     }
     if (parametersType.length === 0) {
-        parametersType = "object";
+        parametersType.push("object");
     }
     const statements = [];
     if (this.parentObjectTypes.length > 0) {
@@ -30,8 +27,14 @@ function constructorDeclaration() {
         // of trying to sense whether we need to or not.
         statements.push("super(parameters);");
     }
+    const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
+        parametersPropertySignatures.every((propertySignature) => !!propertySignature.hasQuestionToken);
+    const parametersVariable = `parameters${parametersHasQuestionToken ? "?" : ""}`;
     const propertyStatements = this.properties.flatMap((property) => property.constructorStatements({
-        variables: { parameter: `parameters.${property.name}` },
+        variables: {
+            parameter: `${parametersVariable}.${property.name}`,
+            parameters: parametersVariable,
+        },
     }));
     statements.push(...propertyStatements);
     return {
@@ -40,8 +43,9 @@ function constructorDeclaration() {
             : undefined,
         parameters: [
             {
+                hasQuestionToken: parametersHasQuestionToken,
                 name: statements.length > 0 ? "parameters" : "_parameters",
-                type: parametersType,
+                type: parametersType.join(" & "),
             },
         ],
         statements,

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

@@ -12,23 +12,34 @@ export function createFunctionDeclaration() {
     if (this.extern) {
         return Maybe.empty();
     }
-    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersPropertySignature
-        .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
-        .toList());
-    // Should always have at least an identifier
-    invariant(parametersPropertySignatures.length > 0);
-    const parametersType = [`{ ${parametersPropertySignatures.join(", ")} }`]
-        .concat(this.parentObjectTypes.map((parentObjectType) => `Parameters<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}create>[0]`))
-        .join(" & ");
+    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersPropertySignature.toList());
+    const parametersType = [];
+    if (parametersPropertySignatures.length > 0) {
+        parametersType.push(`{ ${parametersPropertySignatures
+            .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
+            .join(", ")} }`);
+    }
+    for (const parentObjectType of this.parentObjectTypes) {
+        parametersType.push(`Parameters<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}create>[0]`);
+    }
+    if (parametersType.length === 0) {
+        parametersType.push("object");
+    }
     const propertyInitializers = [];
     const omitPropertyNames = [];
     const propertyStatements = [];
     for (const parentObjectType of this.parentObjectTypes) {
         propertyInitializers.push(`...${parentObjectType.staticModuleName}.${syntheticNamePrefix}create(parameters)`);
     }
+    const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
+        parametersPropertySignatures.every((propertySignature) => !!propertySignature.hasQuestionToken);
+    const parametersVariable = `parameters${parametersHasQuestionToken ? "?" : ""}`;
     for (const property of this.properties) {
         const thisPropertyStatements = property.constructorStatements({
-            variables: { parameter: `parameters.${property.name}` },
+            variables: {
+                parameter: `${parametersVariable}.${property.name}`,
+                parameters: parametersVariable,
+            },
         });
         if (thisPropertyStatements.length > 0) {
             propertyInitializers.push(property.name);
@@ -46,8 +57,9 @@ export function createFunctionDeclaration() {
         name: `${syntheticNamePrefix}create`,
         parameters: [
             {
+                hasQuestionToken: parametersHasQuestionToken,
                 name: "parameters",
-                type: parametersType,
+                type: parametersType.join(" & "),
             },
         ],
         returnType: omitPropertyNames.length === 0

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

@@ -38,7 +38,9 @@ export function equalsFunctionOrMethodDeclaration() {
         }
     }
     for (const property of this.ownProperties) {
-        chain.push(`(${property.equalsFunction})(${leftVariable}.${property.name}, ${rightVariable}.${property.name}).mapLeft(propertyValuesUnequal => ({ left: ${leftVariable}, right: ${rightVariable}, propertyName: "${property.name}", propertyValuesUnequal, type: "Property" as const }))`);
+        property.equalsFunction.ifJust((equalsFunction) => {
+            chain.push(`(${equalsFunction})(${leftVariable}.${property.name}, ${rightVariable}.${property.name}).mapLeft(propertyValuesUnequal => ({ left: ${leftVariable}, right: ${rightVariable}, propertyName: "${property.name}", propertyValuesUnequal, type: "Property" as const }))`);
+        });
     }
     return Maybe.of({
         hasOverrideKeyword,