chore: Rename Projects to Templates (#880)

Customer feedback indicated projects was a confusing name.
After querying the team internally, it seemed unanimous
that it is indeed a confusing name.

Here's for a lil less confusion @ashmeer7 🥂

codersdk/organizations.go

@@ -21,10 +21,10 @@ 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"`
+// CreateTemplateVersionRequest enables callers to create a new Template Version.
+type CreateTemplateVersionRequest struct {
+	// TemplateID optionally associates a version with a template.
+	TemplateID uuid.UUID `json:"template_id"`
 
 	StorageMethod database.ProvisionerStorageMethod `json:"storage_method" validate:"oneof=file,required"`
 	StorageSource string                            `json:"storage_source" validate:"required"`
@@ -34,17 +34,17 @@ type CreateProjectVersionRequest struct {
 	ParameterValues []CreateParameterRequest `json:"parameter_values"`
 }
 
-// CreateProjectRequest provides options when creating a project.
-type CreateProjectRequest struct {
+// CreateTemplateRequest provides options when creating a template.
+type CreateTemplateRequest 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.
+	// an initial version of the template.
 	//
 	// 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"`
+	// template works. There is no reason the data-model cannot support
+	// empty templates, but it doesn't make sense for users.
+	VersionID       uuid.UUID                `json:"template_version_id" validate:"required"`
 	ParameterValues []CreateParameterRequest `json:"parameter_values"`
 }
 
@@ -82,49 +82,49 @@ func (c *Client) ProvisionerDaemonsByOrganization(ctx context.Context, organizat
 	return daemons, json.NewDecoder(res.Body).Decode(&daemons)
 }
 
-// CreateProjectVersion processes source-code and optionally associates the version with a project.
-// Executing without a project is useful for validating source-code.
-func (c *Client) CreateProjectVersion(ctx context.Context, organizationID uuid.UUID, req CreateProjectVersionRequest) (ProjectVersion, error) {
+// CreateTemplateVersion processes source-code and optionally associates the version with a template.
+// Executing without a template is useful for validating source-code.
+func (c *Client) CreateTemplateVersion(ctx context.Context, organizationID uuid.UUID, req CreateTemplateVersionRequest) (TemplateVersion, error) {
 	res, err := c.request(ctx, http.MethodPost,
-		fmt.Sprintf("/api/v2/organizations/%s/projectversions", organizationID.String()),
+		fmt.Sprintf("/api/v2/organizations/%s/templateversions", organizationID.String()),
 		req,
 	)
 	if err != nil {
-		return ProjectVersion{}, xerrors.Errorf("execute request: %w", err)
+		return TemplateVersion{}, xerrors.Errorf("execute request: %w", err)
 	}
 	defer res.Body.Close()
 
 	if res.StatusCode != http.StatusCreated {
-		return ProjectVersion{}, readBodyAsError(res)
+		return TemplateVersion{}, readBodyAsError(res)
 	}
 
-	var projectVersion ProjectVersion
-	return projectVersion, json.NewDecoder(res.Body).Decode(&projectVersion)
+	var templateVersion TemplateVersion
+	return templateVersion, json.NewDecoder(res.Body).Decode(&templateVersion)
 }
 
-// CreateProject creates a new project inside an organization.
-func (c *Client) CreateProject(ctx context.Context, organizationID uuid.UUID, request CreateProjectRequest) (Project, error) {
+// CreateTemplate creates a new template inside an organization.
+func (c *Client) CreateTemplate(ctx context.Context, organizationID uuid.UUID, request CreateTemplateRequest) (Template, error) {
 	res, err := c.request(ctx, http.MethodPost,
-		fmt.Sprintf("/api/v2/organizations/%s/projects", organizationID.String()),
+		fmt.Sprintf("/api/v2/organizations/%s/templates", organizationID.String()),
 		request,
 	)
 	if err != nil {
-		return Project{}, xerrors.Errorf("execute request: %w", err)
+		return Template{}, xerrors.Errorf("execute request: %w", err)
 	}
 	defer res.Body.Close()
 
 	if res.StatusCode != http.StatusCreated {
-		return Project{}, readBodyAsError(res)
+		return Template{}, readBodyAsError(res)
 	}
 
-	var project Project
-	return project, json.NewDecoder(res.Body).Decode(&project)
+	var template Template
+	return template, json.NewDecoder(res.Body).Decode(&template)
 }
 
-// ProjectsByOrganization lists all projects inside of an organization.
-func (c *Client) ProjectsByOrganization(ctx context.Context, organizationID uuid.UUID) ([]Project, error) {
+// TemplatesByOrganization lists all templates inside of an organization.
+func (c *Client) TemplatesByOrganization(ctx context.Context, organizationID uuid.UUID) ([]Template, error) {
 	res, err := c.request(ctx, http.MethodGet,
-		fmt.Sprintf("/api/v2/organizations/%s/projects", organizationID.String()),
+		fmt.Sprintf("/api/v2/organizations/%s/templates", organizationID.String()),
 		nil,
 	)
 	if err != nil {
@@ -136,25 +136,25 @@ func (c *Client) ProjectsByOrganization(ctx context.Context, organizationID uuid
 		return nil, readBodyAsError(res)
 	}
 
-	var projects []Project
-	return projects, json.NewDecoder(res.Body).Decode(&projects)
+	var templates []Template
+	return templates, json.NewDecoder(res.Body).Decode(&templates)
 }
 
-// ProjectByName finds a project inside the organization provided with a case-insensitive name.
-func (c *Client) ProjectByName(ctx context.Context, organizationID uuid.UUID, name string) (Project, error) {
+// TemplateByName finds a template inside the organization provided with a case-insensitive name.
+func (c *Client) TemplateByName(ctx context.Context, organizationID uuid.UUID, name string) (Template, error) {
 	res, err := c.request(ctx, http.MethodGet,
-		fmt.Sprintf("/api/v2/organizations/%s/projects/%s", organizationID.String(), name),
+		fmt.Sprintf("/api/v2/organizations/%s/templates/%s", organizationID.String(), name),
 		nil,
 	)
 	if err != nil {
-		return Project{}, xerrors.Errorf("execute request: %w", err)
+		return Template{}, xerrors.Errorf("execute request: %w", err)
 	}
 	defer res.Body.Close()
 
 	if res.StatusCode != http.StatusOK {
-		return Project{}, readBodyAsError(res)
+		return Template{}, readBodyAsError(res)
 	}
 
-	var project Project
-	return project, json.NewDecoder(res.Body).Decode(&project)
+	var template Template
+	return template, json.NewDecoder(res.Body).Decode(&template)
 }

codersdk/parameters.go

@@ -17,7 +17,7 @@ type ParameterScope string
 
 const (
 	ParameterOrganization ParameterScope = "organization"
-	ParameterProject      ParameterScope = "project"
+	ParameterTemplate     ParameterScope = "template"
 	ParameterUser         ParameterScope = "user"
 	ParameterWorkspace    ParameterScope = "workspace"
 )

codersdk/projectversions.go

@@ -1,109 +0,0 @@
-package codersdk
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/google/uuid"
-
-	"github.com/coder/coder/coderd/database"
-	"github.com/coder/coder/coderd/parameter"
-)
-
-// 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
-
-// ProjectVersion returns a project version by ID.
-func (c *Client) ProjectVersion(ctx context.Context, id uuid.UUID) (ProjectVersion, error) {
-	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/projectversions/%s", id), nil)
-	if err != nil {
-		return ProjectVersion{}, err
-	}
-	defer res.Body.Close()
-	if res.StatusCode != http.StatusOK {
-		return ProjectVersion{}, readBodyAsError(res)
-	}
-	var version ProjectVersion
-	return version, json.NewDecoder(res.Body).Decode(&version)
-}
-
-// CancelProjectVersion marks a project version job as canceled.
-func (c *Client) CancelProjectVersion(ctx context.Context, version uuid.UUID) error {
-	res, err := c.request(ctx, http.MethodPatch, fmt.Sprintf("/api/v2/projectversions/%s/cancel", version), nil)
-	if err != nil {
-		return err
-	}
-	defer res.Body.Close()
-	if res.StatusCode != http.StatusOK {
-		return readBodyAsError(res)
-	}
-	return nil
-}
-
-// ProjectVersionSchema returns schemas for a project version by ID.
-func (c *Client) ProjectVersionSchema(ctx context.Context, version uuid.UUID) ([]ProjectVersionParameterSchema, error) {
-	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/projectversions/%s/schema", version), nil)
-	if err != nil {
-		return nil, err
-	}
-	defer res.Body.Close()
-	if res.StatusCode != http.StatusOK {
-		return nil, readBodyAsError(res)
-	}
-	var params []ProjectVersionParameterSchema
-	return params, json.NewDecoder(res.Body).Decode(&params)
-}
-
-// ProjectVersionParameters returns computed parameters for a project version.
-func (c *Client) ProjectVersionParameters(ctx context.Context, version uuid.UUID) ([]ProjectVersionParameter, error) {
-	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/projectversions/%s/parameters", version), nil)
-	if err != nil {
-		return nil, err
-	}
-	defer res.Body.Close()
-	if res.StatusCode != http.StatusOK {
-		return nil, readBodyAsError(res)
-	}
-	var params []ProjectVersionParameter
-	return params, json.NewDecoder(res.Body).Decode(&params)
-}
-
-// ProjectVersionResources returns resources a project version declares.
-func (c *Client) ProjectVersionResources(ctx context.Context, version uuid.UUID) ([]WorkspaceResource, error) {
-	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/projectversions/%s/resources", version), nil)
-	if err != nil {
-		return nil, err
-	}
-	defer res.Body.Close()
-	if res.StatusCode != http.StatusOK {
-		return nil, readBodyAsError(res)
-	}
-	var resources []WorkspaceResource
-	return resources, json.NewDecoder(res.Body).Decode(&resources)
-}
-
-// ProjectVersionLogsBefore returns logs that occurred before a specific time.
-func (c *Client) ProjectVersionLogsBefore(ctx context.Context, version uuid.UUID, before time.Time) ([]ProvisionerJobLog, error) {
-	return c.provisionerJobLogsBefore(ctx, fmt.Sprintf("/api/v2/projectversions/%s/logs", version), before)
-}
-
-// ProjectVersionLogsAfter streams logs for a project version that occurred after a specific time.
-func (c *Client) ProjectVersionLogsAfter(ctx context.Context, version uuid.UUID, after time.Time) (<-chan ProvisionerJobLog, error) {
-	return c.provisionerJobLogsAfter(ctx, fmt.Sprintf("/api/v2/projectversions/%s/logs", version), after)
-}

codersdk/templates.go

@@ -12,9 +12,9 @@ import (
 	"github.com/coder/coder/coderd/database"
 )
 
-// Project is the JSON representation of a Coder project. This type matches the
+// Template is the JSON representation of a Coder template. This type matches the
 // database object for now, but is abstracted for ease of change later on.
-type Project struct {
+type Template struct {
 	ID                  uuid.UUID                `json:"id"`
 	CreatedAt           time.Time                `json:"created_at"`
 	UpdatedAt           time.Time                `json:"updated_at"`
@@ -25,26 +25,26 @@ type Project struct {
 	WorkspaceOwnerCount uint32                   `json:"workspace_owner_count"`
 }
 
-type UpdateActiveProjectVersion struct {
+type UpdateActiveTemplateVersion struct {
 	ID uuid.UUID `json:"id" validate:"required"`
 }
 
-// Project returns a single project.
-func (c *Client) Project(ctx context.Context, project uuid.UUID) (Project, error) {
-	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/projects/%s", project), nil)
+// Template returns a single template.
+func (c *Client) Template(ctx context.Context, template uuid.UUID) (Template, error) {
+	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/templates/%s", template), nil)
 	if err != nil {
-		return Project{}, nil
+		return Template{}, nil
 	}
 	defer res.Body.Close()
 	if res.StatusCode != http.StatusOK {
-		return Project{}, readBodyAsError(res)
+		return Template{}, readBodyAsError(res)
 	}
-	var resp Project
+	var resp Template
 	return resp, json.NewDecoder(res.Body).Decode(&resp)
 }
 
-func (c *Client) DeleteProject(ctx context.Context, project uuid.UUID) error {
-	res, err := c.request(ctx, http.MethodDelete, fmt.Sprintf("/api/v2/projects/%s", project), nil)
+func (c *Client) DeleteTemplate(ctx context.Context, template uuid.UUID) error {
+	res, err := c.request(ctx, http.MethodDelete, fmt.Sprintf("/api/v2/templates/%s", template), nil)
 	if err != nil {
 		return err
 	}
@@ -55,10 +55,10 @@ func (c *Client) DeleteProject(ctx context.Context, project uuid.UUID) error {
 	return nil
 }
 
-// UpdateActiveProjectVersion updates the active project version to the ID provided.
-// The project version must be attached to the project.
-func (c *Client) UpdateActiveProjectVersion(ctx context.Context, project uuid.UUID, req UpdateActiveProjectVersion) error {
-	res, err := c.request(ctx, http.MethodPatch, fmt.Sprintf("/api/v2/projects/%s/versions", project), req)
+// UpdateActiveTemplateVersion updates the active template version to the ID provided.
+// The template version must be attached to the template.
+func (c *Client) UpdateActiveTemplateVersion(ctx context.Context, template uuid.UUID, req UpdateActiveTemplateVersion) error {
+	res, err := c.request(ctx, http.MethodPatch, fmt.Sprintf("/api/v2/templates/%s/versions", template), req)
 	if err != nil {
 		return nil
 	}
@@ -69,9 +69,9 @@ func (c *Client) UpdateActiveProjectVersion(ctx context.Context, project uuid.UU
 	return nil
 }
 
-// ProjectVersionsByProject lists versions associated with a project.
-func (c *Client) ProjectVersionsByProject(ctx context.Context, project uuid.UUID) ([]ProjectVersion, error) {
-	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/projects/%s/versions", project), nil)
+// TemplateVersionsByTemplate lists versions associated with a template.
+func (c *Client) TemplateVersionsByTemplate(ctx context.Context, template uuid.UUID) ([]TemplateVersion, error) {
+	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/templates/%s/versions", template), nil)
 	if err != nil {
 		return nil, err
 	}
@@ -79,21 +79,21 @@ func (c *Client) ProjectVersionsByProject(ctx context.Context, project uuid.UUID
 	if res.StatusCode != http.StatusOK {
 		return nil, readBodyAsError(res)
 	}
-	var projectVersion []ProjectVersion
-	return projectVersion, json.NewDecoder(res.Body).Decode(&projectVersion)
+	var templateVersion []TemplateVersion
+	return templateVersion, json.NewDecoder(res.Body).Decode(&templateVersion)
 }
 
-// ProjectVersionByName returns a project version by it's friendly name.
-// This is used for path-based routing. Like: /projects/example/versions/helloworld
-func (c *Client) ProjectVersionByName(ctx context.Context, project uuid.UUID, name string) (ProjectVersion, error) {
-	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/projects/%s/versions/%s", project, name), nil)
+// TemplateVersionByName returns a template version by it's friendly name.
+// This is used for path-based routing. Like: /templates/example/versions/helloworld
+func (c *Client) TemplateVersionByName(ctx context.Context, template uuid.UUID, name string) (TemplateVersion, error) {
+	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/templates/%s/versions/%s", template, name), nil)
 	if err != nil {
-		return ProjectVersion{}, err
+		return TemplateVersion{}, err
 	}
 	defer res.Body.Close()
 	if res.StatusCode != http.StatusOK {
-		return ProjectVersion{}, readBodyAsError(res)
+		return TemplateVersion{}, readBodyAsError(res)
 	}
-	var projectVersion ProjectVersion
-	return projectVersion, json.NewDecoder(res.Body).Decode(&projectVersion)
+	var templateVersion TemplateVersion
+	return templateVersion, json.NewDecoder(res.Body).Decode(&templateVersion)
 }

codersdk/templateversions.go

@@ -0,0 +1,109 @@
+package codersdk
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/google/uuid"
+
+	"github.com/coder/coder/coderd/database"
+	"github.com/coder/coder/coderd/parameter"
+)
+
+// TemplateVersion represents a single version of a template.
+type TemplateVersion struct {
+	ID         uuid.UUID      `json:"id"`
+	TemplateID *uuid.UUID     `json:"template_id,omitempty"`
+	CreatedAt  time.Time      `json:"created_at"`
+	UpdatedAt  time.Time      `json:"updated_at"`
+	Name       string         `json:"name"`
+	Job        ProvisionerJob `json:"job"`
+}
+
+// TemplateVersionParameterSchema represents a parameter parsed from template version source.
+type TemplateVersionParameterSchema database.ParameterSchema
+
+// TemplateVersionParameter represents a computed parameter value.
+type TemplateVersionParameter parameter.ComputedValue
+
+// TemplateVersion returns a template version by ID.
+func (c *Client) TemplateVersion(ctx context.Context, id uuid.UUID) (TemplateVersion, error) {
+	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/templateversions/%s", id), nil)
+	if err != nil {
+		return TemplateVersion{}, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return TemplateVersion{}, readBodyAsError(res)
+	}
+	var version TemplateVersion
+	return version, json.NewDecoder(res.Body).Decode(&version)
+}
+
+// CancelTemplateVersion marks a template version job as canceled.
+func (c *Client) CancelTemplateVersion(ctx context.Context, version uuid.UUID) error {
+	res, err := c.request(ctx, http.MethodPatch, fmt.Sprintf("/api/v2/templateversions/%s/cancel", version), nil)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return readBodyAsError(res)
+	}
+	return nil
+}
+
+// TemplateVersionSchema returns schemas for a template version by ID.
+func (c *Client) TemplateVersionSchema(ctx context.Context, version uuid.UUID) ([]TemplateVersionParameterSchema, error) {
+	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/templateversions/%s/schema", version), nil)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return nil, readBodyAsError(res)
+	}
+	var params []TemplateVersionParameterSchema
+	return params, json.NewDecoder(res.Body).Decode(&params)
+}
+
+// TemplateVersionParameters returns computed parameters for a template version.
+func (c *Client) TemplateVersionParameters(ctx context.Context, version uuid.UUID) ([]TemplateVersionParameter, error) {
+	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/templateversions/%s/parameters", version), nil)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return nil, readBodyAsError(res)
+	}
+	var params []TemplateVersionParameter
+	return params, json.NewDecoder(res.Body).Decode(&params)
+}
+
+// TemplateVersionResources returns resources a template version declares.
+func (c *Client) TemplateVersionResources(ctx context.Context, version uuid.UUID) ([]WorkspaceResource, error) {
+	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/templateversions/%s/resources", version), nil)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return nil, readBodyAsError(res)
+	}
+	var resources []WorkspaceResource
+	return resources, json.NewDecoder(res.Body).Decode(&resources)
+}
+
+// TemplateVersionLogsBefore returns logs that occurred before a specific time.
+func (c *Client) TemplateVersionLogsBefore(ctx context.Context, version uuid.UUID, before time.Time) ([]ProvisionerJobLog, error) {
+	return c.provisionerJobLogsBefore(ctx, fmt.Sprintf("/api/v2/templateversions/%s/logs", version), before)
+}
+
+// TemplateVersionLogsAfter streams logs for a template version that occurred after a specific time.
+func (c *Client) TemplateVersionLogsAfter(ctx context.Context, version uuid.UUID, after time.Time) (<-chan ProvisionerJobLog, error) {
+	return c.provisionerJobLogsAfter(ctx, fmt.Sprintf("/api/v2/templateversions/%s/logs", version), after)
+}

codersdk/users.go

@@ -63,8 +63,8 @@ type CreateOrganizationRequest struct {
 
 // 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"`
+	TemplateID uuid.UUID `json:"template_id" validate:"required"`
+	Name       string    `json:"name" validate:"username,required"`
 	// ParameterValues allows for additional parameters to be provided
 	// during the initial provision.
 	ParameterValues []CreateParameterRequest `json:"parameter_values"`
@@ -219,7 +219,7 @@ func (c *Client) CreateOrganization(ctx context.Context, userID uuid.UUID, req C
 	return org, json.NewDecoder(res.Body).Decode(&org)
 }
 
-// CreateWorkspace creates a new workspace for the project specified.
+// CreateWorkspace creates a new workspace for the template specified.
 func (c *Client) CreateWorkspace(ctx context.Context, userID uuid.UUID, request CreateWorkspaceRequest) (Workspace, error) {
 	res, err := c.request(ctx, http.MethodPost, fmt.Sprintf("/api/v2/users/%s/workspaces", uuidOrMe(userID)), request)
 	if err != nil {

codersdk/workspacebuilds.go

@@ -15,17 +15,17 @@ import (
 // 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"`
-	InitiatorID      uuid.UUID                    `json:"initiator_id"`
-	Job              ProvisionerJob               `json:"job"`
+	ID                uuid.UUID                    `json:"id"`
+	CreatedAt         time.Time                    `json:"created_at"`
+	UpdatedAt         time.Time                    `json:"updated_at"`
+	WorkspaceID       uuid.UUID                    `json:"workspace_id"`
+	TemplateVersionID uuid.UUID                    `json:"template_version_id"`
+	BeforeID          uuid.UUID                    `json:"before_id"`
+	AfterID           uuid.UUID                    `json:"after_id"`
+	Name              string                       `json:"name"`
+	Transition        database.WorkspaceTransition `json:"transition"`
+	InitiatorID       uuid.UUID                    `json:"initiator_id"`
+	Job               ProvisionerJob               `json:"job"`
 }
 
 // WorkspaceBuild returns a single workspace build for a workspace.

codersdk/workspaces.go

@@ -12,25 +12,25 @@ import (
 	"github.com/coder/coder/coderd/database"
 )
 
-// Workspace is a per-user deployment of a project. It tracks
-// project versions, and can be updated.
+// Workspace is a per-user deployment of a template. It tracks
+// template versions, and can be updated.
 type Workspace struct {
-	ID          uuid.UUID      `json:"id"`
-	CreatedAt   time.Time      `json:"created_at"`
-	UpdatedAt   time.Time      `json:"updated_at"`
-	OwnerID     uuid.UUID      `json:"owner_id"`
-	ProjectID   uuid.UUID      `json:"project_id"`
-	ProjectName string         `json:"project_name"`
-	LatestBuild WorkspaceBuild `json:"latest_build"`
-	Outdated    bool           `json:"outdated"`
-	Name        string         `json:"name"`
+	ID           uuid.UUID      `json:"id"`
+	CreatedAt    time.Time      `json:"created_at"`
+	UpdatedAt    time.Time      `json:"updated_at"`
+	OwnerID      uuid.UUID      `json:"owner_id"`
+	TemplateID   uuid.UUID      `json:"template_id"`
+	TemplateName string         `json:"template_name"`
+	LatestBuild  WorkspaceBuild `json:"latest_build"`
+	Outdated     bool           `json:"outdated"`
+	Name         string         `json:"name"`
 }
 
 // CreateWorkspaceBuildRequest provides options to update the latest workspace build.
 type CreateWorkspaceBuildRequest struct {
-	ProjectVersionID uuid.UUID                    `json:"project_version_id"`
-	Transition       database.WorkspaceTransition `json:"transition" validate:"oneof=create start stop delete,required"`
-	DryRun           bool                         `json:"dry_run"`
+	TemplateVersionID uuid.UUID                    `json:"template_version_id"`
+	Transition        database.WorkspaceTransition `json:"transition" validate:"oneof=create start stop delete,required"`
+	DryRun            bool                         `json:"dry_run"`
 }
 
 // Workspace returns a single workspace.