fix sqlx woes

coder · sreya · Sep 13, 2022 · Sep 13, 2022 · Sep 13, 2022 · Sep 15, 2022
commit 68831064d891331aeda220815751fe8bce65ddc1
diff --git a/coderd/coderd.go b/coderd/coderd.go
@@ -319,6 +319,7 @@ func New(options *Options) *API {
 			r.Get("/", api.template)
 			r.Delete("/", api.deleteTemplate)
 			r.Patch("/", api.patchTemplateMeta)
+			r.Get("/user-roles", api.templateUserRoles)
 			r.Route("/versions", func(r chi.Router) {
 				r.Get("/", api.templateVersionsByTemplate)
 				r.Patch("/", api.patchActiveTemplateVersion)

diff --git a/coderd/database/databasefake/databasefake.go b/coderd/database/databasefake/databasefake.go
@@ -12,6 +12,7 @@ import (
 	"github.com/lib/pq"
 	"golang.org/x/exp/maps"
 	"golang.org/x/exp/slices"
+	"golang.org/x/xerrors"
 
 	"github.com/coder/coder/coderd/database"
 	"github.com/coder/coder/coderd/rbac"
@@ -1244,6 +1245,45 @@ func (q *fakeQuerier) UpdateTemplateUserACLByID(_ context.Context, id uuid.UUID,
 	return sql.ErrNoRows
 }
 
+func (q *fakeQuerier) GetTemplateUserRoles(ctx context.Context, id uuid.UUID) ([]database.TemplateUser, error) {
+	q.mutex.RLock()
+	defer q.mutex.RUnlock()
+
+	var template database.Template
+	for _, t := range q.templates {
+		if t.ID == id {
+			template = t
+			break
+		}
+	}
+
+	if template.ID == uuid.Nil {
+		return nil, sql.ErrNoRows
+	}
+
+	acl := template.UserACL()
+
+	users := make([]database.TemplateUser, 0, len(acl))
+	for k, v := range acl {
+		user, err := q.GetUserByID(context.Background(), uuid.MustParse(k))
+		if err != nil && xerrors.Is(err, sql.ErrNoRows) {
+			return nil, xerrors.Errorf("get user by ID: %w", err)
+		}
+		// We don't delete users from the map if they
+		// get deleted so just skip.
+		if xerrors.Is(err, sql.ErrNoRows) {
+			continue
+		}
+
+		users = append(users, database.TemplateUser{
+			User: user,
+			Role: v,
+		})
+	}
+
+	return users, nil
+}
+
 func (q *fakeQuerier) GetOrganizationMemberByUserID(_ context.Context, arg database.GetOrganizationMemberByUserIDParams) (database.OrganizationMember, error) {
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()

diff --git a/coderd/database/db.go b/coderd/database/db.go
@@ -31,13 +31,16 @@ type DBTX interface {
 	PrepareContext(context.Context, string) (*sql.Stmt, error)
 	QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
 	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
+	SelectContext(ctx context.Context, dest interface{}, query string, args ...interface{}) error
+	GetContext(ctx context.Context, dest interface{}, query string, args ...interface{}) error
 }
 
 // New creates a new database store using a SQL database connection.
 func New(sdb *sql.DB) Store {
+	dbx := sqlx.NewDb(sdb, "postgres")
 	return &sqlQuerier{
-		db:  sdb,
-		sdb: sqlx.NewDb(sdb, "postgres"),
+		db:  dbx,
+		sdb: dbx,
 	}
 }
 
@@ -66,7 +69,7 @@ func (q *sqlQuerier) InTx(function func(Store) error) error {
 		return nil
 	}
 
-	transaction, err := q.sdb.Begin()
+	transaction, err := q.sdb.BeginTxx(context.Background(), nil)
 	if err != nil {
 		return xerrors.Errorf("begin transaction: %w", err)
 	}

diff --git a/coderd/database/modelqueries.go b/coderd/database/modelqueries.go
@@ -17,6 +17,7 @@ type customQuerier interface {
 
 type templateQuerier interface {
 	UpdateTemplateUserACLByID(ctx context.Context, id uuid.UUID, acl UserACL) error
+	GetTemplateUserRoles(ctx context.Context, id uuid.UUID) ([]TemplateUser, error)
 }
 
 type TemplateUser struct {
@@ -45,3 +46,38 @@ WHERE
 
 	return nil
 }
+
+func (q *sqlQuerier) GetTemplateUserRoles(ctx context.Context, id uuid.UUID) ([]TemplateUser, error) {
+	const query = `
+	SELECT
+		perms.value as role, users.*
+	FROM
+		users
+	JOIN
+		(
+			SELECT
+				*
+			FROM
+				jsonb_each_text(
+					(
+						SELECT
+							templates.user_acl
+						FROM
+							templates
+						WHERE
+							id = $1
+					)
+				)
+		) AS perms
+	ON
+		users.id::text = perms.key;
+	`
+
+	var tus []TemplateUser
+	err := q.db.SelectContext(ctx, &tus, query, id.String())
+	if err != nil {
+		return nil, xerrors.Errorf("select context: %w", err)
+	}
+
+	return tus, nil
+}
diff --git a/coderd/database/models.go b/coderd/database/models.go
diff --git a/coderd/database/queries.sql.go b/coderd/database/queries.sql.go
diff --git a/coderd/database/sqlc.yaml b/coderd/database/sqlc.yaml
@@ -16,6 +16,10 @@ packages:
     # deleted after generation.
     output_db_file_name: db_tmp.go
 
+overrides:
+  - column: "users.rbac_roles"
+    go_type: "github.com/lib/pq.StringArray"
+
 rename:
   api_key: APIKey
   api_key_scope: APIKeyScope

diff --git a/coderd/templates.go b/coderd/templates.go
@@ -625,6 +625,47 @@ func (api *API) templateDAUs(rw http.ResponseWriter, r *http.Request) {
 	httpapi.Write(rw, http.StatusOK, resp)
 }
 
+func (api *API) templateUserRoles(rw http.ResponseWriter, r *http.Request) {
+	template := httpmw.TemplateParam(r)
+	if !api.Authorize(r, rbac.ActionRead, template) {
+		httpapi.ResourceNotFound(rw)
+		return
+	}
+
+	users, err := api.Database.GetTemplateUserRoles(r.Context(), template.ID)
+	if err != nil {
+		httpapi.InternalServerError(rw, err)
+		return
+	}
+
+	users, err = AuthorizeFilter(api.httpAuth, r, rbac.ActionRead, users)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, codersdk.Response{
+			Message: "Internal error fetching users.",
+			Detail:  err.Error(),
+		})
+		return
+	}
+
+	userIDs := make([]uuid.UUID, 0, len(users))
+	for _, user := range users {
+		userIDs = append(userIDs, user.ID)
+	}
+
+	orgIDsByMemberIDsRows, err := api.Database.GetOrganizationIDsByMemberIDs(r.Context(), userIDs)
+	if err != nil {
+		httpapi.InternalServerError(rw, err)
+		return
+	}
+
+	organizationIDsByUserID := map[uuid.UUID][]uuid.UUID{}
+	for _, organizationIDsByMemberIDsRow := range orgIDsByMemberIDsRows {
+		organizationIDsByUserID[organizationIDsByMemberIDsRow.UserID] = organizationIDsByMemberIDsRow.OrganizationIDs
+	}
+
+	httpapi.Write(rw, http.StatusOK, convertTemplateUsers(users, organizationIDsByUserID))
+}
+
 type autoImportTemplateOpts struct {
 	name    string
 	archive []byte
@@ -828,8 +869,8 @@ func (api *API) convertTemplate(
 	}
 }
 
-func convertTemplateACL(acl database.UserACL) codersdk.TemplateUserACL {
-	userACL := make(codersdk.TemplateUserACL, len(acl))
+func convertTemplateACL(acl database.UserACL) map[string]codersdk.TemplateRole {
+	userACL := make(map[string]codersdk.TemplateRole, len(acl))
 	for k, v := range acl {
 		userACL[k] = convertDatabaseTemplateRole(v)
 	}
@@ -871,3 +912,16 @@ func validateTemplateRole(role codersdk.TemplateRole) error {
 
 	return nil
 }
+
+func convertTemplateUsers(tus []database.TemplateUser, orgIDsByUserIDs map[uuid.UUID][]uuid.UUID) []codersdk.TemplateUser {
+	users := make([]codersdk.TemplateUser, 0, len(tus))
+
+	for _, tu := range tus {
+		users = append(users, codersdk.TemplateUser{
+			User: convertUser(tu.User, orgIDsByUserIDs[tu.User.ID]),
+			Role: codersdk.TemplateRole(tu.Role),
+		})
+	}
+
+	return users
+}
diff --git a/coderd/templates_test.go b/coderd/templates_test.go
@@ -897,6 +897,52 @@ func TestDeleteTemplate(t *testing.T) {
 	})
 }
 
+func TestTemplateUserRoles(t *testing.T) {
+	t.Parallel()
+
+	t.Run("OK", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		_, user2 := coderdtest.CreateAnotherUserWithUser(t, client, user.OrganizationID)
+		_, user3 := coderdtest.CreateAnotherUserWithUser(t, client, user.OrganizationID)
+		version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
+		template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID,
+			func(r *codersdk.CreateTemplateRequest) {
+				r.IsPrivate = true
+			},
+		)
+
+		ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
+		defer cancel()
+
+		_, err := client.UpdateTemplateMeta(ctx, template.ID, codersdk.UpdateTemplateMeta{
+			UserPerms: map[string]codersdk.TemplateRole{
+				user2.ID.String(): codersdk.TemplateRoleRead,
+				user3.ID.String(): codersdk.TemplateRoleWrite,
+			},
+		})
+		require.NoError(t, err)
+
+		users, err := client.TemplateUserRoles(ctx, template.ID)
+		require.NoError(t, err)
+
+		templateUser2 := codersdk.TemplateUser{
+			User: user2,
+			Role: codersdk.TemplateRoleRead,
+		}
+
+		templateUser3 := codersdk.TemplateUser{
+			User: user3,
+			Role: codersdk.TemplateRoleWrite,
+		}
+
+		require.Len(t, users, 2)
+		require.Contains(t, users, templateUser2)
+		require.Contains(t, users, templateUser3)
+	})
+}
+
 func TestTemplateDAUs(t *testing.T) {
 	t.Parallel()