feat: Refactor API routes to use UUIDs instead of friendly names (#401)

* Add client for agent

* Cleanup code

* Fix linting error

* Rename routes to be simpler

* Rename workspace history to workspace build

* Refactor HTTP middlewares to use UUIDs

* Cleanup routes

* Compiles!

* Fix files and organizations

* Fix querying

* Fix agent lock

* Cleanup database abstraction

* Add parameters

* Fix linting errors

* Fix log race

* Lock on close wait

* Fix log cleanup

* Fix e2e tests

* Fix upstream version of opencensus-go

* Update coderdtest.go

* Fix coverpkg

* Fix codecov ignore

coderd/cmd/root.go

@@ -98,7 +98,7 @@ func newProvisionerDaemon(ctx context.Context, client *codersdk.Client, logger s
 	if err != nil {
 		return nil, err
 	}
-	return provisionerd.New(client.ProvisionerDaemonClient, &provisionerd.Options{
+	return provisionerd.New(client.ListenProvisionerDaemon, &provisionerd.Options{
 		Logger:         logger,
 		PollInterval:   50 * time.Millisecond,
 		UpdateInterval: 50 * time.Millisecond,

coderd/coderd.go

@@ -41,119 +41,131 @@ func New(options *Options) (http.Handler, func()) {
 				Message: "👋",
 			})
 		})
-		r.Post("/login", api.postLogin)
-		r.Post("/logout", api.postLogout)
-
-		// Used for setup.
-		r.Get("/user", api.user)
-		r.Post("/user", api.postUser)
-		r.Route("/users", func(r chi.Router) {
-			r.Use(
-				httpmw.ExtractAPIKey(options.Database, nil),
-			)
-			r.Post("/", api.postUsers)
-
-			r.Route("/{user}", func(r chi.Router) {
-				r.Use(httpmw.ExtractUserParam(options.Database))
-				r.Get("/", api.userByName)
-				r.Get("/organizations", api.organizationsByUser)
-				r.Post("/keys", api.postKeyForUser)
-			})
+		r.Route("/files", func(r chi.Router) {
+			r.Use(httpmw.ExtractAPIKey(options.Database, nil))
+			r.Get("/{hash}", api.fileByHash)
+			r.Post("/", api.postFile)
 		})
-		r.Route("/projects", func(r chi.Router) {
+		r.Route("/organizations/{organization}", func(r chi.Router) {
 			r.Use(
 				httpmw.ExtractAPIKey(options.Database, nil),
+				httpmw.ExtractOrganizationParam(options.Database),
 			)
-			r.Get("/", api.projects)
-			r.Route("/{organization}", func(r chi.Router) {
-				r.Use(httpmw.ExtractOrganizationParam(options.Database))
-				r.Get("/", api.projectsByOrganization)
+			r.Get("/", api.organization)
+			r.Get("/provisionerdaemons", api.provisionerDaemonsByOrganization)
+			r.Post("/projectversions", api.postProjectVersionsByOrganization)
+			r.Route("/projects", func(r chi.Router) {
 				r.Post("/", api.postProjectsByOrganization)
-				r.Route("/{project}", func(r chi.Router) {
-					r.Use(httpmw.ExtractProjectParam(options.Database))
-					r.Get("/", api.projectByOrganization)
-					r.Get("/workspaces", api.workspacesByProject)
-					r.Route("/parameters", func(r chi.Router) {
-						r.Get("/", api.parametersByProject)
-						r.Post("/", api.postParametersByProject)
+				r.Get("/", api.projectsByOrganization)
+				r.Get("/{projectname}", api.projectByOrganizationAndName)
+			})
+		})
+		r.Route("/parameters/{scope}/{id}", func(r chi.Router) {
+			r.Use(httpmw.ExtractAPIKey(options.Database, nil))
+			r.Post("/", api.postParameter)
+			r.Get("/", api.parameters)
+			r.Route("/{name}", func(r chi.Router) {
+				r.Delete("/", api.deleteParameter)
+			})
+		})
+		r.Route("/projects/{project}", func(r chi.Router) {
+			r.Use(
+				httpmw.ExtractAPIKey(options.Database, nil),
+				httpmw.ExtractProjectParam(options.Database),
+				httpmw.ExtractOrganizationParam(options.Database),
+			)
+			r.Get("/", api.project)
+			r.Route("/versions", func(r chi.Router) {
+				r.Get("/", api.projectVersionsByProject)
+				r.Patch("/versions", nil)
+				r.Get("/{projectversionname}", api.projectVersionByName)
+			})
+		})
+		r.Route("/projectversions/{projectversion}", func(r chi.Router) {
+			r.Use(
+				httpmw.ExtractAPIKey(options.Database, nil),
+				httpmw.ExtractProjectVersionParam(options.Database),
+				httpmw.ExtractOrganizationParam(options.Database),
+			)
+
+			r.Get("/", api.projectVersion)
+			r.Get("/schema", api.projectVersionSchema)
+			r.Get("/parameters", api.projectVersionParameters)
+			r.Get("/resources", api.projectVersionResources)
+			r.Get("/logs", api.projectVersionLogs)
+		})
+		r.Route("/provisionerdaemons", func(r chi.Router) {
+			r.Route("/me", func(r chi.Router) {
+				r.Get("/listen", api.provisionerDaemonsListen)
+			})
+		})
+		r.Route("/users", func(r chi.Router) {
+			r.Get("/first", api.firstUser)
+			r.Post("/first", api.postFirstUser)
+			r.Post("/login", api.postLogin)
+			r.Post("/logout", api.postLogout)
+			r.Group(func(r chi.Router) {
+				r.Use(httpmw.ExtractAPIKey(options.Database, nil))
+				r.Post("/", api.postUsers)
+				r.Route("/{user}", func(r chi.Router) {
+					r.Use(httpmw.ExtractUserParam(options.Database))
+					r.Get("/", api.userByName)
+					r.Get("/organizations", api.organizationsByUser)
+					r.Post("/organizations", api.postOrganizationsByUser)
+					r.Post("/keys", api.postAPIKey)
+					r.Route("/organizations", func(r chi.Router) {
+						r.Post("/", api.postOrganizationsByUser)
+						r.Get("/", api.organizationsByUser)
+						r.Get("/{organizationname}", api.organizationByUserAndName)
 					})
-					r.Route("/versions", func(r chi.Router) {
-						r.Get("/", api.projectVersionsByOrganization)
-						r.Post("/", api.postProjectVersionByOrganization)
-						r.Route("/{projectversion}", func(r chi.Router) {
-							r.Use(httpmw.ExtractProjectVersionParam(api.Database))
-							r.Get("/", api.projectVersionByOrganizationAndName)
-						})
+					r.Route("/workspaces", func(r chi.Router) {
+						r.Post("/", api.postWorkspacesByUser)
+						r.Get("/", api.workspacesByUser)
+						r.Get("/{workspacename}", api.workspaceByUserAndName)
 					})
 				})
 			})
 		})
-
-		// Listing operations specific to resources should go under
-		// their respective routes. eg. /orgs/<name>/workspaces
-		r.Route("/workspaces", func(r chi.Router) {
-			r.Use(httpmw.ExtractAPIKey(options.Database, nil))
-			r.Get("/", api.workspaces)
-			r.Route("/{user}", func(r chi.Router) {
-				r.Use(httpmw.ExtractUserParam(options.Database))
-				r.Post("/", api.postWorkspaceByUser)
-				r.Route("/{workspace}", func(r chi.Router) {
-					r.Use(httpmw.ExtractWorkspaceParam(options.Database))
-					r.Get("/", api.workspaceByUser)
-					r.Route("/version", func(r chi.Router) {
-						r.Post("/", api.postWorkspaceHistoryByUser)
-						r.Get("/", api.workspaceHistoryByUser)
-						r.Route("/{workspacehistory}", func(r chi.Router) {
-							r.Use(httpmw.ExtractWorkspaceHistoryParam(options.Database))
-							r.Get("/", api.workspaceHistoryByName)
-						})
-					})
-				})
+		r.Route("/workspaceresources", func(r chi.Router) {
+			r.Route("/auth", func(r chi.Router) {
+				r.Post("/google-instance-identity", api.postWorkspaceAuthGoogleInstanceIdentity)
+			})
+			r.Route("/agent", func(r chi.Router) {
+				r.Use(httpmw.ExtractWorkspaceAgent(options.Database))
+				r.Get("/", api.workspaceAgentListen)
+			})
+			r.Route("/{workspaceresource}", func(r chi.Router) {
+				r.Use(
+					httpmw.ExtractAPIKey(options.Database, nil),
+					httpmw.ExtractWorkspaceResourceParam(options.Database),
+					httpmw.ExtractWorkspaceParam(options.Database),
+				)
+				r.Get("/", api.workspaceResource)
+				r.Get("/dial", api.workspaceResourceDial)
 			})
 		})
-
-		r.Route("/workspaceagent", func(r chi.Router) {
-			r.Route("/authenticate", func(r chi.Router) {
-				r.Post("/google-instance-identity", api.postAuthenticateWorkspaceAgentUsingGoogleInstanceIdentity)
-			})
-		})
-
-		r.Route("/upload", func(r chi.Router) {
-			r.Use(httpmw.ExtractAPIKey(options.Database, nil))
-			r.Post("/", api.postUpload)
-		})
-
-		r.Route("/projectimport/{organization}", func(r chi.Router) {
+		r.Route("/workspaces/{workspace}", func(r chi.Router) {
 			r.Use(
 				httpmw.ExtractAPIKey(options.Database, nil),
-				httpmw.ExtractOrganizationParam(options.Database),
+				httpmw.ExtractWorkspaceParam(options.Database),
 			)
-			r.Post("/", api.postProjectImportByOrganization)
-			r.Route("/{provisionerjob}", func(r chi.Router) {
-				r.Use(httpmw.ExtractProvisionerJobParam(options.Database))
-				r.Get("/", api.provisionerJobByID)
-				r.Get("/schemas", api.projectImportJobSchemasByID)
-				r.Get("/parameters", api.projectImportJobParametersByID)
-				r.Get("/resources", api.projectImportJobResourcesByID)
-				r.Get("/logs", api.provisionerJobLogsByID)
+			r.Get("/", api.workspace)
+			r.Route("/builds", func(r chi.Router) {
+				r.Get("/", api.workspaceBuilds)
+				r.Post("/", api.postWorkspaceBuilds)
+				r.Get("/latest", api.workspaceBuildLatest)
+				r.Get("/{workspacebuildname}", api.workspaceBuildByName)
 			})
 		})
-
-		r.Route("/workspaceprovision/{organization}", func(r chi.Router) {
+		r.Route("/workspacebuilds/{workspacebuild}", func(r chi.Router) {
 			r.Use(
 				httpmw.ExtractAPIKey(options.Database, nil),
-				httpmw.ExtractOrganizationParam(options.Database),
+				httpmw.ExtractWorkspaceBuildParam(options.Database),
+				httpmw.ExtractWorkspaceParam(options.Database),
 			)
-			r.Route("/{provisionerjob}", func(r chi.Router) {
-				r.Use(httpmw.ExtractProvisionerJobParam(options.Database))
-				r.Get("/", api.provisionerJobByID)
-				r.Get("/logs", api.provisionerJobLogsByID)
-			})
-		})
-
-		r.Route("/provisioners/daemons", func(r chi.Router) {
-			r.Get("/", api.provisionerDaemons)
-			r.Get("/serve", api.provisionerDaemonsServe)
+			r.Get("/", api.workspaceBuild)
+			r.Get("/logs", api.workspaceBuildLogs)
+			r.Get("/resources", api.workspaceBuildResources)
 		})
 	})
 	r.NotFound(site.Handler(options.Logger).ServeHTTP)

coderd/coderdtest/coderdtest.go

@@ -15,7 +15,6 @@ import (
 	"github.com/google/uuid"
 	"github.com/moby/moby/pkg/namesgenerator"
 	"github.com/stretchr/testify/require"
-	"go.opencensus.io/stats/view"
 	"google.golang.org/api/idtoken"
 	"google.golang.org/api/option"
 
@@ -39,13 +38,6 @@ type Options struct {
 // New constructs an in-memory coderd instance and returns
 // the connected client.
 func New(t *testing.T, options *Options) *codersdk.Client {
-	// Stops the opencensus.io worker from leaking a goroutine.
-	// The worker isn't used anyways, and is an indirect dependency
-	// of the Google Cloud SDK.
-	t.Cleanup(func() {
-		view.Stop()
-	})
-
 	if options == nil {
 		options = &Options{}
 	}
@@ -125,7 +117,7 @@ func NewProvisionerDaemon(t *testing.T, client *codersdk.Client) io.Closer {
 		require.NoError(t, err)
 	}()
 
-	closer := provisionerd.New(client.ProvisionerDaemonClient, &provisionerd.Options{
+	closer := provisionerd.New(client.ListenProvisionerDaemon, &provisionerd.Options{
 		Logger:         slogtest.Make(t, nil).Named("provisionerd").Leveled(slog.LevelDebug),
 		PollInterval:   50 * time.Millisecond,
 		UpdateInterval: 50 * time.Millisecond,
@@ -140,16 +132,16 @@ func NewProvisionerDaemon(t *testing.T, client *codersdk.Client) io.Closer {
 	return closer
 }
 
-// CreateInitialUser creates a user with preset credentials and authenticates
+// CreateFirstUser creates a user with preset credentials and authenticates
 // with the passed in codersdk client.
-func CreateInitialUser(t *testing.T, client *codersdk.Client) coderd.CreateInitialUserRequest {
-	req := coderd.CreateInitialUserRequest{
+func CreateFirstUser(t *testing.T, client *codersdk.Client) coderd.CreateFirstUserResponse {
+	req := coderd.CreateFirstUserRequest{
 		Email:        "testuser@coder.com",
 		Username:     "testuser",
 		Password:     "testpass",
 		Organization: "testorg",
 	}
-	_, err := client.CreateInitialUser(context.Background(), req)
+	resp, err := client.CreateFirstUser(context.Background(), req)
 	require.NoError(t, err)
 
 	login, err := client.LoginWithPassword(context.Background(), coderd.LoginWithPasswordRequest{
@@ -158,59 +150,101 @@ func CreateInitialUser(t *testing.T, client *codersdk.Client) coderd.CreateIniti
 	})
 	require.NoError(t, err)
 	client.SessionToken = login.SessionToken
-	return req
+	return resp
 }
 
-// CreateProjectImportJob creates a project import provisioner job
+// CreateAnotherUser creates and authenticates a new user.
+func CreateAnotherUser(t *testing.T, client *codersdk.Client, organization string) *codersdk.Client {
+	req := coderd.CreateUserRequest{
+		Email:          namesgenerator.GetRandomName(1) + "@coder.com",
+		Username:       randomUsername(),
+		Password:       "testpass",
+		OrganizationID: organization,
+	}
+	_, err := client.CreateUser(context.Background(), req)
+	require.NoError(t, err)
+
+	login, err := client.LoginWithPassword(context.Background(), coderd.LoginWithPasswordRequest{
+		Email:    req.Email,
+		Password: req.Password,
+	})
+	require.NoError(t, err)
+
+	other := codersdk.New(client.URL)
+	other.SessionToken = login.SessionToken
+	return other
+}
+
+// CreateProjectVersion creates a project import provisioner job
 // with the responses provided. It uses the "echo" provisioner for compatibility
 // with testing.
-func CreateProjectImportJob(t *testing.T, client *codersdk.Client, organization string, res *echo.Responses) coderd.ProvisionerJob {
+func CreateProjectVersion(t *testing.T, client *codersdk.Client, organization string, res *echo.Responses) coderd.ProjectVersion {
 	data, err := echo.Tar(res)
 	require.NoError(t, err)
-	file, err := client.UploadFile(context.Background(), codersdk.ContentTypeTar, data)
+	file, err := client.Upload(context.Background(), codersdk.ContentTypeTar, data)
 	require.NoError(t, err)
-	job, err := client.CreateProjectImportJob(context.Background(), organization, coderd.CreateProjectImportJobRequest{
+	projectVersion, err := client.CreateProjectVersion(context.Background(), organization, coderd.CreateProjectVersionRequest{
 		StorageSource: file.Hash,
 		StorageMethod: database.ProvisionerStorageMethodFile,
 		Provisioner:   database.ProvisionerTypeEcho,
 	})
 	require.NoError(t, err)
-	return job
+	return projectVersion
 }
 
 // CreateProject creates a project with the "echo" provisioner for
 // compatibility with testing. The name assigned is randomly generated.
-func CreateProject(t *testing.T, client *codersdk.Client, organization string, job uuid.UUID) coderd.Project {
+func CreateProject(t *testing.T, client *codersdk.Client, organization string, version uuid.UUID) coderd.Project {
 	project, err := client.CreateProject(context.Background(), organization, coderd.CreateProjectRequest{
-		Name:               randomUsername(),
-		VersionImportJobID: job,
+		Name:      randomUsername(),
+		VersionID: version,
 	})
 	require.NoError(t, err)
 	return project
 }
 
 // AwaitProjectImportJob awaits for an import job to reach completed status.
-func AwaitProjectImportJob(t *testing.T, client *codersdk.Client, organization string, job uuid.UUID) coderd.ProvisionerJob {
-	var provisionerJob coderd.ProvisionerJob
+func AwaitProjectVersionJob(t *testing.T, client *codersdk.Client, version uuid.UUID) coderd.ProjectVersion {
+	var projectVersion coderd.ProjectVersion
 	require.Eventually(t, func() bool {
 		var err error
-		provisionerJob, err = client.ProjectImportJob(context.Background(), organization, job)
+		projectVersion, err = client.ProjectVersion(context.Background(), version)
 		require.NoError(t, err)
-		return provisionerJob.Status.Completed()
+		return projectVersion.Job.CompletedAt != nil
 	}, 5*time.Second, 25*time.Millisecond)
-	return provisionerJob
+	return projectVersion
 }
 
-// AwaitWorkspaceProvisionJob awaits for a workspace provision job to reach completed status.
-func AwaitWorkspaceProvisionJob(t *testing.T, client *codersdk.Client, organization string, job uuid.UUID) coderd.ProvisionerJob {
-	var provisionerJob coderd.ProvisionerJob
+// AwaitWorkspaceBuildJob waits for a workspace provision job to reach completed status.
+func AwaitWorkspaceBuildJob(t *testing.T, client *codersdk.Client, build uuid.UUID) coderd.WorkspaceBuild {
+	var workspaceBuild coderd.WorkspaceBuild
 	require.Eventually(t, func() bool {
 		var err error
-		provisionerJob, err = client.WorkspaceProvisionJob(context.Background(), organization, job)
+		workspaceBuild, err = client.WorkspaceBuild(context.Background(), build)
 		require.NoError(t, err)
-		return provisionerJob.Status.Completed()
+		return workspaceBuild.Job.CompletedAt != nil
 	}, 5*time.Second, 25*time.Millisecond)
-	return provisionerJob
+	return workspaceBuild
+}
+
+// AwaitWorkspaceAgents waits for all resources with agents to be connected.
+func AwaitWorkspaceAgents(t *testing.T, client *codersdk.Client, build uuid.UUID) []coderd.WorkspaceResource {
+	var resources []coderd.WorkspaceResource
+	require.Eventually(t, func() bool {
+		var err error
+		resources, err = client.WorkspaceResourcesByBuild(context.Background(), build)
+		require.NoError(t, err)
+		for _, resource := range resources {
+			if resource.Agent == nil {
+				continue
+			}
+			if resource.Agent.UpdatedAt.IsZero() {
+				return false
+			}
+		}
+		return true
+	}, 5*time.Second, 25*time.Millisecond)
+	return resources
 }
 
 // CreateWorkspace creates a workspace for the user and project provided.

coderd/coderdtest/coderdtest_test.go

@@ -20,17 +20,18 @@ func TestMain(m *testing.M) {
 func TestNew(t *testing.T) {
 	t.Parallel()
 	client := coderdtest.New(t, nil)
-	user := coderdtest.CreateInitialUser(t, client)
+	user := coderdtest.CreateFirstUser(t, client)
 	closer := coderdtest.NewProvisionerDaemon(t, client)
-	job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-	coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-	project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
+	version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+	coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+	project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
 	workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
-	history, err := client.CreateWorkspaceHistory(context.Background(), "me", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
+	build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
 		ProjectVersionID: project.ActiveVersionID,
 		Transition:       database.WorkspaceTransitionStart,
 	})
 	require.NoError(t, err)
-	coderdtest.AwaitWorkspaceProvisionJob(t, client, user.Organization, history.ProvisionJobID)
+	coderdtest.AwaitWorkspaceBuildJob(t, client, build.ID)
+	coderdtest.AwaitWorkspaceAgents(t, client, build.ID)
 	closer.Close()
 }

coderd/files.go

@@ -2,11 +2,14 @@ package coderd
 
 import (
 	"crypto/sha256"
+	"database/sql"
 	"encoding/hex"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
 
+	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/render"
 
 	"github.com/coder/coder/database"
@@ -14,11 +17,12 @@ import (
 	"github.com/coder/coder/httpmw"
 )
 
-type UploadFileResponse struct {
+// UploadResponse contains the hash to reference the uploaded file.
+type UploadResponse struct {
 	Hash string `json:"hash"`
 }
 
-func (api *api) postUpload(rw http.ResponseWriter, r *http.Request) {
+func (api *api) postFile(rw http.ResponseWriter, r *http.Request) {
 	apiKey := httpmw.APIKey(r)
 	contentType := r.Header.Get("Content-Type")
 
@@ -45,7 +49,7 @@ func (api *api) postUpload(rw http.ResponseWriter, r *http.Request) {
 	if err == nil {
 		// The file already exists!
 		render.Status(r, http.StatusOK)
-		render.JSON(rw, r, UploadFileResponse{
+		render.JSON(rw, r, UploadResponse{
 			Hash: file.Hash,
 		})
 		return
@@ -64,7 +68,33 @@ func (api *api) postUpload(rw http.ResponseWriter, r *http.Request) {
 		return
 	}
 	render.Status(r, http.StatusCreated)
-	render.JSON(rw, r, UploadFileResponse{
+	render.JSON(rw, r, UploadResponse{
 		Hash: file.Hash,
 	})
 }
+
+func (api *api) fileByHash(rw http.ResponseWriter, r *http.Request) {
+	hash := chi.URLParam(r, "hash")
+	if hash == "" {
+		httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
+			Message: "hash must be provided",
+		})
+		return
+	}
+	file, err := api.Database.GetFileByHash(r.Context(), hash)
+	if errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
+			Message: "no file exists with that hash",
+		})
+		return
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get file: %s", err),
+		})
+		return
+	}
+	rw.Header().Set("Content-Type", file.Mimetype)
+	rw.WriteHeader(http.StatusOK)
+	_, _ = rw.Write(file.Data)
+}

coderd/files_test.go

@@ -2,6 +2,7 @@ package coderd_test
 
 import (
 	"context"
+	"net/http"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -10,32 +11,57 @@ import (
 	"github.com/coder/coder/codersdk"
 )
 
-func TestPostUpload(t *testing.T) {
+func TestPostFiles(t *testing.T) {
 	t.Parallel()
 	t.Run("BadContentType", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		_ = coderdtest.CreateInitialUser(t, client)
-		_, err := client.UploadFile(context.Background(), "bad", []byte{'a'})
+		_ = coderdtest.CreateFirstUser(t, client)
+		_, err := client.Upload(context.Background(), "bad", []byte{'a'})
 		require.Error(t, err)
 	})
 
 	t.Run("Insert", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		_ = coderdtest.CreateInitialUser(t, client)
-		_, err := client.UploadFile(context.Background(), codersdk.ContentTypeTar, make([]byte, 1024))
+		_ = coderdtest.CreateFirstUser(t, client)
+		_, err := client.Upload(context.Background(), codersdk.ContentTypeTar, make([]byte, 1024))
 		require.NoError(t, err)
 	})
 
 	t.Run("InsertAlreadyExists", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		_ = coderdtest.CreateInitialUser(t, client)
+		_ = coderdtest.CreateFirstUser(t, client)
 		data := make([]byte, 1024)
-		_, err := client.UploadFile(context.Background(), codersdk.ContentTypeTar, data)
+		_, err := client.Upload(context.Background(), codersdk.ContentTypeTar, data)
 		require.NoError(t, err)
-		_, err = client.UploadFile(context.Background(), codersdk.ContentTypeTar, data)
+		_, err = client.Upload(context.Background(), codersdk.ContentTypeTar, data)
 		require.NoError(t, err)
 	})
 }
+
+func TestDownload(t *testing.T) {
+	t.Parallel()
+	t.Run("NotFound", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		_ = coderdtest.CreateFirstUser(t, client)
+		_, _, err := client.Download(context.Background(), "something")
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusNotFound, apiErr.StatusCode())
+	})
+
+	t.Run("Insert", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		_ = coderdtest.CreateFirstUser(t, client)
+		resp, err := client.Upload(context.Background(), codersdk.ContentTypeTar, make([]byte, 1024))
+		require.NoError(t, err)
+		data, contentType, err := client.Download(context.Background(), resp.Hash)
+		require.NoError(t, err)
+		require.Len(t, data, 1024)
+		require.Equal(t, codersdk.ContentTypeTar, contentType)
+	})
+}

coderd/organizations.go

@@ -1,9 +1,21 @@
 package coderd
 
 import (
+	"database/sql"
+	"errors"
+	"fmt"
+	"net/http"
 	"time"
 
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/render"
+	"github.com/google/uuid"
+	"github.com/moby/moby/pkg/namesgenerator"
+	"golang.org/x/xerrors"
+
 	"github.com/coder/coder/database"
+	"github.com/coder/coder/httpapi"
+	"github.com/coder/coder/httpmw"
 )
 
 // Organization is the JSON representation of a Coder organization.
@@ -14,6 +26,317 @@ type Organization struct {
 	UpdatedAt time.Time `json:"updated_at" validate:"required"`
 }
 
+// CreateProjectVersionRequest enables callers to create a new Project Version.
+type CreateProjectVersionRequest struct {
+	// ProjectID optionally associates a version with a project.
+	ProjectID *uuid.UUID `json:"project_id"`
+
+	StorageMethod database.ProvisionerStorageMethod `json:"storage_method" validate:"oneof=file,required"`
+	StorageSource string                            `json:"storage_source" validate:"required"`
+	Provisioner   database.ProvisionerType          `json:"provisioner" validate:"oneof=terraform echo,required"`
+	// ParameterValues allows for additional parameters to be provided
+	// during the dry-run provision stage.
+	ParameterValues []CreateParameterRequest `json:"parameter_values"`
+}
+
+// CreateProjectRequest provides options when creating a project.
+type CreateProjectRequest struct {
+	Name string `json:"name" validate:"username,required"`
+
+	// VersionID is an in-progress or completed job to use as
+	// an initial version of the project.
+	//
+	// This is required on creation to enable a user-flow of validating a
+	// project works. There is no reason the data-model cannot support
+	// empty projects, but it doesn't make sense for users.
+	VersionID uuid.UUID `json:"project_version_id" validate:"required"`
+}
+
+func (*api) organization(rw http.ResponseWriter, r *http.Request) {
+	organization := httpmw.OrganizationParam(r)
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, convertOrganization(organization))
+}
+
+func (api *api) provisionerDaemonsByOrganization(rw http.ResponseWriter, r *http.Request) {
+	daemons, err := api.Database.GetProvisionerDaemons(r.Context())
+	if errors.Is(err, sql.ErrNoRows) {
+		err = nil
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner daemons: %s", err),
+		})
+		return
+	}
+	if daemons == nil {
+		daemons = []database.ProvisionerDaemon{}
+	}
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, daemons)
+}
+
+// Creates a new version of a project. An import job is queued to parse the storage method provided.
+func (api *api) postProjectVersionsByOrganization(rw http.ResponseWriter, r *http.Request) {
+	apiKey := httpmw.APIKey(r)
+	organization := httpmw.OrganizationParam(r)
+	var req CreateProjectVersionRequest
+	if !httpapi.Read(rw, r, &req) {
+		return
+	}
+	if req.ProjectID != nil {
+		_, err := api.Database.GetProjectByID(r.Context(), *req.ProjectID)
+		if errors.Is(err, sql.ErrNoRows) {
+			httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
+				Message: "project does not exist",
+			})
+			return
+		}
+		if err != nil {
+			httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+				Message: fmt.Sprintf("get project: %s", err),
+			})
+			return
+		}
+	}
+
+	file, err := api.Database.GetFileByHash(r.Context(), req.StorageSource)
+	if errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
+			Message: "file not found",
+		})
+		return
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get file: %s", err),
+		})
+		return
+	}
+
+	var projectVersion database.ProjectVersion
+	var provisionerJob database.ProvisionerJob
+	err = api.Database.InTx(func(db database.Store) error {
+		jobID := uuid.New()
+		for _, parameterValue := range req.ParameterValues {
+			_, err = db.InsertParameterValue(r.Context(), database.InsertParameterValueParams{
+				ID:                uuid.New(),
+				Name:              parameterValue.Name,
+				CreatedAt:         database.Now(),
+				UpdatedAt:         database.Now(),
+				Scope:             database.ParameterScopeImportJob,
+				ScopeID:           jobID.String(),
+				SourceScheme:      parameterValue.SourceScheme,
+				SourceValue:       parameterValue.SourceValue,
+				DestinationScheme: parameterValue.DestinationScheme,
+			})
+			if err != nil {
+				return xerrors.Errorf("insert parameter value: %w", err)
+			}
+		}
+
+		provisionerJob, err = api.Database.InsertProvisionerJob(r.Context(), database.InsertProvisionerJobParams{
+			ID:             jobID,
+			CreatedAt:      database.Now(),
+			UpdatedAt:      database.Now(),
+			OrganizationID: organization.ID,
+			InitiatorID:    apiKey.UserID,
+			Provisioner:    req.Provisioner,
+			StorageMethod:  database.ProvisionerStorageMethodFile,
+			StorageSource:  file.Hash,
+			Type:           database.ProvisionerJobTypeProjectVersionImport,
+			Input:          []byte{'{', '}'},
+		})
+		if err != nil {
+			return xerrors.Errorf("insert provisioner job: %w", err)
+		}
+
+		var projectID uuid.NullUUID
+		if req.ProjectID != nil {
+			projectID = uuid.NullUUID{
+				UUID:  *req.ProjectID,
+				Valid: true,
+			}
+		}
+
+		projectVersion, err = api.Database.InsertProjectVersion(r.Context(), database.InsertProjectVersionParams{
+			ID:             uuid.New(),
+			ProjectID:      projectID,
+			OrganizationID: organization.ID,
+			CreatedAt:      database.Now(),
+			UpdatedAt:      database.Now(),
+			Name:           namesgenerator.GetRandomName(1),
+			Description:    "",
+			JobID:          provisionerJob.ID,
+		})
+		if err != nil {
+			return xerrors.Errorf("insert project version: %w", err)
+		}
+		return nil
+	})
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: err.Error(),
+		})
+		return
+	}
+
+	render.Status(r, http.StatusCreated)
+	render.JSON(rw, r, convertProjectVersion(projectVersion, convertProvisionerJob(provisionerJob)))
+}
+
+// Create a new project in an organization.
+func (api *api) postProjectsByOrganization(rw http.ResponseWriter, r *http.Request) {
+	var createProject CreateProjectRequest
+	if !httpapi.Read(rw, r, &createProject) {
+		return
+	}
+	organization := httpmw.OrganizationParam(r)
+	_, err := api.Database.GetProjectByOrganizationAndName(r.Context(), database.GetProjectByOrganizationAndNameParams{
+		OrganizationID: organization.ID,
+		Name:           createProject.Name,
+	})
+	if err == nil {
+		httpapi.Write(rw, http.StatusConflict, httpapi.Response{
+			Message: fmt.Sprintf("project %q already exists", createProject.Name),
+			Errors: []httpapi.Error{{
+				Field: "name",
+				Code:  "exists",
+			}},
+		})
+		return
+	}
+	if !errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get project by name: %s", err),
+		})
+		return
+	}
+	projectVersion, err := api.Database.GetProjectVersionByID(r.Context(), createProject.VersionID)
+	if errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
+			Message: "project version does not exist",
+		})
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get project version by id: %s", err),
+		})
+		return
+	}
+	importJob, err := api.Database.GetProvisionerJobByID(r.Context(), projectVersion.JobID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get import job by id: %s", err),
+		})
+		return
+	}
+
+	var project Project
+	err = api.Database.InTx(func(db database.Store) error {
+		dbProject, err := db.InsertProject(r.Context(), database.InsertProjectParams{
+			ID:              uuid.New(),
+			CreatedAt:       database.Now(),
+			UpdatedAt:       database.Now(),
+			OrganizationID:  organization.ID,
+			Name:            createProject.Name,
+			Provisioner:     importJob.Provisioner,
+			ActiveVersionID: projectVersion.ID,
+		})
+		if err != nil {
+			return xerrors.Errorf("insert project: %s", err)
+		}
+		err = db.UpdateProjectVersionByID(r.Context(), database.UpdateProjectVersionByIDParams{
+			ID: projectVersion.ID,
+			ProjectID: uuid.NullUUID{
+				UUID:  dbProject.ID,
+				Valid: true,
+			},
+		})
+		if err != nil {
+			return xerrors.Errorf("insert project version: %s", err)
+		}
+		project = convertProject(dbProject, 0)
+		return nil
+	})
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: err.Error(),
+		})
+		return
+	}
+
+	render.Status(r, http.StatusCreated)
+	render.JSON(rw, r, project)
+}
+
+func (api *api) projectsByOrganization(rw http.ResponseWriter, r *http.Request) {
+	organization := httpmw.OrganizationParam(r)
+	projects, err := api.Database.GetProjectsByOrganization(r.Context(), organization.ID)
+	if errors.Is(err, sql.ErrNoRows) {
+		err = nil
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get projects: %s", err.Error()),
+		})
+		return
+	}
+	projectIDs := make([]uuid.UUID, 0, len(projects))
+	for _, project := range projects {
+		projectIDs = append(projectIDs, project.ID)
+	}
+	workspaceCounts, err := api.Database.GetWorkspaceOwnerCountsByProjectIDs(r.Context(), projectIDs)
+	if errors.Is(err, sql.ErrNoRows) {
+		err = nil
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get workspace counts: %s", err.Error()),
+		})
+		return
+	}
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, convertProjects(projects, workspaceCounts))
+}
+
+func (api *api) projectByOrganizationAndName(rw http.ResponseWriter, r *http.Request) {
+	organization := httpmw.OrganizationParam(r)
+	projectName := chi.URLParam(r, "projectname")
+	project, err := api.Database.GetProjectByOrganizationAndName(r.Context(), database.GetProjectByOrganizationAndNameParams{
+		OrganizationID: organization.ID,
+		Name:           projectName,
+	})
+	if errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
+			Message: fmt.Sprintf("no project found by name %q in the %q organization", projectName, organization.Name),
+		})
+		return
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get project by organization and name: %s", err),
+		})
+		return
+	}
+	workspaceCounts, err := api.Database.GetWorkspaceOwnerCountsByProjectIDs(r.Context(), []uuid.UUID{project.ID})
+	if errors.Is(err, sql.ErrNoRows) {
+		err = nil
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get workspace counts: %s", err.Error()),
+		})
+		return
+	}
+	count := uint32(0)
+	if len(workspaceCounts) > 0 {
+		count = uint32(workspaceCounts[0].Count)
+	}
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, convertProject(project, count))
+}
+
 // convertOrganization consumes the database representation and outputs an API friendly representation.
 func convertOrganization(organization database.Organization) Organization {
 	return Organization{

coderd/organizations_test.go

@@ -0,0 +1,179 @@
+package coderd_test
+
+import (
+	"context"
+	"net/http"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/require"
+
+	"github.com/coder/coder/coderd"
+	"github.com/coder/coder/coderd/coderdtest"
+	"github.com/coder/coder/codersdk"
+	"github.com/coder/coder/database"
+	"github.com/coder/coder/provisioner/echo"
+)
+
+func TestProvisionerDaemonsByOrganization(t *testing.T) {
+	t.Parallel()
+	t.Run("NoAuth", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		_, err := client.ProvisionerDaemonsByOrganization(context.Background(), "someorg")
+		require.Error(t, err)
+	})
+
+	t.Run("Get", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		_, err := client.ProvisionerDaemonsByOrganization(context.Background(), user.OrganizationID)
+		require.NoError(t, err)
+	})
+}
+
+func TestPostProjectVersionsByOrganization(t *testing.T) {
+	t.Parallel()
+	t.Run("InvalidProject", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		projectID := uuid.New()
+		_, err := client.CreateProjectVersion(context.Background(), user.OrganizationID, coderd.CreateProjectVersionRequest{
+			ProjectID:     &projectID,
+			StorageMethod: database.ProvisionerStorageMethodFile,
+			StorageSource: "hash",
+			Provisioner:   database.ProvisionerTypeEcho,
+		})
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusNotFound, apiErr.StatusCode())
+	})
+
+	t.Run("FileNotFound", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		_, err := client.CreateProjectVersion(context.Background(), user.OrganizationID, coderd.CreateProjectVersionRequest{
+			StorageMethod: database.ProvisionerStorageMethodFile,
+			StorageSource: "hash",
+			Provisioner:   database.ProvisionerTypeEcho,
+		})
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusNotFound, apiErr.StatusCode())
+	})
+
+	t.Run("WithParameters", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		data, err := echo.Tar(&echo.Responses{
+			Parse:           echo.ParseComplete,
+			Provision:       echo.ProvisionComplete,
+			ProvisionDryRun: echo.ProvisionComplete,
+		})
+		require.NoError(t, err)
+		file, err := client.Upload(context.Background(), codersdk.ContentTypeTar, data)
+		require.NoError(t, err)
+		_, err = client.CreateProjectVersion(context.Background(), user.OrganizationID, coderd.CreateProjectVersionRequest{
+			StorageMethod: database.ProvisionerStorageMethodFile,
+			StorageSource: file.Hash,
+			Provisioner:   database.ProvisionerTypeEcho,
+			ParameterValues: []coderd.CreateParameterRequest{{
+				Name:              "example",
+				SourceValue:       "value",
+				SourceScheme:      database.ParameterSourceSchemeData,
+				DestinationScheme: database.ParameterDestinationSchemeProvisionerVariable,
+			}},
+		})
+		require.NoError(t, err)
+	})
+}
+
+func TestPostProjectsByOrganization(t *testing.T) {
+	t.Parallel()
+	t.Run("Create", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		_ = coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+	})
+
+	t.Run("AlreadyExists", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		_, err := client.CreateProject(context.Background(), user.OrganizationID, coderd.CreateProjectRequest{
+			Name:      project.Name,
+			VersionID: version.ID,
+		})
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusConflict, apiErr.StatusCode())
+	})
+
+	t.Run("NoVersion", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		_, err := client.CreateProject(context.Background(), user.OrganizationID, coderd.CreateProjectRequest{
+			Name:      "test",
+			VersionID: uuid.New(),
+		})
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusNotFound, apiErr.StatusCode())
+	})
+}
+
+func TestProjectsByOrganization(t *testing.T) {
+	t.Parallel()
+	t.Run("ListEmpty", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		projects, err := client.ProjectsByOrganization(context.Background(), user.OrganizationID)
+		require.NoError(t, err)
+		require.NotNil(t, projects)
+		require.Len(t, projects, 0)
+	})
+
+	t.Run("List", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		projects, err := client.ProjectsByOrganization(context.Background(), user.OrganizationID)
+		require.NoError(t, err)
+		require.Len(t, projects, 1)
+	})
+}
+
+func TestProjectByOrganizationAndName(t *testing.T) {
+	t.Parallel()
+	t.Run("NotFound", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		_, err := client.ProjectByName(context.Background(), user.OrganizationID, "something")
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusNotFound, apiErr.StatusCode())
+	})
+
+	t.Run("Found", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		_, err := client.ProjectByName(context.Background(), user.OrganizationID, project.Name)
+		require.NoError(t, err)
+	})
+}

coderd/parameters.go

@@ -0,0 +1,189 @@
+package coderd
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/render"
+	"github.com/google/uuid"
+
+	"github.com/coder/coder/database"
+	"github.com/coder/coder/httpapi"
+)
+
+type ParameterScope string
+
+const (
+	ParameterOrganization ParameterScope = "organization"
+	ParameterProject      ParameterScope = "project"
+	ParameterUser         ParameterScope = "user"
+	ParameterWorkspace    ParameterScope = "workspace"
+)
+
+// Parameter represents a set value for the scope.
+type Parameter struct {
+	ID                uuid.UUID                           `db:"id" json:"id"`
+	CreatedAt         time.Time                           `db:"created_at" json:"created_at"`
+	UpdatedAt         time.Time                           `db:"updated_at" json:"updated_at"`
+	Scope             ParameterScope                      `db:"scope" json:"scope"`
+	ScopeID           string                              `db:"scope_id" json:"scope_id"`
+	Name              string                              `db:"name" json:"name"`
+	SourceScheme      database.ParameterSourceScheme      `db:"source_scheme" json:"source_scheme"`
+	DestinationScheme database.ParameterDestinationScheme `db:"destination_scheme" json:"destination_scheme"`
+}
+
+// CreateParameterRequest is used to create a new parameter value for a scope.
+type CreateParameterRequest struct {
+	Name              string                              `json:"name" validate:"required"`
+	SourceValue       string                              `json:"source_value" validate:"required"`
+	SourceScheme      database.ParameterSourceScheme      `json:"source_scheme" validate:"oneof=data,required"`
+	DestinationScheme database.ParameterDestinationScheme `json:"destination_scheme" validate:"oneof=environment_variable provisioner_variable,required"`
+}
+
+func (api *api) postParameter(rw http.ResponseWriter, r *http.Request) {
+	var createRequest CreateParameterRequest
+	if !httpapi.Read(rw, r, &createRequest) {
+		return
+	}
+	scope, scopeID, valid := readScopeAndID(rw, r)
+	if !valid {
+		return
+	}
+	_, err := api.Database.GetParameterValueByScopeAndName(r.Context(), database.GetParameterValueByScopeAndNameParams{
+		Scope:   scope,
+		ScopeID: scopeID,
+		Name:    createRequest.Name,
+	})
+	if err == nil {
+		httpapi.Write(rw, http.StatusConflict, httpapi.Response{
+			Message: fmt.Sprintf("a parameter already exists in scope %q with name %q", scope, createRequest.Name),
+		})
+		return
+	}
+	if !errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get parameter value: %s", err),
+		})
+		return
+	}
+	parameterValue, err := api.Database.InsertParameterValue(r.Context(), database.InsertParameterValueParams{
+		ID:                uuid.New(),
+		Name:              createRequest.Name,
+		CreatedAt:         database.Now(),
+		UpdatedAt:         database.Now(),
+		Scope:             scope,
+		ScopeID:           scopeID,
+		SourceScheme:      createRequest.SourceScheme,
+		SourceValue:       createRequest.SourceValue,
+		DestinationScheme: createRequest.DestinationScheme,
+	})
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("insert parameter value: %s", err),
+		})
+		return
+	}
+
+	render.Status(r, http.StatusCreated)
+	render.JSON(rw, r, convertParameterValue(parameterValue))
+}
+
+func (api *api) parameters(rw http.ResponseWriter, r *http.Request) {
+	scope, scopeID, valid := readScopeAndID(rw, r)
+	if !valid {
+		return
+	}
+	parameterValues, err := api.Database.GetParameterValuesByScope(r.Context(), database.GetParameterValuesByScopeParams{
+		Scope:   scope,
+		ScopeID: scopeID,
+	})
+	if errors.Is(err, sql.ErrNoRows) {
+		err = nil
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get parameter values by scope: %s", err),
+		})
+		return
+	}
+	apiParameterValues := make([]Parameter, 0, len(parameterValues))
+	for _, parameterValue := range parameterValues {
+		apiParameterValues = append(apiParameterValues, convertParameterValue(parameterValue))
+	}
+
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, apiParameterValues)
+}
+
+func (api *api) deleteParameter(rw http.ResponseWriter, r *http.Request) {
+	scope, scopeID, valid := readScopeAndID(rw, r)
+	if !valid {
+		return
+	}
+	name := chi.URLParam(r, "name")
+	parameterValue, err := api.Database.GetParameterValueByScopeAndName(r.Context(), database.GetParameterValueByScopeAndNameParams{
+		Scope:   scope,
+		ScopeID: scopeID,
+		Name:    name,
+	})
+	if errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
+			Message: fmt.Sprintf("parameter doesn't exist in the provided scope with name %q", name),
+		})
+		return
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get parameter value: %s", err),
+		})
+		return
+	}
+	err = api.Database.DeleteParameterValueByID(r.Context(), parameterValue.ID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("delete parameter: %s", err),
+		})
+		return
+	}
+	httpapi.Write(rw, http.StatusOK, httpapi.Response{
+		Message: "parameter deleted",
+	})
+}
+
+func convertParameterValue(parameterValue database.ParameterValue) Parameter {
+	return Parameter{
+		ID:                parameterValue.ID,
+		CreatedAt:         parameterValue.CreatedAt,
+		UpdatedAt:         parameterValue.UpdatedAt,
+		Scope:             ParameterScope(parameterValue.Scope),
+		ScopeID:           parameterValue.ScopeID,
+		Name:              parameterValue.Name,
+		SourceScheme:      parameterValue.SourceScheme,
+		DestinationScheme: parameterValue.DestinationScheme,
+	}
+}
+
+func readScopeAndID(rw http.ResponseWriter, r *http.Request) (database.ParameterScope, string, bool) {
+	var scope database.ParameterScope
+	switch chi.URLParam(r, "scope") {
+	case string(ParameterOrganization):
+		scope = database.ParameterScopeOrganization
+	case string(ParameterProject):
+		scope = database.ParameterScopeProject
+	case string(ParameterUser):
+		scope = database.ParameterScopeUser
+	case string(ParameterWorkspace):
+		scope = database.ParameterScopeWorkspace
+	default:
+		httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
+			Message: fmt.Sprintf("invalid scope %q", scope),
+		})
+		return scope, "", false
+	}
+
+	return scope, chi.URLParam(r, "id"), true
+}

coderd/parameters_test.go

@@ -0,0 +1,121 @@
+package coderd_test
+
+import (
+	"context"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/coder/coder/coderd"
+	"github.com/coder/coder/coderd/coderdtest"
+	"github.com/coder/coder/codersdk"
+	"github.com/coder/coder/database"
+)
+
+func TestPostParameter(t *testing.T) {
+	t.Parallel()
+	t.Run("BadScope", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		_, err := client.CreateParameter(context.Background(), coderd.ParameterScope("something"), user.OrganizationID, coderd.CreateParameterRequest{
+			Name:              "example",
+			SourceValue:       "tomato",
+			SourceScheme:      database.ParameterSourceSchemeData,
+			DestinationScheme: database.ParameterDestinationSchemeProvisionerVariable,
+		})
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusBadRequest, apiErr.StatusCode())
+	})
+
+	t.Run("Create", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		_, err := client.CreateParameter(context.Background(), coderd.ParameterOrganization, user.OrganizationID, coderd.CreateParameterRequest{
+			Name:              "example",
+			SourceValue:       "tomato",
+			SourceScheme:      database.ParameterSourceSchemeData,
+			DestinationScheme: database.ParameterDestinationSchemeProvisionerVariable,
+		})
+		require.NoError(t, err)
+	})
+
+	t.Run("AlreadyExists", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		_, err := client.CreateParameter(context.Background(), coderd.ParameterOrganization, user.OrganizationID, coderd.CreateParameterRequest{
+			Name:              "example",
+			SourceValue:       "tomato",
+			SourceScheme:      database.ParameterSourceSchemeData,
+			DestinationScheme: database.ParameterDestinationSchemeProvisionerVariable,
+		})
+		require.NoError(t, err)
+
+		_, err = client.CreateParameter(context.Background(), coderd.ParameterOrganization, user.OrganizationID, coderd.CreateParameterRequest{
+			Name:              "example",
+			SourceValue:       "tomato",
+			SourceScheme:      database.ParameterSourceSchemeData,
+			DestinationScheme: database.ParameterDestinationSchemeProvisionerVariable,
+		})
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusConflict, apiErr.StatusCode())
+	})
+}
+
+func TestParameters(t *testing.T) {
+	t.Parallel()
+	t.Run("ListEmpty", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		_, err := client.Parameters(context.Background(), coderd.ParameterOrganization, user.OrganizationID)
+		require.NoError(t, err)
+	})
+	t.Run("List", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		_, err := client.CreateParameter(context.Background(), coderd.ParameterOrganization, user.OrganizationID, coderd.CreateParameterRequest{
+			Name:              "example",
+			SourceValue:       "tomato",
+			SourceScheme:      database.ParameterSourceSchemeData,
+			DestinationScheme: database.ParameterDestinationSchemeProvisionerVariable,
+		})
+		require.NoError(t, err)
+		params, err := client.Parameters(context.Background(), coderd.ParameterOrganization, user.OrganizationID)
+		require.NoError(t, err)
+		require.Len(t, params, 1)
+	})
+}
+
+func TestDeleteParameter(t *testing.T) {
+	t.Parallel()
+	t.Run("NotExist", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		err := client.DeleteParameter(context.Background(), coderd.ParameterOrganization, user.OrganizationID, "something")
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusNotFound, apiErr.StatusCode())
+	})
+	t.Run("Delete", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		param, err := client.CreateParameter(context.Background(), coderd.ParameterOrganization, user.OrganizationID, coderd.CreateParameterRequest{
+			Name:              "example",
+			SourceValue:       "tomato",
+			SourceScheme:      database.ParameterSourceSchemeData,
+			DestinationScheme: database.ParameterDestinationSchemeProvisionerVariable,
+		})
+		require.NoError(t, err)
+		err = client.DeleteParameter(context.Background(), coderd.ParameterOrganization, user.OrganizationID, param.Name)
+		require.NoError(t, err)
+	})
+}

coderd/projectimport.go

@@ -1,182 +0,0 @@
-package coderd
-
-import (
-	"database/sql"
-	"errors"
-	"fmt"
-	"net/http"
-
-	"github.com/go-chi/render"
-	"github.com/google/uuid"
-
-	"github.com/coder/coder/coderd/parameter"
-	"github.com/coder/coder/database"
-	"github.com/coder/coder/httpapi"
-	"github.com/coder/coder/httpmw"
-)
-
-// ParameterSchema represents a parameter parsed from project version source.
-type ParameterSchema database.ParameterSchema
-
-// ComputedParameterValue represents a computed parameter value.
-type ComputedParameterValue parameter.ComputedValue
-
-// CreateProjectImportJobRequest provides options to create a project import job.
-type CreateProjectImportJobRequest struct {
-	StorageMethod database.ProvisionerStorageMethod `json:"storage_method" validate:"oneof=file,required"`
-	StorageSource string                            `json:"storage_source" validate:"required"`
-	Provisioner   database.ProvisionerType          `json:"provisioner" validate:"oneof=terraform echo,required"`
-	// ParameterValues allows for additional parameters to be provided
-	// during the dry-run provision stage.
-	ParameterValues []CreateParameterValueRequest `json:"parameter_values"`
-}
-
-// Create a new project import job!
-func (api *api) postProjectImportByOrganization(rw http.ResponseWriter, r *http.Request) {
-	apiKey := httpmw.APIKey(r)
-	organization := httpmw.OrganizationParam(r)
-	var req CreateProjectImportJobRequest
-	if !httpapi.Read(rw, r, &req) {
-		return
-	}
-	file, err := api.Database.GetFileByHash(r.Context(), req.StorageSource)
-	if errors.Is(err, sql.ErrNoRows) {
-		httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
-			Message: "file not found",
-		})
-		return
-	}
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get file: %s", err),
-		})
-		return
-	}
-
-	jobID := uuid.New()
-	for _, parameterValue := range req.ParameterValues {
-		_, err = api.Database.InsertParameterValue(r.Context(), database.InsertParameterValueParams{
-			ID:                uuid.New(),
-			Name:              parameterValue.Name,
-			CreatedAt:         database.Now(),
-			UpdatedAt:         database.Now(),
-			Scope:             database.ParameterScopeImportJob,
-			ScopeID:           jobID.String(),
-			SourceScheme:      parameterValue.SourceScheme,
-			SourceValue:       parameterValue.SourceValue,
-			DestinationScheme: parameterValue.DestinationScheme,
-		})
-		if err != nil {
-			httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-				Message: fmt.Sprintf("insert parameter value: %s", err),
-			})
-			return
-		}
-	}
-
-	job, err := api.Database.InsertProvisionerJob(r.Context(), database.InsertProvisionerJobParams{
-		ID:             jobID,
-		CreatedAt:      database.Now(),
-		UpdatedAt:      database.Now(),
-		OrganizationID: organization.ID,
-		InitiatorID:    apiKey.UserID,
-		Provisioner:    req.Provisioner,
-		StorageMethod:  database.ProvisionerStorageMethodFile,
-		StorageSource:  file.Hash,
-		Type:           database.ProvisionerJobTypeProjectVersionImport,
-		Input:          []byte{'{', '}'},
-	})
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("insert provisioner job: %s", err),
-		})
-		return
-	}
-
-	render.Status(r, http.StatusCreated)
-	render.JSON(rw, r, convertProvisionerJob(job))
-}
-
-// Returns imported parameter schemas from a completed job!
-func (api *api) projectImportJobSchemasByID(rw http.ResponseWriter, r *http.Request) {
-	job := httpmw.ProvisionerJobParam(r)
-	if !convertProvisionerJob(job).Status.Completed() {
-		httpapi.Write(rw, http.StatusPreconditionFailed, httpapi.Response{
-			Message: "Job hasn't completed!",
-		})
-		return
-	}
-
-	schemas, err := api.Database.GetParameterSchemasByJobID(r.Context(), job.ID)
-	if errors.Is(err, sql.ErrNoRows) {
-		err = nil
-	}
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("list parameter schemas: %s", err),
-		})
-		return
-	}
-	if schemas == nil {
-		schemas = []database.ParameterSchema{}
-	}
-	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, schemas)
-}
-
-// Returns computed parameters for an import job by ID.
-func (api *api) projectImportJobParametersByID(rw http.ResponseWriter, r *http.Request) {
-	apiKey := httpmw.APIKey(r)
-	job := httpmw.ProvisionerJobParam(r)
-	if !convertProvisionerJob(job).Status.Completed() {
-		httpapi.Write(rw, http.StatusPreconditionFailed, httpapi.Response{
-			Message: "Job hasn't completed!",
-		})
-		return
-	}
-	values, err := parameter.Compute(r.Context(), api.Database, parameter.ComputeScope{
-		ProjectImportJobID: job.ID,
-		OrganizationID:     job.OrganizationID,
-		UserID:             apiKey.UserID,
-	}, &parameter.ComputeOptions{
-		// We *never* want to send the client secret parameter values.
-		HideRedisplayValues: true,
-	})
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("compute values: %s", err),
-		})
-		return
-	}
-	if values == nil {
-		values = []parameter.ComputedValue{}
-	}
-	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, values)
-}
-
-// Returns resources for an import job by ID.
-func (api *api) projectImportJobResourcesByID(rw http.ResponseWriter, r *http.Request) {
-	job := httpmw.ProvisionerJobParam(r)
-	if !convertProvisionerJob(job).Status.Completed() {
-		httpapi.Write(rw, http.StatusPreconditionFailed, httpapi.Response{
-			Message: "Job hasn't completed!",
-		})
-		return
-	}
-	resources, err := api.Database.GetProvisionerJobResourcesByJobID(r.Context(), job.ID)
-	if errors.Is(err, sql.ErrNoRows) {
-		err = nil
-	}
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get project import job resources: %s", err),
-		})
-		return
-	}
-	if resources == nil {
-		resources = []database.ProvisionerJobResource{}
-	}
-	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, resources)
-}

coderd/projectimport_test.go

@@ -1,163 +0,0 @@
-package coderd_test
-
-import (
-	"context"
-	"net/http"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/coder/coder/coderd"
-	"github.com/coder/coder/coderd/coderdtest"
-	"github.com/coder/coder/codersdk"
-	"github.com/coder/coder/database"
-	"github.com/coder/coder/provisioner/echo"
-	"github.com/coder/coder/provisionersdk/proto"
-)
-
-func TestPostProjectImportByOrganization(t *testing.T) {
-	t.Parallel()
-	t.Run("FileNotFound", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		_, err := client.CreateProjectImportJob(context.Background(), user.Organization, coderd.CreateProjectImportJobRequest{
-			StorageMethod: database.ProvisionerStorageMethodFile,
-			StorageSource: "bananas",
-			Provisioner:   database.ProvisionerTypeEcho,
-		})
-		require.Error(t, err)
-	})
-	t.Run("Create", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		_ = coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-	})
-}
-
-func TestProjectImportJobSchemasByID(t *testing.T) {
-	t.Parallel()
-	t.Run("ListRunning", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		_, err := client.ProjectImportJobSchemas(context.Background(), user.Organization, job.ID)
-		var apiErr *codersdk.Error
-		require.ErrorAs(t, err, &apiErr)
-		require.Equal(t, http.StatusPreconditionFailed, apiErr.StatusCode())
-	})
-	t.Run("List", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, &echo.Responses{
-			Parse: []*proto.Parse_Response{{
-				Type: &proto.Parse_Response_Complete{
-					Complete: &proto.Parse_Complete{
-						ParameterSchemas: []*proto.ParameterSchema{{
-							Name: "example",
-							DefaultDestination: &proto.ParameterDestination{
-								Scheme: proto.ParameterDestination_PROVISIONER_VARIABLE,
-							},
-						}},
-					},
-				},
-			}},
-			Provision: echo.ProvisionComplete,
-		})
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-		schemas, err := client.ProjectImportJobSchemas(context.Background(), user.Organization, job.ID)
-		require.NoError(t, err)
-		require.NotNil(t, schemas)
-		require.Len(t, schemas, 1)
-	})
-}
-
-func TestProjectImportJobParametersByID(t *testing.T) {
-	t.Parallel()
-	t.Run("ListRunning", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		_, err := client.ProjectImportJobSchemas(context.Background(), user.Organization, job.ID)
-		var apiErr *codersdk.Error
-		require.ErrorAs(t, err, &apiErr)
-		require.Equal(t, http.StatusPreconditionFailed, apiErr.StatusCode())
-	})
-	t.Run("List", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, &echo.Responses{
-			Parse: []*proto.Parse_Response{{
-				Type: &proto.Parse_Response_Complete{
-					Complete: &proto.Parse_Complete{
-						ParameterSchemas: []*proto.ParameterSchema{{
-							Name:           "example",
-							RedisplayValue: true,
-							DefaultSource: &proto.ParameterSource{
-								Scheme: proto.ParameterSource_DATA,
-								Value:  "hello",
-							},
-							DefaultDestination: &proto.ParameterDestination{
-								Scheme: proto.ParameterDestination_PROVISIONER_VARIABLE,
-							},
-						}},
-					},
-				},
-			}},
-			Provision: echo.ProvisionComplete,
-		})
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-		params, err := client.ProjectImportJobParameters(context.Background(), user.Organization, job.ID)
-		require.NoError(t, err)
-		require.NotNil(t, params)
-		require.Len(t, params, 1)
-		require.Equal(t, "hello", params[0].SourceValue)
-	})
-}
-
-func TestProjectImportJobResourcesByID(t *testing.T) {
-	t.Parallel()
-	t.Run("ListRunning", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		_, err := client.ProjectImportJobResources(context.Background(), user.Organization, job.ID)
-		var apiErr *codersdk.Error
-		require.ErrorAs(t, err, &apiErr)
-		require.Equal(t, http.StatusPreconditionFailed, apiErr.StatusCode())
-	})
-	t.Run("List", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, &echo.Responses{
-			Parse: echo.ParseComplete,
-			Provision: []*proto.Provision_Response{{
-				Type: &proto.Provision_Response_Complete{
-					Complete: &proto.Provision_Complete{
-						Resources: []*proto.Resource{{
-							Name: "some",
-							Type: "example",
-						}},
-					},
-				},
-			}},
-		})
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-		resources, err := client.ProjectImportJobResources(context.Background(), user.Organization, job.ID)
-		require.NoError(t, err)
-		require.NotNil(t, resources)
-		require.Len(t, resources, 2)
-		require.Equal(t, "some", resources[0].Name)
-		require.Equal(t, "example", resources[0].Type)
-	})
-}

coderd/projects.go

@@ -7,27 +7,15 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/render"
 	"github.com/google/uuid"
-	"github.com/moby/moby/pkg/namesgenerator"
-	"golang.org/x/xerrors"
 
 	"github.com/coder/coder/database"
 	"github.com/coder/coder/httpapi"
 	"github.com/coder/coder/httpmw"
 )
 
-// ParameterValue represents a set value for the scope.
-type ParameterValue database.ParameterValue
-
-// CreateParameterValueRequest is used to create a new parameter value for a scope.
-type CreateParameterValueRequest struct {
-	Name              string                              `json:"name" validate:"required"`
-	SourceValue       string                              `json:"source_value" validate:"required"`
-	SourceScheme      database.ParameterSourceScheme      `json:"source_scheme" validate:"oneof=data,required"`
-	DestinationScheme database.ParameterDestinationScheme `json:"destination_scheme" validate:"oneof=environment_variable provisioner_variable,required"`
-}
-
 // Project is the JSON representation of a Coder project.
 // This type matches the database object for now, but is
 // abstracted for ease of change later on.
@@ -42,48 +30,10 @@ type Project struct {
 	WorkspaceOwnerCount uint32                   `json:"workspace_owner_count"`
 }
 
-// CreateProjectRequest enables callers to create a new Project.
-type CreateProjectRequest struct {
-	Name string `json:"name" validate:"username,required"`
-
-	// VersionImportJobID is an in-progress or completed job to use as
-	// an initial version of the project.
-	//
-	// This is required on creation to enable a user-flow of validating
-	// the project works. There is no reason the data-model cannot support
-	// empty projects, but it doesn't make sense for users.
-	VersionImportJobID uuid.UUID `json:"import_job_id" validate:"required"`
-}
-
-// Lists all projects the authenticated user has access to.
-func (api *api) projects(rw http.ResponseWriter, r *http.Request) {
-	apiKey := httpmw.APIKey(r)
-	organizations, err := api.Database.GetOrganizationsByUserID(r.Context(), apiKey.UserID)
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get organizations: %s", err.Error()),
-		})
-		return
-	}
-	organizationIDs := make([]string, 0, len(organizations))
-	for _, organization := range organizations {
-		organizationIDs = append(organizationIDs, organization.ID)
-	}
-	projects, err := api.Database.GetProjectsByOrganizationIDs(r.Context(), organizationIDs)
-	if errors.Is(err, sql.ErrNoRows) {
-		err = nil
-	}
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get projects: %s", err.Error()),
-		})
-		return
-	}
-	projectIDs := make([]uuid.UUID, 0, len(projects))
-	for _, project := range projects {
-		projectIDs = append(projectIDs, project.ID)
-	}
-	workspaceCounts, err := api.Database.GetWorkspaceOwnerCountsByProjectIDs(r.Context(), projectIDs)
+// Returns a single project.
+func (api *api) project(rw http.ResponseWriter, r *http.Request) {
+	project := httpmw.ProjectParam(r)
+	workspaceCounts, err := api.Database.GetWorkspaceOwnerCountsByProjectIDs(r.Context(), []uuid.UUID{project.ID})
 	if errors.Is(err, sql.ErrNoRows) {
 		err = nil
 	}
@@ -93,184 +43,91 @@ func (api *api) projects(rw http.ResponseWriter, r *http.Request) {
 		})
 		return
 	}
+	count := uint32(0)
+	if len(workspaceCounts) > 0 {
+		count = uint32(workspaceCounts[0].Count)
+	}
+
 	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, convertProjects(projects, workspaceCounts))
+	render.JSON(rw, r, convertProject(project, count))
 }
 
-// Lists all projects in an organization.
-func (api *api) projectsByOrganization(rw http.ResponseWriter, r *http.Request) {
-	organization := httpmw.OrganizationParam(r)
-	projects, err := api.Database.GetProjectsByOrganizationIDs(r.Context(), []string{organization.ID})
+func (api *api) projectVersionsByProject(rw http.ResponseWriter, r *http.Request) {
+	project := httpmw.ProjectParam(r)
+
+	versions, err := api.Database.GetProjectVersionsByProjectID(r.Context(), project.ID)
 	if errors.Is(err, sql.ErrNoRows) {
 		err = nil
 	}
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get projects: %s", err.Error()),
+			Message: fmt.Sprintf("get project version: %s", err),
 		})
 		return
 	}
-	projectIDs := make([]uuid.UUID, 0, len(projects))
-	for _, project := range projects {
-		projectIDs = append(projectIDs, project.ID)
-	}
-	workspaceCounts, err := api.Database.GetWorkspaceOwnerCountsByProjectIDs(r.Context(), projectIDs)
-	if errors.Is(err, sql.ErrNoRows) {
-		err = nil
+	jobIDs := make([]uuid.UUID, 0, len(versions))
+	for _, version := range versions {
+		jobIDs = append(jobIDs, version.JobID)
 	}
+	jobs, err := api.Database.GetProvisionerJobsByIDs(r.Context(), jobIDs)
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get workspace counts: %s", err.Error()),
+			Message: fmt.Sprintf("get jobs: %s", err),
 		})
 		return
 	}
+	jobByID := map[string]database.ProvisionerJob{}
+	for _, job := range jobs {
+		jobByID[job.ID.String()] = job
+	}
+
+	apiVersion := make([]ProjectVersion, 0)
+	for _, version := range versions {
+		job, exists := jobByID[version.JobID.String()]
+		if !exists {
+			httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+				Message: fmt.Sprintf("job %q doesn't exist for version %q", version.JobID, version.ID),
+			})
+			return
+		}
+		apiVersion = append(apiVersion, convertProjectVersion(version, convertProvisionerJob(job)))
+	}
 	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, convertProjects(projects, workspaceCounts))
+	render.JSON(rw, r, apiVersion)
 }
 
-// Create a new project in an organization.
-func (api *api) postProjectsByOrganization(rw http.ResponseWriter, r *http.Request) {
-	var createProject CreateProjectRequest
-	if !httpapi.Read(rw, r, &createProject) {
-		return
-	}
-	organization := httpmw.OrganizationParam(r)
-	_, err := api.Database.GetProjectByOrganizationAndName(r.Context(), database.GetProjectByOrganizationAndNameParams{
-		OrganizationID: organization.ID,
-		Name:           createProject.Name,
+func (api *api) projectVersionByName(rw http.ResponseWriter, r *http.Request) {
+	project := httpmw.ProjectParam(r)
+	projectVersionName := chi.URLParam(r, "projectversionname")
+	projectVersion, err := api.Database.GetProjectVersionByProjectIDAndName(r.Context(), database.GetProjectVersionByProjectIDAndNameParams{
+		ProjectID: uuid.NullUUID{
+			UUID:  project.ID,
+			Valid: true,
+		},
+		Name: projectVersionName,
 	})
-	if err == nil {
-		httpapi.Write(rw, http.StatusConflict, httpapi.Response{
-			Message: fmt.Sprintf("project %q already exists", createProject.Name),
-			Errors: []httpapi.Error{{
-				Field: "name",
-				Code:  "exists",
-			}},
-		})
-		return
-	}
-	if !errors.Is(err, sql.ErrNoRows) {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get project by name: %s", err),
-		})
-		return
-	}
-	importJob, err := api.Database.GetProvisionerJobByID(r.Context(), createProject.VersionImportJobID)
 	if errors.Is(err, sql.ErrNoRows) {
 		httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
-			Message: "import job does not exist",
+			Message: fmt.Sprintf("no project version found by name %q", projectVersionName),
 		})
+		return
 	}
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get import job by id: %s", err),
+			Message: fmt.Sprintf("get project version by name: %s", err),
 		})
 		return
 	}
-
-	var project Project
-	err = api.Database.InTx(func(db database.Store) error {
-		projectVersionID := uuid.New()
-		dbProject, err := db.InsertProject(r.Context(), database.InsertProjectParams{
-			ID:              uuid.New(),
-			CreatedAt:       database.Now(),
-			UpdatedAt:       database.Now(),
-			OrganizationID:  organization.ID,
-			Name:            createProject.Name,
-			Provisioner:     importJob.Provisioner,
-			ActiveVersionID: projectVersionID,
-		})
-		if err != nil {
-			return xerrors.Errorf("insert project: %s", err)
-		}
-		_, err = db.InsertProjectVersion(r.Context(), database.InsertProjectVersionParams{
-			ID:          projectVersionID,
-			ProjectID:   dbProject.ID,
-			CreatedAt:   database.Now(),
-			UpdatedAt:   database.Now(),
-			Name:        namesgenerator.GetRandomName(1),
-			ImportJobID: importJob.ID,
-		})
-		if err != nil {
-			return xerrors.Errorf("insert project version: %s", err)
-		}
-		project = convertProject(dbProject, 0)
-		return nil
-	})
+	job, err := api.Database.GetProvisionerJobByID(r.Context(), projectVersion.JobID)
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: err.Error(),
+			Message: fmt.Sprintf("get provisioner job: %s", err),
 		})
 		return
 	}
 
-	render.Status(r, http.StatusCreated)
-	render.JSON(rw, r, project)
-}
-
-// Returns a single project.
-func (*api) projectByOrganization(rw http.ResponseWriter, r *http.Request) {
-	project := httpmw.ProjectParam(r)
-
-	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, project)
-}
-
-// Creates parameters for a project.
-// This should validate the calling user has permissions!
-func (api *api) postParametersByProject(rw http.ResponseWriter, r *http.Request) {
-	project := httpmw.ProjectParam(r)
-	var createRequest CreateParameterValueRequest
-	if !httpapi.Read(rw, r, &createRequest) {
-		return
-	}
-	parameterValue, err := api.Database.InsertParameterValue(r.Context(), database.InsertParameterValueParams{
-		ID:                uuid.New(),
-		Name:              createRequest.Name,
-		CreatedAt:         database.Now(),
-		UpdatedAt:         database.Now(),
-		Scope:             database.ParameterScopeProject,
-		ScopeID:           project.ID.String(),
-		SourceScheme:      createRequest.SourceScheme,
-		SourceValue:       createRequest.SourceValue,
-		DestinationScheme: createRequest.DestinationScheme,
-	})
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("insert parameter value: %s", err),
-		})
-		return
-	}
-
-	render.Status(r, http.StatusCreated)
-	render.JSON(rw, r, parameterValue)
-}
-
-// Lists parameters for a project.
-func (api *api) parametersByProject(rw http.ResponseWriter, r *http.Request) {
-	project := httpmw.ProjectParam(r)
-	parameterValues, err := api.Database.GetParameterValuesByScope(r.Context(), database.GetParameterValuesByScopeParams{
-		Scope:   database.ParameterScopeProject,
-		ScopeID: project.ID.String(),
-	})
-	if errors.Is(err, sql.ErrNoRows) {
-		err = nil
-		parameterValues = []database.ParameterValue{}
-	}
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get parameter values: %s", err),
-		})
-		return
-	}
-
-	apiParameterValues := make([]ParameterValue, 0, len(parameterValues))
-	for _, parameterValue := range parameterValues {
-		apiParameterValues = append(apiParameterValues, convertParameterValue(parameterValue))
-	}
-
 	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, apiParameterValues)
+	render.JSON(rw, r, convertProjectVersion(projectVersion, convertProvisionerJob(job)))
 }
 
 func convertProjects(projects []database.Project, workspaceCounts []database.GetWorkspaceOwnerCountsByProjectIDsRow) []Project {
@@ -304,8 +161,3 @@ func convertProject(project database.Project, workspaceOwnerCount uint32) Projec
 		WorkspaceOwnerCount: workspaceOwnerCount,
 	}
 }
-
-func convertParameterValue(parameterValue database.ParameterValue) ParameterValue {
-	parameterValue.SourceValue = ""
-	return ParameterValue(parameterValue)
-}

coderd/projects_test.go

@@ -7,163 +7,59 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"github.com/coder/coder/coderd"
 	"github.com/coder/coder/coderd/coderdtest"
 	"github.com/coder/coder/codersdk"
-	"github.com/coder/coder/database"
 )
 
-func TestProjects(t *testing.T) {
+func TestProject(t *testing.T) {
 	t.Parallel()
 
-	t.Run("ListEmpty", func(t *testing.T) {
+	t.Run("Get", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		_ = coderdtest.CreateInitialUser(t, client)
-		projects, err := client.Projects(context.Background(), "")
+		user := coderdtest.CreateFirstUser(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		_, err := client.Project(context.Background(), project.ID)
 		require.NoError(t, err)
-		require.NotNil(t, projects)
-		require.Len(t, projects, 0)
-	})
-
-	t.Run("List", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		_ = coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		projects, err := client.Projects(context.Background(), "")
-		require.NoError(t, err)
-		require.Len(t, projects, 1)
-	})
-
-	t.Run("ListWorkspaceOwnerCount", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		_ = coderdtest.CreateWorkspace(t, client, "", project.ID)
-		_ = coderdtest.CreateWorkspace(t, client, "", project.ID)
-		projects, err := client.Projects(context.Background(), "")
-		require.NoError(t, err)
-		require.Len(t, projects, 1)
-		require.Equal(t, projects[0].WorkspaceOwnerCount, uint32(1))
 	})
 }
 
-func TestProjectsByOrganization(t *testing.T) {
-	t.Parallel()
-	t.Run("ListEmpty", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		projects, err := client.Projects(context.Background(), user.Organization)
-		require.NoError(t, err)
-		require.NotNil(t, projects)
-		require.Len(t, projects, 0)
-	})
-
-	t.Run("List", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		_ = coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		projects, err := client.Projects(context.Background(), "")
-		require.NoError(t, err)
-		require.Len(t, projects, 1)
-	})
-}
-
-func TestPostProjectsByOrganization(t *testing.T) {
-	t.Parallel()
-	t.Run("Create", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		_ = coderdtest.CreateProject(t, client, user.Organization, job.ID)
-	})
-
-	t.Run("AlreadyExists", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		_, err := client.CreateProject(context.Background(), user.Organization, coderd.CreateProjectRequest{
-			Name:               project.Name,
-			VersionImportJobID: job.ID,
-		})
-		var apiErr *codersdk.Error
-		require.ErrorAs(t, err, &apiErr)
-		require.Equal(t, http.StatusConflict, apiErr.StatusCode())
-	})
-}
-
-func TestProjectByOrganization(t *testing.T) {
+func TestProjectVersionsByProject(t *testing.T) {
 	t.Parallel()
 	t.Run("Get", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		_, err := client.Project(context.Background(), user.Organization, project.Name)
+		user := coderdtest.CreateFirstUser(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		versions, err := client.ProjectVersionsByProject(context.Background(), project.ID)
 		require.NoError(t, err)
+		require.Len(t, versions, 1)
 	})
 }
 
-func TestPostParametersByProject(t *testing.T) {
+func TestProjectVersionByName(t *testing.T) {
 	t.Parallel()
-	t.Run("Create", func(t *testing.T) {
+	t.Run("NotFound", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		_, err := client.CreateProjectParameter(context.Background(), user.Organization, project.Name, coderd.CreateParameterValueRequest{
-			Name:              "somename",
-			SourceValue:       "tomato",
-			SourceScheme:      database.ParameterSourceSchemeData,
-			DestinationScheme: database.ParameterDestinationSchemeEnvironmentVariable,
-		})
+		user := coderdtest.CreateFirstUser(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		_, err := client.ProjectVersionByName(context.Background(), project.ID, "nothing")
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusNotFound, apiErr.StatusCode())
+	})
+
+	t.Run("Found", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		_, err := client.ProjectVersionByName(context.Background(), project.ID, version.Name)
 		require.NoError(t, err)
 	})
 }
-
-func TestParametersByProject(t *testing.T) {
-	t.Parallel()
-	t.Run("ListEmpty", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		params, err := client.ProjectParameters(context.Background(), user.Organization, project.Name)
-		require.NoError(t, err)
-		require.NotNil(t, params)
-	})
-
-	t.Run("List", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		_, err := client.CreateProjectParameter(context.Background(), user.Organization, project.Name, coderd.CreateParameterValueRequest{
-			Name:              "example",
-			SourceValue:       "source-value",
-			SourceScheme:      database.ParameterSourceSchemeData,
-			DestinationScheme: database.ParameterDestinationSchemeEnvironmentVariable,
-		})
-		require.NoError(t, err)
-		params, err := client.ProjectParameters(context.Background(), user.Organization, project.Name)
-		require.NoError(t, err)
-		require.NotNil(t, params)
-		require.Len(t, params, 1)
-	})
-}

coderd/projectversion.go

@@ -1,113 +0,0 @@
-package coderd
-
-import (
-	"database/sql"
-	"errors"
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/go-chi/render"
-	"github.com/google/uuid"
-	"github.com/moby/moby/pkg/namesgenerator"
-
-	"github.com/coder/coder/database"
-	"github.com/coder/coder/httpapi"
-	"github.com/coder/coder/httpmw"
-)
-
-// ProjectVersion represents a single version of a project.
-type ProjectVersion struct {
-	ID          uuid.UUID `json:"id"`
-	ProjectID   uuid.UUID `json:"project_id"`
-	CreatedAt   time.Time `json:"created_at"`
-	UpdatedAt   time.Time `json:"updated_at"`
-	Name        string    `json:"name"`
-	ImportJobID uuid.UUID `json:"import_job_id"`
-}
-
-// CreateProjectVersionRequest enables callers to create a new Project Version.
-type CreateProjectVersionRequest struct {
-	ImportJobID uuid.UUID `json:"import_job_id" validate:"required"`
-}
-
-// Lists versions for a single project.
-func (api *api) projectVersionsByOrganization(rw http.ResponseWriter, r *http.Request) {
-	project := httpmw.ProjectParam(r)
-
-	version, err := api.Database.GetProjectVersionsByProjectID(r.Context(), project.ID)
-	if errors.Is(err, sql.ErrNoRows) {
-		err = nil
-	}
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get project version: %s", err),
-		})
-		return
-	}
-	apiVersion := make([]ProjectVersion, 0)
-	for _, version := range version {
-		apiVersion = append(apiVersion, convertProjectVersion(version))
-	}
-	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, apiVersion)
-}
-
-// Return a single project version by organization and name.
-func (*api) projectVersionByOrganizationAndName(rw http.ResponseWriter, r *http.Request) {
-	projectVersion := httpmw.ProjectVersionParam(r)
-	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, convertProjectVersion(projectVersion))
-}
-
-// Creates a new version of the project. An import job is queued to parse
-// the storage method provided. Once completed, the import job will specify
-// the version as latest.
-func (api *api) postProjectVersionByOrganization(rw http.ResponseWriter, r *http.Request) {
-	var createProjectVersion CreateProjectVersionRequest
-	if !httpapi.Read(rw, r, &createProjectVersion) {
-		return
-	}
-	job, err := api.Database.GetProvisionerJobByID(r.Context(), createProjectVersion.ImportJobID)
-	if errors.Is(err, sql.ErrNoRows) {
-		httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
-			Message: "job not found",
-		})
-		return
-	}
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get provisioner job: %s", err),
-		})
-		return
-	}
-	project := httpmw.ProjectParam(r)
-	projectVersion, err := api.Database.InsertProjectVersion(r.Context(), database.InsertProjectVersionParams{
-		ID:          uuid.New(),
-		ProjectID:   project.ID,
-		CreatedAt:   database.Now(),
-		UpdatedAt:   database.Now(),
-		Name:        namesgenerator.GetRandomName(1),
-		ImportJobID: job.ID,
-	})
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("insert project version: %s", err),
-		})
-		return
-	}
-
-	render.Status(r, http.StatusCreated)
-	render.JSON(rw, r, convertProjectVersion(projectVersion))
-}
-
-func convertProjectVersion(version database.ProjectVersion) ProjectVersion {
-	return ProjectVersion{
-		ID:          version.ID,
-		ProjectID:   version.ProjectID,
-		CreatedAt:   version.CreatedAt,
-		UpdatedAt:   version.UpdatedAt,
-		Name:        version.Name,
-		ImportJobID: version.ImportJobID,
-	}
-}

coderd/projectversion_test.go

@@ -1,54 +0,0 @@
-package coderd_test
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/coder/coder/coderd"
-	"github.com/coder/coder/coderd/coderdtest"
-)
-
-func TestProjectVersionsByOrganization(t *testing.T) {
-	t.Parallel()
-	t.Run("List", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		versions, err := client.ProjectVersions(context.Background(), user.Organization, project.Name)
-		require.NoError(t, err)
-		require.NotNil(t, versions)
-		require.Len(t, versions, 1)
-	})
-}
-
-func TestProjectVersionByOrganizationAndName(t *testing.T) {
-	t.Parallel()
-	t.Run("Get", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		_, err := client.ProjectVersion(context.Background(), user.Organization, project.Name, project.ActiveVersionID.String())
-		require.NoError(t, err)
-	})
-}
-
-func TestPostProjectVersionByOrganization(t *testing.T) {
-	t.Parallel()
-	t.Run("Create", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		_, err := client.CreateProjectVersion(context.Background(), user.Organization, project.Name, coderd.CreateProjectVersionRequest{
-			ImportJobID: job.ID,
-		})
-		require.NoError(t, err)
-	})
-}

coderd/projectversions.go

@@ -0,0 +1,150 @@
+package coderd
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/go-chi/render"
+	"github.com/google/uuid"
+
+	"github.com/coder/coder/coderd/parameter"
+	"github.com/coder/coder/database"
+	"github.com/coder/coder/httpapi"
+	"github.com/coder/coder/httpmw"
+)
+
+// ProjectVersion represents a single version of a project.
+type ProjectVersion struct {
+	ID        uuid.UUID      `json:"id"`
+	ProjectID *uuid.UUID     `json:"project_id,omitempty"`
+	CreatedAt time.Time      `json:"created_at"`
+	UpdatedAt time.Time      `json:"updated_at"`
+	Name      string         `json:"name"`
+	Job       ProvisionerJob `json:"job"`
+}
+
+// ProjectVersionParameterSchema represents a parameter parsed from project version source.
+type ProjectVersionParameterSchema database.ParameterSchema
+
+// ProjectVersionParameter represents a computed parameter value.
+type ProjectVersionParameter parameter.ComputedValue
+
+func (api *api) projectVersion(rw http.ResponseWriter, r *http.Request) {
+	projectVersion := httpmw.ProjectVersionParam(r)
+	job, err := api.Database.GetProvisionerJobByID(r.Context(), projectVersion.JobID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job: %s", err),
+		})
+		return
+	}
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, convertProjectVersion(projectVersion, convertProvisionerJob(job)))
+}
+
+func (api *api) projectVersionSchema(rw http.ResponseWriter, r *http.Request) {
+	projectVersion := httpmw.ProjectVersionParam(r)
+	job, err := api.Database.GetProvisionerJobByID(r.Context(), projectVersion.JobID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job: %s", err),
+		})
+		return
+	}
+	if !job.CompletedAt.Valid {
+		httpapi.Write(rw, http.StatusPreconditionFailed, httpapi.Response{
+			Message: "Project version job hasn't completed!",
+		})
+		return
+	}
+	schemas, err := api.Database.GetParameterSchemasByJobID(r.Context(), job.ID)
+	if errors.Is(err, sql.ErrNoRows) {
+		err = nil
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("list parameter schemas: %s", err),
+		})
+		return
+	}
+	if schemas == nil {
+		schemas = []database.ParameterSchema{}
+	}
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, schemas)
+}
+
+func (api *api) projectVersionParameters(rw http.ResponseWriter, r *http.Request) {
+	apiKey := httpmw.APIKey(r)
+	projectVersion := httpmw.ProjectVersionParam(r)
+	job, err := api.Database.GetProvisionerJobByID(r.Context(), projectVersion.JobID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job: %s", err),
+		})
+		return
+	}
+	if !job.CompletedAt.Valid {
+		httpapi.Write(rw, http.StatusPreconditionFailed, httpapi.Response{
+			Message: "Job hasn't completed!",
+		})
+		return
+	}
+	values, err := parameter.Compute(r.Context(), api.Database, parameter.ComputeScope{
+		ProjectImportJobID: job.ID,
+		OrganizationID:     job.OrganizationID,
+		UserID:             apiKey.UserID,
+	}, &parameter.ComputeOptions{
+		// We *never* want to send the client secret parameter values.
+		HideRedisplayValues: true,
+	})
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("compute values: %s", err),
+		})
+		return
+	}
+	if values == nil {
+		values = []parameter.ComputedValue{}
+	}
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, values)
+}
+
+func (api *api) projectVersionResources(rw http.ResponseWriter, r *http.Request) {
+	projectVersion := httpmw.ProjectVersionParam(r)
+	job, err := api.Database.GetProvisionerJobByID(r.Context(), projectVersion.JobID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job: %s", err),
+		})
+		return
+	}
+	api.provisionerJobResources(rw, r, job)
+}
+
+func (api *api) projectVersionLogs(rw http.ResponseWriter, r *http.Request) {
+	projectVersion := httpmw.ProjectVersionParam(r)
+	job, err := api.Database.GetProvisionerJobByID(r.Context(), projectVersion.JobID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job: %s", err),
+		})
+		return
+	}
+	api.provisionerJobLogs(rw, r, job)
+}
+
+func convertProjectVersion(version database.ProjectVersion, job ProvisionerJob) ProjectVersion {
+	return ProjectVersion{
+		ID:        version.ID,
+		ProjectID: &version.ProjectID.UUID,
+		CreatedAt: version.CreatedAt,
+		UpdatedAt: version.UpdatedAt,
+		Name:      version.Name,
+		Job:       job,
+	}
+}

coderd/projectversions_test.go

@@ -0,0 +1,205 @@
+package coderd_test
+
+import (
+	"context"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/require"
+
+	"github.com/coder/coder/coderd/coderdtest"
+	"github.com/coder/coder/codersdk"
+	"github.com/coder/coder/provisioner/echo"
+	"github.com/coder/coder/provisionersdk/proto"
+)
+
+func TestProjectVersion(t *testing.T) {
+	t.Parallel()
+	t.Run("Get", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		_, err := client.ProjectVersion(context.Background(), version.ID)
+		require.NoError(t, err)
+	})
+}
+
+func TestProjectVersionSchema(t *testing.T) {
+	t.Parallel()
+	t.Run("ListRunning", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		_, err := client.ProjectVersionSchema(context.Background(), version.ID)
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusPreconditionFailed, apiErr.StatusCode())
+	})
+	t.Run("List", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		coderdtest.NewProvisionerDaemon(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, &echo.Responses{
+			Parse: []*proto.Parse_Response{{
+				Type: &proto.Parse_Response_Complete{
+					Complete: &proto.Parse_Complete{
+						ParameterSchemas: []*proto.ParameterSchema{{
+							Name: "example",
+							DefaultDestination: &proto.ParameterDestination{
+								Scheme: proto.ParameterDestination_PROVISIONER_VARIABLE,
+							},
+						}},
+					},
+				},
+			}},
+			Provision: echo.ProvisionComplete,
+		})
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+		schemas, err := client.ProjectVersionSchema(context.Background(), version.ID)
+		require.NoError(t, err)
+		require.NotNil(t, schemas)
+		require.Len(t, schemas, 1)
+	})
+}
+
+func TestProjectVersionParameters(t *testing.T) {
+	t.Parallel()
+	t.Run("ListRunning", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		_, err := client.ProjectVersionParameters(context.Background(), version.ID)
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusPreconditionFailed, apiErr.StatusCode())
+	})
+	t.Run("List", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		coderdtest.NewProvisionerDaemon(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, &echo.Responses{
+			Parse: []*proto.Parse_Response{{
+				Type: &proto.Parse_Response_Complete{
+					Complete: &proto.Parse_Complete{
+						ParameterSchemas: []*proto.ParameterSchema{{
+							Name:           "example",
+							RedisplayValue: true,
+							DefaultSource: &proto.ParameterSource{
+								Scheme: proto.ParameterSource_DATA,
+								Value:  "hello",
+							},
+							DefaultDestination: &proto.ParameterDestination{
+								Scheme: proto.ParameterDestination_PROVISIONER_VARIABLE,
+							},
+						}},
+					},
+				},
+			}},
+			Provision: echo.ProvisionComplete,
+		})
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+		params, err := client.ProjectVersionParameters(context.Background(), version.ID)
+		require.NoError(t, err)
+		require.NotNil(t, params)
+		require.Len(t, params, 1)
+		require.Equal(t, "hello", params[0].SourceValue)
+	})
+}
+
+func TestProjectVersionResources(t *testing.T) {
+	t.Parallel()
+	t.Run("ListRunning", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		_, err := client.ProjectVersionResources(context.Background(), version.ID)
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusPreconditionFailed, apiErr.StatusCode())
+	})
+	t.Run("List", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		coderdtest.NewProvisionerDaemon(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, &echo.Responses{
+			Parse: echo.ParseComplete,
+			Provision: []*proto.Provision_Response{{
+				Type: &proto.Provision_Response_Complete{
+					Complete: &proto.Provision_Complete{
+						Resources: []*proto.Resource{{
+							Name: "some",
+							Type: "example",
+							Agent: &proto.Agent{
+								Id:   "something",
+								Auth: &proto.Agent_Token{},
+							},
+						}, {
+							Name: "another",
+							Type: "example",
+						}},
+					},
+				},
+			}},
+		})
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+		resources, err := client.ProjectVersionResources(context.Background(), version.ID)
+		require.NoError(t, err)
+		require.NotNil(t, resources)
+		require.Len(t, resources, 4)
+		require.Equal(t, "some", resources[0].Name)
+		require.Equal(t, "example", resources[0].Type)
+		require.NotNil(t, resources[0].Agent)
+	})
+}
+
+func TestProjectVersionLogs(t *testing.T) {
+	t.Parallel()
+	client := coderdtest.New(t, nil)
+	user := coderdtest.CreateFirstUser(t, client)
+	coderdtest.NewProvisionerDaemon(t, client)
+	before := time.Now()
+	version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, &echo.Responses{
+		Parse: echo.ParseComplete,
+		Provision: []*proto.Provision_Response{{
+			Type: &proto.Provision_Response_Log{
+				Log: &proto.Log{
+					Level:  proto.LogLevel_INFO,
+					Output: "example",
+				},
+			},
+		}, {
+			Type: &proto.Provision_Response_Complete{
+				Complete: &proto.Provision_Complete{
+					Resources: []*proto.Resource{{
+						Name: "some",
+						Type: "example",
+						Agent: &proto.Agent{
+							Id: "something",
+							Auth: &proto.Agent_Token{
+								Token: uuid.NewString(),
+							},
+						},
+					}, {
+						Name: "another",
+						Type: "example",
+					}},
+				},
+			},
+		}},
+	})
+	ctx, cancelFunc := context.WithCancel(context.Background())
+	t.Cleanup(cancelFunc)
+	logs, err := client.ProjectVersionLogsAfter(ctx, version.ID, before)
+	require.NoError(t, err)
+	log := <-logs
+	require.Equal(t, "example", log.Output)
+}

coderd/provisionerdaemons.go

@@ -12,7 +12,6 @@ import (
 	"reflect"
 	"time"
 
-	"github.com/go-chi/render"
 	"github.com/google/uuid"
 	"github.com/hashicorp/yamux"
 	"github.com/moby/moby/pkg/namesgenerator"
@@ -33,27 +32,8 @@ import (
 
 type ProvisionerDaemon database.ProvisionerDaemon
 
-// Lists all registered provisioner daemons.
-func (api *api) provisionerDaemons(rw http.ResponseWriter, r *http.Request) {
-	daemons, err := api.Database.GetProvisionerDaemons(r.Context())
-	if errors.Is(err, sql.ErrNoRows) {
-		err = nil
-	}
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get provisioner daemons: %s", err),
-		})
-		return
-	}
-	if daemons == nil {
-		daemons = []database.ProvisionerDaemon{}
-	}
-	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, daemons)
-}
-
 // Serves the provisioner daemon protobuf API over a WebSocket.
-func (api *api) provisionerDaemonsServe(rw http.ResponseWriter, r *http.Request) {
+func (api *api) provisionerDaemonsListen(rw http.ResponseWriter, r *http.Request) {
 	api.websocketWaitGroup.Add(1)
 	defer api.websocketWaitGroup.Done()
 
@@ -113,8 +93,8 @@ func (api *api) provisionerDaemonsServe(rw http.ResponseWriter, r *http.Request)
 
 // The input for a "workspace_provision" job.
 type workspaceProvisionJob struct {
-	WorkspaceHistoryID uuid.UUID `json:"workspace_history_id"`
-	DryRun             bool      `json:"dry_run"`
+	WorkspaceBuildID uuid.UUID `json:"workspace_build_id"`
+	DryRun           bool      `json:"dry_run"`
 }
 
 // Implementation of the provisioner daemon protobuf server.
@@ -182,32 +162,32 @@ func (server *provisionerdServer) AcquireJob(ctx context.Context, _ *proto.Empty
 		UserName:    user.Username,
 	}
 	switch job.Type {
-	case database.ProvisionerJobTypeWorkspaceProvision:
+	case database.ProvisionerJobTypeWorkspaceBuild:
 		var input workspaceProvisionJob
 		err = json.Unmarshal(job.Input, &input)
 		if err != nil {
 			return nil, failJob(fmt.Sprintf("unmarshal job input %q: %s", job.Input, err))
 		}
-		workspaceHistory, err := server.Database.GetWorkspaceHistoryByID(ctx, input.WorkspaceHistoryID)
+		workspaceBuild, err := server.Database.GetWorkspaceBuildByID(ctx, input.WorkspaceBuildID)
 		if err != nil {
-			return nil, failJob(fmt.Sprintf("get workspace history: %s", err))
+			return nil, failJob(fmt.Sprintf("get workspace build: %s", err))
 		}
-		workspace, err := server.Database.GetWorkspaceByID(ctx, workspaceHistory.WorkspaceID)
+		workspace, err := server.Database.GetWorkspaceByID(ctx, workspaceBuild.WorkspaceID)
 		if err != nil {
 			return nil, failJob(fmt.Sprintf("get workspace: %s", err))
 		}
-		projectVersion, err := server.Database.GetProjectVersionByID(ctx, workspaceHistory.ProjectVersionID)
+		projectVersion, err := server.Database.GetProjectVersionByID(ctx, workspaceBuild.ProjectVersionID)
 		if err != nil {
 			return nil, failJob(fmt.Sprintf("get project version: %s", err))
 		}
-		project, err := server.Database.GetProjectByID(ctx, projectVersion.ProjectID)
+		project, err := server.Database.GetProjectByID(ctx, projectVersion.ProjectID.UUID)
 		if err != nil {
 			return nil, failJob(fmt.Sprintf("get project: %s", err))
 		}
 
 		// Compute parameters for the workspace to consume.
 		parameters, err := parameter.Compute(ctx, server.Database, parameter.ComputeScope{
-			ProjectImportJobID: projectVersion.ImportJobID,
+			ProjectImportJobID: projectVersion.JobID,
 			OrganizationID:     job.OrganizationID,
 			ProjectID: uuid.NullUUID{
 				UUID:  project.ID,
@@ -231,17 +211,17 @@ func (server *provisionerdServer) AcquireJob(ctx context.Context, _ *proto.Empty
 			}
 			protoParameters = append(protoParameters, converted)
 		}
-		transition, err := convertWorkspaceTransition(workspaceHistory.Transition)
+		transition, err := convertWorkspaceTransition(workspaceBuild.Transition)
 		if err != nil {
 			return nil, failJob(fmt.Sprint("convert workspace transition: %w", err))
 		}
 
-		protoJob.Type = &proto.AcquiredJob_WorkspaceProvision_{
-			WorkspaceProvision: &proto.AcquiredJob_WorkspaceProvision{
-				WorkspaceHistoryId: workspaceHistory.ID.String(),
-				WorkspaceName:      workspace.Name,
-				State:              workspaceHistory.ProvisionerState,
-				ParameterValues:    protoParameters,
+		protoJob.Type = &proto.AcquiredJob_WorkspaceBuild_{
+			WorkspaceBuild: &proto.AcquiredJob_WorkspaceBuild{
+				WorkspaceBuildId: workspaceBuild.ID.String(),
+				WorkspaceName:    workspace.Name,
+				State:            workspaceBuild.ProvisionerState,
+				ParameterValues:  protoParameters,
 				Metadata: &sdkproto.Provision_Metadata{
 					CoderUrl:            server.AccessURL.String(),
 					WorkspaceTransition: transition,
@@ -432,8 +412,8 @@ func (server *provisionerdServer) FailJob(ctx context.Context, failJob *proto.Fa
 		return nil, xerrors.Errorf("update provisioner job: %w", err)
 	}
 	switch jobType := failJob.Type.(type) {
-	case *proto.FailedJob_WorkspaceProvision_:
-		if jobType.WorkspaceProvision.State == nil {
+	case *proto.FailedJob_WorkspaceBuild_:
+		if jobType.WorkspaceBuild.State == nil {
 			break
 		}
 		var input workspaceProvisionJob
@@ -441,13 +421,13 @@ func (server *provisionerdServer) FailJob(ctx context.Context, failJob *proto.Fa
 		if err != nil {
 			return nil, xerrors.Errorf("unmarshal workspace provision input: %w", err)
 		}
-		err = server.Database.UpdateWorkspaceHistoryByID(ctx, database.UpdateWorkspaceHistoryByIDParams{
+		err = server.Database.UpdateWorkspaceBuildByID(ctx, database.UpdateWorkspaceBuildByIDParams{
 			ID:               jobID,
 			UpdatedAt:        database.Now(),
-			ProvisionerState: jobType.WorkspaceProvision.State,
+			ProvisionerState: jobType.WorkspaceBuild.State,
 		})
 		if err != nil {
-			return nil, xerrors.Errorf("update workspace history state: %w", err)
+			return nil, xerrors.Errorf("update workspace build state: %w", err)
 		}
 	case *proto.FailedJob_ProjectImport_:
 	}
@@ -481,7 +461,7 @@ func (server *provisionerdServer) CompleteJob(ctx context.Context, completed *pr
 					slog.F("resource_type", resource.Type),
 					slog.F("transition", transition))
 
-				err = insertProvisionerJobResource(ctx, server.Database, jobID, transition, resource)
+				err = insertWorkspaceResource(ctx, server.Database, jobID, transition, resource)
 				if err != nil {
 					return nil, xerrors.Errorf("insert resource: %w", err)
 				}
@@ -503,16 +483,16 @@ func (server *provisionerdServer) CompleteJob(ctx context.Context, completed *pr
 		if err != nil {
 			return nil, xerrors.Errorf("complete job: %w", err)
 		}
-	case *proto.CompletedJob_WorkspaceProvision_:
+	case *proto.CompletedJob_WorkspaceBuild_:
 		var input workspaceProvisionJob
 		err = json.Unmarshal(job.Input, &input)
 		if err != nil {
 			return nil, xerrors.Errorf("unmarshal job data: %w", err)
 		}
 
-		workspaceHistory, err := server.Database.GetWorkspaceHistoryByID(ctx, input.WorkspaceHistoryID)
+		workspaceBuild, err := server.Database.GetWorkspaceBuildByID(ctx, input.WorkspaceBuildID)
 		if err != nil {
-			return nil, xerrors.Errorf("get workspace history: %w", err)
+			return nil, xerrors.Errorf("get workspace build: %w", err)
 		}
 
 		err = server.Database.InTx(func(db database.Store) error {
@@ -527,17 +507,17 @@ func (server *provisionerdServer) CompleteJob(ctx context.Context, completed *pr
 			if err != nil {
 				return xerrors.Errorf("update provisioner job: %w", err)
 			}
-			err = db.UpdateWorkspaceHistoryByID(ctx, database.UpdateWorkspaceHistoryByIDParams{
-				ID:               workspaceHistory.ID,
+			err = db.UpdateWorkspaceBuildByID(ctx, database.UpdateWorkspaceBuildByIDParams{
+				ID:               workspaceBuild.ID,
 				UpdatedAt:        database.Now(),
-				ProvisionerState: jobType.WorkspaceProvision.State,
+				ProvisionerState: jobType.WorkspaceBuild.State,
 			})
 			if err != nil {
-				return xerrors.Errorf("update workspace history: %w", err)
+				return xerrors.Errorf("update workspace build: %w", err)
 			}
 			// This could be a bulk insert to improve performance.
-			for _, protoResource := range jobType.WorkspaceProvision.Resources {
-				err = insertProvisionerJobResource(ctx, db, job.ID, workspaceHistory.Transition, protoResource)
+			for _, protoResource := range jobType.WorkspaceBuild.Resources {
+				err = insertWorkspaceResource(ctx, db, job.ID, workspaceBuild.Transition, protoResource)
 				if err != nil {
 					return xerrors.Errorf("insert provisioner job: %w", err)
 				}
@@ -555,8 +535,8 @@ func (server *provisionerdServer) CompleteJob(ctx context.Context, completed *pr
 	return &proto.Empty{}, nil
 }
 
-func insertProvisionerJobResource(ctx context.Context, db database.Store, jobID uuid.UUID, transition database.WorkspaceTransition, protoResource *sdkproto.Resource) error {
-	resource, err := db.InsertProvisionerJobResource(ctx, database.InsertProvisionerJobResourceParams{
+func insertWorkspaceResource(ctx context.Context, db database.Store, jobID uuid.UUID, transition database.WorkspaceTransition, protoResource *sdkproto.Resource) error {
+	resource, err := db.InsertWorkspaceResource(ctx, database.InsertWorkspaceResourceParams{
 		ID:         uuid.New(),
 		CreatedAt:  database.Now(),
 		JobID:      jobID,
@@ -590,12 +570,19 @@ func insertProvisionerJobResource(ctx context.Context, db database.Store, jobID
 				Valid:      true,
 			}
 		}
+		authToken := uuid.New()
+		if protoResource.Agent.GetToken() != "" {
+			authToken, err = uuid.Parse(protoResource.Agent.GetToken())
+			if err != nil {
+				return xerrors.Errorf("invalid auth token format; must be uuid: %w", err)
+			}
+		}
 
-		_, err := db.InsertProvisionerJobAgent(ctx, database.InsertProvisionerJobAgentParams{
+		_, err := db.InsertWorkspaceAgent(ctx, database.InsertWorkspaceAgentParams{
 			ID:                   resource.AgentID.UUID,
 			CreatedAt:            database.Now(),
 			ResourceID:           resource.ID,
-			AuthToken:            uuid.New(),
+			AuthToken:            authToken,
 			AuthInstanceID:       instanceID,
 			EnvironmentVariables: env,
 			StartupScript: sql.NullString{

coderd/provisionerdaemons_test.go

@@ -1,25 +0,0 @@
-package coderd_test
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/coder/coder/coderd/coderdtest"
-)
-
-func TestProvisionerDaemons(t *testing.T) {
-	// Tests for properly processing specific job types should be placed
-	// in their respective files.
-	t.Parallel()
-
-	client := coderdtest.New(t, nil)
-	_ = coderdtest.NewProvisionerDaemon(t, client)
-	require.Eventually(t, func() bool {
-		daemons, err := client.ProvisionerDaemons(context.Background())
-		require.NoError(t, err)
-		return len(daemons) > 0
-	}, 3*time.Second, 50*time.Millisecond)
-}

coderd/provisionerjobs.go

@@ -17,38 +17,29 @@ import (
 
 	"github.com/coder/coder/database"
 	"github.com/coder/coder/httpapi"
-	"github.com/coder/coder/httpmw"
 )
 
+// ProvisionerJobStaus represents the at-time state of a job.
 type ProvisionerJobStatus string
 
-// Completed returns whether the job is still processing.
-func (p ProvisionerJobStatus) Completed() bool {
-	return p == ProvisionerJobStatusSucceeded || p == ProvisionerJobStatusFailed || p == ProvisionerJobStatusCancelled
-}
-
 const (
-	ProvisionerJobStatusPending   ProvisionerJobStatus = "pending"
-	ProvisionerJobStatusRunning   ProvisionerJobStatus = "running"
-	ProvisionerJobStatusSucceeded ProvisionerJobStatus = "succeeded"
-	ProvisionerJobStatusCancelled ProvisionerJobStatus = "canceled"
-	ProvisionerJobStatusFailed    ProvisionerJobStatus = "failed"
+	ProvisionerJobPending   ProvisionerJobStatus = "pending"
+	ProvisionerJobRunning   ProvisionerJobStatus = "running"
+	ProvisionerJobSucceeded ProvisionerJobStatus = "succeeded"
+	ProvisionerJobCancelled ProvisionerJobStatus = "canceled"
+	ProvisionerJobFailed    ProvisionerJobStatus = "failed"
 )
 
 type ProvisionerJob struct {
-	ID          uuid.UUID                `json:"id"`
-	CreatedAt   time.Time                `json:"created_at"`
-	UpdatedAt   time.Time                `json:"updated_at"`
-	StartedAt   *time.Time               `json:"started_at,omitempty"`
-	CancelledAt *time.Time               `json:"canceled_at,omitempty"`
-	CompletedAt *time.Time               `json:"completed_at,omitempty"`
-	Status      ProvisionerJobStatus     `json:"status"`
-	Error       string                   `json:"error,omitempty"`
-	Provisioner database.ProvisionerType `json:"provisioner"`
-	WorkerID    *uuid.UUID               `json:"worker_id,omitempty"`
+	ID          uuid.UUID            `json:"id"`
+	CreatedAt   time.Time            `json:"created_at"`
+	StartedAt   *time.Time           `json:"started_at,omitempty"`
+	CompletedAt *time.Time           `json:"completed_at,omitempty"`
+	Error       string               `json:"error,omitempty"`
+	Status      ProvisionerJobStatus `json:"status"`
+	WorkerID    *uuid.UUID           `json:"worker_id,omitempty"`
 }
 
-// ProvisionerJobLog represents a single log from a provisioner job.
 type ProvisionerJobLog struct {
 	ID        uuid.UUID          `json:"id"`
 	CreatedAt time.Time          `json:"created_at"`
@@ -57,31 +48,6 @@ type ProvisionerJobLog struct {
 	Output    string             `json:"output"`
 }
 
-type ProvisionerJobResource struct {
-	ID         uuid.UUID                    `json:"id"`
-	CreatedAt  time.Time                    `json:"created_at"`
-	JobID      uuid.UUID                    `json:"job_id"`
-	Transition database.WorkspaceTransition `json:"workspace_transition"`
-	Type       string                       `json:"type"`
-	Name       string                       `json:"name"`
-}
-
-type ProvisionerJobAgent struct {
-	ID                   uuid.UUID         `json:"id"`
-	CreatedAt            time.Time         `json:"created_at"`
-	UpdatedAt            time.Time         `json:"updated_at"`
-	ResourceID           uuid.UUID         `json:"resource_id"`
-	InstanceID           string            `json:"instance_id,omitempty"`
-	EnvironmentVariables map[string]string `json:"environment_variables"`
-	StartupScript        string            `json:"startup_script,omitempty"`
-}
-
-func (*api) provisionerJobByID(rw http.ResponseWriter, r *http.Request) {
-	job := httpmw.ProvisionerJobParam(r)
-	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, convertProvisionerJob(job))
-}
-
 // Returns provisioner logs based on query parameters.
 // The intended usage for a client to stream all logs (with JS API):
 // const timestamp = new Date().getTime();
@@ -89,7 +55,7 @@ func (*api) provisionerJobByID(rw http.ResponseWriter, r *http.Request) {
 // 2. GET /logs?after=<timestamp>&follow
 // The combination of these responses should provide all current logs
 // to the consumer, and future logs are streamed in the follow request.
-func (api *api) provisionerJobLogsByID(rw http.ResponseWriter, r *http.Request) {
+func (api *api) provisionerJobLogs(rw http.ResponseWriter, r *http.Request, job database.ProvisionerJob) {
 	follow := r.URL.Query().Has("follow")
 	afterRaw := r.URL.Query().Get("after")
 	beforeRaw := r.URL.Query().Get("before")
@@ -131,7 +97,6 @@ func (api *api) provisionerJobLogsByID(rw http.ResponseWriter, r *http.Request)
 		before = database.Now()
 	}
 
-	job := httpmw.ProvisionerJobParam(r)
 	if !follow {
 		logs, err := api.Database.GetProvisionerLogsByIDBetween(r.Context(), database.GetProvisionerLogsByIDBetweenParams{
 			JobID:         job.ID,
@@ -231,13 +196,56 @@ func (api *api) provisionerJobLogsByID(rw http.ResponseWriter, r *http.Request)
 				api.Logger.Warn(r.Context(), "streaming job logs; checking if completed", slog.Error(err), slog.F("job_id", job.ID.String()))
 				continue
 			}
-			if convertProvisionerJob(job).Status.Completed() {
+			if job.CompletedAt.Valid {
 				return
 			}
 		}
 	}
 }
 
+func (api *api) provisionerJobResources(rw http.ResponseWriter, r *http.Request, job database.ProvisionerJob) {
+	if !job.CompletedAt.Valid {
+		httpapi.Write(rw, http.StatusPreconditionFailed, httpapi.Response{
+			Message: "Job hasn't completed!",
+		})
+		return
+	}
+	resources, err := api.Database.GetWorkspaceResourcesByJobID(r.Context(), job.ID)
+	if errors.Is(err, sql.ErrNoRows) {
+		err = nil
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job resources: %s", err),
+		})
+		return
+	}
+	apiResources := make([]WorkspaceResource, 0)
+	for _, resource := range resources {
+		if !resource.AgentID.Valid {
+			apiResources = append(apiResources, convertWorkspaceResource(resource, nil))
+			continue
+		}
+		agent, err := api.Database.GetWorkspaceAgentByResourceID(r.Context(), resource.ID)
+		if err != nil {
+			httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+				Message: fmt.Sprintf("get provisioner job agent: %s", err),
+			})
+			return
+		}
+		apiAgent, err := convertWorkspaceAgent(agent)
+		if err != nil {
+			httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+				Message: fmt.Sprintf("convert provisioner job agent: %s", err),
+			})
+			return
+		}
+		apiResources = append(apiResources, convertWorkspaceResource(resource, &apiAgent))
+	}
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, apiResources)
+}
+
 func convertProvisionerJobLog(provisionerJobLog database.ProvisionerJobLog) ProvisionerJobLog {
 	return ProvisionerJobLog{
 		ID:        provisionerJobLog.ID,
@@ -250,19 +258,14 @@ func convertProvisionerJobLog(provisionerJobLog database.ProvisionerJobLog) Prov
 
 func convertProvisionerJob(provisionerJob database.ProvisionerJob) ProvisionerJob {
 	job := ProvisionerJob{
-		ID:          provisionerJob.ID,
-		CreatedAt:   provisionerJob.CreatedAt,
-		UpdatedAt:   provisionerJob.UpdatedAt,
-		Error:       provisionerJob.Error.String,
-		Provisioner: provisionerJob.Provisioner,
+		ID:        provisionerJob.ID,
+		CreatedAt: provisionerJob.CreatedAt,
+		Error:     provisionerJob.Error.String,
 	}
 	// Applying values optional to the struct.
 	if provisionerJob.StartedAt.Valid {
 		job.StartedAt = &provisionerJob.StartedAt.Time
 	}
-	if provisionerJob.CancelledAt.Valid {
-		job.CancelledAt = &provisionerJob.CancelledAt.Time
-	}
 	if provisionerJob.CompletedAt.Valid {
 		job.CompletedAt = &provisionerJob.CompletedAt.Time
 	}
@@ -272,20 +275,20 @@ func convertProvisionerJob(provisionerJob database.ProvisionerJob) ProvisionerJo
 
 	switch {
 	case provisionerJob.CancelledAt.Valid:
-		job.Status = ProvisionerJobStatusCancelled
+		job.Status = ProvisionerJobCancelled
 	case !provisionerJob.StartedAt.Valid:
-		job.Status = ProvisionerJobStatusPending
+		job.Status = ProvisionerJobPending
 	case provisionerJob.CompletedAt.Valid:
 		if job.Error == "" {
-			job.Status = ProvisionerJobStatusSucceeded
+			job.Status = ProvisionerJobSucceeded
 		} else {
-			job.Status = ProvisionerJobStatusFailed
+			job.Status = ProvisionerJobFailed
 		}
 	case database.Now().Sub(provisionerJob.UpdatedAt) > 30*time.Second:
-		job.Status = ProvisionerJobStatusFailed
+		job.Status = ProvisionerJobFailed
 		job.Error = "Worker failed to update job in time."
 	default:
-		job.Status = ProvisionerJobStatusRunning
+		job.Status = ProvisionerJobRunning
 	}
 
 	return job

coderd/provisionerjobs_test.go

@@ -2,7 +2,6 @@ package coderd_test
 
 import (
 	"context"
-	"net/http"
 	"testing"
 	"time"
 
@@ -10,239 +9,19 @@ import (
 
 	"github.com/coder/coder/coderd"
 	"github.com/coder/coder/coderd/coderdtest"
-	"github.com/coder/coder/codersdk"
 	"github.com/coder/coder/database"
 	"github.com/coder/coder/provisioner/echo"
 	"github.com/coder/coder/provisionersdk/proto"
 )
 
-func TestPostProvisionerImportJobByOrganization(t *testing.T) {
+func TestProvisionerJobLogs(t *testing.T) {
 	t.Parallel()
-	t.Run("Create", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		_ = coderdtest.NewProvisionerDaemon(t, client)
-		before := time.Now()
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, &echo.Responses{
-			Parse: []*proto.Parse_Response{{
-				Type: &proto.Parse_Response_Complete{
-					Complete: &proto.Parse_Complete{
-						ParameterSchemas: []*proto.ParameterSchema{},
-					},
-				},
-			}},
-			Provision: []*proto.Provision_Response{{
-				Type: &proto.Provision_Response_Complete{
-					Complete: &proto.Provision_Complete{
-						Resources: []*proto.Resource{{
-							Name: "dev",
-							Type: "ec2_instance",
-						}},
-					},
-				},
-			}},
-		})
-		logs, err := client.ProjectImportJobLogsAfter(context.Background(), user.Organization, job.ID, before)
-		require.NoError(t, err)
-		for {
-			log, ok := <-logs
-			if !ok {
-				break
-			}
-			t.Log(log.Output)
-		}
-	})
-
-	t.Run("CreateWithParameters", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		_ = coderdtest.NewProvisionerDaemon(t, client)
-		data, err := echo.Tar(&echo.Responses{
-			Parse: []*proto.Parse_Response{{
-				Type: &proto.Parse_Response_Complete{
-					Complete: &proto.Parse_Complete{
-						ParameterSchemas: []*proto.ParameterSchema{{
-							Name:           "test",
-							RedisplayValue: true,
-						}},
-					},
-				},
-			}},
-			Provision: echo.ProvisionComplete,
-		})
-		require.NoError(t, err)
-		file, err := client.UploadFile(context.Background(), codersdk.ContentTypeTar, data)
-		require.NoError(t, err)
-		job, err := client.CreateProjectImportJob(context.Background(), user.Organization, coderd.CreateProjectImportJobRequest{
-			StorageSource: file.Hash,
-			StorageMethod: database.ProvisionerStorageMethodFile,
-			Provisioner:   database.ProvisionerTypeEcho,
-			ParameterValues: []coderd.CreateParameterValueRequest{{
-				Name:              "test",
-				SourceValue:       "somevalue",
-				SourceScheme:      database.ParameterSourceSchemeData,
-				DestinationScheme: database.ParameterDestinationSchemeProvisionerVariable,
-			}},
-		})
-		require.NoError(t, err)
-		job = coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-		values, err := client.ProjectImportJobParameters(context.Background(), user.Organization, job.ID)
-		require.NoError(t, err)
-		require.Equal(t, "somevalue", values[0].SourceValue)
-	})
-}
-
-func TestProvisionerJobParametersByID(t *testing.T) {
-	t.Parallel()
-	t.Run("NotImported", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		_, err := client.ProjectImportJobParameters(context.Background(), user.Organization, job.ID)
-		var apiErr *codersdk.Error
-		require.ErrorAs(t, err, &apiErr)
-		require.Equal(t, http.StatusPreconditionFailed, apiErr.StatusCode())
-	})
-
-	t.Run("List", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		_ = coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, &echo.Responses{
-			Parse: []*proto.Parse_Response{{
-				Type: &proto.Parse_Response_Complete{
-					Complete: &proto.Parse_Complete{
-						ParameterSchemas: []*proto.ParameterSchema{{
-							Name: "example",
-							DefaultSource: &proto.ParameterSource{
-								Scheme: proto.ParameterSource_DATA,
-								Value:  "hello",
-							},
-							DefaultDestination: &proto.ParameterDestination{
-								Scheme: proto.ParameterDestination_PROVISIONER_VARIABLE,
-							},
-						}},
-					},
-				},
-			}},
-			Provision: echo.ProvisionComplete,
-		})
-		job = coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-		params, err := client.ProjectImportJobParameters(context.Background(), user.Organization, job.ID)
-		require.NoError(t, err)
-		require.Len(t, params, 1)
-	})
-
-	t.Run("ListNoRedisplay", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		_ = coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, &echo.Responses{
-			Parse: []*proto.Parse_Response{{
-				Type: &proto.Parse_Response_Complete{
-					Complete: &proto.Parse_Complete{
-						ParameterSchemas: []*proto.ParameterSchema{{
-							Name: "example",
-							DefaultSource: &proto.ParameterSource{
-								Scheme: proto.ParameterSource_DATA,
-								Value:  "tomato",
-							},
-							DefaultDestination: &proto.ParameterDestination{
-								Scheme: proto.ParameterDestination_PROVISIONER_VARIABLE,
-							},
-							RedisplayValue: false,
-						}},
-					},
-				},
-			}},
-			Provision: echo.ProvisionComplete,
-		})
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-		params, err := client.ProjectImportJobParameters(context.Background(), user.Organization, job.ID)
-		require.NoError(t, err)
-		require.Len(t, params, 1)
-		require.NotNil(t, params[0])
-		require.Equal(t, params[0].SourceValue, "")
-	})
-}
-
-func TestProvisionerJobResourcesByID(t *testing.T) {
-	t.Parallel()
-	t.Run("List", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		_ = coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, &echo.Responses{
-			Parse: echo.ParseComplete,
-			Provision: []*proto.Provision_Response{{
-				Type: &proto.Provision_Response_Complete{
-					Complete: &proto.Provision_Complete{
-						Resources: []*proto.Resource{{
-							Name: "hello",
-							Type: "ec2_instance",
-						}},
-					},
-				},
-			}},
-		})
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-		resources, err := client.ProjectImportJobResources(context.Background(), user.Organization, job.ID)
-		require.NoError(t, err)
-		// One for start, and one for stop!
-		require.Len(t, resources, 2)
-	})
-}
-
-func TestProvisionerJobLogsByName(t *testing.T) {
-	t.Parallel()
-	t.Run("List", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, &echo.Responses{
-			Parse: echo.ParseComplete,
-			Provision: []*proto.Provision_Response{{
-				Type: &proto.Provision_Response_Log{
-					Log: &proto.Log{
-						Level:  proto.LogLevel_INFO,
-						Output: "log-output",
-					},
-				},
-			}, {
-				Type: &proto.Provision_Response_Complete{
-					Complete: &proto.Provision_Complete{},
-				},
-			}},
-		})
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
-		history, err := client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
-			ProjectVersionID: project.ActiveVersionID,
-			Transition:       database.WorkspaceTransitionStart,
-		})
-		require.NoError(t, err)
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, history.ProvisionJobID)
-		// Return the log after completion!
-		logs, err := client.WorkspaceProvisionJobLogsBefore(context.Background(), user.Organization, history.ProvisionJobID, time.Time{})
-		require.NoError(t, err)
-		require.NotNil(t, logs)
-		require.Len(t, logs, 1)
-	})
-
 	t.Run("StreamAfterComplete", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
+		user := coderdtest.CreateFirstUser(t, client)
 		coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, &echo.Responses{
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, &echo.Responses{
 			Parse: echo.ParseComplete,
 			Provision: []*proto.Provision_Response{{
 				Type: &proto.Provision_Response_Log{
@@ -257,18 +36,20 @@ func TestProvisionerJobLogsByName(t *testing.T) {
 				},
 			}},
 		})
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
 		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
 		before := time.Now().UTC()
-		history, err := client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
+		build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
 			ProjectVersionID: project.ActiveVersionID,
 			Transition:       database.WorkspaceTransitionStart,
 		})
 		require.NoError(t, err)
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, history.ProvisionJobID)
+		coderdtest.AwaitWorkspaceBuildJob(t, client, build.ID)
 
-		logs, err := client.WorkspaceProvisionJobLogsAfter(context.Background(), user.Organization, history.ProvisionJobID, before)
+		ctx, cancelFunc := context.WithCancel(context.Background())
+		t.Cleanup(cancelFunc)
+		logs, err := client.WorkspaceBuildLogsAfter(ctx, build.ID, before)
 		require.NoError(t, err)
 		log, ok := <-logs
 		require.True(t, ok)
@@ -281,9 +62,9 @@ func TestProvisionerJobLogsByName(t *testing.T) {
 	t.Run("StreamWhileRunning", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
+		user := coderdtest.CreateFirstUser(t, client)
 		coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, &echo.Responses{
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, &echo.Responses{
 			Parse: echo.ParseComplete,
 			Provision: []*proto.Provision_Response{{
 				Type: &proto.Provision_Response_Log{
@@ -298,21 +79,56 @@ func TestProvisionerJobLogsByName(t *testing.T) {
 				},
 			}},
 		})
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
 		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
 		before := database.Now()
-		history, err := client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
+		build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
 			ProjectVersionID: project.ActiveVersionID,
 			Transition:       database.WorkspaceTransitionStart,
 		})
 		require.NoError(t, err)
-		logs, err := client.WorkspaceProvisionJobLogsAfter(context.Background(), user.Organization, history.ProvisionJobID, before)
+		ctx, cancelFunc := context.WithCancel(context.Background())
+		t.Cleanup(cancelFunc)
+		logs, err := client.WorkspaceBuildLogsAfter(ctx, build.ID, before)
 		require.NoError(t, err)
 		log := <-logs
 		require.Equal(t, "log-output", log.Output)
-		// Make sure the channel automatically closes!
 		_, ok := <-logs
 		require.False(t, ok)
 	})
+
+	t.Run("List", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		coderdtest.NewProvisionerDaemon(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, &echo.Responses{
+			Parse: echo.ParseComplete,
+			Provision: []*proto.Provision_Response{{
+				Type: &proto.Provision_Response_Log{
+					Log: &proto.Log{
+						Level:  proto.LogLevel_INFO,
+						Output: "log-output",
+					},
+				},
+			}, {
+				Type: &proto.Provision_Response_Complete{
+					Complete: &proto.Provision_Complete{},
+				},
+			}},
+		})
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
+		build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+			ProjectVersionID: project.ActiveVersionID,
+			Transition:       database.WorkspaceTransitionStart,
+		})
+		require.NoError(t, err)
+		coderdtest.AwaitWorkspaceBuildJob(t, client, build.ID)
+		logs, err := client.WorkspaceBuildLogsBefore(context.Background(), build.ID, time.Now())
+		require.NoError(t, err)
+		require.Len(t, logs, 1)
+	})
 }

coderd/users.go

@@ -8,6 +8,7 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/render"
 	"github.com/google/uuid"
 	"golang.org/x/xerrors"
@@ -27,21 +28,24 @@ type User struct {
 	Username  string    `json:"username" validate:"required"`
 }
 
-// CreateInitialUserRequest provides options to create the initial
-// user for a Coder deployment. The organization provided will be
-// created as well.
-type CreateInitialUserRequest struct {
+type CreateFirstUserRequest struct {
 	Email        string `json:"email" validate:"required,email"`
 	Username     string `json:"username" validate:"required,username"`
 	Password     string `json:"password" validate:"required"`
 	Organization string `json:"organization" validate:"required,username"`
 }
 
-// CreateUserRequest provides options for creating a new user.
+// CreateFirstUserResponse contains IDs for newly created user info.
+type CreateFirstUserResponse struct {
+	UserID         string `json:"user_id"`
+	OrganizationID string `json:"organization_id"`
+}
+
 type CreateUserRequest struct {
-	Email    string `json:"email" validate:"required,email"`
-	Username string `json:"username" validate:"required,username"`
-	Password string `json:"password" validate:"required"`
+	Email          string `json:"email" validate:"required,email"`
+	Username       string `json:"username" validate:"required,username"`
+	Password       string `json:"password" validate:"required"`
+	OrganizationID string `json:"organization_id" validate:"required"`
 }
 
 // LoginWithPasswordRequest enables callers to authenticate with email and password.
@@ -60,8 +64,18 @@ type GenerateAPIKeyResponse struct {
 	Key string `json:"key"`
 }
 
+type CreateOrganizationRequest struct {
+	Name string `json:"name" validate:"required,username"`
+}
+
+// CreateWorkspaceRequest provides options for creating a new workspace.
+type CreateWorkspaceRequest struct {
+	ProjectID uuid.UUID `json:"project_id" validate:"required"`
+	Name      string    `json:"name" validate:"username,required"`
+}
+
 // Returns whether the initial user has been created or not.
-func (api *api) user(rw http.ResponseWriter, r *http.Request) {
+func (api *api) firstUser(rw http.ResponseWriter, r *http.Request) {
 	userCount, err := api.Database.GetUserCount(r.Context())
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
@@ -81,8 +95,8 @@ func (api *api) user(rw http.ResponseWriter, r *http.Request) {
 }
 
 // Creates the initial user for a Coder deployment.
-func (api *api) postUser(rw http.ResponseWriter, r *http.Request) {
-	var createUser CreateInitialUserRequest
+func (api *api) postFirstUser(rw http.ResponseWriter, r *http.Request) {
+	var createUser CreateFirstUserRequest
 	if !httpapi.Read(rw, r, &createUser) {
 		return
 	}
@@ -111,6 +125,7 @@ func (api *api) postUser(rw http.ResponseWriter, r *http.Request) {
 
 	// Create the user, organization, and membership to the user.
 	var user database.User
+	var organization database.Organization
 	err = api.Database.InTx(func(s database.Store) error {
 		user, err = api.Database.InsertUser(r.Context(), database.InsertUserParams{
 			ID:             uuid.NewString(),
@@ -124,7 +139,7 @@ func (api *api) postUser(rw http.ResponseWriter, r *http.Request) {
 		if err != nil {
 			return xerrors.Errorf("create user: %w", err)
 		}
-		organization, err := api.Database.InsertOrganization(r.Context(), database.InsertOrganizationParams{
+		organization, err = api.Database.InsertOrganization(r.Context(), database.InsertOrganizationParams{
 			ID:        uuid.NewString(),
 			Name:      createUser.Organization,
 			CreatedAt: database.Now(),
@@ -153,11 +168,16 @@ func (api *api) postUser(rw http.ResponseWriter, r *http.Request) {
 	}
 
 	render.Status(r, http.StatusCreated)
-	render.JSON(rw, r, convertUser(user))
+	render.JSON(rw, r, CreateFirstUserResponse{
+		UserID:         user.ID,
+		OrganizationID: organization.ID,
+	})
 }
 
 // Creates a new user.
 func (api *api) postUsers(rw http.ResponseWriter, r *http.Request) {
+	apiKey := httpmw.APIKey(r)
+
 	var createUser CreateUserRequest
 	if !httpapi.Read(rw, r, &createUser) {
 		return
@@ -179,6 +199,37 @@ func (api *api) postUsers(rw http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	organization, err := api.Database.GetOrganizationByID(r.Context(), createUser.OrganizationID)
+	if errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
+			Message: "organization does not exist with the provided id",
+		})
+		return
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get organization: %s", err),
+		})
+		return
+	}
+	// Check if the caller has permissions to the organization requested.
+	_, err = api.Database.GetOrganizationMemberByUserID(r.Context(), database.GetOrganizationMemberByUserIDParams{
+		OrganizationID: organization.ID,
+		UserID:         apiKey.UserID,
+	})
+	if errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusUnauthorized, httpapi.Response{
+			Message: "you are not authorized to add members to that organization",
+		})
+		return
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get organization member: %s", err),
+		})
+		return
+	}
+
 	hashedPassword, err := userpassword.Hash(createUser.Password)
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
@@ -187,18 +238,35 @@ func (api *api) postUsers(rw http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	user, err := api.Database.InsertUser(r.Context(), database.InsertUserParams{
-		ID:             uuid.NewString(),
-		Email:          createUser.Email,
-		HashedPassword: []byte(hashedPassword),
-		Username:       createUser.Username,
-		LoginType:      database.LoginTypeBuiltIn,
-		CreatedAt:      database.Now(),
-		UpdatedAt:      database.Now(),
+	var user database.User
+	err = api.Database.InTx(func(db database.Store) error {
+		user, err = db.InsertUser(r.Context(), database.InsertUserParams{
+			ID:             uuid.NewString(),
+			Email:          createUser.Email,
+			HashedPassword: []byte(hashedPassword),
+			Username:       createUser.Username,
+			LoginType:      database.LoginTypeBuiltIn,
+			CreatedAt:      database.Now(),
+			UpdatedAt:      database.Now(),
+		})
+		if err != nil {
+			return xerrors.Errorf("create user: %w", err)
+		}
+		_, err = db.InsertOrganizationMember(r.Context(), database.InsertOrganizationMemberParams{
+			OrganizationID: organization.ID,
+			UserID:         user.ID,
+			CreatedAt:      database.Now(),
+			UpdatedAt:      database.Now(),
+			Roles:          []string{},
+		})
+		if err != nil {
+			return xerrors.Errorf("create organization member: %w", err)
+		}
+		return nil
 	})
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("create user: %s", err.Error()),
+			Message: err.Error(),
 		})
 		return
 	}
@@ -240,6 +308,97 @@ func (api *api) organizationsByUser(rw http.ResponseWriter, r *http.Request) {
 	render.JSON(rw, r, publicOrganizations)
 }
 
+func (api *api) organizationByUserAndName(rw http.ResponseWriter, r *http.Request) {
+	user := httpmw.UserParam(r)
+	organizationName := chi.URLParam(r, "organizationname")
+	organization, err := api.Database.GetOrganizationByName(r.Context(), organizationName)
+	if errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
+			Message: fmt.Sprintf("no organization found by name %q", organizationName),
+		})
+		return
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get organization by name: %s", err),
+		})
+		return
+	}
+	_, err = api.Database.GetOrganizationMemberByUserID(r.Context(), database.GetOrganizationMemberByUserIDParams{
+		OrganizationID: organization.ID,
+		UserID:         user.ID,
+	})
+	if errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusUnauthorized, httpapi.Response{
+			Message: "you are not a member of that organization",
+		})
+		return
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get organization member: %s", err),
+		})
+		return
+	}
+
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, convertOrganization(organization))
+}
+
+func (api *api) postOrganizationsByUser(rw http.ResponseWriter, r *http.Request) {
+	user := httpmw.UserParam(r)
+	var req CreateOrganizationRequest
+	if !httpapi.Read(rw, r, &req) {
+		return
+	}
+	_, err := api.Database.GetOrganizationByName(r.Context(), req.Name)
+	if err == nil {
+		httpapi.Write(rw, http.StatusConflict, httpapi.Response{
+			Message: "organization already exists with that name",
+		})
+		return
+	}
+	if !errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get organization: %s", err.Error()),
+		})
+		return
+	}
+
+	var organization database.Organization
+	err = api.Database.InTx(func(db database.Store) error {
+		organization, err = api.Database.InsertOrganization(r.Context(), database.InsertOrganizationParams{
+			ID:        uuid.NewString(),
+			Name:      req.Name,
+			CreatedAt: database.Now(),
+			UpdatedAt: database.Now(),
+		})
+		if err != nil {
+			return xerrors.Errorf("create organization: %w", err)
+		}
+		_, err = api.Database.InsertOrganizationMember(r.Context(), database.InsertOrganizationMemberParams{
+			OrganizationID: organization.ID,
+			UserID:         user.ID,
+			CreatedAt:      database.Now(),
+			UpdatedAt:      database.Now(),
+			Roles:          []string{"organization-admin"},
+		})
+		if err != nil {
+			return xerrors.Errorf("create organization member: %w", err)
+		}
+		return nil
+	})
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: err.Error(),
+		})
+		return
+	}
+
+	render.Status(r, http.StatusCreated)
+	render.JSON(rw, r, convertOrganization(organization))
+}
+
 // Authenticates the user with an email and password.
 func (api *api) postLogin(rw http.ResponseWriter, r *http.Request) {
 	var loginWithPassword LoginWithPasswordRequest
@@ -318,7 +477,7 @@ func (api *api) postLogin(rw http.ResponseWriter, r *http.Request) {
 }
 
 // Creates a new session key, used for logging in via the CLI
-func (api *api) postKeyForUser(rw http.ResponseWriter, r *http.Request) {
+func (api *api) postAPIKey(rw http.ResponseWriter, r *http.Request) {
 	user := httpmw.UserParam(r)
 	apiKey := httpmw.APIKey(r)
 
@@ -375,6 +534,141 @@ func (*api) postLogout(rw http.ResponseWriter, r *http.Request) {
 	render.Status(r, http.StatusOK)
 }
 
+// Create a new workspace for the currently authenticated user.
+func (api *api) postWorkspacesByUser(rw http.ResponseWriter, r *http.Request) {
+	var createWorkspace CreateWorkspaceRequest
+	if !httpapi.Read(rw, r, &createWorkspace) {
+		return
+	}
+	apiKey := httpmw.APIKey(r)
+	project, err := api.Database.GetProjectByID(r.Context(), createWorkspace.ProjectID)
+	if errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
+			Message: fmt.Sprintf("project %q doesn't exist", createWorkspace.ProjectID.String()),
+			Errors: []httpapi.Error{{
+				Field: "project_id",
+				Code:  "not_found",
+			}},
+		})
+		return
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get project: %s", err),
+		})
+		return
+	}
+	_, err = api.Database.GetOrganizationMemberByUserID(r.Context(), database.GetOrganizationMemberByUserIDParams{
+		OrganizationID: project.OrganizationID,
+		UserID:         apiKey.UserID,
+	})
+	if errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusUnauthorized, httpapi.Response{
+			Message: "you aren't allowed to access projects in that organization",
+		})
+		return
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get organization member: %s", err),
+		})
+		return
+	}
+
+	workspace, err := api.Database.GetWorkspaceByUserIDAndName(r.Context(), database.GetWorkspaceByUserIDAndNameParams{
+		OwnerID: apiKey.UserID,
+		Name:    createWorkspace.Name,
+	})
+	if err == nil {
+		// If the workspace already exists, don't allow creation.
+		project, err := api.Database.GetProjectByID(r.Context(), workspace.ProjectID)
+		if err != nil {
+			httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+				Message: fmt.Sprintf("find project for conflicting workspace name %q: %s", createWorkspace.Name, err),
+			})
+			return
+		}
+		// The project is fetched for clarity to the user on where the conflicting name may be.
+		httpapi.Write(rw, http.StatusConflict, httpapi.Response{
+			Message: fmt.Sprintf("workspace %q already exists in the %q project", createWorkspace.Name, project.Name),
+			Errors: []httpapi.Error{{
+				Field: "name",
+				Code:  "exists",
+			}},
+		})
+		return
+	}
+	if !errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get workspace by name: %s", err.Error()),
+		})
+		return
+	}
+
+	// Workspaces are created without any versions.
+	workspace, err = api.Database.InsertWorkspace(r.Context(), database.InsertWorkspaceParams{
+		ID:        uuid.New(),
+		CreatedAt: database.Now(),
+		UpdatedAt: database.Now(),
+		OwnerID:   apiKey.UserID,
+		ProjectID: project.ID,
+		Name:      createWorkspace.Name,
+	})
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("insert workspace: %s", err),
+		})
+		return
+	}
+
+	render.Status(r, http.StatusCreated)
+	render.JSON(rw, r, convertWorkspace(workspace))
+}
+
+func (api *api) workspacesByUser(rw http.ResponseWriter, r *http.Request) {
+	user := httpmw.UserParam(r)
+	workspaces, err := api.Database.GetWorkspacesByUserID(r.Context(), user.ID)
+	if errors.Is(err, sql.ErrNoRows) {
+		err = nil
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get workspaces: %s", err),
+		})
+		return
+	}
+	apiWorkspaces := make([]Workspace, 0, len(workspaces))
+	for _, workspace := range workspaces {
+		apiWorkspaces = append(apiWorkspaces, convertWorkspace(workspace))
+	}
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, apiWorkspaces)
+}
+
+func (api *api) workspaceByUserAndName(rw http.ResponseWriter, r *http.Request) {
+	user := httpmw.UserParam(r)
+	workspaceName := chi.URLParam(r, "workspacename")
+	workspace, err := api.Database.GetWorkspaceByUserIDAndName(r.Context(), database.GetWorkspaceByUserIDAndNameParams{
+		OwnerID: user.ID,
+		Name:    workspaceName,
+	})
+	if errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
+			Message: fmt.Sprintf("no workspace found by name %q", workspaceName),
+		})
+		return
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get workspace by name: %s", err),
+		})
+		return
+	}
+
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, convertWorkspace(workspace))
+}
+
 // Generates a new ID and secret for an API key.
 func generateAPIKeyIDSecret() (id string, secret string, err error) {
 	// Length of an API Key ID.

coderd/users_test.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 	"testing"
 
+	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
 
 	"github.com/coder/coder/coderd"
@@ -13,40 +14,20 @@ import (
 	"github.com/coder/coder/httpmw"
 )
 
-func TestUser(t *testing.T) {
-	t.Parallel()
-	t.Run("NotFound", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		has, err := client.HasInitialUser(context.Background())
-		require.NoError(t, err)
-		require.False(t, has)
-	})
-
-	t.Run("Found", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		_ = coderdtest.CreateInitialUser(t, client)
-		has, err := client.HasInitialUser(context.Background())
-		require.NoError(t, err)
-		require.True(t, has)
-	})
-}
-
-func TestPostUser(t *testing.T) {
+func TestFirstUser(t *testing.T) {
 	t.Parallel()
 	t.Run("BadRequest", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		_, err := client.CreateInitialUser(context.Background(), coderd.CreateInitialUserRequest{})
+		_, err := client.CreateFirstUser(context.Background(), coderd.CreateFirstUserRequest{})
 		require.Error(t, err)
 	})
 
 	t.Run("AlreadyExists", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		_ = coderdtest.CreateInitialUser(t, client)
-		_, err := client.CreateInitialUser(context.Background(), coderd.CreateInitialUserRequest{
+		_ = coderdtest.CreateFirstUser(t, client)
+		_, err := client.CreateFirstUser(context.Background(), coderd.CreateFirstUserRequest{
 			Email:        "some@email.com",
 			Username:     "exampleuser",
 			Password:     "password",
@@ -60,89 +41,7 @@ func TestPostUser(t *testing.T) {
 	t.Run("Create", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		_ = coderdtest.CreateInitialUser(t, client)
-	})
-}
-
-func TestPostUsers(t *testing.T) {
-	t.Parallel()
-	t.Run("BadRequest", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		_, err := client.CreateInitialUser(context.Background(), coderd.CreateInitialUserRequest{})
-		require.Error(t, err)
-	})
-
-	t.Run("Conflicting", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		_, err := client.CreateInitialUser(context.Background(), coderd.CreateInitialUserRequest{
-			Email:        user.Email,
-			Username:     user.Username,
-			Password:     "password",
-			Organization: "someorg",
-		})
-		var apiErr *codersdk.Error
-		require.ErrorAs(t, err, &apiErr)
-		require.Equal(t, http.StatusConflict, apiErr.StatusCode())
-	})
-
-	t.Run("Create", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		_ = coderdtest.CreateInitialUser(t, client)
-		_, err := client.CreateUser(context.Background(), coderd.CreateUserRequest{
-			Email:    "another@user.org",
-			Username: "someone-else",
-			Password: "testing",
-		})
-		require.NoError(t, err)
-	})
-}
-
-func TestUserByName(t *testing.T) {
-	t.Parallel()
-	client := coderdtest.New(t, nil)
-	_ = coderdtest.CreateInitialUser(t, client)
-	_, err := client.User(context.Background(), "")
-	require.NoError(t, err)
-}
-
-func TestOrganizationsByUser(t *testing.T) {
-	t.Parallel()
-	client := coderdtest.New(t, nil)
-	_ = coderdtest.CreateInitialUser(t, client)
-	orgs, err := client.UserOrganizations(context.Background(), "")
-	require.NoError(t, err)
-	require.NotNil(t, orgs)
-	require.Len(t, orgs, 1)
-}
-
-func TestPostKey(t *testing.T) {
-	t.Parallel()
-	t.Run("InvalidUser", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		_ = coderdtest.CreateInitialUser(t, client)
-
-		// Clear session token
-		client.SessionToken = ""
-		// ...and request an API key
-		_, err := client.CreateAPIKey(context.Background())
-		var apiErr *codersdk.Error
-		require.ErrorAs(t, err, &apiErr)
-		require.Equal(t, http.StatusUnauthorized, apiErr.StatusCode())
-	})
-
-	t.Run("Success", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		_ = coderdtest.CreateInitialUser(t, client)
-		apiKey, err := client.CreateAPIKey(context.Background())
-		require.NotNil(t, apiKey)
-		require.GreaterOrEqual(t, len(apiKey.Key), 2)
-		require.NoError(t, err)
+		_ = coderdtest.CreateFirstUser(t, client)
 	})
 }
 
@@ -163,9 +62,16 @@ func TestPostLogin(t *testing.T) {
 	t.Run("BadPassword", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		_, err := client.LoginWithPassword(context.Background(), coderd.LoginWithPasswordRequest{
-			Email:    user.Email,
+		req := coderd.CreateFirstUserRequest{
+			Email:        "testuser@coder.com",
+			Username:     "testuser",
+			Password:     "testpass",
+			Organization: "testorg",
+		}
+		_, err := client.CreateFirstUser(context.Background(), req)
+		require.NoError(t, err)
+		_, err = client.LoginWithPassword(context.Background(), coderd.LoginWithPasswordRequest{
+			Email:    req.Email,
 			Password: "badpass",
 		})
 		var apiErr *codersdk.Error
@@ -176,10 +82,17 @@ func TestPostLogin(t *testing.T) {
 	t.Run("Success", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		_, err := client.LoginWithPassword(context.Background(), coderd.LoginWithPasswordRequest{
-			Email:    user.Email,
-			Password: user.Password,
+		req := coderd.CreateFirstUserRequest{
+			Email:        "testuser@coder.com",
+			Username:     "testuser",
+			Password:     "testpass",
+			Organization: "testorg",
+		}
+		_, err := client.CreateFirstUser(context.Background(), req)
+		require.NoError(t, err)
+		_, err = client.LoginWithPassword(context.Background(), coderd.LoginWithPasswordRequest{
+			Email:    req.Email,
+			Password: req.Password,
 		})
 		require.NoError(t, err)
 	})
@@ -192,7 +105,7 @@ func TestPostLogout(t *testing.T) {
 		t.Parallel()
 
 		client := coderdtest.New(t, nil)
-		fullURL, err := client.URL.Parse("/api/v2/logout")
+		fullURL, err := client.URL.Parse("/api/v2/users/logout")
 		require.NoError(t, err, "Server URL should parse successfully")
 
 		req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, fullURL.String(), nil)
@@ -211,3 +124,298 @@ func TestPostLogout(t *testing.T) {
 		require.Equal(t, cookies[0].MaxAge, -1, "Cookie should be set to delete")
 	})
 }
+
+func TestPostUsers(t *testing.T) {
+	t.Parallel()
+	t.Run("NoAuth", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		_, err := client.CreateUser(context.Background(), coderd.CreateUserRequest{})
+		require.Error(t, err)
+	})
+
+	t.Run("Conflicting", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		coderdtest.CreateFirstUser(t, client)
+		me, err := client.User(context.Background(), "")
+		require.NoError(t, err)
+		_, err = client.CreateUser(context.Background(), coderd.CreateUserRequest{
+			Email:          me.Email,
+			Username:       me.Username,
+			Password:       "password",
+			OrganizationID: "someorg",
+		})
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusConflict, apiErr.StatusCode())
+	})
+
+	t.Run("OrganizationNotFound", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		coderdtest.CreateFirstUser(t, client)
+		_, err := client.CreateUser(context.Background(), coderd.CreateUserRequest{
+			OrganizationID: "not-exists",
+			Email:          "another@user.org",
+			Username:       "someone-else",
+			Password:       "testing",
+		})
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusNotFound, apiErr.StatusCode())
+	})
+
+	t.Run("OrganizationNoAccess", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		first := coderdtest.CreateFirstUser(t, client)
+		other := coderdtest.CreateAnotherUser(t, client, first.OrganizationID)
+		org, err := other.CreateOrganization(context.Background(), "", coderd.CreateOrganizationRequest{
+			Name: "another",
+		})
+		require.NoError(t, err)
+
+		_, err = client.CreateUser(context.Background(), coderd.CreateUserRequest{
+			Email:          "some@domain.com",
+			Username:       "anotheruser",
+			Password:       "testing",
+			OrganizationID: org.ID,
+		})
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusUnauthorized, apiErr.StatusCode())
+	})
+
+	t.Run("Create", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		_, err := client.CreateUser(context.Background(), coderd.CreateUserRequest{
+			OrganizationID: user.OrganizationID,
+			Email:          "another@user.org",
+			Username:       "someone-else",
+			Password:       "testing",
+		})
+		require.NoError(t, err)
+	})
+}
+
+func TestUserByName(t *testing.T) {
+	t.Parallel()
+	client := coderdtest.New(t, nil)
+	_ = coderdtest.CreateFirstUser(t, client)
+	_, err := client.User(context.Background(), "")
+	require.NoError(t, err)
+}
+
+func TestOrganizationsByUser(t *testing.T) {
+	t.Parallel()
+	client := coderdtest.New(t, nil)
+	_ = coderdtest.CreateFirstUser(t, client)
+	orgs, err := client.OrganizationsByUser(context.Background(), "")
+	require.NoError(t, err)
+	require.NotNil(t, orgs)
+	require.Len(t, orgs, 1)
+}
+
+func TestOrganizationByUserAndName(t *testing.T) {
+	t.Parallel()
+	t.Run("NoExist", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		coderdtest.CreateFirstUser(t, client)
+		_, err := client.OrganizationByName(context.Background(), "", "nothing")
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusNotFound, apiErr.StatusCode())
+	})
+
+	t.Run("NoMember", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		first := coderdtest.CreateFirstUser(t, client)
+		other := coderdtest.CreateAnotherUser(t, client, first.OrganizationID)
+		org, err := other.CreateOrganization(context.Background(), "", coderd.CreateOrganizationRequest{
+			Name: "another",
+		})
+		require.NoError(t, err)
+		_, err = client.OrganizationByName(context.Background(), "", org.Name)
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusUnauthorized, apiErr.StatusCode())
+	})
+
+	t.Run("Valid", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		org, err := client.Organization(context.Background(), user.OrganizationID)
+		require.NoError(t, err)
+		_, err = client.OrganizationByName(context.Background(), "", org.Name)
+		require.NoError(t, err)
+	})
+}
+
+func TestPostOrganizationsByUser(t *testing.T) {
+	t.Parallel()
+	t.Run("Conflict", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		org, err := client.Organization(context.Background(), user.OrganizationID)
+		require.NoError(t, err)
+		_, err = client.CreateOrganization(context.Background(), "", coderd.CreateOrganizationRequest{
+			Name: org.Name,
+		})
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusConflict, apiErr.StatusCode())
+	})
+
+	t.Run("Create", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		_ = coderdtest.CreateFirstUser(t, client)
+		_, err := client.CreateOrganization(context.Background(), "", coderd.CreateOrganizationRequest{
+			Name: "new",
+		})
+		require.NoError(t, err)
+	})
+}
+
+func TestPostAPIKey(t *testing.T) {
+	t.Parallel()
+	t.Run("InvalidUser", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		_ = coderdtest.CreateFirstUser(t, client)
+
+		client.SessionToken = ""
+		_, err := client.CreateAPIKey(context.Background(), "")
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusUnauthorized, apiErr.StatusCode())
+	})
+
+	t.Run("Success", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		_ = coderdtest.CreateFirstUser(t, client)
+		apiKey, err := client.CreateAPIKey(context.Background(), "")
+		require.NotNil(t, apiKey)
+		require.GreaterOrEqual(t, len(apiKey.Key), 2)
+		require.NoError(t, err)
+	})
+}
+
+func TestPostWorkspacesByUser(t *testing.T) {
+	t.Parallel()
+	t.Run("InvalidProject", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		_ = coderdtest.CreateFirstUser(t, client)
+		_, err := client.CreateWorkspace(context.Background(), "", coderd.CreateWorkspaceRequest{
+			ProjectID: uuid.New(),
+			Name:      "workspace",
+		})
+		require.Error(t, err)
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusBadRequest, apiErr.StatusCode())
+	})
+
+	t.Run("NoProjectAccess", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		first := coderdtest.CreateFirstUser(t, client)
+
+		other := coderdtest.CreateAnotherUser(t, client, first.OrganizationID)
+		org, err := other.CreateOrganization(context.Background(), "", coderd.CreateOrganizationRequest{
+			Name: "another",
+		})
+		require.NoError(t, err)
+		version := coderdtest.CreateProjectVersion(t, other, org.ID, nil)
+		project := coderdtest.CreateProject(t, other, org.ID, version.ID)
+
+		_, err = client.CreateWorkspace(context.Background(), "", coderd.CreateWorkspaceRequest{
+			ProjectID: project.ID,
+			Name:      "workspace",
+		})
+		require.Error(t, err)
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusUnauthorized, apiErr.StatusCode())
+	})
+
+	t.Run("AlreadyExists", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		job := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, job.ID)
+		workspace := coderdtest.CreateWorkspace(t, client, "", project.ID)
+		_, err := client.CreateWorkspace(context.Background(), "", coderd.CreateWorkspaceRequest{
+			ProjectID: project.ID,
+			Name:      workspace.Name,
+		})
+		require.Error(t, err)
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusConflict, apiErr.StatusCode())
+	})
+
+	t.Run("Create", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		job := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, job.ID)
+		_ = coderdtest.CreateWorkspace(t, client, "", project.ID)
+	})
+}
+
+func TestWorkspacesByUser(t *testing.T) {
+	t.Parallel()
+	t.Run("ListEmpty", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		coderdtest.CreateFirstUser(t, client)
+		_, err := client.WorkspacesByUser(context.Background(), "")
+		require.NoError(t, err)
+	})
+	t.Run("List", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		job := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, job.ID)
+		_ = coderdtest.CreateWorkspace(t, client, "", project.ID)
+		workspaces, err := client.WorkspacesByUser(context.Background(), "")
+		require.NoError(t, err)
+		require.Len(t, workspaces, 1)
+	})
+}
+
+func TestWorkspaceByUserAndName(t *testing.T) {
+	t.Parallel()
+	t.Run("NotFound", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		coderdtest.CreateFirstUser(t, client)
+		_, err := client.WorkspaceByName(context.Background(), "", "something")
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusNotFound, apiErr.StatusCode())
+	})
+	t.Run("Get", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		job := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, job.ID)
+		workspace := coderdtest.CreateWorkspace(t, client, "", project.ID)
+		_, err := client.WorkspaceByName(context.Background(), "", workspace.Name)
+		require.NoError(t, err)
+	})
+}

coderd/workspacebuilds.go

@@ -0,0 +1,96 @@
+package coderd
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/go-chi/render"
+	"github.com/google/uuid"
+
+	"github.com/coder/coder/database"
+	"github.com/coder/coder/httpapi"
+	"github.com/coder/coder/httpmw"
+)
+
+// WorkspaceBuild is an at-point representation of a workspace state.
+// Iterate on before/after to determine a chronological history.
+type WorkspaceBuild struct {
+	ID               uuid.UUID                    `json:"id"`
+	CreatedAt        time.Time                    `json:"created_at"`
+	UpdatedAt        time.Time                    `json:"updated_at"`
+	WorkspaceID      uuid.UUID                    `json:"workspace_id"`
+	ProjectVersionID uuid.UUID                    `json:"project_version_id"`
+	BeforeID         uuid.UUID                    `json:"before_id"`
+	AfterID          uuid.UUID                    `json:"after_id"`
+	Name             string                       `json:"name"`
+	Transition       database.WorkspaceTransition `json:"transition"`
+	Initiator        string                       `json:"initiator"`
+	Job              ProvisionerJob               `json:"job"`
+}
+
+func (api *api) workspaceBuild(rw http.ResponseWriter, r *http.Request) {
+	workspaceBuild := httpmw.WorkspaceBuildParam(r)
+	job, err := api.Database.GetProvisionerJobByID(r.Context(), workspaceBuild.JobID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job: %s", err),
+		})
+		return
+	}
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, convertWorkspaceBuild(workspaceBuild, convertProvisionerJob(job)))
+}
+
+func (api *api) workspaceBuildResources(rw http.ResponseWriter, r *http.Request) {
+	workspaceBuild := httpmw.WorkspaceBuildParam(r)
+	job, err := api.Database.GetProvisionerJobByID(r.Context(), workspaceBuild.JobID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job: %s", err),
+		})
+		return
+	}
+	api.provisionerJobResources(rw, r, job)
+}
+
+func (api *api) workspaceBuildLogs(rw http.ResponseWriter, r *http.Request) {
+	workspaceBuild := httpmw.WorkspaceBuildParam(r)
+	job, err := api.Database.GetProvisionerJobByID(r.Context(), workspaceBuild.JobID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job: %s", err),
+		})
+		return
+	}
+	api.provisionerJobLogs(rw, r, job)
+}
+
+func convertWorkspaceBuild(workspaceBuild database.WorkspaceBuild, job ProvisionerJob) WorkspaceBuild {
+	//nolint:unconvert
+	return WorkspaceBuild(WorkspaceBuild{
+		ID:               workspaceBuild.ID,
+		CreatedAt:        workspaceBuild.CreatedAt,
+		UpdatedAt:        workspaceBuild.UpdatedAt,
+		WorkspaceID:      workspaceBuild.WorkspaceID,
+		ProjectVersionID: workspaceBuild.ProjectVersionID,
+		BeforeID:         workspaceBuild.BeforeID.UUID,
+		AfterID:          workspaceBuild.AfterID.UUID,
+		Name:             workspaceBuild.Name,
+		Transition:       workspaceBuild.Transition,
+		Initiator:        workspaceBuild.Initiator,
+		Job:              job,
+	})
+}
+
+func convertWorkspaceResource(resource database.WorkspaceResource, agent *WorkspaceAgent) WorkspaceResource {
+	return WorkspaceResource{
+		ID:         resource.ID,
+		CreatedAt:  resource.CreatedAt,
+		JobID:      resource.JobID,
+		Transition: resource.Transition,
+		Type:       resource.Type,
+		Name:       resource.Name,
+		Agent:      agent,
+	}
+}

coderd/workspacebuilds_test.go

@@ -0,0 +1,150 @@
+package coderd_test
+
+import (
+	"context"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/coder/coder/coderd"
+	"github.com/coder/coder/coderd/coderdtest"
+	"github.com/coder/coder/codersdk"
+	"github.com/coder/coder/database"
+	"github.com/coder/coder/provisioner/echo"
+	"github.com/coder/coder/provisionersdk/proto"
+)
+
+func TestWorkspaceBuild(t *testing.T) {
+	t.Parallel()
+	client := coderdtest.New(t, nil)
+	user := coderdtest.CreateFirstUser(t, client)
+	coderdtest.NewProvisionerDaemon(t, client)
+	version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+	project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+	coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+	workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
+	build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+		ProjectVersionID: project.ActiveVersionID,
+		Transition:       database.WorkspaceTransitionStart,
+	})
+	require.NoError(t, err)
+	_, err = client.WorkspaceBuild(context.Background(), build.ID)
+	require.NoError(t, err)
+}
+
+func TestWorkspaceBuildResources(t *testing.T) {
+	t.Parallel()
+	t.Run("ListRunning", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		closeDaemon := coderdtest.NewProvisionerDaemon(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+		closeDaemon.Close()
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		workspace := coderdtest.CreateWorkspace(t, client, "", project.ID)
+		build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+			ProjectVersionID: project.ActiveVersionID,
+			Transition:       database.WorkspaceTransitionStart,
+		})
+		require.NoError(t, err)
+		_, err = client.WorkspaceResourcesByBuild(context.Background(), build.ID)
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusPreconditionFailed, apiErr.StatusCode())
+	})
+	t.Run("List", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		coderdtest.NewProvisionerDaemon(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, &echo.Responses{
+			Parse: echo.ParseComplete,
+			Provision: []*proto.Provision_Response{{
+				Type: &proto.Provision_Response_Complete{
+					Complete: &proto.Provision_Complete{
+						Resources: []*proto.Resource{{
+							Name: "some",
+							Type: "example",
+							Agent: &proto.Agent{
+								Id:   "something",
+								Auth: &proto.Agent_Token{},
+							},
+						}, {
+							Name: "another",
+							Type: "example",
+						}},
+					},
+				},
+			}},
+		})
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		workspace := coderdtest.CreateWorkspace(t, client, "", project.ID)
+		build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+			ProjectVersionID: project.ActiveVersionID,
+			Transition:       database.WorkspaceTransitionStart,
+		})
+		require.NoError(t, err)
+		coderdtest.AwaitWorkspaceBuildJob(t, client, build.ID)
+		resources, err := client.WorkspaceResourcesByBuild(context.Background(), build.ID)
+		require.NoError(t, err)
+		require.NotNil(t, resources)
+		require.Len(t, resources, 2)
+		require.Equal(t, "some", resources[0].Name)
+		require.Equal(t, "example", resources[0].Type)
+		require.NotNil(t, resources[0].Agent)
+	})
+}
+
+func TestWorkspaceBuildLogs(t *testing.T) {
+	t.Parallel()
+	client := coderdtest.New(t, nil)
+	user := coderdtest.CreateFirstUser(t, client)
+	coderdtest.NewProvisionerDaemon(t, client)
+	before := time.Now()
+	version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, &echo.Responses{
+		Parse: echo.ParseComplete,
+		Provision: []*proto.Provision_Response{{
+			Type: &proto.Provision_Response_Log{
+				Log: &proto.Log{
+					Level:  proto.LogLevel_INFO,
+					Output: "example",
+				},
+			},
+		}, {
+			Type: &proto.Provision_Response_Complete{
+				Complete: &proto.Provision_Complete{
+					Resources: []*proto.Resource{{
+						Name: "some",
+						Type: "example",
+						Agent: &proto.Agent{
+							Id:   "something",
+							Auth: &proto.Agent_Token{},
+						},
+					}, {
+						Name: "another",
+						Type: "example",
+					}},
+				},
+			},
+		}},
+	})
+	coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+	project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+	workspace := coderdtest.CreateWorkspace(t, client, "", project.ID)
+	build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+		ProjectVersionID: project.ActiveVersionID,
+		Transition:       database.WorkspaceTransitionStart,
+	})
+	require.NoError(t, err)
+	ctx, cancelFunc := context.WithCancel(context.Background())
+	t.Cleanup(cancelFunc)
+	logs, err := client.WorkspaceBuildLogsAfter(ctx, build.ID, before)
+	require.NoError(t, err)
+	log := <-logs
+	require.Equal(t, "example", log.Output)
+}

coderd/workspacehistory.go

@@ -1,244 +0,0 @@
-package coderd
-
-import (
-	"database/sql"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/go-chi/render"
-	"github.com/google/uuid"
-	"github.com/moby/moby/pkg/namesgenerator"
-	"golang.org/x/xerrors"
-
-	"github.com/coder/coder/database"
-	"github.com/coder/coder/httpapi"
-	"github.com/coder/coder/httpmw"
-)
-
-// WorkspaceHistory is an at-point representation of a workspace state.
-// Iterate on before/after to determine a chronological history.
-type WorkspaceHistory struct {
-	ID               uuid.UUID                    `json:"id"`
-	CreatedAt        time.Time                    `json:"created_at"`
-	UpdatedAt        time.Time                    `json:"updated_at"`
-	WorkspaceID      uuid.UUID                    `json:"workspace_id"`
-	ProjectVersionID uuid.UUID                    `json:"project_version_id"`
-	BeforeID         uuid.UUID                    `json:"before_id"`
-	AfterID          uuid.UUID                    `json:"after_id"`
-	Name             string                       `json:"name"`
-	Transition       database.WorkspaceTransition `json:"transition"`
-	Initiator        string                       `json:"initiator"`
-	ProvisionJobID   uuid.UUID                    `json:"provision_job_id"`
-}
-
-// CreateWorkspaceHistoryRequest provides options to update the latest workspace history.
-type CreateWorkspaceHistoryRequest struct {
-	ProjectVersionID uuid.UUID                    `json:"project_version_id" validate:"required"`
-	Transition       database.WorkspaceTransition `json:"transition" validate:"oneof=create start stop delete,required"`
-}
-
-func (api *api) postWorkspaceHistoryByUser(rw http.ResponseWriter, r *http.Request) {
-	var createBuild CreateWorkspaceHistoryRequest
-	if !httpapi.Read(rw, r, &createBuild) {
-		return
-	}
-	user := httpmw.UserParam(r)
-	workspace := httpmw.WorkspaceParam(r)
-	projectVersion, err := api.Database.GetProjectVersionByID(r.Context(), createBuild.ProjectVersionID)
-	if errors.Is(err, sql.ErrNoRows) {
-		httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
-			Message: "project version not found",
-			Errors: []httpapi.Error{{
-				Field: "project_version_id",
-				Code:  "exists",
-			}},
-		})
-		return
-	}
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get project version: %s", err),
-		})
-		return
-	}
-	projectVersionJob, err := api.Database.GetProvisionerJobByID(r.Context(), projectVersion.ImportJobID)
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get provisioner job: %s", err),
-		})
-		return
-	}
-	projectVersionJobStatus := convertProvisionerJob(projectVersionJob).Status
-	switch projectVersionJobStatus {
-	case ProvisionerJobStatusPending, ProvisionerJobStatusRunning:
-		httpapi.Write(rw, http.StatusNotAcceptable, httpapi.Response{
-			Message: fmt.Sprintf("The provided project version is %s. Wait for it to complete importing!", projectVersionJobStatus),
-		})
-		return
-	case ProvisionerJobStatusFailed:
-		httpapi.Write(rw, http.StatusPreconditionFailed, httpapi.Response{
-			Message: fmt.Sprintf("The provided project version %q has failed to import. You cannot create workspaces using it!", projectVersion.Name),
-		})
-		return
-	case ProvisionerJobStatusCancelled:
-		httpapi.Write(rw, http.StatusPreconditionFailed, httpapi.Response{
-			Message: "The provided project version was canceled during import. You cannot create workspaces using it!",
-		})
-		return
-	}
-
-	project, err := api.Database.GetProjectByID(r.Context(), projectVersion.ProjectID)
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get project: %s", err),
-		})
-		return
-	}
-
-	// Store prior history ID if it exists to update it after we create new!
-	priorHistoryID := uuid.NullUUID{}
-	priorHistory, err := api.Database.GetWorkspaceHistoryByWorkspaceIDWithoutAfter(r.Context(), workspace.ID)
-	if err == nil {
-		priorJob, err := api.Database.GetProvisionerJobByID(r.Context(), priorHistory.ProvisionJobID)
-		if err == nil && !convertProvisionerJob(priorJob).Status.Completed() {
-			httpapi.Write(rw, http.StatusConflict, httpapi.Response{
-				Message: "a workspace build is already active",
-			})
-			return
-		}
-
-		priorHistoryID = uuid.NullUUID{
-			UUID:  priorHistory.ID,
-			Valid: true,
-		}
-	} else if !errors.Is(err, sql.ErrNoRows) {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get prior workspace history: %s", err),
-		})
-		return
-	}
-
-	var workspaceHistory database.WorkspaceHistory
-	// This must happen in a transaction to ensure history can be inserted, and
-	// the prior history can update it's "after" column to point at the new.
-	err = api.Database.InTx(func(db database.Store) error {
-		provisionerJobID := uuid.New()
-		workspaceHistory, err = db.InsertWorkspaceHistory(r.Context(), database.InsertWorkspaceHistoryParams{
-			ID:               uuid.New(),
-			CreatedAt:        database.Now(),
-			UpdatedAt:        database.Now(),
-			WorkspaceID:      workspace.ID,
-			ProjectVersionID: projectVersion.ID,
-			BeforeID:         priorHistoryID,
-			Name:             namesgenerator.GetRandomName(1),
-			Initiator:        user.ID,
-			Transition:       createBuild.Transition,
-			ProvisionJobID:   provisionerJobID,
-		})
-		if err != nil {
-			return xerrors.Errorf("insert workspace history: %w", err)
-		}
-
-		input, err := json.Marshal(workspaceProvisionJob{
-			WorkspaceHistoryID: workspaceHistory.ID,
-		})
-		if err != nil {
-			return xerrors.Errorf("marshal provision job: %w", err)
-		}
-
-		_, err = db.InsertProvisionerJob(r.Context(), database.InsertProvisionerJobParams{
-			ID:             provisionerJobID,
-			CreatedAt:      database.Now(),
-			UpdatedAt:      database.Now(),
-			InitiatorID:    user.ID,
-			OrganizationID: project.OrganizationID,
-			Provisioner:    project.Provisioner,
-			Type:           database.ProvisionerJobTypeWorkspaceProvision,
-			StorageMethod:  projectVersionJob.StorageMethod,
-			StorageSource:  projectVersionJob.StorageSource,
-			Input:          input,
-		})
-		if err != nil {
-			return xerrors.Errorf("insert provisioner job: %w", err)
-		}
-
-		if priorHistoryID.Valid {
-			// Update the prior history entries "after" column.
-			err = db.UpdateWorkspaceHistoryByID(r.Context(), database.UpdateWorkspaceHistoryByIDParams{
-				ID:               priorHistory.ID,
-				ProvisionerState: priorHistory.ProvisionerState,
-				UpdatedAt:        database.Now(),
-				AfterID: uuid.NullUUID{
-					UUID:  workspaceHistory.ID,
-					Valid: true,
-				},
-			})
-			if err != nil {
-				return xerrors.Errorf("update prior workspace history: %w", err)
-			}
-		}
-
-		return nil
-	})
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: err.Error(),
-		})
-		return
-	}
-
-	render.Status(r, http.StatusCreated)
-	render.JSON(rw, r, convertWorkspaceHistory(workspaceHistory))
-}
-
-// Returns all workspace history. This is not sorted. Use before/after to chronologically sort.
-func (api *api) workspaceHistoryByUser(rw http.ResponseWriter, r *http.Request) {
-	workspace := httpmw.WorkspaceParam(r)
-
-	history, err := api.Database.GetWorkspaceHistoryByWorkspaceID(r.Context(), workspace.ID)
-	if errors.Is(err, sql.ErrNoRows) {
-		err = nil
-		history = []database.WorkspaceHistory{}
-	}
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get workspace history: %s", err),
-		})
-		return
-	}
-
-	apiHistory := make([]WorkspaceHistory, 0, len(history))
-	for _, history := range history {
-		apiHistory = append(apiHistory, convertWorkspaceHistory(history))
-	}
-
-	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, apiHistory)
-}
-
-func (*api) workspaceHistoryByName(rw http.ResponseWriter, r *http.Request) {
-	workspaceHistory := httpmw.WorkspaceHistoryParam(r)
-	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, convertWorkspaceHistory(workspaceHistory))
-}
-
-// Converts the internal history representation to a public external-facing model.
-func convertWorkspaceHistory(workspaceHistory database.WorkspaceHistory) WorkspaceHistory {
-	//nolint:unconvert
-	return WorkspaceHistory(WorkspaceHistory{
-		ID:               workspaceHistory.ID,
-		CreatedAt:        workspaceHistory.CreatedAt,
-		UpdatedAt:        workspaceHistory.UpdatedAt,
-		WorkspaceID:      workspaceHistory.WorkspaceID,
-		ProjectVersionID: workspaceHistory.ProjectVersionID,
-		BeforeID:         workspaceHistory.BeforeID.UUID,
-		AfterID:          workspaceHistory.AfterID.UUID,
-		Name:             workspaceHistory.Name,
-		Transition:       workspaceHistory.Transition,
-		Initiator:        workspaceHistory.Initiator,
-		ProvisionJobID:   workspaceHistory.ProvisionJobID,
-	})
-}

coderd/workspacehistory_test.go

@@ -1,166 +0,0 @@
-package coderd_test
-
-import (
-	"context"
-	"net/http"
-	"testing"
-
-	"github.com/google/uuid"
-	"github.com/stretchr/testify/require"
-
-	"github.com/coder/coder/coderd"
-	"github.com/coder/coder/coderd/coderdtest"
-	"github.com/coder/coder/codersdk"
-	"github.com/coder/coder/database"
-	"github.com/coder/coder/provisioner/echo"
-	"github.com/coder/coder/provisionersdk/proto"
-)
-
-func TestPostWorkspaceHistoryByUser(t *testing.T) {
-	t.Parallel()
-	t.Run("NoProjectVersion", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
-		_, err := client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
-			ProjectVersionID: uuid.New(),
-			Transition:       database.WorkspaceTransitionStart,
-		})
-		require.Error(t, err)
-		var apiErr *codersdk.Error
-		require.ErrorAs(t, err, &apiErr)
-		require.Equal(t, http.StatusBadRequest, apiErr.StatusCode())
-	})
-
-	t.Run("ProjectVersionFailedImport", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, &echo.Responses{
-			Provision: []*proto.Provision_Response{{}},
-		})
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
-		_, err := client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
-			ProjectVersionID: project.ActiveVersionID,
-			Transition:       database.WorkspaceTransitionStart,
-		})
-		require.Error(t, err)
-		var apiErr *codersdk.Error
-		require.ErrorAs(t, err, &apiErr)
-		require.Equal(t, http.StatusPreconditionFailed, apiErr.StatusCode())
-	})
-
-	t.Run("AlreadyActive", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		closeDaemon := coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-		// Close here so workspace history doesn't process!
-		closeDaemon.Close()
-		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
-		_, err := client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
-			ProjectVersionID: project.ActiveVersionID,
-			Transition:       database.WorkspaceTransitionStart,
-		})
-		require.NoError(t, err)
-		_, err = client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
-			ProjectVersionID: project.ActiveVersionID,
-			Transition:       database.WorkspaceTransitionStart,
-		})
-		require.Error(t, err)
-		var apiErr *codersdk.Error
-		require.ErrorAs(t, err, &apiErr)
-		require.Equal(t, http.StatusConflict, apiErr.StatusCode())
-	})
-
-	t.Run("UpdatePriorAfterField", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
-		firstHistory, err := client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
-			ProjectVersionID: project.ActiveVersionID,
-			Transition:       database.WorkspaceTransitionStart,
-		})
-		require.NoError(t, err)
-		coderdtest.AwaitWorkspaceProvisionJob(t, client, user.Organization, firstHistory.ProvisionJobID)
-		secondHistory, err := client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
-			ProjectVersionID: project.ActiveVersionID,
-			Transition:       database.WorkspaceTransitionStart,
-		})
-		require.NoError(t, err)
-		require.Equal(t, firstHistory.ID.String(), secondHistory.BeforeID.String())
-
-		firstHistory, err = client.WorkspaceHistory(context.Background(), "", workspace.Name, firstHistory.Name)
-		require.NoError(t, err)
-		require.Equal(t, secondHistory.ID.String(), firstHistory.AfterID.String())
-	})
-}
-
-func TestWorkspaceHistoryByUser(t *testing.T) {
-	t.Parallel()
-	t.Run("ListEmpty", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
-		history, err := client.ListWorkspaceHistory(context.Background(), "me", workspace.Name)
-		require.NoError(t, err)
-		require.NotNil(t, history)
-		require.Len(t, history, 0)
-	})
-
-	t.Run("List", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
-		_, err := client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
-			ProjectVersionID: project.ActiveVersionID,
-			Transition:       database.WorkspaceTransitionStart,
-		})
-		require.NoError(t, err)
-		history, err := client.ListWorkspaceHistory(context.Background(), "me", workspace.Name)
-		require.NoError(t, err)
-		require.NotNil(t, history)
-		require.Len(t, history, 1)
-	})
-}
-
-func TestWorkspaceHistoryByName(t *testing.T) {
-	t.Parallel()
-	client := coderdtest.New(t, nil)
-	user := coderdtest.CreateInitialUser(t, client)
-	coderdtest.NewProvisionerDaemon(t, client)
-	job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-	coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
-	project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-	workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
-	history, err := client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
-		ProjectVersionID: project.ActiveVersionID,
-		Transition:       database.WorkspaceTransitionStart,
-	})
-	require.NoError(t, err)
-	_, err = client.WorkspaceHistory(context.Background(), "me", workspace.Name, history.Name)
-	require.NoError(t, err)
-}

coderd/workspaceresourceauth.go

@@ -28,7 +28,7 @@ type WorkspaceAgentAuthenticateResponse struct {
 // Google Compute Engine supports instance identity verification:
 // https://cloud.google.com/compute/docs/instances/verifying-instance-identity
 // Using this, we can exchange a signed instance payload for an agent token.
-func (api *api) postAuthenticateWorkspaceAgentUsingGoogleInstanceIdentity(rw http.ResponseWriter, r *http.Request) {
+func (api *api) postWorkspaceAuthGoogleInstanceIdentity(rw http.ResponseWriter, r *http.Request) {
 	var req GoogleInstanceIdentityToken
 	if !httpapi.Read(rw, r, &req) {
 		return
@@ -56,7 +56,7 @@ func (api *api) postAuthenticateWorkspaceAgentUsingGoogleInstanceIdentity(rw htt
 		})
 		return
 	}
-	agent, err := api.Database.GetProvisionerJobAgentByInstanceID(r.Context(), claims.Google.ComputeEngine.InstanceID)
+	agent, err := api.Database.GetWorkspaceAgentByInstanceID(r.Context(), claims.Google.ComputeEngine.InstanceID)
 	if errors.Is(err, sql.ErrNoRows) {
 		httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
 			Message: fmt.Sprintf("instance with id %q not found", claims.Google.ComputeEngine.InstanceID),
@@ -69,7 +69,7 @@ func (api *api) postAuthenticateWorkspaceAgentUsingGoogleInstanceIdentity(rw htt
 		})
 		return
 	}
-	resource, err := api.Database.GetProvisionerJobResourceByID(r.Context(), agent.ResourceID)
+	resource, err := api.Database.GetWorkspaceResourceByID(r.Context(), agent.ResourceID)
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
 			Message: fmt.Sprintf("get provisioner job resource: %s", err),
@@ -83,7 +83,7 @@ func (api *api) postAuthenticateWorkspaceAgentUsingGoogleInstanceIdentity(rw htt
 		})
 		return
 	}
-	if job.Type != database.ProvisionerJobTypeWorkspaceProvision {
+	if job.Type != database.ProvisionerJobTypeWorkspaceBuild {
 		httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
 			Message: fmt.Sprintf("%q jobs cannot be authenticated", job.Type),
 		})
@@ -97,20 +97,20 @@ func (api *api) postAuthenticateWorkspaceAgentUsingGoogleInstanceIdentity(rw htt
 		})
 		return
 	}
-	resourceHistory, err := api.Database.GetWorkspaceHistoryByID(r.Context(), jobData.WorkspaceHistoryID)
+	resourceHistory, err := api.Database.GetWorkspaceBuildByID(r.Context(), jobData.WorkspaceBuildID)
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get workspace history: %s", err),
+			Message: fmt.Sprintf("get workspace build: %s", err),
 		})
 		return
 	}
 	// This token should only be exchanged if the instance ID is valid
 	// for the latest history. If an instance ID is recycled by a cloud,
 	// we'd hate to leak access to a user's workspace.
-	latestHistory, err := api.Database.GetWorkspaceHistoryByWorkspaceIDWithoutAfter(r.Context(), resourceHistory.WorkspaceID)
+	latestHistory, err := api.Database.GetWorkspaceBuildByWorkspaceIDWithoutAfter(r.Context(), resourceHistory.WorkspaceID)
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get latest workspace history: %s", err),
+			Message: fmt.Sprintf("get latest workspace build: %s", err),
 		})
 		return
 	}

coderd/workspaceresourceauth_test.go

@@ -28,7 +28,7 @@ import (
 	"github.com/coder/coder/provisionersdk/proto"
 )
 
-func TestPostWorkspaceAgentAuthenticateGoogleInstanceIdentity(t *testing.T) {
+func TestPostWorkspaceAuthGoogleInstanceIdentity(t *testing.T) {
 	t.Parallel()
 	t.Run("Expired", func(t *testing.T) {
 		t.Parallel()
@@ -38,7 +38,7 @@ func TestPostWorkspaceAgentAuthenticateGoogleInstanceIdentity(t *testing.T) {
 		client := coderdtest.New(t, &coderdtest.Options{
 			GoogleTokenValidator: validator,
 		})
-		_, err := client.AuthenticateWorkspaceAgentUsingGoogleCloudIdentity(context.Background(), "", createMetadataClient(signedKey))
+		_, err := client.AuthWorkspaceGoogleInstanceIdentity(context.Background(), "", createMetadataClient(signedKey))
 		var apiErr *codersdk.Error
 		require.ErrorAs(t, err, &apiErr)
 		require.Equal(t, http.StatusUnauthorized, apiErr.StatusCode())
@@ -52,7 +52,7 @@ func TestPostWorkspaceAgentAuthenticateGoogleInstanceIdentity(t *testing.T) {
 		client := coderdtest.New(t, &coderdtest.Options{
 			GoogleTokenValidator: validator,
 		})
-		_, err := client.AuthenticateWorkspaceAgentUsingGoogleCloudIdentity(context.Background(), "", createMetadataClient(signedKey))
+		_, err := client.AuthWorkspaceGoogleInstanceIdentity(context.Background(), "", createMetadataClient(signedKey))
 		var apiErr *codersdk.Error
 		require.ErrorAs(t, err, &apiErr)
 		require.Equal(t, http.StatusNotFound, apiErr.StatusCode())
@@ -66,9 +66,9 @@ func TestPostWorkspaceAgentAuthenticateGoogleInstanceIdentity(t *testing.T) {
 		client := coderdtest.New(t, &coderdtest.Options{
 			GoogleTokenValidator: validator,
 		})
-		user := coderdtest.CreateInitialUser(t, client)
+		user := coderdtest.CreateFirstUser(t, client)
 		coderdtest.NewProvisionerDaemon(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, &echo.Responses{
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, &echo.Responses{
 			Parse: echo.ParseComplete,
 			Provision: []*proto.Provision_Response{{
 				Type: &proto.Provision_Response_Complete{
@@ -88,17 +88,17 @@ func TestPostWorkspaceAgentAuthenticateGoogleInstanceIdentity(t *testing.T) {
 				},
 			}},
 		})
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		coderdtest.AwaitProjectImportJob(t, client, user.Organization, job.ID)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
 		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
-		firstHistory, err := client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
+		build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
 			ProjectVersionID: project.ActiveVersionID,
 			Transition:       database.WorkspaceTransitionStart,
 		})
 		require.NoError(t, err)
-		coderdtest.AwaitWorkspaceProvisionJob(t, client, user.Organization, firstHistory.ProvisionJobID)
+		coderdtest.AwaitWorkspaceBuildJob(t, client, build.ID)
 
-		_, err = client.AuthenticateWorkspaceAgentUsingGoogleCloudIdentity(context.Background(), "", createMetadataClient(signedKey))
+		_, err = client.AuthWorkspaceGoogleInstanceIdentity(context.Background(), "", createMetadataClient(signedKey))
 		require.NoError(t, err)
 	})
 }

coderd/workspaceresources.go

@@ -0,0 +1,236 @@
+package coderd
+
+import (
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"github.com/go-chi/render"
+	"github.com/google/uuid"
+	"github.com/hashicorp/yamux"
+	"golang.org/x/xerrors"
+	"nhooyr.io/websocket"
+
+	"github.com/coder/coder/database"
+	"github.com/coder/coder/httpapi"
+	"github.com/coder/coder/httpmw"
+	"github.com/coder/coder/peerbroker"
+	"github.com/coder/coder/peerbroker/proto"
+	"github.com/coder/coder/provisionersdk"
+)
+
+type WorkspaceResource struct {
+	ID         uuid.UUID                    `json:"id"`
+	CreatedAt  time.Time                    `json:"created_at"`
+	JobID      uuid.UUID                    `json:"job_id"`
+	Transition database.WorkspaceTransition `json:"workspace_transition"`
+	Type       string                       `json:"type"`
+	Name       string                       `json:"name"`
+	Agent      *WorkspaceAgent              `json:"agent,omitempty"`
+}
+
+type WorkspaceAgent struct {
+	ID                   uuid.UUID         `json:"id"`
+	CreatedAt            time.Time         `json:"created_at"`
+	UpdatedAt            time.Time         `json:"updated_at"`
+	ResourceID           uuid.UUID         `json:"resource_id"`
+	InstanceID           string            `json:"instance_id,omitempty"`
+	EnvironmentVariables map[string]string `json:"environment_variables"`
+	StartupScript        string            `json:"startup_script,omitempty"`
+}
+
+type WorkspaceAgentResourceMetadata struct {
+	MemoryTotal uint64  `json:"memory_total"`
+	DiskTotal   uint64  `json:"disk_total"`
+	CPUCores    uint64  `json:"cpu_cores"`
+	CPUModel    string  `json:"cpu_model"`
+	CPUMhz      float64 `json:"cpu_mhz"`
+}
+
+type WorkspaceAgentInstanceMetadata struct {
+	JailOrchestrator   string `json:"jail_orchestrator"`
+	OperatingSystem    string `json:"operating_system"`
+	Platform           string `json:"platform"`
+	PlatformFamily     string `json:"platform_family"`
+	KernelVersion      string `json:"kernel_version"`
+	KernelArchitecture string `json:"kernel_architecture"`
+	Cloud              string `json:"cloud"`
+	Jail               string `json:"jail"`
+	VNC                bool   `json:"vnc"`
+}
+
+func (api *api) workspaceResource(rw http.ResponseWriter, r *http.Request) {
+	workspaceBuild := httpmw.WorkspaceBuildParam(r)
+	workspaceResource := httpmw.WorkspaceResourceParam(r)
+	job, err := api.Database.GetProvisionerJobByID(r.Context(), workspaceBuild.JobID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job: %s", err),
+		})
+		return
+	}
+	if !job.CompletedAt.Valid {
+		httpapi.Write(rw, http.StatusPreconditionFailed, httpapi.Response{
+			Message: "Job hasn't completed!",
+		})
+		return
+	}
+	var apiAgent *WorkspaceAgent
+	if workspaceResource.AgentID.Valid {
+		agent, err := api.Database.GetWorkspaceAgentByResourceID(r.Context(), workspaceResource.ID)
+		if err != nil {
+			httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+				Message: fmt.Sprintf("get provisioner job agent: %s", err),
+			})
+			return
+		}
+		convertedAgent, err := convertWorkspaceAgent(agent)
+		if err != nil {
+			httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+				Message: fmt.Sprintf("convert provisioner job agent: %s", err),
+			})
+			return
+		}
+		apiAgent = &convertedAgent
+	}
+
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, convertWorkspaceResource(workspaceResource, apiAgent))
+}
+
+func (api *api) workspaceResourceDial(rw http.ResponseWriter, r *http.Request) {
+	api.websocketWaitGroup.Add(1)
+	defer api.websocketWaitGroup.Done()
+
+	resource := httpmw.WorkspaceResourceParam(r)
+	if !resource.AgentID.Valid {
+		httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
+			Message: "resource doesn't have an agent",
+		})
+		return
+	}
+	agent, err := api.Database.GetWorkspaceAgentByResourceID(r.Context(), resource.ID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job agent: %s", err),
+		})
+		return
+	}
+	conn, err := websocket.Accept(rw, r, &websocket.AcceptOptions{
+		CompressionMode: websocket.CompressionDisabled,
+	})
+	if err != nil {
+		httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
+			Message: fmt.Sprintf("accept websocket: %s", err),
+		})
+		return
+	}
+	defer func() {
+		_ = conn.Close(websocket.StatusNormalClosure, "")
+	}()
+	config := yamux.DefaultConfig()
+	config.LogOutput = io.Discard
+	session, err := yamux.Server(websocket.NetConn(r.Context(), conn, websocket.MessageBinary), config)
+	if err != nil {
+		_ = conn.Close(websocket.StatusAbnormalClosure, err.Error())
+		return
+	}
+	err = peerbroker.ProxyListen(r.Context(), session, peerbroker.ProxyOptions{
+		ChannelID: agent.ID.String(),
+		Logger:    api.Logger.Named("peerbroker-proxy-dial"),
+		Pubsub:    api.Pubsub,
+	})
+	if err != nil {
+		_ = conn.Close(websocket.StatusInternalError, fmt.Sprintf("serve: %s", err))
+		return
+	}
+}
+
+func (api *api) workspaceAgentListen(rw http.ResponseWriter, r *http.Request) {
+	api.websocketWaitGroup.Add(1)
+	defer api.websocketWaitGroup.Done()
+
+	agent := httpmw.WorkspaceAgent(r)
+	conn, err := websocket.Accept(rw, r, &websocket.AcceptOptions{
+		CompressionMode: websocket.CompressionDisabled,
+	})
+	if err != nil {
+		httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
+			Message: fmt.Sprintf("accept websocket: %s", err),
+		})
+		return
+	}
+	defer func() {
+		_ = conn.Close(websocket.StatusNormalClosure, "")
+	}()
+	config := yamux.DefaultConfig()
+	config.LogOutput = io.Discard
+	session, err := yamux.Server(websocket.NetConn(r.Context(), conn, websocket.MessageBinary), config)
+	if err != nil {
+		_ = conn.Close(websocket.StatusAbnormalClosure, err.Error())
+		return
+	}
+	closer, err := peerbroker.ProxyDial(proto.NewDRPCPeerBrokerClient(provisionersdk.Conn(session)), peerbroker.ProxyOptions{
+		ChannelID: agent.ID.String(),
+		Pubsub:    api.Pubsub,
+		Logger:    api.Logger.Named("peerbroker-proxy-listen"),
+	})
+	if err != nil {
+		_ = conn.Close(websocket.StatusAbnormalClosure, err.Error())
+		return
+	}
+	defer closer.Close()
+	err = api.Database.UpdateWorkspaceAgentByID(r.Context(), database.UpdateWorkspaceAgentByIDParams{
+		ID: agent.ID,
+		UpdatedAt: sql.NullTime{
+			Time:  database.Now(),
+			Valid: true,
+		},
+	})
+	if err != nil {
+		_ = conn.Close(websocket.StatusAbnormalClosure, err.Error())
+		return
+	}
+	ticker := time.NewTicker(5 * time.Second)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-session.CloseChan():
+			return
+		case <-ticker.C:
+			err = api.Database.UpdateWorkspaceAgentByID(r.Context(), database.UpdateWorkspaceAgentByIDParams{
+				ID: agent.ID,
+				UpdatedAt: sql.NullTime{
+					Time:  database.Now(),
+					Valid: true,
+				},
+			})
+			if err != nil {
+				_ = conn.Close(websocket.StatusAbnormalClosure, err.Error())
+				return
+			}
+		}
+	}
+}
+
+func convertWorkspaceAgent(agent database.WorkspaceAgent) (WorkspaceAgent, error) {
+	var envs map[string]string
+	if agent.EnvironmentVariables.Valid {
+		err := json.Unmarshal(agent.EnvironmentVariables.RawMessage, &envs)
+		if err != nil {
+			return WorkspaceAgent{}, xerrors.Errorf("unmarshal: %w", err)
+		}
+	}
+	return WorkspaceAgent{
+		ID:                   agent.ID,
+		CreatedAt:            agent.CreatedAt,
+		UpdatedAt:            agent.UpdatedAt.Time,
+		ResourceID:           agent.ResourceID,
+		InstanceID:           agent.AuthInstanceID.String,
+		StartupScript:        agent.StartupScript.String,
+		EnvironmentVariables: envs,
+	}, nil
+}

coderd/workspaceresources_test.go

@@ -0,0 +1,126 @@
+package coderd_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/require"
+
+	"cdr.dev/slog"
+	"cdr.dev/slog/sloggers/slogtest"
+
+	"github.com/coder/coder/agent"
+	"github.com/coder/coder/coderd"
+	"github.com/coder/coder/coderd/coderdtest"
+	"github.com/coder/coder/codersdk"
+	"github.com/coder/coder/database"
+	"github.com/coder/coder/peer"
+	"github.com/coder/coder/peerbroker"
+	"github.com/coder/coder/provisioner/echo"
+	"github.com/coder/coder/provisionersdk/proto"
+)
+
+func TestWorkspaceResource(t *testing.T) {
+	t.Parallel()
+	t.Run("Get", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		coderdtest.NewProvisionerDaemon(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, &echo.Responses{
+			Parse: echo.ParseComplete,
+			Provision: []*proto.Provision_Response{{
+				Type: &proto.Provision_Response_Complete{
+					Complete: &proto.Provision_Complete{
+						Resources: []*proto.Resource{{
+							Name: "some",
+							Type: "example",
+							Agent: &proto.Agent{
+								Id:   "something",
+								Auth: &proto.Agent_Token{},
+							},
+						}},
+					},
+				},
+			}},
+		})
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		workspace := coderdtest.CreateWorkspace(t, client, "", project.ID)
+		build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+			ProjectVersionID: project.ActiveVersionID,
+			Transition:       database.WorkspaceTransitionStart,
+		})
+		require.NoError(t, err)
+		coderdtest.AwaitWorkspaceBuildJob(t, client, build.ID)
+		resources, err := client.WorkspaceResourcesByBuild(context.Background(), build.ID)
+		require.NoError(t, err)
+		_, err = client.WorkspaceResource(context.Background(), resources[0].ID)
+		require.NoError(t, err)
+	})
+}
+
+func TestWorkspaceAgentListen(t *testing.T) {
+	t.Parallel()
+	client := coderdtest.New(t, nil)
+	user := coderdtest.CreateFirstUser(t, client)
+	daemonCloser := coderdtest.NewProvisionerDaemon(t, client)
+	authToken := uuid.NewString()
+	version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, &echo.Responses{
+		Parse:           echo.ParseComplete,
+		ProvisionDryRun: echo.ProvisionComplete,
+		Provision: []*proto.Provision_Response{{
+			Type: &proto.Provision_Response_Complete{
+				Complete: &proto.Provision_Complete{
+					Resources: []*proto.Resource{{
+						Name: "example",
+						Type: "aws_instance",
+						Agent: &proto.Agent{
+							Id: uuid.NewString(),
+							Auth: &proto.Agent_Token{
+								Token: authToken,
+							},
+						},
+					}},
+				},
+			},
+		}},
+	})
+	project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+	coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+	workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
+	build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+		ProjectVersionID: project.ActiveVersionID,
+		Transition:       database.WorkspaceTransitionStart,
+	})
+	require.NoError(t, err)
+	coderdtest.AwaitWorkspaceBuildJob(t, client, build.ID)
+	daemonCloser.Close()
+
+	agentClient := codersdk.New(client.URL)
+	agentClient.SessionToken = authToken
+	agentCloser := agent.New(agentClient.ListenWorkspaceAgent, &peer.ConnOptions{
+		Logger: slogtest.Make(t, nil),
+	})
+	t.Cleanup(func() {
+		_ = agentCloser.Close()
+	})
+	resources := coderdtest.AwaitWorkspaceAgents(t, client, build.ID)
+	workspaceClient, err := client.DialWorkspaceAgent(context.Background(), resources[0].ID)
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		_ = workspaceClient.DRPCConn().Close()
+	})
+	stream, err := workspaceClient.NegotiateConnection(context.Background())
+	require.NoError(t, err)
+	conn, err := peerbroker.Dial(stream, nil, &peer.ConnOptions{
+		Logger: slogtest.Make(t, nil).Named("client").Leveled(slog.LevelDebug),
+	})
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		_ = conn.Close()
+	})
+	_, err = conn.Ping()
+	require.NoError(t, err)
+}

coderd/workspaces.go

@@ -2,12 +2,16 @@ package coderd
 
 import (
 	"database/sql"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
 
+	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/render"
 	"github.com/google/uuid"
+	"github.com/moby/moby/pkg/namesgenerator"
+	"golang.org/x/xerrors"
 
 	"github.com/coder/coder/database"
 	"github.com/coder/coder/httpapi"
@@ -18,160 +22,268 @@ import (
 // project versions, and can be updated.
 type Workspace database.Workspace
 
-// CreateWorkspaceRequest provides options for creating a new workspace.
-type CreateWorkspaceRequest struct {
-	ProjectID uuid.UUID `json:"project_id" validate:"required"`
-	Name      string    `json:"name" validate:"username,required"`
+// CreateWorkspaceBuildRequest provides options to update the latest workspace build.
+type CreateWorkspaceBuildRequest struct {
+	ProjectVersionID uuid.UUID                    `json:"project_version_id" validate:"required"`
+	Transition       database.WorkspaceTransition `json:"transition" validate:"oneof=create start stop delete,required"`
 }
 
-// Returns all workspaces across all projects and organizations.
-func (api *api) workspaces(rw http.ResponseWriter, r *http.Request) {
-	apiKey := httpmw.APIKey(r)
-	workspaces, err := api.Database.GetWorkspacesByUserID(r.Context(), apiKey.UserID)
-	if errors.Is(err, sql.ErrNoRows) {
-		err = nil
+func (*api) workspace(rw http.ResponseWriter, r *http.Request) {
+	workspace := httpmw.WorkspaceParam(r)
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, convertWorkspace(workspace))
+}
+
+func (api *api) workspaceBuilds(rw http.ResponseWriter, r *http.Request) {
+	workspace := httpmw.WorkspaceParam(r)
+
+	builds, err := api.Database.GetWorkspaceBuildByWorkspaceID(r.Context(), workspace.ID)
+	if err != nil {
+		return
 	}
+	jobIDs := make([]uuid.UUID, 0, len(builds))
+	for _, version := range builds {
+		jobIDs = append(jobIDs, version.JobID)
+	}
+	jobs, err := api.Database.GetProvisionerJobsByIDs(r.Context(), jobIDs)
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get workspaces: %s", err),
+			Message: fmt.Sprintf("get jobs: %s", err),
 		})
 		return
 	}
-
-	apiWorkspaces := make([]Workspace, 0, len(workspaces))
-	for _, workspace := range workspaces {
-		apiWorkspaces = append(apiWorkspaces, convertWorkspace(workspace))
+	jobByID := map[string]database.ProvisionerJob{}
+	for _, job := range jobs {
+		jobByID[job.ID.String()] = job
 	}
+
+	apiBuilds := make([]WorkspaceBuild, 0)
+	for _, build := range builds {
+		job, exists := jobByID[build.JobID.String()]
+		if !exists {
+			httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+				Message: fmt.Sprintf("job %q doesn't exist for build %q", build.JobID, build.ID),
+			})
+			return
+		}
+		apiBuilds = append(apiBuilds, convertWorkspaceBuild(build, convertProvisionerJob(job)))
+	}
+
 	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, apiWorkspaces)
+	render.JSON(rw, r, apiBuilds)
 }
 
-// Create a new workspace for the currently authenticated user.
-func (api *api) postWorkspaceByUser(rw http.ResponseWriter, r *http.Request) {
-	var createWorkspace CreateWorkspaceRequest
-	if !httpapi.Read(rw, r, &createWorkspace) {
+func (api *api) postWorkspaceBuilds(rw http.ResponseWriter, r *http.Request) {
+	apiKey := httpmw.APIKey(r)
+	workspace := httpmw.WorkspaceParam(r)
+	var createBuild CreateWorkspaceBuildRequest
+	if !httpapi.Read(rw, r, &createBuild) {
 		return
 	}
-	apiKey := httpmw.APIKey(r)
-	project, err := api.Database.GetProjectByID(r.Context(), createWorkspace.ProjectID)
+	projectVersion, err := api.Database.GetProjectVersionByID(r.Context(), createBuild.ProjectVersionID)
 	if errors.Is(err, sql.ErrNoRows) {
 		httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
-			Message: fmt.Sprintf("project %q doesn't exist", createWorkspace.ProjectID.String()),
+			Message: "project version not found",
 			Errors: []httpapi.Error{{
-				Field: "project_id",
-				Code:  "not_found",
+				Field: "project_version_id",
+				Code:  "exists",
 			}},
 		})
 		return
 	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get project version: %s", err),
+		})
+		return
+	}
+	projectVersionJob, err := api.Database.GetProvisionerJobByID(r.Context(), projectVersion.JobID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job: %s", err),
+		})
+		return
+	}
+	projectVersionJobStatus := convertProvisionerJob(projectVersionJob).Status
+	switch projectVersionJobStatus {
+	case ProvisionerJobPending, ProvisionerJobRunning:
+		httpapi.Write(rw, http.StatusNotAcceptable, httpapi.Response{
+			Message: fmt.Sprintf("The provided project version is %s. Wait for it to complete importing!", projectVersionJobStatus),
+		})
+		return
+	case ProvisionerJobFailed:
+		httpapi.Write(rw, http.StatusPreconditionFailed, httpapi.Response{
+			Message: fmt.Sprintf("The provided project version %q has failed to import. You cannot create workspaces using it!", projectVersion.Name),
+		})
+		return
+	case ProvisionerJobCancelled:
+		httpapi.Write(rw, http.StatusPreconditionFailed, httpapi.Response{
+			Message: "The provided project version was canceled during import. You cannot create workspaces using it!",
+		})
+		return
+	}
+
+	project, err := api.Database.GetProjectByID(r.Context(), projectVersion.ProjectID.UUID)
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
 			Message: fmt.Sprintf("get project: %s", err),
 		})
 		return
 	}
-	_, err = api.Database.GetOrganizationMemberByUserID(r.Context(), database.GetOrganizationMemberByUserIDParams{
-		OrganizationID: project.OrganizationID,
-		UserID:         apiKey.UserID,
-	})
-	if errors.Is(err, sql.ErrNoRows) {
-		httpapi.Write(rw, http.StatusUnauthorized, httpapi.Response{
-			Message: "you aren't allowed to access projects in that organization",
-		})
-		return
-	}
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get organization member: %s", err),
-		})
-		return
-	}
 
-	workspace, err := api.Database.GetWorkspaceByUserIDAndName(r.Context(), database.GetWorkspaceByUserIDAndNameParams{
-		OwnerID: apiKey.UserID,
-		Name:    createWorkspace.Name,
-	})
+	// Store prior history ID if it exists to update it after we create new!
+	priorHistoryID := uuid.NullUUID{}
+	priorHistory, err := api.Database.GetWorkspaceBuildByWorkspaceIDWithoutAfter(r.Context(), workspace.ID)
 	if err == nil {
-		// If the workspace already exists, don't allow creation.
-		project, err := api.Database.GetProjectByID(r.Context(), workspace.ProjectID)
-		if err != nil {
-			httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-				Message: fmt.Sprintf("find project for conflicting workspace name %q: %s", createWorkspace.Name, err),
+		priorJob, err := api.Database.GetProvisionerJobByID(r.Context(), priorHistory.JobID)
+		if err == nil && !priorJob.CompletedAt.Valid {
+			httpapi.Write(rw, http.StatusConflict, httpapi.Response{
+				Message: "a workspace build is already active",
 			})
 			return
 		}
-		// The project is fetched for clarity to the user on where the conflicting name may be.
-		httpapi.Write(rw, http.StatusConflict, httpapi.Response{
-			Message: fmt.Sprintf("workspace %q already exists in the %q project", createWorkspace.Name, project.Name),
-			Errors: []httpapi.Error{{
-				Field: "name",
-				Code:  "exists",
-			}},
-		})
-		return
-	}
-	if !errors.Is(err, sql.ErrNoRows) {
+
+		priorHistoryID = uuid.NullUUID{
+			UUID:  priorHistory.ID,
+			Valid: true,
+		}
+	} else if !errors.Is(err, sql.ErrNoRows) {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get workspace by name: %s", err.Error()),
+			Message: fmt.Sprintf("get prior workspace build: %s", err),
 		})
 		return
 	}
 
-	// Workspaces are created without any versions.
-	workspace, err = api.Database.InsertWorkspace(r.Context(), database.InsertWorkspaceParams{
-		ID:        uuid.New(),
-		CreatedAt: database.Now(),
-		UpdatedAt: database.Now(),
-		OwnerID:   apiKey.UserID,
-		ProjectID: project.ID,
-		Name:      createWorkspace.Name,
+	var workspaceBuild database.WorkspaceBuild
+	var provisionerJob database.ProvisionerJob
+	// This must happen in a transaction to ensure history can be inserted, and
+	// the prior history can update it's "after" column to point at the new.
+	err = api.Database.InTx(func(db database.Store) error {
+		workspaceBuildID := uuid.New()
+		input, err := json.Marshal(workspaceProvisionJob{
+			WorkspaceBuildID: workspaceBuildID,
+		})
+		if err != nil {
+			return xerrors.Errorf("marshal provision job: %w", err)
+		}
+		provisionerJob, err = db.InsertProvisionerJob(r.Context(), database.InsertProvisionerJobParams{
+			ID:             uuid.New(),
+			CreatedAt:      database.Now(),
+			UpdatedAt:      database.Now(),
+			InitiatorID:    apiKey.UserID,
+			OrganizationID: project.OrganizationID,
+			Provisioner:    project.Provisioner,
+			Type:           database.ProvisionerJobTypeWorkspaceBuild,
+			StorageMethod:  projectVersionJob.StorageMethod,
+			StorageSource:  projectVersionJob.StorageSource,
+			Input:          input,
+		})
+		if err != nil {
+			return xerrors.Errorf("insert provisioner job: %w", err)
+		}
+		workspaceBuild, err = db.InsertWorkspaceBuild(r.Context(), database.InsertWorkspaceBuildParams{
+			ID:               workspaceBuildID,
+			CreatedAt:        database.Now(),
+			UpdatedAt:        database.Now(),
+			WorkspaceID:      workspace.ID,
+			ProjectVersionID: projectVersion.ID,
+			BeforeID:         priorHistoryID,
+			Name:             namesgenerator.GetRandomName(1),
+			Initiator:        apiKey.UserID,
+			Transition:       createBuild.Transition,
+			JobID:            provisionerJob.ID,
+		})
+		if err != nil {
+			return xerrors.Errorf("insert workspace build: %w", err)
+		}
+
+		if priorHistoryID.Valid {
+			// Update the prior history entries "after" column.
+			err = db.UpdateWorkspaceBuildByID(r.Context(), database.UpdateWorkspaceBuildByIDParams{
+				ID:               priorHistory.ID,
+				ProvisionerState: priorHistory.ProvisionerState,
+				UpdatedAt:        database.Now(),
+				AfterID: uuid.NullUUID{
+					UUID:  workspaceBuild.ID,
+					Valid: true,
+				},
+			})
+			if err != nil {
+				return xerrors.Errorf("update prior workspace build: %w", err)
+			}
+		}
+
+		return nil
 	})
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("insert workspace: %s", err),
+			Message: err.Error(),
 		})
 		return
 	}
 
 	render.Status(r, http.StatusCreated)
-	render.JSON(rw, r, convertWorkspace(workspace))
+	render.JSON(rw, r, convertWorkspaceBuild(workspaceBuild, convertProvisionerJob(provisionerJob)))
 }
 
-// Returns a single workspace.
-func (*api) workspaceByUser(rw http.ResponseWriter, r *http.Request) {
+func (api *api) workspaceBuildLatest(rw http.ResponseWriter, r *http.Request) {
 	workspace := httpmw.WorkspaceParam(r)
-
-	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, convertWorkspace(workspace))
-}
-
-// Returns all workspaces for a specific project.
-func (api *api) workspacesByProject(rw http.ResponseWriter, r *http.Request) {
-	apiKey := httpmw.APIKey(r)
-	project := httpmw.ProjectParam(r)
-	workspaces, err := api.Database.GetWorkspacesByProjectAndUserID(r.Context(), database.GetWorkspacesByProjectAndUserIDParams{
-		OwnerID:   apiKey.UserID,
-		ProjectID: project.ID,
-	})
+	workspaceBuild, err := api.Database.GetWorkspaceBuildByWorkspaceIDWithoutAfter(r.Context(), workspace.ID)
 	if errors.Is(err, sql.ErrNoRows) {
-		err = nil
+		httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
+			Message: "no workspace build found",
+		})
+		return
 	}
 	if err != nil {
 		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get workspaces: %s", err),
+			Message: fmt.Sprintf("get workspace build by name: %s", err),
+		})
+		return
+	}
+	job, err := api.Database.GetProvisionerJobByID(r.Context(), workspaceBuild.JobID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job: %s", err),
 		})
 		return
 	}
 
-	apiWorkspaces := make([]Workspace, 0, len(workspaces))
-	for _, workspace := range workspaces {
-		apiWorkspaces = append(apiWorkspaces, convertWorkspace(workspace))
-	}
 	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, apiWorkspaces)
+	render.JSON(rw, r, convertWorkspaceBuild(workspaceBuild, convertProvisionerJob(job)))
+}
+
+func (api *api) workspaceBuildByName(rw http.ResponseWriter, r *http.Request) {
+	workspace := httpmw.WorkspaceParam(r)
+	workspaceBuildName := chi.URLParam(r, "workspacebuildname")
+	workspaceBuild, err := api.Database.GetWorkspaceBuildByWorkspaceIDAndName(r.Context(), database.GetWorkspaceBuildByWorkspaceIDAndNameParams{
+		WorkspaceID: workspace.ID,
+		Name:        workspaceBuildName,
+	})
+	if errors.Is(err, sql.ErrNoRows) {
+		httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
+			Message: fmt.Sprintf("no workspace build found by name %q", workspaceBuildName),
+		})
+		return
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get workspace build by name: %s", err),
+		})
+		return
+	}
+	job, err := api.Database.GetProvisionerJobByID(r.Context(), workspaceBuild.JobID)
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner job: %s", err),
+		})
+		return
+	}
+
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, convertWorkspaceBuild(workspaceBuild, convertProvisionerJob(job)))
 }
 
-// Converts the internal workspace representation to a public external-facing model.
 func convertWorkspace(workspace database.Workspace) Workspace {
 	return Workspace(workspace)
 }

coderd/workspaces_test.go

@@ -11,42 +11,34 @@ import (
 	"github.com/coder/coder/coderd"
 	"github.com/coder/coder/coderd/coderdtest"
 	"github.com/coder/coder/codersdk"
+	"github.com/coder/coder/database"
+	"github.com/coder/coder/provisioner/echo"
+	"github.com/coder/coder/provisionersdk/proto"
 )
 
-func TestWorkspaces(t *testing.T) {
+func TestWorkspace(t *testing.T) {
 	t.Parallel()
-	t.Run("ListNone", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		_ = coderdtest.CreateInitialUser(t, client)
-		workspaces, err := client.Workspaces(context.Background(), "")
-		require.NoError(t, err)
-		require.NotNil(t, workspaces)
-		require.Len(t, workspaces, 0)
-	})
-
-	t.Run("List", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		_ = coderdtest.CreateWorkspace(t, client, "", project.ID)
-		workspaces, err := client.Workspaces(context.Background(), "")
-		require.NoError(t, err)
-		require.Len(t, workspaces, 1)
-	})
+	client := coderdtest.New(t, nil)
+	user := coderdtest.CreateFirstUser(t, client)
+	job := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+	project := coderdtest.CreateProject(t, client, user.OrganizationID, job.ID)
+	workspace := coderdtest.CreateWorkspace(t, client, "", project.ID)
+	_, err := client.Workspace(context.Background(), workspace.ID)
+	require.NoError(t, err)
 }
 
-func TestPostWorkspaceByUser(t *testing.T) {
+func TestPostWorkspaceBuild(t *testing.T) {
 	t.Parallel()
-	t.Run("InvalidProject", func(t *testing.T) {
+	t.Run("NoProjectVersion", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		_ = coderdtest.CreateInitialUser(t, client)
-		_, err := client.CreateWorkspace(context.Background(), "", coderd.CreateWorkspaceRequest{
-			ProjectID: uuid.New(),
-			Name:      "workspace",
+		user := coderdtest.CreateFirstUser(t, client)
+		job := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, job.ID)
+		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
+		_, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+			ProjectVersionID: uuid.New(),
+			Transition:       database.WorkspaceTransitionStart,
 		})
 		require.Error(t, err)
 		var apiErr *codersdk.Error
@@ -54,48 +46,46 @@ func TestPostWorkspaceByUser(t *testing.T) {
 		require.Equal(t, http.StatusBadRequest, apiErr.StatusCode())
 	})
 
-	t.Run("NoProjectAccess", func(t *testing.T) {
+	t.Run("ProjectVersionFailedImport", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-
-		anotherUser := coderd.CreateUserRequest{
-			Email:    "another@user.org",
-			Username: "someuser",
-			Password: "somepass",
-		}
-		_, err := client.CreateUser(context.Background(), anotherUser)
-		require.NoError(t, err)
-		token, err := client.LoginWithPassword(context.Background(), coderd.LoginWithPasswordRequest{
-			Email:    anotherUser.Email,
-			Password: anotherUser.Password,
+		user := coderdtest.CreateFirstUser(t, client)
+		coderdtest.NewProvisionerDaemon(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, &echo.Responses{
+			Provision: []*proto.Provision_Response{{}},
 		})
-		require.NoError(t, err)
-		client.SessionToken = token.SessionToken
-		require.NoError(t, err)
-
-		_, err = client.CreateWorkspace(context.Background(), "", coderd.CreateWorkspaceRequest{
-			ProjectID: project.ID,
-			Name:      "workspace",
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
+		_, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+			ProjectVersionID: project.ActiveVersionID,
+			Transition:       database.WorkspaceTransitionStart,
 		})
 		require.Error(t, err)
 		var apiErr *codersdk.Error
 		require.ErrorAs(t, err, &apiErr)
-		require.Equal(t, http.StatusUnauthorized, apiErr.StatusCode())
+		require.Equal(t, http.StatusPreconditionFailed, apiErr.StatusCode())
 	})
 
-	t.Run("AlreadyExists", func(t *testing.T) {
+	t.Run("AlreadyActive", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		workspace := coderdtest.CreateWorkspace(t, client, "", project.ID)
-		_, err := client.CreateWorkspace(context.Background(), "", coderd.CreateWorkspaceRequest{
-			ProjectID: project.ID,
-			Name:      workspace.Name,
+		user := coderdtest.CreateFirstUser(t, client)
+		closeDaemon := coderdtest.NewProvisionerDaemon(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+		// Close here so workspace build doesn't process!
+		closeDaemon.Close()
+		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
+		_, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+			ProjectVersionID: project.ActiveVersionID,
+			Transition:       database.WorkspaceTransitionStart,
+		})
+		require.NoError(t, err)
+		_, err = client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+			ProjectVersionID: project.ActiveVersionID,
+			Transition:       database.WorkspaceTransitionStart,
 		})
 		require.Error(t, err)
 		var apiErr *codersdk.Error
@@ -103,50 +93,102 @@ func TestPostWorkspaceByUser(t *testing.T) {
 		require.Equal(t, http.StatusConflict, apiErr.StatusCode())
 	})
 
-	t.Run("Create", func(t *testing.T) {
+	t.Run("UpdatePriorAfterField", func(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		_ = coderdtest.CreateWorkspace(t, client, "", project.ID)
-	})
-}
-
-func TestWorkspaceByUser(t *testing.T) {
-	t.Parallel()
-	client := coderdtest.New(t, nil)
-	user := coderdtest.CreateInitialUser(t, client)
-	job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-	project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-	workspace := coderdtest.CreateWorkspace(t, client, "", project.ID)
-	_, err := client.Workspace(context.Background(), "", workspace.Name)
-	require.NoError(t, err)
-}
-
-func TestWorkspacesByProject(t *testing.T) {
-	t.Parallel()
-	t.Run("ListEmpty", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		workspaces, err := client.WorkspacesByProject(context.Background(), user.Organization, project.Name)
+		user := coderdtest.CreateFirstUser(t, client)
+		coderdtest.NewProvisionerDaemon(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
+		firstBuild, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+			ProjectVersionID: project.ActiveVersionID,
+			Transition:       database.WorkspaceTransitionStart,
+		})
 		require.NoError(t, err)
-		require.NotNil(t, workspaces)
-	})
-
-	t.Run("List", func(t *testing.T) {
-		t.Parallel()
-		client := coderdtest.New(t, nil)
-		user := coderdtest.CreateInitialUser(t, client)
-		job := coderdtest.CreateProjectImportJob(t, client, user.Organization, nil)
-		project := coderdtest.CreateProject(t, client, user.Organization, job.ID)
-		_ = coderdtest.CreateWorkspace(t, client, "", project.ID)
-		workspaces, err := client.WorkspacesByProject(context.Background(), user.Organization, project.Name)
+		coderdtest.AwaitWorkspaceBuildJob(t, client, firstBuild.ID)
+		secondBuild, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+			ProjectVersionID: project.ActiveVersionID,
+			Transition:       database.WorkspaceTransitionStart,
+		})
+		require.NoError(t, err)
+		require.Equal(t, firstBuild.ID.String(), secondBuild.BeforeID.String())
+
+		firstBuild, err = client.WorkspaceBuild(context.Background(), firstBuild.ID)
+		require.NoError(t, err)
+		require.Equal(t, secondBuild.ID.String(), firstBuild.AfterID.String())
+	})
+}
+
+func TestWorkspaceBuildLatest(t *testing.T) {
+	t.Parallel()
+	t.Run("None", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		coderdtest.NewProvisionerDaemon(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
+		_, err := client.WorkspaceBuildLatest(context.Background(), workspace.ID)
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusNotFound, apiErr.StatusCode())
+	})
+
+	t.Run("Found", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		coderdtest.NewProvisionerDaemon(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
+		_, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+			ProjectVersionID: project.ActiveVersionID,
+			Transition:       database.WorkspaceTransitionStart,
+		})
+		require.NoError(t, err)
+		_, err = client.WorkspaceBuildLatest(context.Background(), workspace.ID)
+		require.NoError(t, err)
+	})
+}
+
+func TestWorkspaceBuildByName(t *testing.T) {
+	t.Parallel()
+	t.Run("NotFound", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		coderdtest.NewProvisionerDaemon(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
+		_, err := client.WorkspaceBuildByName(context.Background(), workspace.ID, "something")
+		var apiErr *codersdk.Error
+		require.ErrorAs(t, err, &apiErr)
+		require.Equal(t, http.StatusNotFound, apiErr.StatusCode())
+	})
+
+	t.Run("Found", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, nil)
+		user := coderdtest.CreateFirstUser(t, client)
+		coderdtest.NewProvisionerDaemon(t, client)
+		version := coderdtest.CreateProjectVersion(t, client, user.OrganizationID, nil)
+		coderdtest.AwaitProjectVersionJob(t, client, version.ID)
+		project := coderdtest.CreateProject(t, client, user.OrganizationID, version.ID)
+		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
+		build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, coderd.CreateWorkspaceBuildRequest{
+			ProjectVersionID: project.ActiveVersionID,
+			Transition:       database.WorkspaceTransitionStart,
+		})
+		require.NoError(t, err)
+		_, err = client.WorkspaceBuildByName(context.Background(), workspace.ID, build.Name)
 		require.NoError(t, err)
-		require.NotNil(t, workspaces)
-		require.Len(t, workspaces, 1)
 	})
 }