refactor schema folder

backend/internal/data/ent/client.go

@@ -1301,6 +1301,22 @@ func (c *ItemClient) GetX(ctx context.Context, id uuid.UUID) *Item {
 	return obj
 }
 
+// QueryGroup queries the group edge of a Item.
+func (c *ItemClient) QueryGroup(i *Item) *GroupQuery {
+	query := (&GroupClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := i.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(item.Table, item.FieldID, id),
+			sqlgraph.To(group.Table, group.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, item.GroupTable, item.GroupColumn),
+		)
+		fromV = sqlgraph.Neighbors(i.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
 // QueryParent queries the parent edge of a Item.
 func (c *ItemClient) QueryParent(i *Item) *ItemQuery {
 	query := (&ItemClient{config: c.config}).Query()
@@ -1333,22 +1349,6 @@ func (c *ItemClient) QueryChildren(i *Item) *ItemQuery {
 	return query
 }
 
-// QueryGroup queries the group edge of a Item.
-func (c *ItemClient) QueryGroup(i *Item) *GroupQuery {
-	query := (&GroupClient{config: c.config}).Query()
-	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
-		id := i.ID
-		step := sqlgraph.NewStep(
-			sqlgraph.From(item.Table, item.FieldID, id),
-			sqlgraph.To(group.Table, group.FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, item.GroupTable, item.GroupColumn),
-		)
-		fromV = sqlgraph.Neighbors(i.driver.Dialect(), step)
-		return fromV, nil
-	}
-	return query
-}
-
 // QueryLabel queries the label edge of a Item.
 func (c *ItemClient) QueryLabel(i *Item) *LabelQuery {
 	query := (&LabelClient{config: c.config}).Query()
@@ -1831,6 +1831,22 @@ func (c *LocationClient) GetX(ctx context.Context, id uuid.UUID) *Location {
 	return obj
 }
 
+// QueryGroup queries the group edge of a Location.
+func (c *LocationClient) QueryGroup(l *Location) *GroupQuery {
+	query := (&GroupClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := l.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(location.Table, location.FieldID, id),
+			sqlgraph.To(group.Table, group.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, location.GroupTable, location.GroupColumn),
+		)
+		fromV = sqlgraph.Neighbors(l.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
 // QueryParent queries the parent edge of a Location.
 func (c *LocationClient) QueryParent(l *Location) *LocationQuery {
 	query := (&LocationClient{config: c.config}).Query()
@@ -1863,22 +1879,6 @@ func (c *LocationClient) QueryChildren(l *Location) *LocationQuery {
 	return query
 }
 
-// QueryGroup queries the group edge of a Location.
-func (c *LocationClient) QueryGroup(l *Location) *GroupQuery {
-	query := (&GroupClient{config: c.config}).Query()
-	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
-		id := l.ID
-		step := sqlgraph.NewStep(
-			sqlgraph.From(location.Table, location.FieldID, id),
-			sqlgraph.To(group.Table, group.FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, location.GroupTable, location.GroupColumn),
-		)
-		fromV = sqlgraph.Neighbors(l.driver.Dialect(), step)
-		return fromV, nil
-	}
-	return query
-}
-
 // QueryItems queries the items edge of a Location.
 func (c *LocationClient) QueryItems(l *Location) *ItemQuery {
 	query := (&ItemClient{config: c.config}).Query()

backend/internal/data/ent/item.go

@@ -75,12 +75,12 @@ type Item struct {
 
 // ItemEdges holds the relations/edges for other nodes in the graph.
 type ItemEdges struct {
+	// Group holds the value of the group edge.
+	Group *Group `json:"group,omitempty"`
 	// Parent holds the value of the parent edge.
 	Parent *Item `json:"parent,omitempty"`
 	// Children holds the value of the children edge.
 	Children []*Item `json:"children,omitempty"`
-	// Group holds the value of the group edge.
-	Group *Group `json:"group,omitempty"`
 	// Label holds the value of the label edge.
 	Label []*Label `json:"label,omitempty"`
 	// Location holds the value of the location edge.
@@ -96,10 +96,23 @@ type ItemEdges struct {
 	loadedTypes [8]bool
 }
 
+// GroupOrErr returns the Group value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e ItemEdges) GroupOrErr() (*Group, error) {
+	if e.loadedTypes[0] {
+		if e.Group == nil {
+			// Edge was loaded but was not found.
+			return nil, &NotFoundError{label: group.Label}
+		}
+		return e.Group, nil
+	}
+	return nil, &NotLoadedError{edge: "group"}
+}
+
 // ParentOrErr returns the Parent value or an error if the edge
 // was not loaded in eager-loading, or loaded but was not found.
 func (e ItemEdges) ParentOrErr() (*Item, error) {
-	if e.loadedTypes[0] {
+	if e.loadedTypes[1] {
 		if e.Parent == nil {
 			// Edge was loaded but was not found.
 			return nil, &NotFoundError{label: item.Label}
@@ -112,25 +125,12 @@ func (e ItemEdges) ParentOrErr() (*Item, error) {
 // ChildrenOrErr returns the Children value or an error if the edge
 // was not loaded in eager-loading.
 func (e ItemEdges) ChildrenOrErr() ([]*Item, error) {
-	if e.loadedTypes[1] {
+	if e.loadedTypes[2] {
 		return e.Children, nil
 	}
 	return nil, &NotLoadedError{edge: "children"}
 }
 
-// GroupOrErr returns the Group value or an error if the edge
-// was not loaded in eager-loading, or loaded but was not found.
-func (e ItemEdges) GroupOrErr() (*Group, error) {
-	if e.loadedTypes[2] {
-		if e.Group == nil {
-			// Edge was loaded but was not found.
-			return nil, &NotFoundError{label: group.Label}
-		}
-		return e.Group, nil
-	}
-	return nil, &NotLoadedError{edge: "group"}
-}
-
 // LabelOrErr returns the Label value or an error if the edge
 // was not loaded in eager-loading.
 func (e ItemEdges) LabelOrErr() ([]*Label, error) {
@@ -388,6 +388,11 @@ func (i *Item) assignValues(columns []string, values []any) error {
 	return nil
 }
 
+// QueryGroup queries the "group" edge of the Item entity.
+func (i *Item) QueryGroup() *GroupQuery {
+	return NewItemClient(i.config).QueryGroup(i)
+}
+
 // QueryParent queries the "parent" edge of the Item entity.
 func (i *Item) QueryParent() *ItemQuery {
 	return NewItemClient(i.config).QueryParent(i)
@@ -398,11 +403,6 @@ func (i *Item) QueryChildren() *ItemQuery {
 	return NewItemClient(i.config).QueryChildren(i)
 }
 
-// QueryGroup queries the "group" edge of the Item entity.
-func (i *Item) QueryGroup() *GroupQuery {
-	return NewItemClient(i.config).QueryGroup(i)
-}
-
 // QueryLabel queries the "label" edge of the Item entity.
 func (i *Item) QueryLabel() *LabelQuery {
 	return NewItemClient(i.config).QueryLabel(i)

backend/internal/data/ent/item/item.go

@@ -59,12 +59,12 @@ const (
 	FieldSoldPrice = "sold_price"
 	// FieldSoldNotes holds the string denoting the sold_notes field in the database.
 	FieldSoldNotes = "sold_notes"
+	// EdgeGroup holds the string denoting the group edge name in mutations.
+	EdgeGroup = "group"
 	// EdgeParent holds the string denoting the parent edge name in mutations.
 	EdgeParent = "parent"
 	// EdgeChildren holds the string denoting the children edge name in mutations.
 	EdgeChildren = "children"
-	// EdgeGroup holds the string denoting the group edge name in mutations.
-	EdgeGroup = "group"
 	// EdgeLabel holds the string denoting the label edge name in mutations.
 	EdgeLabel = "label"
 	// EdgeLocation holds the string denoting the location edge name in mutations.
@@ -77,6 +77,13 @@ const (
 	EdgeAttachments = "attachments"
 	// Table holds the table name of the item in the database.
 	Table = "items"
+	// GroupTable is the table that holds the group relation/edge.
+	GroupTable = "items"
+	// GroupInverseTable is the table name for the Group entity.
+	// It exists in this package in order to avoid circular dependency with the "group" package.
+	GroupInverseTable = "groups"
+	// GroupColumn is the table column denoting the group relation/edge.
+	GroupColumn = "group_items"
 	// ParentTable is the table that holds the parent relation/edge.
 	ParentTable = "items"
 	// ParentColumn is the table column denoting the parent relation/edge.
@@ -85,13 +92,6 @@ const (
 	ChildrenTable = "items"
 	// ChildrenColumn is the table column denoting the children relation/edge.
 	ChildrenColumn = "item_children"
-	// GroupTable is the table that holds the group relation/edge.
-	GroupTable = "items"
-	// GroupInverseTable is the table name for the Group entity.
-	// It exists in this package in order to avoid circular dependency with the "group" package.
-	GroupInverseTable = "groups"
-	// GroupColumn is the table column denoting the group relation/edge.
-	GroupColumn = "group_items"
 	// LabelTable is the table that holds the label relation/edge. The primary key declared below.
 	LabelTable = "label_items"
 	// LabelInverseTable is the table name for the Label entity.

backend/internal/data/ent/item/where.go

@@ -1406,6 +1406,33 @@ func SoldNotesContainsFold(v string) predicate.Item {
 	return predicate.Item(sql.FieldContainsFold(FieldSoldNotes, v))
 }
 
+// HasGroup applies the HasEdge predicate on the "group" edge.
+func HasGroup() predicate.Item {
+	return predicate.Item(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasGroupWith applies the HasEdge predicate on the "group" edge with a given conditions (other predicates).
+func HasGroupWith(preds ...predicate.Group) predicate.Item {
+	return predicate.Item(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.To(GroupInverseTable, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
+		)
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
 // HasParent applies the HasEdge predicate on the "parent" edge.
 func HasParent() predicate.Item {
 	return predicate.Item(func(s *sql.Selector) {
@@ -1460,33 +1487,6 @@ func HasChildrenWith(preds ...predicate.Item) predicate.Item {
 	})
 }
 
-// HasGroup applies the HasEdge predicate on the "group" edge.
-func HasGroup() predicate.Item {
-	return predicate.Item(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasGroupWith applies the HasEdge predicate on the "group" edge with a given conditions (other predicates).
-func HasGroupWith(preds ...predicate.Group) predicate.Item {
-	return predicate.Item(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.To(GroupInverseTable, FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
-		)
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
 // HasLabel applies the HasEdge predicate on the "label" edge.
 func HasLabel() predicate.Item {
 	return predicate.Item(func(s *sql.Selector) {

backend/internal/data/ent/item_create.go

@@ -355,6 +355,17 @@ func (ic *ItemCreate) SetNillableID(u *uuid.UUID) *ItemCreate {
 	return ic
 }
 
+// SetGroupID sets the "group" edge to the Group entity by ID.
+func (ic *ItemCreate) SetGroupID(id uuid.UUID) *ItemCreate {
+	ic.mutation.SetGroupID(id)
+	return ic
+}
+
+// SetGroup sets the "group" edge to the Group entity.
+func (ic *ItemCreate) SetGroup(g *Group) *ItemCreate {
+	return ic.SetGroupID(g.ID)
+}
+
 // SetParentID sets the "parent" edge to the Item entity by ID.
 func (ic *ItemCreate) SetParentID(id uuid.UUID) *ItemCreate {
 	ic.mutation.SetParentID(id)
@@ -389,17 +400,6 @@ func (ic *ItemCreate) AddChildren(i ...*Item) *ItemCreate {
 	return ic.AddChildIDs(ids...)
 }
 
-// SetGroupID sets the "group" edge to the Group entity by ID.
-func (ic *ItemCreate) SetGroupID(id uuid.UUID) *ItemCreate {
-	ic.mutation.SetGroupID(id)
-	return ic
-}
-
-// SetGroup sets the "group" edge to the Group entity.
-func (ic *ItemCreate) SetGroup(g *Group) *ItemCreate {
-	return ic.SetGroupID(g.ID)
-}
-
 // AddLabelIDs adds the "label" edge to the Label entity by IDs.
 func (ic *ItemCreate) AddLabelIDs(ids ...uuid.UUID) *ItemCreate {
 	ic.mutation.AddLabelIDs(ids...)
@@ -763,6 +763,26 @@ func (ic *ItemCreate) createSpec() (*Item, *sqlgraph.CreateSpec) {
 		_spec.SetField(item.FieldSoldNotes, field.TypeString, value)
 		_node.SoldNotes = value
 	}
+	if nodes := ic.mutation.GroupIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   item.GroupTable,
+			Columns: []string{item.GroupColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: &sqlgraph.FieldSpec{
+					Type:   field.TypeUUID,
+					Column: group.FieldID,
+				},
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.group_items = &nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
 	if nodes := ic.mutation.ParentIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2O,
@@ -802,26 +822,6 @@ func (ic *ItemCreate) createSpec() (*Item, *sqlgraph.CreateSpec) {
 		}
 		_spec.Edges = append(_spec.Edges, edge)
 	}
-	if nodes := ic.mutation.GroupIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   item.GroupTable,
-			Columns: []string{item.GroupColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: &sqlgraph.FieldSpec{
-					Type:   field.TypeUUID,
-					Column: group.FieldID,
-				},
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_node.group_items = &nodes[0]
-		_spec.Edges = append(_spec.Edges, edge)
-	}
 	if nodes := ic.mutation.LabelIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2M,

backend/internal/data/ent/item_query.go

@@ -29,9 +29,9 @@ type ItemQuery struct {
 	order                  []OrderFunc
 	inters                 []Interceptor
 	predicates             []predicate.Item
+	withGroup              *GroupQuery
 	withParent             *ItemQuery
 	withChildren           *ItemQuery
-	withGroup              *GroupQuery
 	withLabel              *LabelQuery
 	withLocation           *LocationQuery
 	withFields             *ItemFieldQuery
@@ -74,6 +74,28 @@ func (iq *ItemQuery) Order(o ...OrderFunc) *ItemQuery {
 	return iq
 }
 
+// QueryGroup chains the current query on the "group" edge.
+func (iq *ItemQuery) QueryGroup() *GroupQuery {
+	query := (&GroupClient{config: iq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := iq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := iq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(item.Table, item.FieldID, selector),
+			sqlgraph.To(group.Table, group.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, item.GroupTable, item.GroupColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(iq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
 // QueryParent chains the current query on the "parent" edge.
 func (iq *ItemQuery) QueryParent() *ItemQuery {
 	query := (&ItemClient{config: iq.config}).Query()
@@ -118,28 +140,6 @@ func (iq *ItemQuery) QueryChildren() *ItemQuery {
 	return query
 }
 
-// QueryGroup chains the current query on the "group" edge.
-func (iq *ItemQuery) QueryGroup() *GroupQuery {
-	query := (&GroupClient{config: iq.config}).Query()
-	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
-		if err := iq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		selector := iq.sqlQuery(ctx)
-		if err := selector.Err(); err != nil {
-			return nil, err
-		}
-		step := sqlgraph.NewStep(
-			sqlgraph.From(item.Table, item.FieldID, selector),
-			sqlgraph.To(group.Table, group.FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, item.GroupTable, item.GroupColumn),
-		)
-		fromU = sqlgraph.SetNeighbors(iq.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
 // QueryLabel chains the current query on the "label" edge.
 func (iq *ItemQuery) QueryLabel() *LabelQuery {
 	query := (&LabelClient{config: iq.config}).Query()
@@ -442,9 +442,9 @@ func (iq *ItemQuery) Clone() *ItemQuery {
 		order:                  append([]OrderFunc{}, iq.order...),
 		inters:                 append([]Interceptor{}, iq.inters...),
 		predicates:             append([]predicate.Item{}, iq.predicates...),
+		withGroup:              iq.withGroup.Clone(),
 		withParent:             iq.withParent.Clone(),
 		withChildren:           iq.withChildren.Clone(),
-		withGroup:              iq.withGroup.Clone(),
 		withLabel:              iq.withLabel.Clone(),
 		withLocation:           iq.withLocation.Clone(),
 		withFields:             iq.withFields.Clone(),
@@ -456,6 +456,17 @@ func (iq *ItemQuery) Clone() *ItemQuery {
 	}
 }
 
+// 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 (iq *ItemQuery) WithGroup(opts ...func(*GroupQuery)) *ItemQuery {
+	query := (&GroupClient{config: iq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	iq.withGroup = query
+	return iq
+}
+
 // WithParent tells the query-builder to eager-load the nodes that are connected to
 // the "parent" edge. The optional arguments are used to configure the query builder of the edge.
 func (iq *ItemQuery) WithParent(opts ...func(*ItemQuery)) *ItemQuery {
@@ -478,17 +489,6 @@ func (iq *ItemQuery) WithChildren(opts ...func(*ItemQuery)) *ItemQuery {
 	return iq
 }
 
-// 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 (iq *ItemQuery) WithGroup(opts ...func(*GroupQuery)) *ItemQuery {
-	query := (&GroupClient{config: iq.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	iq.withGroup = query
-	return iq
-}
-
 // WithLabel tells the query-builder to eager-load the nodes that are connected to
 // the "label" edge. The optional arguments are used to configure the query builder of the edge.
 func (iq *ItemQuery) WithLabel(opts ...func(*LabelQuery)) *ItemQuery {
@@ -624,9 +624,9 @@ func (iq *ItemQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Item, e
 		withFKs     = iq.withFKs
 		_spec       = iq.querySpec()
 		loadedTypes = [8]bool{
+			iq.withGroup != nil,
 			iq.withParent != nil,
 			iq.withChildren != nil,
-			iq.withGroup != nil,
 			iq.withLabel != nil,
 			iq.withLocation != nil,
 			iq.withFields != nil,
@@ -634,7 +634,7 @@ func (iq *ItemQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Item, e
 			iq.withAttachments != nil,
 		}
 	)
-	if iq.withParent != nil || iq.withGroup != nil || iq.withLocation != nil {
+	if iq.withGroup != nil || iq.withParent != nil || iq.withLocation != nil {
 		withFKs = true
 	}
 	if withFKs {
@@ -658,6 +658,12 @@ func (iq *ItemQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Item, e
 	if len(nodes) == 0 {
 		return nodes, nil
 	}
+	if query := iq.withGroup; query != nil {
+		if err := iq.loadGroup(ctx, query, nodes, nil,
+			func(n *Item, e *Group) { n.Edges.Group = e }); err != nil {
+			return nil, err
+		}
+	}
 	if query := iq.withParent; query != nil {
 		if err := iq.loadParent(ctx, query, nodes, nil,
 			func(n *Item, e *Item) { n.Edges.Parent = e }); err != nil {
@@ -671,12 +677,6 @@ func (iq *ItemQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Item, e
 			return nil, err
 		}
 	}
-	if query := iq.withGroup; query != nil {
-		if err := iq.loadGroup(ctx, query, nodes, nil,
-			func(n *Item, e *Group) { n.Edges.Group = e }); err != nil {
-			return nil, err
-		}
-	}
 	if query := iq.withLabel; query != nil {
 		if err := iq.loadLabel(ctx, query, nodes,
 			func(n *Item) { n.Edges.Label = []*Label{} },
@@ -714,6 +714,38 @@ func (iq *ItemQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Item, e
 	return nodes, nil
 }
 
+func (iq *ItemQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes []*Item, init func(*Item), assign func(*Item, *Group)) error {
+	ids := make([]uuid.UUID, 0, len(nodes))
+	nodeids := make(map[uuid.UUID][]*Item)
+	for i := range nodes {
+		if nodes[i].group_items == nil {
+			continue
+		}
+		fk := *nodes[i].group_items
+		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_items" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
 func (iq *ItemQuery) loadParent(ctx context.Context, query *ItemQuery, nodes []*Item, init func(*Item), assign func(*Item, *Item)) error {
 	ids := make([]uuid.UUID, 0, len(nodes))
 	nodeids := make(map[uuid.UUID][]*Item)
@@ -777,38 +809,6 @@ func (iq *ItemQuery) loadChildren(ctx context.Context, query *ItemQuery, nodes [
 	}
 	return nil
 }
-func (iq *ItemQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes []*Item, init func(*Item), assign func(*Item, *Group)) error {
-	ids := make([]uuid.UUID, 0, len(nodes))
-	nodeids := make(map[uuid.UUID][]*Item)
-	for i := range nodes {
-		if nodes[i].group_items == nil {
-			continue
-		}
-		fk := *nodes[i].group_items
-		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_items" returned %v`, n.ID)
-		}
-		for i := range nodes {
-			assign(nodes[i], n)
-		}
-	}
-	return nil
-}
 func (iq *ItemQuery) loadLabel(ctx context.Context, query *LabelQuery, nodes []*Item, init func(*Item), assign func(*Item, *Label)) error {
 	edgeIDs := make([]driver.Value, len(nodes))
 	byID := make(map[uuid.UUID]*Item)

backend/internal/data/ent/item_update.go

@@ -433,6 +433,17 @@ func (iu *ItemUpdate) ClearSoldNotes() *ItemUpdate {
 	return iu
 }
 
+// SetGroupID sets the "group" edge to the Group entity by ID.
+func (iu *ItemUpdate) SetGroupID(id uuid.UUID) *ItemUpdate {
+	iu.mutation.SetGroupID(id)
+	return iu
+}
+
+// SetGroup sets the "group" edge to the Group entity.
+func (iu *ItemUpdate) SetGroup(g *Group) *ItemUpdate {
+	return iu.SetGroupID(g.ID)
+}
+
 // SetParentID sets the "parent" edge to the Item entity by ID.
 func (iu *ItemUpdate) SetParentID(id uuid.UUID) *ItemUpdate {
 	iu.mutation.SetParentID(id)
@@ -467,17 +478,6 @@ func (iu *ItemUpdate) AddChildren(i ...*Item) *ItemUpdate {
 	return iu.AddChildIDs(ids...)
 }
 
-// SetGroupID sets the "group" edge to the Group entity by ID.
-func (iu *ItemUpdate) SetGroupID(id uuid.UUID) *ItemUpdate {
-	iu.mutation.SetGroupID(id)
-	return iu
-}
-
-// SetGroup sets the "group" edge to the Group entity.
-func (iu *ItemUpdate) SetGroup(g *Group) *ItemUpdate {
-	return iu.SetGroupID(g.ID)
-}
-
 // AddLabelIDs adds the "label" edge to the Label entity by IDs.
 func (iu *ItemUpdate) AddLabelIDs(ids ...uuid.UUID) *ItemUpdate {
 	iu.mutation.AddLabelIDs(ids...)
@@ -562,6 +562,12 @@ func (iu *ItemUpdate) Mutation() *ItemMutation {
 	return iu.mutation
 }
 
+// ClearGroup clears the "group" edge to the Group entity.
+func (iu *ItemUpdate) ClearGroup() *ItemUpdate {
+	iu.mutation.ClearGroup()
+	return iu
+}
+
 // ClearParent clears the "parent" edge to the Item entity.
 func (iu *ItemUpdate) ClearParent() *ItemUpdate {
 	iu.mutation.ClearParent()
@@ -589,12 +595,6 @@ func (iu *ItemUpdate) RemoveChildren(i ...*Item) *ItemUpdate {
 	return iu.RemoveChildIDs(ids...)
 }
 
-// ClearGroup clears the "group" edge to the Group entity.
-func (iu *ItemUpdate) ClearGroup() *ItemUpdate {
-	iu.mutation.ClearGroup()
-	return iu
-}
-
 // ClearLabel clears all "label" edges to the Label entity.
 func (iu *ItemUpdate) ClearLabel() *ItemUpdate {
 	iu.mutation.ClearLabel()
@@ -903,6 +903,41 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if iu.mutation.SoldNotesCleared() {
 		_spec.ClearField(item.FieldSoldNotes, field.TypeString)
 	}
+	if iu.mutation.GroupCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   item.GroupTable,
+			Columns: []string{item.GroupColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: &sqlgraph.FieldSpec{
+					Type:   field.TypeUUID,
+					Column: group.FieldID,
+				},
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := iu.mutation.GroupIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   item.GroupTable,
+			Columns: []string{item.GroupColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: &sqlgraph.FieldSpec{
+					Type:   field.TypeUUID,
+					Column: group.FieldID,
+				},
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
 	if iu.mutation.ParentCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2O,
@@ -992,41 +1027,6 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	if iu.mutation.GroupCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   item.GroupTable,
-			Columns: []string{item.GroupColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: &sqlgraph.FieldSpec{
-					Type:   field.TypeUUID,
-					Column: group.FieldID,
-				},
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := iu.mutation.GroupIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   item.GroupTable,
-			Columns: []string{item.GroupColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: &sqlgraph.FieldSpec{
-					Type:   field.TypeUUID,
-					Column: group.FieldID,
-				},
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
 	if iu.mutation.LabelCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2M,
@@ -1696,6 +1696,17 @@ func (iuo *ItemUpdateOne) ClearSoldNotes() *ItemUpdateOne {
 	return iuo
 }
 
+// SetGroupID sets the "group" edge to the Group entity by ID.
+func (iuo *ItemUpdateOne) SetGroupID(id uuid.UUID) *ItemUpdateOne {
+	iuo.mutation.SetGroupID(id)
+	return iuo
+}
+
+// SetGroup sets the "group" edge to the Group entity.
+func (iuo *ItemUpdateOne) SetGroup(g *Group) *ItemUpdateOne {
+	return iuo.SetGroupID(g.ID)
+}
+
 // SetParentID sets the "parent" edge to the Item entity by ID.
 func (iuo *ItemUpdateOne) SetParentID(id uuid.UUID) *ItemUpdateOne {
 	iuo.mutation.SetParentID(id)
@@ -1730,17 +1741,6 @@ func (iuo *ItemUpdateOne) AddChildren(i ...*Item) *ItemUpdateOne {
 	return iuo.AddChildIDs(ids...)
 }
 
-// SetGroupID sets the "group" edge to the Group entity by ID.
-func (iuo *ItemUpdateOne) SetGroupID(id uuid.UUID) *ItemUpdateOne {
-	iuo.mutation.SetGroupID(id)
-	return iuo
-}
-
-// SetGroup sets the "group" edge to the Group entity.
-func (iuo *ItemUpdateOne) SetGroup(g *Group) *ItemUpdateOne {
-	return iuo.SetGroupID(g.ID)
-}
-
 // AddLabelIDs adds the "label" edge to the Label entity by IDs.
 func (iuo *ItemUpdateOne) AddLabelIDs(ids ...uuid.UUID) *ItemUpdateOne {
 	iuo.mutation.AddLabelIDs(ids...)
@@ -1825,6 +1825,12 @@ func (iuo *ItemUpdateOne) Mutation() *ItemMutation {
 	return iuo.mutation
 }
 
+// ClearGroup clears the "group" edge to the Group entity.
+func (iuo *ItemUpdateOne) ClearGroup() *ItemUpdateOne {
+	iuo.mutation.ClearGroup()
+	return iuo
+}
+
 // ClearParent clears the "parent" edge to the Item entity.
 func (iuo *ItemUpdateOne) ClearParent() *ItemUpdateOne {
 	iuo.mutation.ClearParent()
@@ -1852,12 +1858,6 @@ func (iuo *ItemUpdateOne) RemoveChildren(i ...*Item) *ItemUpdateOne {
 	return iuo.RemoveChildIDs(ids...)
 }
 
-// ClearGroup clears the "group" edge to the Group entity.
-func (iuo *ItemUpdateOne) ClearGroup() *ItemUpdateOne {
-	iuo.mutation.ClearGroup()
-	return iuo
-}
-
 // ClearLabel clears all "label" edges to the Label entity.
 func (iuo *ItemUpdateOne) ClearLabel() *ItemUpdateOne {
 	iuo.mutation.ClearLabel()
@@ -2196,6 +2196,41 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
 	if iuo.mutation.SoldNotesCleared() {
 		_spec.ClearField(item.FieldSoldNotes, field.TypeString)
 	}
+	if iuo.mutation.GroupCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   item.GroupTable,
+			Columns: []string{item.GroupColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: &sqlgraph.FieldSpec{
+					Type:   field.TypeUUID,
+					Column: group.FieldID,
+				},
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := iuo.mutation.GroupIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   item.GroupTable,
+			Columns: []string{item.GroupColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: &sqlgraph.FieldSpec{
+					Type:   field.TypeUUID,
+					Column: group.FieldID,
+				},
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
 	if iuo.mutation.ParentCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2O,
@@ -2285,41 +2320,6 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	if iuo.mutation.GroupCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   item.GroupTable,
-			Columns: []string{item.GroupColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: &sqlgraph.FieldSpec{
-					Type:   field.TypeUUID,
-					Column: group.FieldID,
-				},
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := iuo.mutation.GroupIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   item.GroupTable,
-			Columns: []string{item.GroupColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: &sqlgraph.FieldSpec{
-					Type:   field.TypeUUID,
-					Column: group.FieldID,
-				},
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
 	if iuo.mutation.LabelCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2M,

backend/internal/data/ent/location.go

@@ -35,12 +35,12 @@ type Location struct {
 
 // LocationEdges holds the relations/edges for other nodes in the graph.
 type LocationEdges struct {
+	// Group holds the value of the group edge.
+	Group *Group `json:"group,omitempty"`
 	// Parent holds the value of the parent edge.
 	Parent *Location `json:"parent,omitempty"`
 	// Children holds the value of the children edge.
 	Children []*Location `json:"children,omitempty"`
-	// Group holds the value of the group edge.
-	Group *Group `json:"group,omitempty"`
 	// Items holds the value of the items edge.
 	Items []*Item `json:"items,omitempty"`
 	// loadedTypes holds the information for reporting if a
@@ -48,10 +48,23 @@ type LocationEdges struct {
 	loadedTypes [4]bool
 }
 
+// GroupOrErr returns the Group value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e LocationEdges) GroupOrErr() (*Group, error) {
+	if e.loadedTypes[0] {
+		if e.Group == nil {
+			// Edge was loaded but was not found.
+			return nil, &NotFoundError{label: group.Label}
+		}
+		return e.Group, nil
+	}
+	return nil, &NotLoadedError{edge: "group"}
+}
+
 // ParentOrErr returns the Parent value or an error if the edge
 // was not loaded in eager-loading, or loaded but was not found.
 func (e LocationEdges) ParentOrErr() (*Location, error) {
-	if e.loadedTypes[0] {
+	if e.loadedTypes[1] {
 		if e.Parent == nil {
 			// Edge was loaded but was not found.
 			return nil, &NotFoundError{label: location.Label}
@@ -64,25 +77,12 @@ func (e LocationEdges) ParentOrErr() (*Location, error) {
 // ChildrenOrErr returns the Children value or an error if the edge
 // was not loaded in eager-loading.
 func (e LocationEdges) ChildrenOrErr() ([]*Location, error) {
-	if e.loadedTypes[1] {
+	if e.loadedTypes[2] {
 		return e.Children, nil
 	}
 	return nil, &NotLoadedError{edge: "children"}
 }
 
-// GroupOrErr returns the Group value or an error if the edge
-// was not loaded in eager-loading, or loaded but was not found.
-func (e LocationEdges) GroupOrErr() (*Group, error) {
-	if e.loadedTypes[2] {
-		if e.Group == nil {
-			// Edge was loaded but was not found.
-			return nil, &NotFoundError{label: group.Label}
-		}
-		return e.Group, nil
-	}
-	return nil, &NotLoadedError{edge: "group"}
-}
-
 // ItemsOrErr returns the Items value or an error if the edge
 // was not loaded in eager-loading.
 func (e LocationEdges) ItemsOrErr() ([]*Item, error) {
@@ -171,6 +171,11 @@ func (l *Location) assignValues(columns []string, values []any) error {
 	return nil
 }
 
+// QueryGroup queries the "group" edge of the Location entity.
+func (l *Location) QueryGroup() *GroupQuery {
+	return NewLocationClient(l.config).QueryGroup(l)
+}
+
 // QueryParent queries the "parent" edge of the Location entity.
 func (l *Location) QueryParent() *LocationQuery {
 	return NewLocationClient(l.config).QueryParent(l)
@@ -181,11 +186,6 @@ func (l *Location) QueryChildren() *LocationQuery {
 	return NewLocationClient(l.config).QueryChildren(l)
 }
 
-// QueryGroup queries the "group" edge of the Location entity.
-func (l *Location) QueryGroup() *GroupQuery {
-	return NewLocationClient(l.config).QueryGroup(l)
-}
-
 // QueryItems queries the "items" edge of the Location entity.
 func (l *Location) QueryItems() *ItemQuery {
 	return NewLocationClient(l.config).QueryItems(l)

backend/internal/data/ent/location/location.go

@@ -21,16 +21,23 @@ const (
 	FieldName = "name"
 	// FieldDescription holds the string denoting the description field in the database.
 	FieldDescription = "description"
+	// EdgeGroup holds the string denoting the group edge name in mutations.
+	EdgeGroup = "group"
 	// EdgeParent holds the string denoting the parent edge name in mutations.
 	EdgeParent = "parent"
 	// EdgeChildren holds the string denoting the children edge name in mutations.
 	EdgeChildren = "children"
-	// EdgeGroup holds the string denoting the group edge name in mutations.
-	EdgeGroup = "group"
 	// EdgeItems holds the string denoting the items edge name in mutations.
 	EdgeItems = "items"
 	// Table holds the table name of the location in the database.
 	Table = "locations"
+	// GroupTable is the table that holds the group relation/edge.
+	GroupTable = "locations"
+	// GroupInverseTable is the table name for the Group entity.
+	// It exists in this package in order to avoid circular dependency with the "group" package.
+	GroupInverseTable = "groups"
+	// GroupColumn is the table column denoting the group relation/edge.
+	GroupColumn = "group_locations"
 	// ParentTable is the table that holds the parent relation/edge.
 	ParentTable = "locations"
 	// ParentColumn is the table column denoting the parent relation/edge.
@@ -39,13 +46,6 @@ const (
 	ChildrenTable = "locations"
 	// ChildrenColumn is the table column denoting the children relation/edge.
 	ChildrenColumn = "location_children"
-	// GroupTable is the table that holds the group relation/edge.
-	GroupTable = "locations"
-	// GroupInverseTable is the table name for the Group entity.
-	// It exists in this package in order to avoid circular dependency with the "group" package.
-	GroupInverseTable = "groups"
-	// GroupColumn is the table column denoting the group relation/edge.
-	GroupColumn = "group_locations"
 	// ItemsTable is the table that holds the items relation/edge.
 	ItemsTable = "items"
 	// ItemsInverseTable is the table name for the Item entity.

backend/internal/data/ent/location/where.go

@@ -296,6 +296,33 @@ func DescriptionContainsFold(v string) predicate.Location {
 	return predicate.Location(sql.FieldContainsFold(FieldDescription, v))
 }
 
+// HasGroup applies the HasEdge predicate on the "group" edge.
+func HasGroup() predicate.Location {
+	return predicate.Location(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasGroupWith applies the HasEdge predicate on the "group" edge with a given conditions (other predicates).
+func HasGroupWith(preds ...predicate.Group) predicate.Location {
+	return predicate.Location(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.To(GroupInverseTable, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
+		)
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
 // HasParent applies the HasEdge predicate on the "parent" edge.
 func HasParent() predicate.Location {
 	return predicate.Location(func(s *sql.Selector) {
@@ -350,33 +377,6 @@ func HasChildrenWith(preds ...predicate.Location) predicate.Location {
 	})
 }
 
-// HasGroup applies the HasEdge predicate on the "group" edge.
-func HasGroup() predicate.Location {
-	return predicate.Location(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasGroupWith applies the HasEdge predicate on the "group" edge with a given conditions (other predicates).
-func HasGroupWith(preds ...predicate.Group) predicate.Location {
-	return predicate.Location(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.To(GroupInverseTable, FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
-		)
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
 // HasItems applies the HasEdge predicate on the "items" edge.
 func HasItems() predicate.Location {
 	return predicate.Location(func(s *sql.Selector) {

backend/internal/data/ent/location_create.go

@@ -85,6 +85,17 @@ func (lc *LocationCreate) SetNillableID(u *uuid.UUID) *LocationCreate {
 	return lc
 }
 
+// SetGroupID sets the "group" edge to the Group entity by ID.
+func (lc *LocationCreate) SetGroupID(id uuid.UUID) *LocationCreate {
+	lc.mutation.SetGroupID(id)
+	return lc
+}
+
+// SetGroup sets the "group" edge to the Group entity.
+func (lc *LocationCreate) SetGroup(g *Group) *LocationCreate {
+	return lc.SetGroupID(g.ID)
+}
+
 // SetParentID sets the "parent" edge to the Location entity by ID.
 func (lc *LocationCreate) SetParentID(id uuid.UUID) *LocationCreate {
 	lc.mutation.SetParentID(id)
@@ -119,17 +130,6 @@ func (lc *LocationCreate) AddChildren(l ...*Location) *LocationCreate {
 	return lc.AddChildIDs(ids...)
 }
 
-// SetGroupID sets the "group" edge to the Group entity by ID.
-func (lc *LocationCreate) SetGroupID(id uuid.UUID) *LocationCreate {
-	lc.mutation.SetGroupID(id)
-	return lc
-}
-
-// SetGroup sets the "group" edge to the Group entity.
-func (lc *LocationCreate) SetGroup(g *Group) *LocationCreate {
-	return lc.SetGroupID(g.ID)
-}
-
 // AddItemIDs adds the "items" edge to the Item entity by IDs.
 func (lc *LocationCreate) AddItemIDs(ids ...uuid.UUID) *LocationCreate {
 	lc.mutation.AddItemIDs(ids...)
@@ -269,6 +269,26 @@ func (lc *LocationCreate) createSpec() (*Location, *sqlgraph.CreateSpec) {
 		_spec.SetField(location.FieldDescription, field.TypeString, value)
 		_node.Description = value
 	}
+	if nodes := lc.mutation.GroupIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   location.GroupTable,
+			Columns: []string{location.GroupColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: &sqlgraph.FieldSpec{
+					Type:   field.TypeUUID,
+					Column: group.FieldID,
+				},
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.group_locations = &nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
 	if nodes := lc.mutation.ParentIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2O,
@@ -308,26 +328,6 @@ func (lc *LocationCreate) createSpec() (*Location, *sqlgraph.CreateSpec) {
 		}
 		_spec.Edges = append(_spec.Edges, edge)
 	}
-	if nodes := lc.mutation.GroupIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   location.GroupTable,
-			Columns: []string{location.GroupColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: &sqlgraph.FieldSpec{
-					Type:   field.TypeUUID,
-					Column: group.FieldID,
-				},
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_node.group_locations = &nodes[0]
-		_spec.Edges = append(_spec.Edges, edge)
-	}
 	if nodes := lc.mutation.ItemsIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,

backend/internal/data/ent/location_query.go

@@ -25,9 +25,9 @@ type LocationQuery struct {
 	order        []OrderFunc
 	inters       []Interceptor
 	predicates   []predicate.Location
+	withGroup    *GroupQuery
 	withParent   *LocationQuery
 	withChildren *LocationQuery
-	withGroup    *GroupQuery
 	withItems    *ItemQuery
 	withFKs      bool
 	// intermediate query (i.e. traversal path).
@@ -66,6 +66,28 @@ func (lq *LocationQuery) Order(o ...OrderFunc) *LocationQuery {
 	return lq
 }
 
+// QueryGroup chains the current query on the "group" edge.
+func (lq *LocationQuery) QueryGroup() *GroupQuery {
+	query := (&GroupClient{config: lq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := lq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := lq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(location.Table, location.FieldID, selector),
+			sqlgraph.To(group.Table, group.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, location.GroupTable, location.GroupColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(lq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
 // QueryParent chains the current query on the "parent" edge.
 func (lq *LocationQuery) QueryParent() *LocationQuery {
 	query := (&LocationClient{config: lq.config}).Query()
@@ -110,28 +132,6 @@ func (lq *LocationQuery) QueryChildren() *LocationQuery {
 	return query
 }
 
-// QueryGroup chains the current query on the "group" edge.
-func (lq *LocationQuery) QueryGroup() *GroupQuery {
-	query := (&GroupClient{config: lq.config}).Query()
-	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
-		if err := lq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		selector := lq.sqlQuery(ctx)
-		if err := selector.Err(); err != nil {
-			return nil, err
-		}
-		step := sqlgraph.NewStep(
-			sqlgraph.From(location.Table, location.FieldID, selector),
-			sqlgraph.To(group.Table, group.FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, location.GroupTable, location.GroupColumn),
-		)
-		fromU = sqlgraph.SetNeighbors(lq.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
 // QueryItems chains the current query on the "items" edge.
 func (lq *LocationQuery) QueryItems() *ItemQuery {
 	query := (&ItemClient{config: lq.config}).Query()
@@ -346,9 +346,9 @@ func (lq *LocationQuery) Clone() *LocationQuery {
 		order:        append([]OrderFunc{}, lq.order...),
 		inters:       append([]Interceptor{}, lq.inters...),
 		predicates:   append([]predicate.Location{}, lq.predicates...),
+		withGroup:    lq.withGroup.Clone(),
 		withParent:   lq.withParent.Clone(),
 		withChildren: lq.withChildren.Clone(),
-		withGroup:    lq.withGroup.Clone(),
 		withItems:    lq.withItems.Clone(),
 		// clone intermediate query.
 		sql:  lq.sql.Clone(),
@@ -356,6 +356,17 @@ func (lq *LocationQuery) Clone() *LocationQuery {
 	}
 }
 
+// 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 (lq *LocationQuery) WithGroup(opts ...func(*GroupQuery)) *LocationQuery {
+	query := (&GroupClient{config: lq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	lq.withGroup = query
+	return lq
+}
+
 // WithParent tells the query-builder to eager-load the nodes that are connected to
 // the "parent" edge. The optional arguments are used to configure the query builder of the edge.
 func (lq *LocationQuery) WithParent(opts ...func(*LocationQuery)) *LocationQuery {
@@ -378,17 +389,6 @@ func (lq *LocationQuery) WithChildren(opts ...func(*LocationQuery)) *LocationQue
 	return lq
 }
 
-// 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 (lq *LocationQuery) WithGroup(opts ...func(*GroupQuery)) *LocationQuery {
-	query := (&GroupClient{config: lq.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	lq.withGroup = query
-	return lq
-}
-
 // WithItems tells the query-builder to eager-load the nodes that are connected to
 // the "items" edge. The optional arguments are used to configure the query builder of the edge.
 func (lq *LocationQuery) WithItems(opts ...func(*ItemQuery)) *LocationQuery {
@@ -480,13 +480,13 @@ func (lq *LocationQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Loc
 		withFKs     = lq.withFKs
 		_spec       = lq.querySpec()
 		loadedTypes = [4]bool{
+			lq.withGroup != nil,
 			lq.withParent != nil,
 			lq.withChildren != nil,
-			lq.withGroup != nil,
 			lq.withItems != nil,
 		}
 	)
-	if lq.withParent != nil || lq.withGroup != nil {
+	if lq.withGroup != nil || lq.withParent != nil {
 		withFKs = true
 	}
 	if withFKs {
@@ -510,6 +510,12 @@ func (lq *LocationQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Loc
 	if len(nodes) == 0 {
 		return nodes, nil
 	}
+	if query := lq.withGroup; query != nil {
+		if err := lq.loadGroup(ctx, query, nodes, nil,
+			func(n *Location, e *Group) { n.Edges.Group = e }); err != nil {
+			return nil, err
+		}
+	}
 	if query := lq.withParent; query != nil {
 		if err := lq.loadParent(ctx, query, nodes, nil,
 			func(n *Location, e *Location) { n.Edges.Parent = e }); err != nil {
@@ -523,12 +529,6 @@ func (lq *LocationQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Loc
 			return nil, err
 		}
 	}
-	if query := lq.withGroup; query != nil {
-		if err := lq.loadGroup(ctx, query, nodes, nil,
-			func(n *Location, e *Group) { n.Edges.Group = e }); err != nil {
-			return nil, err
-		}
-	}
 	if query := lq.withItems; query != nil {
 		if err := lq.loadItems(ctx, query, nodes,
 			func(n *Location) { n.Edges.Items = []*Item{} },
@@ -539,6 +539,38 @@ func (lq *LocationQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Loc
 	return nodes, nil
 }
 
+func (lq *LocationQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes []*Location, init func(*Location), assign func(*Location, *Group)) error {
+	ids := make([]uuid.UUID, 0, len(nodes))
+	nodeids := make(map[uuid.UUID][]*Location)
+	for i := range nodes {
+		if nodes[i].group_locations == nil {
+			continue
+		}
+		fk := *nodes[i].group_locations
+		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_locations" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
 func (lq *LocationQuery) loadParent(ctx context.Context, query *LocationQuery, nodes []*Location, init func(*Location), assign func(*Location, *Location)) error {
 	ids := make([]uuid.UUID, 0, len(nodes))
 	nodeids := make(map[uuid.UUID][]*Location)
@@ -602,38 +634,6 @@ func (lq *LocationQuery) loadChildren(ctx context.Context, query *LocationQuery,
 	}
 	return nil
 }
-func (lq *LocationQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes []*Location, init func(*Location), assign func(*Location, *Group)) error {
-	ids := make([]uuid.UUID, 0, len(nodes))
-	nodeids := make(map[uuid.UUID][]*Location)
-	for i := range nodes {
-		if nodes[i].group_locations == nil {
-			continue
-		}
-		fk := *nodes[i].group_locations
-		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_locations" returned %v`, n.ID)
-		}
-		for i := range nodes {
-			assign(nodes[i], n)
-		}
-	}
-	return nil
-}
 func (lq *LocationQuery) loadItems(ctx context.Context, query *ItemQuery, nodes []*Location, init func(*Location), assign func(*Location, *Item)) error {
 	fks := make([]driver.Value, 0, len(nodes))
 	nodeids := make(map[uuid.UUID]*Location)

backend/internal/data/ent/location_update.go

@@ -63,6 +63,17 @@ func (lu *LocationUpdate) ClearDescription() *LocationUpdate {
 	return lu
 }
 
+// SetGroupID sets the "group" edge to the Group entity by ID.
+func (lu *LocationUpdate) SetGroupID(id uuid.UUID) *LocationUpdate {
+	lu.mutation.SetGroupID(id)
+	return lu
+}
+
+// SetGroup sets the "group" edge to the Group entity.
+func (lu *LocationUpdate) SetGroup(g *Group) *LocationUpdate {
+	return lu.SetGroupID(g.ID)
+}
+
 // SetParentID sets the "parent" edge to the Location entity by ID.
 func (lu *LocationUpdate) SetParentID(id uuid.UUID) *LocationUpdate {
 	lu.mutation.SetParentID(id)
@@ -97,17 +108,6 @@ func (lu *LocationUpdate) AddChildren(l ...*Location) *LocationUpdate {
 	return lu.AddChildIDs(ids...)
 }
 
-// SetGroupID sets the "group" edge to the Group entity by ID.
-func (lu *LocationUpdate) SetGroupID(id uuid.UUID) *LocationUpdate {
-	lu.mutation.SetGroupID(id)
-	return lu
-}
-
-// SetGroup sets the "group" edge to the Group entity.
-func (lu *LocationUpdate) SetGroup(g *Group) *LocationUpdate {
-	return lu.SetGroupID(g.ID)
-}
-
 // AddItemIDs adds the "items" edge to the Item entity by IDs.
 func (lu *LocationUpdate) AddItemIDs(ids ...uuid.UUID) *LocationUpdate {
 	lu.mutation.AddItemIDs(ids...)
@@ -128,6 +128,12 @@ func (lu *LocationUpdate) Mutation() *LocationMutation {
 	return lu.mutation
 }
 
+// ClearGroup clears the "group" edge to the Group entity.
+func (lu *LocationUpdate) ClearGroup() *LocationUpdate {
+	lu.mutation.ClearGroup()
+	return lu
+}
+
 // ClearParent clears the "parent" edge to the Location entity.
 func (lu *LocationUpdate) ClearParent() *LocationUpdate {
 	lu.mutation.ClearParent()
@@ -155,12 +161,6 @@ func (lu *LocationUpdate) RemoveChildren(l ...*Location) *LocationUpdate {
 	return lu.RemoveChildIDs(ids...)
 }
 
-// ClearGroup clears the "group" edge to the Group entity.
-func (lu *LocationUpdate) ClearGroup() *LocationUpdate {
-	lu.mutation.ClearGroup()
-	return lu
-}
-
 // ClearItems clears all "items" edges to the Item entity.
 func (lu *LocationUpdate) ClearItems() *LocationUpdate {
 	lu.mutation.ClearItems()
@@ -260,6 +260,41 @@ func (lu *LocationUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if lu.mutation.DescriptionCleared() {
 		_spec.ClearField(location.FieldDescription, field.TypeString)
 	}
+	if lu.mutation.GroupCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   location.GroupTable,
+			Columns: []string{location.GroupColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: &sqlgraph.FieldSpec{
+					Type:   field.TypeUUID,
+					Column: group.FieldID,
+				},
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := lu.mutation.GroupIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   location.GroupTable,
+			Columns: []string{location.GroupColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: &sqlgraph.FieldSpec{
+					Type:   field.TypeUUID,
+					Column: group.FieldID,
+				},
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
 	if lu.mutation.ParentCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2O,
@@ -349,41 +384,6 @@ func (lu *LocationUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	if lu.mutation.GroupCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   location.GroupTable,
-			Columns: []string{location.GroupColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: &sqlgraph.FieldSpec{
-					Type:   field.TypeUUID,
-					Column: group.FieldID,
-				},
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := lu.mutation.GroupIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   location.GroupTable,
-			Columns: []string{location.GroupColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: &sqlgraph.FieldSpec{
-					Type:   field.TypeUUID,
-					Column: group.FieldID,
-				},
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
 	if lu.mutation.ItemsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
@@ -490,6 +490,17 @@ func (luo *LocationUpdateOne) ClearDescription() *LocationUpdateOne {
 	return luo
 }
 
+// SetGroupID sets the "group" edge to the Group entity by ID.
+func (luo *LocationUpdateOne) SetGroupID(id uuid.UUID) *LocationUpdateOne {
+	luo.mutation.SetGroupID(id)
+	return luo
+}
+
+// SetGroup sets the "group" edge to the Group entity.
+func (luo *LocationUpdateOne) SetGroup(g *Group) *LocationUpdateOne {
+	return luo.SetGroupID(g.ID)
+}
+
 // SetParentID sets the "parent" edge to the Location entity by ID.
 func (luo *LocationUpdateOne) SetParentID(id uuid.UUID) *LocationUpdateOne {
 	luo.mutation.SetParentID(id)
@@ -524,17 +535,6 @@ func (luo *LocationUpdateOne) AddChildren(l ...*Location) *LocationUpdateOne {
 	return luo.AddChildIDs(ids...)
 }
 
-// SetGroupID sets the "group" edge to the Group entity by ID.
-func (luo *LocationUpdateOne) SetGroupID(id uuid.UUID) *LocationUpdateOne {
-	luo.mutation.SetGroupID(id)
-	return luo
-}
-
-// SetGroup sets the "group" edge to the Group entity.
-func (luo *LocationUpdateOne) SetGroup(g *Group) *LocationUpdateOne {
-	return luo.SetGroupID(g.ID)
-}
-
 // AddItemIDs adds the "items" edge to the Item entity by IDs.
 func (luo *LocationUpdateOne) AddItemIDs(ids ...uuid.UUID) *LocationUpdateOne {
 	luo.mutation.AddItemIDs(ids...)
@@ -555,6 +555,12 @@ func (luo *LocationUpdateOne) Mutation() *LocationMutation {
 	return luo.mutation
 }
 
+// ClearGroup clears the "group" edge to the Group entity.
+func (luo *LocationUpdateOne) ClearGroup() *LocationUpdateOne {
+	luo.mutation.ClearGroup()
+	return luo
+}
+
 // ClearParent clears the "parent" edge to the Location entity.
 func (luo *LocationUpdateOne) ClearParent() *LocationUpdateOne {
 	luo.mutation.ClearParent()
@@ -582,12 +588,6 @@ func (luo *LocationUpdateOne) RemoveChildren(l ...*Location) *LocationUpdateOne
 	return luo.RemoveChildIDs(ids...)
 }
 
-// ClearGroup clears the "group" edge to the Group entity.
-func (luo *LocationUpdateOne) ClearGroup() *LocationUpdateOne {
-	luo.mutation.ClearGroup()
-	return luo
-}
-
 // ClearItems clears all "items" edges to the Item entity.
 func (luo *LocationUpdateOne) ClearItems() *LocationUpdateOne {
 	luo.mutation.ClearItems()
@@ -717,6 +717,41 @@ func (luo *LocationUpdateOne) sqlSave(ctx context.Context) (_node *Location, err
 	if luo.mutation.DescriptionCleared() {
 		_spec.ClearField(location.FieldDescription, field.TypeString)
 	}
+	if luo.mutation.GroupCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   location.GroupTable,
+			Columns: []string{location.GroupColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: &sqlgraph.FieldSpec{
+					Type:   field.TypeUUID,
+					Column: group.FieldID,
+				},
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := luo.mutation.GroupIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   location.GroupTable,
+			Columns: []string{location.GroupColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: &sqlgraph.FieldSpec{
+					Type:   field.TypeUUID,
+					Column: group.FieldID,
+				},
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
 	if luo.mutation.ParentCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2O,
@@ -806,41 +841,6 @@ func (luo *LocationUpdateOne) sqlSave(ctx context.Context) (_node *Location, err
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	if luo.mutation.GroupCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   location.GroupTable,
-			Columns: []string{location.GroupColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: &sqlgraph.FieldSpec{
-					Type:   field.TypeUUID,
-					Column: group.FieldID,
-				},
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := luo.mutation.GroupIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   location.GroupTable,
-			Columns: []string{location.GroupColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: &sqlgraph.FieldSpec{
-					Type:   field.TypeUUID,
-					Column: group.FieldID,
-				},
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
 	if luo.mutation.ItemsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,

backend/internal/data/ent/mutation.go

@@ -4048,13 +4048,13 @@ type ItemMutation struct {
 	addsold_price              *float64
 	sold_notes                 *string
 	clearedFields              map[string]struct{}
+	group                      *uuid.UUID
+	clearedgroup               bool
 	parent                     *uuid.UUID
 	clearedparent              bool
 	children                   map[uuid.UUID]struct{}
 	removedchildren            map[uuid.UUID]struct{}
 	clearedchildren            bool
-	group                      *uuid.UUID
-	clearedgroup               bool
 	label                      map[uuid.UUID]struct{}
 	removedlabel               map[uuid.UUID]struct{}
 	clearedlabel               bool
@@ -5255,6 +5255,45 @@ func (m *ItemMutation) ResetSoldNotes() {
 	delete(m.clearedFields, item.FieldSoldNotes)
 }
 
+// SetGroupID sets the "group" edge to the Group entity by id.
+func (m *ItemMutation) SetGroupID(id uuid.UUID) {
+	m.group = &id
+}
+
+// ClearGroup clears the "group" edge to the Group entity.
+func (m *ItemMutation) ClearGroup() {
+	m.clearedgroup = true
+}
+
+// GroupCleared reports if the "group" edge to the Group entity was cleared.
+func (m *ItemMutation) GroupCleared() bool {
+	return m.clearedgroup
+}
+
+// GroupID returns the "group" edge ID in the mutation.
+func (m *ItemMutation) GroupID() (id uuid.UUID, exists bool) {
+	if m.group != nil {
+		return *m.group, true
+	}
+	return
+}
+
+// GroupIDs returns the "group" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// GroupID instead. It exists only for internal usage by the builders.
+func (m *ItemMutation) GroupIDs() (ids []uuid.UUID) {
+	if id := m.group; id != nil {
+		ids = append(ids, *id)
+	}
+	return
+}
+
+// ResetGroup resets all changes to the "group" edge.
+func (m *ItemMutation) ResetGroup() {
+	m.group = nil
+	m.clearedgroup = false
+}
+
 // SetParentID sets the "parent" edge to the Item entity by id.
 func (m *ItemMutation) SetParentID(id uuid.UUID) {
 	m.parent = &id
@@ -5348,45 +5387,6 @@ func (m *ItemMutation) ResetChildren() {
 	m.removedchildren = nil
 }
 
-// SetGroupID sets the "group" edge to the Group entity by id.
-func (m *ItemMutation) SetGroupID(id uuid.UUID) {
-	m.group = &id
-}
-
-// ClearGroup clears the "group" edge to the Group entity.
-func (m *ItemMutation) ClearGroup() {
-	m.clearedgroup = true
-}
-
-// GroupCleared reports if the "group" edge to the Group entity was cleared.
-func (m *ItemMutation) GroupCleared() bool {
-	return m.clearedgroup
-}
-
-// GroupID returns the "group" edge ID in the mutation.
-func (m *ItemMutation) GroupID() (id uuid.UUID, exists bool) {
-	if m.group != nil {
-		return *m.group, true
-	}
-	return
-}
-
-// GroupIDs returns the "group" edge IDs in the mutation.
-// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
-// GroupID instead. It exists only for internal usage by the builders.
-func (m *ItemMutation) GroupIDs() (ids []uuid.UUID) {
-	if id := m.group; id != nil {
-		ids = append(ids, *id)
-	}
-	return
-}
-
-// ResetGroup resets all changes to the "group" edge.
-func (m *ItemMutation) ResetGroup() {
-	m.group = nil
-	m.clearedgroup = false
-}
-
 // AddLabelIDs adds the "label" edge to the Label entity by ids.
 func (m *ItemMutation) AddLabelIDs(ids ...uuid.UUID) {
 	if m.label == nil {
@@ -6282,15 +6282,15 @@ func (m *ItemMutation) ResetField(name string) error {
 // AddedEdges returns all edge names that were set/added in this mutation.
 func (m *ItemMutation) AddedEdges() []string {
 	edges := make([]string, 0, 8)
+	if m.group != nil {
+		edges = append(edges, item.EdgeGroup)
+	}
 	if m.parent != nil {
 		edges = append(edges, item.EdgeParent)
 	}
 	if m.children != nil {
 		edges = append(edges, item.EdgeChildren)
 	}
-	if m.group != nil {
-		edges = append(edges, item.EdgeGroup)
-	}
 	if m.label != nil {
 		edges = append(edges, item.EdgeLabel)
 	}
@@ -6313,6 +6313,10 @@ func (m *ItemMutation) AddedEdges() []string {
 // name in this mutation.
 func (m *ItemMutation) AddedIDs(name string) []ent.Value {
 	switch name {
+	case item.EdgeGroup:
+		if id := m.group; id != nil {
+			return []ent.Value{*id}
+		}
 	case item.EdgeParent:
 		if id := m.parent; id != nil {
 			return []ent.Value{*id}
@@ -6323,10 +6327,6 @@ func (m *ItemMutation) AddedIDs(name string) []ent.Value {
 			ids = append(ids, id)
 		}
 		return ids
-	case item.EdgeGroup:
-		if id := m.group; id != nil {
-			return []ent.Value{*id}
-		}
 	case item.EdgeLabel:
 		ids := make([]ent.Value, 0, len(m.label))
 		for id := range m.label {
@@ -6421,15 +6421,15 @@ func (m *ItemMutation) RemovedIDs(name string) []ent.Value {
 // ClearedEdges returns all edge names that were cleared in this mutation.
 func (m *ItemMutation) ClearedEdges() []string {
 	edges := make([]string, 0, 8)
+	if m.clearedgroup {
+		edges = append(edges, item.EdgeGroup)
+	}
 	if m.clearedparent {
 		edges = append(edges, item.EdgeParent)
 	}
 	if m.clearedchildren {
 		edges = append(edges, item.EdgeChildren)
 	}
-	if m.clearedgroup {
-		edges = append(edges, item.EdgeGroup)
-	}
 	if m.clearedlabel {
 		edges = append(edges, item.EdgeLabel)
 	}
@@ -6452,12 +6452,12 @@ func (m *ItemMutation) ClearedEdges() []string {
 // was cleared in this mutation.
 func (m *ItemMutation) EdgeCleared(name string) bool {
 	switch name {
+	case item.EdgeGroup:
+		return m.clearedgroup
 	case item.EdgeParent:
 		return m.clearedparent
 	case item.EdgeChildren:
 		return m.clearedchildren
-	case item.EdgeGroup:
-		return m.clearedgroup
 	case item.EdgeLabel:
 		return m.clearedlabel
 	case item.EdgeLocation:
@@ -6476,12 +6476,12 @@ func (m *ItemMutation) EdgeCleared(name string) bool {
 // if that edge is not defined in the schema.
 func (m *ItemMutation) ClearEdge(name string) error {
 	switch name {
-	case item.EdgeParent:
-		m.ClearParent()
-		return nil
 	case item.EdgeGroup:
 		m.ClearGroup()
 		return nil
+	case item.EdgeParent:
+		m.ClearParent()
+		return nil
 	case item.EdgeLocation:
 		m.ClearLocation()
 		return nil
@@ -6493,15 +6493,15 @@ func (m *ItemMutation) ClearEdge(name string) error {
 // It returns an error if the edge is not defined in the schema.
 func (m *ItemMutation) ResetEdge(name string) error {
 	switch name {
+	case item.EdgeGroup:
+		m.ResetGroup()
+		return nil
 	case item.EdgeParent:
 		m.ResetParent()
 		return nil
 	case item.EdgeChildren:
 		m.ResetChildren()
 		return nil
-	case item.EdgeGroup:
-		m.ResetGroup()
-		return nil
 	case item.EdgeLabel:
 		m.ResetLabel()
 		return nil
@@ -8201,13 +8201,13 @@ type LocationMutation struct {
 	name            *string
 	description     *string
 	clearedFields   map[string]struct{}
+	group           *uuid.UUID
+	clearedgroup    bool
 	parent          *uuid.UUID
 	clearedparent   bool
 	children        map[uuid.UUID]struct{}
 	removedchildren map[uuid.UUID]struct{}
 	clearedchildren bool
-	group           *uuid.UUID
-	clearedgroup    bool
 	items           map[uuid.UUID]struct{}
 	removeditems    map[uuid.UUID]struct{}
 	cleareditems    bool
@@ -8477,6 +8477,45 @@ func (m *LocationMutation) ResetDescription() {
 	delete(m.clearedFields, location.FieldDescription)
 }
 
+// SetGroupID sets the "group" edge to the Group entity by id.
+func (m *LocationMutation) SetGroupID(id uuid.UUID) {
+	m.group = &id
+}
+
+// ClearGroup clears the "group" edge to the Group entity.
+func (m *LocationMutation) ClearGroup() {
+	m.clearedgroup = true
+}
+
+// GroupCleared reports if the "group" edge to the Group entity was cleared.
+func (m *LocationMutation) GroupCleared() bool {
+	return m.clearedgroup
+}
+
+// GroupID returns the "group" edge ID in the mutation.
+func (m *LocationMutation) GroupID() (id uuid.UUID, exists bool) {
+	if m.group != nil {
+		return *m.group, true
+	}
+	return
+}
+
+// GroupIDs returns the "group" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// GroupID instead. It exists only for internal usage by the builders.
+func (m *LocationMutation) GroupIDs() (ids []uuid.UUID) {
+	if id := m.group; id != nil {
+		ids = append(ids, *id)
+	}
+	return
+}
+
+// ResetGroup resets all changes to the "group" edge.
+func (m *LocationMutation) ResetGroup() {
+	m.group = nil
+	m.clearedgroup = false
+}
+
 // SetParentID sets the "parent" edge to the Location entity by id.
 func (m *LocationMutation) SetParentID(id uuid.UUID) {
 	m.parent = &id
@@ -8570,45 +8609,6 @@ func (m *LocationMutation) ResetChildren() {
 	m.removedchildren = nil
 }
 
-// SetGroupID sets the "group" edge to the Group entity by id.
-func (m *LocationMutation) SetGroupID(id uuid.UUID) {
-	m.group = &id
-}
-
-// ClearGroup clears the "group" edge to the Group entity.
-func (m *LocationMutation) ClearGroup() {
-	m.clearedgroup = true
-}
-
-// GroupCleared reports if the "group" edge to the Group entity was cleared.
-func (m *LocationMutation) GroupCleared() bool {
-	return m.clearedgroup
-}
-
-// GroupID returns the "group" edge ID in the mutation.
-func (m *LocationMutation) GroupID() (id uuid.UUID, exists bool) {
-	if m.group != nil {
-		return *m.group, true
-	}
-	return
-}
-
-// GroupIDs returns the "group" edge IDs in the mutation.
-// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
-// GroupID instead. It exists only for internal usage by the builders.
-func (m *LocationMutation) GroupIDs() (ids []uuid.UUID) {
-	if id := m.group; id != nil {
-		ids = append(ids, *id)
-	}
-	return
-}
-
-// ResetGroup resets all changes to the "group" edge.
-func (m *LocationMutation) ResetGroup() {
-	m.group = nil
-	m.clearedgroup = false
-}
-
 // AddItemIDs adds the "items" edge to the Item entity by ids.
 func (m *LocationMutation) AddItemIDs(ids ...uuid.UUID) {
 	if m.items == nil {
@@ -8857,15 +8857,15 @@ func (m *LocationMutation) ResetField(name string) error {
 // AddedEdges returns all edge names that were set/added in this mutation.
 func (m *LocationMutation) AddedEdges() []string {
 	edges := make([]string, 0, 4)
+	if m.group != nil {
+		edges = append(edges, location.EdgeGroup)
+	}
 	if m.parent != nil {
 		edges = append(edges, location.EdgeParent)
 	}
 	if m.children != nil {
 		edges = append(edges, location.EdgeChildren)
 	}
-	if m.group != nil {
-		edges = append(edges, location.EdgeGroup)
-	}
 	if m.items != nil {
 		edges = append(edges, location.EdgeItems)
 	}
@@ -8876,6 +8876,10 @@ func (m *LocationMutation) AddedEdges() []string {
 // name in this mutation.
 func (m *LocationMutation) AddedIDs(name string) []ent.Value {
 	switch name {
+	case location.EdgeGroup:
+		if id := m.group; id != nil {
+			return []ent.Value{*id}
+		}
 	case location.EdgeParent:
 		if id := m.parent; id != nil {
 			return []ent.Value{*id}
@@ -8886,10 +8890,6 @@ func (m *LocationMutation) AddedIDs(name string) []ent.Value {
 			ids = append(ids, id)
 		}
 		return ids
-	case location.EdgeGroup:
-		if id := m.group; id != nil {
-			return []ent.Value{*id}
-		}
 	case location.EdgeItems:
 		ids := make([]ent.Value, 0, len(m.items))
 		for id := range m.items {
@@ -8935,15 +8935,15 @@ func (m *LocationMutation) RemovedIDs(name string) []ent.Value {
 // ClearedEdges returns all edge names that were cleared in this mutation.
 func (m *LocationMutation) ClearedEdges() []string {
 	edges := make([]string, 0, 4)
+	if m.clearedgroup {
+		edges = append(edges, location.EdgeGroup)
+	}
 	if m.clearedparent {
 		edges = append(edges, location.EdgeParent)
 	}
 	if m.clearedchildren {
 		edges = append(edges, location.EdgeChildren)
 	}
-	if m.clearedgroup {
-		edges = append(edges, location.EdgeGroup)
-	}
 	if m.cleareditems {
 		edges = append(edges, location.EdgeItems)
 	}
@@ -8954,12 +8954,12 @@ func (m *LocationMutation) ClearedEdges() []string {
 // was cleared in this mutation.
 func (m *LocationMutation) EdgeCleared(name string) bool {
 	switch name {
+	case location.EdgeGroup:
+		return m.clearedgroup
 	case location.EdgeParent:
 		return m.clearedparent
 	case location.EdgeChildren:
 		return m.clearedchildren
-	case location.EdgeGroup:
-		return m.clearedgroup
 	case location.EdgeItems:
 		return m.cleareditems
 	}
@@ -8970,12 +8970,12 @@ func (m *LocationMutation) EdgeCleared(name string) bool {
 // if that edge is not defined in the schema.
 func (m *LocationMutation) ClearEdge(name string) error {
 	switch name {
-	case location.EdgeParent:
-		m.ClearParent()
-		return nil
 	case location.EdgeGroup:
 		m.ClearGroup()
 		return nil
+	case location.EdgeParent:
+		m.ClearParent()
+		return nil
 	}
 	return fmt.Errorf("unknown Location unique edge %s", name)
 }
@@ -8984,15 +8984,15 @@ func (m *LocationMutation) ClearEdge(name string) error {
 // It returns an error if the edge is not defined in the schema.
 func (m *LocationMutation) ResetEdge(name string) error {
 	switch name {
+	case location.EdgeGroup:
+		m.ResetGroup()
+		return nil
 	case location.EdgeParent:
 		m.ResetParent()
 		return nil
 	case location.EdgeChildren:
 		m.ResetChildren()
 		return nil
-	case location.EdgeGroup:
-		m.ResetGroup()
-		return nil
 	case location.EdgeItems:
 		m.ResetItems()
 		return nil

backend/internal/data/ent/schema/document.go

@@ -16,6 +16,7 @@ type Document struct {
 func (Document) Mixin() []ent.Mixin {
 	return []ent.Mixin{
 		mixins.BaseMixin{},
+		GroupMixin{ref: "documents"},
 	}
 }
 
@@ -34,10 +35,6 @@ func (Document) Fields() []ent.Field {
 // Edges of the Document.
 func (Document) Edges() []ent.Edge {
 	return []ent.Edge{
-		edge.From("group", Group.Type).
-			Ref("documents").
-			Required().
-			Unique(),
 		edge.To("attachments", Attachment.Type).
 			Annotations(entsql.Annotation{
 				OnDelete: entsql.Cascade,

backend/internal/data/ent/schema/group.go

@@ -5,6 +5,7 @@ import (
 	"entgo.io/ent/dialect/entsql"
 	"entgo.io/ent/schema/edge"
 	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/mixin"
 	"github.com/hay-kot/homebox/backend/internal/data/ent/schema/mixins"
 )
 
@@ -33,34 +34,36 @@ func (Group) Fields() []ent.Field {
 
 // Edges of the Home.
 func (Group) Edges() []ent.Edge {
+	owned := func(name string, t any) ent.Edge {
+		return edge.To(name, t).
+			Annotations(entsql.Annotation{
+				OnDelete: entsql.Cascade,
+			})
+	}
+
 	return []ent.Edge{
-		edge.To("users", User.Type).
+		owned("users", User.Type),
-			Annotations(entsql.Annotation{
+		owned("locations", Location.Type),
-				OnDelete: entsql.Cascade,
+		owned("items", Item.Type),
-			}),
+		owned("labels", Label.Type),
-		edge.To("locations", Location.Type).
+		owned("documents", Document.Type),
-			Annotations(entsql.Annotation{
+		owned("invitation_tokens", GroupInvitationToken.Type),
-				OnDelete: entsql.Cascade,
+		owned("notifiers", Notifier.Type),
-			}),
+	}
-		edge.To("items", Item.Type).
+}
-			Annotations(entsql.Annotation{
+
-				OnDelete: entsql.Cascade,
+// GroupMixin when embedded in an ent.Schema, adds a reference to
-			}),
+// the Group entity.
-		edge.To("labels", Label.Type).
+type GroupMixin struct {
-			Annotations(entsql.Annotation{
+	ref string
-				OnDelete: entsql.Cascade,
+	mixin.Schema
-			}),
+}
-		edge.To("documents", Document.Type).
+
-			Annotations(entsql.Annotation{
+func (g GroupMixin) Edges() []ent.Edge {
-				OnDelete: entsql.Cascade,
+	return []ent.Edge{
-			}),
+		edge.From("group", Group.Type).
-		edge.To("invitation_tokens", GroupInvitationToken.Type).
+			Ref(g.ref).
-			Annotations(entsql.Annotation{
+			Unique().
-				OnDelete: entsql.Cascade,
+			Required(),
-			}),
-		edge.To("notifiers", Notifier.Type).
-			Annotations(entsql.Annotation{
-				OnDelete: entsql.Cascade,
-			}),
 	}
 }

backend/internal/data/ent/schema/helpers.go

@@ -0,0 +1 @@
+package schema

backend/internal/data/ent/schema/item.go

@@ -18,6 +18,7 @@ func (Item) Mixin() []ent.Mixin {
 	return []ent.Mixin{
 		mixins.BaseMixin{},
 		mixins.DetailsMixin{},
+		GroupMixin{ref: "items"},
 	}
 }
 
@@ -102,10 +103,6 @@ func (Item) Edges() []ent.Edge {
 		edge.To("children", Item.Type).
 			From("parent").
 			Unique(),
-		edge.From("group", Group.Type).
-			Ref("items").
-			Required().
-			Unique(),
 		edge.From("label", Label.Type).
 			Ref("items"),
 		edge.From("location", Location.Type).

backend/internal/data/ent/schema/label.go

@@ -16,6 +16,7 @@ func (Label) Mixin() []ent.Mixin {
 	return []ent.Mixin{
 		mixins.BaseMixin{},
 		mixins.DetailsMixin{},
+		GroupMixin{ref: "labels"},
 	}
 }
 
@@ -31,10 +32,6 @@ func (Label) Fields() []ent.Field {
 // Edges of the Label.
 func (Label) Edges() []ent.Edge {
 	return []ent.Edge{
-		edge.From("group", Group.Type).
-			Ref("labels").
-			Required().
-			Unique(),
 		edge.To("items", Item.Type),
 	}
 }

backend/internal/data/ent/schema/location.go

@@ -16,6 +16,7 @@ func (Location) Mixin() []ent.Mixin {
 	return []ent.Mixin{
 		mixins.BaseMixin{},
 		mixins.DetailsMixin{},
+		GroupMixin{ref: "locations"},
 	}
 }
 
@@ -30,10 +31,6 @@ func (Location) Edges() []ent.Edge {
 		edge.To("children", Location.Type).
 			From("parent").
 			Unique(),
-		edge.From("group", Group.Type).
-			Ref("locations").
-			Unique().
-			Required(),
 		edge.To("items", Item.Type).
 			Annotations(entsql.Annotation{
 				OnDelete: entsql.Cascade,

backend/internal/data/ent/schema/notifier.go

@@ -57,7 +57,6 @@ func (Notifier) Indexes() []ent.Index {
 	return []ent.Index{
 		index.Fields("user_id"),
 		index.Fields("user_id", "is_active"),
-
 		index.Fields("group_id"),
 		index.Fields("group_id", "is_active"),
 	}

backend/internal/data/ent/schema/user.go

@@ -16,6 +16,7 @@ type User struct {
 func (User) Mixin() []ent.Mixin {
 	return []ent.Mixin{
 		mixins.BaseMixin{},
+		GroupMixin{ref: "users"},
 	}
 }
 
@@ -48,10 +49,6 @@ func (User) Fields() []ent.Field {
 // Edges of the User.
 func (User) Edges() []ent.Edge {
 	return []ent.Edge{
-		edge.From("group", Group.Type).
-			Ref("users").
-			Required().
-			Unique(),
 		edge.To("auth_tokens", AuthTokens.Type).
 			Annotations(entsql.Annotation{
 				OnDelete: entsql.Cascade,