feat: workspace filter query supported in backend (coder#2232)

* feat: add support for template in workspace filter
* feat: Implement workspace search filter to support names
* Use new query param parser for pagination fields
* Remove excessive calls, use filters on a single query

Co-authored-by: Garrett <garrett@coder.com>

Author: Emyrk

coderd/database/databasefake/databasefake.go

@@ -321,41 +321,47 @@ func (q *fakeQuerier) GetWorkspacesWithFilter(_ context.Context, arg database.Ge
 
 	workspaces := make([]database.Workspace, 0)
 	for _, workspace := range q.workspaces {
-		if arg.OrganizationID != uuid.Nil && workspace.OrganizationID != arg.OrganizationID {
-			continue
-		}
 		if arg.OwnerID != uuid.Nil && workspace.OwnerID != arg.OwnerID {
 			continue
 		}
+		if arg.OwnerUsername != "" {
+			owner, err := q.GetUserByID(context.Background(), workspace.OwnerID)
+			if err == nil && arg.OwnerUsername != owner.Username {
+				continue
+			}
+		}
+		if arg.TemplateName != "" {
+			templates, err := q.GetTemplatesWithFilter(context.Background(), database.GetTemplatesWithFilterParams{
+				ExactName: arg.TemplateName,
+			})
+			// Add to later param
+			if err == nil {
+				for _, t := range templates {
+					arg.TemplateIds = append(arg.TemplateIds, t.ID)
+				}
+			}
+		}
 		if !arg.Deleted && workspace.Deleted {
 			continue
 		}
 		if arg.Name != "" && !strings.Contains(workspace.Name, arg.Name) {
 			continue
 		}
-		workspaces = append(workspaces, workspace)
-	}
-
-	return workspaces, nil
-}
-
-func (q *fakeQuerier) GetWorkspacesByTemplateID(_ context.Context, arg database.GetWorkspacesByTemplateIDParams) ([]database.Workspace, error) {
-	q.mutex.RLock()
-	defer q.mutex.RUnlock()
-
-	workspaces := make([]database.Workspace, 0)
-	for _, workspace := range q.workspaces {
-		if workspace.TemplateID.String() != arg.TemplateID.String() {
-			continue
-		}
-		if workspace.Deleted != arg.Deleted {
-			continue
+		if len(arg.TemplateIds) > 0 {
+			match := false
+			for _, id := range arg.TemplateIds {
+				if workspace.TemplateID == id {
+					match = true
+					break
+				}
+			}
+			if !match {
+				continue
+			}
 		}
 		workspaces = append(workspaces, workspace)
 	}
-	if len(workspaces) == 0 {
-		return nil, sql.ErrNoRows
-	}
+
 	return workspaces, nil
 }
 
@@ -641,25 +647,6 @@ func (q *fakeQuerier) GetWorkspaceBuildByWorkspaceIDAndBuildNumber(_ context.Con
 	return database.WorkspaceBuild{}, sql.ErrNoRows
 }
 
-func (q *fakeQuerier) GetWorkspacesByOrganizationIDs(_ context.Context, req database.GetWorkspacesByOrganizationIDsParams) ([]database.Workspace, error) {
-	q.mutex.RLock()
-	defer q.mutex.RUnlock()
-
-	workspaces := make([]database.Workspace, 0)
-	for _, workspace := range q.workspaces {
-		for _, id := range req.Ids {
-			if workspace.OrganizationID != id {
-				continue
-			}
-			if workspace.Deleted != req.Deleted {
-				continue
-			}
-			workspaces = append(workspaces, workspace)
-		}
-	}
-	return workspaces, nil
-}
-
 func (q *fakeQuerier) GetOrganizations(_ context.Context) ([]database.Organization, error) {
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
@@ -786,6 +773,44 @@ func (q *fakeQuerier) UpdateTemplateMetaByID(_ context.Context, arg database.Upd
 	return sql.ErrNoRows
 }
 
+func (q *fakeQuerier) GetTemplatesWithFilter(_ context.Context, arg database.GetTemplatesWithFilterParams) ([]database.Template, error) {
+	q.mutex.RLock()
+	defer q.mutex.RUnlock()
+
+	var templates []database.Template
+	for _, template := range q.templates {
+		if template.Deleted != arg.Deleted {
+			continue
+		}
+		if arg.OrganizationID != uuid.Nil && template.OrganizationID != arg.OrganizationID {
+			continue
+		}
+
+		if arg.ExactName != "" && !strings.EqualFold(template.Name, arg.ExactName) {
+			continue
+		}
+
+		if len(arg.Ids) > 0 {
+			match := false
+			for _, id := range arg.Ids {
+				if template.ID == id {
+					match = true
+					break
+				}
+			}
+			if !match {
+				continue
+			}
+		}
+		templates = append(templates, template)
+	}
+	if len(templates) > 0 {
+		return templates, nil
+	}
+
+	return nil, sql.ErrNoRows
+}
+
 func (q *fakeQuerier) GetTemplateVersionsByTemplateID(_ context.Context, arg database.GetTemplateVersionsByTemplateIDParams) (version []database.TemplateVersion, err error) {
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
@@ -923,45 +948,6 @@ func (q *fakeQuerier) GetParameterValueByScopeAndName(_ context.Context, arg dat
 	return database.ParameterValue{}, sql.ErrNoRows
 }
 
-func (q *fakeQuerier) GetTemplatesByOrganization(_ context.Context, arg database.GetTemplatesByOrganizationParams) ([]database.Template, error) {
-	q.mutex.RLock()
-	defer q.mutex.RUnlock()
-
-	templates := make([]database.Template, 0)
-	for _, template := range q.templates {
-		if template.Deleted != arg.Deleted {
-			continue
-		}
-		if template.OrganizationID != arg.OrganizationID {
-			continue
-		}
-		templates = append(templates, template)
-	}
-	if len(templates) == 0 {
-		return nil, sql.ErrNoRows
-	}
-	return templates, nil
-}
-
-func (q *fakeQuerier) GetTemplatesByIDs(_ context.Context, ids []uuid.UUID) ([]database.Template, error) {
-	q.mutex.RLock()
-	defer q.mutex.RUnlock()
-
-	templates := make([]database.Template, 0)
-	for _, template := range q.templates {
-		for _, id := range ids {
-			if template.ID.String() != id.String() {
-				continue
-			}
-			templates = append(templates, template)
-		}
-	}
-	if len(templates) == 0 {
-		return nil, sql.ErrNoRows
-	}
-	return templates, nil
-}
-
 func (q *fakeQuerier) GetOrganizationMemberByUserID(_ context.Context, arg database.GetOrganizationMemberByUserIDParams) (database.OrganizationMember, error) {
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()

coderd/database/databasefake/databasefake_test.go

@@ -0,0 +1,61 @@
+package databasefake_test
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/coder/coder/coderd/database"
+
+	"github.com/coder/coder/coderd/database/databasefake"
+)
+
+// TestExactMethods will ensure the fake database does not hold onto excessive
+// functions. The fake database is a manual implementation, so it is possible
+// we forget to delete functions that we remove. This unit test just ensures
+// we remove the extra methods.
+func TestExactMethods(t *testing.T) {
+	t.Parallel()
+
+	// extraFakeMethods contains the extra allowed methods that are not a part
+	// of the database.Store interface.
+	extraFakeMethods := map[string]string{
+		// Example
+		// "SortFakeLists": "Helper function used",
+	}
+
+	fake := reflect.TypeOf(databasefake.New())
+	fakeMethods := methods(fake)
+
+	store := reflect.TypeOf((*database.Store)(nil)).Elem()
+	storeMethods := methods(store)
+
+	// Store should be a subset
+	for k := range storeMethods {
+		_, ok := fakeMethods[k]
+		if !ok {
+			panic(fmt.Sprintf("This should never happen. FakeDB missing method %s, so doesn't fit the interface", k))
+		}
+		delete(storeMethods, k)
+		delete(fakeMethods, k)
+	}
+
+	for k := range fakeMethods {
+		_, ok := extraFakeMethods[k]
+		if ok {
+			continue
+		}
+		// If you are seeing this error, you have an extra function not required
+		// for the database.Store. If you still want to keep it, add it to
+		// 'extraFakeMethods' to allow it.
+		t.Errorf("Fake method '%s()' is excessive and not needed to fit interface, delete it", k)
+	}
+}
+
+func methods(rt reflect.Type) map[string]bool {
+	methods := make(map[string]bool)
+	for i := 0; i < rt.NumMethod(); i++ {
+		methods[rt.Method(i).Name] = true
+	}
+	return methods
+}