add group_id to notifier

backend/internal/data/ent/notifier_query.go

@@ -11,6 +11,7 @@ import (
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
 	"github.com/google/uuid"
+	"github.com/hay-kot/homebox/backend/internal/data/ent/group"
 	"github.com/hay-kot/homebox/backend/internal/data/ent/notifier"
 	"github.com/hay-kot/homebox/backend/internal/data/ent/predicate"
 	"github.com/hay-kot/homebox/backend/internal/data/ent/user"
@@ -24,6 +25,7 @@ type NotifierQuery struct {
 	inters     []Interceptor
 	predicates []predicate.Notifier
 	withUser   *UserQuery
+	withGroup  *GroupQuery
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -82,6 +84,28 @@ func (nq *NotifierQuery) QueryUser() *UserQuery {
 	return query
 }
 
+// QueryGroup chains the current query on the "group" edge.
+func (nq *NotifierQuery) QueryGroup() *GroupQuery {
+	query := (&GroupClient{config: nq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := nq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := nq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(notifier.Table, notifier.FieldID, selector),
+			sqlgraph.To(group.Table, group.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, notifier.GroupTable, notifier.GroupColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(nq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
 // First returns the first Notifier entity from the query.
 // Returns a *NotFoundError when no Notifier was found.
 func (nq *NotifierQuery) First(ctx context.Context) (*Notifier, error) {
@@ -275,6 +299,7 @@ func (nq *NotifierQuery) Clone() *NotifierQuery {
 		inters:     append([]Interceptor{}, nq.inters...),
 		predicates: append([]predicate.Notifier{}, nq.predicates...),
 		withUser:   nq.withUser.Clone(),
+		withGroup:  nq.withGroup.Clone(),
 		// clone intermediate query.
 		sql:  nq.sql.Clone(),
 		path: nq.path,
@@ -292,6 +317,17 @@ func (nq *NotifierQuery) WithUser(opts ...func(*UserQuery)) *NotifierQuery {
 	return nq
 }
 
+// WithGroup tells the query-builder to eager-load the nodes that are connected to
+// the "group" edge. The optional arguments are used to configure the query builder of the edge.
+func (nq *NotifierQuery) WithGroup(opts ...func(*GroupQuery)) *NotifierQuery {
+	query := (&GroupClient{config: nq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	nq.withGroup = query
+	return nq
+}
+
 // GroupBy is used to group vertices by one or more fields/columns.
 // It is often used with aggregate functions, like: count, max, mean, min, sum.
 //
@@ -370,8 +406,9 @@ func (nq *NotifierQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Not
 	var (
 		nodes       = []*Notifier{}
 		_spec       = nq.querySpec()
-		loadedTypes = [1]bool{
+		loadedTypes = [2]bool{
 			nq.withUser != nil,
+			nq.withGroup != nil,
 		}
 	)
 	_spec.ScanValues = func(columns []string) ([]any, error) {
@@ -398,6 +435,12 @@ func (nq *NotifierQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Not
 			return nil, err
 		}
 	}
+	if query := nq.withGroup; query != nil {
+		if err := nq.loadGroup(ctx, query, nodes, nil,
+			func(n *Notifier, e *Group) { n.Edges.Group = e }); err != nil {
+			return nil, err
+		}
+	}
 	return nodes, nil
 }
 
@@ -430,6 +473,35 @@ func (nq *NotifierQuery) loadUser(ctx context.Context, query *UserQuery, nodes [
 	}
 	return nil
 }
+func (nq *NotifierQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes []*Notifier, init func(*Notifier), assign func(*Notifier, *Group)) error {
+	ids := make([]uuid.UUID, 0, len(nodes))
+	nodeids := make(map[uuid.UUID][]*Notifier)
+	for i := range nodes {
+		fk := nodes[i].GroupID
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(group.IDIn(ids...))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nodeids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected foreign-key "group_id" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
 
 func (nq *NotifierQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := nq.querySpec()