chore: Implement joins with golang templates (#6429)

* feat: Implement view for workspace builds to include rbac info

* Removes the need to fetch the workspace to run an rbac check.
* chore: Use workspace build as RBAC object
* chore: Use golang templates instead of sqlc files

coderd/database/dbgen/generator.go

@@ -153,20 +153,34 @@ func Workspace(t testing.TB, db database.Store, orig database.Workspace) databas
 	return workspace
 }
 
-func WorkspaceBuild(t testing.TB, db database.Store, orig database.WorkspaceBuild) database.WorkspaceBuild {
+type AnyWorkspaceBuild interface {
+	database.WorkspaceBuildRBAC | database.WorkspaceBuild
+}
+
+func WorkspaceBuild[B AnyWorkspaceBuild](t testing.TB, db database.Store, orig B) database.WorkspaceBuild {
+	var thin database.WorkspaceBuild
+	switch v := any(orig).(type) {
+	case database.WorkspaceBuildRBAC:
+		thin = v.WorkspaceBuild
+	case database.WorkspaceBuild:
+		thin = v
+	default:
+		panic(fmt.Sprintf("developer error: invalid type %T", v))
+	}
 	build, err := db.InsertWorkspaceBuild(context.Background(), database.InsertWorkspaceBuildParams{
-		ID:                takeFirst(orig.ID, uuid.New()),
-		CreatedAt:         takeFirst(orig.CreatedAt, database.Now()),
-		UpdatedAt:         takeFirst(orig.UpdatedAt, database.Now()),
-		WorkspaceID:       takeFirst(orig.WorkspaceID, uuid.New()),
-		TemplateVersionID: takeFirst(orig.TemplateVersionID, uuid.New()),
-		BuildNumber:       takeFirst(orig.BuildNumber, 1),
-		Transition:        takeFirst(orig.Transition, database.WorkspaceTransitionStart),
-		InitiatorID:       takeFirst(orig.InitiatorID, uuid.New()),
-		JobID:             takeFirst(orig.JobID, uuid.New()),
-		ProvisionerState:  takeFirstSlice(orig.ProvisionerState, []byte{}),
-		Deadline:          takeFirst(orig.Deadline, database.Now().Add(time.Hour)),
-		Reason:            takeFirst(orig.Reason, database.BuildReasonInitiator),
+		ID:                takeFirst(thin.ID, uuid.New()),
+		CreatedAt:         takeFirst(thin.CreatedAt, database.Now()),
+		UpdatedAt:         takeFirst(thin.UpdatedAt, database.Now()),
+		WorkspaceID:       takeFirst(thin.WorkspaceID, uuid.New()),
+		TemplateVersionID: takeFirst(thin.TemplateVersionID, uuid.New()),
+		BuildNumber:       takeFirst(thin.BuildNumber, 1),
+		Transition:        takeFirst(thin.Transition, database.WorkspaceTransitionStart),
+		InitiatorID:       takeFirst(thin.InitiatorID, uuid.New()),
+		JobID:             takeFirst(thin.JobID, uuid.New()),
+		ProvisionerState:  takeFirstSlice(thin.ProvisionerState, []byte{}),
+		Deadline:          takeFirst(thin.Deadline, database.Now().Add(time.Hour)),
+		MaxDeadline:       takeFirst(thin.MaxDeadline, database.Now().Add(time.Hour*24*7)),
+		Reason:            takeFirst(thin.Reason, database.BuildReasonInitiator),
 	})
 	require.NoError(t, err, "insert workspace build")
 	return build
@@ -219,7 +233,7 @@ func OrganizationMember(t testing.TB, db database.Store, orig database.Organizat
 		UpdatedAt:      takeFirst(orig.UpdatedAt, database.Now()),
 		Roles:          takeFirstSlice(orig.Roles, []string{}),
 	})
-	require.NoError(t, err, "insert organization")
+	require.NoError(t, err, "insert organization member")
 	return mem
 }
 

coderd/database/dbgen/generator_test.go

@@ -166,8 +166,8 @@ func TestGenerator(t *testing.T) {
 	t.Run("WorkspaceBuild", func(t *testing.T) {
 		t.Parallel()
 		db := dbfake.New()
-		exp := dbgen.WorkspaceBuild(t, db, database.WorkspaceBuild{})
-		require.Equal(t, exp, must(db.GetWorkspaceBuildByID(context.Background(), exp.ID)))
+		exp := dbgen.WorkspaceBuild(t, db, database.WorkspaceBuildRBAC{})
+		require.Equal(t, exp, must(db.GetWorkspaceBuildByID(context.Background(), exp.ID)).WorkspaceBuild)
 	})
 
 	t.Run("User", func(t *testing.T) {

coderd/database/dbgen/take.go

@@ -13,9 +13,14 @@ func takeFirstIP(values ...net.IPNet) net.IPNet {
 // takeFirstSlice implements takeFirst for []any.
 // []any is not a comparable type.
 func takeFirstSlice[T any](values ...[]T) []T {
-	return takeFirstF(values, func(v []T) bool {
+	out := takeFirstF(values, func(v []T) bool {
 		return len(v) != 0
 	})
+	// Prevent nil slices
+	if out == nil {
+		return []T{}
+	}
+	return out
 }
 
 // takeFirstF takes the first value that returns true