package repository import ( "database/sql" "errors" ) // Group is a named set of users (V2-6) : sharing to a group grants every // member. One level only (no nested groups). The creator owns the group // (member management + deletion) ; membership confers no admin rights. type Group struct { ID string Name string CreatedBy string } // Groups implements group persistence. type Groups struct { DB *sql.DB } // Create stores a group owned by ownerID and returns its id. func (g *Groups) Create(name, ownerID string) (string, error) { id := NewID() _, err := g.DB.Exec( `INSERT INTO groups (id, name, created_by) VALUES ($1, $2, $3)`, id, name, ownerID, ) if err != nil { return "", err } return id, nil } // Get returns a group by id. No-rows → ErrNotFound. func (g *Groups) Get(groupID string) (Group, error) { var group Group err := g.DB.QueryRow( `SELECT id, name, created_by FROM groups WHERE id = $1`, groupID, ).Scan(&group.ID, &group.Name, &group.CreatedBy) if errors.Is(err, sql.ErrNoRows) { return Group{}, ErrNotFound } return group, err } // IsOwner reports whether userID created the group. func (g *Groups) IsOwner(groupID, userID string) (bool, error) { var n int err := g.DB.QueryRow( `SELECT COUNT(*) FROM groups WHERE id = $1 AND created_by = $2`, groupID, userID, ).Scan(&n) return n > 0, err } // IsMember reports group membership (owner excluded : ownership is separate). func (g *Groups) IsMember(groupID, userID string) (bool, error) { var n int err := g.DB.QueryRow( `SELECT COUNT(*) FROM group_members WHERE group_id = $1 AND user_id = $2`, groupID, userID, ).Scan(&n) return n > 0, err } // GroupWithRole is a group listing row (owned or joined). type GroupWithRole struct { Group Role string // "owner" | "member" } // ListForUser returns groups the user owns or joins, owned first. func (g *Groups) ListForUser(userID string) ([]GroupWithRole, error) { rows, err := g.DB.Query( `SELECT id, name, created_by, CASE WHEN created_by = $1 THEN 'owner' ELSE 'member' END AS role FROM groups WHERE created_by = $1 OR id IN (SELECT group_id FROM group_members WHERE user_id = $1) ORDER BY created_at ASC`, userID, ) if err != nil { return nil, err } defer rows.Close() var out []GroupWithRole for rows.Next() { var gr GroupWithRole if err := rows.Scan(&gr.ID, &gr.Name, &gr.CreatedBy, &gr.Role); err != nil { return nil, err } out = append(out, gr) } return out, rows.Err() } // AddMember inserts a membership. Idempotent on replay (ON CONFLICT DO // NOTHING) ; returns rows-affected style via ErrNotFound when the group or // the user does not exist (FK violation mapped). func (g *Groups) AddMember(groupID, userID string) error { _, err := g.DB.Exec( `INSERT INTO group_members (group_id, user_id) VALUES ($1, $2) ON CONFLICT DO NOTHING`, groupID, userID, ) if isForeignKeyViolation(err) { return ErrNotFound } return err } // RemoveMember deletes a membership. Missing row → ErrNotFound. func (g *Groups) RemoveMember(groupID, userID string) error { result, err := g.DB.Exec( `DELETE FROM group_members WHERE group_id = $1 AND user_id = $2`, groupID, userID, ) if err != nil { return err } affected, err := result.RowsAffected() if err != nil { return err } if affected == 0 { return ErrNotFound } return nil } // Member is a group membership row (owner view). type Member struct { UserID string Username string } // ListMembers returns memberships of a group, ordered by username. func (g *Groups) ListMembers(groupID string) ([]Member, error) { rows, err := g.DB.Query( `SELECT u.id, COALESCE(u.username, u.id) FROM group_members gm JOIN users u ON u.id = gm.user_id AND u.deleted_at IS NULL WHERE gm.group_id = $1 ORDER BY COALESCE(u.username, u.id) ASC`, groupID, ) if err != nil { return nil, err } defer rows.Close() var out []Member for rows.Next() { var m Member if err := rows.Scan(&m.UserID, &m.Username); err != nil { return nil, err } out = append(out, m) } return out, rows.Err() } // Errors specific to groups. var ErrGroupNotFound = errors.New("group not found") // Delete removes a group (owner only — caller checks). Shares targeting it // cascade (FK), placements are untouched (device-scoped, not group-scoped). func (g *Groups) Delete(groupID, ownerID string) error { result, err := g.DB.Exec( `DELETE FROM groups WHERE id = $1 AND created_by = $2`, groupID, ownerID, ) if err != nil { return err } affected, err := result.RowsAffected() if err != nil { return err } if affected == 0 { return ErrNotFound } return nil }