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

codersdk/users.go

@@ -9,10 +9,9 @@ import (
 	"github.com/coder/coder/coderd"
 )
 
-// HasInitialUser returns whether the initial user has already been
-// created or not.
-func (c *Client) HasInitialUser(ctx context.Context) (bool, error) {
-	res, err := c.request(ctx, http.MethodGet, "/api/v2/user", nil)
+// HasFirstUser returns whether the first user has been created.
+func (c *Client) HasFirstUser(ctx context.Context) (bool, error) {
+	res, err := c.request(ctx, http.MethodGet, "/api/v2/users/first", nil)
 	if err != nil {
 		return false, err
 	}
@@ -26,20 +25,19 @@ func (c *Client) HasInitialUser(ctx context.Context) (bool, error) {
 	return true, nil
 }
 
-// CreateInitialUser attempts to create the first user on a Coder deployment.
-// This initial user has superadmin privileges. If >0 users exist, this request
-// will fail.
-func (c *Client) CreateInitialUser(ctx context.Context, req coderd.CreateInitialUserRequest) (coderd.User, error) {
-	res, err := c.request(ctx, http.MethodPost, "/api/v2/user", req)
+// CreateFirstUser attempts to create the first user on a Coder deployment.
+// This initial user has superadmin privileges. If >0 users exist, this request will fail.
+func (c *Client) CreateFirstUser(ctx context.Context, req coderd.CreateFirstUserRequest) (coderd.CreateFirstUserResponse, error) {
+	res, err := c.request(ctx, http.MethodPost, "/api/v2/users/first", req)
 	if err != nil {
-		return coderd.User{}, err
+		return coderd.CreateFirstUserResponse{}, err
 	}
 	defer res.Body.Close()
 	if res.StatusCode != http.StatusCreated {
-		return coderd.User{}, readBodyAsError(res)
+		return coderd.CreateFirstUserResponse{}, readBodyAsError(res)
 	}
-	var user coderd.User
-	return user, json.NewDecoder(res.Body).Decode(&user)
+	var resp coderd.CreateFirstUserResponse
+	return resp, json.NewDecoder(res.Body).Decode(&resp)
 }
 
 // CreateUser creates a new user.
@@ -56,9 +54,12 @@ func (c *Client) CreateUser(ctx context.Context, req coderd.CreateUserRequest) (
 	return user, json.NewDecoder(res.Body).Decode(&user)
 }
 
-// CreateAPIKey calls the /api-key API
-func (c *Client) CreateAPIKey(ctx context.Context) (*coderd.GenerateAPIKeyResponse, error) {
-	res, err := c.request(ctx, http.MethodPost, "/api/v2/users/me/keys", nil)
+// CreateAPIKey generates an API key for the user ID provided.
+func (c *Client) CreateAPIKey(ctx context.Context, id string) (*coderd.GenerateAPIKeyResponse, error) {
+	if id == "" {
+		id = "me"
+	}
+	res, err := c.request(ctx, http.MethodPost, fmt.Sprintf("/api/v2/users/%s/keys", id), nil)
 	if err != nil {
 		return nil, err
 	}
@@ -73,7 +74,7 @@ func (c *Client) CreateAPIKey(ctx context.Context) (*coderd.GenerateAPIKeyRespon
 // LoginWithPassword creates a session token authenticating with an email and password.
 // Call `SetSessionToken()` to apply the newly acquired token to the client.
 func (c *Client) LoginWithPassword(ctx context.Context, req coderd.LoginWithPasswordRequest) (coderd.LoginWithPasswordResponse, error) {
-	res, err := c.request(ctx, http.MethodPost, "/api/v2/login", req)
+	res, err := c.request(ctx, http.MethodPost, "/api/v2/users/login", req)
 	if err != nil {
 		return coderd.LoginWithPasswordResponse{}, err
 	}
@@ -94,7 +95,7 @@ func (c *Client) LoginWithPassword(ctx context.Context, req coderd.LoginWithPass
 func (c *Client) Logout(ctx context.Context) error {
 	// Since `LoginWithPassword` doesn't actually set a SessionToken
 	// (it requires a call to SetSessionToken), this is essentially a no-op
-	res, err := c.request(ctx, http.MethodPost, "/api/v2/logout", nil)
+	res, err := c.request(ctx, http.MethodPost, "/api/v2/users/logout", nil)
 	if err != nil {
 		return err
 	}
@@ -120,8 +121,8 @@ func (c *Client) User(ctx context.Context, id string) (coderd.User, error) {
 	return user, json.NewDecoder(res.Body).Decode(&user)
 }
 
-// UserOrganizations fetches organizations a user is part of.
-func (c *Client) UserOrganizations(ctx context.Context, id string) ([]coderd.Organization, error) {
+// OrganizationsByUser returns all organizations the user is a member of.
+func (c *Client) OrganizationsByUser(ctx context.Context, id string) ([]coderd.Organization, error) {
 	if id == "" {
 		id = "me"
 	}
@@ -130,9 +131,92 @@ func (c *Client) UserOrganizations(ctx context.Context, id string) ([]coderd.Org
 		return nil, err
 	}
 	defer res.Body.Close()
-	if res.StatusCode != http.StatusOK {
+	if res.StatusCode > http.StatusOK {
 		return nil, readBodyAsError(res)
 	}
 	var orgs []coderd.Organization
 	return orgs, json.NewDecoder(res.Body).Decode(&orgs)
 }
+
+func (c *Client) OrganizationByName(ctx context.Context, user, name string) (coderd.Organization, error) {
+	if user == "" {
+		user = "me"
+	}
+	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/users/%s/organizations/%s", user, name), nil)
+	if err != nil {
+		return coderd.Organization{}, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return coderd.Organization{}, readBodyAsError(res)
+	}
+	var org coderd.Organization
+	return org, json.NewDecoder(res.Body).Decode(&org)
+}
+
+// CreateOrganization creates an organization and adds the provided user as an admin.
+func (c *Client) CreateOrganization(ctx context.Context, user string, req coderd.CreateOrganizationRequest) (coderd.Organization, error) {
+	if user == "" {
+		user = "me"
+	}
+	res, err := c.request(ctx, http.MethodPost, fmt.Sprintf("/api/v2/users/%s/organizations", user), req)
+	if err != nil {
+		return coderd.Organization{}, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusCreated {
+		return coderd.Organization{}, readBodyAsError(res)
+	}
+	var org coderd.Organization
+	return org, json.NewDecoder(res.Body).Decode(&org)
+}
+
+// CreateWorkspace creates a new workspace for the project specified.
+func (c *Client) CreateWorkspace(ctx context.Context, user string, request coderd.CreateWorkspaceRequest) (coderd.Workspace, error) {
+	if user == "" {
+		user = "me"
+	}
+	res, err := c.request(ctx, http.MethodPost, fmt.Sprintf("/api/v2/users/%s/workspaces", user), request)
+	if err != nil {
+		return coderd.Workspace{}, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusCreated {
+		return coderd.Workspace{}, readBodyAsError(res)
+	}
+	var workspace coderd.Workspace
+	return workspace, json.NewDecoder(res.Body).Decode(&workspace)
+}
+
+// WorkspacesByUser returns all workspaces the specified user has access to.
+func (c *Client) WorkspacesByUser(ctx context.Context, user string) ([]coderd.Workspace, error) {
+	if user == "" {
+		user = "me"
+	}
+	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/users/%s/workspaces", user), nil)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return nil, readBodyAsError(res)
+	}
+	var workspaces []coderd.Workspace
+	return workspaces, json.NewDecoder(res.Body).Decode(&workspaces)
+}
+
+func (c *Client) WorkspaceByName(ctx context.Context, user, name string) (coderd.Workspace, error) {
+	if user == "" {
+		user = "me"
+	}
+	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/users/%s/workspaces/%s", user, name), nil)
+	if err != nil {
+		return coderd.Workspace{}, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return coderd.Workspace{}, readBodyAsError(res)
+	}
+	var workspace coderd.Workspace
+	return workspace, json.NewDecoder(res.Body).Decode(&workspace)
+}