updated deps; switched sitemap lib; ent regen

ent/client.go

@@ -10,6 +10,10 @@ import (
 
 	"git.harting.dev/csgowtf/csgowtfd/ent/migrate"
 
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
 	"git.harting.dev/csgowtf/csgowtfd/ent/match"
 	"git.harting.dev/csgowtf/csgowtfd/ent/matchplayer"
 	"git.harting.dev/csgowtf/csgowtfd/ent/messages"
@@ -17,10 +21,6 @@ import (
 	"git.harting.dev/csgowtf/csgowtfd/ent/roundstats"
 	"git.harting.dev/csgowtf/csgowtfd/ent/spray"
 	"git.harting.dev/csgowtf/csgowtfd/ent/weapon"
-
-	"entgo.io/ent/dialect"
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
 )
 
 // Client is the client that holds all ent builders.
@@ -46,7 +46,7 @@ type Client struct {
 
 // NewClient creates a new client configured with the given options.
 func NewClient(opts ...Option) *Client {
-	cfg := config{log: log.Println, hooks: &hooks{}}
+	cfg := config{log: log.Println, hooks: &hooks{}, inters: &inters{}}
 	cfg.options(opts...)
 	client := &Client{config: cfg}
 	client.init()
@@ -64,6 +64,55 @@ func (c *Client) init() {
 	c.Weapon = NewWeaponClient(c.config)
 }
 
+type (
+	// config is the configuration for the client and its builder.
+	config struct {
+		// driver used for executing database requests.
+		driver dialect.Driver
+		// debug enable a debug logging.
+		debug bool
+		// log used for logging on debug mode.
+		log func(...any)
+		// hooks to execute on mutations.
+		hooks *hooks
+		// interceptors to execute on queries.
+		inters *inters
+	}
+	// Option function to configure the client.
+	Option func(*config)
+)
+
+// options applies the options on the config object.
+func (c *config) options(opts ...Option) {
+	for _, opt := range opts {
+		opt(c)
+	}
+	if c.debug {
+		c.driver = dialect.Debug(c.driver, c.log)
+	}
+}
+
+// Debug enables debug logging on the ent.Driver.
+func Debug() Option {
+	return func(c *config) {
+		c.debug = true
+	}
+}
+
+// Log sets the logging function for debug mode.
+func Log(fn func(...any)) Option {
+	return func(c *config) {
+		c.log = fn
+	}
+}
+
+// Driver configures the client driver.
+func Driver(driver dialect.Driver) Option {
+	return func(c *config) {
+		c.driver = driver
+	}
+}
+
 // Open opens a database/sql.DB specified by the driver name and
 // the data source name, and returns a new client attached to it.
 // Optional parameters can be added for configuring the client.
@@ -156,13 +205,43 @@ func (c *Client) Close() error {
 // Use adds the mutation hooks to all the entity clients.
 // In order to add hooks to a specific client, call: `client.Node.Use(...)`.
 func (c *Client) Use(hooks ...Hook) {
-	c.Match.Use(hooks...)
+	for _, n := range []interface{ Use(...Hook) }{
-	c.MatchPlayer.Use(hooks...)
+		c.Match, c.MatchPlayer, c.Messages, c.Player, c.RoundStats, c.Spray, c.Weapon,
-	c.Messages.Use(hooks...)
+	} {
-	c.Player.Use(hooks...)
+		n.Use(hooks...)
-	c.RoundStats.Use(hooks...)
+	}
-	c.Spray.Use(hooks...)
+}
-	c.Weapon.Use(hooks...)
+
+// Intercept adds the query interceptors to all the entity clients.
+// In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`.
+func (c *Client) Intercept(interceptors ...Interceptor) {
+	for _, n := range []interface{ Intercept(...Interceptor) }{
+		c.Match, c.MatchPlayer, c.Messages, c.Player, c.RoundStats, c.Spray, c.Weapon,
+	} {
+		n.Intercept(interceptors...)
+	}
+}
+
+// Mutate implements the ent.Mutator interface.
+func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
+	switch m := m.(type) {
+	case *MatchMutation:
+		return c.Match.mutate(ctx, m)
+	case *MatchPlayerMutation:
+		return c.MatchPlayer.mutate(ctx, m)
+	case *MessagesMutation:
+		return c.Messages.mutate(ctx, m)
+	case *PlayerMutation:
+		return c.Player.mutate(ctx, m)
+	case *RoundStatsMutation:
+		return c.RoundStats.mutate(ctx, m)
+	case *SprayMutation:
+		return c.Spray.mutate(ctx, m)
+	case *WeaponMutation:
+		return c.Weapon.mutate(ctx, m)
+	default:
+		return nil, fmt.Errorf("ent: unknown mutation type %T", m)
+	}
 }
 
 // MatchClient is a client for the Match schema.
@@ -181,6 +260,12 @@ func (c *MatchClient) Use(hooks ...Hook) {
 	c.hooks.Match = append(c.hooks.Match, hooks...)
 }
 
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `match.Intercept(f(g(h())))`.
+func (c *MatchClient) Intercept(interceptors ...Interceptor) {
+	c.inters.Match = append(c.inters.Match, interceptors...)
+}
+
 // Create returns a builder for creating a Match entity.
 func (c *MatchClient) Create() *MatchCreate {
 	mutation := newMatchMutation(c.config, OpCreate)
@@ -233,6 +318,8 @@ func (c *MatchClient) DeleteOneID(id uint64) *MatchDeleteOne {
 func (c *MatchClient) Query() *MatchQuery {
 	return &MatchQuery{
 		config: c.config,
+		ctx:    &QueryContext{Type: TypeMatch},
+		inters: c.Interceptors(),
 	}
 }
 
@@ -252,7 +339,7 @@ func (c *MatchClient) GetX(ctx context.Context, id uint64) *Match {
 
 // QueryStats queries the stats edge of a Match.
 func (c *MatchClient) QueryStats(m *Match) *MatchPlayerQuery {
-	query := &MatchPlayerQuery{config: c.config}
+	query := (&MatchPlayerClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := m.ID
 		step := sqlgraph.NewStep(
@@ -268,7 +355,7 @@ func (c *MatchClient) QueryStats(m *Match) *MatchPlayerQuery {
 
 // QueryPlayers queries the players edge of a Match.
 func (c *MatchClient) QueryPlayers(m *Match) *PlayerQuery {
-	query := &PlayerQuery{config: c.config}
+	query := (&PlayerClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := m.ID
 		step := sqlgraph.NewStep(
@@ -287,6 +374,26 @@ func (c *MatchClient) Hooks() []Hook {
 	return c.hooks.Match
 }
 
+// Interceptors returns the client interceptors.
+func (c *MatchClient) Interceptors() []Interceptor {
+	return c.inters.Match
+}
+
+func (c *MatchClient) mutate(ctx context.Context, m *MatchMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&MatchCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&MatchUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&MatchUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&MatchDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("ent: unknown Match mutation op: %q", m.Op())
+	}
+}
+
 // MatchPlayerClient is a client for the MatchPlayer schema.
 type MatchPlayerClient struct {
 	config
@@ -303,6 +410,12 @@ func (c *MatchPlayerClient) Use(hooks ...Hook) {
 	c.hooks.MatchPlayer = append(c.hooks.MatchPlayer, hooks...)
 }
 
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `matchplayer.Intercept(f(g(h())))`.
+func (c *MatchPlayerClient) Intercept(interceptors ...Interceptor) {
+	c.inters.MatchPlayer = append(c.inters.MatchPlayer, interceptors...)
+}
+
 // Create returns a builder for creating a MatchPlayer entity.
 func (c *MatchPlayerClient) Create() *MatchPlayerCreate {
 	mutation := newMatchPlayerMutation(c.config, OpCreate)
@@ -355,6 +468,8 @@ func (c *MatchPlayerClient) DeleteOneID(id int) *MatchPlayerDeleteOne {
 func (c *MatchPlayerClient) Query() *MatchPlayerQuery {
 	return &MatchPlayerQuery{
 		config: c.config,
+		ctx:    &QueryContext{Type: TypeMatchPlayer},
+		inters: c.Interceptors(),
 	}
 }
 
@@ -374,7 +489,7 @@ func (c *MatchPlayerClient) GetX(ctx context.Context, id int) *MatchPlayer {
 
 // QueryMatches queries the matches edge of a MatchPlayer.
 func (c *MatchPlayerClient) QueryMatches(mp *MatchPlayer) *MatchQuery {
-	query := &MatchQuery{config: c.config}
+	query := (&MatchClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := mp.ID
 		step := sqlgraph.NewStep(
@@ -390,7 +505,7 @@ func (c *MatchPlayerClient) QueryMatches(mp *MatchPlayer) *MatchQuery {
 
 // QueryPlayers queries the players edge of a MatchPlayer.
 func (c *MatchPlayerClient) QueryPlayers(mp *MatchPlayer) *PlayerQuery {
-	query := &PlayerQuery{config: c.config}
+	query := (&PlayerClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := mp.ID
 		step := sqlgraph.NewStep(
@@ -406,7 +521,7 @@ func (c *MatchPlayerClient) QueryPlayers(mp *MatchPlayer) *PlayerQuery {
 
 // QueryWeaponStats queries the weapon_stats edge of a MatchPlayer.
 func (c *MatchPlayerClient) QueryWeaponStats(mp *MatchPlayer) *WeaponQuery {
-	query := &WeaponQuery{config: c.config}
+	query := (&WeaponClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := mp.ID
 		step := sqlgraph.NewStep(
@@ -422,7 +537,7 @@ func (c *MatchPlayerClient) QueryWeaponStats(mp *MatchPlayer) *WeaponQuery {
 
 // QueryRoundStats queries the round_stats edge of a MatchPlayer.
 func (c *MatchPlayerClient) QueryRoundStats(mp *MatchPlayer) *RoundStatsQuery {
-	query := &RoundStatsQuery{config: c.config}
+	query := (&RoundStatsClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := mp.ID
 		step := sqlgraph.NewStep(
@@ -438,7 +553,7 @@ func (c *MatchPlayerClient) QueryRoundStats(mp *MatchPlayer) *RoundStatsQuery {
 
 // QuerySpray queries the spray edge of a MatchPlayer.
 func (c *MatchPlayerClient) QuerySpray(mp *MatchPlayer) *SprayQuery {
-	query := &SprayQuery{config: c.config}
+	query := (&SprayClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := mp.ID
 		step := sqlgraph.NewStep(
@@ -454,7 +569,7 @@ func (c *MatchPlayerClient) QuerySpray(mp *MatchPlayer) *SprayQuery {
 
 // QueryMessages queries the messages edge of a MatchPlayer.
 func (c *MatchPlayerClient) QueryMessages(mp *MatchPlayer) *MessagesQuery {
-	query := &MessagesQuery{config: c.config}
+	query := (&MessagesClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := mp.ID
 		step := sqlgraph.NewStep(
@@ -473,6 +588,26 @@ func (c *MatchPlayerClient) Hooks() []Hook {
 	return c.hooks.MatchPlayer
 }
 
+// Interceptors returns the client interceptors.
+func (c *MatchPlayerClient) Interceptors() []Interceptor {
+	return c.inters.MatchPlayer
+}
+
+func (c *MatchPlayerClient) mutate(ctx context.Context, m *MatchPlayerMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&MatchPlayerCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&MatchPlayerUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&MatchPlayerUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&MatchPlayerDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("ent: unknown MatchPlayer mutation op: %q", m.Op())
+	}
+}
+
 // MessagesClient is a client for the Messages schema.
 type MessagesClient struct {
 	config
@@ -489,6 +624,12 @@ func (c *MessagesClient) Use(hooks ...Hook) {
 	c.hooks.Messages = append(c.hooks.Messages, hooks...)
 }
 
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `messages.Intercept(f(g(h())))`.
+func (c *MessagesClient) Intercept(interceptors ...Interceptor) {
+	c.inters.Messages = append(c.inters.Messages, interceptors...)
+}
+
 // Create returns a builder for creating a Messages entity.
 func (c *MessagesClient) Create() *MessagesCreate {
 	mutation := newMessagesMutation(c.config, OpCreate)
@@ -541,6 +682,8 @@ func (c *MessagesClient) DeleteOneID(id int) *MessagesDeleteOne {
 func (c *MessagesClient) Query() *MessagesQuery {
 	return &MessagesQuery{
 		config: c.config,
+		ctx:    &QueryContext{Type: TypeMessages},
+		inters: c.Interceptors(),
 	}
 }
 
@@ -560,7 +703,7 @@ func (c *MessagesClient) GetX(ctx context.Context, id int) *Messages {
 
 // QueryMatchPlayer queries the match_player edge of a Messages.
 func (c *MessagesClient) QueryMatchPlayer(m *Messages) *MatchPlayerQuery {
-	query := &MatchPlayerQuery{config: c.config}
+	query := (&MatchPlayerClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := m.ID
 		step := sqlgraph.NewStep(
@@ -579,6 +722,26 @@ func (c *MessagesClient) Hooks() []Hook {
 	return c.hooks.Messages
 }
 
+// Interceptors returns the client interceptors.
+func (c *MessagesClient) Interceptors() []Interceptor {
+	return c.inters.Messages
+}
+
+func (c *MessagesClient) mutate(ctx context.Context, m *MessagesMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&MessagesCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&MessagesUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&MessagesUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&MessagesDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("ent: unknown Messages mutation op: %q", m.Op())
+	}
+}
+
 // PlayerClient is a client for the Player schema.
 type PlayerClient struct {
 	config
@@ -595,6 +758,12 @@ func (c *PlayerClient) Use(hooks ...Hook) {
 	c.hooks.Player = append(c.hooks.Player, hooks...)
 }
 
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `player.Intercept(f(g(h())))`.
+func (c *PlayerClient) Intercept(interceptors ...Interceptor) {
+	c.inters.Player = append(c.inters.Player, interceptors...)
+}
+
 // Create returns a builder for creating a Player entity.
 func (c *PlayerClient) Create() *PlayerCreate {
 	mutation := newPlayerMutation(c.config, OpCreate)
@@ -647,6 +816,8 @@ func (c *PlayerClient) DeleteOneID(id uint64) *PlayerDeleteOne {
 func (c *PlayerClient) Query() *PlayerQuery {
 	return &PlayerQuery{
 		config: c.config,
+		ctx:    &QueryContext{Type: TypePlayer},
+		inters: c.Interceptors(),
 	}
 }
 
@@ -666,7 +837,7 @@ func (c *PlayerClient) GetX(ctx context.Context, id uint64) *Player {
 
 // QueryStats queries the stats edge of a Player.
 func (c *PlayerClient) QueryStats(pl *Player) *MatchPlayerQuery {
-	query := &MatchPlayerQuery{config: c.config}
+	query := (&MatchPlayerClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := pl.ID
 		step := sqlgraph.NewStep(
@@ -682,7 +853,7 @@ func (c *PlayerClient) QueryStats(pl *Player) *MatchPlayerQuery {
 
 // QueryMatches queries the matches edge of a Player.
 func (c *PlayerClient) QueryMatches(pl *Player) *MatchQuery {
-	query := &MatchQuery{config: c.config}
+	query := (&MatchClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := pl.ID
 		step := sqlgraph.NewStep(
@@ -701,6 +872,26 @@ func (c *PlayerClient) Hooks() []Hook {
 	return c.hooks.Player
 }
 
+// Interceptors returns the client interceptors.
+func (c *PlayerClient) Interceptors() []Interceptor {
+	return c.inters.Player
+}
+
+func (c *PlayerClient) mutate(ctx context.Context, m *PlayerMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&PlayerCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&PlayerUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&PlayerUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&PlayerDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("ent: unknown Player mutation op: %q", m.Op())
+	}
+}
+
 // RoundStatsClient is a client for the RoundStats schema.
 type RoundStatsClient struct {
 	config
@@ -717,6 +908,12 @@ func (c *RoundStatsClient) Use(hooks ...Hook) {
 	c.hooks.RoundStats = append(c.hooks.RoundStats, hooks...)
 }
 
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `roundstats.Intercept(f(g(h())))`.
+func (c *RoundStatsClient) Intercept(interceptors ...Interceptor) {
+	c.inters.RoundStats = append(c.inters.RoundStats, interceptors...)
+}
+
 // Create returns a builder for creating a RoundStats entity.
 func (c *RoundStatsClient) Create() *RoundStatsCreate {
 	mutation := newRoundStatsMutation(c.config, OpCreate)
@@ -769,6 +966,8 @@ func (c *RoundStatsClient) DeleteOneID(id int) *RoundStatsDeleteOne {
 func (c *RoundStatsClient) Query() *RoundStatsQuery {
 	return &RoundStatsQuery{
 		config: c.config,
+		ctx:    &QueryContext{Type: TypeRoundStats},
+		inters: c.Interceptors(),
 	}
 }
 
@@ -788,7 +987,7 @@ func (c *RoundStatsClient) GetX(ctx context.Context, id int) *RoundStats {
 
 // QueryMatchPlayer queries the match_player edge of a RoundStats.
 func (c *RoundStatsClient) QueryMatchPlayer(rs *RoundStats) *MatchPlayerQuery {
-	query := &MatchPlayerQuery{config: c.config}
+	query := (&MatchPlayerClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := rs.ID
 		step := sqlgraph.NewStep(
@@ -807,6 +1006,26 @@ func (c *RoundStatsClient) Hooks() []Hook {
 	return c.hooks.RoundStats
 }
 
+// Interceptors returns the client interceptors.
+func (c *RoundStatsClient) Interceptors() []Interceptor {
+	return c.inters.RoundStats
+}
+
+func (c *RoundStatsClient) mutate(ctx context.Context, m *RoundStatsMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&RoundStatsCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&RoundStatsUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&RoundStatsUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&RoundStatsDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("ent: unknown RoundStats mutation op: %q", m.Op())
+	}
+}
+
 // SprayClient is a client for the Spray schema.
 type SprayClient struct {
 	config
@@ -823,6 +1042,12 @@ func (c *SprayClient) Use(hooks ...Hook) {
 	c.hooks.Spray = append(c.hooks.Spray, hooks...)
 }
 
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `spray.Intercept(f(g(h())))`.
+func (c *SprayClient) Intercept(interceptors ...Interceptor) {
+	c.inters.Spray = append(c.inters.Spray, interceptors...)
+}
+
 // Create returns a builder for creating a Spray entity.
 func (c *SprayClient) Create() *SprayCreate {
 	mutation := newSprayMutation(c.config, OpCreate)
@@ -875,6 +1100,8 @@ func (c *SprayClient) DeleteOneID(id int) *SprayDeleteOne {
 func (c *SprayClient) Query() *SprayQuery {
 	return &SprayQuery{
 		config: c.config,
+		ctx:    &QueryContext{Type: TypeSpray},
+		inters: c.Interceptors(),
 	}
 }
 
@@ -894,7 +1121,7 @@ func (c *SprayClient) GetX(ctx context.Context, id int) *Spray {
 
 // QueryMatchPlayers queries the match_players edge of a Spray.
 func (c *SprayClient) QueryMatchPlayers(s *Spray) *MatchPlayerQuery {
-	query := &MatchPlayerQuery{config: c.config}
+	query := (&MatchPlayerClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := s.ID
 		step := sqlgraph.NewStep(
@@ -913,6 +1140,26 @@ func (c *SprayClient) Hooks() []Hook {
 	return c.hooks.Spray
 }
 
+// Interceptors returns the client interceptors.
+func (c *SprayClient) Interceptors() []Interceptor {
+	return c.inters.Spray
+}
+
+func (c *SprayClient) mutate(ctx context.Context, m *SprayMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&SprayCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&SprayUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&SprayUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&SprayDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("ent: unknown Spray mutation op: %q", m.Op())
+	}
+}
+
 // WeaponClient is a client for the Weapon schema.
 type WeaponClient struct {
 	config
@@ -929,6 +1176,12 @@ func (c *WeaponClient) Use(hooks ...Hook) {
 	c.hooks.Weapon = append(c.hooks.Weapon, hooks...)
 }
 
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `weapon.Intercept(f(g(h())))`.
+func (c *WeaponClient) Intercept(interceptors ...Interceptor) {
+	c.inters.Weapon = append(c.inters.Weapon, interceptors...)
+}
+
 // Create returns a builder for creating a Weapon entity.
 func (c *WeaponClient) Create() *WeaponCreate {
 	mutation := newWeaponMutation(c.config, OpCreate)
@@ -981,6 +1234,8 @@ func (c *WeaponClient) DeleteOneID(id int) *WeaponDeleteOne {
 func (c *WeaponClient) Query() *WeaponQuery {
 	return &WeaponQuery{
 		config: c.config,
+		ctx:    &QueryContext{Type: TypeWeapon},
+		inters: c.Interceptors(),
 	}
 }
 
@@ -1000,7 +1255,7 @@ func (c *WeaponClient) GetX(ctx context.Context, id int) *Weapon {
 
 // QueryStat queries the stat edge of a Weapon.
 func (c *WeaponClient) QueryStat(w *Weapon) *MatchPlayerQuery {
-	query := &MatchPlayerQuery{config: c.config}
+	query := (&MatchPlayerClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := w.ID
 		step := sqlgraph.NewStep(
@@ -1018,3 +1273,34 @@ func (c *WeaponClient) QueryStat(w *Weapon) *MatchPlayerQuery {
 func (c *WeaponClient) Hooks() []Hook {
 	return c.hooks.Weapon
 }
+
+// Interceptors returns the client interceptors.
+func (c *WeaponClient) Interceptors() []Interceptor {
+	return c.inters.Weapon
+}
+
+func (c *WeaponClient) mutate(ctx context.Context, m *WeaponMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&WeaponCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&WeaponUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&WeaponUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&WeaponDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("ent: unknown Weapon mutation op: %q", m.Op())
+	}
+}
+
+// hooks and interceptors per client, for fast access.
+type (
+	hooks struct {
+		Match, MatchPlayer, Messages, Player, RoundStats, Spray, Weapon []ent.Hook
+	}
+	inters struct {
+		Match, MatchPlayer, Messages, Player, RoundStats, Spray,
+		Weapon []ent.Interceptor
+	}
+)

ent/config.go

@@ -1,65 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"entgo.io/ent"
-	"entgo.io/ent/dialect"
-)
-
-// Option function to configure the client.
-type Option func(*config)
-
-// Config is the configuration for the client and its builder.
-type config struct {
-	// driver used for executing database requests.
-	driver dialect.Driver
-	// debug enable a debug logging.
-	debug bool
-	// log used for logging on debug mode.
-	log func(...any)
-	// hooks to execute on mutations.
-	hooks *hooks
-}
-
-// hooks per client, for fast access.
-type hooks struct {
-	Match       []ent.Hook
-	MatchPlayer []ent.Hook
-	Messages    []ent.Hook
-	Player      []ent.Hook
-	RoundStats  []ent.Hook
-	Spray       []ent.Hook
-	Weapon      []ent.Hook
-}
-
-// Options applies the options on the config object.
-func (c *config) options(opts ...Option) {
-	for _, opt := range opts {
-		opt(c)
-	}
-	if c.debug {
-		c.driver = dialect.Debug(c.driver, c.log)
-	}
-}
-
-// Debug enables debug logging on the ent.Driver.
-func Debug() Option {
-	return func(c *config) {
-		c.debug = true
-	}
-}
-
-// Log sets the logging function for debug mode.
-func Log(fn func(...any)) Option {
-	return func(c *config) {
-		c.log = fn
-	}
-}
-
-// Driver configures the client driver.
-func Driver(driver dialect.Driver) Option {
-	return func(c *config) {
-		c.driver = driver
-	}
-}

ent/context.go

@@ -1,33 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-)
-
-type clientCtxKey struct{}
-
-// FromContext returns a Client stored inside a context, or nil if there isn't one.
-func FromContext(ctx context.Context) *Client {
-	c, _ := ctx.Value(clientCtxKey{}).(*Client)
-	return c
-}
-
-// NewContext returns a new context with the given Client attached.
-func NewContext(parent context.Context, c *Client) context.Context {
-	return context.WithValue(parent, clientCtxKey{}, c)
-}
-
-type txCtxKey struct{}
-
-// TxFromContext returns a Tx stored inside a context, or nil if there isn't one.
-func TxFromContext(ctx context.Context) *Tx {
-	tx, _ := ctx.Value(txCtxKey{}).(*Tx)
-	return tx
-}
-
-// NewTxContext returns a new context with the given Tx attached.
-func NewTxContext(parent context.Context, tx *Tx) context.Context {
-	return context.WithValue(parent, txCtxKey{}, tx)
-}

ent/ent.go

@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"reflect"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -21,16 +22,49 @@ import (
 
 // ent aliases to avoid import conflicts in user's code.
 type (
-	Op         = ent.Op
+	Op            = ent.Op
-	Hook       = ent.Hook
+	Hook          = ent.Hook
-	Value      = ent.Value
+	Value         = ent.Value
-	Query      = ent.Query
+	Query         = ent.Query
-	Policy     = ent.Policy
+	QueryContext  = ent.QueryContext
-	Mutator    = ent.Mutator
+	Querier       = ent.Querier
-	Mutation   = ent.Mutation
+	QuerierFunc   = ent.QuerierFunc
-	MutateFunc = ent.MutateFunc
+	Interceptor   = ent.Interceptor
+	InterceptFunc = ent.InterceptFunc
+	Traverser     = ent.Traverser
+	TraverseFunc  = ent.TraverseFunc
+	Policy        = ent.Policy
+	Mutator       = ent.Mutator
+	Mutation      = ent.Mutation
+	MutateFunc    = ent.MutateFunc
 )
 
+type clientCtxKey struct{}
+
+// FromContext returns a Client stored inside a context, or nil if there isn't one.
+func FromContext(ctx context.Context) *Client {
+	c, _ := ctx.Value(clientCtxKey{}).(*Client)
+	return c
+}
+
+// NewContext returns a new context with the given Client attached.
+func NewContext(parent context.Context, c *Client) context.Context {
+	return context.WithValue(parent, clientCtxKey{}, c)
+}
+
+type txCtxKey struct{}
+
+// TxFromContext returns a Tx stored inside a context, or nil if there isn't one.
+func TxFromContext(ctx context.Context) *Tx {
+	tx, _ := ctx.Value(txCtxKey{}).(*Tx)
+	return tx
+}
+
+// NewTxContext returns a new context with the given Tx attached.
+func NewTxContext(parent context.Context, tx *Tx) context.Context {
+	return context.WithValue(parent, txCtxKey{}, tx)
+}
+
 // OrderFunc applies an ordering on the sql selector.
 type OrderFunc func(*sql.Selector)
 
@@ -474,5 +508,121 @@ func (s *selector) BoolX(ctx context.Context) bool {
 	return v
 }
 
+// withHooks invokes the builder operation with the given hooks, if any.
+func withHooks[V Value, M any, PM interface {
+	*M
+	Mutation
+}](ctx context.Context, exec func(context.Context) (V, error), mutation PM, hooks []Hook) (value V, err error) {
+	if len(hooks) == 0 {
+		return exec(ctx)
+	}
+	var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+		mutationT, ok := m.(PM)
+		if !ok {
+			return nil, fmt.Errorf("unexpected mutation type %T", m)
+		}
+		// Set the mutation to the builder.
+		*mutation = *mutationT
+		return exec(ctx)
+	})
+	for i := len(hooks) - 1; i >= 0; i-- {
+		if hooks[i] == nil {
+			return value, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
+		}
+		mut = hooks[i](mut)
+	}
+	v, err := mut.Mutate(ctx, mutation)
+	if err != nil {
+		return value, err
+	}
+	nv, ok := v.(V)
+	if !ok {
+		return value, fmt.Errorf("unexpected node type %T returned from %T", v, mutation)
+	}
+	return nv, nil
+}
+
+// setContextOp returns a new context with the given QueryContext attached (including its op) in case it does not exist.
+func setContextOp(ctx context.Context, qc *QueryContext, op string) context.Context {
+	if ent.QueryFromContext(ctx) == nil {
+		qc.Op = op
+		ctx = ent.NewQueryContext(ctx, qc)
+	}
+	return ctx
+}
+
+func querierAll[V Value, Q interface {
+	sqlAll(context.Context, ...queryHook) (V, error)
+}]() Querier {
+	return QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		return query.sqlAll(ctx)
+	})
+}
+
+func querierCount[Q interface {
+	sqlCount(context.Context) (int, error)
+}]() Querier {
+	return QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		return query.sqlCount(ctx)
+	})
+}
+
+func withInterceptors[V Value](ctx context.Context, q Query, qr Querier, inters []Interceptor) (v V, err error) {
+	for i := len(inters) - 1; i >= 0; i-- {
+		qr = inters[i].Intercept(qr)
+	}
+	rv, err := qr.Query(ctx, q)
+	if err != nil {
+		return v, err
+	}
+	vt, ok := rv.(V)
+	if !ok {
+		return v, fmt.Errorf("unexpected type %T returned from %T. expected type: %T", vt, q, v)
+	}
+	return vt, nil
+}
+
+func scanWithInterceptors[Q1 ent.Query, Q2 interface {
+	sqlScan(context.Context, Q1, any) error
+}](ctx context.Context, rootQuery Q1, selectOrGroup Q2, inters []Interceptor, v any) error {
+	rv := reflect.ValueOf(v)
+	var qr Querier = QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q1)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		if err := selectOrGroup.sqlScan(ctx, query, v); err != nil {
+			return nil, err
+		}
+		if k := rv.Kind(); k == reflect.Pointer && rv.Elem().CanInterface() {
+			return rv.Elem().Interface(), nil
+		}
+		return v, nil
+	})
+	for i := len(inters) - 1; i >= 0; i-- {
+		qr = inters[i].Intercept(qr)
+	}
+	vv, err := qr.Query(ctx, rootQuery)
+	if err != nil {
+		return err
+	}
+	switch rv2 := reflect.ValueOf(vv); {
+	case rv.IsNil(), rv2.IsNil(), rv.Kind() != reflect.Pointer:
+	case rv.Type() == rv2.Type():
+		rv.Elem().Set(rv2.Elem())
+	case rv.Elem().Type() == rv2.Type():
+		rv.Elem().Set(rv2)
+	}
+	return nil
+}
+
 // queryHook describes an internal hook for the different sqlAll methods.
 type queryHook func(context.Context, *sqlgraph.QuerySpec)

ent/hook/hook.go

@@ -15,11 +15,10 @@ type MatchFunc func(context.Context, *ent.MatchMutation) (ent.Value, error)
 
 // Mutate calls f(ctx, m).
 func (f MatchFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	mv, ok := m.(*ent.MatchMutation)
+	if mv, ok := m.(*ent.MatchMutation); ok {
-	if !ok {
+		return f(ctx, mv)
-		return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.MatchMutation", m)
 	}
-	return f(ctx, mv)
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.MatchMutation", m)
 }
 
 // The MatchPlayerFunc type is an adapter to allow the use of ordinary
@@ -28,11 +27,10 @@ type MatchPlayerFunc func(context.Context, *ent.MatchPlayerMutation) (ent.Value,
 
 // Mutate calls f(ctx, m).
 func (f MatchPlayerFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	mv, ok := m.(*ent.MatchPlayerMutation)
+	if mv, ok := m.(*ent.MatchPlayerMutation); ok {
-	if !ok {
+		return f(ctx, mv)
-		return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.MatchPlayerMutation", m)
 	}
-	return f(ctx, mv)
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.MatchPlayerMutation", m)
 }
 
 // The MessagesFunc type is an adapter to allow the use of ordinary
@@ -41,11 +39,10 @@ type MessagesFunc func(context.Context, *ent.MessagesMutation) (ent.Value, error
 
 // Mutate calls f(ctx, m).
 func (f MessagesFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	mv, ok := m.(*ent.MessagesMutation)
+	if mv, ok := m.(*ent.MessagesMutation); ok {
-	if !ok {
+		return f(ctx, mv)
-		return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.MessagesMutation", m)
 	}
-	return f(ctx, mv)
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.MessagesMutation", m)
 }
 
 // The PlayerFunc type is an adapter to allow the use of ordinary
@@ -54,11 +51,10 @@ type PlayerFunc func(context.Context, *ent.PlayerMutation) (ent.Value, error)
 
 // Mutate calls f(ctx, m).
 func (f PlayerFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	mv, ok := m.(*ent.PlayerMutation)
+	if mv, ok := m.(*ent.PlayerMutation); ok {
-	if !ok {
+		return f(ctx, mv)
-		return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.PlayerMutation", m)
 	}
-	return f(ctx, mv)
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.PlayerMutation", m)
 }
 
 // The RoundStatsFunc type is an adapter to allow the use of ordinary
@@ -67,11 +63,10 @@ type RoundStatsFunc func(context.Context, *ent.RoundStatsMutation) (ent.Value, e
 
 // Mutate calls f(ctx, m).
 func (f RoundStatsFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	mv, ok := m.(*ent.RoundStatsMutation)
+	if mv, ok := m.(*ent.RoundStatsMutation); ok {
-	if !ok {
+		return f(ctx, mv)
-		return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.RoundStatsMutation", m)
 	}
-	return f(ctx, mv)
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.RoundStatsMutation", m)
 }
 
 // The SprayFunc type is an adapter to allow the use of ordinary
@@ -80,11 +75,10 @@ type SprayFunc func(context.Context, *ent.SprayMutation) (ent.Value, error)
 
 // Mutate calls f(ctx, m).
 func (f SprayFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	mv, ok := m.(*ent.SprayMutation)
+	if mv, ok := m.(*ent.SprayMutation); ok {
-	if !ok {
+		return f(ctx, mv)
-		return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.SprayMutation", m)
 	}
-	return f(ctx, mv)
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.SprayMutation", m)
 }
 
 // The WeaponFunc type is an adapter to allow the use of ordinary
@@ -93,11 +87,10 @@ type WeaponFunc func(context.Context, *ent.WeaponMutation) (ent.Value, error)
 
 // Mutate calls f(ctx, m).
 func (f WeaponFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	mv, ok := m.(*ent.WeaponMutation)
+	if mv, ok := m.(*ent.WeaponMutation); ok {
-	if !ok {
+		return f(ctx, mv)
-		return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.WeaponMutation", m)
 	}
-	return f(ctx, mv)
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.WeaponMutation", m)
 }
 
 // Condition is a hook condition function.

ent/match.go

@@ -207,19 +207,19 @@ func (m *Match) assignValues(columns []string, values []any) error {
 
 // QueryStats queries the "stats" edge of the Match entity.
 func (m *Match) QueryStats() *MatchPlayerQuery {
-	return (&MatchClient{config: m.config}).QueryStats(m)
+	return NewMatchClient(m.config).QueryStats(m)
 }
 
 // QueryPlayers queries the "players" edge of the Match entity.
 func (m *Match) QueryPlayers() *PlayerQuery {
-	return (&MatchClient{config: m.config}).QueryPlayers(m)
+	return NewMatchClient(m.config).QueryPlayers(m)
 }
 
 // Update returns a builder for updating this Match.
 // Note that you need to call Match.Unwrap() before calling this method if this Match
 // was returned from a transaction, and the transaction was committed or rolled back.
 func (m *Match) Update() *MatchUpdateOne {
-	return (&MatchClient{config: m.config}).UpdateOne(m)
+	return NewMatchClient(m.config).UpdateOne(m)
 }
 
 // Unwrap unwraps the Match entity that was returned from a transaction after it was closed,
@@ -285,9 +285,3 @@ func (m *Match) String() string {
 
 // Matches is a parsable slice of Match.
 type Matches []*Match
-
-func (m Matches) config(cfg config) {
-	for _i := range m {
-		m[_i].config = cfg
-	}
-}

ent/match_create.go

@@ -197,50 +197,8 @@ func (mc *MatchCreate) Mutation() *MatchMutation {
 
 // Save creates the Match in the database.
 func (mc *MatchCreate) Save(ctx context.Context) (*Match, error) {
-	var (
-		err  error
-		node *Match
-	)
 	mc.defaults()
-	if len(mc.hooks) == 0 {
+	return withHooks[*Match, MatchMutation](ctx, mc.sqlSave, mc.mutation, mc.hooks)
-		if err = mc.check(); err != nil {
-			return nil, err
-		}
-		node, err = mc.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*MatchMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = mc.check(); err != nil {
-				return nil, err
-			}
-			mc.mutation = mutation
-			if node, err = mc.sqlSave(ctx); err != nil {
-				return nil, err
-			}
-			mutation.id = &node.ID
-			mutation.done = true
-			return node, err
-		})
-		for i := len(mc.hooks) - 1; i >= 0; i-- {
-			if mc.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = mc.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, mc.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*Match)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from MatchMutation", v)
-		}
-		node = nv
-	}
-	return node, err
 }
 
 // SaveX calls Save and panics if Save returns an error.
@@ -317,6 +275,9 @@ func (mc *MatchCreate) check() error {
 }
 
 func (mc *MatchCreate) sqlSave(ctx context.Context) (*Match, error) {
+	if err := mc.check(); err != nil {
+		return nil, err
+	}
 	_node, _spec := mc.createSpec()
 	if err := sqlgraph.CreateNode(ctx, mc.driver, _spec); err != nil {
 		if sqlgraph.IsConstraintError(err) {
@@ -328,19 +289,15 @@ func (mc *MatchCreate) sqlSave(ctx context.Context) (*Match, error) {
 		id := _spec.ID.Value.(int64)
 		_node.ID = uint64(id)
 	}
+	mc.mutation.id = &_node.ID
+	mc.mutation.done = true
 	return _node, nil
 }
 
 func (mc *MatchCreate) createSpec() (*Match, *sqlgraph.CreateSpec) {
 	var (
 		_node = &Match{config: mc.config}
-		_spec = &sqlgraph.CreateSpec{
+		_spec = sqlgraph.NewCreateSpec(match.Table, sqlgraph.NewFieldSpec(match.FieldID, field.TypeUint64))
-			Table: match.Table,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeUint64,
-				Column: match.FieldID,
-			},
-		}
 	)
 	if id, ok := mc.mutation.ID(); ok {
 		_node.ID = id

ent/match_delete.go

@@ -4,7 +4,6 @@ package ent
 
 import (
 	"context"
-	"fmt"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -28,34 +27,7 @@ func (md *MatchDelete) Where(ps ...predicate.Match) *MatchDelete {
 
 // Exec executes the deletion query and returns how many vertices were deleted.
 func (md *MatchDelete) Exec(ctx context.Context) (int, error) {
-	var (
+	return withHooks[int, MatchMutation](ctx, md.sqlExec, md.mutation, md.hooks)
-		err      error
-		affected int
-	)
-	if len(md.hooks) == 0 {
-		affected, err = md.sqlExec(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*MatchMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			md.mutation = mutation
-			affected, err = md.sqlExec(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(md.hooks) - 1; i >= 0; i-- {
-			if md.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = md.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, md.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
 }
 
 // ExecX is like Exec, but panics if an error occurs.
@@ -68,15 +40,7 @@ func (md *MatchDelete) ExecX(ctx context.Context) int {
 }
 
 func (md *MatchDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := &sqlgraph.DeleteSpec{
+	_spec := sqlgraph.NewDeleteSpec(match.Table, sqlgraph.NewFieldSpec(match.FieldID, field.TypeUint64))
-		Node: &sqlgraph.NodeSpec{
-			Table: match.Table,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeUint64,
-				Column: match.FieldID,
-			},
-		},
-	}
 	if ps := md.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -88,6 +52,7 @@ func (md *MatchDelete) sqlExec(ctx context.Context) (int, error) {
 	if err != nil && sqlgraph.IsConstraintError(err) {
 		err = &ConstraintError{msg: err.Error(), wrap: err}
 	}
+	md.mutation.done = true
 	return affected, err
 }
 
@@ -96,6 +61,12 @@ type MatchDeleteOne struct {
 	md *MatchDelete
 }
 
+// Where appends a list predicates to the MatchDelete builder.
+func (mdo *MatchDeleteOne) Where(ps ...predicate.Match) *MatchDeleteOne {
+	mdo.md.mutation.Where(ps...)
+	return mdo
+}
+
 // Exec executes the deletion query.
 func (mdo *MatchDeleteOne) Exec(ctx context.Context) error {
 	n, err := mdo.md.Exec(ctx)
@@ -111,5 +82,7 @@ func (mdo *MatchDeleteOne) Exec(ctx context.Context) error {
 
 // ExecX is like Exec, but panics if an error occurs.
 func (mdo *MatchDeleteOne) ExecX(ctx context.Context) {
-	mdo.md.ExecX(ctx)
+	if err := mdo.Exec(ctx); err != nil {
+		panic(err)
+	}
 }

ent/match_query.go

@@ -20,11 +20,9 @@ import (
 // MatchQuery is the builder for querying Match entities.
 type MatchQuery struct {
 	config
-	limit       *int
+	ctx         *QueryContext
-	offset      *int
-	unique      *bool
 	order       []OrderFunc
-	fields      []string
+	inters      []Interceptor
 	predicates  []predicate.Match
 	withStats   *MatchPlayerQuery
 	withPlayers *PlayerQuery
@@ -40,26 +38,26 @@ func (mq *MatchQuery) Where(ps ...predicate.Match) *MatchQuery {
 	return mq
 }
 
-// Limit adds a limit step to the query.
+// Limit the number of records to be returned by this query.
 func (mq *MatchQuery) Limit(limit int) *MatchQuery {
-	mq.limit = &limit
+	mq.ctx.Limit = &limit
 	return mq
 }
 
-// Offset adds an offset step to the query.
+// Offset to start from.
 func (mq *MatchQuery) Offset(offset int) *MatchQuery {
-	mq.offset = &offset
+	mq.ctx.Offset = &offset
 	return mq
 }
 
 // Unique configures the query builder to filter duplicate records on query.
 // By default, unique is set to true, and can be disabled using this method.
 func (mq *MatchQuery) Unique(unique bool) *MatchQuery {
-	mq.unique = &unique
+	mq.ctx.Unique = &unique
 	return mq
 }
 
-// Order adds an order step to the query.
+// Order specifies how the records should be ordered.
 func (mq *MatchQuery) Order(o ...OrderFunc) *MatchQuery {
 	mq.order = append(mq.order, o...)
 	return mq
@@ -67,7 +65,7 @@ func (mq *MatchQuery) Order(o ...OrderFunc) *MatchQuery {
 
 // QueryStats chains the current query on the "stats" edge.
 func (mq *MatchQuery) QueryStats() *MatchPlayerQuery {
-	query := &MatchPlayerQuery{config: mq.config}
+	query := (&MatchPlayerClient{config: mq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := mq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -89,7 +87,7 @@ func (mq *MatchQuery) QueryStats() *MatchPlayerQuery {
 
 // QueryPlayers chains the current query on the "players" edge.
 func (mq *MatchQuery) QueryPlayers() *PlayerQuery {
-	query := &PlayerQuery{config: mq.config}
+	query := (&PlayerClient{config: mq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := mq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -112,7 +110,7 @@ func (mq *MatchQuery) QueryPlayers() *PlayerQuery {
 // First returns the first Match entity from the query.
 // Returns a *NotFoundError when no Match was found.
 func (mq *MatchQuery) First(ctx context.Context) (*Match, error) {
-	nodes, err := mq.Limit(1).All(ctx)
+	nodes, err := mq.Limit(1).All(setContextOp(ctx, mq.ctx, "First"))
 	if err != nil {
 		return nil, err
 	}
@@ -135,7 +133,7 @@ func (mq *MatchQuery) FirstX(ctx context.Context) *Match {
 // Returns a *NotFoundError when no Match ID was found.
 func (mq *MatchQuery) FirstID(ctx context.Context) (id uint64, err error) {
 	var ids []uint64
-	if ids, err = mq.Limit(1).IDs(ctx); err != nil {
+	if ids, err = mq.Limit(1).IDs(setContextOp(ctx, mq.ctx, "FirstID")); err != nil {
 		return
 	}
 	if len(ids) == 0 {
@@ -158,7 +156,7 @@ func (mq *MatchQuery) FirstIDX(ctx context.Context) uint64 {
 // Returns a *NotSingularError when more than one Match entity is found.
 // Returns a *NotFoundError when no Match entities are found.
 func (mq *MatchQuery) Only(ctx context.Context) (*Match, error) {
-	nodes, err := mq.Limit(2).All(ctx)
+	nodes, err := mq.Limit(2).All(setContextOp(ctx, mq.ctx, "Only"))
 	if err != nil {
 		return nil, err
 	}
@@ -186,7 +184,7 @@ func (mq *MatchQuery) OnlyX(ctx context.Context) *Match {
 // Returns a *NotFoundError when no entities are found.
 func (mq *MatchQuery) OnlyID(ctx context.Context) (id uint64, err error) {
 	var ids []uint64
-	if ids, err = mq.Limit(2).IDs(ctx); err != nil {
+	if ids, err = mq.Limit(2).IDs(setContextOp(ctx, mq.ctx, "OnlyID")); err != nil {
 		return
 	}
 	switch len(ids) {
@@ -211,10 +209,12 @@ func (mq *MatchQuery) OnlyIDX(ctx context.Context) uint64 {
 
 // All executes the query and returns a list of Matches.
 func (mq *MatchQuery) All(ctx context.Context) ([]*Match, error) {
+	ctx = setContextOp(ctx, mq.ctx, "All")
 	if err := mq.prepareQuery(ctx); err != nil {
 		return nil, err
 	}
-	return mq.sqlAll(ctx)
+	qr := querierAll[[]*Match, *MatchQuery]()
+	return withInterceptors[[]*Match](ctx, mq, qr, mq.inters)
 }
 
 // AllX is like All, but panics if an error occurs.
@@ -227,9 +227,12 @@ func (mq *MatchQuery) AllX(ctx context.Context) []*Match {
 }
 
 // IDs executes the query and returns a list of Match IDs.
-func (mq *MatchQuery) IDs(ctx context.Context) ([]uint64, error) {
+func (mq *MatchQuery) IDs(ctx context.Context) (ids []uint64, err error) {
-	var ids []uint64
+	if mq.ctx.Unique == nil && mq.path != nil {
-	if err := mq.Select(match.FieldID).Scan(ctx, &ids); err != nil {
+		mq.Unique(true)
+	}
+	ctx = setContextOp(ctx, mq.ctx, "IDs")
+	if err = mq.Select(match.FieldID).Scan(ctx, &ids); err != nil {
 		return nil, err
 	}
 	return ids, nil
@@ -246,10 +249,11 @@ func (mq *MatchQuery) IDsX(ctx context.Context) []uint64 {
 
 // Count returns the count of the given query.
 func (mq *MatchQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, mq.ctx, "Count")
 	if err := mq.prepareQuery(ctx); err != nil {
 		return 0, err
 	}
-	return mq.sqlCount(ctx)
+	return withInterceptors[int](ctx, mq, querierCount[*MatchQuery](), mq.inters)
 }
 
 // CountX is like Count, but panics if an error occurs.
@@ -263,10 +267,15 @@ func (mq *MatchQuery) CountX(ctx context.Context) int {
 
 // Exist returns true if the query has elements in the graph.
 func (mq *MatchQuery) Exist(ctx context.Context) (bool, error) {
-	if err := mq.prepareQuery(ctx); err != nil {
+	ctx = setContextOp(ctx, mq.ctx, "Exist")
-		return false, err
+	switch _, err := mq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("ent: check existence: %w", err)
+	default:
+		return true, nil
 	}
-	return mq.sqlExist(ctx)
 }
 
 // ExistX is like Exist, but panics if an error occurs.
@@ -286,23 +295,22 @@ func (mq *MatchQuery) Clone() *MatchQuery {
 	}
 	return &MatchQuery{
 		config:      mq.config,
-		limit:       mq.limit,
+		ctx:         mq.ctx.Clone(),
-		offset:      mq.offset,
 		order:       append([]OrderFunc{}, mq.order...),
+		inters:      append([]Interceptor{}, mq.inters...),
 		predicates:  append([]predicate.Match{}, mq.predicates...),
 		withStats:   mq.withStats.Clone(),
 		withPlayers: mq.withPlayers.Clone(),
 		// clone intermediate query.
-		sql:    mq.sql.Clone(),
+		sql:  mq.sql.Clone(),
-		path:   mq.path,
+		path: mq.path,
-		unique: mq.unique,
 	}
 }
 
 // WithStats tells the query-builder to eager-load the nodes that are connected to
 // the "stats" edge. The optional arguments are used to configure the query builder of the edge.
 func (mq *MatchQuery) WithStats(opts ...func(*MatchPlayerQuery)) *MatchQuery {
-	query := &MatchPlayerQuery{config: mq.config}
+	query := (&MatchPlayerClient{config: mq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -313,7 +321,7 @@ func (mq *MatchQuery) WithStats(opts ...func(*MatchPlayerQuery)) *MatchQuery {
 // WithPlayers tells the query-builder to eager-load the nodes that are connected to
 // the "players" edge. The optional arguments are used to configure the query builder of the edge.
 func (mq *MatchQuery) WithPlayers(opts ...func(*PlayerQuery)) *MatchQuery {
-	query := &PlayerQuery{config: mq.config}
+	query := (&PlayerClient{config: mq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -336,16 +344,11 @@ func (mq *MatchQuery) WithPlayers(opts ...func(*PlayerQuery)) *MatchQuery {
 //		Aggregate(ent.Count()).
 //		Scan(ctx, &v)
 func (mq *MatchQuery) GroupBy(field string, fields ...string) *MatchGroupBy {
-	grbuild := &MatchGroupBy{config: mq.config}
+	mq.ctx.Fields = append([]string{field}, fields...)
-	grbuild.fields = append([]string{field}, fields...)
+	grbuild := &MatchGroupBy{build: mq}
-	grbuild.path = func(ctx context.Context) (prev *sql.Selector, err error) {
+	grbuild.flds = &mq.ctx.Fields
-		if err := mq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		return mq.sqlQuery(ctx), nil
-	}
 	grbuild.label = match.Label
-	grbuild.flds, grbuild.scan = &grbuild.fields, grbuild.Scan
+	grbuild.scan = grbuild.Scan
 	return grbuild
 }
 
@@ -362,11 +365,11 @@ func (mq *MatchQuery) GroupBy(field string, fields ...string) *MatchGroupBy {
 //		Select(match.FieldShareCode).
 //		Scan(ctx, &v)
 func (mq *MatchQuery) Select(fields ...string) *MatchSelect {
-	mq.fields = append(mq.fields, fields...)
+	mq.ctx.Fields = append(mq.ctx.Fields, fields...)
-	selbuild := &MatchSelect{MatchQuery: mq}
+	sbuild := &MatchSelect{MatchQuery: mq}
-	selbuild.label = match.Label
+	sbuild.label = match.Label
-	selbuild.flds, selbuild.scan = &mq.fields, selbuild.Scan
+	sbuild.flds, sbuild.scan = &mq.ctx.Fields, sbuild.Scan
-	return selbuild
+	return sbuild
 }
 
 // Aggregate returns a MatchSelect configured with the given aggregations.
@@ -375,7 +378,17 @@ func (mq *MatchQuery) Aggregate(fns ...AggregateFunc) *MatchSelect {
 }
 
 func (mq *MatchQuery) prepareQuery(ctx context.Context) error {
-	for _, f := range mq.fields {
+	for _, inter := range mq.inters {
+		if inter == nil {
+			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, mq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range mq.ctx.Fields {
 		if !match.ValidColumn(f) {
 			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
 		}
@@ -487,27 +500,30 @@ func (mq *MatchQuery) loadPlayers(ctx context.Context, query *PlayerQuery, nodes
 	if err := query.prepareQuery(ctx); err != nil {
 		return err
 	}
-	neighbors, err := query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
+	qr := QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
-		assign := spec.Assign
+		return query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
-		values := spec.ScanValues
+			assign := spec.Assign
-		spec.ScanValues = func(columns []string) ([]any, error) {
+			values := spec.ScanValues
-			values, err := values(columns[1:])
+			spec.ScanValues = func(columns []string) ([]any, error) {
-			if err != nil {
+				values, err := values(columns[1:])
-				return nil, err
+				if err != nil {
+					return nil, err
+				}
+				return append([]any{new(sql.NullInt64)}, values...), nil
 			}
-			return append([]any{new(sql.NullInt64)}, values...), nil
+			spec.Assign = func(columns []string, values []any) error {
-		}
+				outValue := uint64(values[0].(*sql.NullInt64).Int64)
-		spec.Assign = func(columns []string, values []any) error {
+				inValue := uint64(values[1].(*sql.NullInt64).Int64)
-			outValue := uint64(values[0].(*sql.NullInt64).Int64)
+				if nids[inValue] == nil {
-			inValue := uint64(values[1].(*sql.NullInt64).Int64)
+					nids[inValue] = map[*Match]struct{}{byID[outValue]: {}}
-			if nids[inValue] == nil {
+					return assign(columns[1:], values[1:])
-				nids[inValue] = map[*Match]struct{}{byID[outValue]: {}}
+				}
-				return assign(columns[1:], values[1:])
+				nids[inValue][byID[outValue]] = struct{}{}
+				return nil
 			}
-			nids[inValue][byID[outValue]] = struct{}{}
+		})
-			return nil
-		}
 	})
+	neighbors, err := withInterceptors[[]*Player](ctx, query, qr, query.inters)
 	if err != nil {
 		return err
 	}
@@ -528,41 +544,22 @@ func (mq *MatchQuery) sqlCount(ctx context.Context) (int, error) {
 	if len(mq.modifiers) > 0 {
 		_spec.Modifiers = mq.modifiers
 	}
-	_spec.Node.Columns = mq.fields
+	_spec.Node.Columns = mq.ctx.Fields
-	if len(mq.fields) > 0 {
+	if len(mq.ctx.Fields) > 0 {
-		_spec.Unique = mq.unique != nil && *mq.unique
+		_spec.Unique = mq.ctx.Unique != nil && *mq.ctx.Unique
 	}
 	return sqlgraph.CountNodes(ctx, mq.driver, _spec)
 }
 
-func (mq *MatchQuery) sqlExist(ctx context.Context) (bool, error) {
-	switch _, err := mq.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
 func (mq *MatchQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := &sqlgraph.QuerySpec{
+	_spec := sqlgraph.NewQuerySpec(match.Table, match.Columns, sqlgraph.NewFieldSpec(match.FieldID, field.TypeUint64))
-		Node: &sqlgraph.NodeSpec{
+	_spec.From = mq.sql
-			Table:   match.Table,
+	if unique := mq.ctx.Unique; unique != nil {
-			Columns: match.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeUint64,
-				Column: match.FieldID,
-			},
-		},
-		From:   mq.sql,
-		Unique: true,
-	}
-	if unique := mq.unique; unique != nil {
 		_spec.Unique = *unique
+	} else if mq.path != nil {
+		_spec.Unique = true
 	}
-	if fields := mq.fields; len(fields) > 0 {
+	if fields := mq.ctx.Fields; len(fields) > 0 {
 		_spec.Node.Columns = make([]string, 0, len(fields))
 		_spec.Node.Columns = append(_spec.Node.Columns, match.FieldID)
 		for i := range fields {
@@ -578,10 +575,10 @@ func (mq *MatchQuery) querySpec() *sqlgraph.QuerySpec {
 			}
 		}
 	}
-	if limit := mq.limit; limit != nil {
+	if limit := mq.ctx.Limit; limit != nil {
 		_spec.Limit = *limit
 	}
-	if offset := mq.offset; offset != nil {
+	if offset := mq.ctx.Offset; offset != nil {
 		_spec.Offset = *offset
 	}
 	if ps := mq.order; len(ps) > 0 {
@@ -597,7 +594,7 @@ func (mq *MatchQuery) querySpec() *sqlgraph.QuerySpec {
 func (mq *MatchQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	builder := sql.Dialect(mq.driver.Dialect())
 	t1 := builder.Table(match.Table)
-	columns := mq.fields
+	columns := mq.ctx.Fields
 	if len(columns) == 0 {
 		columns = match.Columns
 	}
@@ -606,7 +603,7 @@ func (mq *MatchQuery) sqlQuery(ctx context.Context) *sql.Selector {
 		selector = mq.sql
 		selector.Select(selector.Columns(columns...)...)
 	}
-	if mq.unique != nil && *mq.unique {
+	if mq.ctx.Unique != nil && *mq.ctx.Unique {
 		selector.Distinct()
 	}
 	for _, m := range mq.modifiers {
@@ -618,12 +615,12 @@ func (mq *MatchQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	for _, p := range mq.order {
 		p(selector)
 	}
-	if offset := mq.offset; offset != nil {
+	if offset := mq.ctx.Offset; offset != nil {
 		// limit is mandatory for offset clause. We start
 		// with default value, and override it below if needed.
 		selector.Offset(*offset).Limit(math.MaxInt32)
 	}
-	if limit := mq.limit; limit != nil {
+	if limit := mq.ctx.Limit; limit != nil {
 		selector.Limit(*limit)
 	}
 	return selector
@@ -637,13 +634,8 @@ func (mq *MatchQuery) Modify(modifiers ...func(s *sql.Selector)) *MatchSelect {
 
 // MatchGroupBy is the group-by builder for Match entities.
 type MatchGroupBy struct {
-	config
 	selector
-	fields []string
+	build *MatchQuery
-	fns    []AggregateFunc
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
 }
 
 // Aggregate adds the given aggregation functions to the group-by query.
@@ -652,58 +644,46 @@ func (mgb *MatchGroupBy) Aggregate(fns ...AggregateFunc) *MatchGroupBy {
 	return mgb
 }
 
-// Scan applies the group-by query and scans the result into the given value.
+// Scan applies the selector query and scans the result into the given value.
 func (mgb *MatchGroupBy) Scan(ctx context.Context, v any) error {
-	query, err := mgb.path(ctx)
+	ctx = setContextOp(ctx, mgb.build.ctx, "GroupBy")
-	if err != nil {
+	if err := mgb.build.prepareQuery(ctx); err != nil {
 		return err
 	}
-	mgb.sql = query
+	return scanWithInterceptors[*MatchQuery, *MatchGroupBy](ctx, mgb.build, mgb, mgb.build.inters, v)
-	return mgb.sqlScan(ctx, v)
 }
 
-func (mgb *MatchGroupBy) sqlScan(ctx context.Context, v any) error {
+func (mgb *MatchGroupBy) sqlScan(ctx context.Context, root *MatchQuery, v any) error {
-	for _, f := range mgb.fields {
+	selector := root.sqlQuery(ctx).Select()
-		if !match.ValidColumn(f) {
+	aggregation := make([]string, 0, len(mgb.fns))
-			return &ValidationError{Name: f, err: fmt.Errorf("invalid field %q for group-by", f)}
+	for _, fn := range mgb.fns {
-		}
+		aggregation = append(aggregation, fn(selector))
 	}
-	selector := mgb.sqlQuery()
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*mgb.flds)+len(mgb.fns))
+		for _, f := range *mgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*mgb.flds...)...)
 	if err := selector.Err(); err != nil {
 		return err
 	}
 	rows := &sql.Rows{}
 	query, args := selector.Query()
-	if err := mgb.driver.Query(ctx, query, args, rows); err != nil {
+	if err := mgb.build.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
 
-func (mgb *MatchGroupBy) sqlQuery() *sql.Selector {
-	selector := mgb.sql.Select()
-	aggregation := make([]string, 0, len(mgb.fns))
-	for _, fn := range mgb.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(mgb.fields)+len(mgb.fns))
-		for _, f := range mgb.fields {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	return selector.GroupBy(selector.Columns(mgb.fields...)...)
-}
-
 // MatchSelect is the builder for selecting fields of Match entities.
 type MatchSelect struct {
 	*MatchQuery
 	selector
-	// intermediate query (i.e. traversal path).
-	sql *sql.Selector
 }
 
 // Aggregate adds the given aggregation functions to the selector query.
@@ -714,26 +694,27 @@ func (ms *MatchSelect) Aggregate(fns ...AggregateFunc) *MatchSelect {
 
 // Scan applies the selector query and scans the result into the given value.
 func (ms *MatchSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ms.ctx, "Select")
 	if err := ms.prepareQuery(ctx); err != nil {
 		return err
 	}
-	ms.sql = ms.MatchQuery.sqlQuery(ctx)
+	return scanWithInterceptors[*MatchQuery, *MatchSelect](ctx, ms.MatchQuery, ms, ms.inters, v)
-	return ms.sqlScan(ctx, v)
 }
 
-func (ms *MatchSelect) sqlScan(ctx context.Context, v any) error {
+func (ms *MatchSelect) sqlScan(ctx context.Context, root *MatchQuery, v any) error {
+	selector := root.sqlQuery(ctx)
 	aggregation := make([]string, 0, len(ms.fns))
 	for _, fn := range ms.fns {
-		aggregation = append(aggregation, fn(ms.sql))
+		aggregation = append(aggregation, fn(selector))
 	}
 	switch n := len(*ms.selector.flds); {
 	case n == 0 && len(aggregation) > 0:
-		ms.sql.Select(aggregation...)
+		selector.Select(aggregation...)
 	case n != 0 && len(aggregation) > 0:
-		ms.sql.AppendSelect(aggregation...)
+		selector.AppendSelect(aggregation...)
 	}
 	rows := &sql.Rows{}
-	query, args := ms.sql.Query()
+	query, args := selector.Query()
 	if err := ms.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}

ent/match_update.go

@@ -308,34 +308,7 @@ func (mu *MatchUpdate) RemovePlayers(p ...*Player) *MatchUpdate {
 
 // Save executes the query and returns the number of nodes affected by the update operation.
 func (mu *MatchUpdate) Save(ctx context.Context) (int, error) {
-	var (
+	return withHooks[int, MatchMutation](ctx, mu.sqlSave, mu.mutation, mu.hooks)
-		err      error
-		affected int
-	)
-	if len(mu.hooks) == 0 {
-		affected, err = mu.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*MatchMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			mu.mutation = mutation
-			affected, err = mu.sqlSave(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(mu.hooks) - 1; i >= 0; i-- {
-			if mu.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = mu.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, mu.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -367,16 +340,7 @@ func (mu *MatchUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *MatchUpd
 }
 
 func (mu *MatchUpdate) sqlSave(ctx context.Context) (n int, err error) {
-	_spec := &sqlgraph.UpdateSpec{
+	_spec := sqlgraph.NewUpdateSpec(match.Table, match.Columns, sqlgraph.NewFieldSpec(match.FieldID, field.TypeUint64))
-		Node: &sqlgraph.NodeSpec{
-			Table:   match.Table,
-			Columns: match.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeUint64,
-				Column: match.FieldID,
-			},
-		},
-	}
 	if ps := mu.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -573,6 +537,7 @@ func (mu *MatchUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		return 0, err
 	}
+	mu.mutation.done = true
 	return n, nil
 }
 
@@ -860,6 +825,12 @@ func (muo *MatchUpdateOne) RemovePlayers(p ...*Player) *MatchUpdateOne {
 	return muo.RemovePlayerIDs(ids...)
 }
 
+// Where appends a list predicates to the MatchUpdate builder.
+func (muo *MatchUpdateOne) Where(ps ...predicate.Match) *MatchUpdateOne {
+	muo.mutation.Where(ps...)
+	return muo
+}
+
 // Select allows selecting one or more fields (columns) of the returned entity.
 // The default is selecting all fields defined in the entity schema.
 func (muo *MatchUpdateOne) Select(field string, fields ...string) *MatchUpdateOne {
@@ -869,40 +840,7 @@ func (muo *MatchUpdateOne) Select(field string, fields ...string) *MatchUpdateOn
 
 // Save executes the query and returns the updated Match entity.
 func (muo *MatchUpdateOne) Save(ctx context.Context) (*Match, error) {
-	var (
+	return withHooks[*Match, MatchMutation](ctx, muo.sqlSave, muo.mutation, muo.hooks)
-		err  error
-		node *Match
-	)
-	if len(muo.hooks) == 0 {
-		node, err = muo.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*MatchMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			muo.mutation = mutation
-			node, err = muo.sqlSave(ctx)
-			mutation.done = true
-			return node, err
-		})
-		for i := len(muo.hooks) - 1; i >= 0; i-- {
-			if muo.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = muo.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, muo.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*Match)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from MatchMutation", v)
-		}
-		node = nv
-	}
-	return node, err
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -934,16 +872,7 @@ func (muo *MatchUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *Matc
 }
 
 func (muo *MatchUpdateOne) sqlSave(ctx context.Context) (_node *Match, err error) {
-	_spec := &sqlgraph.UpdateSpec{
+	_spec := sqlgraph.NewUpdateSpec(match.Table, match.Columns, sqlgraph.NewFieldSpec(match.FieldID, field.TypeUint64))
-		Node: &sqlgraph.NodeSpec{
-			Table:   match.Table,
-			Columns: match.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeUint64,
-				Column: match.FieldID,
-			},
-		},
-	}
 	id, ok := muo.mutation.ID()
 	if !ok {
 		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Match.id" for update`)}
@@ -1160,5 +1089,6 @@ func (muo *MatchUpdateOne) sqlSave(ctx context.Context) (_node *Match, err error
 		}
 		return nil, err
 	}
+	muo.mutation.done = true
 	return _node, nil
 }

ent/matchplayer.go

@@ -406,39 +406,39 @@ func (mp *MatchPlayer) assignValues(columns []string, values []any) error {
 
 // QueryMatches queries the "matches" edge of the MatchPlayer entity.
 func (mp *MatchPlayer) QueryMatches() *MatchQuery {
-	return (&MatchPlayerClient{config: mp.config}).QueryMatches(mp)
+	return NewMatchPlayerClient(mp.config).QueryMatches(mp)
 }
 
 // QueryPlayers queries the "players" edge of the MatchPlayer entity.
 func (mp *MatchPlayer) QueryPlayers() *PlayerQuery {
-	return (&MatchPlayerClient{config: mp.config}).QueryPlayers(mp)
+	return NewMatchPlayerClient(mp.config).QueryPlayers(mp)
 }
 
 // QueryWeaponStats queries the "weapon_stats" edge of the MatchPlayer entity.
 func (mp *MatchPlayer) QueryWeaponStats() *WeaponQuery {
-	return (&MatchPlayerClient{config: mp.config}).QueryWeaponStats(mp)
+	return NewMatchPlayerClient(mp.config).QueryWeaponStats(mp)
 }
 
 // QueryRoundStats queries the "round_stats" edge of the MatchPlayer entity.
 func (mp *MatchPlayer) QueryRoundStats() *RoundStatsQuery {
-	return (&MatchPlayerClient{config: mp.config}).QueryRoundStats(mp)
+	return NewMatchPlayerClient(mp.config).QueryRoundStats(mp)
 }
 
 // QuerySpray queries the "spray" edge of the MatchPlayer entity.
 func (mp *MatchPlayer) QuerySpray() *SprayQuery {
-	return (&MatchPlayerClient{config: mp.config}).QuerySpray(mp)
+	return NewMatchPlayerClient(mp.config).QuerySpray(mp)
 }
 
 // QueryMessages queries the "messages" edge of the MatchPlayer entity.
 func (mp *MatchPlayer) QueryMessages() *MessagesQuery {
-	return (&MatchPlayerClient{config: mp.config}).QueryMessages(mp)
+	return NewMatchPlayerClient(mp.config).QueryMessages(mp)
 }
 
 // Update returns a builder for updating this MatchPlayer.
 // Note that you need to call MatchPlayer.Unwrap() before calling this method if this MatchPlayer
 // was returned from a transaction, and the transaction was committed or rolled back.
 func (mp *MatchPlayer) Update() *MatchPlayerUpdateOne {
-	return (&MatchPlayerClient{config: mp.config}).UpdateOne(mp)
+	return NewMatchPlayerClient(mp.config).UpdateOne(mp)
 }
 
 // Unwrap unwraps the MatchPlayer entity that was returned from a transaction after it was closed,
@@ -561,9 +561,3 @@ func (mp *MatchPlayer) String() string {
 
 // MatchPlayers is a parsable slice of MatchPlayer.
 type MatchPlayers []*MatchPlayer
-
-func (mp MatchPlayers) config(cfg config) {
-	for _i := range mp {
-		mp[_i].config = cfg
-	}
-}

ent/matchplayer_create.go

@@ -536,49 +536,7 @@ func (mpc *MatchPlayerCreate) Mutation() *MatchPlayerMutation {
 
 // Save creates the MatchPlayer in the database.
 func (mpc *MatchPlayerCreate) Save(ctx context.Context) (*MatchPlayer, error) {
-	var (
+	return withHooks[*MatchPlayer, MatchPlayerMutation](ctx, mpc.sqlSave, mpc.mutation, mpc.hooks)
-		err  error
-		node *MatchPlayer
-	)
-	if len(mpc.hooks) == 0 {
-		if err = mpc.check(); err != nil {
-			return nil, err
-		}
-		node, err = mpc.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*MatchPlayerMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = mpc.check(); err != nil {
-				return nil, err
-			}
-			mpc.mutation = mutation
-			if node, err = mpc.sqlSave(ctx); err != nil {
-				return nil, err
-			}
-			mutation.id = &node.ID
-			mutation.done = true
-			return node, err
-		})
-		for i := len(mpc.hooks) - 1; i >= 0; i-- {
-			if mpc.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = mpc.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, mpc.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*MatchPlayer)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from MatchPlayerMutation", v)
-		}
-		node = nv
-	}
-	return node, err
 }
 
 // SaveX calls Save and panics if Save returns an error.
@@ -635,6 +593,9 @@ func (mpc *MatchPlayerCreate) check() error {
 }
 
 func (mpc *MatchPlayerCreate) sqlSave(ctx context.Context) (*MatchPlayer, error) {
+	if err := mpc.check(); err != nil {
+		return nil, err
+	}
 	_node, _spec := mpc.createSpec()
 	if err := sqlgraph.CreateNode(ctx, mpc.driver, _spec); err != nil {
 		if sqlgraph.IsConstraintError(err) {
@@ -644,19 +605,15 @@ func (mpc *MatchPlayerCreate) sqlSave(ctx context.Context) (*MatchPlayer, error)
 	}
 	id := _spec.ID.Value.(int64)
 	_node.ID = int(id)
+	mpc.mutation.id = &_node.ID
+	mpc.mutation.done = true
 	return _node, nil
 }
 
 func (mpc *MatchPlayerCreate) createSpec() (*MatchPlayer, *sqlgraph.CreateSpec) {
 	var (
 		_node = &MatchPlayer{config: mpc.config}
-		_spec = &sqlgraph.CreateSpec{
+		_spec = sqlgraph.NewCreateSpec(matchplayer.Table, sqlgraph.NewFieldSpec(matchplayer.FieldID, field.TypeInt))
-			Table: matchplayer.Table,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: matchplayer.FieldID,
-			},
-		}
 	)
 	if value, ok := mpc.mutation.TeamID(); ok {
 		_spec.SetField(matchplayer.FieldTeamID, field.TypeInt, value)

ent/matchplayer_delete.go

@@ -4,7 +4,6 @@ package ent
 
 import (
 	"context"
-	"fmt"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -28,34 +27,7 @@ func (mpd *MatchPlayerDelete) Where(ps ...predicate.MatchPlayer) *MatchPlayerDel
 
 // Exec executes the deletion query and returns how many vertices were deleted.
 func (mpd *MatchPlayerDelete) Exec(ctx context.Context) (int, error) {
-	var (
+	return withHooks[int, MatchPlayerMutation](ctx, mpd.sqlExec, mpd.mutation, mpd.hooks)
-		err      error
-		affected int
-	)
-	if len(mpd.hooks) == 0 {
-		affected, err = mpd.sqlExec(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*MatchPlayerMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			mpd.mutation = mutation
-			affected, err = mpd.sqlExec(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(mpd.hooks) - 1; i >= 0; i-- {
-			if mpd.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = mpd.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, mpd.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
 }
 
 // ExecX is like Exec, but panics if an error occurs.
@@ -68,15 +40,7 @@ func (mpd *MatchPlayerDelete) ExecX(ctx context.Context) int {
 }
 
 func (mpd *MatchPlayerDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := &sqlgraph.DeleteSpec{
+	_spec := sqlgraph.NewDeleteSpec(matchplayer.Table, sqlgraph.NewFieldSpec(matchplayer.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
-			Table: matchplayer.Table,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: matchplayer.FieldID,
-			},
-		},
-	}
 	if ps := mpd.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -88,6 +52,7 @@ func (mpd *MatchPlayerDelete) sqlExec(ctx context.Context) (int, error) {
 	if err != nil && sqlgraph.IsConstraintError(err) {
 		err = &ConstraintError{msg: err.Error(), wrap: err}
 	}
+	mpd.mutation.done = true
 	return affected, err
 }
 
@@ -96,6 +61,12 @@ type MatchPlayerDeleteOne struct {
 	mpd *MatchPlayerDelete
 }
 
+// Where appends a list predicates to the MatchPlayerDelete builder.
+func (mpdo *MatchPlayerDeleteOne) Where(ps ...predicate.MatchPlayer) *MatchPlayerDeleteOne {
+	mpdo.mpd.mutation.Where(ps...)
+	return mpdo
+}
+
 // Exec executes the deletion query.
 func (mpdo *MatchPlayerDeleteOne) Exec(ctx context.Context) error {
 	n, err := mpdo.mpd.Exec(ctx)
@@ -111,5 +82,7 @@ func (mpdo *MatchPlayerDeleteOne) Exec(ctx context.Context) error {
 
 // ExecX is like Exec, but panics if an error occurs.
 func (mpdo *MatchPlayerDeleteOne) ExecX(ctx context.Context) {
-	mpdo.mpd.ExecX(ctx)
+	if err := mpdo.Exec(ctx); err != nil {
+		panic(err)
+	}
 }

ent/matchplayer_query.go

@@ -24,11 +24,9 @@ import (
 // MatchPlayerQuery is the builder for querying MatchPlayer entities.
 type MatchPlayerQuery struct {
 	config
-	limit           *int
+	ctx             *QueryContext
-	offset          *int
-	unique          *bool
 	order           []OrderFunc
-	fields          []string
+	inters          []Interceptor
 	predicates      []predicate.MatchPlayer
 	withMatches     *MatchQuery
 	withPlayers     *PlayerQuery
@@ -48,26 +46,26 @@ func (mpq *MatchPlayerQuery) Where(ps ...predicate.MatchPlayer) *MatchPlayerQuer
 	return mpq
 }
 
-// Limit adds a limit step to the query.
+// Limit the number of records to be returned by this query.
 func (mpq *MatchPlayerQuery) Limit(limit int) *MatchPlayerQuery {
-	mpq.limit = &limit
+	mpq.ctx.Limit = &limit
 	return mpq
 }
 
-// Offset adds an offset step to the query.
+// Offset to start from.
 func (mpq *MatchPlayerQuery) Offset(offset int) *MatchPlayerQuery {
-	mpq.offset = &offset
+	mpq.ctx.Offset = &offset
 	return mpq
 }
 
 // Unique configures the query builder to filter duplicate records on query.
 // By default, unique is set to true, and can be disabled using this method.
 func (mpq *MatchPlayerQuery) Unique(unique bool) *MatchPlayerQuery {
-	mpq.unique = &unique
+	mpq.ctx.Unique = &unique
 	return mpq
 }
 
-// Order adds an order step to the query.
+// Order specifies how the records should be ordered.
 func (mpq *MatchPlayerQuery) Order(o ...OrderFunc) *MatchPlayerQuery {
 	mpq.order = append(mpq.order, o...)
 	return mpq
@@ -75,7 +73,7 @@ func (mpq *MatchPlayerQuery) Order(o ...OrderFunc) *MatchPlayerQuery {
 
 // QueryMatches chains the current query on the "matches" edge.
 func (mpq *MatchPlayerQuery) QueryMatches() *MatchQuery {
-	query := &MatchQuery{config: mpq.config}
+	query := (&MatchClient{config: mpq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := mpq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -97,7 +95,7 @@ func (mpq *MatchPlayerQuery) QueryMatches() *MatchQuery {
 
 // QueryPlayers chains the current query on the "players" edge.
 func (mpq *MatchPlayerQuery) QueryPlayers() *PlayerQuery {
-	query := &PlayerQuery{config: mpq.config}
+	query := (&PlayerClient{config: mpq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := mpq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -119,7 +117,7 @@ func (mpq *MatchPlayerQuery) QueryPlayers() *PlayerQuery {
 
 // QueryWeaponStats chains the current query on the "weapon_stats" edge.
 func (mpq *MatchPlayerQuery) QueryWeaponStats() *WeaponQuery {
-	query := &WeaponQuery{config: mpq.config}
+	query := (&WeaponClient{config: mpq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := mpq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -141,7 +139,7 @@ func (mpq *MatchPlayerQuery) QueryWeaponStats() *WeaponQuery {
 
 // QueryRoundStats chains the current query on the "round_stats" edge.
 func (mpq *MatchPlayerQuery) QueryRoundStats() *RoundStatsQuery {
-	query := &RoundStatsQuery{config: mpq.config}
+	query := (&RoundStatsClient{config: mpq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := mpq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -163,7 +161,7 @@ func (mpq *MatchPlayerQuery) QueryRoundStats() *RoundStatsQuery {
 
 // QuerySpray chains the current query on the "spray" edge.
 func (mpq *MatchPlayerQuery) QuerySpray() *SprayQuery {
-	query := &SprayQuery{config: mpq.config}
+	query := (&SprayClient{config: mpq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := mpq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -185,7 +183,7 @@ func (mpq *MatchPlayerQuery) QuerySpray() *SprayQuery {
 
 // QueryMessages chains the current query on the "messages" edge.
 func (mpq *MatchPlayerQuery) QueryMessages() *MessagesQuery {
-	query := &MessagesQuery{config: mpq.config}
+	query := (&MessagesClient{config: mpq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := mpq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -208,7 +206,7 @@ func (mpq *MatchPlayerQuery) QueryMessages() *MessagesQuery {
 // First returns the first MatchPlayer entity from the query.
 // Returns a *NotFoundError when no MatchPlayer was found.
 func (mpq *MatchPlayerQuery) First(ctx context.Context) (*MatchPlayer, error) {
-	nodes, err := mpq.Limit(1).All(ctx)
+	nodes, err := mpq.Limit(1).All(setContextOp(ctx, mpq.ctx, "First"))
 	if err != nil {
 		return nil, err
 	}
@@ -231,7 +229,7 @@ func (mpq *MatchPlayerQuery) FirstX(ctx context.Context) *MatchPlayer {
 // Returns a *NotFoundError when no MatchPlayer ID was found.
 func (mpq *MatchPlayerQuery) FirstID(ctx context.Context) (id int, err error) {
 	var ids []int
-	if ids, err = mpq.Limit(1).IDs(ctx); err != nil {
+	if ids, err = mpq.Limit(1).IDs(setContextOp(ctx, mpq.ctx, "FirstID")); err != nil {
 		return
 	}
 	if len(ids) == 0 {
@@ -254,7 +252,7 @@ func (mpq *MatchPlayerQuery) FirstIDX(ctx context.Context) int {
 // Returns a *NotSingularError when more than one MatchPlayer entity is found.
 // Returns a *NotFoundError when no MatchPlayer entities are found.
 func (mpq *MatchPlayerQuery) Only(ctx context.Context) (*MatchPlayer, error) {
-	nodes, err := mpq.Limit(2).All(ctx)
+	nodes, err := mpq.Limit(2).All(setContextOp(ctx, mpq.ctx, "Only"))
 	if err != nil {
 		return nil, err
 	}
@@ -282,7 +280,7 @@ func (mpq *MatchPlayerQuery) OnlyX(ctx context.Context) *MatchPlayer {
 // Returns a *NotFoundError when no entities are found.
 func (mpq *MatchPlayerQuery) OnlyID(ctx context.Context) (id int, err error) {
 	var ids []int
-	if ids, err = mpq.Limit(2).IDs(ctx); err != nil {
+	if ids, err = mpq.Limit(2).IDs(setContextOp(ctx, mpq.ctx, "OnlyID")); err != nil {
 		return
 	}
 	switch len(ids) {
@@ -307,10 +305,12 @@ func (mpq *MatchPlayerQuery) OnlyIDX(ctx context.Context) int {
 
 // All executes the query and returns a list of MatchPlayers.
 func (mpq *MatchPlayerQuery) All(ctx context.Context) ([]*MatchPlayer, error) {
+	ctx = setContextOp(ctx, mpq.ctx, "All")
 	if err := mpq.prepareQuery(ctx); err != nil {
 		return nil, err
 	}
-	return mpq.sqlAll(ctx)
+	qr := querierAll[[]*MatchPlayer, *MatchPlayerQuery]()
+	return withInterceptors[[]*MatchPlayer](ctx, mpq, qr, mpq.inters)
 }
 
 // AllX is like All, but panics if an error occurs.
@@ -323,9 +323,12 @@ func (mpq *MatchPlayerQuery) AllX(ctx context.Context) []*MatchPlayer {
 }
 
 // IDs executes the query and returns a list of MatchPlayer IDs.
-func (mpq *MatchPlayerQuery) IDs(ctx context.Context) ([]int, error) {
+func (mpq *MatchPlayerQuery) IDs(ctx context.Context) (ids []int, err error) {
-	var ids []int
+	if mpq.ctx.Unique == nil && mpq.path != nil {
-	if err := mpq.Select(matchplayer.FieldID).Scan(ctx, &ids); err != nil {
+		mpq.Unique(true)
+	}
+	ctx = setContextOp(ctx, mpq.ctx, "IDs")
+	if err = mpq.Select(matchplayer.FieldID).Scan(ctx, &ids); err != nil {
 		return nil, err
 	}
 	return ids, nil
@@ -342,10 +345,11 @@ func (mpq *MatchPlayerQuery) IDsX(ctx context.Context) []int {
 
 // Count returns the count of the given query.
 func (mpq *MatchPlayerQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, mpq.ctx, "Count")
 	if err := mpq.prepareQuery(ctx); err != nil {
 		return 0, err
 	}
-	return mpq.sqlCount(ctx)
+	return withInterceptors[int](ctx, mpq, querierCount[*MatchPlayerQuery](), mpq.inters)
 }
 
 // CountX is like Count, but panics if an error occurs.
@@ -359,10 +363,15 @@ func (mpq *MatchPlayerQuery) CountX(ctx context.Context) int {
 
 // Exist returns true if the query has elements in the graph.
 func (mpq *MatchPlayerQuery) Exist(ctx context.Context) (bool, error) {
-	if err := mpq.prepareQuery(ctx); err != nil {
+	ctx = setContextOp(ctx, mpq.ctx, "Exist")
-		return false, err
+	switch _, err := mpq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("ent: check existence: %w", err)
+	default:
+		return true, nil
 	}
-	return mpq.sqlExist(ctx)
 }
 
 // ExistX is like Exist, but panics if an error occurs.
@@ -382,9 +391,9 @@ func (mpq *MatchPlayerQuery) Clone() *MatchPlayerQuery {
 	}
 	return &MatchPlayerQuery{
 		config:          mpq.config,
-		limit:           mpq.limit,
+		ctx:             mpq.ctx.Clone(),
-		offset:          mpq.offset,
 		order:           append([]OrderFunc{}, mpq.order...),
+		inters:          append([]Interceptor{}, mpq.inters...),
 		predicates:      append([]predicate.MatchPlayer{}, mpq.predicates...),
 		withMatches:     mpq.withMatches.Clone(),
 		withPlayers:     mpq.withPlayers.Clone(),
@@ -393,16 +402,15 @@ func (mpq *MatchPlayerQuery) Clone() *MatchPlayerQuery {
 		withSpray:       mpq.withSpray.Clone(),
 		withMessages:    mpq.withMessages.Clone(),
 		// clone intermediate query.
-		sql:    mpq.sql.Clone(),
+		sql:  mpq.sql.Clone(),
-		path:   mpq.path,
+		path: mpq.path,
-		unique: mpq.unique,
 	}
 }
 
 // WithMatches tells the query-builder to eager-load the nodes that are connected to
 // the "matches" edge. The optional arguments are used to configure the query builder of the edge.
 func (mpq *MatchPlayerQuery) WithMatches(opts ...func(*MatchQuery)) *MatchPlayerQuery {
-	query := &MatchQuery{config: mpq.config}
+	query := (&MatchClient{config: mpq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -413,7 +421,7 @@ func (mpq *MatchPlayerQuery) WithMatches(opts ...func(*MatchQuery)) *MatchPlayer
 // WithPlayers tells the query-builder to eager-load the nodes that are connected to
 // the "players" edge. The optional arguments are used to configure the query builder of the edge.
 func (mpq *MatchPlayerQuery) WithPlayers(opts ...func(*PlayerQuery)) *MatchPlayerQuery {
-	query := &PlayerQuery{config: mpq.config}
+	query := (&PlayerClient{config: mpq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -424,7 +432,7 @@ func (mpq *MatchPlayerQuery) WithPlayers(opts ...func(*PlayerQuery)) *MatchPlaye
 // WithWeaponStats tells the query-builder to eager-load the nodes that are connected to
 // the "weapon_stats" edge. The optional arguments are used to configure the query builder of the edge.
 func (mpq *MatchPlayerQuery) WithWeaponStats(opts ...func(*WeaponQuery)) *MatchPlayerQuery {
-	query := &WeaponQuery{config: mpq.config}
+	query := (&WeaponClient{config: mpq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -435,7 +443,7 @@ func (mpq *MatchPlayerQuery) WithWeaponStats(opts ...func(*WeaponQuery)) *MatchP
 // WithRoundStats tells the query-builder to eager-load the nodes that are connected to
 // the "round_stats" edge. The optional arguments are used to configure the query builder of the edge.
 func (mpq *MatchPlayerQuery) WithRoundStats(opts ...func(*RoundStatsQuery)) *MatchPlayerQuery {
-	query := &RoundStatsQuery{config: mpq.config}
+	query := (&RoundStatsClient{config: mpq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -446,7 +454,7 @@ func (mpq *MatchPlayerQuery) WithRoundStats(opts ...func(*RoundStatsQuery)) *Mat
 // WithSpray tells the query-builder to eager-load the nodes that are connected to
 // the "spray" edge. The optional arguments are used to configure the query builder of the edge.
 func (mpq *MatchPlayerQuery) WithSpray(opts ...func(*SprayQuery)) *MatchPlayerQuery {
-	query := &SprayQuery{config: mpq.config}
+	query := (&SprayClient{config: mpq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -457,7 +465,7 @@ func (mpq *MatchPlayerQuery) WithSpray(opts ...func(*SprayQuery)) *MatchPlayerQu
 // WithMessages tells the query-builder to eager-load the nodes that are connected to
 // the "messages" edge. The optional arguments are used to configure the query builder of the edge.
 func (mpq *MatchPlayerQuery) WithMessages(opts ...func(*MessagesQuery)) *MatchPlayerQuery {
-	query := &MessagesQuery{config: mpq.config}
+	query := (&MessagesClient{config: mpq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -480,16 +488,11 @@ func (mpq *MatchPlayerQuery) WithMessages(opts ...func(*MessagesQuery)) *MatchPl
 //		Aggregate(ent.Count()).
 //		Scan(ctx, &v)
 func (mpq *MatchPlayerQuery) GroupBy(field string, fields ...string) *MatchPlayerGroupBy {
-	grbuild := &MatchPlayerGroupBy{config: mpq.config}
+	mpq.ctx.Fields = append([]string{field}, fields...)
-	grbuild.fields = append([]string{field}, fields...)
+	grbuild := &MatchPlayerGroupBy{build: mpq}
-	grbuild.path = func(ctx context.Context) (prev *sql.Selector, err error) {
+	grbuild.flds = &mpq.ctx.Fields
-		if err := mpq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		return mpq.sqlQuery(ctx), nil
-	}
 	grbuild.label = matchplayer.Label
-	grbuild.flds, grbuild.scan = &grbuild.fields, grbuild.Scan
+	grbuild.scan = grbuild.Scan
 	return grbuild
 }
 
@@ -506,11 +509,11 @@ func (mpq *MatchPlayerQuery) GroupBy(field string, fields ...string) *MatchPlaye
 //		Select(matchplayer.FieldTeamID).
 //		Scan(ctx, &v)
 func (mpq *MatchPlayerQuery) Select(fields ...string) *MatchPlayerSelect {
-	mpq.fields = append(mpq.fields, fields...)
+	mpq.ctx.Fields = append(mpq.ctx.Fields, fields...)
-	selbuild := &MatchPlayerSelect{MatchPlayerQuery: mpq}
+	sbuild := &MatchPlayerSelect{MatchPlayerQuery: mpq}
-	selbuild.label = matchplayer.Label
+	sbuild.label = matchplayer.Label
-	selbuild.flds, selbuild.scan = &mpq.fields, selbuild.Scan
+	sbuild.flds, sbuild.scan = &mpq.ctx.Fields, sbuild.Scan
-	return selbuild
+	return sbuild
 }
 
 // Aggregate returns a MatchPlayerSelect configured with the given aggregations.
@@ -519,7 +522,17 @@ func (mpq *MatchPlayerQuery) Aggregate(fns ...AggregateFunc) *MatchPlayerSelect
 }
 
 func (mpq *MatchPlayerQuery) prepareQuery(ctx context.Context) error {
-	for _, f := range mpq.fields {
+	for _, inter := range mpq.inters {
+		if inter == nil {
+			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, mpq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range mpq.ctx.Fields {
 		if !matchplayer.ValidColumn(f) {
 			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
 		}
@@ -621,6 +634,9 @@ func (mpq *MatchPlayerQuery) loadMatches(ctx context.Context, query *MatchQuery,
 		}
 		nodeids[fk] = append(nodeids[fk], nodes[i])
 	}
+	if len(ids) == 0 {
+		return nil
+	}
 	query.Where(match.IDIn(ids...))
 	neighbors, err := query.All(ctx)
 	if err != nil {
@@ -647,6 +663,9 @@ func (mpq *MatchPlayerQuery) loadPlayers(ctx context.Context, query *PlayerQuery
 		}
 		nodeids[fk] = append(nodeids[fk], nodes[i])
 	}
+	if len(ids) == 0 {
+		return nil
+	}
 	query.Where(player.IDIn(ids...))
 	neighbors, err := query.All(ctx)
 	if err != nil {
@@ -793,41 +812,22 @@ func (mpq *MatchPlayerQuery) sqlCount(ctx context.Context) (int, error) {
 	if len(mpq.modifiers) > 0 {
 		_spec.Modifiers = mpq.modifiers
 	}
-	_spec.Node.Columns = mpq.fields
+	_spec.Node.Columns = mpq.ctx.Fields
-	if len(mpq.fields) > 0 {
+	if len(mpq.ctx.Fields) > 0 {
-		_spec.Unique = mpq.unique != nil && *mpq.unique
+		_spec.Unique = mpq.ctx.Unique != nil && *mpq.ctx.Unique
 	}
 	return sqlgraph.CountNodes(ctx, mpq.driver, _spec)
 }
 
-func (mpq *MatchPlayerQuery) sqlExist(ctx context.Context) (bool, error) {
-	switch _, err := mpq.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
 func (mpq *MatchPlayerQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := &sqlgraph.QuerySpec{
+	_spec := sqlgraph.NewQuerySpec(matchplayer.Table, matchplayer.Columns, sqlgraph.NewFieldSpec(matchplayer.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
+	_spec.From = mpq.sql
-			Table:   matchplayer.Table,
+	if unique := mpq.ctx.Unique; unique != nil {
-			Columns: matchplayer.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: matchplayer.FieldID,
-			},
-		},
-		From:   mpq.sql,
-		Unique: true,
-	}
-	if unique := mpq.unique; unique != nil {
 		_spec.Unique = *unique
+	} else if mpq.path != nil {
+		_spec.Unique = true
 	}
-	if fields := mpq.fields; len(fields) > 0 {
+	if fields := mpq.ctx.Fields; len(fields) > 0 {
 		_spec.Node.Columns = make([]string, 0, len(fields))
 		_spec.Node.Columns = append(_spec.Node.Columns, matchplayer.FieldID)
 		for i := range fields {
@@ -843,10 +843,10 @@ func (mpq *MatchPlayerQuery) querySpec() *sqlgraph.QuerySpec {
 			}
 		}
 	}
-	if limit := mpq.limit; limit != nil {
+	if limit := mpq.ctx.Limit; limit != nil {
 		_spec.Limit = *limit
 	}
-	if offset := mpq.offset; offset != nil {
+	if offset := mpq.ctx.Offset; offset != nil {
 		_spec.Offset = *offset
 	}
 	if ps := mpq.order; len(ps) > 0 {
@@ -862,7 +862,7 @@ func (mpq *MatchPlayerQuery) querySpec() *sqlgraph.QuerySpec {
 func (mpq *MatchPlayerQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	builder := sql.Dialect(mpq.driver.Dialect())
 	t1 := builder.Table(matchplayer.Table)
-	columns := mpq.fields
+	columns := mpq.ctx.Fields
 	if len(columns) == 0 {
 		columns = matchplayer.Columns
 	}
@@ -871,7 +871,7 @@ func (mpq *MatchPlayerQuery) sqlQuery(ctx context.Context) *sql.Selector {
 		selector = mpq.sql
 		selector.Select(selector.Columns(columns...)...)
 	}
-	if mpq.unique != nil && *mpq.unique {
+	if mpq.ctx.Unique != nil && *mpq.ctx.Unique {
 		selector.Distinct()
 	}
 	for _, m := range mpq.modifiers {
@@ -883,12 +883,12 @@ func (mpq *MatchPlayerQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	for _, p := range mpq.order {
 		p(selector)
 	}
-	if offset := mpq.offset; offset != nil {
+	if offset := mpq.ctx.Offset; offset != nil {
 		// limit is mandatory for offset clause. We start
 		// with default value, and override it below if needed.
 		selector.Offset(*offset).Limit(math.MaxInt32)
 	}
-	if limit := mpq.limit; limit != nil {
+	if limit := mpq.ctx.Limit; limit != nil {
 		selector.Limit(*limit)
 	}
 	return selector
@@ -902,13 +902,8 @@ func (mpq *MatchPlayerQuery) Modify(modifiers ...func(s *sql.Selector)) *MatchPl
 
 // MatchPlayerGroupBy is the group-by builder for MatchPlayer entities.
 type MatchPlayerGroupBy struct {
-	config
 	selector
-	fields []string
+	build *MatchPlayerQuery
-	fns    []AggregateFunc
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
 }
 
 // Aggregate adds the given aggregation functions to the group-by query.
@@ -917,58 +912,46 @@ func (mpgb *MatchPlayerGroupBy) Aggregate(fns ...AggregateFunc) *MatchPlayerGrou
 	return mpgb
 }
 
-// Scan applies the group-by query and scans the result into the given value.
+// Scan applies the selector query and scans the result into the given value.
 func (mpgb *MatchPlayerGroupBy) Scan(ctx context.Context, v any) error {
-	query, err := mpgb.path(ctx)
+	ctx = setContextOp(ctx, mpgb.build.ctx, "GroupBy")
-	if err != nil {
+	if err := mpgb.build.prepareQuery(ctx); err != nil {
 		return err
 	}
-	mpgb.sql = query
+	return scanWithInterceptors[*MatchPlayerQuery, *MatchPlayerGroupBy](ctx, mpgb.build, mpgb, mpgb.build.inters, v)
-	return mpgb.sqlScan(ctx, v)
 }
 
-func (mpgb *MatchPlayerGroupBy) sqlScan(ctx context.Context, v any) error {
+func (mpgb *MatchPlayerGroupBy) sqlScan(ctx context.Context, root *MatchPlayerQuery, v any) error {
-	for _, f := range mpgb.fields {
+	selector := root.sqlQuery(ctx).Select()
-		if !matchplayer.ValidColumn(f) {
+	aggregation := make([]string, 0, len(mpgb.fns))
-			return &ValidationError{Name: f, err: fmt.Errorf("invalid field %q for group-by", f)}
+	for _, fn := range mpgb.fns {
-		}
+		aggregation = append(aggregation, fn(selector))
 	}
-	selector := mpgb.sqlQuery()
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*mpgb.flds)+len(mpgb.fns))
+		for _, f := range *mpgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*mpgb.flds...)...)
 	if err := selector.Err(); err != nil {
 		return err
 	}
 	rows := &sql.Rows{}
 	query, args := selector.Query()
-	if err := mpgb.driver.Query(ctx, query, args, rows); err != nil {
+	if err := mpgb.build.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
 
-func (mpgb *MatchPlayerGroupBy) sqlQuery() *sql.Selector {
-	selector := mpgb.sql.Select()
-	aggregation := make([]string, 0, len(mpgb.fns))
-	for _, fn := range mpgb.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(mpgb.fields)+len(mpgb.fns))
-		for _, f := range mpgb.fields {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	return selector.GroupBy(selector.Columns(mpgb.fields...)...)
-}
-
 // MatchPlayerSelect is the builder for selecting fields of MatchPlayer entities.
 type MatchPlayerSelect struct {
 	*MatchPlayerQuery
 	selector
-	// intermediate query (i.e. traversal path).
-	sql *sql.Selector
 }
 
 // Aggregate adds the given aggregation functions to the selector query.
@@ -979,26 +962,27 @@ func (mps *MatchPlayerSelect) Aggregate(fns ...AggregateFunc) *MatchPlayerSelect
 
 // Scan applies the selector query and scans the result into the given value.
 func (mps *MatchPlayerSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, mps.ctx, "Select")
 	if err := mps.prepareQuery(ctx); err != nil {
 		return err
 	}
-	mps.sql = mps.MatchPlayerQuery.sqlQuery(ctx)
+	return scanWithInterceptors[*MatchPlayerQuery, *MatchPlayerSelect](ctx, mps.MatchPlayerQuery, mps, mps.inters, v)
-	return mps.sqlScan(ctx, v)
 }
 
-func (mps *MatchPlayerSelect) sqlScan(ctx context.Context, v any) error {
+func (mps *MatchPlayerSelect) sqlScan(ctx context.Context, root *MatchPlayerQuery, v any) error {
+	selector := root.sqlQuery(ctx)
 	aggregation := make([]string, 0, len(mps.fns))
 	for _, fn := range mps.fns {
-		aggregation = append(aggregation, fn(mps.sql))
+		aggregation = append(aggregation, fn(selector))
 	}
 	switch n := len(*mps.selector.flds); {
 	case n == 0 && len(aggregation) > 0:
-		mps.sql.Select(aggregation...)
+		selector.Select(aggregation...)
 	case n != 0 && len(aggregation) > 0:
-		mps.sql.AppendSelect(aggregation...)
+		selector.AppendSelect(aggregation...)
 	}
 	rows := &sql.Rows{}
-	query, args := mps.sql.Query()
+	query, args := selector.Query()
 	if err := mps.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}

ent/matchplayer_update.go

@@ -1000,40 +1000,7 @@ func (mpu *MatchPlayerUpdate) RemoveMessages(m ...*Messages) *MatchPlayerUpdate
 
 // Save executes the query and returns the number of nodes affected by the update operation.
 func (mpu *MatchPlayerUpdate) Save(ctx context.Context) (int, error) {
-	var (
+	return withHooks[int, MatchPlayerMutation](ctx, mpu.sqlSave, mpu.mutation, mpu.hooks)
-		err      error
-		affected int
-	)
-	if len(mpu.hooks) == 0 {
-		if err = mpu.check(); err != nil {
-			return 0, err
-		}
-		affected, err = mpu.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*MatchPlayerMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = mpu.check(); err != nil {
-				return 0, err
-			}
-			mpu.mutation = mutation
-			affected, err = mpu.sqlSave(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(mpu.hooks) - 1; i >= 0; i-- {
-			if mpu.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = mpu.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, mpu.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -1075,16 +1042,10 @@ func (mpu *MatchPlayerUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *M
 }
 
 func (mpu *MatchPlayerUpdate) sqlSave(ctx context.Context) (n int, err error) {
-	_spec := &sqlgraph.UpdateSpec{
+	if err := mpu.check(); err != nil {
-		Node: &sqlgraph.NodeSpec{
+		return n, err
-			Table:   matchplayer.Table,
-			Columns: matchplayer.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: matchplayer.FieldID,
-			},
-		},
 	}
+	_spec := sqlgraph.NewUpdateSpec(matchplayer.Table, matchplayer.Columns, sqlgraph.NewFieldSpec(matchplayer.FieldID, field.TypeInt))
 	if ps := mpu.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -1639,6 +1600,7 @@ func (mpu *MatchPlayerUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		return 0, err
 	}
+	mpu.mutation.done = true
 	return n, nil
 }
 
@@ -2615,6 +2577,12 @@ func (mpuo *MatchPlayerUpdateOne) RemoveMessages(m ...*Messages) *MatchPlayerUpd
 	return mpuo.RemoveMessageIDs(ids...)
 }
 
+// Where appends a list predicates to the MatchPlayerUpdate builder.
+func (mpuo *MatchPlayerUpdateOne) Where(ps ...predicate.MatchPlayer) *MatchPlayerUpdateOne {
+	mpuo.mutation.Where(ps...)
+	return mpuo
+}
+
 // Select allows selecting one or more fields (columns) of the returned entity.
 // The default is selecting all fields defined in the entity schema.
 func (mpuo *MatchPlayerUpdateOne) Select(field string, fields ...string) *MatchPlayerUpdateOne {
@@ -2624,46 +2592,7 @@ func (mpuo *MatchPlayerUpdateOne) Select(field string, fields ...string) *MatchP
 
 // Save executes the query and returns the updated MatchPlayer entity.
 func (mpuo *MatchPlayerUpdateOne) Save(ctx context.Context) (*MatchPlayer, error) {
-	var (
+	return withHooks[*MatchPlayer, MatchPlayerMutation](ctx, mpuo.sqlSave, mpuo.mutation, mpuo.hooks)
-		err  error
-		node *MatchPlayer
-	)
-	if len(mpuo.hooks) == 0 {
-		if err = mpuo.check(); err != nil {
-			return nil, err
-		}
-		node, err = mpuo.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*MatchPlayerMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = mpuo.check(); err != nil {
-				return nil, err
-			}
-			mpuo.mutation = mutation
-			node, err = mpuo.sqlSave(ctx)
-			mutation.done = true
-			return node, err
-		})
-		for i := len(mpuo.hooks) - 1; i >= 0; i-- {
-			if mpuo.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = mpuo.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, mpuo.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*MatchPlayer)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from MatchPlayerMutation", v)
-		}
-		node = nv
-	}
-	return node, err
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -2705,16 +2634,10 @@ func (mpuo *MatchPlayerUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)
 }
 
 func (mpuo *MatchPlayerUpdateOne) sqlSave(ctx context.Context) (_node *MatchPlayer, err error) {
-	_spec := &sqlgraph.UpdateSpec{
+	if err := mpuo.check(); err != nil {
-		Node: &sqlgraph.NodeSpec{
+		return _node, err
-			Table:   matchplayer.Table,
-			Columns: matchplayer.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: matchplayer.FieldID,
-			},
-		},
 	}
+	_spec := sqlgraph.NewUpdateSpec(matchplayer.Table, matchplayer.Columns, sqlgraph.NewFieldSpec(matchplayer.FieldID, field.TypeInt))
 	id, ok := mpuo.mutation.ID()
 	if !ok {
 		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "MatchPlayer.id" for update`)}
@@ -3289,5 +3212,6 @@ func (mpuo *MatchPlayerUpdateOne) sqlSave(ctx context.Context) (_node *MatchPlay
 		}
 		return nil, err
 	}
+	mpuo.mutation.done = true
 	return _node, nil
 }

ent/messages.go

@@ -116,14 +116,14 @@ func (m *Messages) assignValues(columns []string, values []any) error {
 
 // QueryMatchPlayer queries the "match_player" edge of the Messages entity.
 func (m *Messages) QueryMatchPlayer() *MatchPlayerQuery {
-	return (&MessagesClient{config: m.config}).QueryMatchPlayer(m)
+	return NewMessagesClient(m.config).QueryMatchPlayer(m)
 }
 
 // Update returns a builder for updating this Messages.
 // Note that you need to call Messages.Unwrap() before calling this method if this Messages
 // was returned from a transaction, and the transaction was committed or rolled back.
 func (m *Messages) Update() *MessagesUpdateOne {
-	return (&MessagesClient{config: m.config}).UpdateOne(m)
+	return NewMessagesClient(m.config).UpdateOne(m)
 }
 
 // Unwrap unwraps the Messages entity that was returned from a transaction after it was closed,
@@ -156,9 +156,3 @@ func (m *Messages) String() string {
 
 // MessagesSlice is a parsable slice of Messages.
 type MessagesSlice []*Messages
-
-func (m MessagesSlice) config(cfg config) {
-	for _i := range m {
-		m[_i].config = cfg
-	}
-}

ent/messages/where.go

@@ -10,271 +10,177 @@ import (
 
 // ID filters vertices based on their ID field.
 func ID(id int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldEQ(FieldID, id))
-		s.Where(sql.EQ(s.C(FieldID), id))
-	})
 }
 
 // IDEQ applies the EQ predicate on the ID field.
 func IDEQ(id int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldEQ(FieldID, id))
-		s.Where(sql.EQ(s.C(FieldID), id))
-	})
 }
 
 // IDNEQ applies the NEQ predicate on the ID field.
 func IDNEQ(id int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldNEQ(FieldID, id))
-		s.Where(sql.NEQ(s.C(FieldID), id))
-	})
 }
 
 // IDIn applies the In predicate on the ID field.
 func IDIn(ids ...int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldIn(FieldID, ids...))
-		v := make([]any, len(ids))
-		for i := range v {
-			v[i] = ids[i]
-		}
-		s.Where(sql.In(s.C(FieldID), v...))
-	})
 }
 
 // IDNotIn applies the NotIn predicate on the ID field.
 func IDNotIn(ids ...int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldNotIn(FieldID, ids...))
-		v := make([]any, len(ids))
-		for i := range v {
-			v[i] = ids[i]
-		}
-		s.Where(sql.NotIn(s.C(FieldID), v...))
-	})
 }
 
 // IDGT applies the GT predicate on the ID field.
 func IDGT(id int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldGT(FieldID, id))
-		s.Where(sql.GT(s.C(FieldID), id))
-	})
 }
 
 // IDGTE applies the GTE predicate on the ID field.
 func IDGTE(id int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldGTE(FieldID, id))
-		s.Where(sql.GTE(s.C(FieldID), id))
-	})
 }
 
 // IDLT applies the LT predicate on the ID field.
 func IDLT(id int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldLT(FieldID, id))
-		s.Where(sql.LT(s.C(FieldID), id))
-	})
 }
 
 // IDLTE applies the LTE predicate on the ID field.
 func IDLTE(id int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldLTE(FieldID, id))
-		s.Where(sql.LTE(s.C(FieldID), id))
-	})
 }
 
 // Message applies equality check predicate on the "message" field. It's identical to MessageEQ.
 func Message(v string) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldEQ(FieldMessage, v))
-		s.Where(sql.EQ(s.C(FieldMessage), v))
-	})
 }
 
 // AllChat applies equality check predicate on the "all_chat" field. It's identical to AllChatEQ.
 func AllChat(v bool) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldEQ(FieldAllChat, v))
-		s.Where(sql.EQ(s.C(FieldAllChat), v))
-	})
 }
 
 // Tick applies equality check predicate on the "tick" field. It's identical to TickEQ.
 func Tick(v int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldEQ(FieldTick, v))
-		s.Where(sql.EQ(s.C(FieldTick), v))
-	})
 }
 
 // MessageEQ applies the EQ predicate on the "message" field.
 func MessageEQ(v string) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldEQ(FieldMessage, v))
-		s.Where(sql.EQ(s.C(FieldMessage), v))
-	})
 }
 
 // MessageNEQ applies the NEQ predicate on the "message" field.
 func MessageNEQ(v string) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldNEQ(FieldMessage, v))
-		s.Where(sql.NEQ(s.C(FieldMessage), v))
-	})
 }
 
 // MessageIn applies the In predicate on the "message" field.
 func MessageIn(vs ...string) predicate.Messages {
-	v := make([]any, len(vs))
+	return predicate.Messages(sql.FieldIn(FieldMessage, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Messages(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldMessage), v...))
-	})
 }
 
 // MessageNotIn applies the NotIn predicate on the "message" field.
 func MessageNotIn(vs ...string) predicate.Messages {
-	v := make([]any, len(vs))
+	return predicate.Messages(sql.FieldNotIn(FieldMessage, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Messages(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldMessage), v...))
-	})
 }
 
 // MessageGT applies the GT predicate on the "message" field.
 func MessageGT(v string) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldGT(FieldMessage, v))
-		s.Where(sql.GT(s.C(FieldMessage), v))
-	})
 }
 
 // MessageGTE applies the GTE predicate on the "message" field.
 func MessageGTE(v string) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldGTE(FieldMessage, v))
-		s.Where(sql.GTE(s.C(FieldMessage), v))
-	})
 }
 
 // MessageLT applies the LT predicate on the "message" field.
 func MessageLT(v string) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldLT(FieldMessage, v))
-		s.Where(sql.LT(s.C(FieldMessage), v))
-	})
 }
 
 // MessageLTE applies the LTE predicate on the "message" field.
 func MessageLTE(v string) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldLTE(FieldMessage, v))
-		s.Where(sql.LTE(s.C(FieldMessage), v))
-	})
 }
 
 // MessageContains applies the Contains predicate on the "message" field.
 func MessageContains(v string) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldContains(FieldMessage, v))
-		s.Where(sql.Contains(s.C(FieldMessage), v))
-	})
 }
 
 // MessageHasPrefix applies the HasPrefix predicate on the "message" field.
 func MessageHasPrefix(v string) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldHasPrefix(FieldMessage, v))
-		s.Where(sql.HasPrefix(s.C(FieldMessage), v))
-	})
 }
 
 // MessageHasSuffix applies the HasSuffix predicate on the "message" field.
 func MessageHasSuffix(v string) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldHasSuffix(FieldMessage, v))
-		s.Where(sql.HasSuffix(s.C(FieldMessage), v))
-	})
 }
 
 // MessageEqualFold applies the EqualFold predicate on the "message" field.
 func MessageEqualFold(v string) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldEqualFold(FieldMessage, v))
-		s.Where(sql.EqualFold(s.C(FieldMessage), v))
-	})
 }
 
 // MessageContainsFold applies the ContainsFold predicate on the "message" field.
 func MessageContainsFold(v string) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldContainsFold(FieldMessage, v))
-		s.Where(sql.ContainsFold(s.C(FieldMessage), v))
-	})
 }
 
 // AllChatEQ applies the EQ predicate on the "all_chat" field.
 func AllChatEQ(v bool) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldEQ(FieldAllChat, v))
-		s.Where(sql.EQ(s.C(FieldAllChat), v))
-	})
 }
 
 // AllChatNEQ applies the NEQ predicate on the "all_chat" field.
 func AllChatNEQ(v bool) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldNEQ(FieldAllChat, v))
-		s.Where(sql.NEQ(s.C(FieldAllChat), v))
-	})
 }
 
 // TickEQ applies the EQ predicate on the "tick" field.
 func TickEQ(v int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldEQ(FieldTick, v))
-		s.Where(sql.EQ(s.C(FieldTick), v))
-	})
 }
 
 // TickNEQ applies the NEQ predicate on the "tick" field.
 func TickNEQ(v int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldNEQ(FieldTick, v))
-		s.Where(sql.NEQ(s.C(FieldTick), v))
-	})
 }
 
 // TickIn applies the In predicate on the "tick" field.
 func TickIn(vs ...int) predicate.Messages {
-	v := make([]any, len(vs))
+	return predicate.Messages(sql.FieldIn(FieldTick, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Messages(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldTick), v...))
-	})
 }
 
 // TickNotIn applies the NotIn predicate on the "tick" field.
 func TickNotIn(vs ...int) predicate.Messages {
-	v := make([]any, len(vs))
+	return predicate.Messages(sql.FieldNotIn(FieldTick, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Messages(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldTick), v...))
-	})
 }
 
 // TickGT applies the GT predicate on the "tick" field.
 func TickGT(v int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldGT(FieldTick, v))
-		s.Where(sql.GT(s.C(FieldTick), v))
-	})
 }
 
 // TickGTE applies the GTE predicate on the "tick" field.
 func TickGTE(v int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldGTE(FieldTick, v))
-		s.Where(sql.GTE(s.C(FieldTick), v))
-	})
 }
 
 // TickLT applies the LT predicate on the "tick" field.
 func TickLT(v int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldLT(FieldTick, v))
-		s.Where(sql.LT(s.C(FieldTick), v))
-	})
 }
 
 // TickLTE applies the LTE predicate on the "tick" field.
 func TickLTE(v int) predicate.Messages {
-	return predicate.Messages(func(s *sql.Selector) {
+	return predicate.Messages(sql.FieldLTE(FieldTick, v))
-		s.Where(sql.LTE(s.C(FieldTick), v))
-	})
 }
 
 // HasMatchPlayer applies the HasEdge predicate on the "match_player" edge.
@@ -282,7 +188,6 @@ func HasMatchPlayer() predicate.Messages {
 	return predicate.Messages(func(s *sql.Selector) {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(Table, FieldID),
-			sqlgraph.To(MatchPlayerTable, FieldID),
 			sqlgraph.Edge(sqlgraph.M2O, true, MatchPlayerTable, MatchPlayerColumn),
 		)
 		sqlgraph.HasNeighbors(s, step)

ent/messages_create.go

@@ -64,49 +64,7 @@ func (mc *MessagesCreate) Mutation() *MessagesMutation {
 
 // Save creates the Messages in the database.
 func (mc *MessagesCreate) Save(ctx context.Context) (*Messages, error) {
-	var (
+	return withHooks[*Messages, MessagesMutation](ctx, mc.sqlSave, mc.mutation, mc.hooks)
-		err  error
-		node *Messages
-	)
-	if len(mc.hooks) == 0 {
-		if err = mc.check(); err != nil {
-			return nil, err
-		}
-		node, err = mc.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*MessagesMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = mc.check(); err != nil {
-				return nil, err
-			}
-			mc.mutation = mutation
-			if node, err = mc.sqlSave(ctx); err != nil {
-				return nil, err
-			}
-			mutation.id = &node.ID
-			mutation.done = true
-			return node, err
-		})
-		for i := len(mc.hooks) - 1; i >= 0; i-- {
-			if mc.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = mc.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, mc.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*Messages)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from MessagesMutation", v)
-		}
-		node = nv
-	}
-	return node, err
 }
 
 // SaveX calls Save and panics if Save returns an error.
@@ -146,6 +104,9 @@ func (mc *MessagesCreate) check() error {
 }
 
 func (mc *MessagesCreate) sqlSave(ctx context.Context) (*Messages, error) {
+	if err := mc.check(); err != nil {
+		return nil, err
+	}
 	_node, _spec := mc.createSpec()
 	if err := sqlgraph.CreateNode(ctx, mc.driver, _spec); err != nil {
 		if sqlgraph.IsConstraintError(err) {
@@ -155,19 +116,15 @@ func (mc *MessagesCreate) sqlSave(ctx context.Context) (*Messages, error) {
 	}
 	id := _spec.ID.Value.(int64)
 	_node.ID = int(id)
+	mc.mutation.id = &_node.ID
+	mc.mutation.done = true
 	return _node, nil
 }
 
 func (mc *MessagesCreate) createSpec() (*Messages, *sqlgraph.CreateSpec) {
 	var (
 		_node = &Messages{config: mc.config}
-		_spec = &sqlgraph.CreateSpec{
+		_spec = sqlgraph.NewCreateSpec(messages.Table, sqlgraph.NewFieldSpec(messages.FieldID, field.TypeInt))
-			Table: messages.Table,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: messages.FieldID,
-			},
-		}
 	)
 	if value, ok := mc.mutation.Message(); ok {
 		_spec.SetField(messages.FieldMessage, field.TypeString, value)

ent/messages_delete.go

@@ -4,7 +4,6 @@ package ent
 
 import (
 	"context"
-	"fmt"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -28,34 +27,7 @@ func (md *MessagesDelete) Where(ps ...predicate.Messages) *MessagesDelete {
 
 // Exec executes the deletion query and returns how many vertices were deleted.
 func (md *MessagesDelete) Exec(ctx context.Context) (int, error) {
-	var (
+	return withHooks[int, MessagesMutation](ctx, md.sqlExec, md.mutation, md.hooks)
-		err      error
-		affected int
-	)
-	if len(md.hooks) == 0 {
-		affected, err = md.sqlExec(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*MessagesMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			md.mutation = mutation
-			affected, err = md.sqlExec(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(md.hooks) - 1; i >= 0; i-- {
-			if md.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = md.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, md.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
 }
 
 // ExecX is like Exec, but panics if an error occurs.
@@ -68,15 +40,7 @@ func (md *MessagesDelete) ExecX(ctx context.Context) int {
 }
 
 func (md *MessagesDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := &sqlgraph.DeleteSpec{
+	_spec := sqlgraph.NewDeleteSpec(messages.Table, sqlgraph.NewFieldSpec(messages.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
-			Table: messages.Table,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: messages.FieldID,
-			},
-		},
-	}
 	if ps := md.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -88,6 +52,7 @@ func (md *MessagesDelete) sqlExec(ctx context.Context) (int, error) {
 	if err != nil && sqlgraph.IsConstraintError(err) {
 		err = &ConstraintError{msg: err.Error(), wrap: err}
 	}
+	md.mutation.done = true
 	return affected, err
 }
 
@@ -96,6 +61,12 @@ type MessagesDeleteOne struct {
 	md *MessagesDelete
 }
 
+// Where appends a list predicates to the MessagesDelete builder.
+func (mdo *MessagesDeleteOne) Where(ps ...predicate.Messages) *MessagesDeleteOne {
+	mdo.md.mutation.Where(ps...)
+	return mdo
+}
+
 // Exec executes the deletion query.
 func (mdo *MessagesDeleteOne) Exec(ctx context.Context) error {
 	n, err := mdo.md.Exec(ctx)
@@ -111,5 +82,7 @@ func (mdo *MessagesDeleteOne) Exec(ctx context.Context) error {
 
 // ExecX is like Exec, but panics if an error occurs.
 func (mdo *MessagesDeleteOne) ExecX(ctx context.Context) {
-	mdo.md.ExecX(ctx)
+	if err := mdo.Exec(ctx); err != nil {
+		panic(err)
+	}
 }

ent/messages_query.go

@@ -18,11 +18,9 @@ import (
 // MessagesQuery is the builder for querying Messages entities.
 type MessagesQuery struct {
 	config
-	limit           *int
+	ctx             *QueryContext
-	offset          *int
-	unique          *bool
 	order           []OrderFunc
-	fields          []string
+	inters          []Interceptor
 	predicates      []predicate.Messages
 	withMatchPlayer *MatchPlayerQuery
 	withFKs         bool
@@ -38,26 +36,26 @@ func (mq *MessagesQuery) Where(ps ...predicate.Messages) *MessagesQuery {
 	return mq
 }
 
-// Limit adds a limit step to the query.
+// Limit the number of records to be returned by this query.
 func (mq *MessagesQuery) Limit(limit int) *MessagesQuery {
-	mq.limit = &limit
+	mq.ctx.Limit = &limit
 	return mq
 }
 
-// Offset adds an offset step to the query.
+// Offset to start from.
 func (mq *MessagesQuery) Offset(offset int) *MessagesQuery {
-	mq.offset = &offset
+	mq.ctx.Offset = &offset
 	return mq
 }
 
 // Unique configures the query builder to filter duplicate records on query.
 // By default, unique is set to true, and can be disabled using this method.
 func (mq *MessagesQuery) Unique(unique bool) *MessagesQuery {
-	mq.unique = &unique
+	mq.ctx.Unique = &unique
 	return mq
 }
 
-// Order adds an order step to the query.
+// Order specifies how the records should be ordered.
 func (mq *MessagesQuery) Order(o ...OrderFunc) *MessagesQuery {
 	mq.order = append(mq.order, o...)
 	return mq
@@ -65,7 +63,7 @@ func (mq *MessagesQuery) Order(o ...OrderFunc) *MessagesQuery {
 
 // QueryMatchPlayer chains the current query on the "match_player" edge.
 func (mq *MessagesQuery) QueryMatchPlayer() *MatchPlayerQuery {
-	query := &MatchPlayerQuery{config: mq.config}
+	query := (&MatchPlayerClient{config: mq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := mq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -88,7 +86,7 @@ func (mq *MessagesQuery) QueryMatchPlayer() *MatchPlayerQuery {
 // First returns the first Messages entity from the query.
 // Returns a *NotFoundError when no Messages was found.
 func (mq *MessagesQuery) First(ctx context.Context) (*Messages, error) {
-	nodes, err := mq.Limit(1).All(ctx)
+	nodes, err := mq.Limit(1).All(setContextOp(ctx, mq.ctx, "First"))
 	if err != nil {
 		return nil, err
 	}
@@ -111,7 +109,7 @@ func (mq *MessagesQuery) FirstX(ctx context.Context) *Messages {
 // Returns a *NotFoundError when no Messages ID was found.
 func (mq *MessagesQuery) FirstID(ctx context.Context) (id int, err error) {
 	var ids []int
-	if ids, err = mq.Limit(1).IDs(ctx); err != nil {
+	if ids, err = mq.Limit(1).IDs(setContextOp(ctx, mq.ctx, "FirstID")); err != nil {
 		return
 	}
 	if len(ids) == 0 {
@@ -134,7 +132,7 @@ func (mq *MessagesQuery) FirstIDX(ctx context.Context) int {
 // Returns a *NotSingularError when more than one Messages entity is found.
 // Returns a *NotFoundError when no Messages entities are found.
 func (mq *MessagesQuery) Only(ctx context.Context) (*Messages, error) {
-	nodes, err := mq.Limit(2).All(ctx)
+	nodes, err := mq.Limit(2).All(setContextOp(ctx, mq.ctx, "Only"))
 	if err != nil {
 		return nil, err
 	}
@@ -162,7 +160,7 @@ func (mq *MessagesQuery) OnlyX(ctx context.Context) *Messages {
 // Returns a *NotFoundError when no entities are found.
 func (mq *MessagesQuery) OnlyID(ctx context.Context) (id int, err error) {
 	var ids []int
-	if ids, err = mq.Limit(2).IDs(ctx); err != nil {
+	if ids, err = mq.Limit(2).IDs(setContextOp(ctx, mq.ctx, "OnlyID")); err != nil {
 		return
 	}
 	switch len(ids) {
@@ -187,10 +185,12 @@ func (mq *MessagesQuery) OnlyIDX(ctx context.Context) int {
 
 // All executes the query and returns a list of MessagesSlice.
 func (mq *MessagesQuery) All(ctx context.Context) ([]*Messages, error) {
+	ctx = setContextOp(ctx, mq.ctx, "All")
 	if err := mq.prepareQuery(ctx); err != nil {
 		return nil, err
 	}
-	return mq.sqlAll(ctx)
+	qr := querierAll[[]*Messages, *MessagesQuery]()
+	return withInterceptors[[]*Messages](ctx, mq, qr, mq.inters)
 }
 
 // AllX is like All, but panics if an error occurs.
@@ -203,9 +203,12 @@ func (mq *MessagesQuery) AllX(ctx context.Context) []*Messages {
 }
 
 // IDs executes the query and returns a list of Messages IDs.
-func (mq *MessagesQuery) IDs(ctx context.Context) ([]int, error) {
+func (mq *MessagesQuery) IDs(ctx context.Context) (ids []int, err error) {
-	var ids []int
+	if mq.ctx.Unique == nil && mq.path != nil {
-	if err := mq.Select(messages.FieldID).Scan(ctx, &ids); err != nil {
+		mq.Unique(true)
+	}
+	ctx = setContextOp(ctx, mq.ctx, "IDs")
+	if err = mq.Select(messages.FieldID).Scan(ctx, &ids); err != nil {
 		return nil, err
 	}
 	return ids, nil
@@ -222,10 +225,11 @@ func (mq *MessagesQuery) IDsX(ctx context.Context) []int {
 
 // Count returns the count of the given query.
 func (mq *MessagesQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, mq.ctx, "Count")
 	if err := mq.prepareQuery(ctx); err != nil {
 		return 0, err
 	}
-	return mq.sqlCount(ctx)
+	return withInterceptors[int](ctx, mq, querierCount[*MessagesQuery](), mq.inters)
 }
 
 // CountX is like Count, but panics if an error occurs.
@@ -239,10 +243,15 @@ func (mq *MessagesQuery) CountX(ctx context.Context) int {
 
 // Exist returns true if the query has elements in the graph.
 func (mq *MessagesQuery) Exist(ctx context.Context) (bool, error) {
-	if err := mq.prepareQuery(ctx); err != nil {
+	ctx = setContextOp(ctx, mq.ctx, "Exist")
-		return false, err
+	switch _, err := mq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("ent: check existence: %w", err)
+	default:
+		return true, nil
 	}
-	return mq.sqlExist(ctx)
 }
 
 // ExistX is like Exist, but panics if an error occurs.
@@ -262,22 +271,21 @@ func (mq *MessagesQuery) Clone() *MessagesQuery {
 	}
 	return &MessagesQuery{
 		config:          mq.config,
-		limit:           mq.limit,
+		ctx:             mq.ctx.Clone(),
-		offset:          mq.offset,
 		order:           append([]OrderFunc{}, mq.order...),
+		inters:          append([]Interceptor{}, mq.inters...),
 		predicates:      append([]predicate.Messages{}, mq.predicates...),
 		withMatchPlayer: mq.withMatchPlayer.Clone(),
 		// clone intermediate query.
-		sql:    mq.sql.Clone(),
+		sql:  mq.sql.Clone(),
-		path:   mq.path,
+		path: mq.path,
-		unique: mq.unique,
 	}
 }
 
 // WithMatchPlayer tells the query-builder to eager-load the nodes that are connected to
 // the "match_player" edge. The optional arguments are used to configure the query builder of the edge.
 func (mq *MessagesQuery) WithMatchPlayer(opts ...func(*MatchPlayerQuery)) *MessagesQuery {
-	query := &MatchPlayerQuery{config: mq.config}
+	query := (&MatchPlayerClient{config: mq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -300,16 +308,11 @@ func (mq *MessagesQuery) WithMatchPlayer(opts ...func(*MatchPlayerQuery)) *Messa
 //		Aggregate(ent.Count()).
 //		Scan(ctx, &v)
 func (mq *MessagesQuery) GroupBy(field string, fields ...string) *MessagesGroupBy {
-	grbuild := &MessagesGroupBy{config: mq.config}
+	mq.ctx.Fields = append([]string{field}, fields...)
-	grbuild.fields = append([]string{field}, fields...)
+	grbuild := &MessagesGroupBy{build: mq}
-	grbuild.path = func(ctx context.Context) (prev *sql.Selector, err error) {
+	grbuild.flds = &mq.ctx.Fields
-		if err := mq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		return mq.sqlQuery(ctx), nil
-	}
 	grbuild.label = messages.Label
-	grbuild.flds, grbuild.scan = &grbuild.fields, grbuild.Scan
+	grbuild.scan = grbuild.Scan
 	return grbuild
 }
 
@@ -326,11 +329,11 @@ func (mq *MessagesQuery) GroupBy(field string, fields ...string) *MessagesGroupB
 //		Select(messages.FieldMessage).
 //		Scan(ctx, &v)
 func (mq *MessagesQuery) Select(fields ...string) *MessagesSelect {
-	mq.fields = append(mq.fields, fields...)
+	mq.ctx.Fields = append(mq.ctx.Fields, fields...)
-	selbuild := &MessagesSelect{MessagesQuery: mq}
+	sbuild := &MessagesSelect{MessagesQuery: mq}
-	selbuild.label = messages.Label
+	sbuild.label = messages.Label
-	selbuild.flds, selbuild.scan = &mq.fields, selbuild.Scan
+	sbuild.flds, sbuild.scan = &mq.ctx.Fields, sbuild.Scan
-	return selbuild
+	return sbuild
 }
 
 // Aggregate returns a MessagesSelect configured with the given aggregations.
@@ -339,7 +342,17 @@ func (mq *MessagesQuery) Aggregate(fns ...AggregateFunc) *MessagesSelect {
 }
 
 func (mq *MessagesQuery) prepareQuery(ctx context.Context) error {
-	for _, f := range mq.fields {
+	for _, inter := range mq.inters {
+		if inter == nil {
+			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, mq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range mq.ctx.Fields {
 		if !messages.ValidColumn(f) {
 			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
 		}
@@ -412,6 +425,9 @@ func (mq *MessagesQuery) loadMatchPlayer(ctx context.Context, query *MatchPlayer
 		}
 		nodeids[fk] = append(nodeids[fk], nodes[i])
 	}
+	if len(ids) == 0 {
+		return nil
+	}
 	query.Where(matchplayer.IDIn(ids...))
 	neighbors, err := query.All(ctx)
 	if err != nil {
@@ -434,41 +450,22 @@ func (mq *MessagesQuery) sqlCount(ctx context.Context) (int, error) {
 	if len(mq.modifiers) > 0 {
 		_spec.Modifiers = mq.modifiers
 	}
-	_spec.Node.Columns = mq.fields
+	_spec.Node.Columns = mq.ctx.Fields
-	if len(mq.fields) > 0 {
+	if len(mq.ctx.Fields) > 0 {
-		_spec.Unique = mq.unique != nil && *mq.unique
+		_spec.Unique = mq.ctx.Unique != nil && *mq.ctx.Unique
 	}
 	return sqlgraph.CountNodes(ctx, mq.driver, _spec)
 }
 
-func (mq *MessagesQuery) sqlExist(ctx context.Context) (bool, error) {
-	switch _, err := mq.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
 func (mq *MessagesQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := &sqlgraph.QuerySpec{
+	_spec := sqlgraph.NewQuerySpec(messages.Table, messages.Columns, sqlgraph.NewFieldSpec(messages.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
+	_spec.From = mq.sql
-			Table:   messages.Table,
+	if unique := mq.ctx.Unique; unique != nil {
-			Columns: messages.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: messages.FieldID,
-			},
-		},
-		From:   mq.sql,
-		Unique: true,
-	}
-	if unique := mq.unique; unique != nil {
 		_spec.Unique = *unique
+	} else if mq.path != nil {
+		_spec.Unique = true
 	}
-	if fields := mq.fields; len(fields) > 0 {
+	if fields := mq.ctx.Fields; len(fields) > 0 {
 		_spec.Node.Columns = make([]string, 0, len(fields))
 		_spec.Node.Columns = append(_spec.Node.Columns, messages.FieldID)
 		for i := range fields {
@@ -484,10 +481,10 @@ func (mq *MessagesQuery) querySpec() *sqlgraph.QuerySpec {
 			}
 		}
 	}
-	if limit := mq.limit; limit != nil {
+	if limit := mq.ctx.Limit; limit != nil {
 		_spec.Limit = *limit
 	}
-	if offset := mq.offset; offset != nil {
+	if offset := mq.ctx.Offset; offset != nil {
 		_spec.Offset = *offset
 	}
 	if ps := mq.order; len(ps) > 0 {
@@ -503,7 +500,7 @@ func (mq *MessagesQuery) querySpec() *sqlgraph.QuerySpec {
 func (mq *MessagesQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	builder := sql.Dialect(mq.driver.Dialect())
 	t1 := builder.Table(messages.Table)
-	columns := mq.fields
+	columns := mq.ctx.Fields
 	if len(columns) == 0 {
 		columns = messages.Columns
 	}
@@ -512,7 +509,7 @@ func (mq *MessagesQuery) sqlQuery(ctx context.Context) *sql.Selector {
 		selector = mq.sql
 		selector.Select(selector.Columns(columns...)...)
 	}
-	if mq.unique != nil && *mq.unique {
+	if mq.ctx.Unique != nil && *mq.ctx.Unique {
 		selector.Distinct()
 	}
 	for _, m := range mq.modifiers {
@@ -524,12 +521,12 @@ func (mq *MessagesQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	for _, p := range mq.order {
 		p(selector)
 	}
-	if offset := mq.offset; offset != nil {
+	if offset := mq.ctx.Offset; offset != nil {
 		// limit is mandatory for offset clause. We start
 		// with default value, and override it below if needed.
 		selector.Offset(*offset).Limit(math.MaxInt32)
 	}
-	if limit := mq.limit; limit != nil {
+	if limit := mq.ctx.Limit; limit != nil {
 		selector.Limit(*limit)
 	}
 	return selector
@@ -543,13 +540,8 @@ func (mq *MessagesQuery) Modify(modifiers ...func(s *sql.Selector)) *MessagesSel
 
 // MessagesGroupBy is the group-by builder for Messages entities.
 type MessagesGroupBy struct {
-	config
 	selector
-	fields []string
+	build *MessagesQuery
-	fns    []AggregateFunc
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
 }
 
 // Aggregate adds the given aggregation functions to the group-by query.
@@ -558,58 +550,46 @@ func (mgb *MessagesGroupBy) Aggregate(fns ...AggregateFunc) *MessagesGroupBy {
 	return mgb
 }
 
-// Scan applies the group-by query and scans the result into the given value.
+// Scan applies the selector query and scans the result into the given value.
 func (mgb *MessagesGroupBy) Scan(ctx context.Context, v any) error {
-	query, err := mgb.path(ctx)
+	ctx = setContextOp(ctx, mgb.build.ctx, "GroupBy")
-	if err != nil {
+	if err := mgb.build.prepareQuery(ctx); err != nil {
 		return err
 	}
-	mgb.sql = query
+	return scanWithInterceptors[*MessagesQuery, *MessagesGroupBy](ctx, mgb.build, mgb, mgb.build.inters, v)
-	return mgb.sqlScan(ctx, v)
 }
 
-func (mgb *MessagesGroupBy) sqlScan(ctx context.Context, v any) error {
+func (mgb *MessagesGroupBy) sqlScan(ctx context.Context, root *MessagesQuery, v any) error {
-	for _, f := range mgb.fields {
+	selector := root.sqlQuery(ctx).Select()
-		if !messages.ValidColumn(f) {
+	aggregation := make([]string, 0, len(mgb.fns))
-			return &ValidationError{Name: f, err: fmt.Errorf("invalid field %q for group-by", f)}
+	for _, fn := range mgb.fns {
-		}
+		aggregation = append(aggregation, fn(selector))
 	}
-	selector := mgb.sqlQuery()
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*mgb.flds)+len(mgb.fns))
+		for _, f := range *mgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*mgb.flds...)...)
 	if err := selector.Err(); err != nil {
 		return err
 	}
 	rows := &sql.Rows{}
 	query, args := selector.Query()
-	if err := mgb.driver.Query(ctx, query, args, rows); err != nil {
+	if err := mgb.build.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
 
-func (mgb *MessagesGroupBy) sqlQuery() *sql.Selector {
-	selector := mgb.sql.Select()
-	aggregation := make([]string, 0, len(mgb.fns))
-	for _, fn := range mgb.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(mgb.fields)+len(mgb.fns))
-		for _, f := range mgb.fields {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	return selector.GroupBy(selector.Columns(mgb.fields...)...)
-}
-
 // MessagesSelect is the builder for selecting fields of Messages entities.
 type MessagesSelect struct {
 	*MessagesQuery
 	selector
-	// intermediate query (i.e. traversal path).
-	sql *sql.Selector
 }
 
 // Aggregate adds the given aggregation functions to the selector query.
@@ -620,26 +600,27 @@ func (ms *MessagesSelect) Aggregate(fns ...AggregateFunc) *MessagesSelect {
 
 // Scan applies the selector query and scans the result into the given value.
 func (ms *MessagesSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ms.ctx, "Select")
 	if err := ms.prepareQuery(ctx); err != nil {
 		return err
 	}
-	ms.sql = ms.MessagesQuery.sqlQuery(ctx)
+	return scanWithInterceptors[*MessagesQuery, *MessagesSelect](ctx, ms.MessagesQuery, ms, ms.inters, v)
-	return ms.sqlScan(ctx, v)
 }
 
-func (ms *MessagesSelect) sqlScan(ctx context.Context, v any) error {
+func (ms *MessagesSelect) sqlScan(ctx context.Context, root *MessagesQuery, v any) error {
+	selector := root.sqlQuery(ctx)
 	aggregation := make([]string, 0, len(ms.fns))
 	for _, fn := range ms.fns {
-		aggregation = append(aggregation, fn(ms.sql))
+		aggregation = append(aggregation, fn(selector))
 	}
 	switch n := len(*ms.selector.flds); {
 	case n == 0 && len(aggregation) > 0:
-		ms.sql.Select(aggregation...)
+		selector.Select(aggregation...)
 	case n != 0 && len(aggregation) > 0:
-		ms.sql.AppendSelect(aggregation...)
+		selector.AppendSelect(aggregation...)
 	}
 	rows := &sql.Rows{}
-	query, args := ms.sql.Query()
+	query, args := selector.Query()
 	if err := ms.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}

ent/messages_update.go

@@ -86,34 +86,7 @@ func (mu *MessagesUpdate) ClearMatchPlayer() *MessagesUpdate {
 
 // Save executes the query and returns the number of nodes affected by the update operation.
 func (mu *MessagesUpdate) Save(ctx context.Context) (int, error) {
-	var (
+	return withHooks[int, MessagesMutation](ctx, mu.sqlSave, mu.mutation, mu.hooks)
-		err      error
-		affected int
-	)
-	if len(mu.hooks) == 0 {
-		affected, err = mu.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*MessagesMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			mu.mutation = mutation
-			affected, err = mu.sqlSave(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(mu.hooks) - 1; i >= 0; i-- {
-			if mu.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = mu.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, mu.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -145,16 +118,7 @@ func (mu *MessagesUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *Messa
 }
 
 func (mu *MessagesUpdate) sqlSave(ctx context.Context) (n int, err error) {
-	_spec := &sqlgraph.UpdateSpec{
+	_spec := sqlgraph.NewUpdateSpec(messages.Table, messages.Columns, sqlgraph.NewFieldSpec(messages.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
-			Table:   messages.Table,
-			Columns: messages.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: messages.FieldID,
-			},
-		},
-	}
 	if ps := mu.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -218,6 +182,7 @@ func (mu *MessagesUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		return 0, err
 	}
+	mu.mutation.done = true
 	return n, nil
 }
 
@@ -285,6 +250,12 @@ func (muo *MessagesUpdateOne) ClearMatchPlayer() *MessagesUpdateOne {
 	return muo
 }
 
+// Where appends a list predicates to the MessagesUpdate builder.
+func (muo *MessagesUpdateOne) Where(ps ...predicate.Messages) *MessagesUpdateOne {
+	muo.mutation.Where(ps...)
+	return muo
+}
+
 // Select allows selecting one or more fields (columns) of the returned entity.
 // The default is selecting all fields defined in the entity schema.
 func (muo *MessagesUpdateOne) Select(field string, fields ...string) *MessagesUpdateOne {
@@ -294,40 +265,7 @@ func (muo *MessagesUpdateOne) Select(field string, fields ...string) *MessagesUp
 
 // Save executes the query and returns the updated Messages entity.
 func (muo *MessagesUpdateOne) Save(ctx context.Context) (*Messages, error) {
-	var (
+	return withHooks[*Messages, MessagesMutation](ctx, muo.sqlSave, muo.mutation, muo.hooks)
-		err  error
-		node *Messages
-	)
-	if len(muo.hooks) == 0 {
-		node, err = muo.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*MessagesMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			muo.mutation = mutation
-			node, err = muo.sqlSave(ctx)
-			mutation.done = true
-			return node, err
-		})
-		for i := len(muo.hooks) - 1; i >= 0; i-- {
-			if muo.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = muo.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, muo.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*Messages)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from MessagesMutation", v)
-		}
-		node = nv
-	}
-	return node, err
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -359,16 +297,7 @@ func (muo *MessagesUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *M
 }
 
 func (muo *MessagesUpdateOne) sqlSave(ctx context.Context) (_node *Messages, err error) {
-	_spec := &sqlgraph.UpdateSpec{
+	_spec := sqlgraph.NewUpdateSpec(messages.Table, messages.Columns, sqlgraph.NewFieldSpec(messages.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
-			Table:   messages.Table,
-			Columns: messages.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: messages.FieldID,
-			},
-		},
-	}
 	id, ok := muo.mutation.ID()
 	if !ok {
 		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Messages.id" for update`)}
@@ -452,5 +381,6 @@ func (muo *MessagesUpdateOne) sqlSave(ctx context.Context) (_node *Messages, err
 		}
 		return nil, err
 	}
+	muo.mutation.done = true
 	return _node, nil
 }

ent/mutation.go

@@ -9,6 +9,8 @@ import (
 	"sync"
 	"time"
 
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
 	"git.harting.dev/csgowtf/csgowtfd/ent/match"
 	"git.harting.dev/csgowtf/csgowtfd/ent/matchplayer"
 	"git.harting.dev/csgowtf/csgowtfd/ent/messages"
@@ -17,8 +19,6 @@ import (
 	"git.harting.dev/csgowtf/csgowtfd/ent/roundstats"
 	"git.harting.dev/csgowtf/csgowtfd/ent/spray"
 	"git.harting.dev/csgowtf/csgowtfd/ent/weapon"
-
-	"entgo.io/ent"
 )
 
 const (
@@ -971,11 +971,26 @@ func (m *MatchMutation) Where(ps ...predicate.Match) {
 	m.predicates = append(m.predicates, ps...)
 }
 
+// WhereP appends storage-level predicates to the MatchMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *MatchMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.Match, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
 // Op returns the operation name.
 func (m *MatchMutation) Op() Op {
 	return m.op
 }
 
+// SetOp allows setting the mutation operation.
+func (m *MatchMutation) SetOp(op Op) {
+	m.op = op
+}
+
 // Type returns the node type of this mutation (Match).
 func (m *MatchMutation) Type() string {
 	return m.typ
@@ -4128,11 +4143,26 @@ func (m *MatchPlayerMutation) Where(ps ...predicate.MatchPlayer) {
 	m.predicates = append(m.predicates, ps...)
 }
 
+// WhereP appends storage-level predicates to the MatchPlayerMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *MatchPlayerMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.MatchPlayer, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
 // Op returns the operation name.
 func (m *MatchPlayerMutation) Op() Op {
 	return m.op
 }
 
+// SetOp allows setting the mutation operation.
+func (m *MatchPlayerMutation) SetOp(op Op) {
+	m.op = op
+}
+
 // Type returns the node type of this mutation (MatchPlayer).
 func (m *MatchPlayerMutation) Type() string {
 	return m.typ
@@ -5779,11 +5809,26 @@ func (m *MessagesMutation) Where(ps ...predicate.Messages) {
 	m.predicates = append(m.predicates, ps...)
 }
 
+// WhereP appends storage-level predicates to the MessagesMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *MessagesMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.Messages, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
 // Op returns the operation name.
 func (m *MessagesMutation) Op() Op {
 	return m.op
 }
 
+// SetOp allows setting the mutation operation.
+func (m *MessagesMutation) SetOp(op Op) {
+	m.op = op
+}
+
 // Type returns the node type of this mutation (Messages).
 func (m *MessagesMutation) Type() string {
 	return m.typ
@@ -7145,11 +7190,26 @@ func (m *PlayerMutation) Where(ps ...predicate.Player) {
 	m.predicates = append(m.predicates, ps...)
 }
 
+// WhereP appends storage-level predicates to the PlayerMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *PlayerMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.Player, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
 // Op returns the operation name.
 func (m *PlayerMutation) Op() Op {
 	return m.op
 }
 
+// SetOp allows setting the mutation operation.
+func (m *PlayerMutation) SetOp(op Op) {
+	m.op = op
+}
+
 // Type returns the node type of this mutation (Player).
 func (m *PlayerMutation) Type() string {
 	return m.typ
@@ -8165,11 +8225,26 @@ func (m *RoundStatsMutation) Where(ps ...predicate.RoundStats) {
 	m.predicates = append(m.predicates, ps...)
 }
 
+// WhereP appends storage-level predicates to the RoundStatsMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *RoundStatsMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.RoundStats, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
 // Op returns the operation name.
 func (m *RoundStatsMutation) Op() Op {
 	return m.op
 }
 
+// SetOp allows setting the mutation operation.
+func (m *RoundStatsMutation) SetOp(op Op) {
+	m.op = op
+}
+
 // Type returns the node type of this mutation (RoundStats).
 func (m *RoundStatsMutation) Type() string {
 	return m.typ
@@ -8703,11 +8778,26 @@ func (m *SprayMutation) Where(ps ...predicate.Spray) {
 	m.predicates = append(m.predicates, ps...)
 }
 
+// WhereP appends storage-level predicates to the SprayMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *SprayMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.Spray, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
 // Op returns the operation name.
 func (m *SprayMutation) Op() Op {
 	return m.op
 }
 
+// SetOp allows setting the mutation operation.
+func (m *SprayMutation) SetOp(op Op) {
+	m.op = op
+}
+
 // Type returns the node type of this mutation (Spray).
 func (m *SprayMutation) Type() string {
 	return m.typ
@@ -9308,11 +9398,26 @@ func (m *WeaponMutation) Where(ps ...predicate.Weapon) {
 	m.predicates = append(m.predicates, ps...)
 }
 
+// WhereP appends storage-level predicates to the WeaponMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *WeaponMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.Weapon, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
 // Op returns the operation name.
 func (m *WeaponMutation) Op() Op {
 	return m.op
 }
 
+// SetOp allows setting the mutation operation.
+func (m *WeaponMutation) SetOp(op Op) {
+	m.op = op
+}
+
 // Type returns the node type of this mutation (Weapon).
 func (m *WeaponMutation) Type() string {
 	return m.typ

ent/player.go

@@ -217,19 +217,19 @@ func (pl *Player) assignValues(columns []string, values []any) error {
 
 // QueryStats queries the "stats" edge of the Player entity.
 func (pl *Player) QueryStats() *MatchPlayerQuery {
-	return (&PlayerClient{config: pl.config}).QueryStats(pl)
+	return NewPlayerClient(pl.config).QueryStats(pl)
 }
 
 // QueryMatches queries the "matches" edge of the Player entity.
 func (pl *Player) QueryMatches() *MatchQuery {
-	return (&PlayerClient{config: pl.config}).QueryMatches(pl)
+	return NewPlayerClient(pl.config).QueryMatches(pl)
 }
 
 // Update returns a builder for updating this Player.
 // Note that you need to call Player.Unwrap() before calling this method if this Player
 // was returned from a transaction, and the transaction was committed or rolled back.
 func (pl *Player) Update() *PlayerUpdateOne {
-	return (&PlayerClient{config: pl.config}).UpdateOne(pl)
+	return NewPlayerClient(pl.config).UpdateOne(pl)
 }
 
 // Unwrap unwraps the Player entity that was returned from a transaction after it was closed,
@@ -300,9 +300,3 @@ func (pl *Player) String() string {
 
 // Players is a parsable slice of Player.
 type Players []*Player
-
-func (pl Players) config(cfg config) {
-	for _i := range pl {
-		pl[_i].config = cfg
-	}
-}

ent/player_create.go

@@ -289,50 +289,8 @@ func (pc *PlayerCreate) Mutation() *PlayerMutation {
 
 // Save creates the Player in the database.
 func (pc *PlayerCreate) Save(ctx context.Context) (*Player, error) {
-	var (
-		err  error
-		node *Player
-	)
 	pc.defaults()
-	if len(pc.hooks) == 0 {
+	return withHooks[*Player, PlayerMutation](ctx, pc.sqlSave, pc.mutation, pc.hooks)
-		if err = pc.check(); err != nil {
-			return nil, err
-		}
-		node, err = pc.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*PlayerMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = pc.check(); err != nil {
-				return nil, err
-			}
-			pc.mutation = mutation
-			if node, err = pc.sqlSave(ctx); err != nil {
-				return nil, err
-			}
-			mutation.id = &node.ID
-			mutation.done = true
-			return node, err
-		})
-		for i := len(pc.hooks) - 1; i >= 0; i-- {
-			if pc.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = pc.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, pc.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*Player)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from PlayerMutation", v)
-		}
-		node = nv
-	}
-	return node, err
 }
 
 // SaveX calls Save and panics if Save returns an error.
@@ -374,6 +332,9 @@ func (pc *PlayerCreate) check() error {
 }
 
 func (pc *PlayerCreate) sqlSave(ctx context.Context) (*Player, error) {
+	if err := pc.check(); err != nil {
+		return nil, err
+	}
 	_node, _spec := pc.createSpec()
 	if err := sqlgraph.CreateNode(ctx, pc.driver, _spec); err != nil {
 		if sqlgraph.IsConstraintError(err) {
@@ -385,19 +346,15 @@ func (pc *PlayerCreate) sqlSave(ctx context.Context) (*Player, error) {
 		id := _spec.ID.Value.(int64)
 		_node.ID = uint64(id)
 	}
+	pc.mutation.id = &_node.ID
+	pc.mutation.done = true
 	return _node, nil
 }
 
 func (pc *PlayerCreate) createSpec() (*Player, *sqlgraph.CreateSpec) {
 	var (
 		_node = &Player{config: pc.config}
-		_spec = &sqlgraph.CreateSpec{
+		_spec = sqlgraph.NewCreateSpec(player.Table, sqlgraph.NewFieldSpec(player.FieldID, field.TypeUint64))
-			Table: player.Table,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeUint64,
-				Column: player.FieldID,
-			},
-		}
 	)
 	if id, ok := pc.mutation.ID(); ok {
 		_node.ID = id

ent/player_delete.go

@@ -4,7 +4,6 @@ package ent
 
 import (
 	"context"
-	"fmt"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -28,34 +27,7 @@ func (pd *PlayerDelete) Where(ps ...predicate.Player) *PlayerDelete {
 
 // Exec executes the deletion query and returns how many vertices were deleted.
 func (pd *PlayerDelete) Exec(ctx context.Context) (int, error) {
-	var (
+	return withHooks[int, PlayerMutation](ctx, pd.sqlExec, pd.mutation, pd.hooks)
-		err      error
-		affected int
-	)
-	if len(pd.hooks) == 0 {
-		affected, err = pd.sqlExec(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*PlayerMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			pd.mutation = mutation
-			affected, err = pd.sqlExec(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(pd.hooks) - 1; i >= 0; i-- {
-			if pd.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = pd.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, pd.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
 }
 
 // ExecX is like Exec, but panics if an error occurs.
@@ -68,15 +40,7 @@ func (pd *PlayerDelete) ExecX(ctx context.Context) int {
 }
 
 func (pd *PlayerDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := &sqlgraph.DeleteSpec{
+	_spec := sqlgraph.NewDeleteSpec(player.Table, sqlgraph.NewFieldSpec(player.FieldID, field.TypeUint64))
-		Node: &sqlgraph.NodeSpec{
-			Table: player.Table,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeUint64,
-				Column: player.FieldID,
-			},
-		},
-	}
 	if ps := pd.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -88,6 +52,7 @@ func (pd *PlayerDelete) sqlExec(ctx context.Context) (int, error) {
 	if err != nil && sqlgraph.IsConstraintError(err) {
 		err = &ConstraintError{msg: err.Error(), wrap: err}
 	}
+	pd.mutation.done = true
 	return affected, err
 }
 
@@ -96,6 +61,12 @@ type PlayerDeleteOne struct {
 	pd *PlayerDelete
 }
 
+// Where appends a list predicates to the PlayerDelete builder.
+func (pdo *PlayerDeleteOne) Where(ps ...predicate.Player) *PlayerDeleteOne {
+	pdo.pd.mutation.Where(ps...)
+	return pdo
+}
+
 // Exec executes the deletion query.
 func (pdo *PlayerDeleteOne) Exec(ctx context.Context) error {
 	n, err := pdo.pd.Exec(ctx)
@@ -111,5 +82,7 @@ func (pdo *PlayerDeleteOne) Exec(ctx context.Context) error {
 
 // ExecX is like Exec, but panics if an error occurs.
 func (pdo *PlayerDeleteOne) ExecX(ctx context.Context) {
-	pdo.pd.ExecX(ctx)
+	if err := pdo.Exec(ctx); err != nil {
+		panic(err)
+	}
 }

ent/player_query.go

@@ -20,11 +20,9 @@ import (
 // PlayerQuery is the builder for querying Player entities.
 type PlayerQuery struct {
 	config
-	limit       *int
+	ctx         *QueryContext
-	offset      *int
-	unique      *bool
 	order       []OrderFunc
-	fields      []string
+	inters      []Interceptor
 	predicates  []predicate.Player
 	withStats   *MatchPlayerQuery
 	withMatches *MatchQuery
@@ -40,26 +38,26 @@ func (pq *PlayerQuery) Where(ps ...predicate.Player) *PlayerQuery {
 	return pq
 }
 
-// Limit adds a limit step to the query.
+// Limit the number of records to be returned by this query.
 func (pq *PlayerQuery) Limit(limit int) *PlayerQuery {
-	pq.limit = &limit
+	pq.ctx.Limit = &limit
 	return pq
 }
 
-// Offset adds an offset step to the query.
+// Offset to start from.
 func (pq *PlayerQuery) Offset(offset int) *PlayerQuery {
-	pq.offset = &offset
+	pq.ctx.Offset = &offset
 	return pq
 }
 
 // Unique configures the query builder to filter duplicate records on query.
 // By default, unique is set to true, and can be disabled using this method.
 func (pq *PlayerQuery) Unique(unique bool) *PlayerQuery {
-	pq.unique = &unique
+	pq.ctx.Unique = &unique
 	return pq
 }
 
-// Order adds an order step to the query.
+// Order specifies how the records should be ordered.
 func (pq *PlayerQuery) Order(o ...OrderFunc) *PlayerQuery {
 	pq.order = append(pq.order, o...)
 	return pq
@@ -67,7 +65,7 @@ func (pq *PlayerQuery) Order(o ...OrderFunc) *PlayerQuery {
 
 // QueryStats chains the current query on the "stats" edge.
 func (pq *PlayerQuery) QueryStats() *MatchPlayerQuery {
-	query := &MatchPlayerQuery{config: pq.config}
+	query := (&MatchPlayerClient{config: pq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := pq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -89,7 +87,7 @@ func (pq *PlayerQuery) QueryStats() *MatchPlayerQuery {
 
 // QueryMatches chains the current query on the "matches" edge.
 func (pq *PlayerQuery) QueryMatches() *MatchQuery {
-	query := &MatchQuery{config: pq.config}
+	query := (&MatchClient{config: pq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := pq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -112,7 +110,7 @@ func (pq *PlayerQuery) QueryMatches() *MatchQuery {
 // First returns the first Player entity from the query.
 // Returns a *NotFoundError when no Player was found.
 func (pq *PlayerQuery) First(ctx context.Context) (*Player, error) {
-	nodes, err := pq.Limit(1).All(ctx)
+	nodes, err := pq.Limit(1).All(setContextOp(ctx, pq.ctx, "First"))
 	if err != nil {
 		return nil, err
 	}
@@ -135,7 +133,7 @@ func (pq *PlayerQuery) FirstX(ctx context.Context) *Player {
 // Returns a *NotFoundError when no Player ID was found.
 func (pq *PlayerQuery) FirstID(ctx context.Context) (id uint64, err error) {
 	var ids []uint64
-	if ids, err = pq.Limit(1).IDs(ctx); err != nil {
+	if ids, err = pq.Limit(1).IDs(setContextOp(ctx, pq.ctx, "FirstID")); err != nil {
 		return
 	}
 	if len(ids) == 0 {
@@ -158,7 +156,7 @@ func (pq *PlayerQuery) FirstIDX(ctx context.Context) uint64 {
 // Returns a *NotSingularError when more than one Player entity is found.
 // Returns a *NotFoundError when no Player entities are found.
 func (pq *PlayerQuery) Only(ctx context.Context) (*Player, error) {
-	nodes, err := pq.Limit(2).All(ctx)
+	nodes, err := pq.Limit(2).All(setContextOp(ctx, pq.ctx, "Only"))
 	if err != nil {
 		return nil, err
 	}
@@ -186,7 +184,7 @@ func (pq *PlayerQuery) OnlyX(ctx context.Context) *Player {
 // Returns a *NotFoundError when no entities are found.
 func (pq *PlayerQuery) OnlyID(ctx context.Context) (id uint64, err error) {
 	var ids []uint64
-	if ids, err = pq.Limit(2).IDs(ctx); err != nil {
+	if ids, err = pq.Limit(2).IDs(setContextOp(ctx, pq.ctx, "OnlyID")); err != nil {
 		return
 	}
 	switch len(ids) {
@@ -211,10 +209,12 @@ func (pq *PlayerQuery) OnlyIDX(ctx context.Context) uint64 {
 
 // All executes the query and returns a list of Players.
 func (pq *PlayerQuery) All(ctx context.Context) ([]*Player, error) {
+	ctx = setContextOp(ctx, pq.ctx, "All")
 	if err := pq.prepareQuery(ctx); err != nil {
 		return nil, err
 	}
-	return pq.sqlAll(ctx)
+	qr := querierAll[[]*Player, *PlayerQuery]()
+	return withInterceptors[[]*Player](ctx, pq, qr, pq.inters)
 }
 
 // AllX is like All, but panics if an error occurs.
@@ -227,9 +227,12 @@ func (pq *PlayerQuery) AllX(ctx context.Context) []*Player {
 }
 
 // IDs executes the query and returns a list of Player IDs.
-func (pq *PlayerQuery) IDs(ctx context.Context) ([]uint64, error) {
+func (pq *PlayerQuery) IDs(ctx context.Context) (ids []uint64, err error) {
-	var ids []uint64
+	if pq.ctx.Unique == nil && pq.path != nil {
-	if err := pq.Select(player.FieldID).Scan(ctx, &ids); err != nil {
+		pq.Unique(true)
+	}
+	ctx = setContextOp(ctx, pq.ctx, "IDs")
+	if err = pq.Select(player.FieldID).Scan(ctx, &ids); err != nil {
 		return nil, err
 	}
 	return ids, nil
@@ -246,10 +249,11 @@ func (pq *PlayerQuery) IDsX(ctx context.Context) []uint64 {
 
 // Count returns the count of the given query.
 func (pq *PlayerQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, pq.ctx, "Count")
 	if err := pq.prepareQuery(ctx); err != nil {
 		return 0, err
 	}
-	return pq.sqlCount(ctx)
+	return withInterceptors[int](ctx, pq, querierCount[*PlayerQuery](), pq.inters)
 }
 
 // CountX is like Count, but panics if an error occurs.
@@ -263,10 +267,15 @@ func (pq *PlayerQuery) CountX(ctx context.Context) int {
 
 // Exist returns true if the query has elements in the graph.
 func (pq *PlayerQuery) Exist(ctx context.Context) (bool, error) {
-	if err := pq.prepareQuery(ctx); err != nil {
+	ctx = setContextOp(ctx, pq.ctx, "Exist")
-		return false, err
+	switch _, err := pq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("ent: check existence: %w", err)
+	default:
+		return true, nil
 	}
-	return pq.sqlExist(ctx)
 }
 
 // ExistX is like Exist, but panics if an error occurs.
@@ -286,23 +295,22 @@ func (pq *PlayerQuery) Clone() *PlayerQuery {
 	}
 	return &PlayerQuery{
 		config:      pq.config,
-		limit:       pq.limit,
+		ctx:         pq.ctx.Clone(),
-		offset:      pq.offset,
 		order:       append([]OrderFunc{}, pq.order...),
+		inters:      append([]Interceptor{}, pq.inters...),
 		predicates:  append([]predicate.Player{}, pq.predicates...),
 		withStats:   pq.withStats.Clone(),
 		withMatches: pq.withMatches.Clone(),
 		// clone intermediate query.
-		sql:    pq.sql.Clone(),
+		sql:  pq.sql.Clone(),
-		path:   pq.path,
+		path: pq.path,
-		unique: pq.unique,
 	}
 }
 
 // WithStats tells the query-builder to eager-load the nodes that are connected to
 // the "stats" edge. The optional arguments are used to configure the query builder of the edge.
 func (pq *PlayerQuery) WithStats(opts ...func(*MatchPlayerQuery)) *PlayerQuery {
-	query := &MatchPlayerQuery{config: pq.config}
+	query := (&MatchPlayerClient{config: pq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -313,7 +321,7 @@ func (pq *PlayerQuery) WithStats(opts ...func(*MatchPlayerQuery)) *PlayerQuery {
 // WithMatches tells the query-builder to eager-load the nodes that are connected to
 // the "matches" edge. The optional arguments are used to configure the query builder of the edge.
 func (pq *PlayerQuery) WithMatches(opts ...func(*MatchQuery)) *PlayerQuery {
-	query := &MatchQuery{config: pq.config}
+	query := (&MatchClient{config: pq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -336,16 +344,11 @@ func (pq *PlayerQuery) WithMatches(opts ...func(*MatchQuery)) *PlayerQuery {
 //		Aggregate(ent.Count()).
 //		Scan(ctx, &v)
 func (pq *PlayerQuery) GroupBy(field string, fields ...string) *PlayerGroupBy {
-	grbuild := &PlayerGroupBy{config: pq.config}
+	pq.ctx.Fields = append([]string{field}, fields...)
-	grbuild.fields = append([]string{field}, fields...)
+	grbuild := &PlayerGroupBy{build: pq}
-	grbuild.path = func(ctx context.Context) (prev *sql.Selector, err error) {
+	grbuild.flds = &pq.ctx.Fields
-		if err := pq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		return pq.sqlQuery(ctx), nil
-	}
 	grbuild.label = player.Label
-	grbuild.flds, grbuild.scan = &grbuild.fields, grbuild.Scan
+	grbuild.scan = grbuild.Scan
 	return grbuild
 }
 
@@ -362,11 +365,11 @@ func (pq *PlayerQuery) GroupBy(field string, fields ...string) *PlayerGroupBy {
 //		Select(player.FieldName).
 //		Scan(ctx, &v)
 func (pq *PlayerQuery) Select(fields ...string) *PlayerSelect {
-	pq.fields = append(pq.fields, fields...)
+	pq.ctx.Fields = append(pq.ctx.Fields, fields...)
-	selbuild := &PlayerSelect{PlayerQuery: pq}
+	sbuild := &PlayerSelect{PlayerQuery: pq}
-	selbuild.label = player.Label
+	sbuild.label = player.Label
-	selbuild.flds, selbuild.scan = &pq.fields, selbuild.Scan
+	sbuild.flds, sbuild.scan = &pq.ctx.Fields, sbuild.Scan
-	return selbuild
+	return sbuild
 }
 
 // Aggregate returns a PlayerSelect configured with the given aggregations.
@@ -375,7 +378,17 @@ func (pq *PlayerQuery) Aggregate(fns ...AggregateFunc) *PlayerSelect {
 }
 
 func (pq *PlayerQuery) prepareQuery(ctx context.Context) error {
-	for _, f := range pq.fields {
+	for _, inter := range pq.inters {
+		if inter == nil {
+			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, pq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range pq.ctx.Fields {
 		if !player.ValidColumn(f) {
 			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
 		}
@@ -487,27 +500,30 @@ func (pq *PlayerQuery) loadMatches(ctx context.Context, query *MatchQuery, nodes
 	if err := query.prepareQuery(ctx); err != nil {
 		return err
 	}
-	neighbors, err := query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
+	qr := QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
-		assign := spec.Assign
+		return query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
-		values := spec.ScanValues
+			assign := spec.Assign
-		spec.ScanValues = func(columns []string) ([]any, error) {
+			values := spec.ScanValues
-			values, err := values(columns[1:])
+			spec.ScanValues = func(columns []string) ([]any, error) {
-			if err != nil {
+				values, err := values(columns[1:])
-				return nil, err
+				if err != nil {
+					return nil, err
+				}
+				return append([]any{new(sql.NullInt64)}, values...), nil
 			}
-			return append([]any{new(sql.NullInt64)}, values...), nil
+			spec.Assign = func(columns []string, values []any) error {
-		}
+				outValue := uint64(values[0].(*sql.NullInt64).Int64)
-		spec.Assign = func(columns []string, values []any) error {
+				inValue := uint64(values[1].(*sql.NullInt64).Int64)
-			outValue := uint64(values[0].(*sql.NullInt64).Int64)
+				if nids[inValue] == nil {
-			inValue := uint64(values[1].(*sql.NullInt64).Int64)
+					nids[inValue] = map[*Player]struct{}{byID[outValue]: {}}
-			if nids[inValue] == nil {
+					return assign(columns[1:], values[1:])
-				nids[inValue] = map[*Player]struct{}{byID[outValue]: {}}
+				}
-				return assign(columns[1:], values[1:])
+				nids[inValue][byID[outValue]] = struct{}{}
+				return nil
 			}
-			nids[inValue][byID[outValue]] = struct{}{}
+		})
-			return nil
-		}
 	})
+	neighbors, err := withInterceptors[[]*Match](ctx, query, qr, query.inters)
 	if err != nil {
 		return err
 	}
@@ -528,41 +544,22 @@ func (pq *PlayerQuery) sqlCount(ctx context.Context) (int, error) {
 	if len(pq.modifiers) > 0 {
 		_spec.Modifiers = pq.modifiers
 	}
-	_spec.Node.Columns = pq.fields
+	_spec.Node.Columns = pq.ctx.Fields
-	if len(pq.fields) > 0 {
+	if len(pq.ctx.Fields) > 0 {
-		_spec.Unique = pq.unique != nil && *pq.unique
+		_spec.Unique = pq.ctx.Unique != nil && *pq.ctx.Unique
 	}
 	return sqlgraph.CountNodes(ctx, pq.driver, _spec)
 }
 
-func (pq *PlayerQuery) sqlExist(ctx context.Context) (bool, error) {
-	switch _, err := pq.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
 func (pq *PlayerQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := &sqlgraph.QuerySpec{
+	_spec := sqlgraph.NewQuerySpec(player.Table, player.Columns, sqlgraph.NewFieldSpec(player.FieldID, field.TypeUint64))
-		Node: &sqlgraph.NodeSpec{
+	_spec.From = pq.sql
-			Table:   player.Table,
+	if unique := pq.ctx.Unique; unique != nil {
-			Columns: player.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeUint64,
-				Column: player.FieldID,
-			},
-		},
-		From:   pq.sql,
-		Unique: true,
-	}
-	if unique := pq.unique; unique != nil {
 		_spec.Unique = *unique
+	} else if pq.path != nil {
+		_spec.Unique = true
 	}
-	if fields := pq.fields; len(fields) > 0 {
+	if fields := pq.ctx.Fields; len(fields) > 0 {
 		_spec.Node.Columns = make([]string, 0, len(fields))
 		_spec.Node.Columns = append(_spec.Node.Columns, player.FieldID)
 		for i := range fields {
@@ -578,10 +575,10 @@ func (pq *PlayerQuery) querySpec() *sqlgraph.QuerySpec {
 			}
 		}
 	}
-	if limit := pq.limit; limit != nil {
+	if limit := pq.ctx.Limit; limit != nil {
 		_spec.Limit = *limit
 	}
-	if offset := pq.offset; offset != nil {
+	if offset := pq.ctx.Offset; offset != nil {
 		_spec.Offset = *offset
 	}
 	if ps := pq.order; len(ps) > 0 {
@@ -597,7 +594,7 @@ func (pq *PlayerQuery) querySpec() *sqlgraph.QuerySpec {
 func (pq *PlayerQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	builder := sql.Dialect(pq.driver.Dialect())
 	t1 := builder.Table(player.Table)
-	columns := pq.fields
+	columns := pq.ctx.Fields
 	if len(columns) == 0 {
 		columns = player.Columns
 	}
@@ -606,7 +603,7 @@ func (pq *PlayerQuery) sqlQuery(ctx context.Context) *sql.Selector {
 		selector = pq.sql
 		selector.Select(selector.Columns(columns...)...)
 	}
-	if pq.unique != nil && *pq.unique {
+	if pq.ctx.Unique != nil && *pq.ctx.Unique {
 		selector.Distinct()
 	}
 	for _, m := range pq.modifiers {
@@ -618,12 +615,12 @@ func (pq *PlayerQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	for _, p := range pq.order {
 		p(selector)
 	}
-	if offset := pq.offset; offset != nil {
+	if offset := pq.ctx.Offset; offset != nil {
 		// limit is mandatory for offset clause. We start
 		// with default value, and override it below if needed.
 		selector.Offset(*offset).Limit(math.MaxInt32)
 	}
-	if limit := pq.limit; limit != nil {
+	if limit := pq.ctx.Limit; limit != nil {
 		selector.Limit(*limit)
 	}
 	return selector
@@ -637,13 +634,8 @@ func (pq *PlayerQuery) Modify(modifiers ...func(s *sql.Selector)) *PlayerSelect
 
 // PlayerGroupBy is the group-by builder for Player entities.
 type PlayerGroupBy struct {
-	config
 	selector
-	fields []string
+	build *PlayerQuery
-	fns    []AggregateFunc
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
 }
 
 // Aggregate adds the given aggregation functions to the group-by query.
@@ -652,58 +644,46 @@ func (pgb *PlayerGroupBy) Aggregate(fns ...AggregateFunc) *PlayerGroupBy {
 	return pgb
 }
 
-// Scan applies the group-by query and scans the result into the given value.
+// Scan applies the selector query and scans the result into the given value.
 func (pgb *PlayerGroupBy) Scan(ctx context.Context, v any) error {
-	query, err := pgb.path(ctx)
+	ctx = setContextOp(ctx, pgb.build.ctx, "GroupBy")
-	if err != nil {
+	if err := pgb.build.prepareQuery(ctx); err != nil {
 		return err
 	}
-	pgb.sql = query
+	return scanWithInterceptors[*PlayerQuery, *PlayerGroupBy](ctx, pgb.build, pgb, pgb.build.inters, v)
-	return pgb.sqlScan(ctx, v)
 }
 
-func (pgb *PlayerGroupBy) sqlScan(ctx context.Context, v any) error {
+func (pgb *PlayerGroupBy) sqlScan(ctx context.Context, root *PlayerQuery, v any) error {
-	for _, f := range pgb.fields {
+	selector := root.sqlQuery(ctx).Select()
-		if !player.ValidColumn(f) {
+	aggregation := make([]string, 0, len(pgb.fns))
-			return &ValidationError{Name: f, err: fmt.Errorf("invalid field %q for group-by", f)}
+	for _, fn := range pgb.fns {
-		}
+		aggregation = append(aggregation, fn(selector))
 	}
-	selector := pgb.sqlQuery()
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*pgb.flds)+len(pgb.fns))
+		for _, f := range *pgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*pgb.flds...)...)
 	if err := selector.Err(); err != nil {
 		return err
 	}
 	rows := &sql.Rows{}
 	query, args := selector.Query()
-	if err := pgb.driver.Query(ctx, query, args, rows); err != nil {
+	if err := pgb.build.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
 
-func (pgb *PlayerGroupBy) sqlQuery() *sql.Selector {
-	selector := pgb.sql.Select()
-	aggregation := make([]string, 0, len(pgb.fns))
-	for _, fn := range pgb.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(pgb.fields)+len(pgb.fns))
-		for _, f := range pgb.fields {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	return selector.GroupBy(selector.Columns(pgb.fields...)...)
-}
-
 // PlayerSelect is the builder for selecting fields of Player entities.
 type PlayerSelect struct {
 	*PlayerQuery
 	selector
-	// intermediate query (i.e. traversal path).
-	sql *sql.Selector
 }
 
 // Aggregate adds the given aggregation functions to the selector query.
@@ -714,26 +694,27 @@ func (ps *PlayerSelect) Aggregate(fns ...AggregateFunc) *PlayerSelect {
 
 // Scan applies the selector query and scans the result into the given value.
 func (ps *PlayerSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ps.ctx, "Select")
 	if err := ps.prepareQuery(ctx); err != nil {
 		return err
 	}
-	ps.sql = ps.PlayerQuery.sqlQuery(ctx)
+	return scanWithInterceptors[*PlayerQuery, *PlayerSelect](ctx, ps.PlayerQuery, ps, ps.inters, v)
-	return ps.sqlScan(ctx, v)
 }
 
-func (ps *PlayerSelect) sqlScan(ctx context.Context, v any) error {
+func (ps *PlayerSelect) sqlScan(ctx context.Context, root *PlayerQuery, v any) error {
+	selector := root.sqlQuery(ctx)
 	aggregation := make([]string, 0, len(ps.fns))
 	for _, fn := range ps.fns {
-		aggregation = append(aggregation, fn(ps.sql))
+		aggregation = append(aggregation, fn(selector))
 	}
 	switch n := len(*ps.selector.flds); {
 	case n == 0 && len(aggregation) > 0:
-		ps.sql.Select(aggregation...)
+		selector.Select(aggregation...)
 	case n != 0 && len(aggregation) > 0:
-		ps.sql.AppendSelect(aggregation...)
+		selector.AppendSelect(aggregation...)
 	}
 	rows := &sql.Rows{}
-	query, args := ps.sql.Query()
+	query, args := selector.Query()
 	if err := ps.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}

ent/player_update.go

@@ -459,34 +459,7 @@ func (pu *PlayerUpdate) RemoveMatches(m ...*Match) *PlayerUpdate {
 
 // Save executes the query and returns the number of nodes affected by the update operation.
 func (pu *PlayerUpdate) Save(ctx context.Context) (int, error) {
-	var (
+	return withHooks[int, PlayerMutation](ctx, pu.sqlSave, pu.mutation, pu.hooks)
-		err      error
-		affected int
-	)
-	if len(pu.hooks) == 0 {
-		affected, err = pu.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*PlayerMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			pu.mutation = mutation
-			affected, err = pu.sqlSave(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(pu.hooks) - 1; i >= 0; i-- {
-			if pu.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = pu.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, pu.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -518,16 +491,7 @@ func (pu *PlayerUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *PlayerU
 }
 
 func (pu *PlayerUpdate) sqlSave(ctx context.Context) (n int, err error) {
-	_spec := &sqlgraph.UpdateSpec{
+	_spec := sqlgraph.NewUpdateSpec(player.Table, player.Columns, sqlgraph.NewFieldSpec(player.FieldID, field.TypeUint64))
-		Node: &sqlgraph.NodeSpec{
-			Table:   player.Table,
-			Columns: player.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeUint64,
-				Column: player.FieldID,
-			},
-		},
-	}
 	if ps := pu.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -760,6 +724,7 @@ func (pu *PlayerUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		return 0, err
 	}
+	pu.mutation.done = true
 	return n, nil
 }
 
@@ -1198,6 +1163,12 @@ func (puo *PlayerUpdateOne) RemoveMatches(m ...*Match) *PlayerUpdateOne {
 	return puo.RemoveMatchIDs(ids...)
 }
 
+// Where appends a list predicates to the PlayerUpdate builder.
+func (puo *PlayerUpdateOne) Where(ps ...predicate.Player) *PlayerUpdateOne {
+	puo.mutation.Where(ps...)
+	return puo
+}
+
 // Select allows selecting one or more fields (columns) of the returned entity.
 // The default is selecting all fields defined in the entity schema.
 func (puo *PlayerUpdateOne) Select(field string, fields ...string) *PlayerUpdateOne {
@@ -1207,40 +1178,7 @@ func (puo *PlayerUpdateOne) Select(field string, fields ...string) *PlayerUpdate
 
 // Save executes the query and returns the updated Player entity.
 func (puo *PlayerUpdateOne) Save(ctx context.Context) (*Player, error) {
-	var (
+	return withHooks[*Player, PlayerMutation](ctx, puo.sqlSave, puo.mutation, puo.hooks)
-		err  error
-		node *Player
-	)
-	if len(puo.hooks) == 0 {
-		node, err = puo.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*PlayerMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			puo.mutation = mutation
-			node, err = puo.sqlSave(ctx)
-			mutation.done = true
-			return node, err
-		})
-		for i := len(puo.hooks) - 1; i >= 0; i-- {
-			if puo.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = puo.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, puo.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*Player)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from PlayerMutation", v)
-		}
-		node = nv
-	}
-	return node, err
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -1272,16 +1210,7 @@ func (puo *PlayerUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *Pla
 }
 
 func (puo *PlayerUpdateOne) sqlSave(ctx context.Context) (_node *Player, err error) {
-	_spec := &sqlgraph.UpdateSpec{
+	_spec := sqlgraph.NewUpdateSpec(player.Table, player.Columns, sqlgraph.NewFieldSpec(player.FieldID, field.TypeUint64))
-		Node: &sqlgraph.NodeSpec{
-			Table:   player.Table,
-			Columns: player.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeUint64,
-				Column: player.FieldID,
-			},
-		},
-	}
 	id, ok := puo.mutation.ID()
 	if !ok {
 		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Player.id" for update`)}
@@ -1534,5 +1463,6 @@ func (puo *PlayerUpdateOne) sqlSave(ctx context.Context) (_node *Player, err err
 		}
 		return nil, err
 	}
+	puo.mutation.done = true
 	return _node, nil
 }

ent/roundstats.go

@@ -120,14 +120,14 @@ func (rs *RoundStats) assignValues(columns []string, values []any) error {
 
 // QueryMatchPlayer queries the "match_player" edge of the RoundStats entity.
 func (rs *RoundStats) QueryMatchPlayer() *MatchPlayerQuery {
-	return (&RoundStatsClient{config: rs.config}).QueryMatchPlayer(rs)
+	return NewRoundStatsClient(rs.config).QueryMatchPlayer(rs)
 }
 
 // Update returns a builder for updating this RoundStats.
 // Note that you need to call RoundStats.Unwrap() before calling this method if this RoundStats
 // was returned from a transaction, and the transaction was committed or rolled back.
 func (rs *RoundStats) Update() *RoundStatsUpdateOne {
-	return (&RoundStatsClient{config: rs.config}).UpdateOne(rs)
+	return NewRoundStatsClient(rs.config).UpdateOne(rs)
 }
 
 // Unwrap unwraps the RoundStats entity that was returned from a transaction after it was closed,
@@ -163,9 +163,3 @@ func (rs *RoundStats) String() string {
 
 // RoundStatsSlice is a parsable slice of RoundStats.
 type RoundStatsSlice []*RoundStats
-
-func (rs RoundStatsSlice) config(cfg config) {
-	for _i := range rs {
-		rs[_i].config = cfg
-	}
-}

ent/roundstats/where.go

@@ -10,357 +10,227 @@ import (
 
 // ID filters vertices based on their ID field.
 func ID(id int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldEQ(FieldID, id))
-		s.Where(sql.EQ(s.C(FieldID), id))
-	})
 }
 
 // IDEQ applies the EQ predicate on the ID field.
 func IDEQ(id int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldEQ(FieldID, id))
-		s.Where(sql.EQ(s.C(FieldID), id))
-	})
 }
 
 // IDNEQ applies the NEQ predicate on the ID field.
 func IDNEQ(id int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldNEQ(FieldID, id))
-		s.Where(sql.NEQ(s.C(FieldID), id))
-	})
 }
 
 // IDIn applies the In predicate on the ID field.
 func IDIn(ids ...int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldIn(FieldID, ids...))
-		v := make([]any, len(ids))
-		for i := range v {
-			v[i] = ids[i]
-		}
-		s.Where(sql.In(s.C(FieldID), v...))
-	})
 }
 
 // IDNotIn applies the NotIn predicate on the ID field.
 func IDNotIn(ids ...int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldNotIn(FieldID, ids...))
-		v := make([]any, len(ids))
-		for i := range v {
-			v[i] = ids[i]
-		}
-		s.Where(sql.NotIn(s.C(FieldID), v...))
-	})
 }
 
 // IDGT applies the GT predicate on the ID field.
 func IDGT(id int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldGT(FieldID, id))
-		s.Where(sql.GT(s.C(FieldID), id))
-	})
 }
 
 // IDGTE applies the GTE predicate on the ID field.
 func IDGTE(id int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldGTE(FieldID, id))
-		s.Where(sql.GTE(s.C(FieldID), id))
-	})
 }
 
 // IDLT applies the LT predicate on the ID field.
 func IDLT(id int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldLT(FieldID, id))
-		s.Where(sql.LT(s.C(FieldID), id))
-	})
 }
 
 // IDLTE applies the LTE predicate on the ID field.
 func IDLTE(id int) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldLTE(FieldID, id))
-		s.Where(sql.LTE(s.C(FieldID), id))
-	})
 }
 
 // Round applies equality check predicate on the "round" field. It's identical to RoundEQ.
 func Round(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldEQ(FieldRound, v))
-		s.Where(sql.EQ(s.C(FieldRound), v))
-	})
 }
 
 // Bank applies equality check predicate on the "bank" field. It's identical to BankEQ.
 func Bank(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldEQ(FieldBank, v))
-		s.Where(sql.EQ(s.C(FieldBank), v))
-	})
 }
 
 // Equipment applies equality check predicate on the "equipment" field. It's identical to EquipmentEQ.
 func Equipment(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldEQ(FieldEquipment, v))
-		s.Where(sql.EQ(s.C(FieldEquipment), v))
-	})
 }
 
 // Spent applies equality check predicate on the "spent" field. It's identical to SpentEQ.
 func Spent(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldEQ(FieldSpent, v))
-		s.Where(sql.EQ(s.C(FieldSpent), v))
-	})
 }
 
 // RoundEQ applies the EQ predicate on the "round" field.
 func RoundEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldEQ(FieldRound, v))
-		s.Where(sql.EQ(s.C(FieldRound), v))
-	})
 }
 
 // RoundNEQ applies the NEQ predicate on the "round" field.
 func RoundNEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldNEQ(FieldRound, v))
-		s.Where(sql.NEQ(s.C(FieldRound), v))
-	})
 }
 
 // RoundIn applies the In predicate on the "round" field.
 func RoundIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
+	return predicate.RoundStats(sql.FieldIn(FieldRound, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldRound), v...))
-	})
 }
 
 // RoundNotIn applies the NotIn predicate on the "round" field.
 func RoundNotIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
+	return predicate.RoundStats(sql.FieldNotIn(FieldRound, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldRound), v...))
-	})
 }
 
 // RoundGT applies the GT predicate on the "round" field.
 func RoundGT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldGT(FieldRound, v))
-		s.Where(sql.GT(s.C(FieldRound), v))
-	})
 }
 
 // RoundGTE applies the GTE predicate on the "round" field.
 func RoundGTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldGTE(FieldRound, v))
-		s.Where(sql.GTE(s.C(FieldRound), v))
-	})
 }
 
 // RoundLT applies the LT predicate on the "round" field.
 func RoundLT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldLT(FieldRound, v))
-		s.Where(sql.LT(s.C(FieldRound), v))
-	})
 }
 
 // RoundLTE applies the LTE predicate on the "round" field.
 func RoundLTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldLTE(FieldRound, v))
-		s.Where(sql.LTE(s.C(FieldRound), v))
-	})
 }
 
 // BankEQ applies the EQ predicate on the "bank" field.
 func BankEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldEQ(FieldBank, v))
-		s.Where(sql.EQ(s.C(FieldBank), v))
-	})
 }
 
 // BankNEQ applies the NEQ predicate on the "bank" field.
 func BankNEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldNEQ(FieldBank, v))
-		s.Where(sql.NEQ(s.C(FieldBank), v))
-	})
 }
 
 // BankIn applies the In predicate on the "bank" field.
 func BankIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
+	return predicate.RoundStats(sql.FieldIn(FieldBank, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldBank), v...))
-	})
 }
 
 // BankNotIn applies the NotIn predicate on the "bank" field.
 func BankNotIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
+	return predicate.RoundStats(sql.FieldNotIn(FieldBank, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldBank), v...))
-	})
 }
 
 // BankGT applies the GT predicate on the "bank" field.
 func BankGT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldGT(FieldBank, v))
-		s.Where(sql.GT(s.C(FieldBank), v))
-	})
 }
 
 // BankGTE applies the GTE predicate on the "bank" field.
 func BankGTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldGTE(FieldBank, v))
-		s.Where(sql.GTE(s.C(FieldBank), v))
-	})
 }
 
 // BankLT applies the LT predicate on the "bank" field.
 func BankLT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldLT(FieldBank, v))
-		s.Where(sql.LT(s.C(FieldBank), v))
-	})
 }
 
 // BankLTE applies the LTE predicate on the "bank" field.
 func BankLTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldLTE(FieldBank, v))
-		s.Where(sql.LTE(s.C(FieldBank), v))
-	})
 }
 
 // EquipmentEQ applies the EQ predicate on the "equipment" field.
 func EquipmentEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldEQ(FieldEquipment, v))
-		s.Where(sql.EQ(s.C(FieldEquipment), v))
-	})
 }
 
 // EquipmentNEQ applies the NEQ predicate on the "equipment" field.
 func EquipmentNEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldNEQ(FieldEquipment, v))
-		s.Where(sql.NEQ(s.C(FieldEquipment), v))
-	})
 }
 
 // EquipmentIn applies the In predicate on the "equipment" field.
 func EquipmentIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
+	return predicate.RoundStats(sql.FieldIn(FieldEquipment, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldEquipment), v...))
-	})
 }
 
 // EquipmentNotIn applies the NotIn predicate on the "equipment" field.
 func EquipmentNotIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
+	return predicate.RoundStats(sql.FieldNotIn(FieldEquipment, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldEquipment), v...))
-	})
 }
 
 // EquipmentGT applies the GT predicate on the "equipment" field.
 func EquipmentGT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldGT(FieldEquipment, v))
-		s.Where(sql.GT(s.C(FieldEquipment), v))
-	})
 }
 
 // EquipmentGTE applies the GTE predicate on the "equipment" field.
 func EquipmentGTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldGTE(FieldEquipment, v))
-		s.Where(sql.GTE(s.C(FieldEquipment), v))
-	})
 }
 
 // EquipmentLT applies the LT predicate on the "equipment" field.
 func EquipmentLT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldLT(FieldEquipment, v))
-		s.Where(sql.LT(s.C(FieldEquipment), v))
-	})
 }
 
 // EquipmentLTE applies the LTE predicate on the "equipment" field.
 func EquipmentLTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldLTE(FieldEquipment, v))
-		s.Where(sql.LTE(s.C(FieldEquipment), v))
-	})
 }
 
 // SpentEQ applies the EQ predicate on the "spent" field.
 func SpentEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldEQ(FieldSpent, v))
-		s.Where(sql.EQ(s.C(FieldSpent), v))
-	})
 }
 
 // SpentNEQ applies the NEQ predicate on the "spent" field.
 func SpentNEQ(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldNEQ(FieldSpent, v))
-		s.Where(sql.NEQ(s.C(FieldSpent), v))
-	})
 }
 
 // SpentIn applies the In predicate on the "spent" field.
 func SpentIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
+	return predicate.RoundStats(sql.FieldIn(FieldSpent, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldSpent), v...))
-	})
 }
 
 // SpentNotIn applies the NotIn predicate on the "spent" field.
 func SpentNotIn(vs ...uint) predicate.RoundStats {
-	v := make([]any, len(vs))
+	return predicate.RoundStats(sql.FieldNotIn(FieldSpent, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.RoundStats(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldSpent), v...))
-	})
 }
 
 // SpentGT applies the GT predicate on the "spent" field.
 func SpentGT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldGT(FieldSpent, v))
-		s.Where(sql.GT(s.C(FieldSpent), v))
-	})
 }
 
 // SpentGTE applies the GTE predicate on the "spent" field.
 func SpentGTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldGTE(FieldSpent, v))
-		s.Where(sql.GTE(s.C(FieldSpent), v))
-	})
 }
 
 // SpentLT applies the LT predicate on the "spent" field.
 func SpentLT(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldLT(FieldSpent, v))
-		s.Where(sql.LT(s.C(FieldSpent), v))
-	})
 }
 
 // SpentLTE applies the LTE predicate on the "spent" field.
 func SpentLTE(v uint) predicate.RoundStats {
-	return predicate.RoundStats(func(s *sql.Selector) {
+	return predicate.RoundStats(sql.FieldLTE(FieldSpent, v))
-		s.Where(sql.LTE(s.C(FieldSpent), v))
-	})
 }
 
 // HasMatchPlayer applies the HasEdge predicate on the "match_player" edge.
@@ -368,7 +238,6 @@ func HasMatchPlayer() predicate.RoundStats {
 	return predicate.RoundStats(func(s *sql.Selector) {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(Table, FieldID),
-			sqlgraph.To(MatchPlayerTable, FieldID),
 			sqlgraph.Edge(sqlgraph.M2O, true, MatchPlayerTable, MatchPlayerColumn),
 		)
 		sqlgraph.HasNeighbors(s, step)

ent/roundstats_create.go

@@ -70,49 +70,7 @@ func (rsc *RoundStatsCreate) Mutation() *RoundStatsMutation {
 
 // Save creates the RoundStats in the database.
 func (rsc *RoundStatsCreate) Save(ctx context.Context) (*RoundStats, error) {
-	var (
+	return withHooks[*RoundStats, RoundStatsMutation](ctx, rsc.sqlSave, rsc.mutation, rsc.hooks)
-		err  error
-		node *RoundStats
-	)
-	if len(rsc.hooks) == 0 {
-		if err = rsc.check(); err != nil {
-			return nil, err
-		}
-		node, err = rsc.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*RoundStatsMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = rsc.check(); err != nil {
-				return nil, err
-			}
-			rsc.mutation = mutation
-			if node, err = rsc.sqlSave(ctx); err != nil {
-				return nil, err
-			}
-			mutation.id = &node.ID
-			mutation.done = true
-			return node, err
-		})
-		for i := len(rsc.hooks) - 1; i >= 0; i-- {
-			if rsc.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = rsc.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, rsc.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*RoundStats)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from RoundStatsMutation", v)
-		}
-		node = nv
-	}
-	return node, err
 }
 
 // SaveX calls Save and panics if Save returns an error.
@@ -155,6 +113,9 @@ func (rsc *RoundStatsCreate) check() error {
 }
 
 func (rsc *RoundStatsCreate) sqlSave(ctx context.Context) (*RoundStats, error) {
+	if err := rsc.check(); err != nil {
+		return nil, err
+	}
 	_node, _spec := rsc.createSpec()
 	if err := sqlgraph.CreateNode(ctx, rsc.driver, _spec); err != nil {
 		if sqlgraph.IsConstraintError(err) {
@@ -164,19 +125,15 @@ func (rsc *RoundStatsCreate) sqlSave(ctx context.Context) (*RoundStats, error) {
 	}
 	id := _spec.ID.Value.(int64)
 	_node.ID = int(id)
+	rsc.mutation.id = &_node.ID
+	rsc.mutation.done = true
 	return _node, nil
 }
 
 func (rsc *RoundStatsCreate) createSpec() (*RoundStats, *sqlgraph.CreateSpec) {
 	var (
 		_node = &RoundStats{config: rsc.config}
-		_spec = &sqlgraph.CreateSpec{
+		_spec = sqlgraph.NewCreateSpec(roundstats.Table, sqlgraph.NewFieldSpec(roundstats.FieldID, field.TypeInt))
-			Table: roundstats.Table,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: roundstats.FieldID,
-			},
-		}
 	)
 	if value, ok := rsc.mutation.Round(); ok {
 		_spec.SetField(roundstats.FieldRound, field.TypeUint, value)

ent/roundstats_delete.go

@@ -4,7 +4,6 @@ package ent
 
 import (
 	"context"
-	"fmt"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -28,34 +27,7 @@ func (rsd *RoundStatsDelete) Where(ps ...predicate.RoundStats) *RoundStatsDelete
 
 // Exec executes the deletion query and returns how many vertices were deleted.
 func (rsd *RoundStatsDelete) Exec(ctx context.Context) (int, error) {
-	var (
+	return withHooks[int, RoundStatsMutation](ctx, rsd.sqlExec, rsd.mutation, rsd.hooks)
-		err      error
-		affected int
-	)
-	if len(rsd.hooks) == 0 {
-		affected, err = rsd.sqlExec(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*RoundStatsMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			rsd.mutation = mutation
-			affected, err = rsd.sqlExec(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(rsd.hooks) - 1; i >= 0; i-- {
-			if rsd.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = rsd.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, rsd.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
 }
 
 // ExecX is like Exec, but panics if an error occurs.
@@ -68,15 +40,7 @@ func (rsd *RoundStatsDelete) ExecX(ctx context.Context) int {
 }
 
 func (rsd *RoundStatsDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := &sqlgraph.DeleteSpec{
+	_spec := sqlgraph.NewDeleteSpec(roundstats.Table, sqlgraph.NewFieldSpec(roundstats.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
-			Table: roundstats.Table,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: roundstats.FieldID,
-			},
-		},
-	}
 	if ps := rsd.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -88,6 +52,7 @@ func (rsd *RoundStatsDelete) sqlExec(ctx context.Context) (int, error) {
 	if err != nil && sqlgraph.IsConstraintError(err) {
 		err = &ConstraintError{msg: err.Error(), wrap: err}
 	}
+	rsd.mutation.done = true
 	return affected, err
 }
 
@@ -96,6 +61,12 @@ type RoundStatsDeleteOne struct {
 	rsd *RoundStatsDelete
 }
 
+// Where appends a list predicates to the RoundStatsDelete builder.
+func (rsdo *RoundStatsDeleteOne) Where(ps ...predicate.RoundStats) *RoundStatsDeleteOne {
+	rsdo.rsd.mutation.Where(ps...)
+	return rsdo
+}
+
 // Exec executes the deletion query.
 func (rsdo *RoundStatsDeleteOne) Exec(ctx context.Context) error {
 	n, err := rsdo.rsd.Exec(ctx)
@@ -111,5 +82,7 @@ func (rsdo *RoundStatsDeleteOne) Exec(ctx context.Context) error {
 
 // ExecX is like Exec, but panics if an error occurs.
 func (rsdo *RoundStatsDeleteOne) ExecX(ctx context.Context) {
-	rsdo.rsd.ExecX(ctx)
+	if err := rsdo.Exec(ctx); err != nil {
+		panic(err)
+	}
 }

ent/roundstats_query.go

@@ -18,11 +18,9 @@ import (
 // RoundStatsQuery is the builder for querying RoundStats entities.
 type RoundStatsQuery struct {
 	config
-	limit           *int
+	ctx             *QueryContext
-	offset          *int
-	unique          *bool
 	order           []OrderFunc
-	fields          []string
+	inters          []Interceptor
 	predicates      []predicate.RoundStats
 	withMatchPlayer *MatchPlayerQuery
 	withFKs         bool
@@ -38,26 +36,26 @@ func (rsq *RoundStatsQuery) Where(ps ...predicate.RoundStats) *RoundStatsQuery {
 	return rsq
 }
 
-// Limit adds a limit step to the query.
+// Limit the number of records to be returned by this query.
 func (rsq *RoundStatsQuery) Limit(limit int) *RoundStatsQuery {
-	rsq.limit = &limit
+	rsq.ctx.Limit = &limit
 	return rsq
 }
 
-// Offset adds an offset step to the query.
+// Offset to start from.
 func (rsq *RoundStatsQuery) Offset(offset int) *RoundStatsQuery {
-	rsq.offset = &offset
+	rsq.ctx.Offset = &offset
 	return rsq
 }
 
 // Unique configures the query builder to filter duplicate records on query.
 // By default, unique is set to true, and can be disabled using this method.
 func (rsq *RoundStatsQuery) Unique(unique bool) *RoundStatsQuery {
-	rsq.unique = &unique
+	rsq.ctx.Unique = &unique
 	return rsq
 }
 
-// Order adds an order step to the query.
+// Order specifies how the records should be ordered.
 func (rsq *RoundStatsQuery) Order(o ...OrderFunc) *RoundStatsQuery {
 	rsq.order = append(rsq.order, o...)
 	return rsq
@@ -65,7 +63,7 @@ func (rsq *RoundStatsQuery) Order(o ...OrderFunc) *RoundStatsQuery {
 
 // QueryMatchPlayer chains the current query on the "match_player" edge.
 func (rsq *RoundStatsQuery) QueryMatchPlayer() *MatchPlayerQuery {
-	query := &MatchPlayerQuery{config: rsq.config}
+	query := (&MatchPlayerClient{config: rsq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := rsq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -88,7 +86,7 @@ func (rsq *RoundStatsQuery) QueryMatchPlayer() *MatchPlayerQuery {
 // First returns the first RoundStats entity from the query.
 // Returns a *NotFoundError when no RoundStats was found.
 func (rsq *RoundStatsQuery) First(ctx context.Context) (*RoundStats, error) {
-	nodes, err := rsq.Limit(1).All(ctx)
+	nodes, err := rsq.Limit(1).All(setContextOp(ctx, rsq.ctx, "First"))
 	if err != nil {
 		return nil, err
 	}
@@ -111,7 +109,7 @@ func (rsq *RoundStatsQuery) FirstX(ctx context.Context) *RoundStats {
 // Returns a *NotFoundError when no RoundStats ID was found.
 func (rsq *RoundStatsQuery) FirstID(ctx context.Context) (id int, err error) {
 	var ids []int
-	if ids, err = rsq.Limit(1).IDs(ctx); err != nil {
+	if ids, err = rsq.Limit(1).IDs(setContextOp(ctx, rsq.ctx, "FirstID")); err != nil {
 		return
 	}
 	if len(ids) == 0 {
@@ -134,7 +132,7 @@ func (rsq *RoundStatsQuery) FirstIDX(ctx context.Context) int {
 // Returns a *NotSingularError when more than one RoundStats entity is found.
 // Returns a *NotFoundError when no RoundStats entities are found.
 func (rsq *RoundStatsQuery) Only(ctx context.Context) (*RoundStats, error) {
-	nodes, err := rsq.Limit(2).All(ctx)
+	nodes, err := rsq.Limit(2).All(setContextOp(ctx, rsq.ctx, "Only"))
 	if err != nil {
 		return nil, err
 	}
@@ -162,7 +160,7 @@ func (rsq *RoundStatsQuery) OnlyX(ctx context.Context) *RoundStats {
 // Returns a *NotFoundError when no entities are found.
 func (rsq *RoundStatsQuery) OnlyID(ctx context.Context) (id int, err error) {
 	var ids []int
-	if ids, err = rsq.Limit(2).IDs(ctx); err != nil {
+	if ids, err = rsq.Limit(2).IDs(setContextOp(ctx, rsq.ctx, "OnlyID")); err != nil {
 		return
 	}
 	switch len(ids) {
@@ -187,10 +185,12 @@ func (rsq *RoundStatsQuery) OnlyIDX(ctx context.Context) int {
 
 // All executes the query and returns a list of RoundStatsSlice.
 func (rsq *RoundStatsQuery) All(ctx context.Context) ([]*RoundStats, error) {
+	ctx = setContextOp(ctx, rsq.ctx, "All")
 	if err := rsq.prepareQuery(ctx); err != nil {
 		return nil, err
 	}
-	return rsq.sqlAll(ctx)
+	qr := querierAll[[]*RoundStats, *RoundStatsQuery]()
+	return withInterceptors[[]*RoundStats](ctx, rsq, qr, rsq.inters)
 }
 
 // AllX is like All, but panics if an error occurs.
@@ -203,9 +203,12 @@ func (rsq *RoundStatsQuery) AllX(ctx context.Context) []*RoundStats {
 }
 
 // IDs executes the query and returns a list of RoundStats IDs.
-func (rsq *RoundStatsQuery) IDs(ctx context.Context) ([]int, error) {
+func (rsq *RoundStatsQuery) IDs(ctx context.Context) (ids []int, err error) {
-	var ids []int
+	if rsq.ctx.Unique == nil && rsq.path != nil {
-	if err := rsq.Select(roundstats.FieldID).Scan(ctx, &ids); err != nil {
+		rsq.Unique(true)
+	}
+	ctx = setContextOp(ctx, rsq.ctx, "IDs")
+	if err = rsq.Select(roundstats.FieldID).Scan(ctx, &ids); err != nil {
 		return nil, err
 	}
 	return ids, nil
@@ -222,10 +225,11 @@ func (rsq *RoundStatsQuery) IDsX(ctx context.Context) []int {
 
 // Count returns the count of the given query.
 func (rsq *RoundStatsQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, rsq.ctx, "Count")
 	if err := rsq.prepareQuery(ctx); err != nil {
 		return 0, err
 	}
-	return rsq.sqlCount(ctx)
+	return withInterceptors[int](ctx, rsq, querierCount[*RoundStatsQuery](), rsq.inters)
 }
 
 // CountX is like Count, but panics if an error occurs.
@@ -239,10 +243,15 @@ func (rsq *RoundStatsQuery) CountX(ctx context.Context) int {
 
 // Exist returns true if the query has elements in the graph.
 func (rsq *RoundStatsQuery) Exist(ctx context.Context) (bool, error) {
-	if err := rsq.prepareQuery(ctx); err != nil {
+	ctx = setContextOp(ctx, rsq.ctx, "Exist")
-		return false, err
+	switch _, err := rsq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("ent: check existence: %w", err)
+	default:
+		return true, nil
 	}
-	return rsq.sqlExist(ctx)
 }
 
 // ExistX is like Exist, but panics if an error occurs.
@@ -262,22 +271,21 @@ func (rsq *RoundStatsQuery) Clone() *RoundStatsQuery {
 	}
 	return &RoundStatsQuery{
 		config:          rsq.config,
-		limit:           rsq.limit,
+		ctx:             rsq.ctx.Clone(),
-		offset:          rsq.offset,
 		order:           append([]OrderFunc{}, rsq.order...),
+		inters:          append([]Interceptor{}, rsq.inters...),
 		predicates:      append([]predicate.RoundStats{}, rsq.predicates...),
 		withMatchPlayer: rsq.withMatchPlayer.Clone(),
 		// clone intermediate query.
-		sql:    rsq.sql.Clone(),
+		sql:  rsq.sql.Clone(),
-		path:   rsq.path,
+		path: rsq.path,
-		unique: rsq.unique,
 	}
 }
 
 // WithMatchPlayer tells the query-builder to eager-load the nodes that are connected to
 // the "match_player" edge. The optional arguments are used to configure the query builder of the edge.
 func (rsq *RoundStatsQuery) WithMatchPlayer(opts ...func(*MatchPlayerQuery)) *RoundStatsQuery {
-	query := &MatchPlayerQuery{config: rsq.config}
+	query := (&MatchPlayerClient{config: rsq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -300,16 +308,11 @@ func (rsq *RoundStatsQuery) WithMatchPlayer(opts ...func(*MatchPlayerQuery)) *Ro
 //		Aggregate(ent.Count()).
 //		Scan(ctx, &v)
 func (rsq *RoundStatsQuery) GroupBy(field string, fields ...string) *RoundStatsGroupBy {
-	grbuild := &RoundStatsGroupBy{config: rsq.config}
+	rsq.ctx.Fields = append([]string{field}, fields...)
-	grbuild.fields = append([]string{field}, fields...)
+	grbuild := &RoundStatsGroupBy{build: rsq}
-	grbuild.path = func(ctx context.Context) (prev *sql.Selector, err error) {
+	grbuild.flds = &rsq.ctx.Fields
-		if err := rsq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		return rsq.sqlQuery(ctx), nil
-	}
 	grbuild.label = roundstats.Label
-	grbuild.flds, grbuild.scan = &grbuild.fields, grbuild.Scan
+	grbuild.scan = grbuild.Scan
 	return grbuild
 }
 
@@ -326,11 +329,11 @@ func (rsq *RoundStatsQuery) GroupBy(field string, fields ...string) *RoundStatsG
 //		Select(roundstats.FieldRound).
 //		Scan(ctx, &v)
 func (rsq *RoundStatsQuery) Select(fields ...string) *RoundStatsSelect {
-	rsq.fields = append(rsq.fields, fields...)
+	rsq.ctx.Fields = append(rsq.ctx.Fields, fields...)
-	selbuild := &RoundStatsSelect{RoundStatsQuery: rsq}
+	sbuild := &RoundStatsSelect{RoundStatsQuery: rsq}
-	selbuild.label = roundstats.Label
+	sbuild.label = roundstats.Label
-	selbuild.flds, selbuild.scan = &rsq.fields, selbuild.Scan
+	sbuild.flds, sbuild.scan = &rsq.ctx.Fields, sbuild.Scan
-	return selbuild
+	return sbuild
 }
 
 // Aggregate returns a RoundStatsSelect configured with the given aggregations.
@@ -339,7 +342,17 @@ func (rsq *RoundStatsQuery) Aggregate(fns ...AggregateFunc) *RoundStatsSelect {
 }
 
 func (rsq *RoundStatsQuery) prepareQuery(ctx context.Context) error {
-	for _, f := range rsq.fields {
+	for _, inter := range rsq.inters {
+		if inter == nil {
+			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, rsq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range rsq.ctx.Fields {
 		if !roundstats.ValidColumn(f) {
 			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
 		}
@@ -412,6 +425,9 @@ func (rsq *RoundStatsQuery) loadMatchPlayer(ctx context.Context, query *MatchPla
 		}
 		nodeids[fk] = append(nodeids[fk], nodes[i])
 	}
+	if len(ids) == 0 {
+		return nil
+	}
 	query.Where(matchplayer.IDIn(ids...))
 	neighbors, err := query.All(ctx)
 	if err != nil {
@@ -434,41 +450,22 @@ func (rsq *RoundStatsQuery) sqlCount(ctx context.Context) (int, error) {
 	if len(rsq.modifiers) > 0 {
 		_spec.Modifiers = rsq.modifiers
 	}
-	_spec.Node.Columns = rsq.fields
+	_spec.Node.Columns = rsq.ctx.Fields
-	if len(rsq.fields) > 0 {
+	if len(rsq.ctx.Fields) > 0 {
-		_spec.Unique = rsq.unique != nil && *rsq.unique
+		_spec.Unique = rsq.ctx.Unique != nil && *rsq.ctx.Unique
 	}
 	return sqlgraph.CountNodes(ctx, rsq.driver, _spec)
 }
 
-func (rsq *RoundStatsQuery) sqlExist(ctx context.Context) (bool, error) {
-	switch _, err := rsq.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
 func (rsq *RoundStatsQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := &sqlgraph.QuerySpec{
+	_spec := sqlgraph.NewQuerySpec(roundstats.Table, roundstats.Columns, sqlgraph.NewFieldSpec(roundstats.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
+	_spec.From = rsq.sql
-			Table:   roundstats.Table,
+	if unique := rsq.ctx.Unique; unique != nil {
-			Columns: roundstats.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: roundstats.FieldID,
-			},
-		},
-		From:   rsq.sql,
-		Unique: true,
-	}
-	if unique := rsq.unique; unique != nil {
 		_spec.Unique = *unique
+	} else if rsq.path != nil {
+		_spec.Unique = true
 	}
-	if fields := rsq.fields; len(fields) > 0 {
+	if fields := rsq.ctx.Fields; len(fields) > 0 {
 		_spec.Node.Columns = make([]string, 0, len(fields))
 		_spec.Node.Columns = append(_spec.Node.Columns, roundstats.FieldID)
 		for i := range fields {
@@ -484,10 +481,10 @@ func (rsq *RoundStatsQuery) querySpec() *sqlgraph.QuerySpec {
 			}
 		}
 	}
-	if limit := rsq.limit; limit != nil {
+	if limit := rsq.ctx.Limit; limit != nil {
 		_spec.Limit = *limit
 	}
-	if offset := rsq.offset; offset != nil {
+	if offset := rsq.ctx.Offset; offset != nil {
 		_spec.Offset = *offset
 	}
 	if ps := rsq.order; len(ps) > 0 {
@@ -503,7 +500,7 @@ func (rsq *RoundStatsQuery) querySpec() *sqlgraph.QuerySpec {
 func (rsq *RoundStatsQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	builder := sql.Dialect(rsq.driver.Dialect())
 	t1 := builder.Table(roundstats.Table)
-	columns := rsq.fields
+	columns := rsq.ctx.Fields
 	if len(columns) == 0 {
 		columns = roundstats.Columns
 	}
@@ -512,7 +509,7 @@ func (rsq *RoundStatsQuery) sqlQuery(ctx context.Context) *sql.Selector {
 		selector = rsq.sql
 		selector.Select(selector.Columns(columns...)...)
 	}
-	if rsq.unique != nil && *rsq.unique {
+	if rsq.ctx.Unique != nil && *rsq.ctx.Unique {
 		selector.Distinct()
 	}
 	for _, m := range rsq.modifiers {
@@ -524,12 +521,12 @@ func (rsq *RoundStatsQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	for _, p := range rsq.order {
 		p(selector)
 	}
-	if offset := rsq.offset; offset != nil {
+	if offset := rsq.ctx.Offset; offset != nil {
 		// limit is mandatory for offset clause. We start
 		// with default value, and override it below if needed.
 		selector.Offset(*offset).Limit(math.MaxInt32)
 	}
-	if limit := rsq.limit; limit != nil {
+	if limit := rsq.ctx.Limit; limit != nil {
 		selector.Limit(*limit)
 	}
 	return selector
@@ -543,13 +540,8 @@ func (rsq *RoundStatsQuery) Modify(modifiers ...func(s *sql.Selector)) *RoundSta
 
 // RoundStatsGroupBy is the group-by builder for RoundStats entities.
 type RoundStatsGroupBy struct {
-	config
 	selector
-	fields []string
+	build *RoundStatsQuery
-	fns    []AggregateFunc
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
 }
 
 // Aggregate adds the given aggregation functions to the group-by query.
@@ -558,58 +550,46 @@ func (rsgb *RoundStatsGroupBy) Aggregate(fns ...AggregateFunc) *RoundStatsGroupB
 	return rsgb
 }
 
-// Scan applies the group-by query and scans the result into the given value.
+// Scan applies the selector query and scans the result into the given value.
 func (rsgb *RoundStatsGroupBy) Scan(ctx context.Context, v any) error {
-	query, err := rsgb.path(ctx)
+	ctx = setContextOp(ctx, rsgb.build.ctx, "GroupBy")
-	if err != nil {
+	if err := rsgb.build.prepareQuery(ctx); err != nil {
 		return err
 	}
-	rsgb.sql = query
+	return scanWithInterceptors[*RoundStatsQuery, *RoundStatsGroupBy](ctx, rsgb.build, rsgb, rsgb.build.inters, v)
-	return rsgb.sqlScan(ctx, v)
 }
 
-func (rsgb *RoundStatsGroupBy) sqlScan(ctx context.Context, v any) error {
+func (rsgb *RoundStatsGroupBy) sqlScan(ctx context.Context, root *RoundStatsQuery, v any) error {
-	for _, f := range rsgb.fields {
+	selector := root.sqlQuery(ctx).Select()
-		if !roundstats.ValidColumn(f) {
+	aggregation := make([]string, 0, len(rsgb.fns))
-			return &ValidationError{Name: f, err: fmt.Errorf("invalid field %q for group-by", f)}
+	for _, fn := range rsgb.fns {
-		}
+		aggregation = append(aggregation, fn(selector))
 	}
-	selector := rsgb.sqlQuery()
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*rsgb.flds)+len(rsgb.fns))
+		for _, f := range *rsgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*rsgb.flds...)...)
 	if err := selector.Err(); err != nil {
 		return err
 	}
 	rows := &sql.Rows{}
 	query, args := selector.Query()
-	if err := rsgb.driver.Query(ctx, query, args, rows); err != nil {
+	if err := rsgb.build.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
 
-func (rsgb *RoundStatsGroupBy) sqlQuery() *sql.Selector {
-	selector := rsgb.sql.Select()
-	aggregation := make([]string, 0, len(rsgb.fns))
-	for _, fn := range rsgb.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(rsgb.fields)+len(rsgb.fns))
-		for _, f := range rsgb.fields {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	return selector.GroupBy(selector.Columns(rsgb.fields...)...)
-}
-
 // RoundStatsSelect is the builder for selecting fields of RoundStats entities.
 type RoundStatsSelect struct {
 	*RoundStatsQuery
 	selector
-	// intermediate query (i.e. traversal path).
-	sql *sql.Selector
 }
 
 // Aggregate adds the given aggregation functions to the selector query.
@@ -620,26 +600,27 @@ func (rss *RoundStatsSelect) Aggregate(fns ...AggregateFunc) *RoundStatsSelect {
 
 // Scan applies the selector query and scans the result into the given value.
 func (rss *RoundStatsSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, rss.ctx, "Select")
 	if err := rss.prepareQuery(ctx); err != nil {
 		return err
 	}
-	rss.sql = rss.RoundStatsQuery.sqlQuery(ctx)
+	return scanWithInterceptors[*RoundStatsQuery, *RoundStatsSelect](ctx, rss.RoundStatsQuery, rss, rss.inters, v)
-	return rss.sqlScan(ctx, v)
 }
 
-func (rss *RoundStatsSelect) sqlScan(ctx context.Context, v any) error {
+func (rss *RoundStatsSelect) sqlScan(ctx context.Context, root *RoundStatsQuery, v any) error {
+	selector := root.sqlQuery(ctx)
 	aggregation := make([]string, 0, len(rss.fns))
 	for _, fn := range rss.fns {
-		aggregation = append(aggregation, fn(rss.sql))
+		aggregation = append(aggregation, fn(selector))
 	}
 	switch n := len(*rss.selector.flds); {
 	case n == 0 && len(aggregation) > 0:
-		rss.sql.Select(aggregation...)
+		selector.Select(aggregation...)
 	case n != 0 && len(aggregation) > 0:
-		rss.sql.AppendSelect(aggregation...)
+		selector.AppendSelect(aggregation...)
 	}
 	rows := &sql.Rows{}
-	query, args := rss.sql.Query()
+	query, args := selector.Query()
 	if err := rss.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}

ent/roundstats_update.go

@@ -113,34 +113,7 @@ func (rsu *RoundStatsUpdate) ClearMatchPlayer() *RoundStatsUpdate {
 
 // Save executes the query and returns the number of nodes affected by the update operation.
 func (rsu *RoundStatsUpdate) Save(ctx context.Context) (int, error) {
-	var (
+	return withHooks[int, RoundStatsMutation](ctx, rsu.sqlSave, rsu.mutation, rsu.hooks)
-		err      error
-		affected int
-	)
-	if len(rsu.hooks) == 0 {
-		affected, err = rsu.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*RoundStatsMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			rsu.mutation = mutation
-			affected, err = rsu.sqlSave(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(rsu.hooks) - 1; i >= 0; i-- {
-			if rsu.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = rsu.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, rsu.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -172,16 +145,7 @@ func (rsu *RoundStatsUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *Ro
 }
 
 func (rsu *RoundStatsUpdate) sqlSave(ctx context.Context) (n int, err error) {
-	_spec := &sqlgraph.UpdateSpec{
+	_spec := sqlgraph.NewUpdateSpec(roundstats.Table, roundstats.Columns, sqlgraph.NewFieldSpec(roundstats.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
-			Table:   roundstats.Table,
-			Columns: roundstats.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: roundstats.FieldID,
-			},
-		},
-	}
 	if ps := rsu.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -257,6 +221,7 @@ func (rsu *RoundStatsUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		return 0, err
 	}
+	rsu.mutation.done = true
 	return n, nil
 }
 
@@ -351,6 +316,12 @@ func (rsuo *RoundStatsUpdateOne) ClearMatchPlayer() *RoundStatsUpdateOne {
 	return rsuo
 }
 
+// Where appends a list predicates to the RoundStatsUpdate builder.
+func (rsuo *RoundStatsUpdateOne) Where(ps ...predicate.RoundStats) *RoundStatsUpdateOne {
+	rsuo.mutation.Where(ps...)
+	return rsuo
+}
+
 // Select allows selecting one or more fields (columns) of the returned entity.
 // The default is selecting all fields defined in the entity schema.
 func (rsuo *RoundStatsUpdateOne) Select(field string, fields ...string) *RoundStatsUpdateOne {
@@ -360,40 +331,7 @@ func (rsuo *RoundStatsUpdateOne) Select(field string, fields ...string) *RoundSt
 
 // Save executes the query and returns the updated RoundStats entity.
 func (rsuo *RoundStatsUpdateOne) Save(ctx context.Context) (*RoundStats, error) {
-	var (
+	return withHooks[*RoundStats, RoundStatsMutation](ctx, rsuo.sqlSave, rsuo.mutation, rsuo.hooks)
-		err  error
-		node *RoundStats
-	)
-	if len(rsuo.hooks) == 0 {
-		node, err = rsuo.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*RoundStatsMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			rsuo.mutation = mutation
-			node, err = rsuo.sqlSave(ctx)
-			mutation.done = true
-			return node, err
-		})
-		for i := len(rsuo.hooks) - 1; i >= 0; i-- {
-			if rsuo.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = rsuo.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, rsuo.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*RoundStats)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from RoundStatsMutation", v)
-		}
-		node = nv
-	}
-	return node, err
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -425,16 +363,7 @@ func (rsuo *RoundStatsUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder))
 }
 
 func (rsuo *RoundStatsUpdateOne) sqlSave(ctx context.Context) (_node *RoundStats, err error) {
-	_spec := &sqlgraph.UpdateSpec{
+	_spec := sqlgraph.NewUpdateSpec(roundstats.Table, roundstats.Columns, sqlgraph.NewFieldSpec(roundstats.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
-			Table:   roundstats.Table,
-			Columns: roundstats.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: roundstats.FieldID,
-			},
-		},
-	}
 	id, ok := rsuo.mutation.ID()
 	if !ok {
 		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "RoundStats.id" for update`)}
@@ -530,5 +459,6 @@ func (rsuo *RoundStatsUpdateOne) sqlSave(ctx context.Context) (_node *RoundStats
 		}
 		return nil, err
 	}
+	rsuo.mutation.done = true
 	return _node, nil
 }

ent/runtime/runtime.go

@@ -5,6 +5,6 @@ package runtime
 // The schema-stitching logic is generated in git.harting.dev/csgowtf/csgowtfd/ent/runtime.go
 
 const (
-	Version = "v0.11.4"                                         // Version of ent codegen.
+	Version = "v0.11.9"                                         // Version of ent codegen.
-	Sum     = "h1:grwVY0fp31BZ6oEo3YrXenAuv8VJmEw7F/Bi6WqeH3Q=" // Sum of ent codegen.
+	Sum     = "h1:dbbCkAiPVTRBIJwoZctiSYjB7zxQIBOzVSU5H9VYIQI=" // Sum of ent codegen.
 )

ent/spray.go

@@ -106,14 +106,14 @@ func (s *Spray) assignValues(columns []string, values []any) error {
 
 // QueryMatchPlayers queries the "match_players" edge of the Spray entity.
 func (s *Spray) QueryMatchPlayers() *MatchPlayerQuery {
-	return (&SprayClient{config: s.config}).QueryMatchPlayers(s)
+	return NewSprayClient(s.config).QueryMatchPlayers(s)
 }
 
 // Update returns a builder for updating this Spray.
 // Note that you need to call Spray.Unwrap() before calling this method if this Spray
 // was returned from a transaction, and the transaction was committed or rolled back.
 func (s *Spray) Update() *SprayUpdateOne {
-	return (&SprayClient{config: s.config}).UpdateOne(s)
+	return NewSprayClient(s.config).UpdateOne(s)
 }
 
 // Unwrap unwraps the Spray entity that was returned from a transaction after it was closed,
@@ -143,9 +143,3 @@ func (s *Spray) String() string {
 
 // Sprays is a parsable slice of Spray.
 type Sprays []*Spray
-
-func (s Sprays) config(cfg config) {
-	for _i := range s {
-		s[_i].config = cfg
-	}
-}

ent/spray/where.go

@@ -10,215 +10,137 @@ import (
 
 // ID filters vertices based on their ID field.
 func ID(id int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldEQ(FieldID, id))
-		s.Where(sql.EQ(s.C(FieldID), id))
-	})
 }
 
 // IDEQ applies the EQ predicate on the ID field.
 func IDEQ(id int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldEQ(FieldID, id))
-		s.Where(sql.EQ(s.C(FieldID), id))
-	})
 }
 
 // IDNEQ applies the NEQ predicate on the ID field.
 func IDNEQ(id int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldNEQ(FieldID, id))
-		s.Where(sql.NEQ(s.C(FieldID), id))
-	})
 }
 
 // IDIn applies the In predicate on the ID field.
 func IDIn(ids ...int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldIn(FieldID, ids...))
-		v := make([]any, len(ids))
-		for i := range v {
-			v[i] = ids[i]
-		}
-		s.Where(sql.In(s.C(FieldID), v...))
-	})
 }
 
 // IDNotIn applies the NotIn predicate on the ID field.
 func IDNotIn(ids ...int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldNotIn(FieldID, ids...))
-		v := make([]any, len(ids))
-		for i := range v {
-			v[i] = ids[i]
-		}
-		s.Where(sql.NotIn(s.C(FieldID), v...))
-	})
 }
 
 // IDGT applies the GT predicate on the ID field.
 func IDGT(id int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldGT(FieldID, id))
-		s.Where(sql.GT(s.C(FieldID), id))
-	})
 }
 
 // IDGTE applies the GTE predicate on the ID field.
 func IDGTE(id int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldGTE(FieldID, id))
-		s.Where(sql.GTE(s.C(FieldID), id))
-	})
 }
 
 // IDLT applies the LT predicate on the ID field.
 func IDLT(id int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldLT(FieldID, id))
-		s.Where(sql.LT(s.C(FieldID), id))
-	})
 }
 
 // IDLTE applies the LTE predicate on the ID field.
 func IDLTE(id int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldLTE(FieldID, id))
-		s.Where(sql.LTE(s.C(FieldID), id))
-	})
 }
 
 // Weapon applies equality check predicate on the "weapon" field. It's identical to WeaponEQ.
 func Weapon(v int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldEQ(FieldWeapon, v))
-		s.Where(sql.EQ(s.C(FieldWeapon), v))
-	})
 }
 
 // Spray applies equality check predicate on the "spray" field. It's identical to SprayEQ.
 func Spray(v []byte) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldEQ(FieldSpray, v))
-		s.Where(sql.EQ(s.C(FieldSpray), v))
-	})
 }
 
 // WeaponEQ applies the EQ predicate on the "weapon" field.
 func WeaponEQ(v int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldEQ(FieldWeapon, v))
-		s.Where(sql.EQ(s.C(FieldWeapon), v))
-	})
 }
 
 // WeaponNEQ applies the NEQ predicate on the "weapon" field.
 func WeaponNEQ(v int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldNEQ(FieldWeapon, v))
-		s.Where(sql.NEQ(s.C(FieldWeapon), v))
-	})
 }
 
 // WeaponIn applies the In predicate on the "weapon" field.
 func WeaponIn(vs ...int) predicate.Spray {
-	v := make([]any, len(vs))
+	return predicate.Spray(sql.FieldIn(FieldWeapon, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Spray(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldWeapon), v...))
-	})
 }
 
 // WeaponNotIn applies the NotIn predicate on the "weapon" field.
 func WeaponNotIn(vs ...int) predicate.Spray {
-	v := make([]any, len(vs))
+	return predicate.Spray(sql.FieldNotIn(FieldWeapon, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Spray(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldWeapon), v...))
-	})
 }
 
 // WeaponGT applies the GT predicate on the "weapon" field.
 func WeaponGT(v int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldGT(FieldWeapon, v))
-		s.Where(sql.GT(s.C(FieldWeapon), v))
-	})
 }
 
 // WeaponGTE applies the GTE predicate on the "weapon" field.
 func WeaponGTE(v int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldGTE(FieldWeapon, v))
-		s.Where(sql.GTE(s.C(FieldWeapon), v))
-	})
 }
 
 // WeaponLT applies the LT predicate on the "weapon" field.
 func WeaponLT(v int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldLT(FieldWeapon, v))
-		s.Where(sql.LT(s.C(FieldWeapon), v))
-	})
 }
 
 // WeaponLTE applies the LTE predicate on the "weapon" field.
 func WeaponLTE(v int) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldLTE(FieldWeapon, v))
-		s.Where(sql.LTE(s.C(FieldWeapon), v))
-	})
 }
 
 // SprayEQ applies the EQ predicate on the "spray" field.
 func SprayEQ(v []byte) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldEQ(FieldSpray, v))
-		s.Where(sql.EQ(s.C(FieldSpray), v))
-	})
 }
 
 // SprayNEQ applies the NEQ predicate on the "spray" field.
 func SprayNEQ(v []byte) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldNEQ(FieldSpray, v))
-		s.Where(sql.NEQ(s.C(FieldSpray), v))
-	})
 }
 
 // SprayIn applies the In predicate on the "spray" field.
 func SprayIn(vs ...[]byte) predicate.Spray {
-	v := make([]any, len(vs))
+	return predicate.Spray(sql.FieldIn(FieldSpray, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Spray(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldSpray), v...))
-	})
 }
 
 // SprayNotIn applies the NotIn predicate on the "spray" field.
 func SprayNotIn(vs ...[]byte) predicate.Spray {
-	v := make([]any, len(vs))
+	return predicate.Spray(sql.FieldNotIn(FieldSpray, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Spray(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldSpray), v...))
-	})
 }
 
 // SprayGT applies the GT predicate on the "spray" field.
 func SprayGT(v []byte) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldGT(FieldSpray, v))
-		s.Where(sql.GT(s.C(FieldSpray), v))
-	})
 }
 
 // SprayGTE applies the GTE predicate on the "spray" field.
 func SprayGTE(v []byte) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldGTE(FieldSpray, v))
-		s.Where(sql.GTE(s.C(FieldSpray), v))
-	})
 }
 
 // SprayLT applies the LT predicate on the "spray" field.
 func SprayLT(v []byte) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldLT(FieldSpray, v))
-		s.Where(sql.LT(s.C(FieldSpray), v))
-	})
 }
 
 // SprayLTE applies the LTE predicate on the "spray" field.
 func SprayLTE(v []byte) predicate.Spray {
-	return predicate.Spray(func(s *sql.Selector) {
+	return predicate.Spray(sql.FieldLTE(FieldSpray, v))
-		s.Where(sql.LTE(s.C(FieldSpray), v))
-	})
 }
 
 // HasMatchPlayers applies the HasEdge predicate on the "match_players" edge.
@@ -226,7 +148,6 @@ func HasMatchPlayers() predicate.Spray {
 	return predicate.Spray(func(s *sql.Selector) {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(Table, FieldID),
-			sqlgraph.To(MatchPlayersTable, FieldID),
 			sqlgraph.Edge(sqlgraph.M2O, true, MatchPlayersTable, MatchPlayersColumn),
 		)
 		sqlgraph.HasNeighbors(s, step)

ent/spray_create.go

@@ -58,49 +58,7 @@ func (sc *SprayCreate) Mutation() *SprayMutation {
 
 // Save creates the Spray in the database.
 func (sc *SprayCreate) Save(ctx context.Context) (*Spray, error) {
-	var (
+	return withHooks[*Spray, SprayMutation](ctx, sc.sqlSave, sc.mutation, sc.hooks)
-		err  error
-		node *Spray
-	)
-	if len(sc.hooks) == 0 {
-		if err = sc.check(); err != nil {
-			return nil, err
-		}
-		node, err = sc.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*SprayMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = sc.check(); err != nil {
-				return nil, err
-			}
-			sc.mutation = mutation
-			if node, err = sc.sqlSave(ctx); err != nil {
-				return nil, err
-			}
-			mutation.id = &node.ID
-			mutation.done = true
-			return node, err
-		})
-		for i := len(sc.hooks) - 1; i >= 0; i-- {
-			if sc.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = sc.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, sc.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*Spray)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from SprayMutation", v)
-		}
-		node = nv
-	}
-	return node, err
 }
 
 // SaveX calls Save and panics if Save returns an error.
@@ -137,6 +95,9 @@ func (sc *SprayCreate) check() error {
 }
 
 func (sc *SprayCreate) sqlSave(ctx context.Context) (*Spray, error) {
+	if err := sc.check(); err != nil {
+		return nil, err
+	}
 	_node, _spec := sc.createSpec()
 	if err := sqlgraph.CreateNode(ctx, sc.driver, _spec); err != nil {
 		if sqlgraph.IsConstraintError(err) {
@@ -146,19 +107,15 @@ func (sc *SprayCreate) sqlSave(ctx context.Context) (*Spray, error) {
 	}
 	id := _spec.ID.Value.(int64)
 	_node.ID = int(id)
+	sc.mutation.id = &_node.ID
+	sc.mutation.done = true
 	return _node, nil
 }
 
 func (sc *SprayCreate) createSpec() (*Spray, *sqlgraph.CreateSpec) {
 	var (
 		_node = &Spray{config: sc.config}
-		_spec = &sqlgraph.CreateSpec{
+		_spec = sqlgraph.NewCreateSpec(spray.Table, sqlgraph.NewFieldSpec(spray.FieldID, field.TypeInt))
-			Table: spray.Table,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: spray.FieldID,
-			},
-		}
 	)
 	if value, ok := sc.mutation.Weapon(); ok {
 		_spec.SetField(spray.FieldWeapon, field.TypeInt, value)

ent/spray_delete.go

@@ -4,7 +4,6 @@ package ent
 
 import (
 	"context"
-	"fmt"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -28,34 +27,7 @@ func (sd *SprayDelete) Where(ps ...predicate.Spray) *SprayDelete {
 
 // Exec executes the deletion query and returns how many vertices were deleted.
 func (sd *SprayDelete) Exec(ctx context.Context) (int, error) {
-	var (
+	return withHooks[int, SprayMutation](ctx, sd.sqlExec, sd.mutation, sd.hooks)
-		err      error
-		affected int
-	)
-	if len(sd.hooks) == 0 {
-		affected, err = sd.sqlExec(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*SprayMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			sd.mutation = mutation
-			affected, err = sd.sqlExec(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(sd.hooks) - 1; i >= 0; i-- {
-			if sd.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = sd.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, sd.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
 }
 
 // ExecX is like Exec, but panics if an error occurs.
@@ -68,15 +40,7 @@ func (sd *SprayDelete) ExecX(ctx context.Context) int {
 }
 
 func (sd *SprayDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := &sqlgraph.DeleteSpec{
+	_spec := sqlgraph.NewDeleteSpec(spray.Table, sqlgraph.NewFieldSpec(spray.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
-			Table: spray.Table,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: spray.FieldID,
-			},
-		},
-	}
 	if ps := sd.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -88,6 +52,7 @@ func (sd *SprayDelete) sqlExec(ctx context.Context) (int, error) {
 	if err != nil && sqlgraph.IsConstraintError(err) {
 		err = &ConstraintError{msg: err.Error(), wrap: err}
 	}
+	sd.mutation.done = true
 	return affected, err
 }
 
@@ -96,6 +61,12 @@ type SprayDeleteOne struct {
 	sd *SprayDelete
 }
 
+// Where appends a list predicates to the SprayDelete builder.
+func (sdo *SprayDeleteOne) Where(ps ...predicate.Spray) *SprayDeleteOne {
+	sdo.sd.mutation.Where(ps...)
+	return sdo
+}
+
 // Exec executes the deletion query.
 func (sdo *SprayDeleteOne) Exec(ctx context.Context) error {
 	n, err := sdo.sd.Exec(ctx)
@@ -111,5 +82,7 @@ func (sdo *SprayDeleteOne) Exec(ctx context.Context) error {
 
 // ExecX is like Exec, but panics if an error occurs.
 func (sdo *SprayDeleteOne) ExecX(ctx context.Context) {
-	sdo.sd.ExecX(ctx)
+	if err := sdo.Exec(ctx); err != nil {
+		panic(err)
+	}
 }

ent/spray_query.go

@@ -18,11 +18,9 @@ import (
 // SprayQuery is the builder for querying Spray entities.
 type SprayQuery struct {
 	config
-	limit            *int
+	ctx              *QueryContext
-	offset           *int
-	unique           *bool
 	order            []OrderFunc
-	fields           []string
+	inters           []Interceptor
 	predicates       []predicate.Spray
 	withMatchPlayers *MatchPlayerQuery
 	withFKs          bool
@@ -38,26 +36,26 @@ func (sq *SprayQuery) Where(ps ...predicate.Spray) *SprayQuery {
 	return sq
 }
 
-// Limit adds a limit step to the query.
+// Limit the number of records to be returned by this query.
 func (sq *SprayQuery) Limit(limit int) *SprayQuery {
-	sq.limit = &limit
+	sq.ctx.Limit = &limit
 	return sq
 }
 
-// Offset adds an offset step to the query.
+// Offset to start from.
 func (sq *SprayQuery) Offset(offset int) *SprayQuery {
-	sq.offset = &offset
+	sq.ctx.Offset = &offset
 	return sq
 }
 
 // Unique configures the query builder to filter duplicate records on query.
 // By default, unique is set to true, and can be disabled using this method.
 func (sq *SprayQuery) Unique(unique bool) *SprayQuery {
-	sq.unique = &unique
+	sq.ctx.Unique = &unique
 	return sq
 }
 
-// Order adds an order step to the query.
+// Order specifies how the records should be ordered.
 func (sq *SprayQuery) Order(o ...OrderFunc) *SprayQuery {
 	sq.order = append(sq.order, o...)
 	return sq
@@ -65,7 +63,7 @@ func (sq *SprayQuery) Order(o ...OrderFunc) *SprayQuery {
 
 // QueryMatchPlayers chains the current query on the "match_players" edge.
 func (sq *SprayQuery) QueryMatchPlayers() *MatchPlayerQuery {
-	query := &MatchPlayerQuery{config: sq.config}
+	query := (&MatchPlayerClient{config: sq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := sq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -88,7 +86,7 @@ func (sq *SprayQuery) QueryMatchPlayers() *MatchPlayerQuery {
 // First returns the first Spray entity from the query.
 // Returns a *NotFoundError when no Spray was found.
 func (sq *SprayQuery) First(ctx context.Context) (*Spray, error) {
-	nodes, err := sq.Limit(1).All(ctx)
+	nodes, err := sq.Limit(1).All(setContextOp(ctx, sq.ctx, "First"))
 	if err != nil {
 		return nil, err
 	}
@@ -111,7 +109,7 @@ func (sq *SprayQuery) FirstX(ctx context.Context) *Spray {
 // Returns a *NotFoundError when no Spray ID was found.
 func (sq *SprayQuery) FirstID(ctx context.Context) (id int, err error) {
 	var ids []int
-	if ids, err = sq.Limit(1).IDs(ctx); err != nil {
+	if ids, err = sq.Limit(1).IDs(setContextOp(ctx, sq.ctx, "FirstID")); err != nil {
 		return
 	}
 	if len(ids) == 0 {
@@ -134,7 +132,7 @@ func (sq *SprayQuery) FirstIDX(ctx context.Context) int {
 // Returns a *NotSingularError when more than one Spray entity is found.
 // Returns a *NotFoundError when no Spray entities are found.
 func (sq *SprayQuery) Only(ctx context.Context) (*Spray, error) {
-	nodes, err := sq.Limit(2).All(ctx)
+	nodes, err := sq.Limit(2).All(setContextOp(ctx, sq.ctx, "Only"))
 	if err != nil {
 		return nil, err
 	}
@@ -162,7 +160,7 @@ func (sq *SprayQuery) OnlyX(ctx context.Context) *Spray {
 // Returns a *NotFoundError when no entities are found.
 func (sq *SprayQuery) OnlyID(ctx context.Context) (id int, err error) {
 	var ids []int
-	if ids, err = sq.Limit(2).IDs(ctx); err != nil {
+	if ids, err = sq.Limit(2).IDs(setContextOp(ctx, sq.ctx, "OnlyID")); err != nil {
 		return
 	}
 	switch len(ids) {
@@ -187,10 +185,12 @@ func (sq *SprayQuery) OnlyIDX(ctx context.Context) int {
 
 // All executes the query and returns a list of Sprays.
 func (sq *SprayQuery) All(ctx context.Context) ([]*Spray, error) {
+	ctx = setContextOp(ctx, sq.ctx, "All")
 	if err := sq.prepareQuery(ctx); err != nil {
 		return nil, err
 	}
-	return sq.sqlAll(ctx)
+	qr := querierAll[[]*Spray, *SprayQuery]()
+	return withInterceptors[[]*Spray](ctx, sq, qr, sq.inters)
 }
 
 // AllX is like All, but panics if an error occurs.
@@ -203,9 +203,12 @@ func (sq *SprayQuery) AllX(ctx context.Context) []*Spray {
 }
 
 // IDs executes the query and returns a list of Spray IDs.
-func (sq *SprayQuery) IDs(ctx context.Context) ([]int, error) {
+func (sq *SprayQuery) IDs(ctx context.Context) (ids []int, err error) {
-	var ids []int
+	if sq.ctx.Unique == nil && sq.path != nil {
-	if err := sq.Select(spray.FieldID).Scan(ctx, &ids); err != nil {
+		sq.Unique(true)
+	}
+	ctx = setContextOp(ctx, sq.ctx, "IDs")
+	if err = sq.Select(spray.FieldID).Scan(ctx, &ids); err != nil {
 		return nil, err
 	}
 	return ids, nil
@@ -222,10 +225,11 @@ func (sq *SprayQuery) IDsX(ctx context.Context) []int {
 
 // Count returns the count of the given query.
 func (sq *SprayQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, sq.ctx, "Count")
 	if err := sq.prepareQuery(ctx); err != nil {
 		return 0, err
 	}
-	return sq.sqlCount(ctx)
+	return withInterceptors[int](ctx, sq, querierCount[*SprayQuery](), sq.inters)
 }
 
 // CountX is like Count, but panics if an error occurs.
@@ -239,10 +243,15 @@ func (sq *SprayQuery) CountX(ctx context.Context) int {
 
 // Exist returns true if the query has elements in the graph.
 func (sq *SprayQuery) Exist(ctx context.Context) (bool, error) {
-	if err := sq.prepareQuery(ctx); err != nil {
+	ctx = setContextOp(ctx, sq.ctx, "Exist")
-		return false, err
+	switch _, err := sq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("ent: check existence: %w", err)
+	default:
+		return true, nil
 	}
-	return sq.sqlExist(ctx)
 }
 
 // ExistX is like Exist, but panics if an error occurs.
@@ -262,22 +271,21 @@ func (sq *SprayQuery) Clone() *SprayQuery {
 	}
 	return &SprayQuery{
 		config:           sq.config,
-		limit:            sq.limit,
+		ctx:              sq.ctx.Clone(),
-		offset:           sq.offset,
 		order:            append([]OrderFunc{}, sq.order...),
+		inters:           append([]Interceptor{}, sq.inters...),
 		predicates:       append([]predicate.Spray{}, sq.predicates...),
 		withMatchPlayers: sq.withMatchPlayers.Clone(),
 		// clone intermediate query.
-		sql:    sq.sql.Clone(),
+		sql:  sq.sql.Clone(),
-		path:   sq.path,
+		path: sq.path,
-		unique: sq.unique,
 	}
 }
 
 // WithMatchPlayers tells the query-builder to eager-load the nodes that are connected to
 // the "match_players" edge. The optional arguments are used to configure the query builder of the edge.
 func (sq *SprayQuery) WithMatchPlayers(opts ...func(*MatchPlayerQuery)) *SprayQuery {
-	query := &MatchPlayerQuery{config: sq.config}
+	query := (&MatchPlayerClient{config: sq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -300,16 +308,11 @@ func (sq *SprayQuery) WithMatchPlayers(opts ...func(*MatchPlayerQuery)) *SprayQu
 //		Aggregate(ent.Count()).
 //		Scan(ctx, &v)
 func (sq *SprayQuery) GroupBy(field string, fields ...string) *SprayGroupBy {
-	grbuild := &SprayGroupBy{config: sq.config}
+	sq.ctx.Fields = append([]string{field}, fields...)
-	grbuild.fields = append([]string{field}, fields...)
+	grbuild := &SprayGroupBy{build: sq}
-	grbuild.path = func(ctx context.Context) (prev *sql.Selector, err error) {
+	grbuild.flds = &sq.ctx.Fields
-		if err := sq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		return sq.sqlQuery(ctx), nil
-	}
 	grbuild.label = spray.Label
-	grbuild.flds, grbuild.scan = &grbuild.fields, grbuild.Scan
+	grbuild.scan = grbuild.Scan
 	return grbuild
 }
 
@@ -326,11 +329,11 @@ func (sq *SprayQuery) GroupBy(field string, fields ...string) *SprayGroupBy {
 //		Select(spray.FieldWeapon).
 //		Scan(ctx, &v)
 func (sq *SprayQuery) Select(fields ...string) *SpraySelect {
-	sq.fields = append(sq.fields, fields...)
+	sq.ctx.Fields = append(sq.ctx.Fields, fields...)
-	selbuild := &SpraySelect{SprayQuery: sq}
+	sbuild := &SpraySelect{SprayQuery: sq}
-	selbuild.label = spray.Label
+	sbuild.label = spray.Label
-	selbuild.flds, selbuild.scan = &sq.fields, selbuild.Scan
+	sbuild.flds, sbuild.scan = &sq.ctx.Fields, sbuild.Scan
-	return selbuild
+	return sbuild
 }
 
 // Aggregate returns a SpraySelect configured with the given aggregations.
@@ -339,7 +342,17 @@ func (sq *SprayQuery) Aggregate(fns ...AggregateFunc) *SpraySelect {
 }
 
 func (sq *SprayQuery) prepareQuery(ctx context.Context) error {
-	for _, f := range sq.fields {
+	for _, inter := range sq.inters {
+		if inter == nil {
+			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, sq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range sq.ctx.Fields {
 		if !spray.ValidColumn(f) {
 			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
 		}
@@ -412,6 +425,9 @@ func (sq *SprayQuery) loadMatchPlayers(ctx context.Context, query *MatchPlayerQu
 		}
 		nodeids[fk] = append(nodeids[fk], nodes[i])
 	}
+	if len(ids) == 0 {
+		return nil
+	}
 	query.Where(matchplayer.IDIn(ids...))
 	neighbors, err := query.All(ctx)
 	if err != nil {
@@ -434,41 +450,22 @@ func (sq *SprayQuery) sqlCount(ctx context.Context) (int, error) {
 	if len(sq.modifiers) > 0 {
 		_spec.Modifiers = sq.modifiers
 	}
-	_spec.Node.Columns = sq.fields
+	_spec.Node.Columns = sq.ctx.Fields
-	if len(sq.fields) > 0 {
+	if len(sq.ctx.Fields) > 0 {
-		_spec.Unique = sq.unique != nil && *sq.unique
+		_spec.Unique = sq.ctx.Unique != nil && *sq.ctx.Unique
 	}
 	return sqlgraph.CountNodes(ctx, sq.driver, _spec)
 }
 
-func (sq *SprayQuery) sqlExist(ctx context.Context) (bool, error) {
-	switch _, err := sq.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
 func (sq *SprayQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := &sqlgraph.QuerySpec{
+	_spec := sqlgraph.NewQuerySpec(spray.Table, spray.Columns, sqlgraph.NewFieldSpec(spray.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
+	_spec.From = sq.sql
-			Table:   spray.Table,
+	if unique := sq.ctx.Unique; unique != nil {
-			Columns: spray.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: spray.FieldID,
-			},
-		},
-		From:   sq.sql,
-		Unique: true,
-	}
-	if unique := sq.unique; unique != nil {
 		_spec.Unique = *unique
+	} else if sq.path != nil {
+		_spec.Unique = true
 	}
-	if fields := sq.fields; len(fields) > 0 {
+	if fields := sq.ctx.Fields; len(fields) > 0 {
 		_spec.Node.Columns = make([]string, 0, len(fields))
 		_spec.Node.Columns = append(_spec.Node.Columns, spray.FieldID)
 		for i := range fields {
@@ -484,10 +481,10 @@ func (sq *SprayQuery) querySpec() *sqlgraph.QuerySpec {
 			}
 		}
 	}
-	if limit := sq.limit; limit != nil {
+	if limit := sq.ctx.Limit; limit != nil {
 		_spec.Limit = *limit
 	}
-	if offset := sq.offset; offset != nil {
+	if offset := sq.ctx.Offset; offset != nil {
 		_spec.Offset = *offset
 	}
 	if ps := sq.order; len(ps) > 0 {
@@ -503,7 +500,7 @@ func (sq *SprayQuery) querySpec() *sqlgraph.QuerySpec {
 func (sq *SprayQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	builder := sql.Dialect(sq.driver.Dialect())
 	t1 := builder.Table(spray.Table)
-	columns := sq.fields
+	columns := sq.ctx.Fields
 	if len(columns) == 0 {
 		columns = spray.Columns
 	}
@@ -512,7 +509,7 @@ func (sq *SprayQuery) sqlQuery(ctx context.Context) *sql.Selector {
 		selector = sq.sql
 		selector.Select(selector.Columns(columns...)...)
 	}
-	if sq.unique != nil && *sq.unique {
+	if sq.ctx.Unique != nil && *sq.ctx.Unique {
 		selector.Distinct()
 	}
 	for _, m := range sq.modifiers {
@@ -524,12 +521,12 @@ func (sq *SprayQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	for _, p := range sq.order {
 		p(selector)
 	}
-	if offset := sq.offset; offset != nil {
+	if offset := sq.ctx.Offset; offset != nil {
 		// limit is mandatory for offset clause. We start
 		// with default value, and override it below if needed.
 		selector.Offset(*offset).Limit(math.MaxInt32)
 	}
-	if limit := sq.limit; limit != nil {
+	if limit := sq.ctx.Limit; limit != nil {
 		selector.Limit(*limit)
 	}
 	return selector
@@ -543,13 +540,8 @@ func (sq *SprayQuery) Modify(modifiers ...func(s *sql.Selector)) *SpraySelect {
 
 // SprayGroupBy is the group-by builder for Spray entities.
 type SprayGroupBy struct {
-	config
 	selector
-	fields []string
+	build *SprayQuery
-	fns    []AggregateFunc
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
 }
 
 // Aggregate adds the given aggregation functions to the group-by query.
@@ -558,58 +550,46 @@ func (sgb *SprayGroupBy) Aggregate(fns ...AggregateFunc) *SprayGroupBy {
 	return sgb
 }
 
-// Scan applies the group-by query and scans the result into the given value.
+// Scan applies the selector query and scans the result into the given value.
 func (sgb *SprayGroupBy) Scan(ctx context.Context, v any) error {
-	query, err := sgb.path(ctx)
+	ctx = setContextOp(ctx, sgb.build.ctx, "GroupBy")
-	if err != nil {
+	if err := sgb.build.prepareQuery(ctx); err != nil {
 		return err
 	}
-	sgb.sql = query
+	return scanWithInterceptors[*SprayQuery, *SprayGroupBy](ctx, sgb.build, sgb, sgb.build.inters, v)
-	return sgb.sqlScan(ctx, v)
 }
 
-func (sgb *SprayGroupBy) sqlScan(ctx context.Context, v any) error {
+func (sgb *SprayGroupBy) sqlScan(ctx context.Context, root *SprayQuery, v any) error {
-	for _, f := range sgb.fields {
+	selector := root.sqlQuery(ctx).Select()
-		if !spray.ValidColumn(f) {
+	aggregation := make([]string, 0, len(sgb.fns))
-			return &ValidationError{Name: f, err: fmt.Errorf("invalid field %q for group-by", f)}
+	for _, fn := range sgb.fns {
-		}
+		aggregation = append(aggregation, fn(selector))
 	}
-	selector := sgb.sqlQuery()
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*sgb.flds)+len(sgb.fns))
+		for _, f := range *sgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*sgb.flds...)...)
 	if err := selector.Err(); err != nil {
 		return err
 	}
 	rows := &sql.Rows{}
 	query, args := selector.Query()
-	if err := sgb.driver.Query(ctx, query, args, rows); err != nil {
+	if err := sgb.build.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
 
-func (sgb *SprayGroupBy) sqlQuery() *sql.Selector {
-	selector := sgb.sql.Select()
-	aggregation := make([]string, 0, len(sgb.fns))
-	for _, fn := range sgb.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(sgb.fields)+len(sgb.fns))
-		for _, f := range sgb.fields {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	return selector.GroupBy(selector.Columns(sgb.fields...)...)
-}
-
 // SpraySelect is the builder for selecting fields of Spray entities.
 type SpraySelect struct {
 	*SprayQuery
 	selector
-	// intermediate query (i.e. traversal path).
-	sql *sql.Selector
 }
 
 // Aggregate adds the given aggregation functions to the selector query.
@@ -620,26 +600,27 @@ func (ss *SpraySelect) Aggregate(fns ...AggregateFunc) *SpraySelect {
 
 // Scan applies the selector query and scans the result into the given value.
 func (ss *SpraySelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ss.ctx, "Select")
 	if err := ss.prepareQuery(ctx); err != nil {
 		return err
 	}
-	ss.sql = ss.SprayQuery.sqlQuery(ctx)
+	return scanWithInterceptors[*SprayQuery, *SpraySelect](ctx, ss.SprayQuery, ss, ss.inters, v)
-	return ss.sqlScan(ctx, v)
 }
 
-func (ss *SpraySelect) sqlScan(ctx context.Context, v any) error {
+func (ss *SpraySelect) sqlScan(ctx context.Context, root *SprayQuery, v any) error {
+	selector := root.sqlQuery(ctx)
 	aggregation := make([]string, 0, len(ss.fns))
 	for _, fn := range ss.fns {
-		aggregation = append(aggregation, fn(ss.sql))
+		aggregation = append(aggregation, fn(selector))
 	}
 	switch n := len(*ss.selector.flds); {
 	case n == 0 && len(aggregation) > 0:
-		ss.sql.Select(aggregation...)
+		selector.Select(aggregation...)
 	case n != 0 && len(aggregation) > 0:
-		ss.sql.AppendSelect(aggregation...)
+		selector.AppendSelect(aggregation...)
 	}
 	rows := &sql.Rows{}
-	query, args := ss.sql.Query()
+	query, args := selector.Query()
 	if err := ss.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}

ent/spray_update.go

@@ -80,34 +80,7 @@ func (su *SprayUpdate) ClearMatchPlayers() *SprayUpdate {
 
 // Save executes the query and returns the number of nodes affected by the update operation.
 func (su *SprayUpdate) Save(ctx context.Context) (int, error) {
-	var (
+	return withHooks[int, SprayMutation](ctx, su.sqlSave, su.mutation, su.hooks)
-		err      error
-		affected int
-	)
-	if len(su.hooks) == 0 {
-		affected, err = su.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*SprayMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			su.mutation = mutation
-			affected, err = su.sqlSave(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(su.hooks) - 1; i >= 0; i-- {
-			if su.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = su.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, su.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -139,16 +112,7 @@ func (su *SprayUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *SprayUpd
 }
 
 func (su *SprayUpdate) sqlSave(ctx context.Context) (n int, err error) {
-	_spec := &sqlgraph.UpdateSpec{
+	_spec := sqlgraph.NewUpdateSpec(spray.Table, spray.Columns, sqlgraph.NewFieldSpec(spray.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
-			Table:   spray.Table,
-			Columns: spray.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: spray.FieldID,
-			},
-		},
-	}
 	if ps := su.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -209,6 +173,7 @@ func (su *SprayUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		return 0, err
 	}
+	su.mutation.done = true
 	return n, nil
 }
 
@@ -270,6 +235,12 @@ func (suo *SprayUpdateOne) ClearMatchPlayers() *SprayUpdateOne {
 	return suo
 }
 
+// Where appends a list predicates to the SprayUpdate builder.
+func (suo *SprayUpdateOne) Where(ps ...predicate.Spray) *SprayUpdateOne {
+	suo.mutation.Where(ps...)
+	return suo
+}
+
 // Select allows selecting one or more fields (columns) of the returned entity.
 // The default is selecting all fields defined in the entity schema.
 func (suo *SprayUpdateOne) Select(field string, fields ...string) *SprayUpdateOne {
@@ -279,40 +250,7 @@ func (suo *SprayUpdateOne) Select(field string, fields ...string) *SprayUpdateOn
 
 // Save executes the query and returns the updated Spray entity.
 func (suo *SprayUpdateOne) Save(ctx context.Context) (*Spray, error) {
-	var (
+	return withHooks[*Spray, SprayMutation](ctx, suo.sqlSave, suo.mutation, suo.hooks)
-		err  error
-		node *Spray
-	)
-	if len(suo.hooks) == 0 {
-		node, err = suo.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*SprayMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			suo.mutation = mutation
-			node, err = suo.sqlSave(ctx)
-			mutation.done = true
-			return node, err
-		})
-		for i := len(suo.hooks) - 1; i >= 0; i-- {
-			if suo.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = suo.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, suo.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*Spray)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from SprayMutation", v)
-		}
-		node = nv
-	}
-	return node, err
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -344,16 +282,7 @@ func (suo *SprayUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *Spra
 }
 
 func (suo *SprayUpdateOne) sqlSave(ctx context.Context) (_node *Spray, err error) {
-	_spec := &sqlgraph.UpdateSpec{
+	_spec := sqlgraph.NewUpdateSpec(spray.Table, spray.Columns, sqlgraph.NewFieldSpec(spray.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
-			Table:   spray.Table,
-			Columns: spray.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: spray.FieldID,
-			},
-		},
-	}
 	id, ok := suo.mutation.ID()
 	if !ok {
 		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Spray.id" for update`)}
@@ -434,5 +363,6 @@ func (suo *SprayUpdateOne) sqlSave(ctx context.Context) (_node *Spray, err error
 		}
 		return nil, err
 	}
+	suo.mutation.done = true
 	return _node, nil
 }

ent/weapon.go

@@ -120,14 +120,14 @@ func (w *Weapon) assignValues(columns []string, values []any) error {
 
 // QueryStat queries the "stat" edge of the Weapon entity.
 func (w *Weapon) QueryStat() *MatchPlayerQuery {
-	return (&WeaponClient{config: w.config}).QueryStat(w)
+	return NewWeaponClient(w.config).QueryStat(w)
 }
 
 // Update returns a builder for updating this Weapon.
 // Note that you need to call Weapon.Unwrap() before calling this method if this Weapon
 // was returned from a transaction, and the transaction was committed or rolled back.
 func (w *Weapon) Update() *WeaponUpdateOne {
-	return (&WeaponClient{config: w.config}).UpdateOne(w)
+	return NewWeaponClient(w.config).UpdateOne(w)
 }
 
 // Unwrap unwraps the Weapon entity that was returned from a transaction after it was closed,
@@ -163,9 +163,3 @@ func (w *Weapon) String() string {
 
 // Weapons is a parsable slice of Weapon.
 type Weapons []*Weapon
-
-func (w Weapons) config(cfg config) {
-	for _i := range w {
-		w[_i].config = cfg
-	}
-}

ent/weapon/where.go

@@ -10,357 +10,227 @@ import (
 
 // ID filters vertices based on their ID field.
 func ID(id int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldEQ(FieldID, id))
-		s.Where(sql.EQ(s.C(FieldID), id))
-	})
 }
 
 // IDEQ applies the EQ predicate on the ID field.
 func IDEQ(id int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldEQ(FieldID, id))
-		s.Where(sql.EQ(s.C(FieldID), id))
-	})
 }
 
 // IDNEQ applies the NEQ predicate on the ID field.
 func IDNEQ(id int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldNEQ(FieldID, id))
-		s.Where(sql.NEQ(s.C(FieldID), id))
-	})
 }
 
 // IDIn applies the In predicate on the ID field.
 func IDIn(ids ...int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldIn(FieldID, ids...))
-		v := make([]any, len(ids))
-		for i := range v {
-			v[i] = ids[i]
-		}
-		s.Where(sql.In(s.C(FieldID), v...))
-	})
 }
 
 // IDNotIn applies the NotIn predicate on the ID field.
 func IDNotIn(ids ...int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldNotIn(FieldID, ids...))
-		v := make([]any, len(ids))
-		for i := range v {
-			v[i] = ids[i]
-		}
-		s.Where(sql.NotIn(s.C(FieldID), v...))
-	})
 }
 
 // IDGT applies the GT predicate on the ID field.
 func IDGT(id int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldGT(FieldID, id))
-		s.Where(sql.GT(s.C(FieldID), id))
-	})
 }
 
 // IDGTE applies the GTE predicate on the ID field.
 func IDGTE(id int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldGTE(FieldID, id))
-		s.Where(sql.GTE(s.C(FieldID), id))
-	})
 }
 
 // IDLT applies the LT predicate on the ID field.
 func IDLT(id int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldLT(FieldID, id))
-		s.Where(sql.LT(s.C(FieldID), id))
-	})
 }
 
 // IDLTE applies the LTE predicate on the ID field.
 func IDLTE(id int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldLTE(FieldID, id))
-		s.Where(sql.LTE(s.C(FieldID), id))
-	})
 }
 
 // Victim applies equality check predicate on the "victim" field. It's identical to VictimEQ.
 func Victim(v uint64) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldEQ(FieldVictim, v))
-		s.Where(sql.EQ(s.C(FieldVictim), v))
-	})
 }
 
 // Dmg applies equality check predicate on the "dmg" field. It's identical to DmgEQ.
 func Dmg(v uint) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldEQ(FieldDmg, v))
-		s.Where(sql.EQ(s.C(FieldDmg), v))
-	})
 }
 
 // EqType applies equality check predicate on the "eq_type" field. It's identical to EqTypeEQ.
 func EqType(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldEQ(FieldEqType, v))
-		s.Where(sql.EQ(s.C(FieldEqType), v))
-	})
 }
 
 // HitGroup applies equality check predicate on the "hit_group" field. It's identical to HitGroupEQ.
 func HitGroup(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldEQ(FieldHitGroup, v))
-		s.Where(sql.EQ(s.C(FieldHitGroup), v))
-	})
 }
 
 // VictimEQ applies the EQ predicate on the "victim" field.
 func VictimEQ(v uint64) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldEQ(FieldVictim, v))
-		s.Where(sql.EQ(s.C(FieldVictim), v))
-	})
 }
 
 // VictimNEQ applies the NEQ predicate on the "victim" field.
 func VictimNEQ(v uint64) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldNEQ(FieldVictim, v))
-		s.Where(sql.NEQ(s.C(FieldVictim), v))
-	})
 }
 
 // VictimIn applies the In predicate on the "victim" field.
 func VictimIn(vs ...uint64) predicate.Weapon {
-	v := make([]any, len(vs))
+	return predicate.Weapon(sql.FieldIn(FieldVictim, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldVictim), v...))
-	})
 }
 
 // VictimNotIn applies the NotIn predicate on the "victim" field.
 func VictimNotIn(vs ...uint64) predicate.Weapon {
-	v := make([]any, len(vs))
+	return predicate.Weapon(sql.FieldNotIn(FieldVictim, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldVictim), v...))
-	})
 }
 
 // VictimGT applies the GT predicate on the "victim" field.
 func VictimGT(v uint64) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldGT(FieldVictim, v))
-		s.Where(sql.GT(s.C(FieldVictim), v))
-	})
 }
 
 // VictimGTE applies the GTE predicate on the "victim" field.
 func VictimGTE(v uint64) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldGTE(FieldVictim, v))
-		s.Where(sql.GTE(s.C(FieldVictim), v))
-	})
 }
 
 // VictimLT applies the LT predicate on the "victim" field.
 func VictimLT(v uint64) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldLT(FieldVictim, v))
-		s.Where(sql.LT(s.C(FieldVictim), v))
-	})
 }
 
 // VictimLTE applies the LTE predicate on the "victim" field.
 func VictimLTE(v uint64) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldLTE(FieldVictim, v))
-		s.Where(sql.LTE(s.C(FieldVictim), v))
-	})
 }
 
 // DmgEQ applies the EQ predicate on the "dmg" field.
 func DmgEQ(v uint) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldEQ(FieldDmg, v))
-		s.Where(sql.EQ(s.C(FieldDmg), v))
-	})
 }
 
 // DmgNEQ applies the NEQ predicate on the "dmg" field.
 func DmgNEQ(v uint) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldNEQ(FieldDmg, v))
-		s.Where(sql.NEQ(s.C(FieldDmg), v))
-	})
 }
 
 // DmgIn applies the In predicate on the "dmg" field.
 func DmgIn(vs ...uint) predicate.Weapon {
-	v := make([]any, len(vs))
+	return predicate.Weapon(sql.FieldIn(FieldDmg, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldDmg), v...))
-	})
 }
 
 // DmgNotIn applies the NotIn predicate on the "dmg" field.
 func DmgNotIn(vs ...uint) predicate.Weapon {
-	v := make([]any, len(vs))
+	return predicate.Weapon(sql.FieldNotIn(FieldDmg, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldDmg), v...))
-	})
 }
 
 // DmgGT applies the GT predicate on the "dmg" field.
 func DmgGT(v uint) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldGT(FieldDmg, v))
-		s.Where(sql.GT(s.C(FieldDmg), v))
-	})
 }
 
 // DmgGTE applies the GTE predicate on the "dmg" field.
 func DmgGTE(v uint) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldGTE(FieldDmg, v))
-		s.Where(sql.GTE(s.C(FieldDmg), v))
-	})
 }
 
 // DmgLT applies the LT predicate on the "dmg" field.
 func DmgLT(v uint) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldLT(FieldDmg, v))
-		s.Where(sql.LT(s.C(FieldDmg), v))
-	})
 }
 
 // DmgLTE applies the LTE predicate on the "dmg" field.
 func DmgLTE(v uint) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldLTE(FieldDmg, v))
-		s.Where(sql.LTE(s.C(FieldDmg), v))
-	})
 }
 
 // EqTypeEQ applies the EQ predicate on the "eq_type" field.
 func EqTypeEQ(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldEQ(FieldEqType, v))
-		s.Where(sql.EQ(s.C(FieldEqType), v))
-	})
 }
 
 // EqTypeNEQ applies the NEQ predicate on the "eq_type" field.
 func EqTypeNEQ(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldNEQ(FieldEqType, v))
-		s.Where(sql.NEQ(s.C(FieldEqType), v))
-	})
 }
 
 // EqTypeIn applies the In predicate on the "eq_type" field.
 func EqTypeIn(vs ...int) predicate.Weapon {
-	v := make([]any, len(vs))
+	return predicate.Weapon(sql.FieldIn(FieldEqType, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldEqType), v...))
-	})
 }
 
 // EqTypeNotIn applies the NotIn predicate on the "eq_type" field.
 func EqTypeNotIn(vs ...int) predicate.Weapon {
-	v := make([]any, len(vs))
+	return predicate.Weapon(sql.FieldNotIn(FieldEqType, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldEqType), v...))
-	})
 }
 
 // EqTypeGT applies the GT predicate on the "eq_type" field.
 func EqTypeGT(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldGT(FieldEqType, v))
-		s.Where(sql.GT(s.C(FieldEqType), v))
-	})
 }
 
 // EqTypeGTE applies the GTE predicate on the "eq_type" field.
 func EqTypeGTE(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldGTE(FieldEqType, v))
-		s.Where(sql.GTE(s.C(FieldEqType), v))
-	})
 }
 
 // EqTypeLT applies the LT predicate on the "eq_type" field.
 func EqTypeLT(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldLT(FieldEqType, v))
-		s.Where(sql.LT(s.C(FieldEqType), v))
-	})
 }
 
 // EqTypeLTE applies the LTE predicate on the "eq_type" field.
 func EqTypeLTE(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldLTE(FieldEqType, v))
-		s.Where(sql.LTE(s.C(FieldEqType), v))
-	})
 }
 
 // HitGroupEQ applies the EQ predicate on the "hit_group" field.
 func HitGroupEQ(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldEQ(FieldHitGroup, v))
-		s.Where(sql.EQ(s.C(FieldHitGroup), v))
-	})
 }
 
 // HitGroupNEQ applies the NEQ predicate on the "hit_group" field.
 func HitGroupNEQ(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldNEQ(FieldHitGroup, v))
-		s.Where(sql.NEQ(s.C(FieldHitGroup), v))
-	})
 }
 
 // HitGroupIn applies the In predicate on the "hit_group" field.
 func HitGroupIn(vs ...int) predicate.Weapon {
-	v := make([]any, len(vs))
+	return predicate.Weapon(sql.FieldIn(FieldHitGroup, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.In(s.C(FieldHitGroup), v...))
-	})
 }
 
 // HitGroupNotIn applies the NotIn predicate on the "hit_group" field.
 func HitGroupNotIn(vs ...int) predicate.Weapon {
-	v := make([]any, len(vs))
+	return predicate.Weapon(sql.FieldNotIn(FieldHitGroup, vs...))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.Weapon(func(s *sql.Selector) {
-		s.Where(sql.NotIn(s.C(FieldHitGroup), v...))
-	})
 }
 
 // HitGroupGT applies the GT predicate on the "hit_group" field.
 func HitGroupGT(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldGT(FieldHitGroup, v))
-		s.Where(sql.GT(s.C(FieldHitGroup), v))
-	})
 }
 
 // HitGroupGTE applies the GTE predicate on the "hit_group" field.
 func HitGroupGTE(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldGTE(FieldHitGroup, v))
-		s.Where(sql.GTE(s.C(FieldHitGroup), v))
-	})
 }
 
 // HitGroupLT applies the LT predicate on the "hit_group" field.
 func HitGroupLT(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldLT(FieldHitGroup, v))
-		s.Where(sql.LT(s.C(FieldHitGroup), v))
-	})
 }
 
 // HitGroupLTE applies the LTE predicate on the "hit_group" field.
 func HitGroupLTE(v int) predicate.Weapon {
-	return predicate.Weapon(func(s *sql.Selector) {
+	return predicate.Weapon(sql.FieldLTE(FieldHitGroup, v))
-		s.Where(sql.LTE(s.C(FieldHitGroup), v))
-	})
 }
 
 // HasStat applies the HasEdge predicate on the "stat" edge.
@@ -368,7 +238,6 @@ func HasStat() predicate.Weapon {
 	return predicate.Weapon(func(s *sql.Selector) {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(Table, FieldID),
-			sqlgraph.To(StatTable, FieldID),
 			sqlgraph.Edge(sqlgraph.M2O, true, StatTable, StatColumn),
 		)
 		sqlgraph.HasNeighbors(s, step)

ent/weapon_create.go

@@ -70,49 +70,7 @@ func (wc *WeaponCreate) Mutation() *WeaponMutation {
 
 // Save creates the Weapon in the database.
 func (wc *WeaponCreate) Save(ctx context.Context) (*Weapon, error) {
-	var (
+	return withHooks[*Weapon, WeaponMutation](ctx, wc.sqlSave, wc.mutation, wc.hooks)
-		err  error
-		node *Weapon
-	)
-	if len(wc.hooks) == 0 {
-		if err = wc.check(); err != nil {
-			return nil, err
-		}
-		node, err = wc.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*WeaponMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = wc.check(); err != nil {
-				return nil, err
-			}
-			wc.mutation = mutation
-			if node, err = wc.sqlSave(ctx); err != nil {
-				return nil, err
-			}
-			mutation.id = &node.ID
-			mutation.done = true
-			return node, err
-		})
-		for i := len(wc.hooks) - 1; i >= 0; i-- {
-			if wc.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = wc.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, wc.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*Weapon)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from WeaponMutation", v)
-		}
-		node = nv
-	}
-	return node, err
 }
 
 // SaveX calls Save and panics if Save returns an error.
@@ -155,6 +113,9 @@ func (wc *WeaponCreate) check() error {
 }
 
 func (wc *WeaponCreate) sqlSave(ctx context.Context) (*Weapon, error) {
+	if err := wc.check(); err != nil {
+		return nil, err
+	}
 	_node, _spec := wc.createSpec()
 	if err := sqlgraph.CreateNode(ctx, wc.driver, _spec); err != nil {
 		if sqlgraph.IsConstraintError(err) {
@@ -164,19 +125,15 @@ func (wc *WeaponCreate) sqlSave(ctx context.Context) (*Weapon, error) {
 	}
 	id := _spec.ID.Value.(int64)
 	_node.ID = int(id)
+	wc.mutation.id = &_node.ID
+	wc.mutation.done = true
 	return _node, nil
 }
 
 func (wc *WeaponCreate) createSpec() (*Weapon, *sqlgraph.CreateSpec) {
 	var (
 		_node = &Weapon{config: wc.config}
-		_spec = &sqlgraph.CreateSpec{
+		_spec = sqlgraph.NewCreateSpec(weapon.Table, sqlgraph.NewFieldSpec(weapon.FieldID, field.TypeInt))
-			Table: weapon.Table,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: weapon.FieldID,
-			},
-		}
 	)
 	if value, ok := wc.mutation.Victim(); ok {
 		_spec.SetField(weapon.FieldVictim, field.TypeUint64, value)

ent/weapon_delete.go

@@ -4,7 +4,6 @@ package ent
 
 import (
 	"context"
-	"fmt"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -28,34 +27,7 @@ func (wd *WeaponDelete) Where(ps ...predicate.Weapon) *WeaponDelete {
 
 // Exec executes the deletion query and returns how many vertices were deleted.
 func (wd *WeaponDelete) Exec(ctx context.Context) (int, error) {
-	var (
+	return withHooks[int, WeaponMutation](ctx, wd.sqlExec, wd.mutation, wd.hooks)
-		err      error
-		affected int
-	)
-	if len(wd.hooks) == 0 {
-		affected, err = wd.sqlExec(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*WeaponMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			wd.mutation = mutation
-			affected, err = wd.sqlExec(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(wd.hooks) - 1; i >= 0; i-- {
-			if wd.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = wd.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, wd.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
 }
 
 // ExecX is like Exec, but panics if an error occurs.
@@ -68,15 +40,7 @@ func (wd *WeaponDelete) ExecX(ctx context.Context) int {
 }
 
 func (wd *WeaponDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := &sqlgraph.DeleteSpec{
+	_spec := sqlgraph.NewDeleteSpec(weapon.Table, sqlgraph.NewFieldSpec(weapon.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
-			Table: weapon.Table,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: weapon.FieldID,
-			},
-		},
-	}
 	if ps := wd.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -88,6 +52,7 @@ func (wd *WeaponDelete) sqlExec(ctx context.Context) (int, error) {
 	if err != nil && sqlgraph.IsConstraintError(err) {
 		err = &ConstraintError{msg: err.Error(), wrap: err}
 	}
+	wd.mutation.done = true
 	return affected, err
 }
 
@@ -96,6 +61,12 @@ type WeaponDeleteOne struct {
 	wd *WeaponDelete
 }
 
+// Where appends a list predicates to the WeaponDelete builder.
+func (wdo *WeaponDeleteOne) Where(ps ...predicate.Weapon) *WeaponDeleteOne {
+	wdo.wd.mutation.Where(ps...)
+	return wdo
+}
+
 // Exec executes the deletion query.
 func (wdo *WeaponDeleteOne) Exec(ctx context.Context) error {
 	n, err := wdo.wd.Exec(ctx)
@@ -111,5 +82,7 @@ func (wdo *WeaponDeleteOne) Exec(ctx context.Context) error {
 
 // ExecX is like Exec, but panics if an error occurs.
 func (wdo *WeaponDeleteOne) ExecX(ctx context.Context) {
-	wdo.wd.ExecX(ctx)
+	if err := wdo.Exec(ctx); err != nil {
+		panic(err)
+	}
 }

ent/weapon_query.go

@@ -18,11 +18,9 @@ import (
 // WeaponQuery is the builder for querying Weapon entities.
 type WeaponQuery struct {
 	config
-	limit      *int
+	ctx        *QueryContext
-	offset     *int
-	unique     *bool
 	order      []OrderFunc
-	fields     []string
+	inters     []Interceptor
 	predicates []predicate.Weapon
 	withStat   *MatchPlayerQuery
 	withFKs    bool
@@ -38,26 +36,26 @@ func (wq *WeaponQuery) Where(ps ...predicate.Weapon) *WeaponQuery {
 	return wq
 }
 
-// Limit adds a limit step to the query.
+// Limit the number of records to be returned by this query.
 func (wq *WeaponQuery) Limit(limit int) *WeaponQuery {
-	wq.limit = &limit
+	wq.ctx.Limit = &limit
 	return wq
 }
 
-// Offset adds an offset step to the query.
+// Offset to start from.
 func (wq *WeaponQuery) Offset(offset int) *WeaponQuery {
-	wq.offset = &offset
+	wq.ctx.Offset = &offset
 	return wq
 }
 
 // Unique configures the query builder to filter duplicate records on query.
 // By default, unique is set to true, and can be disabled using this method.
 func (wq *WeaponQuery) Unique(unique bool) *WeaponQuery {
-	wq.unique = &unique
+	wq.ctx.Unique = &unique
 	return wq
 }
 
-// Order adds an order step to the query.
+// Order specifies how the records should be ordered.
 func (wq *WeaponQuery) Order(o ...OrderFunc) *WeaponQuery {
 	wq.order = append(wq.order, o...)
 	return wq
@@ -65,7 +63,7 @@ func (wq *WeaponQuery) Order(o ...OrderFunc) *WeaponQuery {
 
 // QueryStat chains the current query on the "stat" edge.
 func (wq *WeaponQuery) QueryStat() *MatchPlayerQuery {
-	query := &MatchPlayerQuery{config: wq.config}
+	query := (&MatchPlayerClient{config: wq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := wq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -88,7 +86,7 @@ func (wq *WeaponQuery) QueryStat() *MatchPlayerQuery {
 // First returns the first Weapon entity from the query.
 // Returns a *NotFoundError when no Weapon was found.
 func (wq *WeaponQuery) First(ctx context.Context) (*Weapon, error) {
-	nodes, err := wq.Limit(1).All(ctx)
+	nodes, err := wq.Limit(1).All(setContextOp(ctx, wq.ctx, "First"))
 	if err != nil {
 		return nil, err
 	}
@@ -111,7 +109,7 @@ func (wq *WeaponQuery) FirstX(ctx context.Context) *Weapon {
 // Returns a *NotFoundError when no Weapon ID was found.
 func (wq *WeaponQuery) FirstID(ctx context.Context) (id int, err error) {
 	var ids []int
-	if ids, err = wq.Limit(1).IDs(ctx); err != nil {
+	if ids, err = wq.Limit(1).IDs(setContextOp(ctx, wq.ctx, "FirstID")); err != nil {
 		return
 	}
 	if len(ids) == 0 {
@@ -134,7 +132,7 @@ func (wq *WeaponQuery) FirstIDX(ctx context.Context) int {
 // Returns a *NotSingularError when more than one Weapon entity is found.
 // Returns a *NotFoundError when no Weapon entities are found.
 func (wq *WeaponQuery) Only(ctx context.Context) (*Weapon, error) {
-	nodes, err := wq.Limit(2).All(ctx)
+	nodes, err := wq.Limit(2).All(setContextOp(ctx, wq.ctx, "Only"))
 	if err != nil {
 		return nil, err
 	}
@@ -162,7 +160,7 @@ func (wq *WeaponQuery) OnlyX(ctx context.Context) *Weapon {
 // Returns a *NotFoundError when no entities are found.
 func (wq *WeaponQuery) OnlyID(ctx context.Context) (id int, err error) {
 	var ids []int
-	if ids, err = wq.Limit(2).IDs(ctx); err != nil {
+	if ids, err = wq.Limit(2).IDs(setContextOp(ctx, wq.ctx, "OnlyID")); err != nil {
 		return
 	}
 	switch len(ids) {
@@ -187,10 +185,12 @@ func (wq *WeaponQuery) OnlyIDX(ctx context.Context) int {
 
 // All executes the query and returns a list of Weapons.
 func (wq *WeaponQuery) All(ctx context.Context) ([]*Weapon, error) {
+	ctx = setContextOp(ctx, wq.ctx, "All")
 	if err := wq.prepareQuery(ctx); err != nil {
 		return nil, err
 	}
-	return wq.sqlAll(ctx)
+	qr := querierAll[[]*Weapon, *WeaponQuery]()
+	return withInterceptors[[]*Weapon](ctx, wq, qr, wq.inters)
 }
 
 // AllX is like All, but panics if an error occurs.
@@ -203,9 +203,12 @@ func (wq *WeaponQuery) AllX(ctx context.Context) []*Weapon {
 }
 
 // IDs executes the query and returns a list of Weapon IDs.
-func (wq *WeaponQuery) IDs(ctx context.Context) ([]int, error) {
+func (wq *WeaponQuery) IDs(ctx context.Context) (ids []int, err error) {
-	var ids []int
+	if wq.ctx.Unique == nil && wq.path != nil {
-	if err := wq.Select(weapon.FieldID).Scan(ctx, &ids); err != nil {
+		wq.Unique(true)
+	}
+	ctx = setContextOp(ctx, wq.ctx, "IDs")
+	if err = wq.Select(weapon.FieldID).Scan(ctx, &ids); err != nil {
 		return nil, err
 	}
 	return ids, nil
@@ -222,10 +225,11 @@ func (wq *WeaponQuery) IDsX(ctx context.Context) []int {
 
 // Count returns the count of the given query.
 func (wq *WeaponQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, wq.ctx, "Count")
 	if err := wq.prepareQuery(ctx); err != nil {
 		return 0, err
 	}
-	return wq.sqlCount(ctx)
+	return withInterceptors[int](ctx, wq, querierCount[*WeaponQuery](), wq.inters)
 }
 
 // CountX is like Count, but panics if an error occurs.
@@ -239,10 +243,15 @@ func (wq *WeaponQuery) CountX(ctx context.Context) int {
 
 // Exist returns true if the query has elements in the graph.
 func (wq *WeaponQuery) Exist(ctx context.Context) (bool, error) {
-	if err := wq.prepareQuery(ctx); err != nil {
+	ctx = setContextOp(ctx, wq.ctx, "Exist")
-		return false, err
+	switch _, err := wq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("ent: check existence: %w", err)
+	default:
+		return true, nil
 	}
-	return wq.sqlExist(ctx)
 }
 
 // ExistX is like Exist, but panics if an error occurs.
@@ -262,22 +271,21 @@ func (wq *WeaponQuery) Clone() *WeaponQuery {
 	}
 	return &WeaponQuery{
 		config:     wq.config,
-		limit:      wq.limit,
+		ctx:        wq.ctx.Clone(),
-		offset:     wq.offset,
 		order:      append([]OrderFunc{}, wq.order...),
+		inters:     append([]Interceptor{}, wq.inters...),
 		predicates: append([]predicate.Weapon{}, wq.predicates...),
 		withStat:   wq.withStat.Clone(),
 		// clone intermediate query.
-		sql:    wq.sql.Clone(),
+		sql:  wq.sql.Clone(),
-		path:   wq.path,
+		path: wq.path,
-		unique: wq.unique,
 	}
 }
 
 // WithStat tells the query-builder to eager-load the nodes that are connected to
 // the "stat" edge. The optional arguments are used to configure the query builder of the edge.
 func (wq *WeaponQuery) WithStat(opts ...func(*MatchPlayerQuery)) *WeaponQuery {
-	query := &MatchPlayerQuery{config: wq.config}
+	query := (&MatchPlayerClient{config: wq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -300,16 +308,11 @@ func (wq *WeaponQuery) WithStat(opts ...func(*MatchPlayerQuery)) *WeaponQuery {
 //		Aggregate(ent.Count()).
 //		Scan(ctx, &v)
 func (wq *WeaponQuery) GroupBy(field string, fields ...string) *WeaponGroupBy {
-	grbuild := &WeaponGroupBy{config: wq.config}
+	wq.ctx.Fields = append([]string{field}, fields...)
-	grbuild.fields = append([]string{field}, fields...)
+	grbuild := &WeaponGroupBy{build: wq}
-	grbuild.path = func(ctx context.Context) (prev *sql.Selector, err error) {
+	grbuild.flds = &wq.ctx.Fields
-		if err := wq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		return wq.sqlQuery(ctx), nil
-	}
 	grbuild.label = weapon.Label
-	grbuild.flds, grbuild.scan = &grbuild.fields, grbuild.Scan
+	grbuild.scan = grbuild.Scan
 	return grbuild
 }
 
@@ -326,11 +329,11 @@ func (wq *WeaponQuery) GroupBy(field string, fields ...string) *WeaponGroupBy {
 //		Select(weapon.FieldVictim).
 //		Scan(ctx, &v)
 func (wq *WeaponQuery) Select(fields ...string) *WeaponSelect {
-	wq.fields = append(wq.fields, fields...)
+	wq.ctx.Fields = append(wq.ctx.Fields, fields...)
-	selbuild := &WeaponSelect{WeaponQuery: wq}
+	sbuild := &WeaponSelect{WeaponQuery: wq}
-	selbuild.label = weapon.Label
+	sbuild.label = weapon.Label
-	selbuild.flds, selbuild.scan = &wq.fields, selbuild.Scan
+	sbuild.flds, sbuild.scan = &wq.ctx.Fields, sbuild.Scan
-	return selbuild
+	return sbuild
 }
 
 // Aggregate returns a WeaponSelect configured with the given aggregations.
@@ -339,7 +342,17 @@ func (wq *WeaponQuery) Aggregate(fns ...AggregateFunc) *WeaponSelect {
 }
 
 func (wq *WeaponQuery) prepareQuery(ctx context.Context) error {
-	for _, f := range wq.fields {
+	for _, inter := range wq.inters {
+		if inter == nil {
+			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, wq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range wq.ctx.Fields {
 		if !weapon.ValidColumn(f) {
 			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
 		}
@@ -412,6 +425,9 @@ func (wq *WeaponQuery) loadStat(ctx context.Context, query *MatchPlayerQuery, no
 		}
 		nodeids[fk] = append(nodeids[fk], nodes[i])
 	}
+	if len(ids) == 0 {
+		return nil
+	}
 	query.Where(matchplayer.IDIn(ids...))
 	neighbors, err := query.All(ctx)
 	if err != nil {
@@ -434,41 +450,22 @@ func (wq *WeaponQuery) sqlCount(ctx context.Context) (int, error) {
 	if len(wq.modifiers) > 0 {
 		_spec.Modifiers = wq.modifiers
 	}
-	_spec.Node.Columns = wq.fields
+	_spec.Node.Columns = wq.ctx.Fields
-	if len(wq.fields) > 0 {
+	if len(wq.ctx.Fields) > 0 {
-		_spec.Unique = wq.unique != nil && *wq.unique
+		_spec.Unique = wq.ctx.Unique != nil && *wq.ctx.Unique
 	}
 	return sqlgraph.CountNodes(ctx, wq.driver, _spec)
 }
 
-func (wq *WeaponQuery) sqlExist(ctx context.Context) (bool, error) {
-	switch _, err := wq.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
 func (wq *WeaponQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := &sqlgraph.QuerySpec{
+	_spec := sqlgraph.NewQuerySpec(weapon.Table, weapon.Columns, sqlgraph.NewFieldSpec(weapon.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
+	_spec.From = wq.sql
-			Table:   weapon.Table,
+	if unique := wq.ctx.Unique; unique != nil {
-			Columns: weapon.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: weapon.FieldID,
-			},
-		},
-		From:   wq.sql,
-		Unique: true,
-	}
-	if unique := wq.unique; unique != nil {
 		_spec.Unique = *unique
+	} else if wq.path != nil {
+		_spec.Unique = true
 	}
-	if fields := wq.fields; len(fields) > 0 {
+	if fields := wq.ctx.Fields; len(fields) > 0 {
 		_spec.Node.Columns = make([]string, 0, len(fields))
 		_spec.Node.Columns = append(_spec.Node.Columns, weapon.FieldID)
 		for i := range fields {
@@ -484,10 +481,10 @@ func (wq *WeaponQuery) querySpec() *sqlgraph.QuerySpec {
 			}
 		}
 	}
-	if limit := wq.limit; limit != nil {
+	if limit := wq.ctx.Limit; limit != nil {
 		_spec.Limit = *limit
 	}
-	if offset := wq.offset; offset != nil {
+	if offset := wq.ctx.Offset; offset != nil {
 		_spec.Offset = *offset
 	}
 	if ps := wq.order; len(ps) > 0 {
@@ -503,7 +500,7 @@ func (wq *WeaponQuery) querySpec() *sqlgraph.QuerySpec {
 func (wq *WeaponQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	builder := sql.Dialect(wq.driver.Dialect())
 	t1 := builder.Table(weapon.Table)
-	columns := wq.fields
+	columns := wq.ctx.Fields
 	if len(columns) == 0 {
 		columns = weapon.Columns
 	}
@@ -512,7 +509,7 @@ func (wq *WeaponQuery) sqlQuery(ctx context.Context) *sql.Selector {
 		selector = wq.sql
 		selector.Select(selector.Columns(columns...)...)
 	}
-	if wq.unique != nil && *wq.unique {
+	if wq.ctx.Unique != nil && *wq.ctx.Unique {
 		selector.Distinct()
 	}
 	for _, m := range wq.modifiers {
@@ -524,12 +521,12 @@ func (wq *WeaponQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	for _, p := range wq.order {
 		p(selector)
 	}
-	if offset := wq.offset; offset != nil {
+	if offset := wq.ctx.Offset; offset != nil {
 		// limit is mandatory for offset clause. We start
 		// with default value, and override it below if needed.
 		selector.Offset(*offset).Limit(math.MaxInt32)
 	}
-	if limit := wq.limit; limit != nil {
+	if limit := wq.ctx.Limit; limit != nil {
 		selector.Limit(*limit)
 	}
 	return selector
@@ -543,13 +540,8 @@ func (wq *WeaponQuery) Modify(modifiers ...func(s *sql.Selector)) *WeaponSelect
 
 // WeaponGroupBy is the group-by builder for Weapon entities.
 type WeaponGroupBy struct {
-	config
 	selector
-	fields []string
+	build *WeaponQuery
-	fns    []AggregateFunc
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
 }
 
 // Aggregate adds the given aggregation functions to the group-by query.
@@ -558,58 +550,46 @@ func (wgb *WeaponGroupBy) Aggregate(fns ...AggregateFunc) *WeaponGroupBy {
 	return wgb
 }
 
-// Scan applies the group-by query and scans the result into the given value.
+// Scan applies the selector query and scans the result into the given value.
 func (wgb *WeaponGroupBy) Scan(ctx context.Context, v any) error {
-	query, err := wgb.path(ctx)
+	ctx = setContextOp(ctx, wgb.build.ctx, "GroupBy")
-	if err != nil {
+	if err := wgb.build.prepareQuery(ctx); err != nil {
 		return err
 	}
-	wgb.sql = query
+	return scanWithInterceptors[*WeaponQuery, *WeaponGroupBy](ctx, wgb.build, wgb, wgb.build.inters, v)
-	return wgb.sqlScan(ctx, v)
 }
 
-func (wgb *WeaponGroupBy) sqlScan(ctx context.Context, v any) error {
+func (wgb *WeaponGroupBy) sqlScan(ctx context.Context, root *WeaponQuery, v any) error {
-	for _, f := range wgb.fields {
+	selector := root.sqlQuery(ctx).Select()
-		if !weapon.ValidColumn(f) {
+	aggregation := make([]string, 0, len(wgb.fns))
-			return &ValidationError{Name: f, err: fmt.Errorf("invalid field %q for group-by", f)}
+	for _, fn := range wgb.fns {
-		}
+		aggregation = append(aggregation, fn(selector))
 	}
-	selector := wgb.sqlQuery()
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*wgb.flds)+len(wgb.fns))
+		for _, f := range *wgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*wgb.flds...)...)
 	if err := selector.Err(); err != nil {
 		return err
 	}
 	rows := &sql.Rows{}
 	query, args := selector.Query()
-	if err := wgb.driver.Query(ctx, query, args, rows); err != nil {
+	if err := wgb.build.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
 
-func (wgb *WeaponGroupBy) sqlQuery() *sql.Selector {
-	selector := wgb.sql.Select()
-	aggregation := make([]string, 0, len(wgb.fns))
-	for _, fn := range wgb.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(wgb.fields)+len(wgb.fns))
-		for _, f := range wgb.fields {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	return selector.GroupBy(selector.Columns(wgb.fields...)...)
-}
-
 // WeaponSelect is the builder for selecting fields of Weapon entities.
 type WeaponSelect struct {
 	*WeaponQuery
 	selector
-	// intermediate query (i.e. traversal path).
-	sql *sql.Selector
 }
 
 // Aggregate adds the given aggregation functions to the selector query.
@@ -620,26 +600,27 @@ func (ws *WeaponSelect) Aggregate(fns ...AggregateFunc) *WeaponSelect {
 
 // Scan applies the selector query and scans the result into the given value.
 func (ws *WeaponSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ws.ctx, "Select")
 	if err := ws.prepareQuery(ctx); err != nil {
 		return err
 	}
-	ws.sql = ws.WeaponQuery.sqlQuery(ctx)
+	return scanWithInterceptors[*WeaponQuery, *WeaponSelect](ctx, ws.WeaponQuery, ws, ws.inters, v)
-	return ws.sqlScan(ctx, v)
 }
 
-func (ws *WeaponSelect) sqlScan(ctx context.Context, v any) error {
+func (ws *WeaponSelect) sqlScan(ctx context.Context, root *WeaponQuery, v any) error {
+	selector := root.sqlQuery(ctx)
 	aggregation := make([]string, 0, len(ws.fns))
 	for _, fn := range ws.fns {
-		aggregation = append(aggregation, fn(ws.sql))
+		aggregation = append(aggregation, fn(selector))
 	}
 	switch n := len(*ws.selector.flds); {
 	case n == 0 && len(aggregation) > 0:
-		ws.sql.Select(aggregation...)
+		selector.Select(aggregation...)
 	case n != 0 && len(aggregation) > 0:
-		ws.sql.AppendSelect(aggregation...)
+		selector.AppendSelect(aggregation...)
 	}
 	rows := &sql.Rows{}
-	query, args := ws.sql.Query()
+	query, args := selector.Query()
 	if err := ws.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}

ent/weapon_update.go

@@ -113,34 +113,7 @@ func (wu *WeaponUpdate) ClearStat() *WeaponUpdate {
 
 // Save executes the query and returns the number of nodes affected by the update operation.
 func (wu *WeaponUpdate) Save(ctx context.Context) (int, error) {
-	var (
+	return withHooks[int, WeaponMutation](ctx, wu.sqlSave, wu.mutation, wu.hooks)
-		err      error
-		affected int
-	)
-	if len(wu.hooks) == 0 {
-		affected, err = wu.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*WeaponMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			wu.mutation = mutation
-			affected, err = wu.sqlSave(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(wu.hooks) - 1; i >= 0; i-- {
-			if wu.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = wu.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, wu.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -172,16 +145,7 @@ func (wu *WeaponUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *WeaponU
 }
 
 func (wu *WeaponUpdate) sqlSave(ctx context.Context) (n int, err error) {
-	_spec := &sqlgraph.UpdateSpec{
+	_spec := sqlgraph.NewUpdateSpec(weapon.Table, weapon.Columns, sqlgraph.NewFieldSpec(weapon.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
-			Table:   weapon.Table,
-			Columns: weapon.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: weapon.FieldID,
-			},
-		},
-	}
 	if ps := wu.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -257,6 +221,7 @@ func (wu *WeaponUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		return 0, err
 	}
+	wu.mutation.done = true
 	return n, nil
 }
 
@@ -351,6 +316,12 @@ func (wuo *WeaponUpdateOne) ClearStat() *WeaponUpdateOne {
 	return wuo
 }
 
+// Where appends a list predicates to the WeaponUpdate builder.
+func (wuo *WeaponUpdateOne) Where(ps ...predicate.Weapon) *WeaponUpdateOne {
+	wuo.mutation.Where(ps...)
+	return wuo
+}
+
 // Select allows selecting one or more fields (columns) of the returned entity.
 // The default is selecting all fields defined in the entity schema.
 func (wuo *WeaponUpdateOne) Select(field string, fields ...string) *WeaponUpdateOne {
@@ -360,40 +331,7 @@ func (wuo *WeaponUpdateOne) Select(field string, fields ...string) *WeaponUpdate
 
 // Save executes the query and returns the updated Weapon entity.
 func (wuo *WeaponUpdateOne) Save(ctx context.Context) (*Weapon, error) {
-	var (
+	return withHooks[*Weapon, WeaponMutation](ctx, wuo.sqlSave, wuo.mutation, wuo.hooks)
-		err  error
-		node *Weapon
-	)
-	if len(wuo.hooks) == 0 {
-		node, err = wuo.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*WeaponMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			wuo.mutation = mutation
-			node, err = wuo.sqlSave(ctx)
-			mutation.done = true
-			return node, err
-		})
-		for i := len(wuo.hooks) - 1; i >= 0; i-- {
-			if wuo.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = wuo.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, wuo.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*Weapon)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from WeaponMutation", v)
-		}
-		node = nv
-	}
-	return node, err
 }
 
 // SaveX is like Save, but panics if an error occurs.
@@ -425,16 +363,7 @@ func (wuo *WeaponUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *Wea
 }
 
 func (wuo *WeaponUpdateOne) sqlSave(ctx context.Context) (_node *Weapon, err error) {
-	_spec := &sqlgraph.UpdateSpec{
+	_spec := sqlgraph.NewUpdateSpec(weapon.Table, weapon.Columns, sqlgraph.NewFieldSpec(weapon.FieldID, field.TypeInt))
-		Node: &sqlgraph.NodeSpec{
-			Table:   weapon.Table,
-			Columns: weapon.Columns,
-			ID: &sqlgraph.FieldSpec{
-				Type:   field.TypeInt,
-				Column: weapon.FieldID,
-			},
-		},
-	}
 	id, ok := wuo.mutation.ID()
 	if !ok {
 		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Weapon.id" for update`)}
@@ -530,5 +459,6 @@ func (wuo *WeaponUpdateOne) sqlSave(ctx context.Context) (_node *Weapon, err err
 		}
 		return nil, err
 	}
+	wuo.mutation.done = true
 	return _node, nil
 }

go.mod

@@ -3,75 +3,79 @@ module git.harting.dev/csgowtf/csgowtfd
 go 1.18
 
 require (
-	entgo.io/ent v0.11.4
+	entgo.io/ent v0.11.9
 	github.com/aclements/go-moremath v0.0.0-20210112150236-f10218a38794
 	github.com/an0nfunc/go-steam/v3 v3.0.6
 	github.com/an0nfunc/go-steamapi v1.1.0
 	github.com/gin-contrib/cors v1.4.0
-	github.com/gin-gonic/gin v1.8.2
+	github.com/gin-gonic/gin v1.9.0
 	github.com/go-redis/cache/v8 v8.4.4
 	github.com/go-redis/redis/v8 v8.11.5
 	github.com/golang/geo v0.0.0-20210211234256-740aa86cb551
-	github.com/jackc/pgx/v4 v4.17.2
+	github.com/jackc/pgx/v4 v4.18.1
-	github.com/markus-wa/demoinfocs-golang/v3 v3.1.0
+	github.com/markus-wa/demoinfocs-golang/v3 v3.3.0
 	github.com/pkg/errors v0.9.1
-	github.com/sabloger/sitemap-generator v1.2.1
 	github.com/sethvargo/go-retry v0.2.4
 	github.com/sirupsen/logrus v1.9.0
 	github.com/wercker/journalhook v0.0.0-20180428041537-5d0a5ae867b3
-	golang.org/x/text v0.5.0
+	golang.org/x/text v0.7.0
 	golang.org/x/time v0.3.0
 	google.golang.org/protobuf v1.28.1
 	gopkg.in/yaml.v3 v3.0.1
+	somegit.dev/anonfunc/gositemap v0.1.0
 )
 
 require (
-	ariga.io/atlas v0.8.3 // indirect
+	ariga.io/atlas v0.9.1 // indirect
 	github.com/agext/levenshtein v1.2.3 // indirect
 	github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect
+	github.com/bytedance/sonic v1.8.3 // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
 	github.com/coreos/go-systemd v0.0.0-20191104093116-d3cd4ed1dbcf // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/fsnotify/fsnotify v1.5.1 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
 	github.com/go-openapi/inflect v0.19.0 // indirect
-	github.com/go-playground/locales v0.14.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
-	github.com/go-playground/universal-translator v0.18.0 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.11.1 // indirect
+	github.com/go-playground/validator/v10 v10.11.2 // indirect
 	github.com/goccy/go-json v0.10.0 // indirect
 	github.com/google/go-cmp v0.5.9 // indirect
 	github.com/google/uuid v1.3.0 // indirect
-	github.com/hashicorp/hcl/v2 v2.15.0 // indirect
+	github.com/hashicorp/hcl/v2 v2.16.1 // indirect
 	github.com/jackc/chunkreader/v2 v2.0.1 // indirect
-	github.com/jackc/pgconn v1.13.0 // indirect
+	github.com/jackc/pgconn v1.14.0 // indirect
 	github.com/jackc/pgio v1.0.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
-	github.com/jackc/pgproto3/v2 v2.3.1 // indirect
+	github.com/jackc/pgproto3/v2 v2.3.2 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
-	github.com/jackc/pgtype v1.13.0 // indirect
+	github.com/jackc/pgtype v1.14.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/compress v1.15.13 // indirect
+	github.com/klauspost/compress v1.16.0 // indirect
-	github.com/leodido/go-urn v1.2.1 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
-	github.com/markus-wa/go-unassert v0.1.2 // indirect
+	github.com/leodido/go-urn v1.2.2 // indirect
+	github.com/markus-wa/go-unassert v0.1.3 // indirect
 	github.com/markus-wa/gobitread v0.2.3 // indirect
 	github.com/markus-wa/godispatch v1.4.1 // indirect
 	github.com/markus-wa/ice-cipher-go v0.0.0-20220823210642-1fcccd18c6c1 // indirect
-	github.com/markus-wa/quickhull-go/v2 v2.1.0 // indirect
+	github.com/markus-wa/quickhull-go/v2 v2.2.0 // indirect
 	github.com/mattn/go-isatty v0.0.17 // indirect
 	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/oklog/ulid/v2 v2.1.0 // indirect
-	github.com/pelletier/go-toml/v2 v2.0.6 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.7 // indirect
-	github.com/ugorji/go/codec v1.2.8 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.10 // indirect
 	github.com/vmihailenco/go-tinylfu v0.2.2 // indirect
 	github.com/vmihailenco/msgpack/v5 v5.3.5 // indirect
 	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
-	github.com/zclconf/go-cty v1.12.1 // indirect
+	github.com/zclconf/go-cty v1.13.0 // indirect
-	golang.org/x/crypto v0.4.0 // indirect
+	golang.org/x/arch v0.2.0 // indirect
-	golang.org/x/mod v0.7.0 // indirect
+	golang.org/x/crypto v0.6.0 // indirect
-	golang.org/x/net v0.4.0 // indirect
+	golang.org/x/mod v0.8.0 // indirect
+	golang.org/x/net v0.7.0 // indirect
 	golang.org/x/sync v0.1.0 // indirect
-	golang.org/x/sys v0.3.0 // indirect
+	golang.org/x/sys v0.5.0 // indirect
-	gopkg.in/yaml.v2 v2.4.0 // indirect
 )

go.sum

@@ -1,7 +1,7 @@
-ariga.io/atlas v0.8.3 h1:nddOywkhr/62Cwa+UsGgO35lAhUYh52XGVsbFwGzWZM=
+ariga.io/atlas v0.9.1 h1:EpoPMnwsQG0vn9c0sYExpwSYtr7bvuSUXzQclU2pMjc=
-ariga.io/atlas v0.8.3/go.mod h1:T230JFcENj4ZZzMkZrXFDSkv+2kXkUgpJ5FQQ5hMcKU=
+ariga.io/atlas v0.9.1/go.mod h1:T230JFcENj4ZZzMkZrXFDSkv+2kXkUgpJ5FQQ5hMcKU=
-entgo.io/ent v0.11.4 h1:grwVY0fp31BZ6oEo3YrXenAuv8VJmEw7F/Bi6WqeH3Q=
+entgo.io/ent v0.11.9 h1:dbbCkAiPVTRBIJwoZctiSYjB7zxQIBOzVSU5H9VYIQI=
-entgo.io/ent v0.11.4/go.mod h1:fnQIXL36RYnCk/9nvG4aE7YHBFZhCycfh7wMjY5p7SE=
+entgo.io/ent v0.11.9/go.mod h1:KWHOcDZn1xk3mz3ipWdKrQpMvwqa/9B69TUuAPP9W6g=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
 github.com/Masterminds/semver/v3 v3.1.1 h1:hLg3sBzpNErnxhQtUy/mmLR2I9foDujNK030IGemrRc=
@@ -16,10 +16,16 @@ github.com/an0nfunc/go-steamapi v1.1.0 h1:sBOSAKO0zEmzKrkMX2bVhoFiErA+Gyx9hRl+7B
 github.com/an0nfunc/go-steamapi v1.1.0/go.mod h1:tInHdrGkh0gaXuPnvhMG4BoW9S5gVcWOY9gJ9gCBKOI=
 github.com/apparentlymart/go-textseg/v13 v13.0.0 h1:Y+KvPE1NYz0xl601PVImeQfFyEy6iT90AvPUL1NNfNw=
 github.com/apparentlymart/go-textseg/v13 v13.0.0/go.mod h1:ZK2fH7c4NqDTLtiYLvIkEghdlcqw7yxLeM89kiTRPUo=
+github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
+github.com/bytedance/sonic v1.8.3 h1:pf6fGl5eqWYKkx1RcD4qpuX+BIUaduv/wTm5ekWJ80M=
+github.com/bytedance/sonic v1.8.3/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
 github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
 github.com/cockroachdb/apd v1.1.0 h1:3LFP3629v+1aKXU5Q37mxmRxX/pIu1nijXydLShEq5I=
 github.com/cockroachdb/apd v1.1.0/go.mod h1:8Sl8LxpKi29FqWXR16WEFZRNSz3SoPzUzeMeY4+DwBQ=
 github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
@@ -42,21 +48,23 @@ github.com/gin-contrib/cors v1.4.0/go.mod h1:bs9pNM0x/UsmHPBWT2xZz9ROh8xYjYkiURU
 github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 github.com/gin-gonic/gin v1.8.1/go.mod h1:ji8BvRH1azfM+SYow9zQ6SZMvR8qOMZHmsCuWR9tTTk=
-github.com/gin-gonic/gin v1.8.2 h1:UzKToD9/PoFj/V4rvlKqTRKnQYyz8Sc1MJlv4JHPtvY=
+github.com/gin-gonic/gin v1.9.0 h1:OjyFBKICoexlu99ctXNR2gg+c5pKrKMuyjgARg9qeY8=
-github.com/gin-gonic/gin v1.8.2/go.mod h1:qw5AYuDrzRTnhvusDsrov+fDIxp9Dleuu12h8nfB398=
+github.com/gin-gonic/gin v1.9.0/go.mod h1:W1Me9+hsUSyj3CePGrd1/QrKJMSJ1Tu/0hFEH89961k=
 github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
 github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
 github.com/go-openapi/inflect v0.19.0 h1:9jCH9scKIbHeV9m12SmPilScz6krDxKRasNNSNPXu/4=
 github.com/go-openapi/inflect v0.19.0/go.mod h1:lHpZVlpIQqLyKwJ4N+YSc9hchQy/i12fJykb83CRBH4=
-github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A=
 github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
-github.com/go-playground/locales v0.14.0 h1:u50s323jtVGugKlcYeyzC0etD1HifMjqmJqb8WugfUU=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
 github.com/go-playground/locales v0.14.0/go.mod h1:sawfccIbzZTqEDETgFXqTho0QybSa7l++s0DH+LDiLs=
-github.com/go-playground/universal-translator v0.18.0 h1:82dyy6p4OuJq4/CByFNOn/jYrnRPArHwAcmLoJZxyho=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
 github.com/go-playground/universal-translator v0.18.0/go.mod h1:UvRDBj+xPUEGrFYl+lu/H90nyDXpg0fqeB/AQUGNTVA=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
 github.com/go-playground/validator/v10 v10.10.0/go.mod h1:74x4gJWsvQexRdW8Pn3dXSGrTK4nAUsbPlLADvpJkos=
-github.com/go-playground/validator/v10 v10.11.1 h1:prmOlTVv+YjZjmRmNSF3VmspqJIxJWXmqUsHwfTRRkQ=
+github.com/go-playground/validator/v10 v10.11.2 h1:q3SHpufmypg+erIExEKUmsgmhDTyhcJ38oeKGACXohU=
-github.com/go-playground/validator/v10 v10.11.1/go.mod h1:i+3WkQ1FvaUjjxh1kSvIA4dMGDBiPU55YFDl0WbKdWU=
+github.com/go-playground/validator/v10 v10.11.2/go.mod h1:NieE624vt4SCTJtD87arVLvdmjPAeV8BQlHtMnw9D7s=
 github.com/go-redis/cache/v8 v8.4.4 h1:Rm0wZ55X22BA2JMqVtRQNHYyzDd0I5f+Ec/C9Xx3mXY=
 github.com/go-redis/cache/v8 v8.4.4/go.mod h1:JM6CkupsPvAu/LYEVGQy6UB4WDAzQSXkR0lUCbeIcKc=
 github.com/go-redis/redis/v8 v8.11.3/go.mod h1:xNJ9xDG09FsIPwh3bWdk+0oDWHbtF9rPN0F/oD9XeKc=
@@ -93,8 +101,8 @@ github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/hashicorp/hcl/v2 v2.15.0 h1:CPDXO6+uORPjKflkWCCwoWc9uRp+zSIPcCQ+BrxV7m8=
+github.com/hashicorp/hcl/v2 v2.16.1 h1:BwuxEMD/tsYgbhIW7UuI3crjovf3MzuFWiVgiv57iHg=
-github.com/hashicorp/hcl/v2 v2.15.0/go.mod h1:JRmR89jycNkrrqnMmvPDMd56n1rQJ2Q6KocSLCMCXng=
+github.com/hashicorp/hcl/v2 v2.16.1/go.mod h1:JRmR89jycNkrrqnMmvPDMd56n1rQJ2Q6KocSLCMCXng=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/jackc/chunkreader v1.0.0/go.mod h1:RT6O25fNZIuasFJRyZ4R/Y2BbhasbmZXF9QQ7T3kePo=
 github.com/jackc/chunkreader/v2 v2.0.0/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk=
@@ -106,8 +114,8 @@ github.com/jackc/pgconn v0.0.0-20190831204454-2fabfa3c18b7/go.mod h1:ZJKsE/KZfsU
 github.com/jackc/pgconn v1.8.0/go.mod h1:1C2Pb36bGIP9QHGBYCjnyhqu7Rv3sGshaQUvmfGIB/o=
 github.com/jackc/pgconn v1.9.0/go.mod h1:YctiPyvzfU11JFxoXokUOOKQXQmDMoJL9vJzHH8/2JY=
 github.com/jackc/pgconn v1.9.1-0.20210724152538-d89c8390a530/go.mod h1:4z2w8XhRbP1hYxkpTuBjTS3ne3J48K83+u0zoyvg2pI=
-github.com/jackc/pgconn v1.13.0 h1:3L1XMNV2Zvca/8BYhzcRFS70Lr0WlDg16Di6SFGAbys=
+github.com/jackc/pgconn v1.14.0 h1:vrbA9Ud87g6JdFWkHTJXppVce58qPIdP7N8y0Ml/A7Q=
-github.com/jackc/pgconn v1.13.0/go.mod h1:AnowpAqO4CMIIJNZl2VJp+KrkAZciAkhEl0W0JIobpI=
+github.com/jackc/pgconn v1.14.0/go.mod h1:9mBNlny0UvkgJdCDvdVHYSjI+8tD2rnKK69Wz8ti++E=
 github.com/jackc/pgio v1.0.0 h1:g12B9UwVnzGhueNavwioyEEpAmqMe1E/BN9ES+8ovkE=
 github.com/jackc/pgio v1.0.0/go.mod h1:oP+2QK2wFfUWgr+gxjoBH9KGBb31Eio69xUb0w5bYf8=
 github.com/jackc/pgmock v0.0.0-20190831213851-13a1b77aafa2/go.mod h1:fGZlG77KXmcq05nJLRkk0+p82V8B8Dw8KN2/V9c/OAE=
@@ -123,8 +131,8 @@ github.com/jackc/pgproto3/v2 v2.0.0-rc3/go.mod h1:ryONWYqW6dqSg1Lw6vXNMXoBJhpzvW
 github.com/jackc/pgproto3/v2 v2.0.0-rc3.0.20190831210041-4c03ce451f29/go.mod h1:ryONWYqW6dqSg1Lw6vXNMXoBJhpzvWKnT95C46ckYeM=
 github.com/jackc/pgproto3/v2 v2.0.6/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA=
 github.com/jackc/pgproto3/v2 v2.1.1/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA=
-github.com/jackc/pgproto3/v2 v2.3.1 h1:nwj7qwf0S+Q7ISFfBndqeLwSwxs+4DPsbRFjECT1Y4Y=
+github.com/jackc/pgproto3/v2 v2.3.2 h1:7eY55bdBeCz1F2fTzSz69QC+pG46jYq9/jtSPiJ5nn0=
-github.com/jackc/pgproto3/v2 v2.3.1/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA=
+github.com/jackc/pgproto3/v2 v2.3.2/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA=
 github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b/go.mod h1:vsD4gTJCa9TptPL8sPkXrLZ+hDuNrZCnj29CQpr4X1E=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
@@ -132,15 +140,14 @@ github.com/jackc/pgtype v0.0.0-20190421001408-4ed0de4755e0/go.mod h1:hdSHsc1V01C
 github.com/jackc/pgtype v0.0.0-20190824184912-ab885b375b90/go.mod h1:KcahbBH1nCMSo2DXpzsoWOAfFkdEtEJpPbVLq8eE+mc=
 github.com/jackc/pgtype v0.0.0-20190828014616-a8802b16cc59/go.mod h1:MWlu30kVJrUS8lot6TQqcg7mtthZ9T0EoIBFiJcmcyw=
 github.com/jackc/pgtype v1.8.1-0.20210724151600-32e20a603178/go.mod h1:C516IlIV9NKqfsMCXTdChteoXmwgUceqaLfjg2e3NlM=
-github.com/jackc/pgtype v1.12.0/go.mod h1:LUMuVrfsFfdKGLw+AFFVv6KtHOFMwRgDDzBt76IqCA4=
+github.com/jackc/pgtype v1.14.0 h1:y+xUdabmyMkJLyApYuPj38mW+aAIqCe5uuBB51rH3Vw=
-github.com/jackc/pgtype v1.13.0 h1:XkIc7A+1BmZD19bB2NxrtjJweHxQ9agqvM+9URc68Cg=
+github.com/jackc/pgtype v1.14.0/go.mod h1:LUMuVrfsFfdKGLw+AFFVv6KtHOFMwRgDDzBt76IqCA4=
-github.com/jackc/pgtype v1.13.0/go.mod h1:LUMuVrfsFfdKGLw+AFFVv6KtHOFMwRgDDzBt76IqCA4=
 github.com/jackc/pgx/v4 v4.0.0-20190420224344-cc3461e65d96/go.mod h1:mdxmSJJuR08CZQyj1PVQBHy9XOp5p8/SHH6a0psbY9Y=
 github.com/jackc/pgx/v4 v4.0.0-20190421002000-1b8f0016e912/go.mod h1:no/Y67Jkk/9WuGR0JG/JseM9irFbnEPbuWV2EELPNuM=
 github.com/jackc/pgx/v4 v4.0.0-pre1.0.20190824185557-6972a5742186/go.mod h1:X+GQnOEnf1dqHGpw7JmHqHc1NxDoalibchSk9/RWuDc=
 github.com/jackc/pgx/v4 v4.12.1-0.20210724153913-640aa07df17c/go.mod h1:1QD0+tgSXP7iUjYm9C1NxKhny7lq6ee99u/z+IHFcgs=
-github.com/jackc/pgx/v4 v4.17.2 h1:0Ut0rpeKwvIVbMQ1KbMBU4h6wxehBI535LK6Flheh8E=
+github.com/jackc/pgx/v4 v4.18.1 h1:YP7G1KABtKpB5IHrO9vYwSrCOhs7p3uqhvhhQBptya0=
-github.com/jackc/pgx/v4 v4.17.2/go.mod h1:lcxIZN44yMIrWI78a5CpucdD14hX0SBDbNRvjDBItsw=
+github.com/jackc/pgx/v4 v4.18.1/go.mod h1:FydWkUyadDmdNH/mHnGob881GawxeEm7TcMCzkb+qQE=
 github.com/jackc/puddle v0.0.0-20190413234325-e4ced69a3a2b/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
 github.com/jackc/puddle v0.0.0-20190608224051-11cab39313c9/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
 github.com/jackc/puddle v1.1.3/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
@@ -149,8 +156,11 @@ github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnr
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
-github.com/klauspost/compress v1.15.13 h1:NFn1Wr8cfnenSJSA46lLq4wHCcBzKTSjnBIexDMMOV0=
+github.com/klauspost/compress v1.16.0 h1:iULayQNOReoYUe+1qtKOqw9CwJv3aNQu8ivo7lw1HU4=
-github.com/klauspost/compress v1.15.13/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM=
+github.com/klauspost/compress v1.16.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk=
+github.com/klauspost/cpuid/v2 v2.2.4/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
@@ -163,25 +173,26 @@ github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 h1:MtvEpTB6LX3vkb4ax0b5D2DHbNAUsen0Gx5wZoq3lV4=
-github.com/leodido/go-urn v1.2.1 h1:BqpAaACuzVSgi/VLzGZIobT2z4v53pjosyNd9Yv6n/w=
 github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
+github.com/leodido/go-urn v1.2.2 h1:7z68G0FCGvDk646jz1AelTYNYWrTNm0bEcFAo147wt4=
+github.com/leodido/go-urn v1.2.2/go.mod h1:kUaIbLZWttglzwNuG0pgsh5vuV6u2YcGBYz1hIPjtOQ=
 github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/lib/pq v1.1.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/lib/pq v1.10.2/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/lib/pq v1.10.7 h1:p7ZhMD+KsSRozJr34udlUrhboJwWAgCg34+/ZZNvZZw=
-github.com/markus-wa/demoinfocs-golang/v3 v3.1.0 h1:4NFWPj5EhnAR84xgWGlVdFETavbQrlJr1GEbaIgI1UI=
+github.com/markus-wa/demoinfocs-golang/v3 v3.3.0 h1:cXAI081cH5tDmmyPuyUzuIGeP8strtVzdtRB5VlIvL8=
-github.com/markus-wa/demoinfocs-golang/v3 v3.1.0/go.mod h1:Nxh+AxYncPrUfx5o72ODvPwJi4aOuuettAX0TfVLN0E=
+github.com/markus-wa/demoinfocs-golang/v3 v3.3.0/go.mod h1:NzAkCtDshPkoSMg3hAyojkmHE4ZgnNWCM1Vv4yCPLsI=
-github.com/markus-wa/go-unassert v0.1.2 h1:uXWlMDa8JVtc4RgNq4XJIjyRejv9MOVuy/E0VECPxxo=
+github.com/markus-wa/go-unassert v0.1.3 h1:4N2fPLUS3929Rmkv94jbWskjsLiyNT2yQpCulTFFWfM=
-github.com/markus-wa/go-unassert v0.1.2/go.mod h1:XEvrxR+trvZeMDfXcZPvzqGo6eumEtdk5VjNRuvvzxQ=
+github.com/markus-wa/go-unassert v0.1.3/go.mod h1:/pqt7a0LRmdsRNYQ2nU3SGrXfw3bLXrvIkakY/6jpPY=
 github.com/markus-wa/gobitread v0.2.3 h1:COx7dtYQ7Q+77hgUmD+O4MvOcqG7y17RP3Z7BbjRvPs=
 github.com/markus-wa/gobitread v0.2.3/go.mod h1:PcWXMH4gx7o2CKslbkFkLyJB/aHW7JVRG3MRZe3PINg=
 github.com/markus-wa/godispatch v1.4.1 h1:Cdff5x33ShuX3sDmUbYWejk7tOuoHErFYMhUc2h7sLc=
 github.com/markus-wa/godispatch v1.4.1/go.mod h1:tk8L0yzLO4oAcFwM2sABMge0HRDJMdE8E7xm4gK/+xM=
 github.com/markus-wa/ice-cipher-go v0.0.0-20220823210642-1fcccd18c6c1 h1:YH4WI14HARrM3C6mKUMFDBz93O25oWSlLEYGeL27G0w=
 github.com/markus-wa/ice-cipher-go v0.0.0-20220823210642-1fcccd18c6c1/go.mod h1:JIsht5Oa9P50VnGJTvH2a6nkOqDFJbUeU1YRZYvdplw=
-github.com/markus-wa/quickhull-go/v2 v2.1.0 h1:DA2pzEzH0k5CEnlUsouRqNdD+jzNFb4DBhrX4Hpa5So=
+github.com/markus-wa/quickhull-go/v2 v2.2.0 h1:rB99NLYeUHoZQ/aNRcGOGqjNBGmrOaRxdtqTnsTUPTA=
-github.com/markus-wa/quickhull-go/v2 v2.1.0/go.mod h1:bOlBUpIzGSMMhHX0f9N8CQs0VZD4nnPeta0OocH7m4o=
+github.com/markus-wa/quickhull-go/v2 v2.2.0/go.mod h1:EuLMucfr4B+62eipXm335hOs23LTnO62W7Psn3qvU2k=
 github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
 github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
@@ -213,8 +224,8 @@ github.com/onsi/gomega v1.15.0/go.mod h1:cIuvLEne0aoVhAgh/O6ac0Op8WWw9H6eYCriF+t
 github.com/onsi/gomega v1.18.1 h1:M1GfJqGRrBrrGGsbxzV5dqM2U2ApXefZCQpkukxYRLE=
 github.com/pborman/getopt v0.0.0-20170112200414-7148bc3a4c30/go.mod h1:85jBQOZwpVEaDAr341tbn15RS4fCAsIst0qp7i8ex1o=
 github.com/pelletier/go-toml/v2 v2.0.1/go.mod h1:r9LEWfGN8R5k0VXJ+0BkIe7MYkRdwZOjgMj2KwnJFUo=
-github.com/pelletier/go-toml/v2 v2.0.6 h1:nrzqCb7j9cDFj2coyLNLaZuJTLjWjlaz6nvTvIwycIU=
+github.com/pelletier/go-toml/v2 v2.0.7 h1:muncTPStnKRos5dpVKULv2FVd4bMOhNePj9CjgDb8Us=
-github.com/pelletier/go-toml/v2 v2.0.6/go.mod h1:eumQOmlWiOPt5WriQQqoM5y18pDHwha2N+QD+EUNTek=
+github.com/pelletier/go-toml/v2 v2.0.7/go.mod h1:eumQOmlWiOPt5WriQQqoM5y18pDHwha2N+QD+EUNTek=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -228,8 +239,7 @@ github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6po
 github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
 github.com/rs/zerolog v1.13.0/go.mod h1:YbFCdg8HfsridGWAh22vktObvhZbQsZXe4/zB0OKkWU=
 github.com/rs/zerolog v1.15.0/go.mod h1:xYTKnLHcpfU2225ny5qZjxnj9NvkumZYjJHlAThCjNc=
-github.com/sabloger/sitemap-generator v1.2.1 h1:H/vZE0Z49ZCmcXy57FNqw6zn27UJYO6zuozSxfzm8qY=
+github.com/rwtodd/Go.Sed v0.0.0-20210816025313-55464686f9ef/go.mod h1:8AEUvGVi2uQ5b24BIhcr0GCcpd/RNAFWaN2CJFrWIIQ=
-github.com/sabloger/sitemap-generator v1.2.1/go.mod h1:vm0TjqX6syzcmQDBK2HkIZzORA0WQ3baEN8248nhHVk=
 github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
 github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
 github.com/sethvargo/go-retry v0.2.4 h1:T+jHEQy/zKJf5s95UkguisicE0zuF9y7+/vgz08Ocec=
@@ -255,12 +265,15 @@ github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
+github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go v1.2.7/go.mod h1:nF9osbDWLy6bDVv/Rtoh6QgnvNDpmCalQV5urGCCS6M=
 github.com/ugorji/go/codec v1.2.7/go.mod h1:WGN1fab3R1fzQlVQTkfxVtIBhWDRqOviHU95kRgeqEY=
-github.com/ugorji/go/codec v1.2.8 h1:sgBJS6COt0b/P40VouWKdseidkDgHxYGm0SAglUHfP0=
+github.com/ugorji/go/codec v1.2.10 h1:eimT6Lsr+2lzmSZxPhLFoOWFmQqwk0fllJJ5hEbTXtQ=
-github.com/ugorji/go/codec v1.2.8/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/ugorji/go/codec v1.2.10/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
 github.com/vmihailenco/go-tinylfu v0.2.2 h1:H1eiG6HM36iniK6+21n9LLpzx1G9R3DJa2UjUjbynsI=
 github.com/vmihailenco/go-tinylfu v0.2.2/go.mod h1:CutYi2Q9puTxfcolkliPq4npPuofg9N9t8JVrjzwa3Q=
 github.com/vmihailenco/msgpack/v5 v5.3.4/go.mod h1:7xyJ9e+0+9SaZT0Wt1RGleJXzli6Q/V5KbhBonMG9jc=
@@ -271,8 +284,9 @@ github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV
 github.com/wercker/journalhook v0.0.0-20180428041537-5d0a5ae867b3 h1:shC1HB1UogxN5Ech3Yqaaxj1X/P656PPCB4RbojIJqc=
 github.com/wercker/journalhook v0.0.0-20180428041537-5d0a5ae867b3/go.mod h1:XCsSkdKK4gwBMNrOCZWww0pX6AOt+2gYc5Z6jBRrNVg=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/zclconf/go-cty v1.12.1 h1:PcupnljUm9EIvbgSHQnHhUr3fO6oFmkOrvs2BAFNXXY=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-github.com/zclconf/go-cty v1.12.1/go.mod h1:s9IfD1LK5ccNMSWCVFCE2rJfHiZgi7JijgeWIMfhLvA=
+github.com/zclconf/go-cty v1.13.0 h1:It5dfKTTZHe9aeppbNOda3mN7Ag7sg6QkBNm6TkyFa0=
+github.com/zclconf/go-cty v1.13.0/go.mod h1:YKQzy/7pZ7iq2jNFzy5go57xdxdWoLLpaEp4u238AE0=
 github.com/zenazn/goji v0.9.0/go.mod h1:7S9M489iMyHBNxwZnk9/EHS098H4/F6TATF2mIxtB1Q=
 go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
@@ -285,6 +299,9 @@ go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9E
 go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.2.0 h1:W1sUEHXiJTfjaFJ5SLo0N6lZn+0eO5gWD1MFeTGqQEY=
+golang.org/x/arch v0.2.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190411191339-88737f569e3a/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE=
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
@@ -294,16 +311,16 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh
 golang.org/x/crypto v0.0.0-20201203163018-be400aefbc4c/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
 golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.6.0 h1:qfktjS5LUO+fFKeJXZ+ikTRijMmljikvG68fpMMruSc=
-golang.org/x/crypto v0.4.0 h1:UVQgzMY87xqpKNgb+kDsll2Igd33HszWHFLmpaRMq/8=
+golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
-golang.org/x/crypto v0.4.0/go.mod h1:3quD/ATkf6oY+rnes5c3ExXTbLc8mueNue5/DoinL80=
 golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.7.0 h1:LapD9S96VoQRhi/GrNTqeBJFrUjs5UHCAtTlgwA5oZA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.8.0 h1:LUYupSeNrTNCGzR/hVBk2NHZO4hXcVaW1k4Qx7rjPx8=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
@@ -313,13 +330,15 @@ golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
-golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.4.0 h1:Q5QPcMlvfxFTAPV0+07Xz/MpK9NTXu2VDUuy0FeMfaU=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.4.0/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE=
+golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
+golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -344,20 +363,25 @@ golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ=
+golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
-golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.5.0 h1:OLmvp0KP+FVG99Ct/qFiL/Fhk4zp4QQnZ7b2U+5piUM=
+golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo=
-golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
 golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -370,6 +394,7 @@ golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtn
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -408,3 +433,6 @@ gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
+somegit.dev/anonfunc/gositemap v0.1.0 h1:0y+YN14qUahq/08HSWZzq8BcW0MH07K8G0Cw6FV1N08=
+somegit.dev/anonfunc/gositemap v0.1.0/go.mod h1:2v84uOYv0OQyfvQu9Fq1WI4zr/EjDOoxry5JrMZVEqo=

main.go

@@ -23,7 +23,6 @@ import (
 	"github.com/go-redis/redis/v8"
 	_ "github.com/jackc/pgx/v4/stdlib"
 	"github.com/markus-wa/demoinfocs-golang/v3/pkg/demoinfocs/common"
-	"github.com/sabloger/sitemap-generator/smg"
 	log "github.com/sirupsen/logrus"
 	"github.com/wercker/journalhook"
 	"golang.org/x/text/language"
@@ -33,6 +32,7 @@ import (
 	"net/http"
 	"os"
 	"os/signal"
+	"somegit.dev/anonfunc/gositemap"
 	"strconv"
 	"strings"
 	"syscall"
@@ -50,6 +50,7 @@ var (
 	configFlag     = flag.String("config", "config.yaml", "Set config file to use")
 	journalLogFlag = flag.Bool("journal", false, "Log to systemd journal instead of stdout")
 	sqlDebugFlag   = flag.Bool("sqldebug", false, "Debug SQL queries")
+	siteMap        *gositemap.SiteMap
 )
 
 func housekeeping() {
@@ -1051,53 +1052,35 @@ func getMatch(c *gin.Context) {
 	c.JSON(http.StatusOK, mResponse)
 }
 
+func getSiteMapIndex(c *gin.Context) {
+	res, err := siteMap.SiteMapIndex()
+	if err != nil {
+		_ = c.AbortWithError(http.StatusInternalServerError, err)
+		return
+	}
+
+	c.Data(http.StatusOK, "application/xml", res)
+}
+
 func getSiteMap(c *gin.Context) {
-	now := time.Now().UTC()
+	if c.Param("num") == "" {
-	sm := smg.NewSitemap(false)
+		_ = c.AbortWithError(http.StatusBadRequest, fmt.Errorf("no index specified"))
-	sm.SetLastMod(&now)
+		return
-	sm.SetHostname("https://csgow.tf")
+	}
 
-	players, err := db.Player.Query().IDs(c)
+	id, err := strconv.Atoi(c.Param("num"))
 	if err != nil {
 		_ = c.AbortWithError(http.StatusInternalServerError, err)
 		return
 	}
 
-	for _, tPlayer := range players {
+	res, err := siteMap.SiteMap(id)
-		err = sm.Add(&smg.SitemapLoc{
-			Loc:        fmt.Sprintf("/player/%d", tPlayer),
-			ChangeFreq: smg.Daily,
-		})
-		if err != nil {
-			_ = c.AbortWithError(http.StatusInternalServerError, err)
-			return
-		}
-	}
-
-	matches, err := db.Match.Query().IDs(c)
 	if err != nil {
 		_ = c.AbortWithError(http.StatusInternalServerError, err)
 		return
 	}
 
-	for _, tMatch := range matches {
+	c.Data(http.StatusOK, "application/xml", res)
-		err = sm.Add(&smg.SitemapLoc{
-			Loc:        fmt.Sprintf("/match/%d", tMatch),
-			ChangeFreq: smg.Weekly,
-		})
-		if err != nil {
-			_ = c.AbortWithError(http.StatusInternalServerError, err)
-			return
-		}
-	}
-
-	readBuf := new(bytes.Buffer)
-	sm.Finalize()
-	_, err = sm.WriteTo(readBuf)
-	if err != nil {
-		log.Warningf("error writing to pipe: %v", err)
-	}
-	c.DataFromReader(http.StatusOK, int64(readBuf.Len()), "application/xml", readBuf, nil)
 }
 
 /*
@@ -1205,6 +1188,29 @@ func main() {
 	// start housekeeper
 	go housekeeping()
 
+	// populate sitemap
+	siteMap = &gositemap.SiteMap{BaseURL: "csgow.tf"}
+	players, err := db.Player.Query().IDs(context.Background())
+	if err != nil {
+		log.Panicf("error setting up SiteMap: %v", err)
+	}
+
+	for _, tPlayer := range players {
+		freq := gositemap.Daily
+		siteMap.AddURL(fmt.Sprintf("/player/%d", tPlayer), nil, &freq, nil)
+	}
+
+	matches, err := db.Match.Query().IDs(context.Background())
+	if err != nil {
+		log.Panicf("error setting up SiteMap: %v", err)
+	}
+
+	for _, tMatch := range matches {
+		freq := gositemap.Weekly
+		siteMap.AddURL(fmt.Sprintf("/match/%d", tMatch), nil, &freq, nil)
+	}
+
+	// routes
 	r := gin.New()
 	r.Use(gin.LoggerWithFormatter(func(param gin.LogFormatterParams) string {
 		return fmt.Sprintf("%s - - \"%s %s %s\" %d %d %q %q %s %s\n",
@@ -1238,7 +1244,8 @@ func main() {
 	r.GET("/match/:id/chat", getMatchChat)
 	r.GET("/matches", getMatches)
 	r.GET("/matches/next/:time", getMatches)
-	r.GET("/sitemap", getSiteMap)
+	r.GET("/sitemap_index.xml", getSiteMapIndex)
+	r.GET("/sitemap:num.xml", getSiteMap)
 
 	log.Info("Start listening...")