chore: Rename ProjectHistory to ProjectVersion

Version more accurately represents version storage. This forks from the WorkspaceHistory name, but I think it's easier to understand Workspace history.
coder · kylecarbs · Feb 6, 2022 · Feb 5, 2022 · Feb 5, 2022 · Feb 5, 2022
commit 7f2a99fec5486b9df4deb672b7a5e164351ce705
diff --git a/coderd/coderd.go b/coderd/coderd.go
@@ -66,13 +66,13 @@ func New(options *Options) http.Handler {
 						r.Get("/", api.parametersByProject)
 						r.Post("/", api.postParametersByProject)
 					})
-					r.Route("/history", func(r chi.Router) {
-						r.Get("/", api.projectHistoryByOrganization)
-						r.Post("/", api.postProjectHistoryByOrganization)
-						r.Route("/{projecthistory}", func(r chi.Router) {
-							r.Use(httpmw.ExtractProjectHistoryParam(api.Database))
-							r.Get("/", api.projectHistoryByOrganizationAndName)
-							r.Get("/parameters", api.projectHistoryParametersByOrganizationAndName)
+					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.Get("/parameters", api.projectVersionParametersByOrganizationAndName)
 						})
 					})
 				})
@@ -91,7 +91,7 @@ func New(options *Options) http.Handler {
 				r.Route("/{workspace}", func(r chi.Router) {
 					r.Use(httpmw.ExtractWorkspaceParam(options.Database))
 					r.Get("/", api.workspaceByUser)
-					r.Route("/history", func(r chi.Router) {
+					r.Route("/version", func(r chi.Router) {
 						r.Post("/", api.postWorkspaceHistoryByUser)
 						r.Get("/", api.workspaceHistoryByUser)
 						r.Route("/{workspacehistory}", func(r chi.Router) {

diff --git a/coderd/projecthistory.go b/coderd/projecthistory.go
@@ -20,8 +20,8 @@ import (
 	"github.com/coder/coder/httpmw"
 )
 
-// ProjectHistory is the JSON representation of Coder project version history.
-type ProjectHistory struct {
+// 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"`
@@ -31,11 +31,11 @@ type ProjectHistory struct {
 	Import        ProvisionerJob                `json:"import"`
 }
 
-// ProjectParameter represents a parameter parsed from project history source on creation.
+// ProjectParameter represents a parameter parsed from project version source on creation.
 type ProjectParameter struct {
 	ID                       uuid.UUID                           `json:"id"`
 	CreatedAt                time.Time                           `json:"created_at"`
-	ProjectHistoryID         uuid.UUID                           `json:"project_history_id"`
+	ProjectVersionID         uuid.UUID                           `json:"project_version_id"`
 	Name                     string                              `json:"name"`
 	Description              string                              `json:"description,omitempty"`
 	DefaultSourceScheme      database.ParameterSourceScheme      `json:"default_source_scheme,omitempty"`
@@ -52,60 +52,60 @@ type ProjectParameter struct {
 	ValidationValueType      string                              `json:"validation_value_type,omitempty"`
 }
 
-// CreateProjectHistoryRequest enables callers to create a new Project Version.
-type CreateProjectHistoryRequest struct {
+// CreateProjectVersionRequest enables callers to create a new Project Version.
+type CreateProjectVersionRequest struct {
 	StorageMethod database.ProjectStorageMethod `json:"storage_method" validate:"oneof=inline-archive,required"`
 	StorageSource []byte                        `json:"storage_source" validate:"max=1048576,required"`
 }
 
-// Lists history for a single project.
-func (api *api) projectHistoryByOrganization(rw http.ResponseWriter, r *http.Request) {
+// Lists versions for a single project.
+func (api *api) projectVersionsByOrganization(rw http.ResponseWriter, r *http.Request) {
 	project := httpmw.ProjectParam(r)
 
-	history, err := api.Database.GetProjectHistoryByProjectID(r.Context(), project.ID)
+	version, err := api.Database.GetProjectVersionByProjectID(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 history: %s", err),
+			Message: fmt.Sprintf("get project version: %s", err),
 		})
 		return
 	}
-	apiHistory := make([]ProjectHistory, 0)
-	for _, version := range history {
+	apiVersion := make([]ProjectVersion, 0)
+	for _, version := range version {
 		job, err := api.Database.GetProvisionerJobByID(r.Context(), version.ImportJobID)
 		if err != nil {
 			httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
 				Message: fmt.Sprintf("get provisioner job: %s", err),
 			})
 			return
 		}
-		apiHistory = append(apiHistory, convertProjectHistory(version, job))
+		apiVersion = append(apiVersion, convertProjectVersion(version, job))
 	}
 	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, apiHistory)
+	render.JSON(rw, r, apiVersion)
 }
 
-// Return a single project history by organization and name.
-func (api *api) projectHistoryByOrganizationAndName(rw http.ResponseWriter, r *http.Request) {
-	projectHistory := httpmw.ProjectHistoryParam(r)
-	job, err := api.Database.GetProvisionerJobByID(r.Context(), projectHistory.ImportJobID)
+// Return a single project version by organization and name.
+func (api *api) projectVersionByOrganizationAndName(rw http.ResponseWriter, r *http.Request) {
+	projectVersion := httpmw.ProjectVersionParam(r)
+	job, 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
 	}
 	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, convertProjectHistory(projectHistory, job))
+	render.JSON(rw, r, convertProjectVersion(projectVersion, job))
 }
 
 // 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) postProjectHistoryByOrganization(rw http.ResponseWriter, r *http.Request) {
-	var createProjectVersion CreateProjectHistoryRequest
+func (api *api) postProjectVersionByOrganization(rw http.ResponseWriter, r *http.Request) {
+	var createProjectVersion CreateProjectVersionRequest
 	if !httpapi.Read(rw, r, &createProjectVersion) {
 		return
 	}
@@ -131,11 +131,11 @@ func (api *api) postProjectHistoryByOrganization(rw http.ResponseWriter, r *http
 	project := httpmw.ProjectParam(r)
 
 	var provisionerJob database.ProvisionerJob
-	var projectHistory database.ProjectHistory
+	var projectVersion database.ProjectVersion
 	err := api.Database.InTx(func(db database.Store) error {
-		projectHistoryID := uuid.New()
+		projectVersionID := uuid.New()
 		input, err := json.Marshal(projectImportJob{
-			ProjectHistoryID: projectHistoryID,
+			ProjectVersionID: projectVersionID,
 		})
 		if err != nil {
 			return xerrors.Errorf("marshal import job: %w", err)
@@ -155,8 +155,8 @@ func (api *api) postProjectHistoryByOrganization(rw http.ResponseWriter, r *http
 			return xerrors.Errorf("insert provisioner job: %w", err)
 		}
 
-		projectHistory, err = api.Database.InsertProjectHistory(r.Context(), database.InsertProjectHistoryParams{
-			ID:            projectHistoryID,
+		projectVersion, err = api.Database.InsertProjectVersion(r.Context(), database.InsertProjectVersionParams{
+			ID:            projectVersionID,
 			ProjectID:     project.ID,
 			CreatedAt:     database.Now(),
 			UpdatedAt:     database.Now(),
@@ -166,7 +166,7 @@ func (api *api) postProjectHistoryByOrganization(rw http.ResponseWriter, r *http
 			ImportJobID:   provisionerJob.ID,
 		})
 		if err != nil {
-			return xerrors.Errorf("insert project history: %s", err)
+			return xerrors.Errorf("insert project version: %s", err)
 		}
 		return nil
 	})
@@ -178,12 +178,12 @@ func (api *api) postProjectHistoryByOrganization(rw http.ResponseWriter, r *http
 	}
 
 	render.Status(r, http.StatusCreated)
-	render.JSON(rw, r, convertProjectHistory(projectHistory, provisionerJob))
+	render.JSON(rw, r, convertProjectVersion(projectVersion, provisionerJob))
 }
 
-func (api *api) projectHistoryParametersByOrganizationAndName(rw http.ResponseWriter, r *http.Request) {
-	projectHistory := httpmw.ProjectHistoryParam(r)
-	job, err := api.Database.GetProvisionerJobByID(r.Context(), projectHistory.ImportJobID)
+func (api *api) projectVersionParametersByOrganizationAndName(rw http.ResponseWriter, r *http.Request) {
+	projectVersion := httpmw.ProjectVersionParam(r)
+	job, 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),
@@ -204,7 +204,7 @@ func (api *api) projectHistoryParametersByOrganizationAndName(rw http.ResponseWr
 		return
 	}
 
-	parameters, err := api.Database.GetProjectParametersByHistoryID(r.Context(), projectHistory.ID)
+	parameters, err := api.Database.GetProjectParametersByVersionID(r.Context(), projectVersion.ID)
 	if errors.Is(err, sql.ErrNoRows) {
 		err = nil
 		parameters = []database.ProjectParameter{}
@@ -225,14 +225,14 @@ func (api *api) projectHistoryParametersByOrganizationAndName(rw http.ResponseWr
 	render.JSON(rw, r, apiParameters)
 }
 
-func convertProjectHistory(history database.ProjectHistory, job database.ProvisionerJob) ProjectHistory {
-	return ProjectHistory{
-		ID:            history.ID,
-		ProjectID:     history.ProjectID,
-		CreatedAt:     history.CreatedAt,
-		UpdatedAt:     history.UpdatedAt,
-		Name:          history.Name,
-		StorageMethod: history.StorageMethod,
+func convertProjectVersion(version database.ProjectVersion, job database.ProvisionerJob) ProjectVersion {
+	return ProjectVersion{
+		ID:            version.ID,
+		ProjectID:     version.ProjectID,
+		CreatedAt:     version.CreatedAt,
+		UpdatedAt:     version.UpdatedAt,
+		Name:          version.Name,
+		StorageMethod: version.StorageMethod,
 		Import:        convertProvisionerJob(job),
 	}
 }
@@ -241,7 +241,7 @@ func convertProjectParameter(parameter database.ProjectParameter) ProjectParamet
 	return ProjectParameter{
 		ID:                       parameter.ID,
 		CreatedAt:                parameter.CreatedAt,
-		ProjectHistoryID:         parameter.ProjectHistoryID,
+		ProjectVersionID:         parameter.ProjectVersionID,
 		Name:                     parameter.Name,
 		Description:              parameter.Description,
 		DefaultSourceScheme:      parameter.DefaultSourceScheme,
@@ -259,6 +259,6 @@ func convertProjectParameter(parameter database.ProjectParameter) ProjectParamet
 	}
 }
 
-func projectHistoryLogsChannel(projectHistoryID uuid.UUID) string {
-	return fmt.Sprintf("project-history-logs:%s", projectHistoryID)
+func projectVersionLogsChannel(projectVersionID uuid.UUID) string {
+	return fmt.Sprintf("project-version-logs:%s", projectVersionID)
 }
diff --git a/coderd/projecthistory_test.go b/coderd/projecthistory_test.go
@@ -15,7 +15,7 @@ import (
 	"github.com/coder/coder/provisionersdk/proto"
 )
 
-func TestProjectHistory(t *testing.T) {
+func TestProjectVersion(t *testing.T) {
 	t.Parallel()
 
 	t.Run("NoHistory", func(t *testing.T) {
@@ -27,12 +27,12 @@ func TestProjectHistory(t *testing.T) {
 			Provisioner: database.ProvisionerTypeEcho,
 		})
 		require.NoError(t, err)
-		versions, err := server.Client.ListProjectHistory(context.Background(), user.Organization, project.Name)
+		versions, err := server.Client.ProjectVersions(context.Background(), user.Organization, project.Name)
 		require.NoError(t, err)
 		require.Len(t, versions, 0)
 	})
 
-	t.Run("CreateHistory", func(t *testing.T) {
+	t.Run("CreateVersion", func(t *testing.T) {
 		t.Parallel()
 		server := coderdtest.New(t)
 		user := server.RandomInitialUser(t)
@@ -47,16 +47,16 @@ func TestProjectHistory(t *testing.T) {
 			},
 		}}, nil)
 		require.NoError(t, err)
-		history, err := server.Client.CreateProjectHistory(context.Background(), user.Organization, project.Name, coderd.CreateProjectHistoryRequest{
+		version, err := server.Client.CreateProjectVersion(context.Background(), user.Organization, project.Name, coderd.CreateProjectVersionRequest{
 			StorageMethod: database.ProjectStorageMethodInlineArchive,
 			StorageSource: data,
 		})
 		require.NoError(t, err)
-		versions, err := server.Client.ListProjectHistory(context.Background(), user.Organization, project.Name)
+		versions, err := server.Client.ProjectVersions(context.Background(), user.Organization, project.Name)
 		require.NoError(t, err)
 		require.Len(t, versions, 1)
 
-		_, err = server.Client.ProjectHistory(context.Background(), user.Organization, project.Name, history.Name)
+		_, err = server.Client.ProjectVersion(context.Background(), user.Organization, project.Name, version.Name)
 		require.NoError(t, err)
 	})
 
@@ -78,7 +78,7 @@ func TestProjectHistory(t *testing.T) {
 		require.NoError(t, err)
 		_, err = writer.Write(make([]byte, 1<<21))
 		require.NoError(t, err)
-		_, err = server.Client.CreateProjectHistory(context.Background(), user.Organization, project.Name, coderd.CreateProjectHistoryRequest{
+		_, err = server.Client.CreateProjectVersion(context.Background(), user.Organization, project.Name, coderd.CreateProjectVersionRequest{
 			StorageMethod: database.ProjectStorageMethodInlineArchive,
 			StorageSource: buffer.Bytes(),
 		})
@@ -94,7 +94,7 @@ func TestProjectHistory(t *testing.T) {
 			Provisioner: database.ProvisionerTypeEcho,
 		})
 		require.NoError(t, err)
-		_, err = server.Client.CreateProjectHistory(context.Background(), user.Organization, project.Name, coderd.CreateProjectHistoryRequest{
+		_, err = server.Client.CreateProjectVersion(context.Background(), user.Organization, project.Name, coderd.CreateProjectVersionRequest{
 			StorageMethod: database.ProjectStorageMethodInlineArchive,
 			StorageSource: []byte{},
 		})