@shaclmate/compiler 2.0.23 → 2.0.24

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,7 +91,7 @@ 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: {
@@ -142,6 +147,7 @@ export declare abstract class Property<TypeT extends Pick<Type, "mutable" | "nam
      */
     abstract sparqlWherePatterns(parameters: {
         variables: {
+            languageIn: 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();`,
         ];
@@ -162,6 +170,7 @@ export class ShaclProperty extends Property {
             allowIgnoreRdfType: true,
             context: "object",
             variables: {
+                languageIn: variables.languageIn,
                 object: `dataFactory.variable!(${objectString})`,
                 predicate: this.predicate,
                 subject: variables.subject,
@@ -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,

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

@@ -22,8 +22,20 @@ export function graphqlTypeVariableStatement() {
                     description: this.comment.map(JSON.stringify).extract(),
                     fields: `() => (${objectInitializer(this.properties.reduce((fields, property) => {
                         property.graphqlField.ifJust((field) => {
-                            const { name: fieldName, ...fieldProps } = field;
-                            fields[fieldName] = objectInitializer(fieldProps);
+                            fields[field.name] = objectInitializer({
+                                args: field.args
+                                    .map((args) => objectInitializer(Object.entries(args).reduce((argObjects, [argName, arg]) => {
+                                    argObjects[argName] = objectInitializer(arg);
+                                    return argObjects;
+                                }, {})))
+                                    .extract(),
+                                description: field.description
+                                    .map(JSON.stringify)
+                                    .extract(),
+                                name: JSON.stringify(field.name),
+                                resolve: field.resolve,
+                                type: field.type,
+                            });
                         });
                         return fields;
                     }, {}))})`,