From cf8d0605c247e2656fb07234e62b007a2ec68c71 Mon Sep 17 00:00:00 2001 From: Justin Johnson Date: Wed, 4 May 2022 18:59:44 -0700 Subject: [PATCH 1/8] Failing test --- entc/integration/hooks/hooks_test.go | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/entc/integration/hooks/hooks_test.go b/entc/integration/hooks/hooks_test.go index 417a3a96b3..727e4c5a62 100644 --- a/entc/integration/hooks/hooks_test.go +++ b/entc/integration/hooks/hooks_test.go @@ -212,6 +212,32 @@ func TestPostCreation(t *testing.T) { client.Card.CreateBulk(client.Card.Create().SetNumber("12345")).SaveX(ctx) } +func TestUpdateAfterCreation(t *testing.T) { + ctx := context.Background() + client := enttest.Open(t, "sqlite3", "file:ent?mode=memory&cache=shared&_fk=1") + defer client.Close() + client.User.Use(hook.On(func(next ent.Mutator) ent.Mutator { + return hook.UserFunc(func(ctx context.Context, m *ent.UserMutation) (ent.Value, error) { + value, err := next.Mutate(ctx, m) + if err != nil { + return nil, err + } + existingUser, ok := value.(*ent.User) + require.True(t, ok, "value should be of type %T", existingUser) + require.Equal(t, existingUser.Version, 1, "version does not match the original value") + + // Important to return a completely new model; don't just mutate the existing user. + newUser := m.Client().User.UpdateOneID(existingUser.ID). + SetVersion(2). + SaveX(ctx) + return newUser, nil + }) + }, ent.OpCreate)) + + u := client.User.Create().SetName("a8m").SetVersion(1).SaveX(ctx) + require.Equal(t, u.Version, 2, "version mutation in hook should have propagated back to call site") +} + func TestOldValues(t *testing.T) { ctx := context.Background() client := enttest.Open(t, "sqlite3", "file:ent?mode=memory&cache=shared&_fk=1", enttest.WithMigrateOptions(migrate.WithGlobalUniqueID(true))) From 7ca031bcebfadd2e693d081f02e270f4b012e099 Mon Sep 17 00:00:00 2001 From: Justin Johnson Date: Wed, 4 May 2022 19:11:19 -0700 Subject: [PATCH 2/8] Fix propagating entirely models from OpCreate hook --- entc/gen/template/builder/create.tmpl | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/entc/gen/template/builder/create.tmpl b/entc/gen/template/builder/create.tmpl index 62f9ecdb6f..b9afe79de7 100644 --- a/entc/gen/template/builder/create.tmpl +++ b/entc/gen/template/builder/create.tmpl @@ -83,8 +83,10 @@ func ({{ $receiver }} *{{ $builder }}) Save(ctx context.Context) (*{{ $.Name }}, } mut = {{ $receiver }}.hooks[i](mut) } - if _, err := mut.Mutate(ctx, {{ $mutation }}); err != nil { + if v, err := mut.Mutate(ctx, {{ $mutation }}); err != nil { return nil, err + } else if v, ok := v.(*{{ $.Name }}); ok { + node = v } } return node, err From d16d3b14f8f799d33f0442f0e64e94babd6464f1 Mon Sep 17 00:00:00 2001 From: Justin Johnson Date: Wed, 4 May 2022 22:41:25 -0700 Subject: [PATCH 3/8] Apply suggestions from code review Co-authored-by: Ariel Mashraki <7413593+a8m@users.noreply.github.com> --- entc/gen/template/builder/create.tmpl | 10 +++++++--- entc/integration/hooks/hooks_test.go | 4 ++-- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/entc/gen/template/builder/create.tmpl b/entc/gen/template/builder/create.tmpl index b9afe79de7..ff1832ec8f 100644 --- a/entc/gen/template/builder/create.tmpl +++ b/entc/gen/template/builder/create.tmpl @@ -83,11 +83,15 @@ func ({{ $receiver }} *{{ $builder }}) Save(ctx context.Context) (*{{ $.Name }}, } mut = {{ $receiver }}.hooks[i](mut) } - if v, err := mut.Mutate(ctx, {{ $mutation }}); err != nil { + v, err := mut.Mutate(ctx, {{ $mutation }}) + if err != nil { return nil, err - } else if v, ok := v.(*{{ $.Name }}); ok { - node = v } + nv, ok := v.(*{{ $.Name }}) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from {{ $.MutationName }}", v) + } + node = nv } return node, err } diff --git a/entc/integration/hooks/hooks_test.go b/entc/integration/hooks/hooks_test.go index 727e4c5a62..a6a086fab5 100644 --- a/entc/integration/hooks/hooks_test.go +++ b/entc/integration/hooks/hooks_test.go @@ -223,10 +223,10 @@ func TestUpdateAfterCreation(t *testing.T) { return nil, err } existingUser, ok := value.(*ent.User) - require.True(t, ok, "value should be of type %T", existingUser) + require.Truef(t, ok, "value should be of type %T", existingUser) require.Equal(t, existingUser.Version, 1, "version does not match the original value") - // Important to return a completely new model; don't just mutate the existing user. + // After the user was created, return its updated version (a new object). newUser := m.Client().User.UpdateOneID(existingUser.ID). SetVersion(2). SaveX(ctx) From 3a6f2d3ac6b8b76b32d9a0f573416cb7f11db0b2 Mon Sep 17 00:00:00 2001 From: Justin Johnson Date: Wed, 4 May 2022 23:37:55 -0700 Subject: [PATCH 4/8] whitespace --- entc/gen/template/builder/create.tmpl | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/entc/gen/template/builder/create.tmpl b/entc/gen/template/builder/create.tmpl index ff1832ec8f..7b023b2012 100644 --- a/entc/gen/template/builder/create.tmpl +++ b/entc/gen/template/builder/create.tmpl @@ -87,11 +87,11 @@ func ({{ $receiver }} *{{ $builder }}) Save(ctx context.Context) (*{{ $.Name }}, if err != nil { return nil, err } - nv, ok := v.(*{{ $.Name }}) - if !ok { - return nil, fmt.Errorf("unexpected node type %T returned from {{ $.MutationName }}", v) - } - node = nv + nv, ok := v.(*{{ $.Name }}) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from {{ $.MutationName }}", v) + } + node = nv } return node, err } From 737b9a99334cde6549ae2a8ed2c6fd743642a324 Mon Sep 17 00:00:00 2001 From: Justin Johnson Date: Wed, 4 May 2022 23:42:24 -0700 Subject: [PATCH 5/8] Failing test for updateone --- entc/integration/hooks/hooks_test.go | 30 +++++++++++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-) diff --git a/entc/integration/hooks/hooks_test.go b/entc/integration/hooks/hooks_test.go index a6a086fab5..8601d92e9d 100644 --- a/entc/integration/hooks/hooks_test.go +++ b/entc/integration/hooks/hooks_test.go @@ -235,7 +235,35 @@ func TestUpdateAfterCreation(t *testing.T) { }, ent.OpCreate)) u := client.User.Create().SetName("a8m").SetVersion(1).SaveX(ctx) - require.Equal(t, u.Version, 2, "version mutation in hook should have propagated back to call site") + require.Equal(t, 2, u.Version, "version mutation in hook should have propagated back to call site") +} + +func TestUpdateAfterUpdateOne(t *testing.T) { + ctx := context.Background() + client := enttest.Open(t, "sqlite3", "file:ent?mode=memory&cache=shared&_fk=1") + defer client.Close() + client.User.Use(hook.On(func(next ent.Mutator) ent.Mutator { + return hook.UserFunc(func(ctx context.Context, m *ent.UserMutation) (ent.Value, error) { + value, err := next.Mutate(ctx, m) + if err != nil { + return nil, err + } + existingUser, ok := value.(*ent.User) + require.Truef(t, ok, "value should be of type %T", existingUser) + require.Equal(t, existingUser.Version, 1, "version does not match the original value") + + // After the user was created, return its updated version (a new object). + newUser := m.Client().User.UpdateOneID(existingUser.ID). + SetVersion(3). + SaveX(ctx) + return newUser, nil + }) + }, ent.OpUpdateOne)) + + u := client.User.Create().SetName("a8m").SetVersion(1).SaveX(ctx) + u = client.User.UpdateOne(u).SetVersion(2).SaveX(ctx) + + require.Equal(t, 3, u.Version, "version mutation in hook should have propagated back to call site") } func TestOldValues(t *testing.T) { From b95b1ea692dfc9a83ad1789aaf053cbfa9b6ab2d Mon Sep 17 00:00:00 2001 From: Justin Johnson Date: Wed, 4 May 2022 23:43:27 -0700 Subject: [PATCH 6/8] fix for updateone --- entc/gen/template/builder/update.tmpl | 8 +++++++- entc/integration/hooks/hooks_test.go | 21 +++++++++++++-------- 2 files changed, 20 insertions(+), 9 deletions(-) diff --git a/entc/gen/template/builder/update.tmpl b/entc/gen/template/builder/update.tmpl index 68be3965f0..dc183f0635 100644 --- a/entc/gen/template/builder/update.tmpl +++ b/entc/gen/template/builder/update.tmpl @@ -197,9 +197,15 @@ func ({{ $receiver }} *{{ $onebuilder }} ) Save(ctx context.Context) (*{{ $.Name } mut = {{ $receiver }}.hooks[i](mut) } - if _, err := mut.Mutate(ctx, {{ $mutation }}); err != nil { + v, err := mut.Mutate(ctx, {{ $mutation }}) + if err != nil { return nil, err } + nv, ok := v.(*{{ $.Name }}) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from {{ $.MutationName }}", v) + } + node = nv } return node, err } diff --git a/entc/integration/hooks/hooks_test.go b/entc/integration/hooks/hooks_test.go index 8601d92e9d..4d0315ea9a 100644 --- a/entc/integration/hooks/hooks_test.go +++ b/entc/integration/hooks/hooks_test.go @@ -222,12 +222,13 @@ func TestUpdateAfterCreation(t *testing.T) { if err != nil { return nil, err } + existingUser, ok := value.(*ent.User) require.Truef(t, ok, "value should be of type %T", existingUser) - require.Equal(t, existingUser.Version, 1, "version does not match the original value") + require.Equal(t, 1, existingUser.Version, "version does not match the original value") // After the user was created, return its updated version (a new object). - newUser := m.Client().User.UpdateOneID(existingUser.ID). + newUser := m.Client().User.UpdateOne(existingUser). SetVersion(2). SaveX(ctx) return newUser, nil @@ -248,15 +249,19 @@ func TestUpdateAfterUpdateOne(t *testing.T) { if err != nil { return nil, err } - existingUser, ok := value.(*ent.User) - require.Truef(t, ok, "value should be of type %T", existingUser) - require.Equal(t, existingUser.Version, 1, "version does not match the original value") - // After the user was created, return its updated version (a new object). - newUser := m.Client().User.UpdateOneID(existingUser.ID). + u, ok := value.(*ent.User) + require.Truef(t, ok, "value should be of type %T", u) + require.Equal(t, 2, u.Version, "version does not match the original value") + + // After the user was created, return its updated version (a new object). Don't use UpdateOne because it + // will cause recursive calls to this hook. + m.Client().User.Update(). + Where(user.IDEQ(u.ID)). SetVersion(3). SaveX(ctx) - return newUser, nil + + return m.Client().User.Get(ctx, u.ID) }) }, ent.OpUpdateOne)) From fac289f95e5988560f78c768995b7cfaf47ea58f Mon Sep 17 00:00:00 2001 From: Justin Johnson Date: Wed, 4 May 2022 23:56:54 -0700 Subject: [PATCH 7/8] Regnerate --- entc/integration/cascadelete/ent/comment_create.go | 8 +++++++- entc/integration/cascadelete/ent/comment_update.go | 8 +++++++- entc/integration/cascadelete/ent/post_create.go | 8 +++++++- entc/integration/cascadelete/ent/post_update.go | 8 +++++++- entc/integration/cascadelete/ent/user_create.go | 8 +++++++- entc/integration/cascadelete/ent/user_update.go | 8 +++++++- entc/integration/config/ent/user_create.go | 8 +++++++- entc/integration/config/ent/user_update.go | 8 +++++++- entc/integration/customid/ent/account_create.go | 8 +++++++- entc/integration/customid/ent/account_update.go | 8 +++++++- entc/integration/customid/ent/blob_create.go | 8 +++++++- entc/integration/customid/ent/blob_update.go | 8 +++++++- entc/integration/customid/ent/car_create.go | 8 +++++++- entc/integration/customid/ent/car_update.go | 8 +++++++- entc/integration/customid/ent/device_create.go | 8 +++++++- entc/integration/customid/ent/device_update.go | 8 +++++++- entc/integration/customid/ent/doc_create.go | 8 +++++++- entc/integration/customid/ent/doc_update.go | 8 +++++++- entc/integration/customid/ent/group_create.go | 8 +++++++- entc/integration/customid/ent/group_update.go | 8 +++++++- entc/integration/customid/ent/mixinid_create.go | 8 +++++++- entc/integration/customid/ent/mixinid_update.go | 8 +++++++- entc/integration/customid/ent/note_create.go | 8 +++++++- entc/integration/customid/ent/note_update.go | 8 +++++++- entc/integration/customid/ent/other_create.go | 8 +++++++- entc/integration/customid/ent/other_update.go | 8 +++++++- entc/integration/customid/ent/pet_create.go | 8 +++++++- entc/integration/customid/ent/pet_update.go | 8 +++++++- entc/integration/customid/ent/revision_create.go | 8 +++++++- entc/integration/customid/ent/revision_update.go | 8 +++++++- entc/integration/customid/ent/session_create.go | 8 +++++++- entc/integration/customid/ent/session_update.go | 8 +++++++- entc/integration/customid/ent/token_create.go | 8 +++++++- entc/integration/customid/ent/token_update.go | 8 +++++++- entc/integration/customid/ent/user_create.go | 8 +++++++- entc/integration/customid/ent/user_update.go | 8 +++++++- entc/integration/edgefield/ent/car_create.go | 8 +++++++- entc/integration/edgefield/ent/car_update.go | 8 +++++++- entc/integration/edgefield/ent/card_create.go | 8 +++++++- entc/integration/edgefield/ent/card_update.go | 8 +++++++- entc/integration/edgefield/ent/info_create.go | 8 +++++++- entc/integration/edgefield/ent/info_update.go | 8 +++++++- entc/integration/edgefield/ent/metadata_create.go | 8 +++++++- entc/integration/edgefield/ent/metadata_update.go | 8 +++++++- entc/integration/edgefield/ent/node_create.go | 8 +++++++- entc/integration/edgefield/ent/node_update.go | 8 +++++++- entc/integration/edgefield/ent/pet_create.go | 8 +++++++- entc/integration/edgefield/ent/pet_update.go | 8 +++++++- entc/integration/edgefield/ent/post_create.go | 8 +++++++- entc/integration/edgefield/ent/post_update.go | 8 +++++++- entc/integration/edgefield/ent/rental_create.go | 8 +++++++- entc/integration/edgefield/ent/rental_update.go | 8 +++++++- entc/integration/edgefield/ent/user_create.go | 8 +++++++- entc/integration/edgefield/ent/user_update.go | 8 +++++++- entc/integration/ent/card_create.go | 8 +++++++- entc/integration/ent/card_update.go | 8 +++++++- entc/integration/ent/comment_create.go | 8 +++++++- entc/integration/ent/comment_update.go | 8 +++++++- entc/integration/ent/fieldtype_create.go | 8 +++++++- entc/integration/ent/fieldtype_update.go | 8 +++++++- entc/integration/ent/file_create.go | 8 +++++++- entc/integration/ent/file_update.go | 8 +++++++- entc/integration/ent/filetype_create.go | 8 +++++++- entc/integration/ent/filetype_update.go | 8 +++++++- entc/integration/ent/goods_create.go | 8 +++++++- entc/integration/ent/goods_update.go | 8 +++++++- entc/integration/ent/group_create.go | 8 +++++++- entc/integration/ent/group_update.go | 8 +++++++- entc/integration/ent/groupinfo_create.go | 8 +++++++- entc/integration/ent/groupinfo_update.go | 8 +++++++- entc/integration/ent/item_create.go | 8 +++++++- entc/integration/ent/item_update.go | 8 +++++++- entc/integration/ent/node_create.go | 8 +++++++- entc/integration/ent/node_update.go | 8 +++++++- entc/integration/ent/pet_create.go | 8 +++++++- entc/integration/ent/pet_update.go | 8 +++++++- entc/integration/ent/spec_create.go | 8 +++++++- entc/integration/ent/spec_update.go | 8 +++++++- entc/integration/ent/task_create.go | 8 +++++++- entc/integration/ent/task_update.go | 8 +++++++- entc/integration/ent/user_create.go | 8 +++++++- entc/integration/ent/user_update.go | 8 +++++++- entc/integration/gremlin/ent/card_create.go | 8 +++++++- entc/integration/gremlin/ent/card_update.go | 8 +++++++- entc/integration/gremlin/ent/comment_create.go | 8 +++++++- entc/integration/gremlin/ent/comment_update.go | 8 +++++++- entc/integration/gremlin/ent/fieldtype_create.go | 8 +++++++- entc/integration/gremlin/ent/fieldtype_update.go | 8 +++++++- entc/integration/gremlin/ent/file_create.go | 8 +++++++- entc/integration/gremlin/ent/file_update.go | 8 +++++++- entc/integration/gremlin/ent/filetype_create.go | 8 +++++++- entc/integration/gremlin/ent/filetype_update.go | 8 +++++++- entc/integration/gremlin/ent/goods_create.go | 8 +++++++- entc/integration/gremlin/ent/goods_update.go | 8 +++++++- entc/integration/gremlin/ent/group_create.go | 8 +++++++- entc/integration/gremlin/ent/group_update.go | 8 +++++++- entc/integration/gremlin/ent/groupinfo_create.go | 8 +++++++- entc/integration/gremlin/ent/groupinfo_update.go | 8 +++++++- entc/integration/gremlin/ent/item_create.go | 8 +++++++- entc/integration/gremlin/ent/item_update.go | 8 +++++++- entc/integration/gremlin/ent/node_create.go | 8 +++++++- entc/integration/gremlin/ent/node_update.go | 8 +++++++- entc/integration/gremlin/ent/pet_create.go | 8 +++++++- entc/integration/gremlin/ent/pet_update.go | 8 +++++++- entc/integration/gremlin/ent/spec_create.go | 8 +++++++- entc/integration/gremlin/ent/spec_update.go | 8 +++++++- entc/integration/gremlin/ent/task_create.go | 8 +++++++- entc/integration/gremlin/ent/task_update.go | 8 +++++++- entc/integration/gremlin/ent/user_create.go | 8 +++++++- entc/integration/gremlin/ent/user_update.go | 8 +++++++- entc/integration/hooks/ent/card_create.go | 8 +++++++- entc/integration/hooks/ent/card_update.go | 8 +++++++- entc/integration/hooks/ent/user_create.go | 8 +++++++- entc/integration/hooks/ent/user_update.go | 8 +++++++- entc/integration/idtype/ent/user_create.go | 8 +++++++- entc/integration/idtype/ent/user_update.go | 8 +++++++- entc/integration/json/ent/user_create.go | 8 +++++++- entc/integration/json/ent/user_update.go | 8 +++++++- entc/integration/migrate/entv1/car_create.go | 8 +++++++- entc/integration/migrate/entv1/car_update.go | 8 +++++++- entc/integration/migrate/entv1/conversion_create.go | 8 +++++++- entc/integration/migrate/entv1/conversion_update.go | 8 +++++++- entc/integration/migrate/entv1/customtype_create.go | 8 +++++++- entc/integration/migrate/entv1/customtype_update.go | 8 +++++++- entc/integration/migrate/entv1/user_create.go | 8 +++++++- entc/integration/migrate/entv1/user_update.go | 8 +++++++- entc/integration/migrate/entv2/car_create.go | 8 +++++++- entc/integration/migrate/entv2/car_update.go | 8 +++++++- entc/integration/migrate/entv2/conversion_create.go | 8 +++++++- entc/integration/migrate/entv2/conversion_update.go | 8 +++++++- entc/integration/migrate/entv2/customtype_create.go | 8 +++++++- entc/integration/migrate/entv2/customtype_update.go | 8 +++++++- entc/integration/migrate/entv2/group_create.go | 8 +++++++- entc/integration/migrate/entv2/group_update.go | 8 +++++++- entc/integration/migrate/entv2/media_create.go | 8 +++++++- entc/integration/migrate/entv2/media_update.go | 8 +++++++- entc/integration/migrate/entv2/pet_create.go | 8 +++++++- entc/integration/migrate/entv2/pet_update.go | 8 +++++++- entc/integration/migrate/entv2/user_create.go | 8 +++++++- entc/integration/migrate/entv2/user_update.go | 8 +++++++- entc/integration/migrate/versioned/user_create.go | 8 +++++++- entc/integration/migrate/versioned/user_update.go | 8 +++++++- entc/integration/multischema/ent/group_create.go | 8 +++++++- entc/integration/multischema/ent/group_update.go | 8 +++++++- entc/integration/multischema/ent/pet_create.go | 8 +++++++- entc/integration/multischema/ent/pet_update.go | 8 +++++++- entc/integration/multischema/ent/user_create.go | 8 +++++++- entc/integration/multischema/ent/user_update.go | 8 +++++++- entc/integration/privacy/ent/task_create.go | 8 +++++++- entc/integration/privacy/ent/task_update.go | 8 +++++++- entc/integration/privacy/ent/team_create.go | 8 +++++++- entc/integration/privacy/ent/team_update.go | 8 +++++++- entc/integration/privacy/ent/user_create.go | 8 +++++++- entc/integration/privacy/ent/user_update.go | 8 +++++++- entc/integration/template/ent/group_create.go | 8 +++++++- entc/integration/template/ent/group_update.go | 8 +++++++- entc/integration/template/ent/pet_create.go | 8 +++++++- entc/integration/template/ent/pet_update.go | 8 +++++++- entc/integration/template/ent/user_create.go | 8 +++++++- entc/integration/template/ent/user_update.go | 8 +++++++- 160 files changed, 1120 insertions(+), 160 deletions(-) diff --git a/entc/integration/cascadelete/ent/comment_create.go b/entc/integration/cascadelete/ent/comment_create.go index 4640b736c2..bc966c7bcf 100644 --- a/entc/integration/cascadelete/ent/comment_create.go +++ b/entc/integration/cascadelete/ent/comment_create.go @@ -80,9 +80,15 @@ func (cc *CommentCreate) Save(ctx context.Context) (*Comment, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Comment) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CommentMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/cascadelete/ent/comment_update.go b/entc/integration/cascadelete/ent/comment_update.go index d6d9121d6c..aa5e597bb6 100644 --- a/entc/integration/cascadelete/ent/comment_update.go +++ b/entc/integration/cascadelete/ent/comment_update.go @@ -273,9 +273,15 @@ func (cuo *CommentUpdateOne) Save(ctx context.Context) (*Comment, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Comment) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CommentMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/cascadelete/ent/post_create.go b/entc/integration/cascadelete/ent/post_create.go index 73e32e4f8c..48a66624a6 100644 --- a/entc/integration/cascadelete/ent/post_create.go +++ b/entc/integration/cascadelete/ent/post_create.go @@ -113,9 +113,15 @@ func (pc *PostCreate) Save(ctx context.Context) (*Post, error) { } mut = pc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, pc.mutation); err != nil { + v, err := mut.Mutate(ctx, pc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Post) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PostMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/cascadelete/ent/post_update.go b/entc/integration/cascadelete/ent/post_update.go index 6ec56ef0e2..0ede3369fd 100644 --- a/entc/integration/cascadelete/ent/post_update.go +++ b/entc/integration/cascadelete/ent/post_update.go @@ -424,9 +424,15 @@ func (puo *PostUpdateOne) Save(ctx context.Context) (*Post, error) { } mut = puo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, puo.mutation); err != nil { + v, err := mut.Mutate(ctx, puo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Post) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PostMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/cascadelete/ent/user_create.go b/entc/integration/cascadelete/ent/user_create.go index 1934bb509b..08e1101eca 100644 --- a/entc/integration/cascadelete/ent/user_create.go +++ b/entc/integration/cascadelete/ent/user_create.go @@ -93,9 +93,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/cascadelete/ent/user_update.go b/entc/integration/cascadelete/ent/user_update.go index 58bf137966..8cee74bb4b 100644 --- a/entc/integration/cascadelete/ent/user_update.go +++ b/entc/integration/cascadelete/ent/user_update.go @@ -326,9 +326,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/config/ent/user_create.go b/entc/integration/config/ent/user_create.go index 43546ed617..d2d2297e09 100644 --- a/entc/integration/config/ent/user_create.go +++ b/entc/integration/config/ent/user_create.go @@ -95,9 +95,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/config/ent/user_update.go b/entc/integration/config/ent/user_update.go index 9d9bed3b3c..bd553f0e4e 100644 --- a/entc/integration/config/ent/user_update.go +++ b/entc/integration/config/ent/user_update.go @@ -270,9 +270,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/account_create.go b/entc/integration/customid/ent/account_create.go index 02c243ef34..7b820fa720 100644 --- a/entc/integration/customid/ent/account_create.go +++ b/entc/integration/customid/ent/account_create.go @@ -103,9 +103,15 @@ func (ac *AccountCreate) Save(ctx context.Context) (*Account, error) { } mut = ac.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ac.mutation); err != nil { + v, err := mut.Mutate(ctx, ac.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Account) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from AccountMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/account_update.go b/entc/integration/customid/ent/account_update.go index dd8cc4c8cd..bc78bd3a41 100644 --- a/entc/integration/customid/ent/account_update.go +++ b/entc/integration/customid/ent/account_update.go @@ -333,9 +333,15 @@ func (auo *AccountUpdateOne) Save(ctx context.Context) (*Account, error) { } mut = auo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, auo.mutation); err != nil { + v, err := mut.Mutate(ctx, auo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Account) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from AccountMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/blob_create.go b/entc/integration/customid/ent/blob_create.go index 0df7ead95f..71a1967220 100644 --- a/entc/integration/customid/ent/blob_create.go +++ b/entc/integration/customid/ent/blob_create.go @@ -143,9 +143,15 @@ func (bc *BlobCreate) Save(ctx context.Context) (*Blob, error) { } mut = bc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, bc.mutation); err != nil { + v, err := mut.Mutate(ctx, bc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Blob) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from BlobMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/blob_update.go b/entc/integration/customid/ent/blob_update.go index c4f112ef5c..f43d62d0a5 100644 --- a/entc/integration/customid/ent/blob_update.go +++ b/entc/integration/customid/ent/blob_update.go @@ -467,9 +467,15 @@ func (buo *BlobUpdateOne) Save(ctx context.Context) (*Blob, error) { } mut = buo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, buo.mutation); err != nil { + v, err := mut.Mutate(ctx, buo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Blob) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from BlobMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/car_create.go b/entc/integration/customid/ent/car_create.go index 0e6255ec66..9c272f5507 100644 --- a/entc/integration/customid/ent/car_create.go +++ b/entc/integration/customid/ent/car_create.go @@ -124,9 +124,15 @@ func (cc *CarCreate) Save(ctx context.Context) (*Car, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Car) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CarMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/car_update.go b/entc/integration/customid/ent/car_update.go index 53f5f14b1e..34c1c62eb7 100644 --- a/entc/integration/customid/ent/car_update.go +++ b/entc/integration/customid/ent/car_update.go @@ -444,9 +444,15 @@ func (cuo *CarUpdateOne) Save(ctx context.Context) (*Car, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Car) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CarMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/device_create.go b/entc/integration/customid/ent/device_create.go index d4f1ae1f37..4fffa6296b 100644 --- a/entc/integration/customid/ent/device_create.go +++ b/entc/integration/customid/ent/device_create.go @@ -116,9 +116,15 @@ func (dc *DeviceCreate) Save(ctx context.Context) (*Device, error) { } mut = dc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, dc.mutation); err != nil { + v, err := mut.Mutate(ctx, dc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Device) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from DeviceMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/device_update.go b/entc/integration/customid/ent/device_update.go index a7a22b0be6..0f2a598716 100644 --- a/entc/integration/customid/ent/device_update.go +++ b/entc/integration/customid/ent/device_update.go @@ -377,9 +377,15 @@ func (duo *DeviceUpdateOne) Save(ctx context.Context) (*Device, error) { } mut = duo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, duo.mutation); err != nil { + v, err := mut.Mutate(ctx, duo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Device) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from DeviceMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/doc_create.go b/entc/integration/customid/ent/doc_create.go index 696d609fdd..e1a140f0d8 100644 --- a/entc/integration/customid/ent/doc_create.go +++ b/entc/integration/customid/ent/doc_create.go @@ -129,9 +129,15 @@ func (dc *DocCreate) Save(ctx context.Context) (*Doc, error) { } mut = dc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, dc.mutation); err != nil { + v, err := mut.Mutate(ctx, dc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Doc) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from DocMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/doc_update.go b/entc/integration/customid/ent/doc_update.go index 44180dda39..a0bd413a84 100644 --- a/entc/integration/customid/ent/doc_update.go +++ b/entc/integration/customid/ent/doc_update.go @@ -429,9 +429,15 @@ func (duo *DocUpdateOne) Save(ctx context.Context) (*Doc, error) { } mut = duo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, duo.mutation); err != nil { + v, err := mut.Mutate(ctx, duo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Doc) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from DocMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/group_create.go b/entc/integration/customid/ent/group_create.go index 39fa4a1725..aabacb7e86 100644 --- a/entc/integration/customid/ent/group_create.go +++ b/entc/integration/customid/ent/group_create.go @@ -86,9 +86,15 @@ func (gc *GroupCreate) Save(ctx context.Context) (*Group, error) { } mut = gc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, gc.mutation); err != nil { + v, err := mut.Mutate(ctx, gc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/group_update.go b/entc/integration/customid/ent/group_update.go index e8e2dafe5a..d7e3b50e41 100644 --- a/entc/integration/customid/ent/group_update.go +++ b/entc/integration/customid/ent/group_update.go @@ -291,9 +291,15 @@ func (guo *GroupUpdateOne) Save(ctx context.Context) (*Group, error) { } mut = guo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, guo.mutation); err != nil { + v, err := mut.Mutate(ctx, guo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/mixinid_create.go b/entc/integration/customid/ent/mixinid_create.go index 72cdc6913f..5f2fdab454 100644 --- a/entc/integration/customid/ent/mixinid_create.go +++ b/entc/integration/customid/ent/mixinid_create.go @@ -93,9 +93,15 @@ func (mic *MixinIDCreate) Save(ctx context.Context) (*MixinID, error) { } mut = mic.hooks[i](mut) } - if _, err := mut.Mutate(ctx, mic.mutation); err != nil { + v, err := mut.Mutate(ctx, mic.mutation) + if err != nil { return nil, err } + nv, ok := v.(*MixinID) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from MixinIDMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/mixinid_update.go b/entc/integration/customid/ent/mixinid_update.go index a8a12ec09e..3eb9975329 100644 --- a/entc/integration/customid/ent/mixinid_update.go +++ b/entc/integration/customid/ent/mixinid_update.go @@ -202,9 +202,15 @@ func (miuo *MixinIDUpdateOne) Save(ctx context.Context) (*MixinID, error) { } mut = miuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, miuo.mutation); err != nil { + v, err := mut.Mutate(ctx, miuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*MixinID) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from MixinIDMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/note_create.go b/entc/integration/customid/ent/note_create.go index e6a6e61b35..4e3c2d4c59 100644 --- a/entc/integration/customid/ent/note_create.go +++ b/entc/integration/customid/ent/note_create.go @@ -129,9 +129,15 @@ func (nc *NoteCreate) Save(ctx context.Context) (*Note, error) { } mut = nc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, nc.mutation); err != nil { + v, err := mut.Mutate(ctx, nc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Note) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from NoteMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/note_update.go b/entc/integration/customid/ent/note_update.go index cce288032c..8113c3ebb4 100644 --- a/entc/integration/customid/ent/note_update.go +++ b/entc/integration/customid/ent/note_update.go @@ -429,9 +429,15 @@ func (nuo *NoteUpdateOne) Save(ctx context.Context) (*Note, error) { } mut = nuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, nuo.mutation); err != nil { + v, err := mut.Mutate(ctx, nuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Note) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from NoteMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/other_create.go b/entc/integration/customid/ent/other_create.go index 7ffb1bed75..6e12a8a114 100644 --- a/entc/integration/customid/ent/other_create.go +++ b/entc/integration/customid/ent/other_create.go @@ -81,9 +81,15 @@ func (oc *OtherCreate) Save(ctx context.Context) (*Other, error) { } mut = oc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, oc.mutation); err != nil { + v, err := mut.Mutate(ctx, oc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Other) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from OtherMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/other_update.go b/entc/integration/customid/ent/other_update.go index 8a5408c24e..8ecd567637 100644 --- a/entc/integration/customid/ent/other_update.go +++ b/entc/integration/customid/ent/other_update.go @@ -164,9 +164,15 @@ func (ouo *OtherUpdateOne) Save(ctx context.Context) (*Other, error) { } mut = ouo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ouo.mutation); err != nil { + v, err := mut.Mutate(ctx, ouo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Other) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from OtherMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/pet_create.go b/entc/integration/customid/ent/pet_create.go index bc7060a193..29b326f233 100644 --- a/entc/integration/customid/ent/pet_create.go +++ b/entc/integration/customid/ent/pet_create.go @@ -150,9 +150,15 @@ func (pc *PetCreate) Save(ctx context.Context) (*Pet, error) { } mut = pc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, pc.mutation); err != nil { + v, err := mut.Mutate(ctx, pc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/pet_update.go b/entc/integration/customid/ent/pet_update.go index 2e8ff9f7a4..56da4f614b 100644 --- a/entc/integration/customid/ent/pet_update.go +++ b/entc/integration/customid/ent/pet_update.go @@ -588,9 +588,15 @@ func (puo *PetUpdateOne) Save(ctx context.Context) (*Pet, error) { } mut = puo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, puo.mutation); err != nil { + v, err := mut.Mutate(ctx, puo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/revision_create.go b/entc/integration/customid/ent/revision_create.go index b1d012734a..fd6c2b2fa9 100644 --- a/entc/integration/customid/ent/revision_create.go +++ b/entc/integration/customid/ent/revision_create.go @@ -71,9 +71,15 @@ func (rc *RevisionCreate) Save(ctx context.Context) (*Revision, error) { } mut = rc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, rc.mutation); err != nil { + v, err := mut.Mutate(ctx, rc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Revision) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from RevisionMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/revision_update.go b/entc/integration/customid/ent/revision_update.go index 6c9ac88e25..bca9f5f299 100644 --- a/entc/integration/customid/ent/revision_update.go +++ b/entc/integration/customid/ent/revision_update.go @@ -164,9 +164,15 @@ func (ruo *RevisionUpdateOne) Save(ctx context.Context) (*Revision, error) { } mut = ruo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ruo.mutation); err != nil { + v, err := mut.Mutate(ctx, ruo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Revision) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from RevisionMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/session_create.go b/entc/integration/customid/ent/session_create.go index 40de650473..f970eb1784 100644 --- a/entc/integration/customid/ent/session_create.go +++ b/entc/integration/customid/ent/session_create.go @@ -101,9 +101,15 @@ func (sc *SessionCreate) Save(ctx context.Context) (*Session, error) { } mut = sc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, sc.mutation); err != nil { + v, err := mut.Mutate(ctx, sc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Session) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from SessionMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/session_update.go b/entc/integration/customid/ent/session_update.go index 1b117e0d21..4831d95a5b 100644 --- a/entc/integration/customid/ent/session_update.go +++ b/entc/integration/customid/ent/session_update.go @@ -251,9 +251,15 @@ func (suo *SessionUpdateOne) Save(ctx context.Context) (*Session, error) { } mut = suo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, suo.mutation); err != nil { + v, err := mut.Mutate(ctx, suo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Session) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from SessionMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/token_create.go b/entc/integration/customid/ent/token_create.go index 1a3c8911fc..44ecc235a8 100644 --- a/entc/integration/customid/ent/token_create.go +++ b/entc/integration/customid/ent/token_create.go @@ -99,9 +99,15 @@ func (tc *TokenCreate) Save(ctx context.Context) (*Token, error) { } mut = tc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, tc.mutation); err != nil { + v, err := mut.Mutate(ctx, tc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Token) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from TokenMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/token_update.go b/entc/integration/customid/ent/token_update.go index cf4bba1006..d2fe6687dc 100644 --- a/entc/integration/customid/ent/token_update.go +++ b/entc/integration/customid/ent/token_update.go @@ -279,9 +279,15 @@ func (tuo *TokenUpdateOne) Save(ctx context.Context) (*Token, error) { } mut = tuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, tuo.mutation); err != nil { + v, err := mut.Mutate(ctx, tuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Token) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from TokenMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/user_create.go b/entc/integration/customid/ent/user_create.go index 44a65336ad..117c1e6dcc 100644 --- a/entc/integration/customid/ent/user_create.go +++ b/entc/integration/customid/ent/user_create.go @@ -136,9 +136,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/customid/ent/user_update.go b/entc/integration/customid/ent/user_update.go index 716edd99ec..8561385a55 100644 --- a/entc/integration/customid/ent/user_update.go +++ b/entc/integration/customid/ent/user_update.go @@ -629,9 +629,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/car_create.go b/entc/integration/edgefield/ent/car_create.go index 24396fdc96..28a260ccec 100644 --- a/entc/integration/edgefield/ent/car_create.go +++ b/entc/integration/edgefield/ent/car_create.go @@ -107,9 +107,15 @@ func (cc *CarCreate) Save(ctx context.Context) (*Car, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Car) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CarMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/car_update.go b/entc/integration/edgefield/ent/car_update.go index eaac85562b..0308b8d913 100644 --- a/entc/integration/edgefield/ent/car_update.go +++ b/entc/integration/edgefield/ent/car_update.go @@ -344,9 +344,15 @@ func (cuo *CarUpdateOne) Save(ctx context.Context) (*Car, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Car) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CarMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/card_create.go b/entc/integration/edgefield/ent/card_create.go index d4303c8fd3..59992deca2 100644 --- a/entc/integration/edgefield/ent/card_create.go +++ b/entc/integration/edgefield/ent/card_create.go @@ -95,9 +95,15 @@ func (cc *CardCreate) Save(ctx context.Context) (*Card, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Card) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CardMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/card_update.go b/entc/integration/edgefield/ent/card_update.go index f0c35efcf1..92f93acad5 100644 --- a/entc/integration/edgefield/ent/card_update.go +++ b/entc/integration/edgefield/ent/card_update.go @@ -315,9 +315,15 @@ func (cuo *CardUpdateOne) Save(ctx context.Context) (*Card, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Card) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CardMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/info_create.go b/entc/integration/edgefield/ent/info_create.go index 6ad666094a..c62d9cefc7 100644 --- a/entc/integration/edgefield/ent/info_create.go +++ b/entc/integration/edgefield/ent/info_create.go @@ -95,9 +95,15 @@ func (ic *InfoCreate) Save(ctx context.Context) (*Info, error) { } mut = ic.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ic.mutation); err != nil { + v, err := mut.Mutate(ctx, ic.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Info) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from InfoMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/info_update.go b/entc/integration/edgefield/ent/info_update.go index d8137263f9..8ee675f22a 100644 --- a/entc/integration/edgefield/ent/info_update.go +++ b/entc/integration/edgefield/ent/info_update.go @@ -270,9 +270,15 @@ func (iuo *InfoUpdateOne) Save(ctx context.Context) (*Info, error) { } mut = iuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, iuo.mutation); err != nil { + v, err := mut.Mutate(ctx, iuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Info) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from InfoMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/metadata_create.go b/entc/integration/edgefield/ent/metadata_create.go index 53d0f7790e..5c48a13ec5 100644 --- a/entc/integration/edgefield/ent/metadata_create.go +++ b/entc/integration/edgefield/ent/metadata_create.go @@ -137,9 +137,15 @@ func (mc *MetadataCreate) Save(ctx context.Context) (*Metadata, error) { } mut = mc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, mc.mutation); err != nil { + v, err := mut.Mutate(ctx, mc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Metadata) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from MetadataMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/metadata_update.go b/entc/integration/edgefield/ent/metadata_update.go index cc981d1400..901b9841c3 100644 --- a/entc/integration/edgefield/ent/metadata_update.go +++ b/entc/integration/edgefield/ent/metadata_update.go @@ -529,9 +529,15 @@ func (muo *MetadataUpdateOne) Save(ctx context.Context) (*Metadata, error) { } mut = muo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, muo.mutation); err != nil { + v, err := mut.Mutate(ctx, muo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Metadata) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from MetadataMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/node_create.go b/entc/integration/edgefield/ent/node_create.go index 6e7fcdb419..a14f28fb6a 100644 --- a/entc/integration/edgefield/ent/node_create.go +++ b/entc/integration/edgefield/ent/node_create.go @@ -115,9 +115,15 @@ func (nc *NodeCreate) Save(ctx context.Context) (*Node, error) { } mut = nc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, nc.mutation); err != nil { + v, err := mut.Mutate(ctx, nc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Node) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from NodeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/node_update.go b/entc/integration/edgefield/ent/node_update.go index 5a3078901a..30c7ee40b0 100644 --- a/entc/integration/edgefield/ent/node_update.go +++ b/entc/integration/edgefield/ent/node_update.go @@ -402,9 +402,15 @@ func (nuo *NodeUpdateOne) Save(ctx context.Context) (*Node, error) { } mut = nuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, nuo.mutation); err != nil { + v, err := mut.Mutate(ctx, nuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Node) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from NodeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/pet_create.go b/entc/integration/edgefield/ent/pet_create.go index 31aaf23dbf..774f2f80b7 100644 --- a/entc/integration/edgefield/ent/pet_create.go +++ b/entc/integration/edgefield/ent/pet_create.go @@ -81,9 +81,15 @@ func (pc *PetCreate) Save(ctx context.Context) (*Pet, error) { } mut = pc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, pc.mutation); err != nil { + v, err := mut.Mutate(ctx, pc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/pet_update.go b/entc/integration/edgefield/ent/pet_update.go index 4d2912d533..2c7d660f5c 100644 --- a/entc/integration/edgefield/ent/pet_update.go +++ b/entc/integration/edgefield/ent/pet_update.go @@ -262,9 +262,15 @@ func (puo *PetUpdateOne) Save(ctx context.Context) (*Pet, error) { } mut = puo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, puo.mutation); err != nil { + v, err := mut.Mutate(ctx, puo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/post_create.go b/entc/integration/edgefield/ent/post_create.go index a84ef341f7..f19f1d28da 100644 --- a/entc/integration/edgefield/ent/post_create.go +++ b/entc/integration/edgefield/ent/post_create.go @@ -88,9 +88,15 @@ func (pc *PostCreate) Save(ctx context.Context) (*Post, error) { } mut = pc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, pc.mutation); err != nil { + v, err := mut.Mutate(ctx, pc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Post) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PostMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/post_update.go b/entc/integration/edgefield/ent/post_update.go index d322bef93d..4c955553f5 100644 --- a/entc/integration/edgefield/ent/post_update.go +++ b/entc/integration/edgefield/ent/post_update.go @@ -281,9 +281,15 @@ func (puo *PostUpdateOne) Save(ctx context.Context) (*Post, error) { } mut = puo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, puo.mutation); err != nil { + v, err := mut.Mutate(ctx, puo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Post) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PostMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/rental_create.go b/entc/integration/edgefield/ent/rental_create.go index 7aa8bbc7ad..57445a6e63 100644 --- a/entc/integration/edgefield/ent/rental_create.go +++ b/entc/integration/edgefield/ent/rental_create.go @@ -103,9 +103,15 @@ func (rc *RentalCreate) Save(ctx context.Context) (*Rental, error) { } mut = rc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, rc.mutation); err != nil { + v, err := mut.Mutate(ctx, rc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Rental) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from RentalMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/rental_update.go b/entc/integration/edgefield/ent/rental_update.go index e6ac310849..322ab6fe67 100644 --- a/entc/integration/edgefield/ent/rental_update.go +++ b/entc/integration/edgefield/ent/rental_update.go @@ -364,9 +364,15 @@ func (ruo *RentalUpdateOne) Save(ctx context.Context) (*Rental, error) { } mut = ruo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ruo.mutation); err != nil { + v, err := mut.Mutate(ctx, ruo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Rental) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from RentalMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/user_create.go b/entc/integration/edgefield/ent/user_create.go index 1f0d4382e5..3a441d06fe 100644 --- a/entc/integration/edgefield/ent/user_create.go +++ b/entc/integration/edgefield/ent/user_create.go @@ -208,9 +208,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/edgefield/ent/user_update.go b/entc/integration/edgefield/ent/user_update.go index 6fb6b7ebf3..2fd83c72a2 100644 --- a/entc/integration/edgefield/ent/user_update.go +++ b/entc/integration/edgefield/ent/user_update.go @@ -1037,9 +1037,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/card_create.go b/entc/integration/ent/card_create.go index 5d193bd6ee..21c8254e7a 100644 --- a/entc/integration/ent/card_create.go +++ b/entc/integration/ent/card_create.go @@ -164,9 +164,15 @@ func (cc *CardCreate) Save(ctx context.Context) (*Card, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Card) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CardMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/card_update.go b/entc/integration/ent/card_update.go index 27c28a9aeb..e8d79c4902 100644 --- a/entc/integration/ent/card_update.go +++ b/entc/integration/ent/card_update.go @@ -538,9 +538,15 @@ func (cuo *CardUpdateOne) Save(ctx context.Context) (*Card, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Card) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CardMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/comment_create.go b/entc/integration/ent/comment_create.go index 6e2838ea72..b60e7b31ca 100644 --- a/entc/integration/ent/comment_create.go +++ b/entc/integration/ent/comment_create.go @@ -104,9 +104,15 @@ func (cc *CommentCreate) Save(ctx context.Context) (*Comment, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Comment) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CommentMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/comment_update.go b/entc/integration/ent/comment_update.go index cbc620643f..f49de75285 100644 --- a/entc/integration/ent/comment_update.go +++ b/entc/integration/ent/comment_update.go @@ -371,9 +371,15 @@ func (cuo *CommentUpdateOne) Save(ctx context.Context) (*Comment, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Comment) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CommentMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/fieldtype_create.go b/entc/integration/ent/fieldtype_create.go index 62c1a129cb..7165a64650 100644 --- a/entc/integration/ent/fieldtype_create.go +++ b/entc/integration/ent/fieldtype_create.go @@ -829,9 +829,15 @@ func (ftc *FieldTypeCreate) Save(ctx context.Context) (*FieldType, error) { } mut = ftc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ftc.mutation); err != nil { + v, err := mut.Mutate(ctx, ftc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*FieldType) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from FieldTypeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/fieldtype_update.go b/entc/integration/ent/fieldtype_update.go index f93ab7ec8b..7a355ce9ef 100644 --- a/entc/integration/ent/fieldtype_update.go +++ b/entc/integration/ent/fieldtype_update.go @@ -3846,9 +3846,15 @@ func (ftuo *FieldTypeUpdateOne) Save(ctx context.Context) (*FieldType, error) { } mut = ftuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ftuo.mutation); err != nil { + v, err := mut.Mutate(ctx, ftuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*FieldType) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from FieldTypeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/file_create.go b/entc/integration/ent/file_create.go index a500a928fa..3cae6aa1ef 100644 --- a/entc/integration/ent/file_create.go +++ b/entc/integration/ent/file_create.go @@ -183,9 +183,15 @@ func (fc *FileCreate) Save(ctx context.Context) (*File, error) { } mut = fc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, fc.mutation); err != nil { + v, err := mut.Mutate(ctx, fc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*File) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from FileMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/file_update.go b/entc/integration/ent/file_update.go index 56d215952a..ae88a396b4 100644 --- a/entc/integration/ent/file_update.go +++ b/entc/integration/ent/file_update.go @@ -719,9 +719,15 @@ func (fuo *FileUpdateOne) Save(ctx context.Context) (*File, error) { } mut = fuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, fuo.mutation); err != nil { + v, err := mut.Mutate(ctx, fuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*File) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from FileMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/filetype_create.go b/entc/integration/ent/filetype_create.go index 3b3f1a8b4c..426fbe426d 100644 --- a/entc/integration/ent/filetype_create.go +++ b/entc/integration/ent/filetype_create.go @@ -115,9 +115,15 @@ func (ftc *FileTypeCreate) Save(ctx context.Context) (*FileType, error) { } mut = ftc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ftc.mutation); err != nil { + v, err := mut.Mutate(ctx, ftc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*FileType) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from FileTypeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/filetype_update.go b/entc/integration/ent/filetype_update.go index 6b435f4134..7061d1f043 100644 --- a/entc/integration/ent/filetype_update.go +++ b/entc/integration/ent/filetype_update.go @@ -407,9 +407,15 @@ func (ftuo *FileTypeUpdateOne) Save(ctx context.Context) (*FileType, error) { } mut = ftuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ftuo.mutation); err != nil { + v, err := mut.Mutate(ctx, ftuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*FileType) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from FileTypeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/goods_create.go b/entc/integration/ent/goods_create.go index d8945b8493..05195f52d5 100644 --- a/entc/integration/ent/goods_create.go +++ b/entc/integration/ent/goods_create.go @@ -64,9 +64,15 @@ func (gc *GoodsCreate) Save(ctx context.Context) (*Goods, error) { } mut = gc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, gc.mutation); err != nil { + v, err := mut.Mutate(ctx, gc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Goods) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GoodsMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/goods_update.go b/entc/integration/ent/goods_update.go index 9d05a5046a..ca80f00494 100644 --- a/entc/integration/ent/goods_update.go +++ b/entc/integration/ent/goods_update.go @@ -164,9 +164,15 @@ func (guo *GoodsUpdateOne) Save(ctx context.Context) (*Goods, error) { } mut = guo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, guo.mutation); err != nil { + v, err := mut.Mutate(ctx, guo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Goods) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GoodsMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/group_create.go b/entc/integration/ent/group_create.go index b295a3771b..6b8d0ef695 100644 --- a/entc/integration/ent/group_create.go +++ b/entc/integration/ent/group_create.go @@ -179,9 +179,15 @@ func (gc *GroupCreate) Save(ctx context.Context) (*Group, error) { } mut = gc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, gc.mutation); err != nil { + v, err := mut.Mutate(ctx, gc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/group_update.go b/entc/integration/ent/group_update.go index be1aca3c10..6cdf988e00 100644 --- a/entc/integration/ent/group_update.go +++ b/entc/integration/ent/group_update.go @@ -850,9 +850,15 @@ func (guo *GroupUpdateOne) Save(ctx context.Context) (*Group, error) { } mut = guo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, guo.mutation); err != nil { + v, err := mut.Mutate(ctx, guo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/groupinfo_create.go b/entc/integration/ent/groupinfo_create.go index ba5a435301..b690e97a96 100644 --- a/entc/integration/ent/groupinfo_create.go +++ b/entc/integration/ent/groupinfo_create.go @@ -101,9 +101,15 @@ func (gic *GroupInfoCreate) Save(ctx context.Context) (*GroupInfo, error) { } mut = gic.hooks[i](mut) } - if _, err := mut.Mutate(ctx, gic.mutation); err != nil { + v, err := mut.Mutate(ctx, gic.mutation) + if err != nil { return nil, err } + nv, ok := v.(*GroupInfo) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupInfoMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/groupinfo_update.go b/entc/integration/ent/groupinfo_update.go index cb65ed0a1f..073de8c01f 100644 --- a/entc/integration/ent/groupinfo_update.go +++ b/entc/integration/ent/groupinfo_update.go @@ -366,9 +366,15 @@ func (giuo *GroupInfoUpdateOne) Save(ctx context.Context) (*GroupInfo, error) { } mut = giuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, giuo.mutation); err != nil { + v, err := mut.Mutate(ctx, giuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*GroupInfo) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupInfoMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/item_create.go b/entc/integration/ent/item_create.go index 955baa333e..5e78b5c69b 100644 --- a/entc/integration/ent/item_create.go +++ b/entc/integration/ent/item_create.go @@ -94,9 +94,15 @@ func (ic *ItemCreate) Save(ctx context.Context) (*Item, error) { } mut = ic.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ic.mutation); err != nil { + v, err := mut.Mutate(ctx, ic.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Item) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from ItemMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/item_update.go b/entc/integration/ent/item_update.go index c222530301..a6005a0175 100644 --- a/entc/integration/ent/item_update.go +++ b/entc/integration/ent/item_update.go @@ -239,9 +239,15 @@ func (iuo *ItemUpdateOne) Save(ctx context.Context) (*Item, error) { } mut = iuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, iuo.mutation); err != nil { + v, err := mut.Mutate(ctx, iuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Item) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from ItemMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/node_create.go b/entc/integration/ent/node_create.go index 823d99d7f7..ecc5fd8adb 100644 --- a/entc/integration/ent/node_create.go +++ b/entc/integration/ent/node_create.go @@ -116,9 +116,15 @@ func (nc *NodeCreate) Save(ctx context.Context) (*Node, error) { } mut = nc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, nc.mutation); err != nil { + v, err := mut.Mutate(ctx, nc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Node) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from NodeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/node_update.go b/entc/integration/ent/node_update.go index 8573a17b7f..46e41c61cd 100644 --- a/entc/integration/ent/node_update.go +++ b/entc/integration/ent/node_update.go @@ -408,9 +408,15 @@ func (nuo *NodeUpdateOne) Save(ctx context.Context) (*Node, error) { } mut = nuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, nuo.mutation); err != nil { + v, err := mut.Mutate(ctx, nuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Node) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from NodeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/pet_create.go b/entc/integration/ent/pet_create.go index a25dbd3cc1..b4dbe3aed3 100644 --- a/entc/integration/ent/pet_create.go +++ b/entc/integration/ent/pet_create.go @@ -153,9 +153,15 @@ func (pc *PetCreate) Save(ctx context.Context) (*Pet, error) { } mut = pc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, pc.mutation); err != nil { + v, err := mut.Mutate(ctx, pc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/pet_update.go b/entc/integration/ent/pet_update.go index ba8516dda4..f09bc547d7 100644 --- a/entc/integration/ent/pet_update.go +++ b/entc/integration/ent/pet_update.go @@ -517,9 +517,15 @@ func (puo *PetUpdateOne) Save(ctx context.Context) (*Pet, error) { } mut = puo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, puo.mutation); err != nil { + v, err := mut.Mutate(ctx, puo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/spec_create.go b/entc/integration/ent/spec_create.go index cecc5dc8d7..a81f1aabb6 100644 --- a/entc/integration/ent/spec_create.go +++ b/entc/integration/ent/spec_create.go @@ -80,9 +80,15 @@ func (sc *SpecCreate) Save(ctx context.Context) (*Spec, error) { } mut = sc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, sc.mutation); err != nil { + v, err := mut.Mutate(ctx, sc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Spec) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from SpecMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/spec_update.go b/entc/integration/ent/spec_update.go index 5a8a0a1caf..3491ec7ee2 100644 --- a/entc/integration/ent/spec_update.go +++ b/entc/integration/ent/spec_update.go @@ -291,9 +291,15 @@ func (suo *SpecUpdateOne) Save(ctx context.Context) (*Spec, error) { } mut = suo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, suo.mutation); err != nil { + v, err := mut.Mutate(ctx, suo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Spec) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from SpecMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/task_create.go b/entc/integration/ent/task_create.go index 565bd69a09..f9413b0969 100644 --- a/entc/integration/ent/task_create.go +++ b/entc/integration/ent/task_create.go @@ -81,9 +81,15 @@ func (tc *TaskCreate) Save(ctx context.Context) (*Task, error) { } mut = tc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, tc.mutation); err != nil { + v, err := mut.Mutate(ctx, tc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Task) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from TaskMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/task_update.go b/entc/integration/ent/task_update.go index 61f56dcdc0..720fe8d9df 100644 --- a/entc/integration/ent/task_update.go +++ b/entc/integration/ent/task_update.go @@ -244,9 +244,15 @@ func (tuo *TaskUpdateOne) Save(ctx context.Context) (*Task, error) { } mut = tuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, tuo.mutation); err != nil { + v, err := mut.Mutate(ctx, tuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Task) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from TaskMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/user_create.go b/entc/integration/ent/user_create.go index 4d6d472fb5..c832f54474 100644 --- a/entc/integration/ent/user_create.go +++ b/entc/integration/ent/user_create.go @@ -388,9 +388,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/ent/user_update.go b/entc/integration/ent/user_update.go index 62dade7c59..ea8b9c5a09 100644 --- a/entc/integration/ent/user_update.go +++ b/entc/integration/ent/user_update.go @@ -1925,9 +1925,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/card_create.go b/entc/integration/gremlin/ent/card_create.go index 17772f906d..6d8cad8b8f 100644 --- a/entc/integration/gremlin/ent/card_create.go +++ b/entc/integration/gremlin/ent/card_create.go @@ -165,9 +165,15 @@ func (cc *CardCreate) Save(ctx context.Context) (*Card, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Card) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CardMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/card_update.go b/entc/integration/gremlin/ent/card_update.go index 08e0b622bd..9433085bb9 100644 --- a/entc/integration/gremlin/ent/card_update.go +++ b/entc/integration/gremlin/ent/card_update.go @@ -468,9 +468,15 @@ func (cuo *CardUpdateOne) Save(ctx context.Context) (*Card, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Card) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CardMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/comment_create.go b/entc/integration/gremlin/ent/comment_create.go index f09d52e38e..5c582ad28d 100644 --- a/entc/integration/gremlin/ent/comment_create.go +++ b/entc/integration/gremlin/ent/comment_create.go @@ -105,9 +105,15 @@ func (cc *CommentCreate) Save(ctx context.Context) (*Comment, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Comment) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CommentMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/comment_update.go b/entc/integration/gremlin/ent/comment_update.go index 8e24b19681..dfc9d256aa 100644 --- a/entc/integration/gremlin/ent/comment_update.go +++ b/entc/integration/gremlin/ent/comment_update.go @@ -375,9 +375,15 @@ func (cuo *CommentUpdateOne) Save(ctx context.Context) (*Comment, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Comment) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CommentMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/fieldtype_create.go b/entc/integration/gremlin/ent/fieldtype_create.go index 6ad4307f02..f5cd83e75a 100644 --- a/entc/integration/gremlin/ent/fieldtype_create.go +++ b/entc/integration/gremlin/ent/fieldtype_create.go @@ -829,9 +829,15 @@ func (ftc *FieldTypeCreate) Save(ctx context.Context) (*FieldType, error) { } mut = ftc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ftc.mutation); err != nil { + v, err := mut.Mutate(ctx, ftc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*FieldType) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from FieldTypeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/fieldtype_update.go b/entc/integration/gremlin/ent/fieldtype_update.go index bfced177dc..1d83822787 100644 --- a/entc/integration/gremlin/ent/fieldtype_update.go +++ b/entc/integration/gremlin/ent/fieldtype_update.go @@ -3299,9 +3299,15 @@ func (ftuo *FieldTypeUpdateOne) Save(ctx context.Context) (*FieldType, error) { } mut = ftuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ftuo.mutation); err != nil { + v, err := mut.Mutate(ctx, ftuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*FieldType) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from FieldTypeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/file_create.go b/entc/integration/gremlin/ent/file_create.go index 91b7028e93..1de8321069 100644 --- a/entc/integration/gremlin/ent/file_create.go +++ b/entc/integration/gremlin/ent/file_create.go @@ -183,9 +183,15 @@ func (fc *FileCreate) Save(ctx context.Context) (*File, error) { } mut = fc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, fc.mutation); err != nil { + v, err := mut.Mutate(ctx, fc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*File) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from FileMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/file_update.go b/entc/integration/gremlin/ent/file_update.go index 9d38fa5fd6..0757b5aee1 100644 --- a/entc/integration/gremlin/ent/file_update.go +++ b/entc/integration/gremlin/ent/file_update.go @@ -606,9 +606,15 @@ func (fuo *FileUpdateOne) Save(ctx context.Context) (*File, error) { } mut = fuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, fuo.mutation); err != nil { + v, err := mut.Mutate(ctx, fuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*File) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from FileMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/filetype_create.go b/entc/integration/gremlin/ent/filetype_create.go index 5b00f7e3a6..a8c102775b 100644 --- a/entc/integration/gremlin/ent/filetype_create.go +++ b/entc/integration/gremlin/ent/filetype_create.go @@ -115,9 +115,15 @@ func (ftc *FileTypeCreate) Save(ctx context.Context) (*FileType, error) { } mut = ftc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ftc.mutation); err != nil { + v, err := mut.Mutate(ctx, ftc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*FileType) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from FileTypeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/filetype_update.go b/entc/integration/gremlin/ent/filetype_update.go index b61d6f95b8..5da4e9d52e 100644 --- a/entc/integration/gremlin/ent/filetype_update.go +++ b/entc/integration/gremlin/ent/filetype_update.go @@ -371,9 +371,15 @@ func (ftuo *FileTypeUpdateOne) Save(ctx context.Context) (*FileType, error) { } mut = ftuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ftuo.mutation); err != nil { + v, err := mut.Mutate(ctx, ftuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*FileType) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from FileTypeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/goods_create.go b/entc/integration/gremlin/ent/goods_create.go index 8ea73997c3..f076379b09 100644 --- a/entc/integration/gremlin/ent/goods_create.go +++ b/entc/integration/gremlin/ent/goods_create.go @@ -62,9 +62,15 @@ func (gc *GoodsCreate) Save(ctx context.Context) (*Goods, error) { } mut = gc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, gc.mutation); err != nil { + v, err := mut.Mutate(ctx, gc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Goods) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GoodsMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/goods_update.go b/entc/integration/gremlin/ent/goods_update.go index 7d6787064d..76cfe1e1f7 100644 --- a/entc/integration/gremlin/ent/goods_update.go +++ b/entc/integration/gremlin/ent/goods_update.go @@ -160,9 +160,15 @@ func (guo *GoodsUpdateOne) Save(ctx context.Context) (*Goods, error) { } mut = guo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, guo.mutation); err != nil { + v, err := mut.Mutate(ctx, guo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Goods) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GoodsMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/group_create.go b/entc/integration/gremlin/ent/group_create.go index c685b82ee8..3b7d09ac0c 100644 --- a/entc/integration/gremlin/ent/group_create.go +++ b/entc/integration/gremlin/ent/group_create.go @@ -178,9 +178,15 @@ func (gc *GroupCreate) Save(ctx context.Context) (*Group, error) { } mut = gc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, gc.mutation); err != nil { + v, err := mut.Mutate(ctx, gc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/group_update.go b/entc/integration/gremlin/ent/group_update.go index 302e1bc8f5..a1d403ee08 100644 --- a/entc/integration/gremlin/ent/group_update.go +++ b/entc/integration/gremlin/ent/group_update.go @@ -677,9 +677,15 @@ func (guo *GroupUpdateOne) Save(ctx context.Context) (*Group, error) { } mut = guo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, guo.mutation); err != nil { + v, err := mut.Mutate(ctx, guo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/groupinfo_create.go b/entc/integration/gremlin/ent/groupinfo_create.go index e0c49f9f6b..e2581709a8 100644 --- a/entc/integration/gremlin/ent/groupinfo_create.go +++ b/entc/integration/gremlin/ent/groupinfo_create.go @@ -102,9 +102,15 @@ func (gic *GroupInfoCreate) Save(ctx context.Context) (*GroupInfo, error) { } mut = gic.hooks[i](mut) } - if _, err := mut.Mutate(ctx, gic.mutation); err != nil { + v, err := mut.Mutate(ctx, gic.mutation) + if err != nil { return nil, err } + nv, ok := v.(*GroupInfo) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupInfoMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/groupinfo_update.go b/entc/integration/gremlin/ent/groupinfo_update.go index 21e5f1941f..39e4ba7a61 100644 --- a/entc/integration/gremlin/ent/groupinfo_update.go +++ b/entc/integration/gremlin/ent/groupinfo_update.go @@ -327,9 +327,15 @@ func (giuo *GroupInfoUpdateOne) Save(ctx context.Context) (*GroupInfo, error) { } mut = giuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, giuo.mutation); err != nil { + v, err := mut.Mutate(ctx, giuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*GroupInfo) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupInfoMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/item_create.go b/entc/integration/gremlin/ent/item_create.go index 9adbbcff0f..301adb771c 100644 --- a/entc/integration/gremlin/ent/item_create.go +++ b/entc/integration/gremlin/ent/item_create.go @@ -93,9 +93,15 @@ func (ic *ItemCreate) Save(ctx context.Context) (*Item, error) { } mut = ic.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ic.mutation); err != nil { + v, err := mut.Mutate(ctx, ic.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Item) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from ItemMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/item_update.go b/entc/integration/gremlin/ent/item_update.go index 88acc9bb7f..c23522265b 100644 --- a/entc/integration/gremlin/ent/item_update.go +++ b/entc/integration/gremlin/ent/item_update.go @@ -256,9 +256,15 @@ func (iuo *ItemUpdateOne) Save(ctx context.Context) (*Item, error) { } mut = iuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, iuo.mutation); err != nil { + v, err := mut.Mutate(ctx, iuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Item) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from ItemMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/node_create.go b/entc/integration/gremlin/ent/node_create.go index a5e9e7bc23..de218de870 100644 --- a/entc/integration/gremlin/ent/node_create.go +++ b/entc/integration/gremlin/ent/node_create.go @@ -116,9 +116,15 @@ func (nc *NodeCreate) Save(ctx context.Context) (*Node, error) { } mut = nc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, nc.mutation); err != nil { + v, err := mut.Mutate(ctx, nc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Node) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from NodeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/node_update.go b/entc/integration/gremlin/ent/node_update.go index 4db7df352e..99d44d101e 100644 --- a/entc/integration/gremlin/ent/node_update.go +++ b/entc/integration/gremlin/ent/node_update.go @@ -369,9 +369,15 @@ func (nuo *NodeUpdateOne) Save(ctx context.Context) (*Node, error) { } mut = nuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, nuo.mutation); err != nil { + v, err := mut.Mutate(ctx, nuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Node) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from NodeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/pet_create.go b/entc/integration/gremlin/ent/pet_create.go index e5ab6f0616..3dcb473aaf 100644 --- a/entc/integration/gremlin/ent/pet_create.go +++ b/entc/integration/gremlin/ent/pet_create.go @@ -154,9 +154,15 @@ func (pc *PetCreate) Save(ctx context.Context) (*Pet, error) { } mut = pc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, pc.mutation); err != nil { + v, err := mut.Mutate(ctx, pc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/pet_update.go b/entc/integration/gremlin/ent/pet_update.go index 0686d0b4b9..11b4f92807 100644 --- a/entc/integration/gremlin/ent/pet_update.go +++ b/entc/integration/gremlin/ent/pet_update.go @@ -459,9 +459,15 @@ func (puo *PetUpdateOne) Save(ctx context.Context) (*Pet, error) { } mut = puo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, puo.mutation); err != nil { + v, err := mut.Mutate(ctx, puo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/spec_create.go b/entc/integration/gremlin/ent/spec_create.go index 9839aaef73..1dafe309a8 100644 --- a/entc/integration/gremlin/ent/spec_create.go +++ b/entc/integration/gremlin/ent/spec_create.go @@ -77,9 +77,15 @@ func (sc *SpecCreate) Save(ctx context.Context) (*Spec, error) { } mut = sc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, sc.mutation); err != nil { + v, err := mut.Mutate(ctx, sc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Spec) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from SpecMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/spec_update.go b/entc/integration/gremlin/ent/spec_update.go index e6a9495529..e6ded718af 100644 --- a/entc/integration/gremlin/ent/spec_update.go +++ b/entc/integration/gremlin/ent/spec_update.go @@ -243,9 +243,15 @@ func (suo *SpecUpdateOne) Save(ctx context.Context) (*Spec, error) { } mut = suo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, suo.mutation); err != nil { + v, err := mut.Mutate(ctx, suo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Spec) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from SpecMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/task_create.go b/entc/integration/gremlin/ent/task_create.go index 4192e53331..26c476aa22 100644 --- a/entc/integration/gremlin/ent/task_create.go +++ b/entc/integration/gremlin/ent/task_create.go @@ -80,9 +80,15 @@ func (tc *TaskCreate) Save(ctx context.Context) (*Task, error) { } mut = tc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, tc.mutation); err != nil { + v, err := mut.Mutate(ctx, tc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Task) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from TaskMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/task_update.go b/entc/integration/gremlin/ent/task_update.go index 7252486e6e..86b55b5a3f 100644 --- a/entc/integration/gremlin/ent/task_update.go +++ b/entc/integration/gremlin/ent/task_update.go @@ -233,9 +233,15 @@ func (tuo *TaskUpdateOne) Save(ctx context.Context) (*Task, error) { } mut = tuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, tuo.mutation); err != nil { + v, err := mut.Mutate(ctx, tuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Task) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from TaskMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/user_create.go b/entc/integration/gremlin/ent/user_create.go index 6d9d3eecd9..fb1f659672 100644 --- a/entc/integration/gremlin/ent/user_create.go +++ b/entc/integration/gremlin/ent/user_create.go @@ -385,9 +385,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/gremlin/ent/user_update.go b/entc/integration/gremlin/ent/user_update.go index 452e5c483a..1a8192cd9a 100644 --- a/entc/integration/gremlin/ent/user_update.go +++ b/entc/integration/gremlin/ent/user_update.go @@ -1466,9 +1466,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/hooks/ent/card_create.go b/entc/integration/hooks/ent/card_create.go index 432ac62b2f..2ace168190 100644 --- a/entc/integration/hooks/ent/card_create.go +++ b/entc/integration/hooks/ent/card_create.go @@ -134,9 +134,15 @@ func (cc *CardCreate) Save(ctx context.Context) (*Card, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Card) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CardMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/hooks/ent/card_update.go b/entc/integration/hooks/ent/card_update.go index 334608c5e2..31483d1088 100644 --- a/entc/integration/hooks/ent/card_update.go +++ b/entc/integration/hooks/ent/card_update.go @@ -358,9 +358,15 @@ func (cuo *CardUpdateOne) Save(ctx context.Context) (*Card, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Card) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CardMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/hooks/ent/user_create.go b/entc/integration/hooks/ent/user_create.go index 3bceef91cb..ccc1b34405 100644 --- a/entc/integration/hooks/ent/user_create.go +++ b/entc/integration/hooks/ent/user_create.go @@ -163,9 +163,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/hooks/ent/user_update.go b/entc/integration/hooks/ent/user_update.go index d7d835b58a..a75e68e6d8 100644 --- a/entc/integration/hooks/ent/user_update.go +++ b/entc/integration/hooks/ent/user_update.go @@ -704,9 +704,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/idtype/ent/user_create.go b/entc/integration/idtype/ent/user_create.go index c7ba9de21a..b305d6fb15 100644 --- a/entc/integration/idtype/ent/user_create.go +++ b/entc/integration/idtype/ent/user_create.go @@ -117,9 +117,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/idtype/ent/user_update.go b/entc/integration/idtype/ent/user_update.go index 0956af973c..d7a6d9f70e 100644 --- a/entc/integration/idtype/ent/user_update.go +++ b/entc/integration/idtype/ent/user_update.go @@ -520,9 +520,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/json/ent/user_create.go b/entc/integration/json/ent/user_create.go index bc1239d09c..171de31ed0 100644 --- a/entc/integration/json/ent/user_create.go +++ b/entc/integration/json/ent/user_create.go @@ -123,9 +123,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/json/ent/user_update.go b/entc/integration/json/ent/user_update.go index 8a118c4ae1..59b97bf282 100644 --- a/entc/integration/json/ent/user_update.go +++ b/entc/integration/json/ent/user_update.go @@ -462,9 +462,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv1/car_create.go b/entc/integration/migrate/entv1/car_create.go index 9ae68f8fe0..db0fcdda69 100644 --- a/entc/integration/migrate/entv1/car_create.go +++ b/entc/integration/migrate/entv1/car_create.go @@ -81,9 +81,15 @@ func (cc *CarCreate) Save(ctx context.Context) (*Car, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Car) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CarMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv1/car_update.go b/entc/integration/migrate/entv1/car_update.go index 2c3207d0d4..149b3a9acc 100644 --- a/entc/integration/migrate/entv1/car_update.go +++ b/entc/integration/migrate/entv1/car_update.go @@ -250,9 +250,15 @@ func (cuo *CarUpdateOne) Save(ctx context.Context) (*Car, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Car) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CarMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv1/conversion_create.go b/entc/integration/migrate/entv1/conversion_create.go index 354450ca75..f815eb89ec 100644 --- a/entc/integration/migrate/entv1/conversion_create.go +++ b/entc/integration/migrate/entv1/conversion_create.go @@ -187,9 +187,15 @@ func (cc *ConversionCreate) Save(ctx context.Context) (*Conversion, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Conversion) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from ConversionMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv1/conversion_update.go b/entc/integration/migrate/entv1/conversion_update.go index 23c8c7fc91..b57a6495a0 100644 --- a/entc/integration/migrate/entv1/conversion_update.go +++ b/entc/integration/migrate/entv1/conversion_update.go @@ -809,9 +809,15 @@ func (cuo *ConversionUpdateOne) Save(ctx context.Context) (*Conversion, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Conversion) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from ConversionMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv1/customtype_create.go b/entc/integration/migrate/entv1/customtype_create.go index adffcdfc7a..b22d1e33ae 100644 --- a/entc/integration/migrate/entv1/customtype_create.go +++ b/entc/integration/migrate/entv1/customtype_create.go @@ -75,9 +75,15 @@ func (ctc *CustomTypeCreate) Save(ctx context.Context) (*CustomType, error) { } mut = ctc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ctc.mutation); err != nil { + v, err := mut.Mutate(ctx, ctc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*CustomType) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CustomTypeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv1/customtype_update.go b/entc/integration/migrate/entv1/customtype_update.go index c512466a6f..d88d7bbb70 100644 --- a/entc/integration/migrate/entv1/customtype_update.go +++ b/entc/integration/migrate/entv1/customtype_update.go @@ -217,9 +217,15 @@ func (ctuo *CustomTypeUpdateOne) Save(ctx context.Context) (*CustomType, error) } mut = ctuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ctuo.mutation); err != nil { + v, err := mut.Mutate(ctx, ctuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*CustomType) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CustomTypeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv1/user_create.go b/entc/integration/migrate/entv1/user_create.go index 05e196054b..7cc5771f5c 100644 --- a/entc/integration/migrate/entv1/user_create.go +++ b/entc/integration/migrate/entv1/user_create.go @@ -278,9 +278,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv1/user_update.go b/entc/integration/migrate/entv1/user_update.go index aea634bdad..db94a87599 100644 --- a/entc/integration/migrate/entv1/user_update.go +++ b/entc/integration/migrate/entv1/user_update.go @@ -1104,9 +1104,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv2/car_create.go b/entc/integration/migrate/entv2/car_create.go index fd14b2f2e4..eaf99f4f59 100644 --- a/entc/integration/migrate/entv2/car_create.go +++ b/entc/integration/migrate/entv2/car_create.go @@ -88,9 +88,15 @@ func (cc *CarCreate) Save(ctx context.Context) (*Car, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Car) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CarMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv2/car_update.go b/entc/integration/migrate/entv2/car_update.go index 538af98443..de762f4d33 100644 --- a/entc/integration/migrate/entv2/car_update.go +++ b/entc/integration/migrate/entv2/car_update.go @@ -307,9 +307,15 @@ func (cuo *CarUpdateOne) Save(ctx context.Context) (*Car, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Car) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CarMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv2/conversion_create.go b/entc/integration/migrate/entv2/conversion_create.go index 860ce6978c..66abbf649d 100644 --- a/entc/integration/migrate/entv2/conversion_create.go +++ b/entc/integration/migrate/entv2/conversion_create.go @@ -187,9 +187,15 @@ func (cc *ConversionCreate) Save(ctx context.Context) (*Conversion, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Conversion) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from ConversionMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv2/conversion_update.go b/entc/integration/migrate/entv2/conversion_update.go index 7efdec8c10..d7a298d8d0 100644 --- a/entc/integration/migrate/entv2/conversion_update.go +++ b/entc/integration/migrate/entv2/conversion_update.go @@ -641,9 +641,15 @@ func (cuo *ConversionUpdateOne) Save(ctx context.Context) (*Conversion, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Conversion) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from ConversionMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv2/customtype_create.go b/entc/integration/migrate/entv2/customtype_create.go index bae326d9c2..1ce2a03ebd 100644 --- a/entc/integration/migrate/entv2/customtype_create.go +++ b/entc/integration/migrate/entv2/customtype_create.go @@ -104,9 +104,15 @@ func (ctc *CustomTypeCreate) Save(ctx context.Context) (*CustomType, error) { } mut = ctc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ctc.mutation); err != nil { + v, err := mut.Mutate(ctx, ctc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*CustomType) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CustomTypeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv2/customtype_update.go b/entc/integration/migrate/entv2/customtype_update.go index 2bd4e9eb3d..2085d21a37 100644 --- a/entc/integration/migrate/entv2/customtype_update.go +++ b/entc/integration/migrate/entv2/customtype_update.go @@ -324,9 +324,15 @@ func (ctuo *CustomTypeUpdateOne) Save(ctx context.Context) (*CustomType, error) } mut = ctuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, ctuo.mutation); err != nil { + v, err := mut.Mutate(ctx, ctuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*CustomType) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CustomTypeMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv2/group_create.go b/entc/integration/migrate/entv2/group_create.go index abc1a4bda4..ed82cd8c0f 100644 --- a/entc/integration/migrate/entv2/group_create.go +++ b/entc/integration/migrate/entv2/group_create.go @@ -61,9 +61,15 @@ func (gc *GroupCreate) Save(ctx context.Context) (*Group, error) { } mut = gc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, gc.mutation); err != nil { + v, err := mut.Mutate(ctx, gc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv2/group_update.go b/entc/integration/migrate/entv2/group_update.go index c6253599b6..e8d1566b5b 100644 --- a/entc/integration/migrate/entv2/group_update.go +++ b/entc/integration/migrate/entv2/group_update.go @@ -164,9 +164,15 @@ func (guo *GroupUpdateOne) Save(ctx context.Context) (*Group, error) { } mut = guo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, guo.mutation); err != nil { + v, err := mut.Mutate(ctx, guo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv2/media_create.go b/entc/integration/migrate/entv2/media_create.go index 2ab35681f4..e59e10a316 100644 --- a/entc/integration/migrate/entv2/media_create.go +++ b/entc/integration/migrate/entv2/media_create.go @@ -103,9 +103,15 @@ func (mc *MediaCreate) Save(ctx context.Context) (*Media, error) { } mut = mc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, mc.mutation); err != nil { + v, err := mut.Mutate(ctx, mc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Media) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from MediaMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv2/media_update.go b/entc/integration/migrate/entv2/media_update.go index d1e5308042..2fac2618c7 100644 --- a/entc/integration/migrate/entv2/media_update.go +++ b/entc/integration/migrate/entv2/media_update.go @@ -323,9 +323,15 @@ func (muo *MediaUpdateOne) Save(ctx context.Context) (*Media, error) { } mut = muo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, muo.mutation); err != nil { + v, err := mut.Mutate(ctx, muo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Media) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from MediaMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv2/pet_create.go b/entc/integration/migrate/entv2/pet_create.go index 95f86a5a58..4a008c0bd6 100644 --- a/entc/integration/migrate/entv2/pet_create.go +++ b/entc/integration/migrate/entv2/pet_create.go @@ -95,9 +95,15 @@ func (pc *PetCreate) Save(ctx context.Context) (*Pet, error) { } mut = pc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, pc.mutation); err != nil { + v, err := mut.Mutate(ctx, pc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv2/pet_update.go b/entc/integration/migrate/entv2/pet_update.go index 7fcb9cbc50..2a0c6dd5dd 100644 --- a/entc/integration/migrate/entv2/pet_update.go +++ b/entc/integration/migrate/entv2/pet_update.go @@ -303,9 +303,15 @@ func (puo *PetUpdateOne) Save(ctx context.Context) (*Pet, error) { } mut = puo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, puo.mutation); err != nil { + v, err := mut.Mutate(ctx, puo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv2/user_create.go b/entc/integration/migrate/entv2/user_create.go index db430fc91b..75a24aa6f1 100644 --- a/entc/integration/migrate/entv2/user_create.go +++ b/entc/integration/migrate/entv2/user_create.go @@ -319,9 +319,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/entv2/user_update.go b/entc/integration/migrate/entv2/user_update.go index 474b3c6632..9677ba494f 100644 --- a/entc/integration/migrate/entv2/user_update.go +++ b/entc/integration/migrate/entv2/user_update.go @@ -1208,9 +1208,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/versioned/user_create.go b/entc/integration/migrate/versioned/user_create.go index 9f11d08aec..b0ac225b8d 100644 --- a/entc/integration/migrate/versioned/user_create.go +++ b/entc/integration/migrate/versioned/user_create.go @@ -108,9 +108,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/migrate/versioned/user_update.go b/entc/integration/migrate/versioned/user_update.go index ad205df5b4..fc287fdf80 100644 --- a/entc/integration/migrate/versioned/user_update.go +++ b/entc/integration/migrate/versioned/user_update.go @@ -351,9 +351,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/multischema/ent/group_create.go b/entc/integration/multischema/ent/group_create.go index b02c841b06..47134d1701 100644 --- a/entc/integration/multischema/ent/group_create.go +++ b/entc/integration/multischema/ent/group_create.go @@ -93,9 +93,15 @@ func (gc *GroupCreate) Save(ctx context.Context) (*Group, error) { } mut = gc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, gc.mutation); err != nil { + v, err := mut.Mutate(ctx, gc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/multischema/ent/group_update.go b/entc/integration/multischema/ent/group_update.go index 396769ce5c..8aecb6454c 100644 --- a/entc/integration/multischema/ent/group_update.go +++ b/entc/integration/multischema/ent/group_update.go @@ -332,9 +332,15 @@ func (guo *GroupUpdateOne) Save(ctx context.Context) (*Group, error) { } mut = guo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, guo.mutation); err != nil { + v, err := mut.Mutate(ctx, guo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/multischema/ent/pet_create.go b/entc/integration/multischema/ent/pet_create.go index d55af1f220..cb38a47943 100644 --- a/entc/integration/multischema/ent/pet_create.go +++ b/entc/integration/multischema/ent/pet_create.go @@ -97,9 +97,15 @@ func (pc *PetCreate) Save(ctx context.Context) (*Pet, error) { } mut = pc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, pc.mutation); err != nil { + v, err := mut.Mutate(ctx, pc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/multischema/ent/pet_update.go b/entc/integration/multischema/ent/pet_update.go index 1590d50ce6..67abdfa5e6 100644 --- a/entc/integration/multischema/ent/pet_update.go +++ b/entc/integration/multischema/ent/pet_update.go @@ -302,9 +302,15 @@ func (puo *PetUpdateOne) Save(ctx context.Context) (*Pet, error) { } mut = puo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, puo.mutation); err != nil { + v, err := mut.Mutate(ctx, puo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/multischema/ent/user_create.go b/entc/integration/multischema/ent/user_create.go index d6627111ae..09431a64f7 100644 --- a/entc/integration/multischema/ent/user_create.go +++ b/entc/integration/multischema/ent/user_create.go @@ -109,9 +109,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/multischema/ent/user_update.go b/entc/integration/multischema/ent/user_update.go index 8a27795a28..197ae59395 100644 --- a/entc/integration/multischema/ent/user_update.go +++ b/entc/integration/multischema/ent/user_update.go @@ -462,9 +462,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/privacy/ent/task_create.go b/entc/integration/privacy/ent/task_create.go index f515d50e9e..62f92848d1 100644 --- a/entc/integration/privacy/ent/task_create.go +++ b/entc/integration/privacy/ent/task_create.go @@ -150,9 +150,15 @@ func (tc *TaskCreate) Save(ctx context.Context) (*Task, error) { } mut = tc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, tc.mutation); err != nil { + v, err := mut.Mutate(ctx, tc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Task) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from TaskMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/privacy/ent/task_update.go b/entc/integration/privacy/ent/task_update.go index c667406756..24a00db522 100644 --- a/entc/integration/privacy/ent/task_update.go +++ b/entc/integration/privacy/ent/task_update.go @@ -565,9 +565,15 @@ func (tuo *TaskUpdateOne) Save(ctx context.Context) (*Task, error) { } mut = tuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, tuo.mutation); err != nil { + v, err := mut.Mutate(ctx, tuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Task) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from TaskMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/privacy/ent/team_create.go b/entc/integration/privacy/ent/team_create.go index 5eacaa15d5..939da4b41d 100644 --- a/entc/integration/privacy/ent/team_create.go +++ b/entc/integration/privacy/ent/team_create.go @@ -100,9 +100,15 @@ func (tc *TeamCreate) Save(ctx context.Context) (*Team, error) { } mut = tc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, tc.mutation); err != nil { + v, err := mut.Mutate(ctx, tc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Team) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from TeamMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/privacy/ent/team_update.go b/entc/integration/privacy/ent/team_update.go index e86a09e606..2542ef2ffe 100644 --- a/entc/integration/privacy/ent/team_update.go +++ b/entc/integration/privacy/ent/team_update.go @@ -459,9 +459,15 @@ func (tuo *TeamUpdateOne) Save(ctx context.Context) (*Team, error) { } mut = tuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, tuo.mutation); err != nil { + v, err := mut.Mutate(ctx, tuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Team) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from TeamMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/privacy/ent/user_create.go b/entc/integration/privacy/ent/user_create.go index a3438236f2..6dfa80c0af 100644 --- a/entc/integration/privacy/ent/user_create.go +++ b/entc/integration/privacy/ent/user_create.go @@ -114,9 +114,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/privacy/ent/user_update.go b/entc/integration/privacy/ent/user_update.go index e791048408..a184edf95b 100644 --- a/entc/integration/privacy/ent/user_update.go +++ b/entc/integration/privacy/ent/user_update.go @@ -492,9 +492,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/template/ent/group_create.go b/entc/integration/template/ent/group_create.go index de7da95048..b1894ae05d 100644 --- a/entc/integration/template/ent/group_create.go +++ b/entc/integration/template/ent/group_create.go @@ -68,9 +68,15 @@ func (gc *GroupCreate) Save(ctx context.Context) (*Group, error) { } mut = gc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, gc.mutation); err != nil { + v, err := mut.Mutate(ctx, gc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/template/ent/group_update.go b/entc/integration/template/ent/group_update.go index ac5174846d..6b07c22f7a 100644 --- a/entc/integration/template/ent/group_update.go +++ b/entc/integration/template/ent/group_update.go @@ -204,9 +204,15 @@ func (guo *GroupUpdateOne) Save(ctx context.Context) (*Group, error) { } mut = guo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, guo.mutation); err != nil { + v, err := mut.Mutate(ctx, guo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/template/ent/pet_create.go b/entc/integration/template/ent/pet_create.go index 6dc842d90d..8ea9aef642 100644 --- a/entc/integration/template/ent/pet_create.go +++ b/entc/integration/template/ent/pet_create.go @@ -103,9 +103,15 @@ func (pc *PetCreate) Save(ctx context.Context) (*Pet, error) { } mut = pc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, pc.mutation); err != nil { + v, err := mut.Mutate(ctx, pc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/template/ent/pet_update.go b/entc/integration/template/ent/pet_update.go index 8bc568ea32..d78be99fbb 100644 --- a/entc/integration/template/ent/pet_update.go +++ b/entc/integration/template/ent/pet_update.go @@ -344,9 +344,15 @@ func (puo *PetUpdateOne) Save(ctx context.Context) (*Pet, error) { } mut = puo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, puo.mutation); err != nil { + v, err := mut.Mutate(ctx, puo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/template/ent/user_create.go b/entc/integration/template/ent/user_create.go index 7b5a6975a6..ce2b5531df 100644 --- a/entc/integration/template/ent/user_create.go +++ b/entc/integration/template/ent/user_create.go @@ -99,9 +99,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/entc/integration/template/ent/user_update.go b/entc/integration/template/ent/user_update.go index 6111e93819..5fafb8f75b 100644 --- a/entc/integration/template/ent/user_update.go +++ b/entc/integration/template/ent/user_update.go @@ -436,9 +436,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } From 480cb19b16f1bd4f8d5ffba527ed75542dd6f569 Mon Sep 17 00:00:00 2001 From: Justin Johnson Date: Thu, 5 May 2022 00:14:48 -0700 Subject: [PATCH 8/8] regen from root --- examples/edgeindex/ent/city_create.go | 8 +++++++- examples/edgeindex/ent/city_update.go | 8 +++++++- examples/edgeindex/ent/street_create.go | 8 +++++++- examples/edgeindex/ent/street_update.go | 8 +++++++- examples/entcpkg/ent/user_create.go | 8 +++++++- examples/entcpkg/ent/user_update.go | 8 +++++++- examples/fs/ent/file_create.go | 8 +++++++- examples/fs/ent/file_update.go | 8 +++++++- examples/m2m2types/ent/group_create.go | 8 +++++++- examples/m2m2types/ent/group_update.go | 8 +++++++- examples/m2m2types/ent/user_create.go | 8 +++++++- examples/m2m2types/ent/user_update.go | 8 +++++++- examples/m2mbidi/ent/user_create.go | 8 +++++++- examples/m2mbidi/ent/user_update.go | 8 +++++++- examples/m2mrecur/ent/user_create.go | 8 +++++++- examples/m2mrecur/ent/user_update.go | 8 +++++++- examples/o2m2types/ent/pet_create.go | 8 +++++++- examples/o2m2types/ent/pet_update.go | 8 +++++++- examples/o2m2types/ent/user_create.go | 8 +++++++- examples/o2m2types/ent/user_update.go | 8 +++++++- examples/o2mrecur/ent/node_create.go | 8 +++++++- examples/o2mrecur/ent/node_update.go | 8 +++++++- examples/o2o2types/ent/card_create.go | 8 +++++++- examples/o2o2types/ent/card_update.go | 8 +++++++- examples/o2o2types/ent/user_create.go | 8 +++++++- examples/o2o2types/ent/user_update.go | 8 +++++++- examples/o2obidi/ent/user_create.go | 8 +++++++- examples/o2obidi/ent/user_update.go | 8 +++++++- examples/o2orecur/ent/node_create.go | 8 +++++++- examples/o2orecur/ent/node_update.go | 8 +++++++- examples/privacyadmin/ent/user_create.go | 8 +++++++- examples/privacyadmin/ent/user_update.go | 8 +++++++- examples/privacytenant/ent/group_create.go | 8 +++++++- examples/privacytenant/ent/group_update.go | 8 +++++++- examples/privacytenant/ent/tenant_create.go | 8 +++++++- examples/privacytenant/ent/tenant_update.go | 8 +++++++- examples/privacytenant/ent/user_create.go | 8 +++++++- examples/privacytenant/ent/user_update.go | 8 +++++++- examples/start/ent/car_create.go | 8 +++++++- examples/start/ent/car_update.go | 8 +++++++- examples/start/ent/group_create.go | 8 +++++++- examples/start/ent/group_update.go | 8 +++++++- examples/start/ent/user_create.go | 8 +++++++- examples/start/ent/user_update.go | 8 +++++++- examples/traversal/ent/group_create.go | 8 +++++++- examples/traversal/ent/group_update.go | 8 +++++++- examples/traversal/ent/pet_create.go | 8 +++++++- examples/traversal/ent/pet_update.go | 8 +++++++- examples/traversal/ent/user_create.go | 8 +++++++- examples/traversal/ent/user_update.go | 8 +++++++- examples/version/ent/user_create.go | 8 +++++++- examples/version/ent/user_update.go | 8 +++++++- 52 files changed, 364 insertions(+), 52 deletions(-) diff --git a/examples/edgeindex/ent/city_create.go b/examples/edgeindex/ent/city_create.go index f36fd179ac..085d969adc 100644 --- a/examples/edgeindex/ent/city_create.go +++ b/examples/edgeindex/ent/city_create.go @@ -84,9 +84,15 @@ func (cc *CityCreate) Save(ctx context.Context) (*City, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*City) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CityMutation", v) + } + node = nv } return node, err } diff --git a/examples/edgeindex/ent/city_update.go b/examples/edgeindex/ent/city_update.go index 84e0a6076d..4c4d38e992 100644 --- a/examples/edgeindex/ent/city_update.go +++ b/examples/edgeindex/ent/city_update.go @@ -310,9 +310,15 @@ func (cuo *CityUpdateOne) Save(ctx context.Context) (*City, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*City) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CityMutation", v) + } + node = nv } return node, err } diff --git a/examples/edgeindex/ent/street_create.go b/examples/edgeindex/ent/street_create.go index a4f271aefe..a6420ef2d2 100644 --- a/examples/edgeindex/ent/street_create.go +++ b/examples/edgeindex/ent/street_create.go @@ -88,9 +88,15 @@ func (sc *StreetCreate) Save(ctx context.Context) (*Street, error) { } mut = sc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, sc.mutation); err != nil { + v, err := mut.Mutate(ctx, sc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Street) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from StreetMutation", v) + } + node = nv } return node, err } diff --git a/examples/edgeindex/ent/street_update.go b/examples/edgeindex/ent/street_update.go index 7d3ac92485..17b2a89099 100644 --- a/examples/edgeindex/ent/street_update.go +++ b/examples/edgeindex/ent/street_update.go @@ -269,9 +269,15 @@ func (suo *StreetUpdateOne) Save(ctx context.Context) (*Street, error) { } mut = suo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, suo.mutation); err != nil { + v, err := mut.Mutate(ctx, suo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Street) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from StreetMutation", v) + } + node = nv } return node, err } diff --git a/examples/entcpkg/ent/user_create.go b/examples/entcpkg/ent/user_create.go index 861ba567f7..6891b035ab 100644 --- a/examples/entcpkg/ent/user_create.go +++ b/examples/entcpkg/ent/user_create.go @@ -89,9 +89,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/entcpkg/ent/user_update.go b/examples/entcpkg/ent/user_update.go index 6f8c962d06..3fd904a0b9 100644 --- a/examples/entcpkg/ent/user_update.go +++ b/examples/entcpkg/ent/user_update.go @@ -291,9 +291,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/fs/ent/file_create.go b/examples/fs/ent/file_create.go index 841ad74589..15f065b2db 100644 --- a/examples/fs/ent/file_create.go +++ b/examples/fs/ent/file_create.go @@ -117,9 +117,15 @@ func (fc *FileCreate) Save(ctx context.Context) (*File, error) { } mut = fc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, fc.mutation); err != nil { + v, err := mut.Mutate(ctx, fc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*File) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from FileMutation", v) + } + node = nv } return node, err } diff --git a/examples/fs/ent/file_update.go b/examples/fs/ent/file_update.go index 4b93a339ad..acf14317ad 100644 --- a/examples/fs/ent/file_update.go +++ b/examples/fs/ent/file_update.go @@ -441,9 +441,15 @@ func (fuo *FileUpdateOne) Save(ctx context.Context) (*File, error) { } mut = fuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, fuo.mutation); err != nil { + v, err := mut.Mutate(ctx, fuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*File) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from FileMutation", v) + } + node = nv } return node, err } diff --git a/examples/m2m2types/ent/group_create.go b/examples/m2m2types/ent/group_create.go index 83fea600a6..2ae85d9427 100644 --- a/examples/m2m2types/ent/group_create.go +++ b/examples/m2m2types/ent/group_create.go @@ -84,9 +84,15 @@ func (gc *GroupCreate) Save(ctx context.Context) (*Group, error) { } mut = gc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, gc.mutation); err != nil { + v, err := mut.Mutate(ctx, gc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/examples/m2m2types/ent/group_update.go b/examples/m2m2types/ent/group_update.go index 06fd1fc7d5..7f456ef004 100644 --- a/examples/m2m2types/ent/group_update.go +++ b/examples/m2m2types/ent/group_update.go @@ -310,9 +310,15 @@ func (guo *GroupUpdateOne) Save(ctx context.Context) (*Group, error) { } mut = guo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, guo.mutation); err != nil { + v, err := mut.Mutate(ctx, guo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/examples/m2m2types/ent/user_create.go b/examples/m2m2types/ent/user_create.go index 1180f586ec..c92e050296 100644 --- a/examples/m2m2types/ent/user_create.go +++ b/examples/m2m2types/ent/user_create.go @@ -90,9 +90,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/m2m2types/ent/user_update.go b/examples/m2m2types/ent/user_update.go index 877af0d7d7..deda78754d 100644 --- a/examples/m2m2types/ent/user_update.go +++ b/examples/m2m2types/ent/user_update.go @@ -350,9 +350,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/m2mbidi/ent/user_create.go b/examples/m2mbidi/ent/user_create.go index 9c9866687b..9ad2427111 100644 --- a/examples/m2mbidi/ent/user_create.go +++ b/examples/m2mbidi/ent/user_create.go @@ -89,9 +89,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/m2mbidi/ent/user_update.go b/examples/m2mbidi/ent/user_update.go index d3f8cdfc30..fcf2f2a434 100644 --- a/examples/m2mbidi/ent/user_update.go +++ b/examples/m2mbidi/ent/user_update.go @@ -349,9 +349,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/m2mrecur/ent/user_create.go b/examples/m2mrecur/ent/user_create.go index 827dee59dd..2b93337330 100644 --- a/examples/m2mrecur/ent/user_create.go +++ b/examples/m2mrecur/ent/user_create.go @@ -104,9 +104,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/m2mrecur/ent/user_update.go b/examples/m2mrecur/ent/user_update.go index 274e43c996..f50cba06ab 100644 --- a/examples/m2mrecur/ent/user_update.go +++ b/examples/m2mrecur/ent/user_update.go @@ -475,9 +475,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/o2m2types/ent/pet_create.go b/examples/o2m2types/ent/pet_create.go index 4a3a834ba5..4fc5f50023 100644 --- a/examples/o2m2types/ent/pet_create.go +++ b/examples/o2m2types/ent/pet_create.go @@ -88,9 +88,15 @@ func (pc *PetCreate) Save(ctx context.Context) (*Pet, error) { } mut = pc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, pc.mutation); err != nil { + v, err := mut.Mutate(ctx, pc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/examples/o2m2types/ent/pet_update.go b/examples/o2m2types/ent/pet_update.go index 5227d57f86..1ad9e26672 100644 --- a/examples/o2m2types/ent/pet_update.go +++ b/examples/o2m2types/ent/pet_update.go @@ -269,9 +269,15 @@ func (puo *PetUpdateOne) Save(ctx context.Context) (*Pet, error) { } mut = puo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, puo.mutation); err != nil { + v, err := mut.Mutate(ctx, puo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/examples/o2m2types/ent/user_create.go b/examples/o2m2types/ent/user_create.go index ca159858f0..c803f77fc9 100644 --- a/examples/o2m2types/ent/user_create.go +++ b/examples/o2m2types/ent/user_create.go @@ -90,9 +90,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/o2m2types/ent/user_update.go b/examples/o2m2types/ent/user_update.go index 859fa278e3..6d62805572 100644 --- a/examples/o2m2types/ent/user_update.go +++ b/examples/o2m2types/ent/user_update.go @@ -350,9 +350,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/o2mrecur/ent/node_create.go b/examples/o2mrecur/ent/node_create.go index 735543ea1e..986274c512 100644 --- a/examples/o2mrecur/ent/node_create.go +++ b/examples/o2mrecur/ent/node_create.go @@ -102,9 +102,15 @@ func (nc *NodeCreate) Save(ctx context.Context) (*Node, error) { } mut = nc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, nc.mutation); err != nil { + v, err := mut.Mutate(ctx, nc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Node) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from NodeMutation", v) + } + node = nv } return node, err } diff --git a/examples/o2mrecur/ent/node_update.go b/examples/o2mrecur/ent/node_update.go index 6ebd719939..3a24ef28a9 100644 --- a/examples/o2mrecur/ent/node_update.go +++ b/examples/o2mrecur/ent/node_update.go @@ -415,9 +415,15 @@ func (nuo *NodeUpdateOne) Save(ctx context.Context) (*Node, error) { } mut = nuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, nuo.mutation); err != nil { + v, err := mut.Mutate(ctx, nuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Node) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from NodeMutation", v) + } + node = nv } return node, err } diff --git a/examples/o2o2types/ent/card_create.go b/examples/o2o2types/ent/card_create.go index 604a14f7cd..d32668e15f 100644 --- a/examples/o2o2types/ent/card_create.go +++ b/examples/o2o2types/ent/card_create.go @@ -87,9 +87,15 @@ func (cc *CardCreate) Save(ctx context.Context) (*Card, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Card) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CardMutation", v) + } + node = nv } return node, err } diff --git a/examples/o2o2types/ent/card_update.go b/examples/o2o2types/ent/card_update.go index 2d5ade73f7..c88f688796 100644 --- a/examples/o2o2types/ent/card_update.go +++ b/examples/o2o2types/ent/card_update.go @@ -293,9 +293,15 @@ func (cuo *CardUpdateOne) Save(ctx context.Context) (*Card, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Card) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CardMutation", v) + } + node = nv } return node, err } diff --git a/examples/o2o2types/ent/user_create.go b/examples/o2o2types/ent/user_create.go index e82715d572..a8d66dc217 100644 --- a/examples/o2o2types/ent/user_create.go +++ b/examples/o2o2types/ent/user_create.go @@ -94,9 +94,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/o2o2types/ent/user_update.go b/examples/o2o2types/ent/user_update.go index 942486a3ee..ace19bcab7 100644 --- a/examples/o2o2types/ent/user_update.go +++ b/examples/o2o2types/ent/user_update.go @@ -309,9 +309,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/o2obidi/ent/user_create.go b/examples/o2obidi/ent/user_create.go index 5802e3cbd8..d3a5a61630 100644 --- a/examples/o2obidi/ent/user_create.go +++ b/examples/o2obidi/ent/user_create.go @@ -93,9 +93,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/o2obidi/ent/user_update.go b/examples/o2obidi/ent/user_update.go index 076f8ccdf9..dce9c08292 100644 --- a/examples/o2obidi/ent/user_update.go +++ b/examples/o2obidi/ent/user_update.go @@ -308,9 +308,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/o2orecur/ent/node_create.go b/examples/o2orecur/ent/node_create.go index 8105306840..cb5d847db4 100644 --- a/examples/o2orecur/ent/node_create.go +++ b/examples/o2orecur/ent/node_create.go @@ -106,9 +106,15 @@ func (nc *NodeCreate) Save(ctx context.Context) (*Node, error) { } mut = nc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, nc.mutation); err != nil { + v, err := mut.Mutate(ctx, nc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Node) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from NodeMutation", v) + } + node = nv } return node, err } diff --git a/examples/o2orecur/ent/node_update.go b/examples/o2orecur/ent/node_update.go index 48e2a53425..02fdf2abbc 100644 --- a/examples/o2orecur/ent/node_update.go +++ b/examples/o2orecur/ent/node_update.go @@ -374,9 +374,15 @@ func (nuo *NodeUpdateOne) Save(ctx context.Context) (*Node, error) { } mut = nuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, nuo.mutation); err != nil { + v, err := mut.Mutate(ctx, nuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Node) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from NodeMutation", v) + } + node = nv } return node, err } diff --git a/examples/privacyadmin/ent/user_create.go b/examples/privacyadmin/ent/user_create.go index d19c38836c..074e2ce70d 100644 --- a/examples/privacyadmin/ent/user_create.go +++ b/examples/privacyadmin/ent/user_create.go @@ -79,9 +79,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/privacyadmin/ent/user_update.go b/examples/privacyadmin/ent/user_update.go index 6dd5e74a5a..305b6594e1 100644 --- a/examples/privacyadmin/ent/user_update.go +++ b/examples/privacyadmin/ent/user_update.go @@ -199,9 +199,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/privacytenant/ent/group_create.go b/examples/privacytenant/ent/group_create.go index 2cf89b55f4..ac76504226 100644 --- a/examples/privacytenant/ent/group_create.go +++ b/examples/privacytenant/ent/group_create.go @@ -107,9 +107,15 @@ func (gc *GroupCreate) Save(ctx context.Context) (*Group, error) { } mut = gc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, gc.mutation); err != nil { + v, err := mut.Mutate(ctx, gc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/examples/privacytenant/ent/group_update.go b/examples/privacytenant/ent/group_update.go index 3ecc2bdb84..e6eaeea2b7 100644 --- a/examples/privacytenant/ent/group_update.go +++ b/examples/privacytenant/ent/group_update.go @@ -416,9 +416,15 @@ func (guo *GroupUpdateOne) Save(ctx context.Context) (*Group, error) { } mut = guo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, guo.mutation); err != nil { + v, err := mut.Mutate(ctx, guo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/examples/privacytenant/ent/tenant_create.go b/examples/privacytenant/ent/tenant_create.go index 476ccd65e0..ed7ef1b265 100644 --- a/examples/privacytenant/ent/tenant_create.go +++ b/examples/privacytenant/ent/tenant_create.go @@ -68,9 +68,15 @@ func (tc *TenantCreate) Save(ctx context.Context) (*Tenant, error) { } mut = tc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, tc.mutation); err != nil { + v, err := mut.Mutate(ctx, tc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Tenant) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from TenantMutation", v) + } + node = nv } return node, err } diff --git a/examples/privacytenant/ent/tenant_update.go b/examples/privacytenant/ent/tenant_update.go index 7e1995bbfe..86b1f81c56 100644 --- a/examples/privacytenant/ent/tenant_update.go +++ b/examples/privacytenant/ent/tenant_update.go @@ -205,9 +205,15 @@ func (tuo *TenantUpdateOne) Save(ctx context.Context) (*Tenant, error) { } mut = tuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, tuo.mutation); err != nil { + v, err := mut.Mutate(ctx, tuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Tenant) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from TenantMutation", v) + } + node = nv } return node, err } diff --git a/examples/privacytenant/ent/user_create.go b/examples/privacytenant/ent/user_create.go index 063b306446..8d59f9a1c2 100644 --- a/examples/privacytenant/ent/user_create.go +++ b/examples/privacytenant/ent/user_create.go @@ -113,9 +113,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/privacytenant/ent/user_update.go b/examples/privacytenant/ent/user_update.go index c3f1593bad..a58c27cf17 100644 --- a/examples/privacytenant/ent/user_update.go +++ b/examples/privacytenant/ent/user_update.go @@ -453,9 +453,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/start/ent/car_create.go b/examples/start/ent/car_create.go index 24fd86209a..558e41e824 100644 --- a/examples/start/ent/car_create.go +++ b/examples/start/ent/car_create.go @@ -95,9 +95,15 @@ func (cc *CarCreate) Save(ctx context.Context) (*Car, error) { } mut = cc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cc.mutation); err != nil { + v, err := mut.Mutate(ctx, cc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Car) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CarMutation", v) + } + node = nv } return node, err } diff --git a/examples/start/ent/car_update.go b/examples/start/ent/car_update.go index 8b132bb22e..43d5324193 100644 --- a/examples/start/ent/car_update.go +++ b/examples/start/ent/car_update.go @@ -289,9 +289,15 @@ func (cuo *CarUpdateOne) Save(ctx context.Context) (*Car, error) { } mut = cuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, cuo.mutation); err != nil { + v, err := mut.Mutate(ctx, cuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Car) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from CarMutation", v) + } + node = nv } return node, err } diff --git a/examples/start/ent/group_create.go b/examples/start/ent/group_create.go index 60b84bd309..bf1ef844c7 100644 --- a/examples/start/ent/group_create.go +++ b/examples/start/ent/group_create.go @@ -84,9 +84,15 @@ func (gc *GroupCreate) Save(ctx context.Context) (*Group, error) { } mut = gc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, gc.mutation); err != nil { + v, err := mut.Mutate(ctx, gc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/examples/start/ent/group_update.go b/examples/start/ent/group_update.go index a719c9a3d1..5d5d88822b 100644 --- a/examples/start/ent/group_update.go +++ b/examples/start/ent/group_update.go @@ -332,9 +332,15 @@ func (guo *GroupUpdateOne) Save(ctx context.Context) (*Group, error) { } mut = guo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, guo.mutation); err != nil { + v, err := mut.Mutate(ctx, guo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/examples/start/ent/user_create.go b/examples/start/ent/user_create.go index be1e018617..c10dc2a647 100644 --- a/examples/start/ent/user_create.go +++ b/examples/start/ent/user_create.go @@ -115,9 +115,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/start/ent/user_update.go b/examples/start/ent/user_update.go index e997c6bd49..e24ec0c121 100644 --- a/examples/start/ent/user_update.go +++ b/examples/start/ent/user_update.go @@ -515,9 +515,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/traversal/ent/group_create.go b/examples/traversal/ent/group_create.go index c2b62d4530..cd1eea431d 100644 --- a/examples/traversal/ent/group_create.go +++ b/examples/traversal/ent/group_create.go @@ -103,9 +103,15 @@ func (gc *GroupCreate) Save(ctx context.Context) (*Group, error) { } mut = gc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, gc.mutation); err != nil { + v, err := mut.Mutate(ctx, gc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/examples/traversal/ent/group_update.go b/examples/traversal/ent/group_update.go index 085629ae2f..11a5176518 100644 --- a/examples/traversal/ent/group_update.go +++ b/examples/traversal/ent/group_update.go @@ -395,9 +395,15 @@ func (guo *GroupUpdateOne) Save(ctx context.Context) (*Group, error) { } mut = guo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, guo.mutation); err != nil { + v, err := mut.Mutate(ctx, guo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Group) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupMutation", v) + } + node = nv } return node, err } diff --git a/examples/traversal/ent/pet_create.go b/examples/traversal/ent/pet_create.go index d46d4e241e..d9dddf1b98 100644 --- a/examples/traversal/ent/pet_create.go +++ b/examples/traversal/ent/pet_create.go @@ -103,9 +103,15 @@ func (pc *PetCreate) Save(ctx context.Context) (*Pet, error) { } mut = pc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, pc.mutation); err != nil { + v, err := mut.Mutate(ctx, pc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/examples/traversal/ent/pet_update.go b/examples/traversal/ent/pet_update.go index 143606f475..59d268fadc 100644 --- a/examples/traversal/ent/pet_update.go +++ b/examples/traversal/ent/pet_update.go @@ -395,9 +395,15 @@ func (puo *PetUpdateOne) Save(ctx context.Context) (*Pet, error) { } mut = puo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, puo.mutation); err != nil { + v, err := mut.Mutate(ctx, puo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*Pet) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from PetMutation", v) + } + node = nv } return node, err } diff --git a/examples/traversal/ent/user_create.go b/examples/traversal/ent/user_create.go index a827c8996d..b8426b14f8 100644 --- a/examples/traversal/ent/user_create.go +++ b/examples/traversal/ent/user_create.go @@ -136,9 +136,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/traversal/ent/user_update.go b/examples/traversal/ent/user_update.go index 4e14e21e10..b9606ab7b6 100644 --- a/examples/traversal/ent/user_update.go +++ b/examples/traversal/ent/user_update.go @@ -729,9 +729,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/version/ent/user_create.go b/examples/version/ent/user_create.go index dda95324d7..624a7d55ee 100644 --- a/examples/version/ent/user_create.go +++ b/examples/version/ent/user_create.go @@ -83,9 +83,15 @@ func (uc *UserCreate) Save(ctx context.Context) (*User, error) { } mut = uc.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { + v, err := mut.Mutate(ctx, uc.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err } diff --git a/examples/version/ent/user_update.go b/examples/version/ent/user_update.go index ec94b6bea4..75b6ad0ac3 100644 --- a/examples/version/ent/user_update.go +++ b/examples/version/ent/user_update.go @@ -261,9 +261,15 @@ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { } mut = uuo.hooks[i](mut) } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { + v, err := mut.Mutate(ctx, uuo.mutation) + if err != nil { return nil, err } + nv, ok := v.(*User) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from UserMutation", v) + } + node = nv } return node, err }