reorganize preview form under tabs (#4090)

Author: ianedwards

api/server/handlers/porter_app/create_app_template.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"encoding/base64"
 	"net/http"
-	"time"
 
+	"connectrpc.com/connect"
 	"github.com/google/uuid"
 	"github.com/porter-dev/api-contracts/generated/go/helpers"
 	porterv1 "github.com/porter-dev/api-contracts/generated/go/porter/v1"
@@ -41,18 +41,25 @@ func NewCreateAppTemplateHandler(
 	}
 }
 
+// Base64AddonWithEnvVars is a struct that contains a base64 encoded addon proto and its env vars
+// These env vars will be used to create an env group that is attached to the addon
+type Base64AddonWithEnvVars struct {
+	Base64Addon string            `json:"base64_addon"`
+	Variables   map[string]string `json:"variables"`
+	Secrets     map[string]string `json:"secrets"`
+}
+
 // CreateAppTemplateRequest is the request object for the /app-template POST endpoint
 type CreateAppTemplateRequest struct {
-	B64AppProto            string            `json:"b64_app_proto"`
-	Variables              map[string]string `json:"variables"`
-	Secrets                map[string]string `json:"secrets"`
-	BaseDeploymentTargetID string            `json:"base_deployment_target_id"`
+	B64AppProto            string                   `json:"b64_app_proto"`
+	Variables              map[string]string        `json:"variables"`
+	Secrets                map[string]string        `json:"secrets"`
+	BaseDeploymentTargetID string                   `json:"base_deployment_target_id"`
+	Addons                 []Base64AddonWithEnvVars `json:"addons"`
 }
 
 // CreateAppTemplateResponse is the response object for the /app-template POST endpoint
-type CreateAppTemplateResponse struct {
-	AppTemplateID string `json:"app_template_id"`
-}
+type CreateAppTemplateResponse struct{}
 
 // ServeHTTP creates or updates an app template for a given porter app
 func (c *CreateAppTemplateHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
@@ -108,115 +115,60 @@ func (c *CreateAppTemplateHandler) ServeHTTP(w http.ResponseWriter, r *http.Requ
 		return
 	}
 
-	porterApps, err := c.Repo().PorterApp().ReadPorterAppsByProjectIDAndName(project.ID, appName)
-	if err != nil {
-		err := telemetry.Error(ctx, span, err, "error getting porter app from repo")
-		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusBadRequest))
-		return
-	}
-	if len(porterApps) == 0 {
-		err := telemetry.Error(ctx, span, err, "no porter apps returned")
-		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusBadRequest))
-		return
-	}
-	if len(porterApps) > 1 {
-		err := telemetry.Error(ctx, span, err, "multiple porter apps returned; unable to determine which one to use")
-		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusBadRequest))
-		return
-	}
-
-	if porterApps[0].ID == 0 {
-		err := telemetry.Error(ctx, span, err, "porter app id is missing")
-		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
-		return
-	}
-
-	telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "porter-app-id", Value: porterApps[0].ID})
-
-	var appTemplate *models.AppTemplate
-
-	existingAppTemplate, err := c.Repo().AppTemplate().AppTemplateByPorterAppID(
-		project.ID,
-		porterApps[0].ID,
-	)
-	if err != nil {
-		err := telemetry.Error(ctx, span, err, "error checking for existing app template")
-		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
-		return
-	}
-
-	if existingAppTemplate.ID != uuid.Nil {
-		appTemplate = existingAppTemplate
-		telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "update-app-template", Value: true})
-	}
-	if appTemplate == nil {
-		appTemplate = &models.AppTemplate{
-			ProjectID:   int(project.ID),
-			PorterAppID: int(porterApps[0].ID),
-		}
-		telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "update-app-template", Value: false})
-	}
-
 	protoWithoutDefaultAppEnvGroups, err := filterDefaultAppEnvGroups(ctx, request.B64AppProto, agent)
 	if err != nil {
 		err := telemetry.Error(ctx, span, err, "error filtering default app env groups")
 		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
 		return
 	}
 
-	appTemplate.Base64App = protoWithoutDefaultAppEnvGroups
-	appTemplate.BaseDeploymentTargetID = baseDeploymentTarget
-
-	updatedAppTemplate, err := c.Repo().AppTemplate().CreateAppTemplate(appTemplate)
-	if err != nil {
-		err := telemetry.Error(ctx, span, err, "error creating app template")
-		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
-		return
-	}
+	var addonTemplates []*porterv1.AddonWithEnvVars
+	for _, addon := range request.Addons {
+		decoded, err := base64.StdEncoding.DecodeString(addon.Base64Addon)
+		if err != nil {
+			err := telemetry.Error(ctx, span, err, "error decoding base64 addon")
+			c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+			return
+		}
 
-	if updatedAppTemplate == nil {
-		err := telemetry.Error(ctx, span, err, "updated app template is nil")
-		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
-		return
-	}
-	if updatedAppTemplate.ID == uuid.Nil {
-		err := telemetry.Error(ctx, span, err, "updated app template id is nil")
-		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
-		return
-	}
+		addonProto := &porterv1.Addon{}
+		err = helpers.UnmarshalContractObject(decoded, addonProto)
+		if err != nil {
+			err := telemetry.Error(ctx, span, err, "error unmarshalling addon proto")
+			c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+			return
+		}
 
-	previewTemplateEnvName, err := porter_app.AppTemplateEnvGroupName(ctx, appName, cluster.ID, c.Repo().PorterApp())
-	if err != nil {
-		err := telemetry.Error(ctx, span, err, "unable to get app template env group name")
-		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
-		return
-	}
+		addonTemplates = append(addonTemplates, &porterv1.AddonWithEnvVars{
+			Addon: addonProto,
+			EnvVars: &porterv1.EnvGroupVariables{
+				Normal: addon.Variables,
+				Secret: addon.Secrets,
+			},
+		})
+	}
+
+	updateAppTemplateReq := connect.NewRequest(&porterv1.UpdateAppTemplateRequest{
+		ProjectId:   int64(project.ID),
+		AppName:     appName,
+		AppTemplate: protoWithoutDefaultAppEnvGroups,
+		AppEnv: &porterv1.EnvGroupVariables{
+			Normal: request.Variables,
+			Secret: request.Secrets,
+		},
+		AddonTemplates:         addonTemplates,
+		BaseDeploymentTargetId: baseDeploymentTarget.String(),
+	})
 
-	envGroup, err := environment_groups.LatestBaseEnvironmentGroup(ctx, agent, previewTemplateEnvName)
+	updateAppTemplateRes, err := c.Config().ClusterControlPlaneClient.UpdateAppTemplate(ctx, updateAppTemplateReq)
 	if err != nil {
-		err := telemetry.Error(ctx, span, err, "unable to get latest base environment group")
+		err := telemetry.Error(ctx, span, err, "error updating app template")
 		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
 		return
 	}
 
-	if envGroup.Name == "" {
-		envGroup = environment_groups.EnvironmentGroup{
-			Name:         previewTemplateEnvName,
-			CreatedAtUTC: time.Now().UTC(),
-		}
-	}
-	envGroup.Variables = request.Variables
-	envGroup.SecretVariables = request.Secrets
-
-	additionalEnvGroupLabels := map[string]string{
-		LabelKey_AppName: appName,
-		environment_groups.LabelKey_DefaultAppEnvironment: "true",
-		LabelKey_PorterManaged:                            "true",
-	}
-
-	err = environment_groups.CreateOrUpdateBaseEnvironmentGroup(ctx, agent, envGroup, additionalEnvGroupLabels)
-	if err != nil {
-		err := telemetry.Error(ctx, span, err, "unable to create or update base environment group")
+	if updateAppTemplateRes == nil || updateAppTemplateRes.Msg == nil {
+		err := telemetry.Error(ctx, span, err, "error updating app template")
 		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
 		return
 	}
@@ -238,45 +190,42 @@ func (c *CreateAppTemplateHandler) ServeHTTP(w http.ResponseWriter, r *http.Requ
 		return
 	}
 
-	res := &CreateAppTemplateResponse{
-		AppTemplateID: updatedAppTemplate.ID.String(),
-	}
+	res := &CreateAppTemplateResponse{}
 
 	c.WriteResult(w, r, res)
 }
 
 // filterDefaultAppEnvGroups filters out any default app env groups found when creating an app template
 // app templates are based on the latest version of a given app, so it is possible for this env group to be included
 // however, the app template will get its own default env group when used to deploy to a preview environment
-func filterDefaultAppEnvGroups(ctx context.Context, b64AppProto string, agent *kubernetes.Agent) (string, error) {
+func filterDefaultAppEnvGroups(ctx context.Context, b64AppProto string, agent *kubernetes.Agent) (*porterv1.PorterApp, error) {
 	ctx, span := telemetry.NewSpan(ctx, "filter-default-app-env-groups")
 	defer span.End()
 
-	var finalAppProto string
+	appProto := &porterv1.PorterApp{}
 
 	if b64AppProto == "" {
-		return finalAppProto, telemetry.Error(ctx, span, nil, "b64 app proto is empty")
+		return appProto, telemetry.Error(ctx, span, nil, "b64 app proto is empty")
 	}
 	if agent == nil {
-		return finalAppProto, telemetry.Error(ctx, span, nil, "agent is nil")
+		return appProto, telemetry.Error(ctx, span, nil, "agent is nil")
 	}
 
 	decoded, err := base64.StdEncoding.DecodeString(b64AppProto)
 	if err != nil {
-		return finalAppProto, telemetry.Error(ctx, span, err, "error decoding base app")
+		return appProto, telemetry.Error(ctx, span, err, "error decoding base app")
 	}
 
-	appProto := &porterv1.PorterApp{}
 	err = helpers.UnmarshalContractObject(decoded, appProto)
 	if err != nil {
-		return finalAppProto, telemetry.Error(ctx, span, err, "error unmarshalling app proto")
+		return appProto, telemetry.Error(ctx, span, err, "error unmarshalling app proto")
 	}
 
 	filteredEnvGroups := []*porterv1.EnvGroup{}
 	for _, envGroup := range appProto.EnvGroups {
 		baseEnvGroup, err := environment_groups.LatestBaseEnvironmentGroup(ctx, agent, envGroup.Name)
 		if err != nil {
-			return finalAppProto, telemetry.Error(ctx, span, err, "unable to get latest base environment group")
+			return appProto, telemetry.Error(ctx, span, err, "unable to get latest base environment group")
 		}
 		if baseEnvGroup.DefaultAppEnvironment {
 			continue
@@ -287,12 +236,5 @@ func filterDefaultAppEnvGroups(ctx context.Context, b64AppProto string, agent *k
 
 	appProto.EnvGroups = filteredEnvGroups
 
-	encoded, err := helpers.MarshalContractObject(ctx, appProto)
-	if err != nil {
-		return finalAppProto, telemetry.Error(ctx, span, err, "error marshalling app proto")
-	}
-
-	finalAppProto = base64.StdEncoding.EncodeToString(encoded)
-
-	return finalAppProto, nil
+	return appProto, nil
 }

dashboard/src/lib/hooks/useAppWithPreviewOverrides.ts

@@ -0,0 +1,61 @@
+import { useMemo } from "react";
+import { PorterApp } from "@porter-dev/api-contracts";
+
+import { type PopulatedEnvGroup } from "main/home/app-dashboard/validate-apply/app-settings/types";
+import {
+  applyPreviewOverrides,
+  clientAppFromProto,
+  type ClientPorterApp,
+} from "lib/porter-apps";
+import { type DetectedServices } from "lib/porter-apps/services";
+
+export const useAppWithPreviewOverrides = ({
+  latestApp,
+  detectedServices,
+  templateEnv,
+  existingTemplate,
+  appEnv,
+}: {
+  latestApp: PorterApp;
+  detectedServices: DetectedServices | null;
+  existingTemplate?: PorterApp;
+  templateEnv?: {
+    variables: Record<string, string>;
+    secret_variables: Record<string, string>;
+  };
+  appEnv?: PopulatedEnvGroup;
+}): ClientPorterApp => {
+  const withPreviewOverrides = useMemo(() => {
+    const proto =
+      existingTemplate ||
+      new PorterApp({
+        ...latestApp,
+        envGroups: [],
+      }); // clear out env groups, they won't get added to the template anyways
+
+    const variables = templateEnv ? templateEnv.variables : appEnv?.variables;
+    const secrets = templateEnv
+      ? templateEnv.secret_variables
+      : appEnv?.secret_variables;
+
+    return applyPreviewOverrides({
+      app: clientAppFromProto({
+        proto,
+        overrides: detectedServices,
+        variables,
+        secrets,
+        lockServiceDeletions: true,
+      }),
+      overrides: detectedServices?.previews,
+    });
+  }, [
+    latestApp,
+    detectedServices,
+    existingTemplate,
+    templateEnv,
+    appEnv?.variables,
+    appEnv?.secret_variables,
+  ]);
+
+  return withPreviewOverrides;
+};