HotChocolate Patching Types #4845

PascalSenn · 2020-01-04T20:50:54Z

PascalSenn
Jan 4, 2020
Maintainer

HotChocolate.Types.Patch

This proposal is very Work In Progress

Introduction

A common thing of every application is partial updates of objects. Using GraphQL you can only create partial updates when using optional input types. In the mutation resolver you have to check the input type for all attribute that are set and then do the partial updates. This behavior is very generic and can occur many times in different places in the application.

Proposal

A new input type created for this use case: PatchInputType<T>. This abstraction allows to configure input types that offer patching abilities provided by the framework.

How it could work shows the example below:

public class Foo {
    public Guid Id {get;set;}
    public string Bar {get;set;}
}

public class FooPatchInputType : PatchInputType<Foo>
{
  protected override Configure(IPatchInputTypeDescirptor<Foo> descriptor) {
     descirptor.Field(x => x.Id);
     descirptor.Patch(x => x.Bar);
  }
}

public class FooResolvers {
  public Task<foo> PatchFoo([Service] MyContextDB db, IResolverContext context)
   {
       IPatch<Foo> patch = context.Argument<IPatch<Foo>>("input");
       Guid id = patch.Get(x => x.Id);
       var foo = db.Foos.SingleOrDefault(b => b.Id == id);
       if (foo != null)
       {
           patch.ApplyTo(foo);
           db.SaveChanges();
       }
       return foo;
   }
}

Patching scalars

The easiest thing to patch are scalars. Patching scalars just replace the scalar.

public class Foo
{
     public Guid Id {get;set;}
     public string Bar {get;set;}
}

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": "Before",
  "Baz": "Before"
}

mutation {
  patchFoo(
    input: { id: "11d8ee94-f258-4c44-8516-4806437cd9c8", bar: "After" }
  ) {
    id
    bar
  }
}

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": "After",
  "Baz": "Before"
}

Patching lists

List could be patched in two different ways

public class Foo {
    public Guid Id {get;set;}
    public string[] Bar {get;set;}
    public string[] Baz {get;set;}
}

public class FooPatchInputType : PatchInputType<Foo>
{
  protected override Configure(IPatchInputTypeDescirptor<Foo> descriptor) {
     descirptor.Field(x => x.Id);
     descirptor.Patch(x => x.Bar);
     descirptor.PatchList(x => x.Bar)
             .BindOperationExplicitly()
                           .AllowSet().And()
                           .AllowAppend().And()
                           .AllowRemoveIndex().And()
                           .AllowReplaceIndex(); //maybe more
  }
}

`Patch(x => x.List)`

This would work the same as scalars do and just replace the list. The benefit of this approach is that input object and output object have the same structure.

`PatchList(x => x.List)`

This method of list patching would allow different ways of patching.

Examples:

`set`

Could potentially be omitted in favor of `Patch(x => x.List)

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": ["Before", "Before", "Before"]
}

mutation {
  patchFoo(
    input: {
      id: "11d8ee94-f258-4c44-8516-4806437cd9c8"
      bar_patch: { set: ["After"] }
    }
  ) {
    id
    bar
  }
}

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": [ "After" ]
}

`append`

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": ["Before","Before","Before"]
}

mutation {
  patchFoo(
    input: {
      id: "11d8ee94-f258-4c44-8516-4806437cd9c8"
      bar_patch: { append: ["After"] }
    }
  ) {
    id
    bar
  }
}

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": ["Before","Before","Before", "After"]
}

`removeIndex`

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": ["Before0","Before1","Before2"],
}

mutation {
  patchFoo(
    input: {
      id: "11d8ee94-f258-4c44-8516-4806437cd9c8"
      bar_patch: { removeIndex: [1, 2] }
    }
  ) {
    id
    bar
  }
}

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": ["Before0"]
}

`replaceIndex`

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": ["Before0","Before1","Before2"]
}

mutation {
  patchFoo(
    input: {
      id: "11d8ee94-f258-4c44-8516-4806437cd9c8"
      bar_patch: { replaceIndex: [{ index: 1, value: "After1" }] }
    }
  ) {
    id
    bar
  }
}

{
   "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
    "Bar": ["Before0","After1","Before2"]
}

Patching objects

Objects can either be set or patched:

public class Foo {
    public Guid Id {get;set;}
    public Bar Bar {get;set;}
    public Bar Baz {get;set;}
}

public class Bar {
    public Guid BarId {get;set;}
    public string Qux {get;set;}
    public string Quux {get;set}
}

public class FooPatchInputType : PatchInputType<Foo>
{
  protected override Configure(IPatchInputTypeDescirptor<Foo> descriptor) {
     descirptor.Field(x => x.Id);
     descirptor.Patch(x => x.Bar);
     descirptor.PatchObject(x => x.Baz);
  }
}

`Patch(x => x.Object)`

This would work the same as scalars do and just replace the list. The benefit of this approach is that input object and output object have the same structure.

`PatchObject(x => x.Object)`

This method allows patching of nested objects

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": {
    "BarId": "474cd1c7-928e-45fb-ad68-2468a62580a7"
    "Qux": "Before",
    "Quux": "Before"
  }
}

mutation {
  patchFoo(
    input: {
      id: "11d8ee94-f258-4c44-8516-4806437cd9c8"
      bar_patch: { qux: "After" }
    }
  ) {
    id
    bar {
      barId
      qux
      quux
    }
  }
}

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": {
    "BarId": "474cd1c7-928e-45fb-ad68-2468a62580a7",
    "Qux": "After",
    "Quux": "Before",
  }
}

Patching of Object Arrays

Patching of object arrays can be done in the same ways as arrays.

public class Foo {
    public Guid Id {get;set;}
    public Bar[] Bar {get;set;}
    public Bar[] Baz {get;set;}
}

public class Bar {
    public Guid BarId {get;set;}
    public string Qux {get;set;}
    public string Quux {get;set}
}


public class FooPatchInputType : PatchInputType<Foo>
{
  protected override Configure(IPatchInputTypeDescirptor<Foo> descriptor) {
     descirptor.Field(x => x.Id);
     descirptor.Patch(x => x.Bar);
     descirptor.PatchList(x => x.Bar)
             .BindOperationExplicitly()
                           .AllowSet().And()
                           .AllowAppend().And()
                           .AllowRemoveIndex().And()
                           .AllowReplaceIndex().And() //Basically the same scalar arrays
                           .AllowPatchAll()
                           .AllowRemoveById(x => x.BarId).And()
                           .AllowReplaceById<InputObjectType<Foo>>(x => x.BarId).And()
                           .AllowPatchById(x => x.BarId);
  }
}

`Patch(x => x.ObjectList)`

This would work the same as scalars do and just replace the list. The benefit of this approach is that input object and output object have the same structure.

`PatchList(x => x.ObjectList)`

`set`

Could potentially be omitted in favor of Patch(x => x.List) See Scalar Listset`

`append`

See Scalar List append

`removeIndex`

See Scalar List removeIndex

`replaceIndex`

See Scalar List replaceIndex

`allowPatchAll`

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": [
    {
      "BarId": "474cd1c7-928e-45fb-ad68-2468a62580a7",
      "Qux": "Before",
      "Quux": "Before"
    },
    {
      "BarId": "6b5ce7a2-33c9-4f6c-9126-d9aae241ea8b",
      "Qux": "Before",
      "Quux": "Before"
    }
  ]
}

mutation {
  patchFoo(
    input: {
      id: "11d8ee94-f258-4c44-8516-4806437cd9c8"
      bar_patch: { patchAll: [{ patch: { qux: "After" } }] }
    }
  ) {
    id
    bar {
      barId
      qux
      quux
    }
  }
}

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": [
    {
      "BarId": "474cd1c7-928e-45fb-ad68-2468a62580a7",
      "Qux": "After",
      "Quux": "Before"
    },
    {
      "BarId": "6b5ce7a2-33c9-4f6c-9126-d9aae241ea8b",
      "Qux": "After",
      "Quux": "Before"
    }
  ]
}

`removeById`

⚠ cannot be bound implicitly!

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": [
    {
      "BarId": "474cd1c7-928e-45fb-ad68-2468a62580a7",
      "Qux": "Before",
      "Quux": "Before"
    },
    {
      "BarId": "6b5ce7a2-33c9-4f6c-9126-d9aae241ea8b",
      "Qux": "Before",
      "Quux": "Before"
    }
  ]
}

mutation {
  patchFoo(
    input: {
      id: "11d8ee94-f258-4c44-8516-4806437cd9c8"
      bar_patch: { removeById: ["6b5ce7a2-33c9-4f6c-9126-d9aae241ea8b"] }
    }
  ) {
    id
    bar {
      barId
      qux
      quux
    }
  }
}

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": [
    {
      "BarId": "474cd1c7-928e-45fb-ad68-2468a62580a7",
      "Qux": "Before",
      "Quux": "Before"
    }
  ]
}

`replaceById`

⚠ cannot be bound implicitly!

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": [
    {
      "BarId": "474cd1c7-928e-45fb-ad68-2468a62580a7",
      "Qux": "Before",
      "Quux": "Before"
    },
    {
      "BarId": "6b5ce7a2-33c9-4f6c-9126-d9aae241ea8b",
      "Qux": "Before",
      "Quux": "Before"
    }
  ]
}

mutation {
  patchFoo(
    input: {
      id: "11d8ee94-f258-4c44-8516-4806437cd9c8"
      bar_patch: {
        replaceById: [
          {
            id: "6b5ce7a2-33c9-4f6c-9126-d9aae241ea8b"
            value: {
              barId: "2a97bee4-7244-45d4-a9c1-eb727c8008ef"
              qux: "After"
              quux: "After"
            }
          }
        ]
      }
    }
  ) {
    id
    bar {
      barId
      qux
      quux
    }
  }
}

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": [
    {
      "BarId": "474cd1c7-928e-45fb-ad68-2468a62580a7",
      "Qux": "Before",
      "Quux": "Before"
    },
    {
      "BarId": "2a97bee4-7244-45d4-a9c1-eb727c8008ef",
      "Qux": "After",
      "Quux": "After"
    }
  ]
}

`patchById`

⚠ cannot be bound implicitly!

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": [
    {
      "BarId": "474cd1c7-928e-45fb-ad68-2468a62580a7",
      "Qux": "Before",
      "Quux": "Before"
    },
    {
      "BarId": "6b5ce7a2-33c9-4f6c-9126-d9aae241ea8b",
      "Qux": "Before",
      "Quux": "Before"
    }
  ]
}

mutation {
  patchFoo(
    input: {
      id: "11d8ee94-f258-4c44-8516-4806437cd9c8"
      bar_patch: {
        patchById: [
          {
            id: "474cd1c7-928e-45fb-ad68-2468a62580a7"
            patch: { qux: "After" }
          }
          {
            id: "6b5ce7a2-33c9-4f6c-9126-d9aae241ea8b"
            patch: { quux: "After" }
          }
        ]
      }
    }
  ) {
    id
    bar {
      barId
      qux
      quux
    }
  }
}

{
  "Id": "11d8ee94-f258-4c44-8516-4806437cd9c8",
  "Bar": [
    {
      "BarId": "474cd1c7-928e-45fb-ad68-2468a62580a7",
      "Qux": "After",
      "Quux": "Before"
    },
    {
      "BarId": "6b5ce7a2-33c9-4f6c-9126-d9aae241ea8b",
      "Qux": "Before",
      "Quux": "After"
    }
  ]
}

Patching Customization

Very early idea, really ;)

What would an API be without customization? A framework is always limited.
It will work for 80% of the cases but unfortunately the feature we need is in the other 20%.
The Pareto Principal and Murphy's Law will strike eventually
If we provide this patching feature, it should really be able to handle all possible ways of patching in some way.

A few ideas are listed below:

Predicate

public class Foo {
    public Guid Id {get;set;}
    public int Bar {get;set;}
}

public delegate void PatchingResolver<TObject>(TObject source, object value) => set(value);

public class FooPatchInputType : PatchInputType<Foo>
{
  protected override Configure(IPatchInputTypeDescirptor<Foo> descriptor) {
     descirptor.Field(x => x.Id);
     descirptor.Patch("multiplyBarBy").Type<IntType>().Resolver((source, value) => source.Bar = (source.Bar*(int)value)));
  }
}

Predicate with get and set

public class Foo {
    public Guid Id {get;set;}
    public int Bar {get;set;}
}

public delegtate void PatchingResolver<TObject, TValue>(TObject source, TValue value, Func<TValue> get, Action<TValue> set) => set(get()*value)

public class FooPatchInputType : PatchInputType<Foo>
{
  protected override Configure(IPatchInputTypeDescirptor<Foo> descriptor) {
     descirptor.Field(x => x.Id);
     descirptor.Patch("multiplyBarBy").Type<IntType>().Resolver((source, value, get, set) => set(value*get())));
  }
}

IPatchingContext

⚠ would be really GC heavy
This is probably not the way to go but would allow similar resolver features like the type resolvers.

public class Foo {
    public Guid Id {get;set;}
    public int Bar {get;set;}
}

public class FooPatchInputType : PatchInputType<Foo>
{
  protected override Configure(IPatchInputTypeDescirptor<Foo> descriptor) {
     descirptor.Field(x => x.Id);
     descirptor.Patch("multiplyBarBy").Property( x => x.Bar).Resolver(x => x.Set(x.Get()*x.Value()));
  }
}

Further Ideas

Connect

A way to create realtions between objects. For example, having a User and connect it with a friend

mutation {
  patchUser(
    input: {
      id: "11d8ee94-f258-4c44-8516-4806437cd9c8"
      friend_patch: { connect: { id: "474cd1c7-928e-45fb-ad68-2468a62580a7" } }
    }
  ) {
    id
    name
    friend {
      name
    }
  }
}

Object List `AllowWhereXY`

A way to create realtions between objects. For example, having a User and connect it with a friend

mutation {
  patchFoo(
    input: {
      bars: { where: { name_startsWith: "John" }, value: { name: "Foo" } }
    }
  ) {
    id
    name
    bars {
      name
    }
  }
}

How others did it

Prisma

# Update
mutation {
  updateUser(
    data: { email: "[email protected]", name: "Zeus2" }
    where: { email: "[email protected]" }
  ) {
    id
    name
  }
}
# Upsert
mutation {
  upsertUser(
    where: { email: "[email protected]" }
    create: { email: "[email protected]", age: 42, name: "Zeus" }
    update: { name: "Another Zeus" }
  ) {
    name
  }
}

# Create a post and connect it to an author
mutation {
  createPost(
    data: {
      title: "This is a draft"
      published: false
      author: { connect: { email: "[email protected]" } }
    }
  ) {
    id
    author {
      name
    }
  }
}

set: Override the existing list with an entirely new list.
push (coming soon): Add one or more elements anywhere in the list.
pop (coming soon): Remove one or more elements from the beginning or the end of the list.
remove (coming soon): Remove all elements from the list that match a given filter.

mutation {
  updateUser(
    where: { id: "cjd4lfdyww0h00144zst9alur" }
    data: { scores: { set: 1 } }
  ) {
    id
  }
}

Hasura

# a different concept so here the schema first
update_article (
  _inc: article_inc_input
  _set: article_set_input
  where: article_bool_exp!
): article_mutation_response

# response of any mutation on the table "article"
type article_mutation_response {
  # number of affected rows by the mutation
  affected_rows: Int!
  #data of the affected rows by the mutation
  returning: [article!]!
}

mutation update_article {
  update_article(
    where: {id: {_eq: 3}},
    _set: {
      title: "lorem ipsum",
      content: "dolor sit amet",
      rating: 2
    }
  ) {
    affected_rows
    returning {
      id
      title
      content
      rating
    }
  }
}
#You can increment an int column with a given value using the _inc operator.
mutation update_likes {
  update_article(
    where: {id: {_eq: 1}},
    _inc: {likes: 2}  # initial value: 1
  ) {
    affected_rows
    returning {
      id
      likes
    }
  }
}

The currently available jsonb operators are:

Operator	Postgres equivalent	Function
_append	`
_prepend	`
_delete_key	`-`	delete top-level key from jsonb column
_delete_elem	`-`	delete array element from jsonb column
_delete_at_path	`#-`	delete element at a path from jsonb column

mutation update_extra_info($value: jsonb) {
  update_article(
    where: {id: {_eq: 1}},
    _prepend: {extra_info: $value}  # initial value "{"key": "value", "key1": "value1"}"
  ) {
    affected_rows
    returning {
      id
      extra_info
    }
  }
}

GraphCMS

# Updating Content
mutation {
  updateBlogPost(
    data: {
      authorName: "Jane Smith"
      title: "The Pros and Woes of a Serverless Backend"
      coverImage: "serverless_illustration.png"
      createdAt: "28-12-2018 17:54"
      slug: "serverless-backend"
    }
    where: { slug: "pros-and-cons-serverless-backend" }
  ) {
    id
    title
    createdAt
    slug
  }
}
# Upserting Content
mutation {
  upsertBlogPost(
    where: { email: "[email protected]" }
    create: {
      email: "[email protected]"
      authorName: "Jane Smith"
      title: "The Pros and Woes of a Serverless Backend"
      coverImage: "serverless_illustration.png"
      createdAt: "28-12-2018 17:54"
      slug: "serverless-backend"
    }
    update: { coverImage: "decentralized.png" }
  ) {
    id
    title
    createdAt
    slug
  }
}

set - Override the existing list with an entirely new list.

mutation {
  createBlogPost(data: { tags: { set: ["Serverless", "Backend Development"] } })
  id
}

Gatsby

no mutation support

allmightyse · 2021-02-03T10:32:50Z

allmightyse
Feb 3, 2021

@michaelstaib is there any planned time when this will be released?

0 replies

michaelstaib · 2021-02-03T14:09:30Z

michaelstaib
Feb 3, 2021
Maintainer

Hi @allmightyse,

not yet, I expect this more towards the end of 2021.

0 replies

bartalclementsen · 2021-12-02T14:43:28Z

bartalclementsen
Dec 2, 2021

@michaelstaib is there any planned time when this will be released?

0 replies

MarkoH17 · 2022-02-25T20:11:05Z

MarkoH17
Feb 25, 2022

@PascalSenn Any idea if this will make its way into HC sometime this year?

0 replies

glen-84 · 2022-06-09T19:35:40Z

glen-84
Jun 9, 2022
Collaborator

@PascalSenn

Are there any examples or best practices for patching with Hot Chocolate?

It's quite a common requirement (SO1, SO2), so having some guidance through documentation would be very helpful.

0 replies

michaelstaib · 2022-08-15T07:37:59Z

michaelstaib
Aug 15, 2022
Maintainer

We have not implemented this yet. Its an open topic we are discussing every now and then but could not get consensus on. But a community package could easily implement this, all the hooks are there.

1 reply

maxnatamo Aug 15, 2022

Do you have any general starting points? Any specific hooks to look at?

ademchenko · 2022-08-17T16:00:37Z

ademchenko
Aug 17, 2022

I have carefully read the spec and, really, it's kind of a very early spec. Actually, it would be very interesting to hear the real needs from projects with real examples.
Let's start with me. For about half a year we have production-ready API based on HC, which is deployed on several client servers. Dozens of different entities, connections between them, etc, etc., dozens of different mutations. But, more or less all we needed for all of that - is just two custom patch types without using the HC infrastructure at all and a very small number of ad-hoc methods for patching the array items.
I have described our experience in the answer of one of the SO questions mentioned in the current thread.
But, despite the spec being very complex and trying to cover as many as possible scenarios, it doesn't cover even our basic scenario. The thing is that we don't use EF.core since it lacks some important features for us. For example, fine-grained locks that are needed for optimizing highly-parallelised database access and others. In our solution, we use a well-recognized library existing for many years called linq2db. And we even don't have an object in memory to patch:

var userQuery = dataConnection.Users.Where(u => u.Id == parameter.UserId);
dataConnection.NextQueryNoKeyUpdate();  //Fine grained lock for the user record (Postgres WITH NO KEY UPDATE)
var updatable = userQuery.AsUpdatable(); //Updatable is something like IQueryable but for update. I.e. the record is not materialized
if (parameter.SetPhone != null) updatable = updatable.Set(p => p.Phone, parameter.SetPhone.Value);
if (parameter.SetEmail != null) updatable = updatable.Set(p => p.Email, parameter.SetEmail.Value);
...
updatable.UpdateAsync(); //Here we push our 'updatable' to the database

But there's no notice in the provided spec if there would be an intermediary providing just a patch details in order to implement a custom "ApplyTo". According to the spec, everything is hidden under the hood of a single method "ApplyTo". That is not flexible and doesn't suit our needs.
We could further discuss the spec, but it's better to see the community proposals as well and maybe some of their project technical details related to the topic.

Also, I want to emphasize that in many cases, the patching is not so difficult and can be done ad-hoc. For that reason, I would suggest the folks asking here not to wait but just implement it in their own way. If you could give more details of your needs you might get some advice here about how to implement it, I hope, without too much difficulty.

0 replies

simon-curtis · 2022-10-14T15:31:53Z

simon-curtis
Oct 14, 2022

I have just spent the last couple of days working on a source generator that automatically creates an input and update proxy model for a class.

namespace ExampleProject.Models;

public class Contact
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string? Email { get; set; }
}

public class ContactTypeBuilder : GraphQlTypeBuilder<Contact>
{
    public override void Configure(GraphQLTypeBuilderOptions<Contact> builder)
    {
        builder
            .Ignore(_ => _.Id)
            ;
    }
}

The source generator traverses the syntax and builds the following models:

Input model will mimic the nullability of the original class but will wrap the properties in an Optional<T> type. The update model will always wrap all properties in an Optional<T> type.

namespace ExampleProject.Models;

// Generated to `ContactInputModel.g.cs`
public record ContactInputModel
{
    public String Name { get; init; } = string.Empty;
    public Optional<String?> Email { get; init; }
}

// Generated to `ContactUpdateModel.g.cs`
public record ContactUpdateModel
{
    public Optional<String?> Name { get; init; }
    public Optional<String?> Email { get; init; }
}

The trick is at the point of creating the model I also make a "Patch" method at the same time. It proceedurally creates the update methods depending on the property's properties - like the System.Text.Json source generator

public record ContactInputModel
{
    public String Name { get; init; } = string.Empty;
    public Optional<String?> Email { get; init; }

    public bool Patch(Contact original) 
    {
        bool hasUpdates = false;

        if (original.Name.Equals(Name.Value) is false)
        {
            original.Name= (String)Name.Value;
            hasUpdates = true;
        }
        
        if (Email.HasValue && original.Email?.Equals(Email.Value) is false)
        {
            original.Email = (String?)Email.Value;
            hasUpdates = true;
        }

        return hasUpdates;
    }
}

public record ContactUpdateModel
{
    public Optional<String?> Name { get; init; }
    public Optional<String?> Email { get; init; }

    public bool Patch(Contact original) 
    {
        bool hasUpdates = false;

        if (Name.HasValue && original.Name.Equals(Name.Value) is false && Name.Value is not null)
        {
            original.Name= (String)Name.Value;
            hasUpdates = true;
        }
        
        if (Email.HasValue && original.Email?.Equals(Email.Value) is false)
        {
            original.Email = (String?)Email.Value;
            hasUpdates = true;
        }

        return hasUpdates;
    }
}

This would mean that migration endpoints look like this:

[GraphQLName("updateContact")]
[GraphQLType(typeof(ContactObjectType))]
public Contact UpdateContact([Service] ContactDao dao, int id, ContactUpdateModel input)
{
    if (dao.GetById(id) is not { } contact)
        throw new GraphQLException(new Error("Unable to find contact", "UPDATE_CONTACT_FAILED"));
    
    return input.Patch(contact)
        ? dao.SaveOrUpdate(contact)
        : contact;
}

It needs some more work but it does work,

I would be happy to contribute my code and services if you wanted to go down this route.

1 reply

ademchenko Oct 17, 2022

@simon-curtis , as I have described in my reply the Optional<T> is not quite a good decision for the patching functionality.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

HotChocolate Patching Types #4845

{{title}}

Replies: 8 comments 2 replies

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Select a reply

HotChocolate Patching Types #4845

PascalSenn Jan 4, 2020 Maintainer

HotChocolate.Types.Patch

Introduction

Proposal

Patching scalars

Patching lists

Patch(x => x.List)

PatchList(x => x.List)

Examples:

set

append

removeIndex

replaceIndex

Patching objects

Patch(x => x.Object)

PatchObject(x => x.Object)

Patching of Object Arrays

Patch(x => x.ObjectList)

PatchList(x => x.ObjectList)

set

append

removeIndex

replaceIndex

allowPatchAll

removeById

replaceById

patchById

Patching Customization

Predicate

Predicate with get and set

IPatchingContext

Further Ideas

Connect

Object List AllowWhereXY

How others did it

Replies: 8 comments · 2 replies

michaelstaib Feb 3, 2021 Maintainer

glen-84 Jun 9, 2022 Collaborator

michaelstaib Aug 15, 2022 Maintainer

PascalSenn
Jan 4, 2020
Maintainer

`Patch(x => x.List)`

`PatchList(x => x.List)`

`set`

`append`

`removeIndex`

`replaceIndex`

`Patch(x => x.Object)`

`PatchObject(x => x.Object)`

`Patch(x => x.ObjectList)`

`PatchList(x => x.ObjectList)`

`set`

`append`

`removeIndex`

`replaceIndex`

`allowPatchAll`

`removeById`

`replaceById`

`patchById`

Object List `AllowWhereXY`

Replies: 8 comments 2 replies

michaelstaib
Feb 3, 2021
Maintainer

glen-84
Jun 9, 2022
Collaborator

michaelstaib
Aug 15, 2022
Maintainer